Skip to content

Instantly share code, notes, and snippets.

@tzkmx

tzkmx/demo.js

Created August 5, 2016 19:33
Show Gist options
  • Save tzkmx/1ef332a911fcf78f5494d50abfc26f4a to your computer and use it in GitHub Desktop.
Save tzkmx/1ef332a911fcf78f5494d50abfc26f4a to your computer and use it in GitHub Desktop.
Download ZIP
Demo of tail call optimization in javascript with metaret.js
Raw
demo.js
function fact(i) {
return i === 1 ? 1 : i * fact(i-1);
}
console.time('fact recursive naive');
for(var i = 0; i<1000000 ; i++) {
var g=fact(170);
}
console.log(g);
console.timeEnd('fact recursive naive');
metaparse("metafun fact_m(self, i, acc) { " +
" acc || (acc = 1 ) ; " +
" if(i > 1) { metaret self, i - 1, acc * i; }"+
" else { return acc; }}"); //need$('js/fact_m.jsm');
console.time('fact recursive meta');
for(var i = 0; i<1000000 ; i++) {
var g=fact_m(170);
}
console.log(g);
console.timeEnd('fact recursive meta');
Raw
metaret_standalone.js
// semibeautified from https://github.com/glathoud/js.metaret/blob/master/metaret_standalone.js
{
var global, exports;
(function(m) {
m.need$ = A;
var E = {},
u = {};
var vB = typeof read === 'function';
need$.read = vB ? read : h; {
var m, F;
if (typeof codeparse === 'undefined') {
var m, F;
if (typeof acorn === 'undefined') {
(function(vz, vA) {
if (typeof F == "object" && typeof module == "object") return vA(F);
if (typeof define == "function" && define.amd) return define(["exports"], vA);
vA(vz.acorn || (vz.acorn = {}));
})(this, function(s1) {
"use strict";
s1.version = "0.5.1";
var pL, pG, tu, s0;
s1.parse = function(vy, vx) {
pG = String(vy);
tu = pG.length;
vl(vx);
uQ();
return sN(pL.program);
};
var vv = s1.defaultOptions = {
ecmaVersion: 5,
strictSemicolons: false,
allowTrailingCommas: true,
forbidReserved: false,
allowReturnOutsideFunction: false,
locations: false,
onComment: null,
ranges: false,
program: null,
sourceFile: null,
directSourceFile: null,
jsm: false
};
function vl(vw) {
pL = vw || {};
for (var vu in vv)
if (!Object.prototype.hasOwnProperty.call(pL, vu)) pL[vu] = vv[vu];
s0 = pL.sourceFile || null;
}
var vb = s1.getLineInfo = function(vt, vq) {
for (var vr = 1, vp = 0;;) {
uN.lastIndex = vp;
var vs = uN.exec(vt);
if (vs && vs.index < vq) {
++vr;
vp = vs.index + vs[0].length;
} else break;
}
return {
line: vr,
column: vq - vp
};
};
s1.canBeSafeIdentifierName = vo;
function vo(vn) {
return !(pK(vn) || pJ(vn) || pH(vn) || p6(vn) || ta(vn) || t_(vn));
}
s1.tokenize = function(vm, vk) {
pG = String(vm);
tu = pG.length;
vl(vk);
uQ();
var vi = {};
function ve(vj) {
sc = pF;
sC(vj);
vi.start = pD;
vi.end = pF;
vi.startLoc = qP;
vi.endLoc = qN;
vi.type = pB;
vi.value = pC;
return vi;
}
ve.jumpTo = function(vh, vf) {
sM = vh;
if (pL.locations) {
s3 = 1;
s4 = uN.lastIndex = 0;
var vg;
while ((vg = uN.exec(pG)) && vg.index < vh) {
++s3;
s4 = vg.index + vg[0].length;
}
}
pz = vf;
s2();
};
return ve;
};
var sM;
var pD, pF;
var qP, qN;
var pB, pC;
var pz;
var s3, s4;
var sh, sc, sL;
var qb, q$, pI;
var p9;
function pE(v$, va) {
var v_ = vb(pG, v$);
va += " (" + v_.line + ":" + v_.column + ")";
var u9 = new SyntaxError(va);
u9.pos = v$;
u9.loc = v_;
u9.raisedAt = sM;
throw u9;
}
var qC = [];
var qn = {
type: "num"
},
qT = {
type: "regexp"
},
qm = {
type: "string"
};
var pM = {
type: "name"
},
sI = {
type: "eof"
};
var sz = {
keyword: "break"
},
sj = {
keyword: "case",
beforeExpr: true
},
sa = {
keyword: "catch"
};
var sB = {
keyword: "continue"
},
sw = {
keyword: "debugger"
},
sk = {
keyword: "default"
};
var sv = {
keyword: "do",
isLoop: true
},
sq = {
keyword: "else",
beforeExpr: true
};
var s_ = {
keyword: "finally"
},
su = {
keyword: "for",
isLoop: true
},
qH = {
keyword: "function"
};
var sr = {
keyword: "if"
},
sm = {
keyword: "return",
beforeExpr: true
},
r4 = {
keyword: "switch"
};
var se = {
keyword: "throw",
beforeExpr: true
},
sb = {
keyword: "try"
},
rH = {
keyword: "var"
};
var r9 = {
keyword: "while",
isLoop: true
},
r7 = {
keyword: "with"
},
qF = {
keyword: "new",
beforeExpr: true
};
var qU = {
keyword: "this"
};
var so = {
keyword: "metafun"
},
sn = {
keyword: "metaret",
beforeExpr: true
},
sp = {
keyword: "inline"
};
var qS = {
keyword: "null",
atomValue: null
},
qR = {
keyword: "true",
atomValue: true
};
var qQ = {
keyword: "false",
atomValue: false
};
var re = {
keyword: "in",
binop: 7,
beforeExpr: true
};
var t$ = {
"break": sz,
"case": sj,
"catch": sa,
"continue": sB,
"debugger": sw,
"default": sk,
"do": sv,
"else": sq,
"finally": s_,
"for": su,
"function": qH,
"if": sr,
"return": sm,
"switch": r4,
"throw": se,
"try": sb,
"var": rH,
"while": r9,
"with": r7,
"null": qS,
"true": qR,
"false": qQ,
"new": qF,
"in": re,
"instanceof": {
keyword: "instanceof",
binop: 7,
beforeExpr: true
},
"this": qU,
"typeof": {
keyword: "typeof",
prefix: true,
beforeExpr: true
},
"void": {
keyword: "void",
prefix: true,
beforeExpr: true
},
"delete": {
keyword: "delete",
prefix: true,
beforeExpr: true
}
};
var s9 = {
"metafun": so,
"metaret": sn,
"inline": sp
};
var qK = {
type: "[",
beforeExpr: true
},
qJ = {
type: "]"
},
qI = {
type: "{",
beforeExpr: true
};
var qz = {
type: "}"
},
qf = {
type: "(",
beforeExpr: true
},
qe = {
type: ")"
};
var pT = {
type: ",",
beforeExpr: true
},
rN = {
type: ";",
beforeExpr: true
};
var qx = {
type: ":",
beforeExpr: true
},
pw = {
type: "."
},
rk = {
type: "?",
beforeExpr: true
};
var sE = {
binop: 10,
beforeExpr: true
},
ry = {
isAssign: true,
beforeExpr: true
};
var sD = {
isAssign: true,
beforeExpr: true
};
var uq = {
postfix: true,
prefix: true,
isUpdate: true
},
t6 = {
prefix: true,
beforeExpr: true
};
var rb = {
binop: 1,
beforeExpr: true
};
var r$ = {
binop: 2,
beforeExpr: true
};
var uv = {
binop: 3,
beforeExpr: true
};
var us = {
binop: 4,
beforeExpr: true
};
var uu = {
binop: 5,
beforeExpr: true
};
var ug = {
binop: 6,
beforeExpr: true
};
var uj = {
binop: 7,
beforeExpr: true
};
var un = {
binop: 8,
beforeExpr: true
};
var uo = {
binop: 9,
prefix: true,
beforeExpr: true
};
var uy = {
binop: 10,
beforeExpr: true
};
s1.tokTypes = {
bracketL: qK,
bracketR: qJ,
braceL: qI,
braceR: qz,
parenL: qf,
parenR: qe,
comma: pT,
semi: rN,
colon: qx,
dot: pw,
question: rk,
slash: sE,
eq: ry,
name: pM,
eof: sI,
num: qn,
regexp: qT,
string: qm
};
for (var u8 in t$) s1.tokTypes["_" + u8] = t$[u8];
function uW(uY) {
uY = uY.split(" ");
var uX = "",
u2 = [];
out: for (var u1 = 0; u1 < uY.length; ++u1) {
for (var u7 = 0; u7 < u2.length; ++u7)
if (u2[u7][0].length == uY[u1].length) {
u2[u7].push(uY[u1]);
continue out;
}
u2.push([uY[u1]]);
}
function uZ(u6) {
if (u6.length == 1) return uX += "return str === " + JSON.stringify(u6[0]) + ";";
uX += "switch(str){";
for (var u5 = 0; u5 < u6.length; ++u5) uX += "case " + JSON.stringify(u6[u5]) + ":";
uX += "return true}return false;";
}
if (u2.length > 3) {
u2.sort(function(u3, u4) {
return u4.length - u3.length;
});
uX += "switch(str.length){";
for (var u1 = 0; u1 < u2.length; ++u1) {
var u0 = u2[u1];
uX += "case " + u0[0].length + ":";
uZ(u0);
}
uX += "}";
} else {
uZ(uY);
}
return new Function("str", uX);
}
var pK = uW("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
var pJ = uW("class enum extends super const export import");
var pH = uW("implements interface let package private protected public static yield");
var p6 = uW("eval arguments");
var ta = uW("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
var t_ = uW("metafun metaret inline");
var uD = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
var uV = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
var uU = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
var t2 = new RegExp("[" + uV + "]");
var uS = new RegExp("[" + uV + uU + "]");
var sd = /[\n\r\u2028\u2029]/;
var uN = /\r\n|[\n\r\u2028\u2029]/g;
var tk = s1.isIdentifierStart = function(uT) {
if (uT < 65) return uT === 36;
if (uT < 91) return true;
if (uT < 97) return uT === 95;
if (uT < 123) return true;
return uT >= 0xaa && t2.test(String.fromCharCode(uT));
};
var tj = s1.isIdentifierChar = function(uR) {
if (uR < 48) return uR === 36;
if (uR < 58) return true;
if (uR < 65) return false;
if (uR < 91) return true;
if (uR < 97) return uR === 95;
if (uR < 123) return true;
return uR >= 0xaa && uS.test(String.fromCharCode(uR));
};
function sK() {
this.line = s3;
this.column = sM - s4;
}
function uQ() {
s3 = 1;
sM = s4 = 0;
pz = true;
s2();
}
function s8(uO, uP) {
pF = sM;
if (pL.locations) qN = new sK();
pB = uO;
s2();
pC = uP;
pz = uO.beforeExpr;
}
function uF() {
var uJ = pL.onComment && pL.locations && new sK();
var uK = sM,
uL = pG.indexOf("*/", sM += 2);
if (uL === -1) pE(sM - 2, "Unterminated comment");
sM = uL + 2;
if (pL.locations) {
uN.lastIndex = uK;
var uM;
while ((uM = uN.exec(pG)) && uM.index < sM) {
++s3;
s4 = uM.index + uM[0].length;
}
}
if (pL.onComment) pL.onComment(true, pG.slice(uK + 2, uL), uK, sM, uJ, pL.locations && new sK());
}
function ul() {
var uH = sM;
var uG = pL.onComment && pL.locations && new sK();
var uI = pG.charCodeAt(sM += 2);
while (sM < tu && uI !== 10 && uI !== 13 && uI !== 8232 && uI !== 8233) {
++sM;
uI = pG.charCodeAt(sM);
}
if (pL.onComment) pL.onComment(false, pG.slice(uH + 2, sM), uH, sM, uG, pL.locations && new sK());
}
function s2() {
while (sM < tu) {
var uC = pG.charCodeAt(sM);
if (uC === 32) {
++sM;
} else if (uC === 13) {
++sM;
var uE = pG.charCodeAt(sM);
if (uE === 10) {
++sM;
}
if (pL.locations) {
++s3;
s4 = sM;
}
} else if (uC === 10 || uC === 8232 || uC === 8233) {
++sM;
if (pL.locations) {
++s3;
s4 = sM;
}
} else if (uC > 8 && uC < 14) {
++sM;
} else if (uC === 47) {
var uE = pG.charCodeAt(sM + 1);
if (uE === 42) {
uF();
} else if (uE === 47) {
ul();
} else break;
} else if (uC === 160) {
++sM;
} else if (uC >= 5760 && uD.test(String.fromCharCode(uC))) {
++sM;
} else {
break;
}
}
}
function ue() {
var uB = pG.charCodeAt(sM + 1);
if (uB >= 48 && uB <= 57) return tD(true);
++sM;
return s8(pw);
}
function uc() {
var uA = pG.charCodeAt(sM + 1);
if (pz) {
++sM;
return tV();
}
if (uA === 61) return tZ(sD, 2);
return tZ(sE, 1);
}
function ub() {
var uz = pG.charCodeAt(sM + 1);
if (uz === 61) return tZ(sD, 2);
return tZ(uy, 1);
}
function ua(uw) {
var ux = pG.charCodeAt(sM + 1);
if (ux === uw) return tZ(uw === 124 ? rb : r$, 2);
if (ux === 61) return tZ(sD, 2);
return tZ(uw === 124 ? uv : uu, 1);
}
function u$() {
var ut = pG.charCodeAt(sM + 1);
if (ut === 61) return tZ(sD, 2);
return tZ(us, 1);
}
function u_(ur) {
var up = pG.charCodeAt(sM + 1);
if (up === ur) {
if (up == 45 && pG.charCodeAt(sM + 2) == 62 && sd.test(pG.slice(sc, sM))) {
sM += 3;
ul();
s2();
return sC();
}
return tZ(uq, 2);
}
if (up === 61) return tZ(sD, 2);
return tZ(uo, 1);
}
function t9(um) {
var uk = pG.charCodeAt(sM + 1);
var ui = 1;
if (uk === um) {
ui = um === 62 && pG.charCodeAt(sM + 2) === 62 ? 3 : 2;
if (pG.charCodeAt(sM + ui) === 61) return tZ(sD, ui + 1);
return tZ(un, ui);
}
if (uk == 33 && um == 60 && pG.charCodeAt(sM + 2) == 45 && pG.charCodeAt(sM + 3) == 45) {
sM += 4;
ul();
s2();
return sC();
}
if (uk === 61) ui = pG.charCodeAt(sM + 2) === 61 ? 3 : 2;
return tZ(uj, ui);
}
function t8(uf) {
var uh = pG.charCodeAt(sM + 1);
if (uh === 61) return tZ(ug, pG.charCodeAt(sM + 2) === 61 ? 3 : 2);
return tZ(uf === 61 ? ry : t6, 1);
}
function t4(t7) {
switch (t7) {
case 46:
return ue();
case 40:
++sM;
return s8(qf);
case 41:
++sM;
return s8(qe);
case 59:
++sM;
return s8(rN);
case 44:
++sM;
return s8(pT);
case 91:
++sM;
return s8(qK);
case 93:
++sM;
return s8(qJ);
case 123:
++sM;
return s8(qI);
case 125:
++sM;
return s8(qz);
case 58:
++sM;
return s8(qx);
case 63:
++sM;
return s8(rk);
case 48:
var ud = pG.charCodeAt(sM + 1);
if (ud === 120 || ud === 88) return tF();
case 49:
case 50:
case 51:
case 52:
case 53:
case 54:
case 55:
case 56:
case 57:
return tD(false);
case 34:
case 39:
return tv(t7);
case 47:
return uc(t7);
case 37:
case 42:
return ub();
case 124:
case 38:
return ua(t7);
case 94:
return u$();
case 43:
case 45:
return u_(t7);
case 60:
case 62:
return t9(t7);
case 61:
case 33:
return t8(t7);
case 126:
return tZ(t6, 1);
}
return false;
}
function sC(t5) {
if (!t5) pD = sM;
else sM = pD + 1;
if (pL.locations) qP = new sK();
if (t5) return tV();
if (sM >= tu) return s8(sI);
var t3 = pG.charCodeAt(sM);
if (tk(t3) || t3 === 92) return td();
var t0 = t4(t3);
if (t0 === false) {
var t1 = String.fromCharCode(t3);
if (t1 === "\\" || t2.test(t1)) return td();
pE(sM, "Unexpected character '" + t1 + "'");
}
return t0;
}
function tZ(tX, tY) {
var tW = pG.slice(sM, sM + tY);
sM += tY;
s8(tX, tW);
}
function tV() {
var tR = "",
tS, tU, tP = sM;
for (;;) {
if (sM >= tu) pE(tP, "Unterminated regular expression");
var tT = pG.charAt(sM);
if (sd.test(tT)) pE(tP, "Unterminated regular expression");
if (!tS) {
if (tT === "[") tU = true;
else if (tT === "]" && tU) tU = false;
else if (tT === "/" && !tU) break;
tS = tT === "\\";
} else tS = false;
++sM;
}
var tR = pG.slice(tP, sM);
++sM;
var tQ = tc();
if (tQ && !/^[gmsiy]*$/.test(tQ)) pE(tP, "Invalid regular expression flag");
try {
var tO = new RegExp(tR, tQ);
} catch (e) {
if (e instanceof SyntaxError) pE(tP, "Error parsing regular expression: " + e.message);
pE(e);
}
return s8(qT, tO);
}
function tp(tK, tH) {
var tI = sM,
tG = 0;
for (var tM = 0, tN = tH == null ? Infinity : tH; tM < tN; ++tM) {
var tL = pG.charCodeAt(sM),
tJ;
if (tL >= 97) tJ = tL - 97 + 10;
else if (tL >= 65) tJ = tL - 65 + 10;
else if (tL >= 48 && tL <= 57) tJ = tL - 48;
else tJ = Infinity;
if (tJ >= tK) break;
++sM;
tG = tG * tK + tJ;
}
if (sM === tI || tH != null && sM - tI !== tH) return null;
return tG;
}
function tF() {
sM += 2;
var tE = tp(16);
if (tE == null) pE(pD + 2, "Expected hexadecimal number");
if (tk(pG.charCodeAt(sM))) pE(sM, "Identifier directly after number");
return s8(qn, tE);
}
function tD(tC) {
var ty = sM,
tA = false,
tz = pG.charCodeAt(sM) === 48;
if (!tC && tp(10) === null) pE(ty, "Invalid number");
if (pG.charCodeAt(sM) === 46) {
++sM;
tp(10);
tA = true;
}
var tB = pG.charCodeAt(sM);
if (tB === 69 || tB === 101) {
tB = pG.charCodeAt(++sM);
if (tB === 43 || tB === 45) ++sM;
if (tp(10) === null) pE(ty, "Invalid number");
tA = true;
}
if (tk(pG.charCodeAt(sM))) pE(sM, "Identifier directly after number");
var tx = pG.slice(ty, sM),
tw;
if (tA) tw = parseFloat(tx);
else if (!tz || tx.length === 1) tw = parseInt(tx, 10);
else if (/[89]/.test(tx) || pI) pE(ty, "Invalid number");
else tw = parseInt(tx, 8);
return s8(qn, tw);
}
function tv(tt) {
sM++;
var tr = "";
for (;;) {
if (sM >= tu) pE(pD, "Unterminated string constant");
var tq = pG.charCodeAt(sM);
if (tq === tt) {
++sM;
return s8(qm, tr);
}
if (tq === 92) {
tq = pG.charCodeAt(++sM);
var ts = /^[0-7]+/.exec(pG.slice(sM, sM + 3));
if (ts) ts = ts[0];
while (ts && parseInt(ts, 8) > 255) ts = ts.slice(0, -1);
if (ts === "0") ts = null;
++sM;
if (ts) {
if (pI) pE(sM - 2, "Octal literal in strict mode");
tr += String.fromCharCode(parseInt(ts, 8));
sM += ts.length - 1;
} else {
switch (tq) {
case 110:
tr += "\n";
break;
case 114:
tr += "\r";
break;
case 120:
tr += String.fromCharCode(tl(2));
break;
case 117:
tr += String.fromCharCode(tl(4));
break;
case 85:
tr += String.fromCharCode(tl(8));
break;
case 116:
tr += "\t";
break;
case 98:
tr += "\b";
break;
case 118:
tr += "\u000b";
break;
case 102:
tr += "\f";
break;
case 48:
tr += "\0";
break;
case 13:
if (pG.charCodeAt(sM) === 10) ++sM;
case 10:
if (pL.locations) {
s4 = sM;
++s3;
}
break;
default:
tr += String.fromCharCode(tq);
break;
}
}
} else {
if (tq === 13 || tq === 10 || tq === 8232 || tq === 8233) pE(pD, "Unterminated string constant");
tr += String.fromCharCode(tq);
++sM;
}
}
}
function tl(to) {
var tn = tp(16, to);
if (tn === null) pE(pD, "Bad character escape sequence");
return tn;
}
var tb;
function tc() {
tb = false;
var tf, tg = true,
te = sM;
for (;;) {
var tm = pG.charCodeAt(sM);
if (tj(tm)) {
if (tb) tf += pG.charAt(sM);
++sM;
} else if (tm === 92) {
if (!tb) tf = pG.slice(te, sM);
tb = true;
if (pG.charCodeAt(++sM) != 117) pE(sM, "Expecting Unicode escape sequence \\uXXXX");
++sM;
var ti = tl(4);
var th = String.fromCharCode(ti);
if (!th) pE(sM - 1, "Invalid Unicode escape");
if (!(tg ? tk(ti) : tj(ti))) pE(sM - 4, "Invalid Unicode escape");
tf += th;
} else {
break;
}
tg = false;
}
return tb ? tf : pG.slice(te, sM);
}
function td() {
var s6 = tc();
var s7 = pM;
if (!tb) {
if (ta(s6)) s7 = t$[s6];
else if (pL.jsm && t_(s6)) s7 = s9[s6];
}
return s8(s7, s6);
}
function py() {
sh = pD;
sc = pF;
sL = qN;
sC();
}
function rR(s5) {
pI = s5;
sM = pD;
if (pL.locations) {
while (sM < s4) {
s4 = pG.lastIndexOf("\n", s4 - 2) + 1;
--s3;
}
}
s2();
sC();
}
function sY() {
this.type = null;
this.start = pD;
this.end = null;
}
s1.Node = sY;
function sX() {
this.start = qP;
this.end = null;
if (s0 !== null) this.source = s0;
}
function pO() {
var sZ = new sY();
if (pL.locations) sZ.loc = new sX();
if (pL.directSourceFile) sZ.sourceFile = pL.directSourceFile;
if (pL.ranges) sZ.range = [pD, 0];
return sZ;
}
function qY(sW) {
var sV = new sY();
sV.start = sW.start;
if (pL.locations) {
sV.loc = new sX();
sV.loc.start = sW.loc.start;
}
if (pL.ranges) sV.range = [sW.range[0], 0];
return sV;
}
function pq(sT, sU) {
sT.type = sU;
sT.end = sc;
if (pL.locations) sT.loc.end = sL;
if (pL.ranges) sT.range[1] = sc;
return sT;
}
function p7(sR) {
return pL.ecmaVersion >= 5 && sR.type === "ExpressionStatement" && sR.expression.type === "Literal" && sR.expression.value === "use strict";
}
function px(sQ) {
if (pB === sQ) {
py();
return true;
}
}
function q3() {
return !pL.strictSemicolons && (pB === sI || pB === qz || sd.test(pG.slice(sc, pD)));
}
function r0() {
if (!px(rN) && !q3()) pA();
}
function pY(sP) {
if (pB === sP) py();
else pA();
}
function pA() {
pE(pD, "Unexpected token");
}
function q2(sO) {
if (sO.type !== "Identifier" && sO.type !== "MemberExpression") pE(sO.start, "Assigning to rvalue");
if (pI && sO.type === "Identifier" && p6(sO.name)) pE(sO.start, "Assigning to " + sO.name + " in strict mode");
}
function sN(sJ) {
sh = sc = sM;
if (pL.locations) sL = new sK();
qb = pI = null;
q$ = [];
sC();
var sF = sJ || pO(),
sG = true;
if (!sJ) sF.body = [];
while (pB !== sI) {
var sH = rE();
sF.body.push(sH);
if (sG && p7(sH)) rR(true);
sG = false;
}
return pq(sF, "Program");
}
var r8 = {
kind: "loop"
},
sl = {
kind: "switch"
};
function rE() {
if (pB === sE || pB === sD && pC == "/=") sC(true);
var r6 = pB,
rZ = pO();
switch (r6) {
case sz:
case sB:
py();
var sx = r6 === sz;
if (px(rN) || q3()) rZ.label = null;
else if (pB !== pM) pA();
else {
rZ.label = pv();
r0();
}
for (var r5 = 0; r5 < q$.length; ++r5) {
var sy = q$[r5];
if (rZ.label == null || sy.name === rZ.label.name) {
if (sy.kind != null && (sx || sy.kind === "loop")) break;
if (rZ.label && sx) break;
}
}
if (r5 === q$.length) pE(rZ.start, "Unsyntactic " + r6.keyword);
return pq(rZ, sx ? "BreakStatement" : "ContinueStatement");
case sw:
py();
r0();
return pq(rZ, "DebuggerStatement");
case sv:
py();
q$.push(r8);
rZ.body = rE();
q$.pop();
pY(r9);
rZ.test = rY();
r0();
return pq(rZ, "DoWhileStatement");
case su:
py();
q$.push(r8);
pY(qf);
if (pB === rN) return rP(rZ, null);
if (pB === rH) {
var ss = pO();
py();
rz(ss, true);
pq(ss, "VariableDeclaration");
if (ss.declarations.length === 1 && px(re)) return rL(rZ, ss);
return rP(rZ, ss);
}
var ss = pS(false, true);
if (px(re)) {
q2(ss);
return rL(rZ, ss);
}
return rP(rZ, ss);
case qH:
py();
return qg(rZ, true);
case sr:
py();
rZ.test = rY();
rZ.consequent = rE();
rZ.alternate = px(sq) ? rE() : null;
return pq(rZ, "IfStatement");
case sp:
py();
return rI(rZ);
case so:
py();
return qk(rZ, true);
case sn:
if (!p9 && !pL.jsmAllowMetaretOutsideFunction) pE(pD, "'metaret' outside of metafun");
py();
if (px(rN) || q3()) rZ.argument = null;
else {
rZ.argument = pS();
r0();
}
return pq(rZ, "JsmMetaretStatement");
case sm:
if (!qb && !pL.allowReturnOutsideFunction) pE(pD, "'return' outside of function");
py();
if (px(rN) || q3()) rZ.argument = null;
else {
rZ.argument = pS();
r0();
}
return pq(rZ, "ReturnStatement");
case r4:
py();
rZ.discriminant = rY();
rZ.cases = [];
pY(qI);
q$.push(sl);
for (var sf, sg; pB != qz;) {
if (pB === sj || pB === sk) {
var si = pB === sj;
if (sf) pq(sf, "SwitchCase");
rZ.cases.push(sf = pO());
sf.consequent = [];
py();
if (si) sf.test = pS();
else {
if (sg) pE(sh, "Multiple default clauses");
sg = true;
sf.test = null;
}
pY(qx);
} else {
if (!sf) pA();
sf.consequent.push(rE());
}
}
if (sf) pq(sf, "SwitchCase");
py();
q$.pop();
return pq(rZ, "SwitchStatement");
case se:
py();
if (sd.test(pG.slice(sc, pD))) pE(sc, "Illegal newline after throw");
rZ.argument = pS();
r0();
return pq(rZ, "ThrowStatement");
case sb:
py();
rZ.block = qc();
rZ.handler = null;
if (pB === sa) {
var s$ = pO();
py();
pY(qf);
s$.param = pv();
if (pI && p6(s$.param.name)) pE(s$.param.start, "Binding " + s$.param.name + " in strict mode");
pY(qe);
s$.guard = null;
s$.body = qc();
rZ.handler = pq(s$, "CatchClause");
}
rZ.guardedHandlers = qC;
rZ.finalizer = px(s_) ? qc() : null;
if (!rZ.handler && !rZ.finalizer) pE(rZ.start, "Missing catch or finally clause");
return pq(rZ, "TryStatement");
case rH:
py();
rz(rZ);
r0();
return pq(rZ, "VariableDeclaration");
case r9:
py();
rZ.test = rY();
q$.push(r8);
rZ.body = rE();
q$.pop();
return pq(rZ, "WhileStatement");
case r7:
if (pI) pE(pD, "'with' in strict mode");
py();
rZ.object = rY();
rZ.body = rE();
return pq(rZ, "WithStatement");
case qI:
return qc();
case rN:
py();
return pq(rZ, "EmptyStatement");
default:
var r3 = pC,
r1 = pS();
if (r6 === pM && r1.type === "Identifier" && px(qx)) {
for (var r5 = 0; r5 < q$.length; ++r5)
if (q$[r5].name === r3) pE(r1.start, "Label '" + r3 + "' is already declared");
var r2 = pB.isLoop ? "loop" : pB === r4 ? "switch" : null;
q$.push({
name: r3,
kind: r2
});
rZ.body = rE();
q$.pop();
rZ.label = r1;
return pq(rZ, "LabeledStatement");
} else {
rZ.expression = r1;
r0();
return pq(rZ, "ExpressionStatement");
}
}
}
function rY() {
pY(qf);
var rX = pS();
pY(qe);
return rX;
}
function qc(rW) {
var rQ = pO(),
rU = true,
rT = false,
rS;
rQ.body = [];
pY(qI);
while (!px(qz)) {
var rV = rE();
rQ.body.push(rV);
if (rU && rW && p7(rV)) {
rS = rT;
rR(rT = true);
}
rU = false;
}
if (rT && !rS) rR(false);
return pq(rQ, "BlockStatement");
}
function rP(rM, rO) {
rM.init = rO;
pY(rN);
rM.test = pB === rN ? null : pS();
pY(rN);
rM.update = pB === qe ? null : pS();
pY(qe);
rM.body = rE();
q$.pop();
return pq(rM, "ForStatement");
}
function rL(rJ, rK) {
rJ.left = rK;
rJ.right = pS();
pY(qe);
rJ.body = rE();
q$.pop();
return pq(rJ, "ForInStatement");
}
function rI(rA) {
if (pB === rH) {
var rG = rE();
if (rG.type !== "VariableDeclaration") throw new Error("parseJsmInline: incorrect variable declaration.");
if (rG.declarations.length !== 1) throw new Error("parseJsmInline: VariableDeclaration: only a single variable declaration!");
var rF = rG.declarations[0];
rA.jsmVarDeclId = rF.id;
rA.jsmVarDeclInit = rF.init;
if (rA.jsmVarDeclInit.type !== "CallExpression") throw new Error("parseJsmInline: VariableDeclaration: only the form 'inline var x = f(); is permitted.");
} else {
var rD = rE();
if (rD.type !== "ExpressionStatement") throw new Error("parseJsmInline: ExpressionStatement: either var or expression stmt.");
var rB = rD.expression,
rC = rB.type;
if (rC !== "AssignmentExpression" && rC !== "CallExpression") throw new Error("parseJsmInline: ExpressionStatement: either AssignmentExpression or CallExpression!");
if (rC === "AssignmentExpression") {
if (rB.left.type !== "Identifier" || rB.right.type !== "CallExpression") throw new Error("parseJsmInline: ExpressionStatement: only the form 'inline x = f(); is permitted.");
rA.jsmAssignLeft = rB.left;
rA.jsmAssignRight = rB.right;
} else {
rA.jsmCall = rB;
}
}
return pq(rA, "JsmInlineStatement");
}
function rz(ru, rw) {
ru.declarations = [];
ru.kind = "var";
for (;;) {
var rv = pO();
rv.id = pv();
if (pI && p6(rv.id.name)) pE(rv.id.start, "Binding " + rv.id.name + " in strict mode");
rv.init = px(ry) ? pS(true, rw) : null;
ru.declarations.push(pq(rv, "VariableDeclarator"));
if (!px(pT)) break;
}
return ru;
}
function pS(rt, rs) {
var rq = rp(rs);
if (!rt && pB === pT) {
var rr = qY(rq);
rr.expressions = [rq];
while (px(pT)) rr.expressions.push(rp(rs));
return pq(rr, "SequenceExpression");
}
return rq;
}
function rp(ro) {
var rm = rl(ro);
if (pB.isAssign) {
var rn = qY(rm);
rn.operator = pC;
rn.left = rm;
py();
rn.right = rp(ro);
q2(rm);
return pq(rn, "AssignmentExpression");
}
return rm;
}
function rl(rj) {
var rh = rg(rj);
if (px(rk)) {
var ri = qY(rh);
ri.test = rh;
ri.consequent = pS(true);
pY(qx);
ri.alternate = pS(true, rj);
return pq(ri, "ConditionalExpression");
}
return rh;
}
function rg(rf) {
return r_(q5(), -1, rf);
}
function r_(q6, q8, q7) {
var rd = pB.binop;
if (rd != null && (!q7 || pB !== re)) {
if (rd > q8) {
var rc = qY(q6);
rc.left = q6;
rc.operator = pC;
var ra = pB;
py();
rc.right = r_(q5(), rd, q7);
var q9 = pq(rc, ra === rb || ra === r$ ? "LogicalExpression" : "BinaryExpression");
return r_(q9, q8, q7);
}
}
return q6;
}
function q5() {
if (pB.prefix) {
var q1 = pO(),
q4 = pB.isUpdate;
q1.operator = pC;
q1.prefix = true;
pz = true;
py();
q1.argument = q5();
if (q4) q2(q1.argument);
else if (pI && q1.operator === "delete" && q1.argument.type === "Identifier") pE(q1.start, "Deleting local variable in strict mode");
return pq(q1, q4 ? "UpdateExpression" : "UnaryExpression");
}
var q0 = qZ();
while (pB.postfix && !q3()) {
var q1 = qY(q0);
q1.operator = pC;
q1.prefix = false;
q1.argument = q0;
q2(q0);
py();
q0 = pq(q1, "UpdateExpression");
}
return q0;
}
function qZ() {
return qD(ql());
}
function qD(qV, qW) {
if (px(pw)) {
var qX = qY(qV);
qX.object = qV;
qX.property = pv(true);
qX.computed = false;
return qD(pq(qX, "MemberExpression"), qW);
} else if (px(qK)) {
var qX = qY(qV);
qX.object = qV;
qX.property = pS();
qX.computed = true;
pY(qJ);
return qD(pq(qX, "MemberExpression"), qW);
} else if (!qW && px(qf)) {
var qX = qY(qV);
qX.callee = qV;
qX.arguments = pZ(qe, false);
return qD(pq(qX, "CallExpression"), qW);
} else return qV;
}
function ql() {
switch (pB) {
case qU:
var qG = pO();
py();
return pq(qG, "ThisExpression");
case pM:
return pv();
case qn:
case qm:
case qT:
var qG = pO();
qG.value = pC;
qG.raw = pG.slice(pD, pF);
py();
return pq(qG, "Literal");
case qS:
case qR:
case qQ:
var qG = pO();
qG.value = pB.atomValue;
qG.raw = pB.keyword;
py();
return pq(qG, "Literal");
case qf:
var qO = qP,
qM = pD;
py();
var qL = pS();
qL.start = qM;
qL.end = pF;
if (pL.locations) {
qL.loc.start = qO;
qL.loc.end = qN;
}
if (pL.ranges) qL.range = [qM, pF];
pY(qe);
return qL;
case qK:
var qG = pO();
py();
qG.elements = pZ(qJ, true, true);
return pq(qG, "ArrayExpression");
case qI:
return qA();
case qH:
var qG = pO();
py();
return qg(qG, false);
case qF:
return qE();
default:
pA();
}
}
function qE() {
var qB = pO();
py();
qB.callee = qD(ql(), true);
if (px(qf)) qB.arguments = pZ(qe, false);
else qB.arguments = qC;
return pq(qB, "NewExpression");
}
function qA() {
var qp = pO(),
qy = true,
qw = false;
qp.properties = [];
py();
while (!px(qz)) {
if (!qy) {
pY(pT);
if (pL.allowTrailingCommas && px(qz)) break;
} else qy = false;
var qq = {
key: qo()
},
qu = false,
qt;
if (px(qx)) {
qq.value = pS(true);
qt = qq.kind = "init";
} else if (pL.ecmaVersion >= 5 && qq.key.type === "Identifier" && (qq.key.name === "get" || qq.key.name === "set")) {
qu = qw = true;
qt = qq.kind = qq.key.name;
qq.key = qo();
if (pB !== qf) pA();
qq.value = qg(pO(), false);
} else pA();
if (qq.key.type === "Identifier" && (pI || qw)) {
for (var qv = 0; qv < qp.properties.length; ++qv) {
var qs = qp.properties[qv];
if (qs.key.name === qq.key.name) {
var qr = qt == qs.kind || qu && qs.kind === "init" || qt === "init" && (qs.kind === "get" || qs.kind === "set");
if (qr && !pI && qt === "init" && qs.kind === "init") qr = false;
if (qr) pE(qq.key.start, "Redefinition of property");
}
}
}
qp.properties.push(qq);
}
return pq(qp, "ObjectExpression");
}
function qo() {
if (pB === qn || pB === qm) return ql();
return pv(true);
}
function qk(qj, qi) {
if (!qi) throw new Error('metafunction can only be declarations, not expressions.');
var qh = true;
return qg(qj, qi, qh);
}
function qg(p2, p0, p1) {
if (!p1) {
if (pB === pM) p2.id = pv();
else if (p0) pA();
else p2.id = null;
} else {
if (pB !== pM) pA();
p2.id = pQ();
}
p2.params = [];
var qd = true;
pY(qf);
while (!px(qe)) {
if (!qd) pY(pT);
else qd = false;
p2.params.push(pv());
}
var qa = qb,
q_ = q$,
p8 = p9;
qb = true;
q$ = [];
p9 = p1;
p2.body = qc(true);
qb = qa;
q$ = q_;
p9 = p8;
if (pI || p2.body.body.length && p7(p2.body.body[0])) {
for (var p5 = p2.id ? -1 : 0; p5 < p2.params.length; ++p5) {
var p3 = p5 < 0 ? p2.id : p2.params[p5];
if (pH(p3.name) || p6(p3.name)) pE(p3.start, "Defining '" + p3.name + "' in strict mode");
if (p5 >= 0)
for (var p4 = 0; p4 < p5; ++p4)
if (p3.name === p2.params[p4].name) pE(p3.start, "Argument name clash in strict mode");
}
}
return pq(p2, (p1 ? 'JsmMetafun' : 'Function') + (p0 ? "Declaration" : "Expression"));
}
function pZ(pW, pX, pU) {
var pR = [],
pV = true;
while (!px(pW)) {
if (!pV) {
pY(pT);
if (pX && pL.allowTrailingCommas && px(pW)) break;
} else pV = false;
if (pU && pB === pT) pR.push(null);
else pR.push(pS(true));
}
return pR;
}
function pQ(pP) {
return pv(pP, true);
}
function pv(pu, pt) {
var pp = pO();
if (pu && pL.forbidReserved == "everywhere") pu = false;
if (pB === pM) {
if (!pu && (pL.forbidReserved && (pL.ecmaVersion === 3 ? pK : pJ)(pC) || pI && pH(pC)) && pG.slice(pD, pF).indexOf("\\") == -1) pE(pD, "The keyword '" + pC + "' is reserved");
pp.name = pC;
} else if (pu && pB.keyword) {
pp.name = pB.keyword;
} else {
pA();
}
pz = false;
py();
if (pt && px(pw)) {
var pr = [pp.name];
var ps = pv(pu, pt);
pr.push.apply(pr, ps.jsmNameArr || [ps.name]);
pp.jsmNameArr = pr;
pp.name = pr.join('.');
return pq(pp, "JsmDottedIdentifier");
}
return pq(pp, "Identifier");
}
});
}
if (typeof acorn.walk === 'undefined') {
(function(po) {
if (typeof F == "object" && typeof module == "object") return po(F);
if (typeof define == "function" && define.amd) return define(["exports"], po);
po((this.acorn || (this.acorn = {})).walk = {});
})(function(mi) {
"use strict";
mi.simple = function(pe, pm, pl, pd) {
if (!pl) pl = mi.base;
function pf(ph, pg, pn) {
var pk = pn || ph.type,
pj = pm[pk];
pl[pk](ph, pg, pf);
if (pj) pj(ph, pg);
}
pf(pe, pd);
};
mi.ancestor = function(o6, pb, pa, o5) {
if (!pa) pa = mi.base;
if (!o5) o5 = [];
function o7(o9, o8, pc) {
var p$ = pc || o9.type,
p_ = pb[p$];
if (o9 != o8[o8.length - 1]) {
o8 = o8.slice();
o8.push(o9);
}
pa[p$](o9, o8, o7);
if (p_) p_(o9, o8);
}
o7(o6, o5);
};
mi.recursive = function(oW, oV, o4, o3) {
var o1 = o4 ? mi.make(o4, o3) : o3;
function oX(oZ, oY, o0) {
o1[o0 || oZ.type](oZ, oY, oX);
}
oX(oW, oV);
};
function oj(oT) {
if (typeof oT == "string") return function(oU) {
return oU == oT;
};
else if (!oT) return function() {
return true;
};
else return oT;
}
function of(oS, oR) {
this.node = oS;
this.state = oR;
}
mi.findNodeAt = function(oH, oM, oL, oO, oP, oG) {
oO = oj(oO);
try {
if (!oP) oP = mi.base;
var oI = function(oK, oJ, oQ) {
var oN = oQ || oK.type;
if ((oM == null || oK.start <= oM) && (oL == null || oK.end >= oL)) oP[oN](oK, oJ, oI);
if (oO(oN, oK) && (oM == null || oK.start == oM) && (oL == null || oK.end == oL)) throw new of(oK, oJ);
};
oI(oH, oG);
} catch (e) {
if (e instanceof of) return e;
throw e;
}
};
mi.findNodeAround = function(ox, oE, oC, oD, ow) {
oC = oj(oC);
try {
if (!oD) oD = mi.base;
var oy = function(oA, oz, oF) {
var oB = oF || oA.type;
if (oA.start > oE || oA.end < oE) return;
oD[oB](oA, oz, oy);
if (oC(oB, oA)) throw new of(oA, oz);
};
oy(ox, ow);
} catch (e) {
if (e instanceof of) return e;
throw e;
}
};
mi.findNodeAfter = function(om, ou, ot, os, ol) {
ot = oj(ot);
try {
if (!os) os = mi.base;
var on = function(oq, oo, ov) {
if (oq.end < ou) return;
var or = ov || oq.type;
if (oq.start >= ou && ot(or, oq)) throw new of(oq, oo);
os[or](oq, oo, on);
};
on(om, ol);
} catch (e) {
if (e instanceof of) return e;
throw e;
}
};
mi.findNodeBefore = function(o$, oh, og, oe, o_) {
og = oj(og);
if (!oe) oe = mi.base;
var n9;
var oa = function(oc, ob, oi) {
if (oc.start > oh) return;
var od = oi || oc.type;
if (oc.end <= oh && (!n9 || n9.node.end < oc.end) && og(od, oc)) n9 = new of(oc, ob);
oe[od](oc, ob, oa);
};
oa(o$, o_);
return n9;
};
mi.make = function(n7, n8) {
if (!n8) n8 = mi.base;
var n5 = {};
for (var n6 in n8) n5[n6] = n8[n6];
for (var n6 in n7) n5[n6] = n7[n6];
return n5;
};
function m4(n3, n2, n4) {
n4(n3, n2);
}
function mA(n1, n0, nZ) {}
var mq = mi.base = {};
mq.Program = mq.BlockStatement = function(nX, nV, nY) {
for (var nW = 0; nW < nX.body.length; ++nW) nY(nX.body[nW], nV, "Statement");
};
mq.Statement = m4;
mq.EmptyStatement = mA;
mq.ExpressionStatement = function(nT, nS, nU) {
nU(nT.expression, nS, "Expression");
};
mq.IfStatement = function(nQ, nP, nR) {
nR(nQ.test, nP, "Expression");
nR(nQ.consequent, nP, "Statement");
if (nQ.alternate) nR(nQ.alternate, nP, "Statement");
};
mq.LabeledStatement = function(nN, nM, nO) {
nO(nN.body, nM, "Statement");
};
mq.BreakStatement = mq.ContinueStatement = mA;
mq.WithStatement = function(nK, nJ, nL) {
nL(nK.object, nJ, "Expression");
nL(nK.body, nJ, "Statement");
};
mq.SwitchStatement = function(nI, nD, nG) {
nG(nI.discriminant, nD, "Expression");
for (var nH = 0; nH < nI.cases.length; ++nH) {
var nF = nI.cases[nH];
if (nF.test) nG(nF.test, nD, "Expression");
for (var nE = 0; nE < nF.consequent.length; ++nE) nG(nF.consequent[nE], nD, "Statement");
}
};
mq.ReturnStatement = function(nB, nA, nC) {
if (nB.argument) nC(nB.argument, nA, "Expression");
};
mq.ThrowStatement = function(ny, nx, nz) {
nz(ny.argument, nx, "Expression");
};
mq.TryStatement = function(nv, nu, nw) {
nw(nv.block, nu, "Statement");
if (nv.handler) nw(nv.handler.body, nu, "ScopeBody");
if (nv.finalizer) nw(nv.finalizer, nu, "Statement");
};
mq.WhileStatement = function(ns, nr, nt) {
nt(ns.test, nr, "Expression");
nt(ns.body, nr, "Statement");
};
mq.DoWhileStatement = mq.WhileStatement;
mq.ForStatement = function(np, no, nq) {
if (np.init) nq(np.init, no, "ForInit");
if (np.test) nq(np.test, no, "Expression");
if (np.update) nq(np.update, no, "Expression");
nq(np.body, no, "Statement");
};
mq.ForInStatement = function(nm, nl, nn) {
nn(nm.left, nl, "ForInit");
nn(nm.right, nl, "Expression");
nn(nm.body, nl, "Statement");
};
mq.ForInit = function(ni, nh, nk) {
if (ni.type == "VariableDeclaration") nk(ni, nh);
else nk(ni, nh, "Expression");
};
mq.DebuggerStatement = mA;
mq.FunctionDeclaration = function(nf, ne, ng) {
ng(nf, ne, "Function");
};
mq.VariableDeclaration = function(nd, n$, nb) {
for (var nc = 0; nc < nd.declarations.length; ++nc) {
var na = nd.declarations[nc];
if (na.init) nb(na.init, n$, "Expression");
}
};
mq.Function = function(m9, m8, n_) {
n_(m9.body, m8, "ScopeBody");
};
mq.ScopeBody = function(m6, m5, m7) {
m7(m6, m5, "Statement");
};
mq.Expression = m4;
mq.ThisExpression = mA;
mq.ArrayExpression = function(m3, mZ, m1) {
for (var m2 = 0; m2 < m3.elements.length; ++m2) {
var m0 = m3.elements[m2];
if (m0) m1(m0, mZ, "Expression");
}
};
mq.ObjectExpression = function(mX, mV, mY) {
for (var mW = 0; mW < mX.properties.length; ++mW) mY(mX.properties[mW].value, mV, "Expression");
};
mq.FunctionExpression = mq.FunctionDeclaration;
mq.SequenceExpression = function(mT, mR, mU) {
for (var mS = 0; mS < mT.expressions.length; ++mS) mU(mT.expressions[mS], mR, "Expression");
};
mq.UnaryExpression = mq.UpdateExpression = function(mP, mO, mQ) {
mQ(mP.argument, mO, "Expression");
};
mq.BinaryExpression = mq.AssignmentExpression = mq.LogicalExpression = function(mM, mL, mN) {
mN(mM.left, mL, "Expression");
mN(mM.right, mL, "Expression");
};
mq.ConditionalExpression = function(mJ, mI, mK) {
mK(mJ.test, mI, "Expression");
mK(mJ.consequent, mI, "Expression");
mK(mJ.alternate, mI, "Expression");
};
mq.NewExpression = mq.CallExpression = function(mG, mE, mH) {
mH(mG.callee, mE, "Expression");
if (mG.arguments)
for (var mF = 0; mF < mG.arguments.length; ++mF) mH(mG.arguments[mF], mE, "Expression");
};
mq.MemberExpression = function(mC, mB, mD) {
mD(mC.object, mB, "Expression");
if (mC.computed) mD(mC.property, mB, "Expression");
};
mq.Identifier = mq.Literal = mA;
mq.JsmMetafunDeclaration = function(my, mx, mz) {
mz(my, mx, "Function");
};
mq.JsmFunctionDeclaration = function(mv, mu, mw) {
mw(mv, mu, "Function");
};
mq.JsmMetaretStatement = function(ms, mr, mt) {
mt(ms.argument, mr, "Expression");
};
mq.JsmInlineStatement = function(mn, mm, mp) {
if (mn.jsmVarDeclId) {
mp(mn.jsmVarDeclId, mm);
mp(mn.jsmVarDeclInit, mm);
} else if (mn.jsmAssignLeft) {
mp(mn.jsmAssignLeft, mm);
mp(mn.jsmAssignRight, mm);
} else {
mp(mn.jsmCall, mm);
}
};
function mb(ml, mk) {
return {
vars: Object.create(null),
prev: ml,
isCatch: mk
};
}
function l8(mj) {
while (mj.isCatch) mj = mj.prev;
return mj;
}
mi.scopeVisitor = mi.make({
Function: function(md, mg, me) {
var mc = mb(mg);
for (var mh = 0; mh < md.params.length; ++mh) mc.vars[md.params[mh].name] = {
type: "argument",
node: md.params[mh]
};
if (md.id) {
var mf = md.type == "FunctionDeclaration";
(mf ? l8(mg) : mc).vars[md.id.name] = {
type: mf ? "function" : "function name",
node: md.id
};
}
me(md.body, mc, "ScopeBody");
},
TryStatement: function(m_, l9, m$) {
m$(m_.block, l9, "Statement");
if (m_.handler) {
var ma = mb(l9, true);
ma.vars[m_.handler.param.name] = {
type: "catch clause",
node: m_.handler.param
};
m$(m_.handler.body, ma, "ScopeBody");
}
if (m_.finalizer) m$(m_.finalizer, l9, "Statement");
},
VariableDeclaration: function(l7, l2, l4) {
var l5 = l8(l2);
for (var l6 = 0; l6 < l7.declarations.length; ++l6) {
var l3 = l7.declarations[l6];
l5.vars[l3.id.name] = {
type: "var",
node: l3.id
};
if (l3.init) l4(l3.init, l2, "Expression");
}
}
});
});
}(function(iL) {
var l1 = 'return',
js = 'var',
lY = ["break", "case", "catch", "continue", "debugger", "default", "delete", "do", "else", "finally", "for", "function", "if", "in", "instanceof", "new", l1, "switch", "this", "throw", "try", "typeof", js, "void", "while", "with", "class", "const", "enum", "export", "extends", "import", "super", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
lX = [{
open: l1,
close: ';',
typebracket: l1,
ignore_unbalanced: true
}, {
open: js,
close: [';', 'in'],
typebracket: js,
ignore_unbalanced: true
}],
ko = {};
iL.codeparse = lZ;
lZ.getDefaultReservedArr = l0;
function l0() {
return [].concat(lY);
}
function lZ(kG, lW) {
var kF = (lW && lW.reservedArr || lY).concat(lW && lW.extraReservedArr || []),
kM = lX.concat(lW && lW.extraBracketArr || []),
k_ = {
strArr: [],
commentArr: [],
regexpArr: [],
callArr: [],
dotArr: [],
dotcallArr: [],
identifierArr: [],
identifierArrReverse: [],
identifierObj: {},
identifierObjReverse: {},
callObj: {},
bracketcurlyArr: [],
bracketroundArr: [],
bracketsquareArr: [],
bracketextraArr: [],
bracketArr: [],
bracketTree: [],
functionDeclarationArr: [],
functionExpressionArr: [],
jsmMetafunArr: [],
jsmMetaretArr: [],
jsmInlineArr: [],
rawAP: null
},
k4 = kG;
var kp = k_.commentArr,
lQ = k_.rawAP = acorn.parse(kG, {
jsm: true,
onComment: lV,
jsmAllowMetaretOutsideFunction: lW && lW.jsmAllowMetaretOutsideFunction,
allowReturnOutsideFunction: lW && lW.allowReturnOutsideFunction
});
function lV(lU, lT, lS, lR) {
kp.push({
begin: lS,
str: kG.substring(lS, lR)
});
k4 = k4.substring(0, lS) + ic(' ', lR - lS) + k4.substring(lR);
}
var kx, lz = k_.callArr,
k3 = k_.dotArr,
lM = k_.dotcallArr,
ks = k_.identifierArr,
l$ = k_.regexpArr,
lb = k_.strArr,
lw = k_.functionDeclarationArr,
lp = k_.functionExpressionArr,
lh = k_.jsmMetafunArr,
kE = k_.jsmMetaretArr,
lk = k_.jsmInlineArr,
kH = k4;
acorn.walk.simple(lQ, {
CallExpression: lD,
FunctionDeclaration: lB,
FunctionExpression: lt,
Identifier: kR,
JsmInlineStatement: ll,
JsmMetafunDeclaration: li,
JsmMetafunExpression: le,
Literal: kY,
MemberExpression: k6,
NewExpression: lE,
ObjectExpression: k0,
ThisExpression: kV,
VariableDeclaration: kT
});
lz.sort(j9);
k3.sort(j9);
lM.sort(j9);
ks.sort(j9);
l$.sort(j9);
lb.sort(j9);
function lD(lI) {
var lF = lI.callee;
if (lF.type === "Identifier") {
var lP = lF.start,
lK = k4.indexOf("(", lF.end);
if (lK < 0) throw new Error('meet_CallExpression bug');
var lO = kG.substring(lP, lK + 1);
lz.push({
begin: lP,
str: lO,
name: lF.name,
acornNode: lI
});
for (var lH = ks.length; lH--;) {
if (lF === ks[lH].acornNode) {
ks.splice(lH, 1);
break;
} else if (ks[lH].begin < lF.start) {
break;
}
}
} else if (lF.type === "MemberExpression") {
var lG = lF.property,
lJ = lG.name,
lL = k4.lastIndexOf(lF.computed ? "[" : ".", lG.start),
lN = lF.computed ? k4.indexOf("]", lG.end) : lG.end,
lK = k4.indexOf("(", lN);
if (lL < 0 || lN < 0 || lN < lL || lK < 0) throw new Error('meet_CallExpression bug');
lM.push({
begin: lL,
str: kG.substring(lL, lK + 1),
name: lJ,
acornNode: lI
});
for (var lH = k3.length; lH--;) {
if (lG === k3[lH].acornNode) {
k3.splice(lH, 1);
break;
} else if (k3[lH].begin < lG.start) {
break;
}
}
} else if (/Expression$/.test(lF.type)) {} else throw new Error("bug");
}
function lE(lC) {
if (lC.arguments.length) lD(lC);
}
function lB(lu) {
var lv = lu.id.name;
(lv || 0).substring.call.a;
var ly = lu.id.start;
ly.toPrecision.call.a;
var lA = k4.indexOf("(", lu.id.end),
lx = k4.substring(ly, lA + 1);
lz.push({
begin: ly,
str: lx,
name: lv,
acornNode: lu
});
lu.params.forEach(kR);
lw.push({
begin: lu.start,
str: k4.substring(lu.start, lu.end),
type: lu.type,
name: lv,
acornNode: lu
});
}
function lt(lm) {
lm.params.forEach(kR);
var lo = lm.start,
lq = lm.end,
ln;
while (!/^function/.test(ln = k4.substring(lo, lq))) {
var ls = /^\s*\(\s*/.exec(ln),
lr = /\s*\)\s*$/.exec(ln);
lo += ls[0].length;
lq -= lr[0].length;
if (lo > lq) throw new Error('bug');
}
lp.push({
begin: lo,
str: ln,
type: lm.type,
name: lm.id ? lm.id.name : '',
acornNode: lm
});
}
function ll(lj) {
lk.push({
begin: lj.start,
end: lj.end,
str: k4.substring(lj.start, lj.end),
type: lj.type,
name: 'inline',
acornNode: lj
});
}
function li(lf) {
var lg = lf.id.name;
(lg || 0).substring.call.a;
lh.push({
begin: lf.start,
str: k4.substring(lf.start, lf.end),
type: lf.type,
name: lg,
acornNode: lf
});
}
function le(ld) {}
function kR(lc) {
ks.push({
begin: lc.start,
str: lc.name,
name: lc.name,
acornNode: lc
});
}
function kY(k7) {
var la = k7.value,
l_ = null,
k9, k8;
if (k9 = 'string' === typeof la) l_ = lb;
else if (k8 = la instanceof RegExp) l_ = l$;
if (l_) l_.push({
begin: k7.start,
str: k7.raw,
acornNode: k7
});
if (k9 || k8) {
kH = kH.substring(0, k7.start) + ic(' ', k7.end - k7.start) + kH.substring(k7.end);
}
}
function k6(k5) {
var k1 = k5.property;
if (!k5.computed && k1.type === "Identifier") {
var k2 = k4.lastIndexOf('.', k1.start);
if (k2 < 0) throw new Error('meet_MemberExpression bug');
k3.push({
begin: k2,
str: kG.substring(k2, k1.start + k1.name.length),
name: k1.name,
acornNode: k1
});
}
}
function k0(kW) {
kW.properties.forEach(function(kZ) {
var kX = kZ.key;
if (kX.type === "Identifier") kR(kX);
else if (kX.type === "Literal") kY(kX);
else throw new Error("Whatever " + kW.start);
});
}
function kV(kU) {
ks.push({
begin: kU.start,
str: 'this',
name: 'this',
acornNode: kU
});
}
function kT(kS) {
kS.declarations.forEach(function(kQ) {
kR(kQ.id);
});
}
var kP = k_.bracketcurlyArr,
kO = k_.bracketroundArr,
kN = k_.bracketsquareArr,
kK = k_.bracketextraArr,
kC = k_.bracketArr,
kI = [{
out_arr: kP,
open: '{',
close: '}',
typebracket: 'curly'
}, {
out_arr: kO,
open: '(',
close: ')',
typebracket: 'round'
}, {
out_arr: kN,
open: '[',
close: ']',
typebracket: 'square'
}].concat(kM.map(function(kL) {
var kJ = Object.create(kL);
kJ.out_arr = kK;
return kJ;
}));
ja(kI, kH, kG, kC);
j3(kC, k_.bracketTree);
jV(kC, kH, kG, kF);
jv(kC, kp);
kE.push.apply(kE, kC.filter(function(kD) {
return kD.typebracket === 'metaret';
}));
var kx = kC.filter(function(kB) {
return kB.typebracket === js;
}).reduce(function(kA, kz) {
return kA.concat(kz.sepSplit);
}, []);
for (var ku = 0, kq = kx.length, ky = ks.length, ka = 0; ka < kq && ku < ky; ka++) {
var km = kx[ka],
kv;
while ((kv = ks[ku]).begin < km.begin) {
kv.isVardecl = false;
ku++;
}
kv.isVardecl = true;
ku++;
}
var ks = k_.identifierArr,
kt = k_.identifierArrReverse = iJ(ks),
kr = k_.vardeclArr = [],
kk = k_.identifierObj = {};
for (var kq = ks.length, ka = 0; ka < kq; ka++) {
var km = ks[ka];
(kk[km.str] !== ko[km.str] ? kk[km.str] : (kk[km.str] = [])).push(km.begin);
if (km.isVardecl) kr.push(km);
}
var kp = k_.callArr,
kn = k_.callObj = {};
for (var kq = kp.length, ka = 0; ka < kq; ka++) {
var km = kp[ka];
(kn[km.name] !== ko[km.name] ? kn[km.name] : (kn[km.name] = [])).push(km.begin);
}
var kl = k_.identifierObjReverse = {};
for (var kj in kk) {
if (!(kj in kl)) {
kl[kj] = iJ(kk[kj]);
}
}
var kd = k_.all = [];
for (var ki in k_) {
var kh = ki.match(/^(.+)Arr$/);
if (kh) {
var kf = k_[ki],
kg = kh[1];
for (var ka = kf.length; ka--;) kf[ka].type = kg;
kd.push.apply(kd, kf);
}
}
for (var ka = kd.length; ka--;) {
var kb = kd[ka];
if (!('end' in kb)) kb.end = kb.begin + kb.str.length;
}
kd.sort(j6);
for (var ka = kd.length; --ka;) {
var kb = kd[ka],
ke = kd[ka - 1];
if (kb.begin === ke.begin && kb.end === ke.end) {
if (kb.type !== ke.type) throw new Error("Internal bug.");
kd.splice(ka, 1);
}
}
k_.allReverse = iJ(kd);
var k$ = [].concat(kd);
for (var ka = k$.length - 1; ka--;) {
var kb = k$[ka],
kc;
while (kc = k$[ka + 1], kc && kb.begin <= kc.begin && kc.end <= kb.end) {
(kb.children || (kb.children = [])).push(k$.splice(ka + 1, 1)[0]);
}
}
k_.allTree = k$;
return k_;
}
reservedSet = {};
function j9(j8, j7) {
return j8.begin < j7.begin ? -1 : +1;
}
function j6(j5, j4) {
return j5.begin < j4.begin ? -1 : j5.begin > j4.begin ? +1 : j5.end > j4.end ? -1 : +1;
}
function j3(j1, jY) {
var jX = [];
for (var j2 = j1.length, j0 = 0; j0 < j2; j0++) {
var jW = j1[j0];
jW.bracketchildren = [];
var jZ;
while ((jZ = jX[jX.length - 1]) && jZ.end < jW.begin) jX.pop();
jW.bracketparent = jZ ? jZ : null;
jW.bracketdepth = jX.length;
if (jZ && jW.begin < jZ.end) jZ.bracketchildren.push(jW);
else jY.push(jW);
jX.push(jW);
}
}
function jV(jT, jC, jD, jU) {
for (var jS = jT.length; jS--;) {
var jJ = jT[jS],
jR = jJ.bracketchildren,
jK = jC.substring(jJ.begin, jJ.end),
jL = jJ.begin,
jP = [{
begin: 0,
end: jJ.open.length
}];
for (var jO = jR.length, jG = 0; jG < jO; jG++) {
var jQ = jR[jG];
jP.push({
begin: jQ.begin - jL,
end: jQ.end - jL
});
}
jP.push({
begin: jK.length - jJ.close.length,
end: jK.length
});
jK = ik(jK, jP);
var jM = jJ.sepArr = [];
for (var jO = jK.length, jG = 0; jG < jO; jG++) {
var jN = jK.charAt(jG);
if (jN === ',' || jN === ';') jM.push({
index: jL + jG,
type: jN
});
}
var jF = '<first>',
jE = '<last>',
jH = [{
index: jL + jJ.open.length,
type: jF
}].concat(jM).concat([{
index: jL + jK.length - jJ.close.length,
type: jE
}]),
jB = jJ.sepSplit = [];
for (var jI = -1 + jH.length, jG = 0; jG < jI; jG++) {
var jx = jH[jG],
jw = jH[jG + 1],
jA = jx.index + (jx.type !== jF && jx.type !== jE ? jx.type.length : 0),
jz = jw.index,
jy = jD.substring(jA, jz);
if (!jy || /^\s*$/.test(jC.substring(jA, jz))) continue;
jB.push({
begin: jA,
end: jz,
str: jy,
sep_begin: jx,
sep_end: jw
});
}
}
}
function jv(ju, jh) {
for (var jt = ju.length, jf = jh.length; jt--;) {
var jr = ju[jt];
if (jr.typebracket !== js) continue;
var jm = jr.vdArr = [];
var jp = jr.sepSplit;
for (var jq = jp.length, jo = 0; jo < jq; jo++) {
var jn = jp[jo],
jk = jn.hasOwnProperty('str_noComments') ? jn.str_noComments : (jn.str_noComments = iB(/\/\*|\*\//.test(jn.str) ? jj(jn) : jn.str)),
jl = jk.match(/^([^=]*)\s*=\s*([\s\S]+)$/);
jm.push(jl ? {
leftstr: jl[1],
rightstr: jl[2]
} : {
leftstr: jk,
rightstr: null
});
}
}
function jj(ji) {
var jb = ji.str,
jd = ji.begin,
jg = ji.end,
jc = [];
if (0 < jf) {
for (; jf--;) {
var je = jh[jf];
if (je.end > jg) continue;
if (je.end < jd) {
jf++;
break;
}
jc.unshift(je.end - jd);
}
jc.unshift(je.begin - jd);
return jc.join('');
}
return jb;
}
}
function ja(iZ, i3, iP, iU) {
var i5 = new RegExp(iZ.map(function(j$) {
var j_ = i6(j$.open),
i9 = i6(j$.close);
return '(' + j_ + ')' + '|' + '(' + i9 + ')';
function i6(i7) {
return 'string' === typeof i7 ? i7.replace(/(\W)/g, '\\$1').replace(/^(\w)/, '\\b$1').replace(/(\w)$/, '$1\\b') : i7.map(i6).join('|');
}
}).join('|'), 'g'),
iS = [],
iW, i0;
while (iW = i5.exec(i3)) {
var i2 = -1;
for (var iT = iW.length; iT--;) {
if (iW[iT]) {
i2 = iT - 1;
break;
}
}
if (!(-1 < i2)) i0.bug;
var iX = 1 & i2,
iY = i2 >> 1;
var i1 = iZ[iY][iX ? 'close' : 'open'];
if (!('string' === typeof i1 ? iW[0] === i1 : -1 < i1.indexOf(iW[0]))) i0.bug;
var iQ = {
begin: iW.index,
end: iW.index + iW[0].length,
cfg: iZ[iY]
};
iQ[iX ? 'close' : 'open'] = iW[0];
iS.push(iQ);
}
var iM = [];
for (var iV = iS.length, iT = 0; iT < iV; iT++) {
var iQ = iS[iT];
if (iQ.open) {
var iN = {
begin: iQ.begin,
typebracket: iQ.cfg.typebracket,
open: iQ.cfg.open,
close: iQ.cfg.close
};
iQ.cfg.out_arr.push(iN);
iU.push(iN);
iM.push({
i: iT,
x: iN
});
} else {
var iK = iM[iM.length - 1];
if (!iK) {
if (!iQ.cfg.ignore_unbalanced) throw new Error('Unbalanced brackets: missing an opening "' + iQ.cfg.open + '".');
} else if ('string' === typeof iK.x.close ? iK.x.close !== iQ.close : 0 > iK.x.close.indexOf(iQ.close)) {
if (!(iS[iK.i].cfg.ignore_unbalanced || iQ.cfg.ignore_unbalanced)) {
throw new Error('Unbalanced brackets: opening typebracket "' + iK.x.typebracket + '" (' + iK.x.begin + ')' + ' does not match closing typebracket "' + iQ.cfg.typebracket + '" (' + iQ.begin + ').');
}
} else {
var iN = iM.pop().x;
iN.close = iQ.close;
iN.end = iQ.end;
iN.str = iP.substring(iN.begin, iN.end);
}
}
}
if (iM.length !== 0) {
var iK = iM[iM.length - 1];
iL.console && iL.console.error("last:", iK);
throw new Error('Unbalanced brackets: missing a closing "' + iK.x.close + '" for {open:"' + iK.x.open + '", begin:<char:' + iK.x.begin + '>}. Did you forget a semicolon, maybe?');
}
}
function iJ(iI) {
var iH = [].concat(iI);
iH.reverse();
return iH;
}
function ic(iG, iF) {
var iD;
if (iF < 1000) {
iD = iG + '#' + iF;
if (iD in ic) return ic[iD];
}
var iE = [];
while (iF) {
if (iF & 1) iE.push(iG);
iG += iG;
iF >>= 1;
}
var iC = iE.join('');
if (iD != null) ic[iD] = iC;
return iC;
}
function iB(iy) {
var iz = iy.length;
if (!iz) return iy;
for (var ix = 0; ix < iz; ix++) {
if (iy.charAt(ix) !== ' ') break;
}
for (var iw = iz - 1; iw >= ix; iw--) {
if (iy.charAt(iw) !== ' ') break;
}
return iy.substring(ix, iw + 1);
}
function ik(i$, ih) {
if (!ih.length) return i$;
var ij = ih[ih.length - 1],
h9 = [],
i_ = 0;
for (var ii = ih.length, ig = 0; ig < ii; ig++) {
var ie = ih[ig],
ia = ie.end,
ib = ie.begin;
if (i_ < ib) h9.push(i$.substring(i_, ib));
h9.push(ic(' ', ia - ib));
i_ = ia;
}
if (i_ < i$.length) h9.push(i$.substring(i_));
return h9.join('');
}
})(m || F || this);
}
if (typeof cp2fmtree === 'undefined') {
var m, F;
(function(h2) {
var hW = 'jsmMetafun',
h8 = 'jsmMetaret',
hY = 'functionExpression',
hX = 'functionDeclaration',
h7 = 'reserved',
h6 = 'call',
h5 = 'dotcall',
h4 = 'bracket',
h3 = 'curly',
gr = {};
h2.cp2fmtree = hu;
function hu(hp, hs, hr, hG) {
var hq = arguments.length < 2;
hs || (hs = []);
hr || (hr = {
iAnonymous: 0,
lastname2fmarr: {}
});
var h0 = hp instanceof Array ? hp : hp.allTree,
hn = [];
if (hq) hn.lastname2fmarr = hr.lastname2fmarr;
for (var h1 = h0.length, hZ = 0; hZ < h1; hZ++) {
var ht = h0[hZ];
var hO = ht.type === hY || ht.type === hX,
hN = ht.type === hW,
hx = hO && !ht.name;
if (hx || hO || hN) {
var hQ = ht.begin,
hP, hM = [],
hL = [],
hV;
if (hx) {
hM = ['anonymous#' + hr.iAnonymous++];
} else {
hM = ht.name.split('.');
}
var hR = ht.children.filter(function(hU) {
return hU.type !== 'comment';
}),
hT = hR[0];
if (hT.type === 'call') {
if (hT.name !== ht.name) throw new Error('Inconsistency! Probably a bug here.');
hR.shift();
}
if (hR.length !== 2) throw new Error('Unexpected metafun declaration or function declaration');
var hK = hR[0],
hI = hK.sepSplit.map(hm),
hH = {};
for (var hS = hI.length; hS--;) hH[hI[hS]] = 1;
var hD = hR[1],
hP = hD.end,
hy = hD.str,
hF = hs.concat(hM),
hJ = hF.join('.'),
hw = hF[hF.length - 1],
hv = {
begin: hQ,
end: hP,
fullname_arr: hF,
lastname: hw,
isFunction: hO,
isMetafunction: hN,
isAnonymousFunction: hx,
dot_arr: hM,
dotnode_arr: hL,
param_node: hK,
body_node: hD,
fm_node: ht,
fullname: hJ,
param_arr: hI,
param_str: hI.join(','),
param_set: hH,
parent: hG || null,
children: null,
body: null
};
var hz = hD.children ? hu(hD.children, hF, hr, hv) : [];
for (var hE = hz.length; hE--;) {
var hC = hz[hE],
hB = hC.begin - hD.begin,
hA = hC.end - hD.begin;
if (!hC.isAnonymousFunction) hy = hy.substring(0, hB) + hy.substring(hB, hA).replace(/[\s\S]/g, ' ') + hy.substring(hA);
}
hv.children = hz;
hv.body = hy;
hn.push(hv);
if (!hx) {
(hr.lastname2fmarr[hw] || (hr.lastname2fmarr[hw] = [])).push(hv);
}
} else if (ht.children) {
hn.push.apply(hn, hu(ht.children, hs, hr));
}
}
if (hq) {
hk(hn, [].concat(hp.vardeclArr), 'vardecl');
hk(hn, hp.identifierArr.filter(function(ho) {
return !ho.isVardecl;
}), 'varuse');
gP(hn);
}
return hn;
}
function hm(hl) {
return hl.str.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^\s+|\s+$)/g, '');
}
function hk(hh, h_, hc) {
var hi = hh.length;
for (var hg = 0; hg < hi; hg++) {
var hd = hh[hg],
hj = hd.children;
if (hj && hj.length) hk(hj, h_, hc);
}
for (var hg = 0; hg < hi; hg++) {
var hd = hh[hg],
hf = hd.begin,
h$ = hd.end,
he = hd.param_node.begin,
hb = hd.param_node.end,
g8 = hd[hc + 'Arr'] = [],
g7 = hd[hc + 'Obj'] = {};
for (var g9 = h_.length; g9--;) {
var ha = h_[g9];
if (ha.end < hb) break;
if (ha.begin < h$) {
var g6 = h_.splice(g9, 1)[0];
g8.unshift(g6);
(g7[g6.name] || (g7[g6.name] = [])).push(g6);
}
}
}
}
function gP(g4, gN) {
if (g4 instanceof Array) {
for (var gU = g4.length, g5 = 0; g5 < gU; g5++) gP(g4[g5], gN);
return;
}
var gO = g4;
gN = gN ? gu(gN) : {};
var g3 = gO.idname2decluse = gN,
gR = [gN];
for (var gT = gO.param_arr.length; gT--;) {
var gS = gO.param_arr[gT],
g2 = gO.param_node.sepSplit[gT];
gG(gR, gS, {
isParam: true,
fmDecl: gO,
use: [],
name: gS,
declArr: [{
begin: g2.begin,
end: g2.end
}]
});
}
for (var gS in gO.vardeclObj) {
if (!(gS in gr)) {
var g0 = gO.vardeclObj[gS],
g1 = g0.length,
gX = new Array(g1);
for (var gZ = 0; gZ < g1; gZ++) {
var gY = g0[gZ];
gX[gZ] = {
begin: gY.begin,
end: gY.end
};
}
gG(gR, gS, {
isVardecl: true,
fmDecl: gO,
use: [],
name: gS,
declArr: gX
});
}
}
for (var gT = gO.children.length; gT--;) {
var gW = gO.children[gT],
gS = gW.lastname,
gV = [];
if (gW.dotnode_arr.length) {
gV.push({
begin: gW.dotnode_arr[0].begin,
end: gW.dotnode_arr.slice(-1)[0].end
});
}
gG(gR, gS, {
isFunction: true,
fmDecl: gO,
use: [],
name: gS,
declArr: gV
});
}
for (var gU = gO.varuseArr.length, gT = 0; gT < gU; gT++) {
var gQ = gO.varuseArr[gT],
gS = gQ.name;
if (!gN[gS]) {
gG(gR, gS, {
isGlobal: true,
fmDecl: null,
use: []
});
}
gz(gR, gO, gQ);
}
gP(gO.children, gN);
}
function gG(gD, gC, gA) {
var gH;
(gC || 0).substring.call.a;
(gA || gH).hasOwnProperty.call.a;
if (gD instanceof Array) {
gD.forEach(function(gF) {
gG(gF, gC, gA);
});
return;
}
if (!gD[gC] || gD[gC].fmDecl !== gA.fmDecl) {
var gE = gu(gA);
gE.use = [].concat(gE.use);
gD[gC] = gE;
} else {
var gB = gD[gC].use;
gB.push.apply(gB, gA.use);
}
}
function gz(gx, gv, gw) {
if (gx instanceof Array) {
gx.forEach(function(gy) {
gz(gy, gv, gw);
});
return;
}
gx[gw.name].use.push(gs(gu(gw), {
fmUse: gv
}));
}
function gu(gt) {
return gs({}, gt);
}
function gs(go, gq) {
for (var gp in gq) {
if (!(gp in gr)) {
go[gp] = gq[gp];
}
}
return go;
}
})(m || F || this);
}
if (typeof metaparse === 'undefined') {
var m, F;
if (typeof codeparse === 'undefined') {}
if (typeof cp2fmtree === 'undefined') {};
(function(fw) {
var dd = 0,
gk = 'metafun',
dG = 'metaret',
gn = [gk, dG],
gm = [{
open: dG,
close: ';',
typebracket: dG,
ignore_unbalanced: true
}],
g$ = {
extraReservedArr: gn,
extraBracketArr: gm
},
fB = {
jsmAllowMetaretOutsideFunction: true,
allowReturnOutsideFunction: true
},
dM = bN({}, g$, fB);
fw.MetaDecl = fX;
fw.MetaFunction = e7;
fw.metaparse = gh;
gh.get_CODEPARSE_OPT = gj;
gh.get_CONST = gl;
function gj() {
return JSON.parse(JSON.stringify(g$));
}
function gl() {
return {
'METAFUN': gk,
'METARET': dG,
'CODEPARSE_OPT': gj()
};
}
var gi = /\s*(metafun|function)\s*(\S+)\s*\(\s*([^\)]+?)\s*\)((?![\r\n]\s*(metafun|function))[\s\S])*/g,
fF = /^\s*(metafun|function)\s*(\S+)\s*\(\s*([^\)]+?)\s*\)\s*\{\s*(((?![\r\n]\s*(metafun|function))[\s\S])*)\s*\}\s*$/,
fG = /^\s*(metafun|function)\s/,
fJ = /^\s*function\s/;
function gh(gg, f8, f7) {
f8 || (f8 = fx);
var ge = gg ? [gg] : document.getElementsByTagName('script'),
f6 = [];
for (var gf = ge.length, gd = 0; gd < gf; gd++) {
var gb = ge[gd],
gc = 'string' === typeof gb;
if (!gc && 'text/js-metaret-decl' !== gb.getAttribute('type')) continue;
var ga = gc ? gb : gb.textContent || gb.innerText,
g_ = codeparse(ga, g$),
f9 = cp2fmtree(g_);
f3(f9, true, f8, f6, f7);
}
return f6;
}
function f3(fZ, f1, f0, fY, f2) {
fY || (fY = []);
if (fZ instanceof Array) {
for (var f5 = fZ.length, f4 = 0; f4 < f5; f4++) f3(fZ[f4], f1, f0, fY, f2);
} else {
if (fZ.children) f3(fZ.children, false, f0, fY, f2);
f0[fZ.fullname] = {
fm: fZ,
_work_in_progress: true
};
fC(fZ.fullname, fZ.param_str, fZ.body, fZ.children, fZ.isFunction, f0, f2);
delete f0[fZ.fullname]._work_in_progress;
if (f1) fY.push({
fullname: fZ.fullname,
fmtree: fZ,
info: f0[fZ.fullname]
});
}
return fY;
}
var fx = {};
function fX(fW, fV, fU, fT, fS, fR) {
fC(fW, fV, fU, fT, false, fS || fx, fR);
}
function fC(fy, fq, fo, fl, fs, fn, fk) {
fl || (fl = []);
fs != null || (fs = fJ.test(fy));
fn || (fn = fx);
var fH = fq == null,
fI = fo == null;
if (fH ^ fI) throw new Error('Decl: invalid usage. Give either both `param` and `body`, or none of them.');
if (fH) {
var fE = fG.test(fy) ? fy : (fs ? 'function' : 'metafun') + ' ' + fy,
fD = fF.exec(fE),
fr = fD[2];
fq = fD[3];
fo = fD[4];
fC(fr, fq, fo, fl, fs, fn, fk);
return;
}
if (!fs) {
var fA = codeparse(fo, fB),
fz = fA.identifierObj['arguments'] || [];
if (fz.length) throw new Error('metafun error: it is forbidden to use `arguments` in the body of the metafun (because the body of the metafun may end up being inlined within a `while` loop).');
}
var fr = fy;
var ft = fr.split('.'),
fu = fn === fx ? fw : {};
while (ft.length > 1) {
var fv = ft.shift();
fu = fu[fv] || (fu[fv] = {});
}
var fp = fs ? '' : ('\nmetafun ' + fr + '\n( ' + fq + ')').replace(/([\r\n])/g, '$1// --- ') + '\n\n';
fu[ft[0]] = (fs ? fj : e7)(fr, fq, fp + fo, fn, fl, fk);
}
function fj(ff, e9, e8, fe, fg, fd) {
d3(fe, ff);
if (fg && fg.length) {
var fh = /\}\s*/,
fi = fh.test(e8);
e8 = fi && e8.replace(fh, '\n\n' + e$(fe, fg) + '\n\n}');
}
var f_ = fe[ff] = fe[ff] || {};
f_.name = ff;
f_.lastname = ff.replace(/^.*\./, '');
f_.origParam = e9;
f_.origBody = e8;
f_.name2info = fe;
f_.impl = null;
f_.paramArr = e9.split(',');
f_.body = e8;
var fc = fd && fd.doNotCompile ? fb : f$();
fc.getInfo = fa;
fc.getImpl = f$;
return fc;
function fb() {
return (f_.impl || (f_.impl = f$())).apply(this, arguments);
}
function fa() {
return Object.create(f_);
}
function f$() {
return f_.impl || (f_.impl = new Function(e9, e8));
}
}
function e7(e2, e6, e4, eZ, e1, eY) {
d3(eZ, e2);
var eT = eZ[e2] = eZ[e2] || {};
eT.name = e2;
eT.lastname = e2.replace(/^.*\./, '');
eT.origParam = e6;
eT.origBody = e4;
eT.name2info = eZ;
eT.solved = false;
eT.newParam = null;
eT.newBody = null;
eT.impl = null;
var e3 = eT.paramArr = dZ(e6),
e5 = eT.varArr = dV(e4),
e0 = eT.metaretArr = dN(e4, e3.self, e2);
eR(eT, e1);
var eX = eW;
if (e0.hasAll(eZ)) {
eT.solve();
if (!(eY && eY.doNotCompile)) eX = eT.compile();
}
eX.getInfo = eV;
eX.getImpl = eU;
return eX;
function eW() {
if (!eT.impl) eT.compile();
return eT.impl.apply(this, arguments);
}
function eV() {
return Object.create(eT);
}
function eU() {
if (!eT.impl) eT.compile();
return eT.impl;
}
}
var d2 = /^(([a-zA-Z_]\w*|anonymous#\d+)\.)*([a-zA-Z_]\w*|anonymous#\d+)$/,
eS = /^(([a-zA-Z_]\w*|anonymous#\d+)\.)*(anonymous#\d+)$/,
dY = /^((?:^\s*|\s*,\s*)[a-zA-Z_]\w*(?:\s*))+$/,
dE = /^[a-zA-Z_]\w*?(\.[a-zA-Z_]\w*?)*$/,
c2 = Array.prototype.slice;
function eR(ep, el) {
var eJ = ep.name,
ez = ep.metaretArr,
er = ep.paramArr,
eQ = ep.varArr,
eF = ep.origBody,
eg = ep.name2info,
eP = eJ.split('.');
ep.solve = eN;
ep.compile = eO;
function eN() {
if (ep.solved) return;
if (!ez.hasAll(eg)) throw new Error('MetaFunction : _createSolver : solve() could not resolve all dependencies yet for metafunction "' + eJ + '".');
if (!ez.length) eM();
else if (!ez.hasOther()) eK();
else eA();
ep.solved = true;
}
function eO() {
if (!ep.solved) eN();
return ep.impl || (ep.impl = new Function(ep.newParam.join(','), ep.newBody));
}
function eM() {
var eL = 'MetaFunction : _createSolver:solveNoMetaret() no #metaret in body of metafunction "' + eJ + '".';
if ('undefined' !== typeof console && console.warn) console.warn(eL);
ep.newParam = er;
ep.newBody = eF.replace(/^\s+$/mg, '');
}
function eK() {
var eI = [er, eF],
eE = dc('L_' + eJ, eI),
eD = dc('undef', eI),
eC = ep.newParam = er,
eG = cg(4),
eH = cg(8),
eB = ep.newBody = eG('var ' + eD + ';\n' + eE + ': while (true) {\n' + eG(cv(c3(eg, ez, eF, eE, er), ep.varArr, eD) + '\n') + ' return;\n' + '}\n' + (el && el.length ? '\n\n' + e$(eg, el) + '\n' : '')).replace(/^\s+$/mg, '');
ep.paramArr = eC;
ep.body = eB;
}
function eA() {
var ey = ez.hasAll(),
em = [ep].concat(ey.infoArr.filter(function(ex) {
return ex !== ep;
})),
ef = em.map(function(ew) {
return ew.name;
}),
ee = em.map(function(ev) {
return ev.paramArr.concat(ev.origBody);
}),
en = ef.switch_ind_name = dc('switch_ind', ee),
eo = ef.switchLabel = dc('L_switch', ee),
ec = dc('undef', ee);
b0(em.map(function(eu) {
return eu.fm;
}));
var eh = cg(4),
ea = cg(8),
et = cg(12),
es = ep.newParam = er,
eq = ep.newBody = eh(['var ' + ec + ';', 'var ' + en + ' = 0;', eo + ': while (true) {', eh('switch (' + en + ') {')].concat(em.map(ej)).concat([eh('}'), eh('return;'), '}', ''].concat(el && el.length ? ['', '', e$(eg, el.filter(function(ek) {
(ek.fullname || 0).substring.call.a;
return 0 > ef.lastIndexOf(ek.fullname);
}))] : []))).join('\n').replace(/^\s+$/mg, '');
function ej(ed, ei) {
var eb = ['', 'case ' + ei + ':'];
eb.push(eh(cv(c3(eg, ed.metaretArr, ed.origBody, ef, ee), ed.varArr, ec)));
eb.push('break;');
eb.push('');
return eb.map(ea).join('\n');
}
}
}
function e$(d7, d9) {
var d4 = [];
for (var e_ = d9.length, d8 = 0; d8 < e_; d8++) {
var d6 = d9[d8],
d5 = d7[d6.fullname];
if (d6.isAnonymousFunction) continue;
d4.push('\n');
d4.push('function ' + d5.lastname + '(' + d5.paramArr.join(',') + ')\n' + (/^\s*\{[\s\S]*?\}\s*$/.test(d5.body) ? d5.body : '{\n' + d5.body + '\n}\n'));
}
return d4.join('\n');
}
function d3(d1, d0) {
if (!d2.test(d0)) throw new Error('MetaFunction : _checkNameNotUsedYet : Invalid function name "' + d0 + '". The function name must match [a-zA-Z_][a-zA-Z_0-9]*');
if (c_(d1, d0, [])) throw new Error('MetaFunction : _checkNameNotUsedYet : Duplicate function name "' + d0 + '". The function name must be unique: ' + 'MetaFunction can be called one time only with a given name.');
}
function dZ(dX) {
dX = dX.replace(/\/\*.*?\*\//g, '');
if (!dY.test(dX)) throw new Error('MetaFunction : _checkExtractParam : Invalid parameters string, the string must be like "self,x,y,z".');
var dW = dX.replace(/\s+/g, '').split(',');
dW.self = dW.splice(dd, 1)[0];
return dW;
}
function dV(dU) {
var dT = codeparse(dU, dM),
dR = dT.identifierArr,
dO = [];
for (var dS = dR.length, dQ = 0; dQ < dS; dQ++) {
var dP = dR[dQ];
dO.push({
text: dP.str,
end: dP.begin + dP.str.length,
start: dP.begin,
isVardecl: dP.isVardecl
});
}
return dO;
}
function dN(dK, dD, dx) {
var dL = codeparse(dK, dM),
dI = dL.bracketextraArr,
dw = [];
dw.body = dK;
dw.self = dD;
dw.selfName = dx;
for (var dJ = dI.length, dH = 0; dH < dJ; dH++) {
var dy = dI[dH];
if (dy.typebracket !== dG) continue;
var dC = dy.sepSplit.map(function(dF) {
return dF.str.replace(/^\s+/, '').replace(/\s+$/, '');
}),
dz = dC.length > dd && dC.splice(dd, 1)[0];
if (!dz) throw new Error('MetaFunction : _checkExtractMetaret() : A `metaret` needs at least an action.');
if (dz !== dD && !dE.test(dz)) {
throw new Error('MetaFunction : _checkExtractMetaret : Invalid action "' + dz + '". action must be self ("' + dD + '") or a named action (like "myOtherAction" or "my.other.action" or "my_other_action").');
}
var dB = dz === dD || dz === dx;
dw.push({
exprArr: dC,
isSelf: dB,
action: dB ? dx : dz,
end: dy.end,
start: dy.begin,
namespace: dx,
namespace_arr: dx.split('.')
});
}
dw.hasOther = dv;
dw.hasAll = dr;
return dw;
}
function dv() {
var dt = 'hasOtherResult';
if (dt in this) return this[dt];
var ds = [];
for (var du = this.length; du--;) {
if (!this[du].isSelf) ds.push(this[du].action);
}
return this[dt] = ds.length && ds;
}
function dr(dl, dk, dh, dg) {
var dj = arguments.length < 2;
if (dj) {
var di = 'hasAllResult';
if (di in this) return this[di];
dh = {};
dg = [];
}
for (var dq = this.length; dq--;) {
var dp = this[dq];
if (dp.isSelf) continue;
var dn = dp.action;
if (!dn) throw new Error('MetaFunction : hasAll : Found a bug: empty metaret action (not permitted).');
if (dn in dh) continue;
var dm = b4(dl, dn, dp.namespace_arr);
if (!dm) return false;
if (dm.name in dh) continue;
dh[dn] = dh[dm.name] = dm;
dg.push(dm);
if (!dm.metaretArr.hasAll(dl, dk, dh, dg)) return false;
}
if (dj) return this[di] = {
vObj: dh,
infoArr: dg
};
else return true;
}
function dc(db, da) {
var d$ = cM(db, da);
da.push(d$);
return d$;
}
function cM(d_) {
var c8 = c2.call(arguments, 1);
for (var c9 = null; true; c9 = (c9 >>> 0) + 1) {
var c7 = '_' + d_.replace(/#/g, '').replace(/\W/g, '_') + (c9 || '') + '_';
if (!c6(c8)) return c7;
}
function c6(c5) {
if (typeof c5 === 'string') return -1 < c5.indexOf(c7);
for (var c4 = c5.length; c4--;) {
if (c6(c5[c4])) return true;
}
return false;
}
}
function c3(cQ, cD, c1, cE) {
var cL = c2.call(arguments, 1),
cF = typeof cE === 'string',
cS = c1;
for (var cZ = cD.length; cZ--;) {
var cX = cD[cZ],
cV = cS.slice(0, cX.start),
cT = cS.slice(cX.end);
var cW = '',
cY = cT.match(/^\s*(?:\/\/[^\r\n]*[\r\n]+|\/\*((?!\*\/)[\s\S]*)\*\/)/);
if (cY) {
cW = cY[0];
cT = cT.substring(cW.length);
}
var cU = cR(cX, cW);
cS = cV + cU + cT;
}
return cS;
function cR(cz, cx) {
var cw = [],
cC = b4(cQ, cz.action, cz.namespace_arr),
cN = cC.paramArr,
cJ = cz.exprArr;
if (cN.length !== cJ.length) {
throw new Error('MetaFunction : _replaceMetaretWithContinue : prepareCode : Invalid number of metaret arguments, action "' + cz.action + '" expects ' + cN.length + ' arguments, but ' + cJ.length + ' were given.');
}
if (cN.length === 1) {
cw.push(cN[0] + ' = ' + cJ[0] + ';');
} else {
for (var cK = 0, cI = 0, cP = cN.length; cI < cP; cI++) {
var cH = cN[cI];
if (cH === cJ[cI]) continue;
var cG = cM(cH, cL);
cL.push(cG);
cw.splice(cK++, 0, 'var ' + cG + ' = ' + cJ[cI] + ';');
cw.push(cH + ' = ' + cG + ';');
}
}
if (cF) {
cw.push('continue ' + cE + ';');
} else {
var cy = cE;
if (cz.action === cD.selfName) {
cw.push('continue ' + cy.switchLabel + '; // --- stay in: ' + cz.action);
} else {
var cB = cy.indexOf(cC.name);
if (0 > cB) {
throw new Error('MetaFunction : _replaceMetaretWithContinue : prepareCode : Found a bug! Could not find the switch index of action "' + cz.action + '"');
}
cw.push(cy.switch_ind_name + ' = ' + cB + '; // --- go to: ' + cz.action);
cw.push('continue ' + cy.switchLabel + ';');
}
}
if (cx) cw.unshift(cx);
cw.unshift('{');
cw.push('}');
return cw.join('\n') + '\n';
}
}
function cv(ci, ct, ck) {
var cj = [],
cq = {};
for (var cr = 0, cu = ct.length; cr < cu; cr++) {
var cn = ct[cr],
cm = cn.text;
if (cm in cq) continue;
cq[cm] = 1;
var co = ci.search(new RegExp(cm + '\\s*[,;]'));
if (cn.isVardecl && -1 < co && co < cn.end) {
cj.push(cm);
}
}
if (!cj.length) return ci;
return 'var ' + cj.map(function(cl) {
return cl + ' = ' + ck;
}).join('\n, ') + (cj.length > 1 ? '\n' : '') + ';\n' + ci;
}
function cg(cf) {
var ce = ' ',
cd = [];
while (cf) {
if (cf & 1) cd.push(ce);
cf >>= 1;
ce += ce;
}
var cb = cd.join('');
return c$;
function c$(ca) {
if (typeof ca === 'string') {
var cc = /\n/;
if (cc.test(ca)) return ca.split(cc).map(c$).join('\n');
return cb + ca;
}
return ca.map(c$);
}
}
function c_(b9, b8, b7) {
var b6 = b4(b9, b8, b7);
return !!(b6 && !b6._work_in_progress);
}
function b4(b3, b2, b1) {
var b5 = b1.concat(b2).join('.');
if (b5 in b3) return b3[b5];
if (b1.length) return b4(b3, b2, b1.slice(0, -1));
return false;
}
function b0(bZ) {
var bS = {};
bZ.forEach(bY);
function bY(bU) {
if (!bU) return;
var bX = bU.varuseObj,
bW = bU.vardeclObj,
bV = bU.param_set;
for (var bR in bX) {
if (!(bR in bW) && !(bR in bV)) {
var bT = bQ(bR, bU);
if (!bS[bR]) bS[bR] = {
scope: bT
};
else if (bT !== bS[bR].scope) throw new Error('metafun error: when using mutual recursion, the various metafunctions must share their bound variables (if any).');
}
}
}
}
function bQ(bP, bO) {
return bO ? bO.vardeclObj[bP] ? bO : bQ(bP, bO.parent) : null;
}
function bN() {
var bI = arguments[0];
for (var bL = 1, bM = arguments.length; bL < bM; bL++) {
var bK = arguments[bL];
for (var bJ in bK) {
if (bK.hasOwnProperty(bJ)) {
bI[bJ] = bK[bJ];
}
}
}
return bI;
}
})(m || F || this);
}(function(bH) {
bH.jsm2js = bG;
function bG(bF) {
var br = {},
bE = metaparse(bF, br, {
doNotCompile: true
}),
bw = bF;
bt(bE);
bp(bw);
return bw;
function bt(bD) {
for (var bC = bD.length; bC--;) {
var bB = bD[bC],
bu = bB.fmtree,
bx = bB.info,
by = bu.begin,
bv = bu.end,
bz = bx.lastname;
by.toPrecision.call.a;
(bv || null).toPrecision.call.a;
if (bu.isMetafunction) {
bw = bw.substring(0, by) + '\nfunction ' + bx.lastname + '(' + bx.paramArr.join(',') + ')\n{\n' + (bx.newBody || bx.solve(), bx.newBody) + '\n}\n' + bw.substring(bv);
} else if (bu.isFunction) {
var bs = bu.children;
if (bs) bt(bs.map(function(bq) {
return {
fmtree: bq,
info: br[bq.fullname]
};
}));
}
}
}
}
var bo;
function bp(be) {
bo || (bo = metaparse.get_CONST());
var bn = codeparse(be, bo.CODEPARSE_OPT),
bi = cp2fmtree(bn),
bl = bn.jsmMetaretArr || [],
bm = bn.jsmMetafunArr || [];
if (bm.length || bl.length) {
if ('undefined' !== typeof console) {
console.error('mfunArr:', bm);
console.error('mretArr:', bl);
}
throw new Error('jsm2js:check_leftover: found remaining `metafun` and/or `metaret` within function(s): ' + ' - Please check for basic errors. For example a `metaret` can only be used from within a `metafun`.' + ' See also github issue #9: https://github.com/glathoud/js.metaret/issues/9');
}
}
})(m || F || this);
} {
var m, F;
if (typeof codeparse === 'undefined') {}
if (typeof cp2fmtree === 'undefined') {}(function(bb) {
var ah = 'inline',
ba = {
extraReservedArr: [ah]
},
$5 = {
extraReservedArr: [ah],
jsmAllowMetaretOutsideFunction: true,
allowReturnOutsideFunction: true
},
$x = 'varassign',
$y = 'assign',
$z = 'call',
au = 'bracket',
as = 'round',
aC = 'identifier',
bc = 'reserved',
$0 = 'return',
$M = 'var',
aw = 'vardecl';
bb.inlineCode = aN;
function aN(aR, aH, aW, aJ) {
aH || (aH = {});
aJ || (aJ = []);
var aM = codeparse(aR, ba),
aL = cp2fmtree(aM),
a9 = aM.all,
aQ = a9.map(function(b$, b_) {
var a8 = aE(b$, b_, a9, aR);
if (a8) {
a8.begin = a8.o.begin;
a8.end = a8.args.end;
a8.str = aR.substring(a8.begin, a8.end);
}
return a8;
}).filter(function(a7) {
return a7;
});
var a5 = aL.lastname2fmarr;
var aG = aW ? JSON.stringify(aW) : aR;
aJ.push({
key: aG,
code: aR,
workspace: aH,
opt_code_info: aW
});
if (aG in aH) {
var aF = aH[aG].newcode;
if ('string' !== typeof aF) {
if ('undefined' !== typeof console && console && console.error) {
console.error('error_inline_stack (summary):\n ' + aJ.map(function(a6) {
return '\n' + a6.key.substring(0, 96) + (a6.key.length < 96 ? '' : '...');
}).join('\n\n###\n'));
console.error('error_inline_stack (full):');
console.error(aJ);
}
throw new Error('inline error: Most likely you have an infinite `inline` recursion. Consider using `metafun` and `metaret` instead.');
}
return aF;
}
aH[aG] = {
code_info: aW,
inlineArr: aQ,
lastname2fmarr: a5,
cp: aM,
fm: aL
};
if (!aQ.length) return aH[aG].newcode = aR;
for (var aP = aQ.length; aP--;) {
var aK = aQ[aP];
aK.fmScopePath = $e(aL, aK);
var a4 = $a(aL, aK, aK.fmScopePath);
if (a4) {
aK.hasLocalMatch = true;
aK.fmCallMatch = a4;
aK.matchKey = aG;
} else {
var a3 = [],
aY = aK.call.name;
(aY || 0).substring.call.a;
for (var aX in aH) {
if (aH.hasOwnProperty(aG)) {
if (aG === aX) continue;
var a2 = aH[aX],
a1 = a2.lastname2fmarr,
a0 = a1[aY],
aZ = a0 && a0.length;
if (aZ === 1) {
if (aK.fmCallMatch) {
throw new Error('Ambiguous match for inline call "' + aY + '" found between the 2 pieces: ' + aK.matchKey + '\n --- and --- \n' + aX);
}
aK.hasLocalMatch = false;
aK.fmCallMatch = a0[0];
aK.matchKey = aX;
_0(aK.fmCallMatch);
} else if (aZ === 2) {
throw new Error('Ambiguous match for inline call "' + aY + '" found within piece "' + aX);
}
}
}
}
if (!aK.fmCallMatch) throw new Error('inline error: when inlining within a file, the source body must be visible to the target inline location. one.call.name: "' + aK.call.name + '", opt_code_info: ' + JSON.stringify(aW));
var aU = aK.fmCallMatch.begin,
aS = aK.fmCallMatch.end,
aV = aM.identifierObj['arguments'] || [];
if (aV.some(function(aT) {
return aU <= aT && aT < aS;
})) throw new Error('inline error: it is forbidden to use `arguments` in the body of the function to be inlined.');
}
var aF = aR;
for (var aP = aQ.length; aP--;) {
var aK = aQ[aP],
aO = aK.begin,
aI = aK.end;
aF = aF.substring(0, aO) + aN(ak(aM.identifierObj, aL, aK), aH, null, aJ) + aF.substring(aI);
}
return aH[aG].newcode = aF;
}
function aE(aq, ao, aD, ar) {
if (aq.name !== ah) return;
var ax, an, am, al, az = aq.children.length,
ay = aq.children[0],
aB = aq.children[1],
aA = aq.children[2];
if (az === 2 && (am = ay).type === $z && (al = aB).type === au && al.typebracket === as) {
return {
o: aq,
ind: ao,
inlinetype: $z,
call: am,
args: al
};
}
if (az === 3 && (an = ay).type === aC && (am = aB).type === $z && (al = aA).type === au && al.typebracket === as && /=/.test(ar.substring(an.end, am.begin))) {
return {
o: aq,
ind: ao,
inlinetype: $y,
identifier: an,
call: am,
args: al
};
}
var av;
if (az === 1 && (ax = ay).type === au && ax.typebracket === $M && (av = ax.children).length === 3 && (an = av[0]).type === aw && (am = av[1]).type === $z && (al = av[2]).type === au && al.typebracket === as && /=/.test(ar.substring(an.end, am.begin))) {
return {
o: aq,
ind: ao,
inlinetype: $x,
identifier: an,
call: am,
args: al
};
}
throw new Error('Unrecognized inline syntax.');
}
function ak(ag, aj, $u) {
var $v;
var ai = $u.fmScopePath,
$9 = $u.fmCallMatch;
if (-1 < ai.indexOf($9)) {
if ('undefined' !== typeof console) console.error('Could not inline: self-recursion found for "' + $9.fullname + '".');
else if ('undefined' !== typeof print) print('[ERROR] Could not inline: self-recursion found for "' + $9.fullname + '".');
return $u.str.substring(ah.length);
}
var aa = Object.create(ag);
var $D = $n('undef', aa),
$w = $n('ret', aa),
ae = $9.param_arr,
$T = ae.map(function(af) {
return $n(af, aa);
}),
$3 = $s(ae, $T),
ad = $9.vardeclArr,
a$ = ad.map(function(ac) {
return ac.name;
}),
a_ = a$.map(function(ab) {
return $n(ab, aa);
}),
$H = $s(a$, a_),
$W = $9.body,
$6 = $9.body_node.begin,
$7 = $9.body_node.end,
$8 = $7 - $6,
$V = [],
$O = codeparse($W, $5);
for (var $N = $O.identifierArr.length; $N--;) {
var $4 = $O.identifierArr[$N],
$1 = $3[$4.name] || $H[$4.name];
if ($1) $V.push({
o: $4,
newstr: $1
});
}
for (var $N = $O.callArr.length; $N--;) {
var $2 = $O.callArr[$N],
$1 = $3[$2.name] || $H[$2.name];
if ($1) $V.push({
o: $2,
newstr: $2.str.replace($2.name, $1)
});
}
for (var $N = $O.bracketextraArr.length; $N--;) {
var $L = $O.bracketextraArr[$N];
if ($L.typebracket !== $0) continue;
$V.push({
o: {
begin: $L.begin,
end: $L.begin + $0.length
},
newstr: $w + ' = '
});
$V.push({
o: {
begin: $L.end,
end: $L.end
},
newstr: ' break;'
});
}
$V.sort(function($Z, $Y) {
var $X;
return $Z.o.begin < $Y.o.begin ? -1 : $Z.o.end > $Y.o.end ? +1 : $X.bug;
});
var $A = $W;
for (var $N = $V.length; $N--;) {
var $U = $V[$N];
$A = $A.substring(0, $U.o.begin) + $U.newstr + $A.substring($U.o.end);
}
var $R = $u.args.sepSplit,
$C = $T.map(function($S, $Q) {
return 'var ' + $S + ' = ' + ($Q < $R.length ? $R[$Q].str : $D) + ';';
});
var $B = [],
$G = {};
for (var $P = $O.bracketextraArr.length, $N = 0; $N < $P; $N++) {
var $L = $O.bracketextraArr[$N];
if ($L.typebracket !== $M) continue;
var $J = $L.vdArr;
for (var $K = $J.length, $I = 0; $I < $K; $I++) {
var $F = $J[$I];
if (!$F.rightstr && !($F.leftstr in $G)) {
$B.push($H[$F.leftstr] + ' = ' + $D);
$G[$F.leftstr] = 1;
}
}
}
var $E = /^\s*\{[\s\S]*?\}\s*$/.test($A);
var $t = ['{', '//#INLINE_BEGIN: ' + $u.str.replace(/\r\n/g, ' ')].concat(['var ' + $D + ', ' + $w + ';']).concat(['//#INLINE_SET_INPUT_ARGS:']).concat($C).concat($B.length ? ['var ' + $B.join(', ') + ';'] : []).concat(['//#INLINE_IMPLEMENT:']).concat(['do {']).concat($A).concat(['} while (false);']).concat($u.inlinetype === $z ? [] : $u.inlinetype === $y ? [$u.identifier.name + ' = ' + $w + ';'] : $u.inlinetype === $x ? ['var ' + $u.identifier.name + ' = ' + $w + ';'] : $v.bug).concat(['//#INLINE_END: ' + $u.str.replace(/\r\n/g, ' ')]).concat(['}']).join('\n');
return $t;
}
function $s($r, $q) {
var $o = {};
for (var $p = $r.length; $p--;) $o[$r[$p]] = $q[$p];
return $o;
}
function $n($m, $j) {
var $l = '_' + $m + '_',
$k = '',
$i;
while (($i = $l + $k) in $j) $k = +$k + 1;
$j[$i] = 1;
return $i;
}
function $e($g, $c, $b) {
$b || ($b = []);
for (var $h = $g.length, $f = 0; $f < $h; $f++) {
var $d = $g[$f];
if ($d.begin <= $c.begin && $c.end <= $d.end) {
$b.push($d);
$e($d.children || [], $c, $b);
break;
}
}
return $b;
}
function $a($_, $$, _2) {
var _4 = $$.call.name,
_9 = $_.concat(_2),
_1;
top_loop: for (var _8 = _9.length; _8--;) {
var _3 = _9[_8];
var _7 = _3.children || [];
for (var _6 = _7.length; _6--;) {
var _5 = _7[_6];
if (_5.lastname === _4) {
_1 = _5;
break top_loop;
}
}
if (_3.lastname === _4) {
_1 = _3;
break top_loop;
}
}
if (_1) U(_1, _2.slice(-1)[0]);
return _1;
}
function _0(X) {
var Z = X.varuseObj,
Y = X.vardeclObj;
for (var W in Z) {
if (!(W in Y)) {
var V = X;
while (V = V.parent) {
if (W in V.vardeclObj) {
throw new Error('inline error: when inlining across files, the body to inline MUST NOT use locally bound variables (closures). (It may use globals, though.)');
}
}
}
}
}
function U(N, L) {
var P = [],
T = N.varuseObj,
S = N.vardeclObj,
R = N.param_set;
for (var Q in T) {
if (!(Q in S) && !(Q in R)) {
P.push(Q);
}
}
P.forEach(O);
function O(M) {
var K = I(M, N),
J = I(M, L);
if (K !== J) throw new Error('inline error: when inlining within a file, the source body and the target inline location must share their bound variables (if the source body has any).');
}
function I(H, G) {
return G ? G.vardeclObj[H] ? G : I(H, G.parent) : null;
}
}
})(m || F || this);
}
var w = true;
function A(q) {
if (E[q]) return;
E[q] = 1;
var y;
if (/\.js$/.test(q)) y = false;
else if (/\.jsm$/.test(q)) y = true;
else throw new Error("need$: unknown type, only .js and .jsm are supported. Path: '" + q + "'");
var l = need$.read(q);
var B = "/need\\$\\s*\\(\\s*([\"\\'])([^\"\\']+)\\1/",
D = new RegExp(B, "g"),
C = new RegExp(B),
z = l.match(/need\$\s*\(\s*(["\'])([^"\']+)\1/g);
while (z && z.length) A(z.shift().match(/need\$\s*\(\s*(["\'])([^"\']+)\1/)[2]);
if (y) {
l = jsm2js(l);
if (w) l = inlineCode(l, u, {
path: q
});
}
eval.call(m, l);
}
function h(_) {
var $ = new XMLHttpRequest();
$.open("GET", _, false);
$.send();
if ($.status !== 0 && $.status !== 200) throw new Error("need$:xhrGetSync: Could not load path '" + _ + "'");
return $.responseText + "\r\n//@ sourceURL=" + _;
}
})(global || exports || this);
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment