@effectful/transducers-loose
Version:
@effectful/transducers built with faster generators
1,939 lines (1,908 loc) • 112 kB
JavaScript
"use strict";
exports.__esModule = true;
var _exportNames = {
optsScope: true,
optsScopeLift: true,
setOpts: true,
getOpts: true,
parse: true,
toks: true,
skip: true,
setType: true,
setPos: true,
repos: true,
reposOne: true,
reposOneArr: true,
Subst: true,
completeSubst: true,
toArray: true,
result: true,
tillLevel: true,
toBlockBody: true,
inBlockBody: true,
fileBody: true,
hasAnnot: true,
clone: true,
till: true,
find: true,
Opts: true,
UpdateOpts: true,
concat: true,
prepend: true,
share: true,
wrap: true,
stage: true,
checkpointLazy: true,
checkpoint: true,
babelBridge: true,
babelPreset: true,
babelPlugin: true,
transform: true,
tee: true,
makeExpr: true,
makeStmt: true,
makeExprPass: true,
removeEmptyBlocks: true,
adjustFieldType: true,
adjustFieldTypeSimple: true,
la: true,
select: true,
enableIf: true,
packed: true,
pack: true,
unpack: true,
cleanEmptyExprs: true,
time: true,
timeEnd: true,
Wrapper: true,
tillVal: true,
single: true,
auto: true
};
exports.UpdateOpts = exports.Subst = exports.Opts = void 0;
exports.Wrapper = Wrapper;
exports.adjustFieldTypeSimple = exports.adjustFieldType = void 0;
exports.auto = auto;
exports.babelBridge = void 0;
exports.babelPlugin = babelPlugin;
exports.babelPreset = babelPreset;
exports.cleanEmptyExprs = exports.checkpointLazy = exports.checkpoint = void 0;
exports.clone = clone;
exports.completeSubst = completeSubst;
exports.concat = concat;
exports.enableIf = void 0;
exports.fileBody = fileBody;
exports.find = void 0;
exports.getOpts = getOpts;
exports.hasAnnot = hasAnnot;
exports.inBlockBody = inBlockBody;
exports.la = la;
exports.makeExpr = void 0;
exports.makeExprPass = makeExprPass;
exports.makeStmt = void 0;
exports.optsScope = optsScope;
exports.optsScopeLift = optsScopeLift;
exports.packed = exports.pack = void 0;
exports.parse = parse;
exports.prepend = prepend;
exports.removeEmptyBlocks = removeEmptyBlocks;
exports.repos = repos;
exports.reposOne = reposOne;
exports.reposOneArr = reposOneArr;
exports.result = result;
exports.select = void 0;
exports.setOpts = setOpts;
exports.setPos = setPos;
exports.setType = setType;
exports.share = share;
exports.single = single;
exports.skip = skip;
exports.stage = stage;
exports.tee = tee;
exports.till = till;
exports.tillLevel = tillLevel;
exports.tillVal = tillVal;
exports.timeEnd = exports.time = void 0;
exports.toArray = toArray;
exports.toBlockBody = toBlockBody;
exports.toks = toks;
exports.transform = void 0;
exports.unpack = unpack;
exports.wrap = void 0;
var _core = require("./core");
var _combinators = require("./v2/combinators");
Object.keys(_combinators).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _combinators[key]) return;
exports[key] = _combinators[key];
});
var T = require("@babel/types");
var _parser = require("@babel/parser");
var M = require("@effectful/es-rt/opts/loose");
const BROWSER_DEBUG = typeof window !== "undefined" && window.chrome || process.env.EFFECTFUL_DEBUG;
let _opts = {};
let leanWrap;
function LeanIterator(iter) {
this.value = void 0;
this.done = false;
this.iter = iter[Symbol.iterator]();
}
LeanIterator.prototype[Symbol.iterator] = function () {
return this.iter;
};
LeanIterator.prototype.step = function step(v) {
var next = this.iter.next(v);
this.done = next.done;
this.value = next.value;
return this;
};
if (Symbol.effectfulIterator) {
leanWrap = function leanWrap(cont) {
return cont[Symbol.effectfulIterator] ? cont[Symbol.effectfulIterator]() : new LeanIterator(cont);
};
} else {
leanWrap = function leanWrap(cont) {
return new LeanIterator(cont);
};
}
/** runs `fun` and reset global options after its exit */
function optsScope(fun) {
var save;
save = _opts;
try {
return fun();
} finally {
_opts = save;
}
}
/** returns function calling `fun` and reseting global options after exit */
function optsScopeLift(fun) {
return function () {
var save;
save = _opts;
try {
return fun.apply(this, arguments);
} finally {
_opts = save;
}
};
}
/** sets global options */
function setOpts(opts) {
_opts = opts;
}
function getOpts() {
return _opts;
}
const memo = new Map();
function parse(jsCode) {
return (0, _parser.parse)(jsCode, {
sourceType: "module",
allowReturnOutsideFunction: true,
plugins: ["dynamicImport"]
});
}
/**
* parses string `s` and outuputs its token stream at `pos`
* following prefixes are supported in the string
* - '^' - module's top level
* - '=' - the string is JS expression
* - '*' - the string is a list of statements
* - '>' - variable declarator
* - otherwise it is considered to be a statement
*
* if in the code in `s` identifier starts with `$` it has special meaning
* if next character is:
* - digit - it will replaces symbol of identifier by `syms`
* at the corresponding position (1 based)
* - `$` - keeps only one `$`
* - `I` - unshifts a symbol from `syms` and replaces the symbol of
* the identifier
*/
function toks(pos, s, ...syms) {
var value,
r,
topLevel,
mod,
js,
b,
body,
_s,
replace = function _replace(s) {
var i,
node,
name,
rest,
replace = M.generator(),
loop,
r,
p;
replace.step = replace_1;
replace.$step = 3;
return replace;
function replace_1(p) {
for (;;) {
switch (replace.$cur = replace.$step) {
case 3:
if (!syms.length) {
replace.$step = 4;
return replace.$delegate(s);
} else {
loop = M.iterator(s);
replace.$step = 5;
replace.$step = 5;
continue;
}
case 4:
replace.$step = 0;
replace.value = s;
replace.done = true;
return replace;
case 5:
if (!(loop = loop.step()).done) {
i = loop.value;
if (i.enter) {
({
node
} = i.value);
node.loc = node.start = node.end = null;
if (i.type === _core.Tag.Identifier && i.value.node.name[0] === "$") {
({
name
} = node);
rest = name.substr(1);
switch (rest[0]) {
case "$":
{
node.name = rest;
break;
}
case "I":
{
i.value.node.name = (i.value.sym = syms.shift()).name;
break;
}
default:
{
if (rest.length && !isNaN(rest)) {
i.value.node.name = (i.value.sym = syms[rest - 1]).name;
}
}
}
}
}
replace.$step = 5;
replace.value = i;
return replace;
} else {
replace.$step = 0;
replace.value = s;
replace.done = true;
return replace;
}
case 0:
replace.$step = 0;
replace.value = p;
replace.done = true;
return replace;
case 1:
replace.$step = 0;
throw p;
case 2:
return replace.$redir(p);
default:
throw new Error("invalid state");
}
}
}
},
i,
toks = M.generator(),
loop,
_r,
p;
toks.step = toks_1;
toks.$step = 3;
return toks;
function toks_1(p) {
var a;
for (;;) {
switch (toks.$cur = toks.$step) {
case 3:
if (Array.isArray(s)) {
a = clone(s);
toks.$step = 4;
return toks.$delegate(a);
} else {
toks.$step = 4;
toks.$step = 4;
continue;
}
case 4:
value = void 0;
if (syms.length && syms[0].name == null) {
value = syms.shift();
}
if (s.substr != null) {
r = memo.get(s);
if (r == null) {
topLevel = false;
if (s[0] === "^") {
s = s.slice(1);
topLevel = true;
}
mod = null;
js = s;
switch (s[0]) {
case "=": // expression
case "*": // list of statements
case ">":
{
// var declarator
mod = s[0];
js = s.slice(1);
}
}
js = topLevel ? js : `function main() { for(;;) {${js}} }`;
b = parse(js);
body = topLevel ? b.program.body : b.program.body[0].body.body[0].body.body;
if (!mod === "*") {}
switch (mod) {
case "=":
{
r = body[0].expression;
break;
}
case ">":
{
_s = body[0].expression;
r = T.variableDeclarator(_s.left, _s.right);
break;
}
case "*":
{
break;
}
default:
{
r = body[0];
}
}
if (mod !== "=" && mod !== ">") {
if (mod === "*") {
r = body;
} else {
r = body[0];
}
}
memo.set(s, r);
}
s = r;
}
if (Array.isArray(s)) {
loop = M.iterator(s);
toks.$step = 5;
toks.$step = 5;
continue;
} else {
a = replace(clone((0, _core.produce)(s, pos, value)));
toks.$step = 6;
return toks.$delegate(a);
}
case 5:
if (!(loop = loop.step()).done) {
i = loop.value;
a = replace(clone((0, _core.produce)(i, pos, value)));
toks.$step = 5;
return toks.$delegate(a);
} else {
toks.$step = 6;
toks.$step = 6;
continue;
}
case 6:
toks.$step = 0;
toks.value = void 0;
toks.done = true;
return toks;
case 0:
toks.$step = 0;
toks.value = p;
toks.done = true;
return toks;
case 1:
toks.$step = 0;
throw p;
case 2:
return toks.$redir(p);
default:
throw new Error("invalid state");
}
}
}
}
/** runs iterable `s` and ignores its output, returns its result */
function skip(s) {
var i, node, babel, next;
i = leanWrap(s).step();
if (i.done) return i.value;
node = i.value.node;
babel = _opts.babel;
if (!babel || _opts.debug || BROWSER_DEBUG) {
for (; !(i = i.step()).done;) {}
} else {
try {
for (; !(i = i.step()).done;) {
next = i.value.node;
if (next && (next._loc || next.loc)) node = next;
}
} catch (e) {
if (!e.esNode) e.esNode = node;
throw e;
}
}
return i.value;
}
/** modifies token replacing its `type` field */
function setType(i, type) {
return {
enter: i.enter,
leave: i.leave,
type,
pos: i.pos,
value: i.value
};
}
/** modifies token replacing its `pos` field */
function setPos(i, pos) {
return {
enter: i.enter,
leave: i.leave,
type: i.type,
pos,
value: i.value
};
}
/** changes position on a first level of Iterable `s` */
function repos(s, pos) {
var i,
level,
v,
repos = M.generator(),
r,
p;
repos.step = repos_1;
repos.$step = 3;
return repos;
function repos_1(p) {
var a;
for (;;) {
switch (repos.$cur = repos.$step) {
case 3:
i = leanWrap(s);
level = 0;
repos.$step = 4;
repos.$step = 4;
continue;
case 4:
if (!(i = i.step()).done) {
v = i.value;
if (v.enter) {
level++;
}
a = level === 1 ? setPos(v, pos) : v;
repos.$step = 5;
repos.value = a;
return repos;
} else {
repos.$step = 0;
repos.value = i.value;
repos.done = true;
return repos;
}
case 5:
if (v.leave) {
level--;
}
repos.$step = 4;
repos.$step = 4;
continue;
case 0:
repos.$step = 0;
repos.value = p;
repos.done = true;
return repos;
case 1:
repos.$step = 0;
throw p;
default:
throw new Error("invalid state");
}
}
}
}
/** probably faster version of `reposOne` if there is only one child */
function reposOne(s, pos) {
var i,
p,
reposOne = M.generator(),
r,
_p;
reposOne.step = reposOne_1;
reposOne.$step = 3;
return reposOne;
function reposOne_1(_p) {
var a;
for (;;) {
switch (reposOne.$cur = reposOne.$step) {
case 3:
i = leanWrap(s).step();
if (i.done) {
reposOne.$step = 0;
reposOne.value = i.value;
reposOne.done = true;
return reposOne;
} else {
p = setPos(i.value, pos);
reposOne.$step = 4;
reposOne.$step = 4;
continue;
}
case 4:
if (!(i = i.step()).done) {
reposOne.$step = 5;
reposOne.value = p;
return reposOne;
} else {
a = setPos(p, pos);
reposOne.$step = 6;
reposOne.value = a;
return reposOne;
}
case 5:
p = i.value;
reposOne.$step = 4;
reposOne.$step = 4;
continue;
case 6:
reposOne.$step = 0;
reposOne.value = i.value;
reposOne.done = true;
return reposOne;
case 0:
reposOne.$step = 0;
reposOne.value = _p;
reposOne.done = true;
return reposOne;
case 1:
reposOne.$step = 0;
throw _p;
default:
throw new Error("invalid state");
}
}
}
}
/** same as `reposOne` but works only for arrays avoiding traversal */
function reposOneArr(arr, pos) {
arr[0] = setPos(arr[0], pos);
arr[arr.length - 1] = setPos(arr[arr.length - 1], pos);
return arr;
}
/** token to mark inner tag position must be changed to this tag postion */
const Subst = exports.Subst = (0, _core.symbol)("Subst", "ctrl");
/** applied `Subst` tokens */
function completeSubst(s) {
var sl,
subst = function subst1(pos) {
var i,
_subst = M.generator(),
loop,
r,
p;
_subst.step = subst_1;
_subst.$step = 3;
return _subst;
function subst_1(p) {
var a, b;
for (;;) {
switch (_subst.$cur = _subst.$step) {
case 3:
loop = M.iterator(sl.sub());
_subst.$step = 4;
_subst.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
if (i.type === Subst) {
if (i.enter) {
a = subst(pos);
_subst.$step = 4;
return _subst.$delegate(a);
} else {
_subst.$step = 4;
_subst.$step = 4;
continue;
}
} else {
b = sl.peel(setPos(i, pos));
_subst.$step = 5;
_subst.value = b;
return _subst;
}
} else {
_subst.$step = 0;
_subst.value = void 0;
_subst.done = true;
return _subst;
}
case 5:
a = walk();
_subst.$step = 6;
return _subst.$delegate(a);
case 6:
a = sl.leave();
_subst.$step = 4;
return _subst.$delegate(a);
case 0:
_subst.$step = 0;
_subst.value = p;
_subst.done = true;
return _subst;
case 1:
_subst.$step = 0;
throw p;
case 2:
return _subst.$redir(p);
default:
throw new Error("invalid state");
}
}
}
},
walk = function _walk() {
var i,
walk = M.generator(),
loop,
r,
p;
walk.step = walk_1;
walk.$step = 3;
return walk;
function walk_1(p) {
var a;
for (;;) {
switch (walk.$cur = walk.$step) {
case 3:
loop = M.iterator(sl.sub());
walk.$step = 4;
walk.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
if (i.type === Subst) {
if (i.enter) {
a = subst(i.pos);
walk.$step = 4;
return walk.$delegate(a);
} else {
walk.$step = 4;
walk.$step = 4;
continue;
}
} else {
walk.$step = 4;
walk.value = i;
return walk;
}
} else {
walk.$step = 0;
walk.value = void 0;
walk.done = true;
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");
}
}
}
},
completeSubst = M.generator(),
r,
p;
completeSubst.step = completeSubst_1;
completeSubst.$step = 3;
return completeSubst;
function completeSubst_1(p) {
var a;
switch (completeSubst.$cur = completeSubst.$step) {
case 3:
sl = auto(s);
a = walk();
completeSubst.$step = 4;
return completeSubst.$delegate(a);
case 4:
completeSubst.$step = 0;
completeSubst.value = void 0;
completeSubst.done = true;
return completeSubst;
case 0:
completeSubst.$step = 0;
completeSubst.value = p;
completeSubst.done = true;
return completeSubst;
case 1:
completeSubst.$step = 0;
throw p;
case 2:
return completeSubst.$redir(p);
default:
throw new Error("invalid state");
}
}
}
/**
* same as `Array.from` but returns `s` if it is already `Array`
*/
function toArray(s) {
if (Array.isArray(s)) return s;
if (s.toArray) return s.toArray();
const res = [];
result(s, res);
return res;
}
/**
* same as `Array.from` but outputs the array into `buf`
* and returns iterable result
*/
function result(s, buf) {
var i, name, babel, msg, node, _i;
i = leanWrap(s).step();
if (i.done) return i.value;
buf.push(i.value);
name = i.value.value && i.value.value.stageName;
babel = _opts.babel;
// for debugging purposes,
// let the debugger catch the exception in browser
if (!babel || _opts.debug || BROWSER_DEBUG) {
for (; !(i = i.step()).done;) {
buf.push(i.value);
}
return i.value;
}
try {
for (; !(i = i.step()).done;) {
buf.push(i.value);
}
} catch (e) {
if (e.esNode) throw e;
msg = e.origMessage = e.origMessage || e.message;
if (name) msg += ` during ${name}`;
node = e.esNode || i && i.value.node;
// || si._last
if (!node || !node.loc && !node._loc) {
msg += " (the position is approximated)";
var loop = M.iterator((0, _combinators.reverse)(buf));
for (; !(loop = loop.step()).done;) {
_i = loop.value;
node = _i.value.node;
if (node && (node.loc || node._loc)) {
e.esNode = node;
break;
}
}
} else e.esNode = node;
e.message = msg;
throw e;
}
return i.value;
}
/**
* values until leaving specified level
*/
function tillLevel(level, s) {
var i,
tillLevel = M.generator(),
loop,
r,
p;
tillLevel.step = tillLevel_1;
tillLevel.$step = 3;
return tillLevel;
function tillLevel_1(p) {
for (;;) {
switch (tillLevel.$cur = tillLevel.$step) {
case 3:
loop = M.iterator(s);
tillLevel.$step = 4;
tillLevel.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
tillLevel.$step = 5;
tillLevel.value = i;
return tillLevel;
} else {
tillLevel.$step = 0;
tillLevel.value = void 0;
tillLevel.done = true;
return tillLevel;
}
case 5:
if (i.leave && s.level === level) {
tillLevel.$step = 0;
tillLevel.value = r;
tillLevel.done = true;
return tillLevel;
} else {
tillLevel.$step = 4;
tillLevel.$step = 4;
continue;
}
case 0:
tillLevel.$step = 0;
tillLevel.value = p;
tillLevel.done = true;
return tillLevel;
case 1:
tillLevel.$step = 0;
throw p;
default:
throw new Error("invalid state");
}
}
}
}
/** to be removed */
function toBlockBody(s) {
var lab,
i,
toBlockBody = M.generator(),
r,
p;
toBlockBody.step = toBlockBody_1;
toBlockBody.$step = 3;
return toBlockBody;
function toBlockBody_1(p) {
var a;
switch (toBlockBody.$cur = toBlockBody.$step) {
case 3:
lab = s.label();
i = s.cur();
if (i.type === _core.Tag.BlockStatement) {
s.peel();
skip(s.peelTo(_core.Tag.body));
toBlockBody.$step = 0;
toBlockBody.value = function () {
var ctx = M.generator(),
r,
p;
ctx.step = f_1;
ctx.$step = 3;
return ctx;
function f_1(p) {
switch (ctx.$cur = ctx.$step) {
case 3:
skip(lab());
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;
default:
throw new Error("invalid state");
}
}
};
toBlockBody.done = true;
return toBlockBody;
} else {
a = s.enter(_core.Tag.push, Subst);
toBlockBody.$step = 4;
toBlockBody.value = a;
return toBlockBody;
}
case 4:
toBlockBody.$step = 0;
toBlockBody.value = lab;
toBlockBody.done = true;
return toBlockBody;
case 0:
toBlockBody.$step = 0;
toBlockBody.value = p;
toBlockBody.done = true;
return toBlockBody;
case 1:
toBlockBody.$step = 0;
throw p;
default:
throw new Error("invalid state");
}
}
}
/** to be removed */
function inBlockBody(s, inner) {
var lab,
i,
inBlockBody = M.generator(),
r,
p;
inBlockBody.step = inBlockBody_1;
inBlockBody.$step = 3;
return inBlockBody;
function inBlockBody_1(p) {
var a;
for (;;) {
switch (inBlockBody.$cur = inBlockBody.$step) {
case 3:
lab = s.label();
i = s.cur();
if (i.type !== _core.Tag.BlockStatement) {
a = s.enter(_core.Tag.push, Subst);
inBlockBody.$step = 4;
inBlockBody.value = a;
return inBlockBody;
} else {
s.peel();
skip(s.peelTo(_core.Tag.body));
inBlockBody.$step = 6;
return inBlockBody.$delegate(inner);
}
case 4:
inBlockBody.$step = 5;
return inBlockBody.$delegate(inner);
case 5:
a = lab();
inBlockBody.$step = 7;
return inBlockBody.$delegate(a);
case 6:
skip(lab());
inBlockBody.$step = 7;
inBlockBody.$step = 7;
continue;
case 7:
inBlockBody.$step = 0;
inBlockBody.value = void 0;
inBlockBody.done = true;
return inBlockBody;
case 0:
inBlockBody.$step = 0;
inBlockBody.value = p;
inBlockBody.done = true;
return inBlockBody;
case 1:
inBlockBody.$step = 0;
throw p;
case 2:
return inBlockBody.$redir(p);
default:
throw new Error("invalid state");
}
}
}
}
/** copies everything until first not-import statement */
function fileBody(s) {
var fileBody = M.generator(),
r,
p;
fileBody.step = fileBody_1;
fileBody.$step = 3;
return fileBody;
function fileBody_1(p) {
var a;
switch (fileBody.$cur = fileBody.$step) {
case 3:
a = s.till(i => {
return i.pos === _core.Tag.body && i.type === _core.Tag.Array;
});
fileBody.$step = 4;
return fileBody.$delegate(a);
case 4:
if (s.cur().type === _core.Tag.ImportDeclaration) {
a = s.one();
fileBody.$step = 4;
return fileBody.$delegate(a);
} else {
fileBody.$step = 0;
fileBody.value = void 0;
fileBody.done = true;
return fileBody;
}
case 0:
fileBody.$step = 0;
fileBody.value = p;
fileBody.done = true;
return fileBody;
case 1:
fileBody.$step = 0;
throw p;
case 2:
return fileBody.$redir(p);
default:
throw new Error("invalid state");
}
}
}
function hasAnnot(node, name) {
return node.leadingComments && node.leadingComments.length && node.leadingComments.find(v => v.value.trim() === name) !== undefined;
}
/** clones all tags and their `value` and `value.node` fields */
function clone(s) {
var stack,
i,
value,
isArray,
clone = M.generator(),
loop,
r,
p;
clone.step = clone_1;
clone.$step = 3;
return clone;
function clone_1(p) {
for (;;) {
switch (clone.$cur = clone.$step) {
case 3:
stack = [];
loop = M.iterator(s);
clone.$step = 4;
clone.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
value = null;
if (i.enter) {
stack.push(value = Object.assign({}, i.value));
isArray = value.isArray = i.type === _core.Tag.Array;
if (isArray) {
value.node = value.node.concat();
} else {
if (value.node != null && _core.Tag[i.type] != null) {
value.node = Object.assign({}, value.node);
if (value.node.leadingComments != null) {
value.node.leadingComments = value.node.leadingComments.concat();
}
if (value.node.trealingComments != null) {
value.node.trealingComments = value.node.trealingComments.concat();
}
}
}
}
if (i.leave) {
value = stack.pop();
}
clone.$step = 4;
clone.value = {
enter: i.enter,
leave: i.leave,
type: i.type,
pos: i.pos,
value
};
return clone;
} else {
clone.$step = 0;
clone.value = void 0;
clone.done = true;
return clone;
}
case 0:
clone.$step = 0;
clone.value = p;
clone.done = true;
return clone;
case 1:
clone.$step = 0;
throw p;
default:
throw new Error("invalid state");
}
}
}
}
/**
* leaves all items un-amended until (and including) an item where
* `pred` is true
*/
function till(pred, s) {
var i,
till = M.generator(),
loop,
r,
p;
till.step = till_1;
till.$step = 3;
return till;
function till_1(p) {
for (;;) {
switch (till.$cur = till.$step) {
case 3:
loop = M.iterator(s);
till.$step = 4;
till.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
till.$step = 5;
till.value = i;
return till;
} else {
till.$step = 0;
till.value = null;
till.done = true;
return till;
}
case 5:
if (pred(i)) {
till.$step = 0;
till.value = i;
till.done = true;
return till;
} else {
till.$step = 4;
till.$step = 4;
continue;
}
case 0:
till.$step = 0;
till.value = p;
till.done = true;
return till;
case 1:
till.$step = 0;
throw p;
default:
throw new Error("invalid state");
}
}
}
}
/**
* copies the stream until `pred` returns true for next token
* the found token is not consumed
* returns true if found
*/
const find = exports.find = (0, _combinators.curry)(function find(pred, s) {
var i,
_find = M.generator(),
loop,
r,
p;
_find.step = find_1;
_find.$step = 3;
return _find;
function find_1(p) {
for (;;) {
switch (_find.$cur = _find.$step) {
case 3:
if (pred(s.cur())) {
_find.$step = 0;
_find.value = true;
_find.done = true;
return _find;
} else {
loop = M.iterator(s);
_find.$step = 4;
_find.$step = 4;
continue;
}
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
_find.$step = 5;
_find.value = i;
return _find;
} else {
_find.$step = 0;
_find.value = false;
_find.done = true;
return _find;
}
case 5:
if (pred(s.cur())) {
_find.$step = 0;
_find.value = true;
_find.done = true;
return _find;
} else {
_find.$step = 4;
_find.$step = 4;
continue;
}
case 0:
_find.$step = 0;
_find.value = p;
_find.done = true;
return _find;
case 1:
_find.$step = 0;
throw p;
default:
throw new Error("invalid state");
}
}
}
});
const Opts = exports.Opts = (0, _core.symbol)("Options");
const UpdateOpts = exports.UpdateOpts = (0, _core.symbol)("MergeOptions");
/** concatenates iterables in arguments into a single iterable */
function concat(...args) {
var i,
concat = M.generator(),
loop,
r,
p;
concat.step = concat_1;
concat.$step = 3;
return concat;
function concat_1(p) {
for (;;) {
switch (concat.$cur = concat.$step) {
case 3:
loop = M.iterator(args);
concat.$step = 4;
concat.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
concat.$step = 4;
return concat.$delegate(i);
} else {
concat.$step = 0;
concat.value = void 0;
concat.done = true;
return concat;
}
case 0:
concat.$step = 0;
concat.value = p;
concat.done = true;
return concat;
case 1:
concat.$step = 0;
throw p;
case 2:
return concat.$redir(p);
default:
throw new Error("invalid state");
}
}
}
}
/** like `concat` but with its last argument application curried */
function prepend(...args) {
return function (s) {
var i,
ctx = M.generator(),
loop,
r,
p;
ctx.step = f_1;
ctx.$step = 3;
return ctx;
function f_1(p) {
for (;;) {
switch (ctx.$cur = ctx.$step) {
case 3:
loop = M.iterator(args);
ctx.$step = 4;
ctx.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
ctx.$step = 4;
return ctx.$delegate(i);
} else {
ctx.$step = 5;
return ctx.$delegate(s);
}
case 5:
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");
}
}
}
};
}
/** shares single iterator between several uses */
function share(s) {
var i;
i = leanWrap(s);
return {
[Symbol.iterator]() {
return this;
},
next(v) {
i = i.step(v);
return {
value: i.value,
done: i.done
};
},
take(v) {
i = i.step(v);
return i.done ? null : i.value;
}
};
}
/** to be removed */
const wrap = exports.wrap = (0, _combinators.curry)(function wrap(name, f, s) {
var si,
iter,
i,
j,
e,
babel,
msg,
node,
_i,
_wrap = M.generator(),
loop,
ex,
r,
p;
_wrap.step = wrap_1;
_wrap.$err = wrap_err;
_wrap.$step = 3;
return _wrap;
function wrap_1(p) {
for (;;) {
switch (_wrap.$cur = _wrap.$step) {
case 3:
si = auto(s);
iter = f(si)[Symbol.iterator]();
i = void 0;
_wrap.$step = 4;
_wrap.$step = 4;
continue;
case 4:
j = void 0;
_wrap.$step = 5;
_wrap.$step = 5;
continue;
case 5:
if (!(j = iter.next()).done) {
i = j.value;
_wrap.$step = 5;
_wrap.value = i;
return _wrap;
} else {
_wrap.$step = 0;
_wrap.value = j.value;
_wrap.done = true;
return _wrap;
}
case 6:
e = ex;
babel = _opts.babel;
if (babel != null) {
msg = `${e.message} during ${name}`;
node = e.esNode || i && i.value.node;
// || si._last
if (!node || !node.loc && !node._loc) {
loop = M.iterator(si);
_wrap.$step = 7;
_wrap.$step = 7;
continue;
} else {
_wrap.$step = 8;
_wrap.$step = 8;
continue;
}
} else {
_wrap.$step = 1;
_wrap.$step = 1;
p = e;
continue;
}
case 7:
if (!(loop = loop.step()).done) {
_i = loop.value;
node = _i.value.node;
if (node && (node.loc || node._loc)) {
_wrap.$step = 1;
_wrap.$step = 1;
p = babel.root.hub.file.buildCodeFrameError(node, msg);
continue;
} else {
_wrap.$step = 7;
_wrap.$step = 7;
continue;
}
} else {
node = babel.root.node;
e.esNode = node;
_wrap.$step = 8;
_wrap.$step = 8;
continue;
}
case 8:
_wrap.$step = 1;
_wrap.$step = 1;
p = babel.root.hub.file.buildCodeFrameError(node, msg);
continue;
case 0:
_wrap.$step = 0;
_wrap.value = p;
_wrap.done = true;
return _wrap;
case 1:
_wrap.$step = 0;
throw p;
case 9:
_wrap.$step = 6;
ex = p;
_wrap.$step = 6;
continue;
default:
throw new Error("invalid state");
}
}
}
});
/** marks all next exceptions with `name`, eagerly consumes the former stage */
function stage(name, s) {
var res;
res = toArray(s);
res[0].value.stageName = name;
return res;
}
/** to be removed */
const checkpointLazy = exports.checkpointLazy = (0, _combinators.curry)(function checkpointLazy(name, s) {
var babel,
iter,
last,
i,
j,
e,
node,
_checkpointLazy = M.generator(),
ex,
r,
p;
_checkpointLazy.step = checkpointLazy_1;
_checkpointLazy.$err = checkpointLazy_err;
_checkpointLazy.$step = 3;
return _checkpointLazy;
function checkpointLazy_1(p) {
for (;;) {
switch (_checkpointLazy.$cur = _checkpointLazy.$step) {
case 3:
babel = _opts.babel;
iter = s[Symbol.iterator]();
last = void 0;
i = void 0;
_checkpointLazy.$step = 4;
_checkpointLazy.$step = 4;
continue;
case 4:
j = iter.next();
i = j.value;
if (j.done) {
_checkpointLazy.$step = 0;
_checkpointLazy.value = i;
_checkpointLazy.done = true;
return _checkpointLazy;
} else {
if (i.enter && i.value.node != null && i.value.node.loc != null) {
last = i.value.node;
}
_checkpointLazy.$step = 4;
_checkpointLazy.value = i;
return _checkpointLazy;
}
case 5:
e = ex;
if (babel != null) {
node = e.esNode || i && i.value.node || last || babel.root.node;
_checkpointLazy.$step = 1;
_checkpointLazy.$step = 1;
p = babel.root.hub.file.buildCodeFrameError(node, `${e.message} during ${name}`);
continue;
} else {
_checkpointLazy.$step = 1;
_checkpointLazy.$step = 1;
p = e;
continue;
}
case 0:
_checkpointLazy.$step = 0;
_checkpointLazy.value = p;
_checkpointLazy.done = true;
return _checkpointLazy;
case 1:
_checkpointLazy.$step = 0;
throw p;
case 6:
_checkpointLazy.$step = 5;
ex = p;
_checkpointLazy.$step = 5;
continue;
default:
throw new Error("invalid state");
}
}
}
});
/** to be removed */
const checkpoint = exports.checkpoint = (0, _combinators.curry)(function (name, s) {
return [...checkpointLazy(name, s)];
});
/**
* babel plugin visitor methods, typically to be applied only to Program node
*/
const babelBridge = exports.babelBridge = (0, _combinators.curry)(function babelBridge(pass, path, state) {
var optSave;
optSave = _opts;
_opts = Object.assign({
args: Object.assign({}, state.opts),
file: Object.assign(state.file.opts),
babel: {
root: path,
state
}
}, _opts);
if (_opts.debug || BROWSER_DEBUG) {
pass((0, _core.produce)(state.file.ast));
} else {
try {
pass((0, _core.produce)(state.file.ast));
} catch (e) {
if (_opts.verbose) console.log(e);
throw path.hub.file.buildCodeFrameError(e.esNode, e.message);
}
}
_opts = optSave;
});
function babelPreset(pass) {
return {
plugins: [function () {
return {
visitor: {
Program(path, state) {
path.skip();
babelBridge(i => (0, _core.consume)(pass(i)), path, state);
}
}
};
}]
};
}
function babelPlugin(pass) {
return function (_, opts) {
return {
visitor: {
Program(path, state) {
_opts.pluginOpts = opts;
babelBridge(function (i) {
(0, _core.consume)(pass(i));
}, path, state);
path.skip();
}
}
};
};
}
const transform = exports.transform = (0, _combinators.curryN)(2, function transform(pass, ast, opts) {
var optSave;
optSave = _opts;
Object.assign(_opts = {}, {
args: {},
file: {},
babel: false
}, opts);
try {
return (0, _core.consume)(pass((0, _core.produce)(ast))).top;
} finally {
_opts = optSave;
}
});
/**
* copies input stream to output and returns it as array
*/
function tee(s, buf) {
var i,
tee = M.generator(),
loop,
r,
p;
tee.step = tee_1;
tee.$step = 3;
return tee;
function tee_1(p) {
for (;;) {
switch (tee.$cur = tee.$step) {
case 3:
if (buf == null) {
buf = [];
}
loop = M.iterator(s);
tee.$step = 4;
tee.$step = 4;
continue;
case 4:
if (!(loop = loop.step()).done) {
i = loop.value;
tee.$step = 5;
tee.value = i;
return tee;
} else {
tee.$step = 0;
tee.value = buf;
tee.done = true;
return tee;
}
case 5:
buf.push(i);
tee.$step = 4;
tee.$step = 4;
continue;
case 0:
tee.$step = 0;
tee.value = p;
tee.done = true;
return tee;
case 1:
tee.$step = 0;
throw p;
default:
throw new Error("invalid state");
}
}
}
}
const makeExpr = exports.makeExpr = (0, _core.symbol)("makeExpr");
const makeStmt = exports.makeStmt = (0, _core.symbol)("makeStmt");
function makeExprPass(s) {
var subst = function _subst(pos) {
var t,
subst = M.generator(),
r,
p;
subst.step = subst_1;
subst.$step = 3;
return subst;
function subst_1(p) {
var a;
switch (subst.$cur = subst.$step) {
case 3:
t = s.peel();
a = s.enter(pos, t.type, t.value);
subst.$step = 4;
subst.value = a;
return subst;
case 4:
a = walk();
subst.$step = 5;
return subst.$delegate(a);
case 5:
a = s.leave();
subst.$step = 6;
return subst.$delegate(a);
case 6:
skip(s.leave());
subst.$step = 0;
subst.value = void 0;
subst.done = true;
return subst;
case 0:
subst.$step = 0;
subst.value = p;
subst.done = true;
return subst;
case 1:
subst.$step = 0;
throw p;
case 2:
return subst.$redir(p);
default:
throw new Error("invalid state");
}
}
},
toExpr = function toExpr1(pos) {
var j,
ti,
lab,
_toExpr = M.generator(),
r,
p;
_toExpr.step = toExpr_1;
_toExpr.$step = 3;
return _toExpr;
function toExpr_1(p) {
var a, b, c, d;
for (;;) {
switch (_toExpr.$cur = _toExpr.$step) {
case 3:
j = s.curLev();
if (j == null) {
_toExpr.$step = 0;
_toExpr.value = r;
_toExpr.done = true;
return _toExpr;
} else {
if (j.type === makeExpr || j.type === makeStmt) {
a = s.peel(j);
_toExpr.$step = 4;
_toExpr.value = a;
return _toExpr;
} else {
ti = (0, _core.typeInfo)(j);
if (ti.block) {
b = s.enter(pos, _core.Tag.CallExpression);
_toExpr.$step = 6;
_toExpr.value = b;
return _toExpr;
} else {
if (ti.stmt) {
c = s.enter(pos, _core.Tag.CallExpression);
_toExpr.$step = 12;
_toExpr.value = c;
return _toExpr;
} else {
if (ti.expr) {
d = subst(pos);
_toExpr.$step = 20;
return _toExpr.$delegate(d);
} else {
_toExpr.$step = 1;
_toExpr.$step = 1;
p = new Error("internal: cannot convert to expression");
continue;
}
}
}
}
}
case 4:
a = toExpr(pos);
_toExpr.$step = 5;
return _toExpr.$delegate(a);
case 5:
a = s.leave();
_toExpr.$step = 20;
_toExpr.value = a;
return _toExpr;
case 6:
a = s.enter(_core.Tag.callee, _core.Tag.ArrowFunctionExpression);
_toExpr.$step = 7;
_toExpr.value = a;
return _toExpr;
case 7:
a = s.tok(_core.Tag.params, _core.Tag.Array);
_toExpr.$step = 8;
_toExpr.value = a;
return _toExpr;
case 8:
a = subst(_core.Tag.body);
_toExpr.$step = 9;
return _toExpr.$delegate(a);
case 9:
a = s.leave();
_toExpr.$step = 10;
return _toExpr.$delegate(a);
case 10:
a = s.tok(_core.Tag.arguments, _core.Tag.Array);
_toExpr.$step = 11;
_toExpr.value = a;
return _toExpr;
case 11:
a = s.leave();
_toExpr.$step = 20;
return _toExpr.$delegate(a);
case 12:
lab = s.label();
a = s.enter(_core.Tag.callee, _core.Tag.ArrowFunctionExpression);
_toExpr.$step = 13;
_toExpr.value = a;
return _toExpr;
case 13:
a = s.tok(_core.Tag.params, _core.Tag.Array);
_toExpr.$step = 14;
_toExpr.value = a;
return _toExpr;
case 14:
a = s.enter(_core.Tag.body, _core.Tag.BlockStatement);
_toExpr.$step = 15;
_toExpr.value = a;
return _toExpr;
case 15:
a = s.enter(_core.Tag.body, _core.Tag.Array);
_toExpr.$step = 16;
_toExpr.value = a;
return _toExpr;
case 16:
a = subst(_core.Tag.push);
_toExpr.$step = 17;
return _toExpr.$delegate(a);
case 17:
a = lab();
_toExpr.$step = 18;
return _toExpr.$delegate(a);
case 18:
a = s.tok(_core.Tag.arguments, _core.Tag.Array);
_toExpr.$step = 19;
_toExpr.value = a;
return _toExpr;
case 19:
a = s.leave();
_toExpr.$step = 20;
return _toExpr.$delegate(a);
case 20:
_toExpr.$step = 0;
_toExpr.value = void 0;
_toExpr.done = true;
return _toExpr;
case 0:
_toExpr.$step = 0;
_toExpr.value = p;
_toExpr.done = true;
return _toExpr;
case 1:
_toExpr.$step = 0;
throw p;
case 2:
return _toExpr.$redir(p);
default:
throw new Error("invalid state");
}
}
}
},
toStmt = function toStmt1(pos) {
var j,
ti,
_toStmt = M.generator(),
r,
p;
_toStmt.step = toStmt_1;
_toStmt.$step = 3;
return _toStmt;
function toStmt_1(p) {
var a, b, c;
switch (_toStmt.$cur = _toStmt.$step) {
case 3:
j = s.curLev();
if (j == null) {
_