@effectful/transducers-loose
Version:
@effectful/transducers built with faster generators
1,265 lines (1,262 loc) • 40 kB
JavaScript
"use strict";
exports.__esModule = true;
exports.default = void 0;
var _core = require("../core");
var Kit = require("../kit");
var Scope = require("../scope");
var RT = require("../rt");
var M = require("@effectful/es-rt/opts/loose");
const path = require("path");
const globals = Scope.newSym("g");
/** calculates captured vars dependencies */
function calcClosCapt(si) {
var sa,
s,
closureSym,
rt,
fs,
walk = function _walk(root, sw) {
var decls,
closDeps,
id = function id(i) {
var si, c;
si = i.value.sym;
if (si != null) {
if (si === Scope.argumentsSym && !root.argumentsSym) {
root.argumentsSym = Scope.newSym("args");
return;
}
if (i.value.decl) decls.push(si);
if (si.declScope) {
if (si.declScope !== root) {
(si.refScopes || (si.refScopes = new Set())).add(root);
for (c = root; c && c !== si.declScope; c = c.parScope) {
c.closDepsSet.add(si.declScope);
}
}
}
}
},
i;
decls = root.clDecls = [];
root.closSym = Scope.newSym(root.node.id && root.node.id.name || "fn");
if (!root.ctxSym) root.ctxSym = Scope.newSym("loc"); // thisSym
closDeps = root.closDepsSet = new Set();
var loop = M.iterator(sw);
for (; !(loop = loop.step()).done;) {
i = loop.value;
if (i.enter) {
switch (i.type) {
case _core.Tag.FunctionDeclaration:
id(s.cur());
Kit.skip(s.one());
case _core.Tag.FunctionExpression:
walk(i.value, s.sub());
break;
case _core.Tag.Identifier:
id(i);
break;
}
}
}
root.closDeps = [...closDeps].sort((a, b) => a.closSym.num - b.closSym.num);
};
sa = Kit.toArray(si);
s = Kit.auto(sa);
closureSym = s.first.value.closureSym = Scope.newSym("closure");
s.first.value.ctxSym = globals;
closureSym.global = true;
rt = s.first.value.rt;
if (!s.opts.noRT) {
fs = require("fs");
rt.inlineSyms.push({
syms: [closureSym],
content: fs.readFileSync(path.join(__dirname, "closConvRT.js"), "utf-8")
});
}
walk(s.first.value, s);
return sa;
}
/** replaces function calls, to call method */
function replaceCalls(si) {
var s,
callMethod,
noConstrs,
noThis,
walk = function walk1(sw, decls) {
var i,
j,
lab,
constr,
sym,
k,
_walk = M.generator(),
loop,
r,
p;
_walk.step = walk_1;
_walk.$step = 3;
return _walk;
function walk_1(p) {
var a, b;
for (;;) {
switch (_walk.$cur = _walk.$step) {
case 3:
loop = M.iterator(sw);
_walk.$step = 4;
_walk.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
if (i.enter) {
switch (i.type) {
case _core.Tag.FunctionDeclaration:
case _core.Tag.FunctionExpression:
_walk.$step = 5;
_walk.value = i;
return _walk;
case _core.Tag.NewExpression:
if (noConstrs) {
_walk.$step = 23;
_walk.$step = 23;
continue;
} else {
_walk.$step = 6;
_walk.$step = 6;
continue;
}
case _core.Tag.CallExpression:
_walk.$step = 6;
_walk.$step = 6;
continue;
default:
_walk.$step = 23;
_walk.$step = 23;
continue;
}
} else {
_walk.$step = 23;
_walk.$step = 23;
continue;
}
} else {
_walk.$step = 0;
_walk.value = void 0;
_walk.done = true;
return _walk;
}
case 5:
a = walk(s.sub(), i.value.clDecls);
_walk.$step = 4;
return _walk.$delegate(a);
case 6:
i.value.callRedir = true;
if (!callMethod) {
_walk.$step = 23;
_walk.$step = 23;
continue;
} else {
j = s.curLev();
lab = s.label();
constr = i.type === _core.Tag.NewExpression;
a = s.peel(Kit.setType(i, _core.Tag.CallExpression));
_walk.$step = 7;
_walk.value = a;
return _walk;
}
case 7:
a = s.enter(_core.Tag.callee, _core.Tag.MemberExpression);
_walk.$step = 8;
_walk.value = a;
return _walk;
case 8:
sym = void 0;
if (j.type === _core.Tag.MemberExpression && !noThis) {
s.take();
a = s.enter(_core.Tag.object, j.type, j.value);
_walk.$step = 9;
_walk.value = a;
return _walk;
} else {
sym = Scope.undefinedSym;
b = Kit.reposOne(walk(s.one()), _core.Tag.object);
_walk.$step = 16;
return _walk.$delegate(b);
}
case 9:
k = s.curLev();
if (k.type === _core.Tag.Identifier || constr) {
a = s.one();
_walk.$step = 10;
return _walk.$delegate(a);
} else {
decls.push(sym = Scope.newSym("temp"));
b = s.template(k.pos, "=$I = $_", sym);
_walk.$step = 11;
return _walk.$delegate(b);
}
case 10:
sym = k.value.sym;
_walk.$step = 13;
_walk.$step = 13;
continue;
case 11:
a = Kit.reposOne(walk(s.one(), decls), _core.Tag.right);
_walk.$step = 12;
return _walk.$delegate(a);
case 12:
a = s.leave();
_walk.$step = 13;
return _walk.$delegate(a);
case 13:
a = walk(s.one(), decls);
_walk.$step = 14;
return _walk.$delegate(a);
case 14:
a = s.leave();
_walk.$step = 15;
return _walk.$delegate(a);
case 15:
s.close(j);
_walk.$step = 16;
_walk.$step = 16;
continue;
case 16:
a = s.tok(_core.Tag.property, _core.Tag.Identifier, {
node: {
name: constr ? "constr" : "call"
}
});
_walk.$step = 17;
_walk.value = a;
return _walk;
case 17:
a = s.leave();
_walk.$step = 18;
return _walk.$delegate(a);
case 18:
a = s.peel();
_walk.$step = 19;
_walk.value = a;
return _walk;
case 19:
if (!constr && !noThis) {
a = s.tok(_core.Tag.push, _core.Tag.Identifier, {
sym
});
_walk.$step = 20;
_walk.value = a;
return _walk;
} else {
_walk.$step = 20;
_walk.$step = 20;
continue;
}
case 20:
a = walk(s.sub(), decls);
_walk.$step = 21;
return _walk.$delegate(a);
case 21:
a = s.leave();
_walk.$step = 22;
return _walk.$delegate(a);
case 22:
a = lab();
_walk.$step = 4;
return _walk.$delegate(a);
case 23:
_walk.$step = 4;
_walk.value = i;
return _walk;
case 0:
_walk.$step = 0;
_walk.value = p;
_walk.done = true;
return _walk;
case 1:
_walk.$step = 0;
throw p;
case 2:
return _walk.$redir(p);
default:
throw new Error("invalid state");
}
}
}
};
s = Kit.auto(si);
callMethod = !s.opts.closImplicitCall;
noConstrs = s.opts.noClosConstrs;
noThis = s.opts.noClosThis;
return walk(s, s.first.value.clDecls);
}
function functToObj(si) {
var s,
hoisted,
closureSym,
dpref,
dpost,
noThis,
walk = function walk1(sw, root, blockHoisted) {
var selfSym,
func = function _func(i, pos) {
var sym,
j,
objArr,
func = M.generator(),
loop,
r,
p;
func.step = func_1;
func.$step = 3;
return func;
function func_1(p) {
var a, b, c;
for (;;) {
switch (func.$cur = func.$step) {
case 3:
sym = i.value.closSym;
a = s.template(pos, "=new $I($_)", {
funcVal: i.value
}, sym);
func.$step = 4;
return func.$delegate(a);
case 4:
loop = M.iterator(i.value.closDeps);
func.$step = 5;
func.$step = 5;
continue;
case 5:
if (!(loop = loop.step()).done) {
j = loop.value;
if (j === root) {
a = s.tok(_core.Tag.push, _core.Tag.Identifier, {
sym: root.ctxSym
});
func.$step = 5;
func.value = a;
return func;
} else {
b = s.toks(_core.Tag.push, `=this.${dpref}${j.closSym.name}${dpost}`, {
origSym: j.closSym
});
func.$step = 5;
return func.$delegate(b);
}
} else {
c = s.leave();
func.$step = 6;
return func.$delegate(c);
}
case 6:
objArr = Kit.toArray(obj(i.value, sym));
objArr[0].value.closConstr = i.value;
hoisted.push(objArr);
s.close(i);
func.$step = 0;
func.value = void 0;
func.done = true;
return func;
case 0:
func.$step = 0;
func.value = p;
func.done = true;
return func;
case 1:
func.$step = 0;
throw p;
case 2:
return func.$redir(p);
default:
throw new Error("invalid state");
}
}
}
},
i,
_hoisted,
buf,
j,
vlab,
pos,
_j,
k,
sym,
j1,
j2,
id,
_walk = M.generator(),
loop,
_loop,
loop1,
loop2,
r,
p;
_walk.step = walk_1;
_walk.$step = 3;
return _walk;
function walk_1(p) {
var a, b, c, d;
for (;;) {
switch (_walk.$cur = _walk.$step) {
case 3:
selfSym = root.selfSym = !noThis && Scope.newSym("self");
loop = M.iterator(sw);
_walk.$step = 4;
_walk.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
if (i.enter) {
switch (i.type) {
case _core.Tag.BlockStatement:
_walk.$step = 5;
_walk.value = i;
return _walk;
case _core.Tag.ThisExpression:
if (!selfSym) {
_walk.$step = 1;
_walk.$step = 1;
p = new Error("`this` is not supported with `noClosThis:true`");
continue;
} else {
a = s.tok(i.pos, _core.Tag.Identifier, {
sym: selfSym
});
_walk.$step = 9;
_walk.value = a;
return _walk;
}
case _core.Tag.VariableDeclaration:
vlab = s.label();
pos = i.pos;
if (i.pos === _core.Tag.left) {
_j = s.take();
k = s.take();
b = s.tok(i.pos, _core.Tag.Identifier, {
sym: s.curLev().value.sym
});
_walk.$step = 10;
_walk.value = b;
return _walk;
} else {
if (pos === _core.Tag.push) {
c = s.enter(_core.Tag.push, _core.Tag.ExpressionStatement);
_walk.$step = 11;
_walk.value = c;
return _walk;
} else {
_walk.$step = 12;
_walk.$step = 12;
continue;
}
}
case _core.Tag.FunctionDeclaration:
blockHoisted.push(Kit.toArray(function (i) {
var ctx = M.generator(),
r,
p;
ctx.step = f_1;
ctx.$step = 3;
return ctx;
function f_1(p) {
var a;
switch (ctx.$cur = ctx.$step) {
case 3:
a = s.template(i.pos, "$I = $_", s.curLev().value.sym);
ctx.$step = 4;
return ctx.$delegate(a);
case 4:
a = func(i, _core.Tag.right);
ctx.$step = 5;
return ctx.$delegate(a);
case 5:
a = s.leave();
ctx.$step = 6;
return ctx.$delegate(a);
case 6:
ctx.$step = 0;
ctx.value = void 0;
ctx.done = true;
return ctx;
case 0:
ctx.$step = 0;
ctx.value = p;
ctx.done = true;
return ctx;
case 1:
ctx.$step = 0;
throw p;
case 2:
return ctx.$redir(p);
default:
throw new Error("invalid state");
}
}
}(i)));
_walk.$step = 4;
_walk.$step = 4;
continue;
case _core.Tag.FunctionExpression:
d = func(i, i.pos);
_walk.$step = 4;
return _walk.$delegate(d);
default:
_walk.$step = 21;
_walk.$step = 21;
continue;
}
} else {
_walk.$step = 21;
_walk.$step = 21;
continue;
}
} else {
_walk.$step = 0;
_walk.value = void 0;
_walk.done = true;
return _walk;
}
case 5:
a = s.peelTo(_core.Tag.body);
_walk.$step = 6;
return _walk.$delegate(a);
case 6:
_hoisted = [];
buf = Kit.toArray(walk(s.sub(), root, _hoisted));
_loop = M.iterator(_hoisted);
_walk.$step = 7;
_walk.$step = 7;
continue;
case 7:
if (!(_loop = _loop.step()).done) {
j = _loop.value;
_walk.$step = 7;
return _walk.$delegate(j);
} else {
_walk.$step = 8;
return _walk.$delegate(buf);
}
case 8:
a = s.leave();
_walk.$step = 4;
return _walk.$delegate(a);
case 9:
s.close(i);
_walk.$step = 4;
_walk.$step = 4;
continue;
case 10:
Kit.skip(s.sub());
s.close(k);
s.close(_j);
s.close(i);
_walk.$step = 4;
_walk.$step = 4;
continue;
case 11:
pos = _core.Tag.expression;
_walk.$step = 12;
_walk.$step = 12;
continue;
case 12:
sym = void 0;
a = s.enter(pos, _core.Tag.SequenceExpression);
_walk.$step = 13;
_walk.value = a;
return _walk;
case 13:
a = s.enter(_core.Tag.expressions, _core.Tag.Array);
_walk.$step = 14;
_walk.value = a;
return _walk;
case 14:
loop1 = M.iterator(s.sub());
_walk.$step = 15;
_walk.$step = 15;
continue;
case 15:
if (!(loop1 = loop1.step()).done) {
j1 = loop1.value;
if (j1.enter) {
loop2 = M.iterator(s.sub());
_walk.$step = 16;
_walk.$step = 16;
continue;
} else {
_walk.$step = 15;
_walk.$step = 15;
continue;
}
} else {
a = vlab();
_walk.$step = 20;
return _walk.$delegate(a);
}
case 16:
if (!(loop2 = loop2.step()).done) {
j2 = loop2.value;
id = Kit.toArray(s.one());
sym = id[0].value.sym;
if (s.curLev() != null) {
a = s.template(_core.Tag.push, "=$I = $_", sym);
_walk.$step = 17;
return _walk.$delegate(a);
} else {
_walk.$step = 19;
_walk.$step = 19;
continue;
}
} else {
_walk.$step = 15;
_walk.$step = 15;
continue;
}
case 17:
a = Kit.reposOne(walk(s.one(), root, blockHoisted), _core.Tag.right);
_walk.$step = 18;
return _walk.$delegate(a);
case 18:
a = s.leave();
_walk.$step = 19;
return _walk.$delegate(a);
case 19:
s.close(j2);
_walk.$step = 16;
_walk.$step = 16;
continue;
case 20:
s.close(i);
_walk.$step = 4;
_walk.$step = 4;
continue;
case 21:
_walk.$step = 4;
_walk.value = i;
return _walk;
case 0:
_walk.$step = 0;
_walk.value = p;
_walk.done = true;
return _walk;
case 1:
_walk.$step = 0;
throw p;
case 2:
return _walk.$redir(p);
default:
throw new Error("invalid state");
}
}
}
},
obj = function _obj(fun, sym) {
var lab,
copies,
j,
_sym,
_j,
copySym,
obj = M.generator(),
loop,
_loop,
r,
p;
obj.step = obj_1;
obj.$step = 3;
return obj;
function obj_1(p) {
var a, b;
for (;;) {
switch (obj.$cur = obj.$step) {
case 3:
lab = s.label();
a = s.template(_core.Tag.push, "*function $1($_){$_} $2($1, $_)", sym, closureSym);
obj.$step = 4;
return obj.$delegate(a);
case 4:
copies = [];
loop = M.iterator(fun.closDeps);
obj.$step = 5;
obj.$step = 5;
continue;
case 5:
if (!(loop = loop.step()).done) {
j = loop.value;
_sym = Scope.newSym(j.closSym.orig);
copies.push(_sym);
_sym.copyOf = j.closSym;
a = s.tok(_core.Tag.push, _core.Tag.Identifier, {
sym: _sym
});
obj.$step = 5;
obj.value = a;
return obj;
} else {
b = s.refocus();
obj.$step = 6;
return obj.$delegate(b);
}
case 6:
_loop = M.iterator(fun.closDeps);
obj.$step = 7;
obj.$step = 7;
continue;
case 7:
if (!(_loop = _loop.step()).done) {
_j = _loop.value;
copySym = copies.shift();
a = s.template(_core.Tag.push, `$E = $I`, copySym);
obj.$step = 8;
return obj.$delegate(a);
} else {
b = s.refocus();
obj.$step = 10;
return obj.$delegate(b);
}
case 8:
a = s.toks(_core.Tag.left, `=this.${dpref}${_j.closSym.name}${dpost}`, {
origSym: _j.closSym,
copySym
});
obj.$step = 9;
return obj.$delegate(a);
case 9:
a = s.leave();
obj.$step = 7;
return obj.$delegate(a);
case 10:
a = s.enter(_core.Tag.push, _core.Tag.FunctionExpression, fun);
obj.$step = 11;
obj.value = a;
return obj;
case 11:
if (s.cur().pos === _core.Tag.id) {
Kit.skip(s.one());
}
if (fun.node) {
fun.node.id = null;
}
a = walk(s.sub(), fun);
obj.$step = 12;
return obj.$delegate(a);
case 12:
a = lab();
obj.$step = 13;
return obj.$delegate(a);
case 13:
obj.$step = 0;
obj.value = void 0;
obj.done = true;
return obj;
case 0:
obj.$step = 0;
obj.value = p;
obj.done = true;
return obj;
case 1:
obj.$step = 0;
throw p;
case 2:
return obj.$redir(p);
default:
throw new Error("invalid state");
}
}
}
},
buf,
i,
functToObj = M.generator(),
loop,
r,
p;
functToObj.step = functToObj_1;
functToObj.$step = 3;
return functToObj;
function functToObj_1(p) {
var a;
for (;;) {
switch (functToObj.$cur = functToObj.$step) {
case 3:
s = Kit.auto(si);
hoisted = [];
closureSym = s.first.value.closureSym;
dpref = s.opts.closDepPrefix || "";
dpost = s.opts.closDepPostfix || "";
noThis = s.opts.noClosThis;
a = Kit.fileBody(s);
functToObj.$step = 4;
return functToObj.$delegate(a);
case 4:
buf = Kit.toArray(walk(s, s.first.value, hoisted));
loop = M.iterator(hoisted);
functToObj.$step = 5;
functToObj.$step = 5;
continue;
case 5:
if (!(loop = loop.step()).done) {
i = loop.value;
functToObj.$step = 5;
return functToObj.$delegate(i);
} else {
functToObj.$step = 6;
return functToObj.$delegate(buf);
}
case 6:
functToObj.$step = 7;
return functToObj.$delegate(s);
case 7:
functToObj.$step = 0;
functToObj.value = void 0;
functToObj.done = true;
return functToObj;
case 0:
functToObj.$step = 0;
functToObj.value = p;
functToObj.done = true;
return functToObj;
case 1:
functToObj.$step = 0;
throw p;
case 2:
return functToObj.$redir(p);
default:
throw new Error("invalid state");
}
}
}
}
function injectLocObjs(si) {
var s,
i,
injectLocObjs = M.generator(),
loop,
r,
p;
injectLocObjs.step = injectLocObjs_1;
injectLocObjs.$step = 3;
return injectLocObjs;
function injectLocObjs_1(p) {
var a;
for (;;) {
switch (injectLocObjs.$cur = injectLocObjs.$step) {
case 3:
s = Kit.auto(si);
loop = M.iterator(s);
injectLocObjs.$step = 4;
injectLocObjs.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
injectLocObjs.$step = 5;
injectLocObjs.value = i;
return injectLocObjs;
} else {
injectLocObjs.$step = 0;
injectLocObjs.value = void 0;
injectLocObjs.done = true;
return injectLocObjs;
}
case 5:
if (i.enter) {
switch (i.type) {
case _core.Tag.File:
case _core.Tag.FunctionExpression:
case _core.Tag.FunctionDeclaration:
if (i.value.ctxSym && i.value.clDecls.some(i => i.refScopes && i.refScopes.size)) {
a = Kit.fileBody(s);
injectLocObjs.$step = 6;
return injectLocObjs.$delegate(a);
} else {
injectLocObjs.$step = 4;
injectLocObjs.$step = 4;
continue;
}
default:
injectLocObjs.$step = 4;
injectLocObjs.$step = 4;
continue;
}
} else {
injectLocObjs.$step = 4;
injectLocObjs.$step = 4;
continue;
}
case 6:
a = s.toks(_core.Tag.push, `var $I = {}`, i.value.ctxSym);
injectLocObjs.$step = 4;
return injectLocObjs.$delegate(a);
case 0:
injectLocObjs.$step = 0;
injectLocObjs.value = p;
injectLocObjs.done = true;
return injectLocObjs;
case 1:
injectLocObjs.$step = 0;
throw p;
case 2:
return injectLocObjs.$redir(p);
default:
throw new Error("invalid state");
}
}
}
}
function substIds(si) {
var s,
vpref,
vpost,
dpref,
dpost,
emitDecls = function _emitDecls({
clDecls: decls,
argumentsSym,
ctxSym
}) {
var locs,
params,
i,
lab,
sym,
_i,
emitDecls = M.generator(),
loop,
_loop,
loop1,
r,
p;
emitDecls.step = emitDecls_1;
emitDecls.$step = 3;
return emitDecls;
function emitDecls_1(p) {
var a, b;
for (;;) {
switch (emitDecls.$cur = emitDecls.$step) {
case 3:
locs = [];
params = [];
loop = M.iterator(decls);
for (; !(loop = loop.step()).done;) {
i = loop.value;
if (i.param) {
if (i.refScopes) {
params.push(i);
}
} else {
if (!i.refScopes) {
locs.push(i);
}
}
}
a = s.till(i => {
return i.pos === _core.Tag.body && i.type === _core.Tag.Array;
});
emitDecls.$step = 4;
return emitDecls.$delegate(a);
case 4:
lab = s.label();
if (locs.length || argumentsSym) {
a = s.enter(_core.Tag.push, _core.Tag.VariableDeclaration, {
node: {
kind: "var"
}
});
emitDecls.$step = 5;
emitDecls.value = a;
return emitDecls;
} else {
emitDecls.$step = 14;
emitDecls.$step = 14;
continue;
}
case 5:
a = s.enter(_core.Tag.declarations, _core.Tag.Array);
emitDecls.$step = 6;
emitDecls.value = a;
return emitDecls;
case 6:
if (argumentsSym) {
a = s.enter(_core.Tag.push, _core.Tag.VariableDeclarator);
emitDecls.$step = 7;
emitDecls.value = a;
return emitDecls;
} else {
emitDecls.$step = 10;
emitDecls.$step = 10;
continue;
}
case 7:
a = s.tok(_core.Tag.id, _core.Tag.Identifier, {
sym: argumentsSym
});
emitDecls.$step = 8;
emitDecls.value = a;
return emitDecls;
case 8:
a = s.toks(_core.Tag.init, "=Array.from(arguments).slice(1)");
emitDecls.$step = 9;
return emitDecls.$delegate(a);
case 9:
a = s.leave();
emitDecls.$step = 10;
return emitDecls.$delegate(a);
case 10:
_loop = M.iterator(locs);
emitDecls.$step = 11;
emitDecls.$step = 11;
continue;
case 11:
if (!(_loop = _loop.step()).done) {
sym = _loop.value;
a = s.enter(_core.Tag.push, _core.Tag.VariableDeclarator);
emitDecls.$step = 12;
emitDecls.value = a;
return emitDecls;
} else {
b = lab();
emitDecls.$step = 14;
return emitDecls.$delegate(b);
}
case 12:
a = s.tok(_core.Tag.id, _core.Tag.Identifier, {
sym
});
emitDecls.$step = 13;
emitDecls.value = a;
return emitDecls;
case 13:
a = s.leave();
emitDecls.$step = 11;
return emitDecls.$delegate(a);
case 14:
if (params.length) {
a = s.enter(_core.Tag.push, _core.Tag.ExpressionStatement);
emitDecls.$step = 15;
emitDecls.value = a;
return emitDecls;
} else {
emitDecls.$step = 21;
emitDecls.$step = 21;
continue;
}
case 15:
a = s.enter(_core.Tag.expression, _core.Tag.SequenceExpression);
emitDecls.$step = 16;
emitDecls.value = a;
return emitDecls;
case 16:
a = s.enter(_core.Tag.expressions, _core.Tag.Array);
emitDecls.$step = 17;
emitDecls.value = a;
return emitDecls;
case 17:
loop1 = M.iterator(params);
emitDecls.$step = 18;
emitDecls.$step = 18;
continue;
case 18:
if (!(loop1 = loop1.step()).done) {
_i = loop1.value;
a = s.template(_core.Tag.push, `=$E = $I`, {
clParam: _i
}, _i);
emitDecls.$step = 19;
return emitDecls.$delegate(a);
} else {
b = lab();
emitDecls.$step = 21;
return emitDecls.$delegate(b);
}
case 19:
a = s.toks(_core.Tag.left, `=$1.${vpref}${_i.name}${vpost}`, {
origSym: _i
}, ctxSym);
emitDecls.$step = 20;
return emitDecls.$delegate(a);
case 20:
a = s.leave();
emitDecls.$step = 18;
return emitDecls.$delegate(a);
case 21:
emitDecls.$step = 0;
emitDecls.value = void 0;
emitDecls.done = true;
return emitDecls;
case 0:
emitDecls.$step = 0;
emitDecls.value = p;
emitDecls.done = true;
return emitDecls;
case 1:
emitDecls.$step = 0;
throw p;
case 2:
return emitDecls.$redir(p);
default:
throw new Error("invalid state");
}
}
}
},
walk = function walk1(root) {
var i,
sym,
_walk = M.generator(),
loop,
r,
p;
_walk.step = walk_1;
_walk.$step = 3;
return _walk;
function walk_1(p) {
var a, b;
for (;;) {
switch (_walk.$cur = _walk.$step) {
case 3:
loop = M.iterator(s.sub());
_walk.$step = 4;
_walk.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
if (i.enter) {
switch (i.type) {
case _core.Tag.FunctionExpression:
_walk.$step = 5;
_walk.value = i;
return _walk;
case _core.Tag.File:
_walk.$step = 9;
_walk.value = i;
return _walk;
case _core.Tag.Identifier:
({
sym
} = i.value);
if (sym) {
if (sym === Scope.argumentsSym) {
i.value.sym = root.argumentsSym;
_walk.$step = 13;
_walk.$step = 13;
continue;
} else {
if (sym.refScopes) {
if (root === sym.declScope) {
a = s.toks(i.pos, `=$I.${vpref}${sym.name}${vpost}`, {
origSym: sym
}, root.ctxSym);
_walk.$step = 12;
return _walk.$delegate(a);
} else {
b = s.template(i.pos, `=$E.${vpref}${sym.name}${vpost}`, {
origSym: sym
});
_walk.$step = 10;
return _walk.$delegate(b);
}
} else {
_walk.$step = 13;
_walk.$step = 13;
continue;
}
}
} else {
_walk.$step = 13;
_walk.$step = 13;
continue;
}
default:
_walk.$step = 13;
_walk.$step = 13;
continue;
}
} else {
_walk.$step = 13;
_walk.$step = 13;
continue;
}
} else {
_walk.$step = 0;
_walk.value = void 0;
_walk.done = true;
return _walk;
}
case 5:
a = s.till(i => {
return i.pos === _core.Tag.params;
});
_walk.$step = 6;
return _walk.$delegate(a);
case 6:
if (i.value.selfSym) {
a = s.tok(_core.Tag.push, _core.Tag.Identifier, {
sym: i.value.selfSym
});
_walk.$step = 7;
_walk.value = a;
return _walk;
} else {
_walk.$step = 7;
_walk.$step = 7;
continue;
}
case 7:
a = emitDecls(i.value);
_walk.$step = 8;
return _walk.$delegate(a);
case 8:
a = walk(i.value);
_walk.$step = 4;
return _walk.$delegate(a);
case 9:
a = emitDecls(i.value);
_walk.$step = 4;
return _walk.$delegate(a);
case 10:
a = s.toks(_core.Tag.object, `=this.${dpref}${sym.declScope.closSym.orig}${dpost}`, {
origSym: sym.declScope.closSym
});
_walk.$step = 11;
return _walk.$delegate(a);
case 11:
a = s.leave();
_walk.$step = 12;
return _walk.$delegate(a);
case 12:
s.close(i);
_walk.$step = 4;
_walk.$step = 4;
continue;
case 13:
_walk.$step = 4;
_walk.value = i;
return _walk;
case 0:
_walk.$step = 0;
_walk.value = p;
_walk.done = true;
return _walk;
case 1:
_walk.$step = 0;
throw p;
case 2:
return _walk.$redir(p);
default:
throw new Error("invalid state");
}
}
}
};
s = Kit.auto(si);
vpref = s.opts.closVarPrefix || "";
vpost = s.opts.closVarPostfix || "";
dpref = s.opts.closDepPrefix || "";
dpost = s.opts.closDepPostfix || "";
return walk(s.first.value);
}
var _default = exports.default = Kit.pipe(Scope.prepare, RT.init, calcClosCapt, replaceCalls, functToObj, Kit.toArray, substIds, injectLocObjs, RT.inline, Scope.resolve);