@thi.ng/parse 1.0.4 → 2.0.3

package/lib/index.js

@@ -1,967 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var checks = require('@thi.ng/checks');
-var errors = require('@thi.ng/errors');
-var defmulti = require('@thi.ng/defmulti');
-var strings = require('@thi.ng/strings');
-
-const ParseError = errors.defError(() => `ParseError`);
-const parseError = (ctx, msg) => {
-    const info = ctx.reader.format(ctx.scope.state);
-    throw new ParseError(msg + (info ? ` @ ${info}` : ""));
-};
-
-class ArrayReader {
-    constructor(_src) {
-        this._src = _src;
-    }
-    read(state) {
-        return this._src[state.p];
-    }
-    next(state) {
-        if (state.done)
-            return;
-        state.last = this._src[state.p];
-        state.done = ++state.p >= this._src.length;
-    }
-    isDone(state) {
-        return (state.done = state.p >= this._src.length);
-    }
-    format(state) {
-        return `offset ${state.p}`;
-    }
-}
-const defArrayReader = (input) => new ArrayReader(input);
-
-class StringReader {
-    constructor(_src) {
-        this._src = _src;
-    }
-    read(state) {
-        return this._src[state.p];
-    }
-    next(state) {
-        if (state.done)
-            return;
-        state.last = this._src[state.p];
-        if (state.last === "\n") {
-            state.l++;
-            state.c = 1;
-        }
-        else {
-            state.c++;
-        }
-        state.done = ++state.p >= this._src.length;
-    }
-    isDone(state) {
-        return (state.done = state.p >= this._src.length);
-    }
-    format(state) {
-        return `offset ${state.p} (${state.l}:${state.c})`;
-    }
-}
-const defStringReader = (input) => new StringReader(input);
-
-const cache = [];
-const indent = (x) => (cache[x] = "  ".repeat(x));
-
-class ParseContext {
-    constructor(reader, opts) {
-        this.reader = reader;
-        this.opts = Object.assign({ maxDepth: 32, debug: false, retain: false }, opts);
-        this._maxDepth = this.opts.maxDepth;
-        this._debug = this.opts.debug;
-        this._retain = this.opts.retain;
-        this.reset();
-    }
-    reset() {
-        this._curr = {
-            id: "root",
-            state: { p: 0, l: 1, c: 1 },
-            children: null,
-            result: null,
-        };
-        this._scopes = [this._curr];
-        this.reader.isDone(this._curr.state);
-        return this;
-    }
-    start(id) {
-        if (this._scopes.length >= this._maxDepth) {
-            parseError(this, `recursion limit reached ${this._maxDepth}`);
-        }
-        const scopes = this._scopes;
-        const scope = {
-            id,
-            state: Object.assign({}, scopes[scopes.length - 1].state),
-            children: null,
-            result: null,
-        };
-        scopes.push(scope);
-        this._debug &&
-            console.log(`${indent(scopes.length)}start: ${id} (${scope.state.p})`);
-        return (this._curr = scope);
-    }
-    discard() {
-        const scopes = this._scopes;
-        const child = scopes.pop();
-        this._curr = scopes[scopes.length - 1];
-        this._debug &&
-            console.log(`${indent(scopes.length + 1)}discard: ${child.id}`);
-        return false;
-    }
-    end() {
-        const scopes = this._scopes;
-        const child = scopes.pop();
-        const parent = scopes[scopes.length - 1];
-        const cstate = child.state;
-        let pstate;
-        this._debug &&
-            console.log(`${indent(scopes.length + 1)}end: ${child.id} (${cstate.p})`);
-        child.state = this._retain
-            ? ((pstate = parent.state),
-                { p: pstate.p, l: pstate.l, c: pstate.c })
-            : null;
-        parent.state = cstate;
-        const children = parent.children;
-        children ? children.push(child) : (parent.children = [child]);
-        this._curr = parent;
-        return true;
-    }
-    addChild(id, result = null, newState = false) {
-        const curr = this._curr;
-        const cstate = curr.state;
-        const child = {
-            id,
-            state: this._retain
-                ? { p: cstate.p, l: cstate.l, c: cstate.c }
-                : null,
-            children: null,
-            result,
-        };
-        this._debug &&
-            console.log(`${indent(this._scopes.length + 1)}addChild: ${id} (${cstate.p})`);
-        const children = curr.children;
-        children ? children.push(child) : (curr.children = [child]);
-        if (newState !== false) {
-            newState === true
-                ? this.reader.next(cstate)
-                : (this._curr.state = newState);
-        }
-        return true;
-    }
-    get scope() {
-        return this._curr;
-    }
-    get state() {
-        return this._curr.state;
-    }
-    set state(state) {
-        this._curr.state = state;
-    }
-    get done() {
-        return this._curr.state.done;
-    }
-    get root() {
-        return this._scopes[0];
-    }
-    get result() {
-        const children = this.root.children;
-        return children ? children[0].result : undefined;
-    }
-    get children() {
-        const children = this.root.children;
-        return children ? children[0].children : undefined;
-    }
-}
-function defContext(input, opts) {
-    return new ParseContext(checks.isString(input)
-        ? defStringReader(input)
-        : checks.isArrayLike(input)
-            ? defArrayReader(input)
-            : input, opts);
-}
-
-const xform = (parser, xf, user) => (ctx) => {
-    if (parser(ctx)) {
-        const children = ctx.scope.children;
-        const scope = children[children.length - 1];
-        if (xf(scope, ctx, user)) {
-            if (scope.children && !scope.children.length) {
-                scope.children = null;
-            }
-        }
-        else {
-            children.pop();
-        }
-        return true;
-    }
-    return false;
-};
-
-const xfDiscard = () => null;
-const discard = (parser) => xform(parser, xfDiscard);
-
-const alt = (parsers) => (ctx) => {
-    if (ctx.done)
-        return false;
-    for (let i = 0, n = parsers.length; i < n; i++) {
-        if (parsers[i](ctx)) {
-            return true;
-        }
-    }
-    return false;
-};
-const altD = (parsers) => discard(alt(parsers));
-
-const dynamic = () => {
-    let impl;
-    const wrapper = (ctx) => (impl ? impl(ctx) : false);
-    wrapper.set = (p) => (impl = p);
-    return wrapper;
-};
-
-const lookahead = (parser, ahead, capture = false, id = "lookahead") => (ctx) => {
-    if (ctx.done)
-        return false;
-    ctx.start(id);
-    let pass = false;
-    while (true) {
-        const state = capture ? null : Object.assign({}, ctx.state);
-        if (ahead(ctx)) {
-            !capture && (ctx.state = state);
-            return pass ? ctx.end() : ctx.discard();
-        }
-        if (!parser(ctx))
-            return ctx.discard();
-        pass = true;
-    }
-};
-
-const pass = (result, id = "pass") => (ctx) => ctx.addChild(id, checks.isFunction(result) ? result() : result);
-const passD = () => true;
-
-const maybe = (parser, result, id = "maybe") => (ctx) => parser(ctx) || pass(result, id)(ctx);
-
-const satisfy = (pred, id = "satisfy") => ((ctx) => {
-    if (ctx.done)
-        return false;
-    const r = ctx.reader.read(ctx.state);
-    return pred(r) ? ctx.addChild(id, r, true) : false;
-});
-const satisfyD = (pred) => ((ctx) => {
-    if (ctx.done)
-        return false;
-    const state = ctx.state;
-    const reader = ctx.reader;
-    return pred(reader.read(state)) ? (reader.next(state), true) : false;
-});
-
-const always = (id = "always") => satisfy(() => true, id);
-const alwaysD = () => satisfyD(() => true);
-
-const not = (parser, fail = always()) => (ctx) => {
-    if (ctx.done)
-        return false;
-    ctx.start("");
-    const res = parser(ctx);
-    ctx.discard();
-    return res ? false : fail(ctx);
-};
-
-const repeat = (parser, min, max, id = "repeat") => (ctx) => {
-    if (ctx.done) {
-        return min < 1 ? ctx.addChild(id) : false;
-    }
-    ctx.start(id);
-    for (let i = 0; i < max; i++) {
-        if (!parser(ctx)) {
-            if (i < min) {
-                return ctx.discard();
-            }
-            break;
-        }
-    }
-    return ctx.end();
-};
-const zeroOrMore = (parser, id = "repeat0", max = Infinity) => repeat(parser, 0, max, id);
-const oneOrMore = (parser, id = "repeat1", max = Infinity) => repeat(parser, 1, max, id);
-const repeatD = (parser, min, max) => discard(repeat(parser, min, max));
-const zeroOrMoreD = (parser, max = Infinity) => repeatD(parser, 0, max);
-const oneOrMoreD = (parser, max = Infinity) => repeatD(parser, 1, max);
-
-const seq = (parsers, id = "seq") => (ctx) => {
-    if (ctx.done)
-        return false;
-    ctx.start(id);
-    for (let i = 0, n = parsers.length; i < n; i++) {
-        if (!parsers[i](ctx)) {
-            return ctx.discard();
-        }
-    }
-    return ctx.end();
-};
-const seqD = (parsers) => discard(seq(parsers));
-
-const oneOfP = (opts) => checks.isSet(opts)
-    ? (x) => opts.has(x)
-    : checks.isPlainObject(opts)
-        ? (x) => opts[x]
-        : (x) => opts.indexOf(x) >= 0;
-function oneOf(opts, id = "oneOf") {
-    return satisfy(oneOfP(opts), id);
-}
-function oneOfD(opts) {
-    return satisfyD(oneOfP(opts));
-}
-
-const rangeP = (min, max) => (x) => x >= min && x <= max;
-const utf16RangeP = (min, max) => (x) => {
-    const c = x.charCodeAt(0);
-    return c >= min && c <= max;
-};
-function range(min, max, id = "lit") {
-    return satisfy(rangeP(min, max), id);
-}
-function rangeD(min, max) {
-    return satisfyD(rangeP(min, max));
-}
-const utf16Range = (min, max, id = "utfLit") => satisfy(utf16RangeP(min, max), id);
-const utf16RangeD = (min, max) => satisfyD(utf16RangeP(min, max));
-
-const LOWER_CASE = range("a", "z");
-const UPPER_CASE = range("A", "Z");
-const ALPHA = oneOf(strings.ALPHA);
-const ALPHA_NUM = oneOf(strings.ALPHA_NUM);
-
-const xfJoin = (scope) => {
-    if (!scope || !scope.children)
-        return null;
-    const res = [];
-    for (let c of scope.children) {
-        xfJoin(c);
-        if (c.result)
-            res.push(c.result);
-    }
-    scope.result = res.join("");
-    scope.children = null;
-    return scope;
-};
-const join = (parser) => xform(parser, xfJoin);
-
-const xfInt = (radix = 10) => (scope) => {
-    scope.result = parseInt(xfJoin(scope).result, radix);
-    return scope;
-};
-const xfFloat = (scope) => {
-    scope.result = parseFloat(xfJoin(scope).result);
-    return scope;
-};
-
-const BIT = oneOf("01");
-const BINARY_UINT = xform(repeat(BIT, 1, 32, "uint"), xfInt(2));
-
-const DIGIT = range("0", "9", "digit");
-const DIGITS = oneOrMore(DIGIT);
-
-const litP = (c) => (x) => x === c;
-const lit = (c, id = "lit") => satisfy(litP(c), id);
-const litD = (c) => satisfyD(litP(c));
-
-const string = (str, id = "string") => (ctx) => {
-    if (ctx.done)
-        return false;
-    const scope = ctx.start(id);
-    const state = scope.state;
-    const reader = ctx.reader;
-    for (let i = 0, n = str.length; i < n; i++) {
-        if (state.done)
-            return false;
-        const r = reader.read(state);
-        if (r !== str[i]) {
-            return ctx.discard();
-        }
-        reader.next(state);
-    }
-    scope.result = str;
-    return ctx.end();
-};
-const stringD = (str) => (ctx) => {
-    if (ctx.done)
-        return false;
-    const state = Object.assign({}, ctx.state);
-    const reader = ctx.reader;
-    for (let i = 0, n = str.length; i < n; i++) {
-        if (state.done)
-            return false;
-        const r = reader.read(state);
-        if (r !== str[i]) {
-            return false;
-        }
-        reader.next(state);
-    }
-    ctx.state = state;
-    return true;
-};
-const stringOf = (pred, id = "string", reduce = (x) => x.join("")) => (ctx) => {
-    const state = Object.assign({}, ctx.state);
-    const reader = ctx.reader;
-    let acc = [];
-    while (!state.done) {
-        const r = reader.read(state);
-        if (!pred(r))
-            break;
-        acc.push(r);
-        reader.next(state);
-    }
-    return ctx.addChild(id, reduce(acc), state);
-};
-
-const HEX_DIGIT = oneOf(strings.HEX);
-const HEX_DIGITS = oneOrMore(HEX_DIGIT);
-const HEX_UINT = xform(repeat(HEX_DIGIT, 1, 8, "uint"), xfInt(16));
-
-const ESC = xform(seq([litD("\\"), always()], "esc"), ($) => {
-    const id = $.children[0].result;
-    const resolved = strings.ESCAPES[id];
-    $.result = resolved !== undefined ? resolved : `\\${id}`;
-    $.children = null;
-    return $;
-});
-const UNICODE = xform(seq([stringD("\\u"), repeat(HEX_DIGIT, 4, 4)], "unicode"), ($, ctx) => (($.result = String.fromCharCode(xfInt(16)($, ctx).result)), $));
-
-const comp = (...xs) => {
-    const [a, b, c, d] = xs;
-    switch (xs.length) {
-        case 0:
-            return (x) => x;
-        case 1:
-            return a;
-        case 2:
-            return (scope, ctx, user) => b(a(scope, ctx, user), ctx, user);
-        case 3:
-            return (scope, ctx, user) => c(b(a(scope, ctx, user), ctx, user), ctx, user);
-        case 4:
-            return (scope, ctx, user) => d(c(b(a(scope, ctx, user), ctx, user), ctx, user), ctx, user);
-        default:
-            return (scope, ctx, user) => xs.reduce((scope, x) => x(scope, ctx, user), scope);
-    }
-};
-
-const xfID = (id) => (scope) => ((scope.id = id), scope);
-const withID = (id, parser) => xform(parser, xfID(id));
-
-const SIGN = maybe(oneOf("-+"));
-const INT = xform(seq([SIGN, DIGITS], "int"), xfInt());
-const UINT = xform(DIGITS, comp(xfID("uint"), xfInt()));
-const EXP = maybe(seq([maybe(oneOf("eE")), SIGN, DIGITS]));
-const DOT = lit(".");
-const FRACT0 = maybe(seq([DOT, zeroOrMore(DIGIT)]));
-const FRACT1 = seq([DOT, DIGITS]);
-const _REAL = seq([SIGN, alt([FRACT1, seq([DIGITS, FRACT0])]), EXP], "real");
-const REAL = join(_REAL);
-const FLOAT = xform(_REAL, xfFloat);
-
-const noneOfP = (opts) => checks.isSet(opts)
-    ? (x) => !opts.has(x)
-    : checks.isPlainObject(opts)
-        ? (x) => !opts[x]
-        : (x) => opts.indexOf(x) < 0;
-function noneOf(opts, id = "noneOf") {
-    return satisfy(noneOfP(opts), id);
-}
-function noneOfD(opts) {
-    return satisfyD(noneOfP(opts));
-}
-
-const quote = litD('"');
-const STRING = join(seq([quote, zeroOrMore(alt([UNICODE, ESC, noneOf('"')])), quote], "string"));
-
-const WS = oneOfD(strings.WS);
-const SPACE = oneOfD(" \t");
-const NL = oneOf("\n\r");
-const DNL = oneOfD("\n\r");
-const WS0 = zeroOrMoreD(WS);
-const WS1 = oneOrMoreD(WS);
-const SPACES0 = zeroOrMoreD(SPACE);
-const SPACES = oneOrMoreD(SPACE);
-
-const anchor = (fn) => (ctx) => {
-    const state = ctx.state;
-    return fn(state.last, state.done ? null : ctx.reader.read(state));
-};
-const inputStart = (ctx) => ctx.state.last == null;
-const inputEnd = (ctx) => ctx.state.done || ctx.reader.read(ctx.state) === undefined;
-const lineStart = (ctx) => {
-    const l = ctx.state.last;
-    return l == null || l === "\n" || l === "\r";
-};
-const lineEnd = (ctx) => {
-    const state = ctx.state;
-    let c;
-    return state.done || (c = ctx.reader.read(state)) === "\n" || c === "\r";
-};
-const wordBoundaryP = (prev, next) => {
-    return prev
-        ? next
-            ? strings.ALPHA_NUM[prev] && !strings.ALPHA_NUM[next]
-            : strings.ALPHA_NUM[prev]
-        : next
-            ? strings.ALPHA_NUM[next]
-            : false;
-};
-const wordBoundary = anchor(wordBoundaryP);
-
-const xfCollect = (scope) => {
-    scope.result = scope.children.map((c) => c.result);
-    scope.children = null;
-    return scope;
-};
-const collect = (parser) => xform(parser, xfCollect);
-
-const xfCount = (scope) => {
-    scope.result = scope.children ? scope.children.length : 0;
-    scope.children = null;
-    return scope;
-};
-const count = (parser) => xform(parser, xfCount);
-
-const xfHoist = (scope) => {
-    Object.assign(scope, scope.children[0]);
-    return scope;
-};
-const xfHoistResult = (scope) => {
-    scope.result = scope.children[0].result;
-    scope.children = null;
-    return scope;
-};
-const hoist = (parser) => xform(parser, xfHoist);
-const hoistResult = (parser) => xform(parser, xfHoistResult);
-
-const xfNest = (parser) => (scope, ctx) => {
-    if (!scope)
-        return;
-    const src = scope.result || xfJoin(Object.assign({}, scope)).result;
-    const inner = defContext(src, ctx.opts);
-    const state = scope.state;
-    if (state) {
-        const istate = inner.scope.state;
-        istate.l = state.l;
-        istate.c = state.c;
-    }
-    if (parser(inner)) {
-        scope.result = null;
-        scope.children = inner.children;
-    }
-    return scope;
-};
-const nest = (outer, inner) => xform(outer, xfNest(inner));
-
-const xfPrint = (fn = console.log) => {
-    const $print = (scope, _, level = 0) => {
-        if (!scope)
-            return;
-        const prefix = indent(level);
-        const state = scope.state;
-        const info = state ? ` (${state.l}:${state.c})` : "";
-        fn(`${prefix}${scope.id}${info}: ${JSON.stringify(scope.result)}`);
-        if (scope.children) {
-            for (let c of scope.children) {
-                $print(c, _, level + 1);
-            }
-        }
-        return scope;
-    };
-    return $print;
-};
-const print = (parser, fn) => xform(parser, xfPrint(fn));
-
-const xfReplace = (result) => (scope) => {
-    scope.result = result;
-    scope.children = null;
-    return scope;
-};
-const replace = (parser, result) => xform(parser, xfReplace(result));
-
-const xfTrim = (scope) => {
-    scope.result = scope.result.trim();
-    return scope;
-};
-const trim = (parser) => xform(parser, xfTrim);
-
-const apos = litD("'");
-const dash = litD("-");
-const REPEAT = maybe(alt([
-    oneOf("?*+", "repeat"),
-    collect(seq([litD("{"), UINT, maybe(lit(",")), maybe(UINT), litD("}")], "repeatN")),
-]));
-const DISCARD = maybe(lit("!"), undefined, "discard");
-const CHAR_OR_ESC = alt([UNICODE, ESC, always()]);
-const CHAR_RANGE = seq([CHAR_OR_ESC, dash, CHAR_OR_ESC], "charRange");
-const CHAR_SEL = seq([
-    litD("["),
-    maybe(lit("^", "invert")),
-    oneOrMore(alt([CHAR_RANGE, UNICODE, noneOf("]", "char")]), "choice"),
-    litD("]"),
-], "charSel");
-const ANY = lit(".", "any");
-const LIT = hoistResult(seq([apos, CHAR_OR_ESC, apos], "char"));
-const SYM = join(oneOrMore(alt([ALPHA_NUM, oneOf(".-_$")]), "sym"));
-const RULE_REF = seq([litD("<"), SYM, litD(">")], "ref");
-const TERM_BODY = alt([RULE_REF, ANY, LIT, STRING, CHAR_SEL]);
-const LOOK_AHEAD = maybe(seq([
-    stringD("(?"),
-    oneOf("-+"),
-    seq([TERM_BODY, REPEAT, DISCARD], "lhterm"),
-    litD(")"),
-], "lhspec"), undefined, "lhnone");
-const TERM = seq([TERM_BODY, REPEAT, DISCARD, LOOK_AHEAD], "term");
-const ALT = seq([
-    litD("("),
-    WS0,
-    TERM,
-    zeroOrMore(seq([WS0, litD("|"), WS0, TERM])),
-    WS0,
-    litD(")"),
-    REPEAT,
-    DISCARD,
-    LOOK_AHEAD,
-], "alt");
-const RULE_XF = hoist(seq([stringD("=>"), WS1, alt([SYM, RULE_REF, STRING]), WS1], "xform"));
-const RULE = seq([
-    WS0,
-    SYM,
-    WS0,
-    litD(":"),
-    oneOrMore(alt([TERM, ALT, WS1]), "body"),
-    maybe(RULE_XF),
-    litD(";"),
-    WS0,
-], "rule");
-const COMMENT = seqD([WS0, litD("#"), lookahead(always(), DNL)]);
-const GRAMMAR = zeroOrMore(alt([RULE, COMMENT]), "rules");
-const first = ($) => $.children[0];
-const nth = ($, n) => $.children[n];
-const compile = defmulti.defmulti((scope) => scope.id, {
-    unicode: ["char"],
-});
-compile.addAll({
-    root: ($, lang, opts, flags) => {
-        const rules = first($).children;
-        rules.reduce((acc, r) => ((acc[first(r).result] = dynamic()), acc), lang.rules);
-        for (let r of rules) {
-            const id = first(r).result;
-            lang.rules[id].set(compile(r, lang, opts, flags));
-        }
-        return lang;
-    },
-    rule: ($, lang, opts, flags) => {
-        const [id, body, xf] = $.children;
-        opts.debug && console.log(`rule: ${id.result}`, xf);
-        const acc = [];
-        for (let b of body.children) {
-            const c = compile(b, lang, opts, flags);
-            c && acc.push(c);
-        }
-        let parser = acc.length > 1 ? seq(acc, id.result) : withID(id.result, acc[0]);
-        if (xf.id === "sym") {
-            const $xf = lang.env[xf.result];
-            if (!$xf)
-                errors.illegalArgs(`missing xform: ${xf.result}`);
-            parser = xform(parser, $xf);
-        }
-        else if (xf.id === "ref") {
-            const $id = first(xf).result;
-            if ($id === id)
-                errors.illegalArgs(`self-referential: ${$id}`);
-            const $xf = lang.rules[$id];
-            if (!$xf)
-                errors.illegalArgs(`missing xform rule: ${$id}`);
-            parser = nest(parser, $xf);
-        }
-        else if (xf.id === "string") {
-            parser = xform(parser, xfReplace(xf.result));
-        }
-        return parser;
-    },
-    ref: ($, lang, opts, flags) => {
-        const id = first($).result;
-        opts.debug && console.log(`ref: ${id}`, flags);
-        const ref = lang.rules[id];
-        return ref
-            ? flags.discard
-                ? discard(ref)
-                : ref
-            : errors.illegalArgs(`invalid rule ref: ${id}`);
-    },
-    term: ($, lang, opts, flags) => {
-        const [term, repeat, discard, lookahead] = $.children;
-        opts.debug && console.log(`term: ${term.id}`, flags);
-        return compileRDL((discard) => compile(term, lang, opts, Object.assign(Object.assign({}, flags), { discard })), repeat, discard, lookahead, lang, opts);
-    },
-    lhterm: ($, lang, opts, flags) => {
-        const [term, repeat, discard] = $.children;
-        opts.debug && console.log(`lhterm: ${term.id}`);
-        return compileRD((discard) => compile(term, lang, opts, Object.assign(Object.assign({}, flags), { discard })), repeat, discard, opts);
-    },
-    alt: ($, lang, opts, flags) => {
-        opts.debug && console.log(`alt: ${$.id}`, flags);
-        const [term0, { children: terms }, repeat, disc, lookahead,] = $.children;
-        const acc = [compile(term0, lang, opts, flags)];
-        if (terms) {
-            for (let c of terms) {
-                acc.push(compile(first(c), lang, opts, flags));
-            }
-        }
-        return compileRDL((optimize) => optimize || flags.discard
-            ? acc.length > 1
-                ? altD(acc)
-                : discard(acc[0])
-            : acc.length > 1
-                ? alt(acc)
-                : acc[0], repeat, disc, lookahead, lang, opts);
-    },
-    any: (_, __, opts, flags) => {
-        opts.debug && console.log(`any`, flags);
-        return flags.discard ? alwaysD() : always("any");
-    },
-    char: ($, _, opts, flags) => {
-        const x = $.result;
-        opts.debug && console.log(`lit: '${x}'`, flags);
-        return (flags.discard ? litD : lit)(x);
-    },
-    string: ($, _, opts, flags) => {
-        const x = $.result;
-        opts.debug && console.log(`string: "${x}"`, flags);
-        return (flags.discard ? stringD : string)(x);
-    },
-    charRange: ($, _, opts, flags) => {
-        const [a, b] = $.children;
-        opts.debug && console.log(`range: ${a.result} - ${b.result}`, flags);
-        return (flags.discard ? rangeD : range)(a.result, b.result);
-    },
-    charSel: ($, lang, opts, flags) => {
-        opts.debug && console.log("charSel", flags);
-        const choices = nth($, 1).children.map((c) => compile(c, lang, opts, flags));
-        const invert = first($).result;
-        const parser = choices.length > 1 ? alt(choices) : choices[0];
-        opts.debug && console.log(`invert: ${invert}`);
-        return invert
-            ? not(parser, flags.discard ? alwaysD() : always())
-            : parser;
-    },
-});
-compile.add(defmulti.DEFAULT, ($) => errors.unsupported(`unknown op: ${$.id}`));
-const compileRepeat = (parser, rspec, opts) => {
-    opts.debug && console.log(`repeat: ${rspec.id}`);
-    if (rspec.id === "repeat") {
-        switch (rspec.result) {
-            case "?":
-                return maybe(parser);
-            case "*":
-                return zeroOrMore(parser);
-            case "+":
-                return oneOrMore(parser);
-            default:
-                return parser;
-        }
-    }
-    else if (rspec.id === "repeatN") {
-        const [n, sep, m] = rspec.result;
-        return repeat(parser, n, sep ? m || Infinity : m || n);
-    }
-    return parser;
-};
-const compileDiscard = (parser, dspec, opts) => {
-    opts.debug && console.log(`discard:`, dspec.result);
-    return dspec.result === "!" ? discard(parser) : parser;
-};
-const compileLookahead = (parser, spec, lang, opts) => {
-    opts.debug && console.log(`lookahead:`, spec.id);
-    return spec.id === "lhspec"
-        ? lookahead(parser, compile(nth(spec, 1), lang, opts, {}), first(spec).result === "+")
-        : parser;
-};
-const compileRD = (parser, rspec, dspec, opts) => dspec.result != null && rspec.result == null
-    ? parser(true)
-    : compileDiscard(compileRepeat(parser(false), rspec, opts), dspec, opts);
-const compileRDL = (parser, rspec, dspec, lhspec, lang, opts) => compileLookahead(compileRD(parser, rspec, dspec, opts), lhspec, lang, opts);
-const defGrammar = (rules, env, opts) => {
-    opts = Object.assign({ debug: false, optimize: true }, opts);
-    env = Object.assign({ binary: xfInt(2), collect: xfCollect, count: xfCount, discard: xfDiscard, float: xfFloat, hex: xfInt(16), hoist: xfHoist, hoistR: xfHoistResult, int: xfInt(10), join: xfJoin, print: xfPrint(), trim: xfTrim }, env);
-    const ctx = defContext(rules);
-    const result = (opts.debug ? print(GRAMMAR) : GRAMMAR)(ctx);
-    if (result) {
-        return compile(ctx.root, {
-            env,
-            grammar: ctx,
-            rules: {
-                ALPHA_NUM,
-                ALPHA,
-                BIT,
-                DIGIT,
-                DNL,
-                END: inputEnd,
-                ESC,
-                FLOAT,
-                HEX_DIGIT,
-                INT,
-                LEND: lineEnd,
-                LSTART: lineStart,
-                NL,
-                START: inputStart,
-                STRING,
-                UNICODE,
-                WB: wordBoundary,
-                WS,
-                WS0,
-                WS1,
-            },
-        }, opts, {});
-    }
-};
-
-const startsWith = (parser) => seq([inputStart, parser]);
-const endsWith = (parser) => seq([parser, inputEnd]);
-const entireLine = (parser) => seq([lineStart, parser, lineEnd]);
-const entirely = (parser) => seq([inputStart, parser, inputEnd]);
-
-const check = (parser, pred, msg = "check failed") => xform(parser, (scope, ctx) => {
-    if (!pred(scope))
-        parseError(ctx, msg);
-    return scope;
-});
-
-const expect = (parser, err) => (ctx) => parser(ctx) || parseError(ctx, err);
-
-const wrap = (parser, pre, post = pre) => hoist(seq([litD(pre), parser, litD(post)]));
-
-const fail = (msg) => (ctx) => parseError(ctx, msg);
-
-const skipWhile = (pred) => (ctx) => {
-    const state = Object.assign({}, ctx.state);
-    const reader = ctx.reader;
-    while (!state.done) {
-        if (!pred(reader.read(state)))
-            break;
-        reader.next(state);
-    }
-    ctx.state = state;
-    return true;
-};
-
-exports.ALPHA = ALPHA;
-exports.ALPHA_NUM = ALPHA_NUM;
-exports.BINARY_UINT = BINARY_UINT;
-exports.BIT = BIT;
-exports.DIGIT = DIGIT;
-exports.DIGITS = DIGITS;
-exports.DNL = DNL;
-exports.ESC = ESC;
-exports.FLOAT = FLOAT;
-exports.GRAMMAR = GRAMMAR;
-exports.HEX_DIGIT = HEX_DIGIT;
-exports.HEX_DIGITS = HEX_DIGITS;
-exports.HEX_UINT = HEX_UINT;
-exports.INT = INT;
-exports.LOWER_CASE = LOWER_CASE;
-exports.NL = NL;
-exports.ParseContext = ParseContext;
-exports.REAL = REAL;
-exports.SIGN = SIGN;
-exports.SPACE = SPACE;
-exports.SPACES = SPACES;
-exports.SPACES0 = SPACES0;
-exports.STRING = STRING;
-exports.UINT = UINT;
-exports.UNICODE = UNICODE;
-exports.UPPER_CASE = UPPER_CASE;
-exports.WS = WS;
-exports.WS0 = WS0;
-exports.WS1 = WS1;
-exports.alt = alt;
-exports.altD = altD;
-exports.always = always;
-exports.alwaysD = alwaysD;
-exports.anchor = anchor;
-exports.check = check;
-exports.collect = collect;
-exports.comp = comp;
-exports.count = count;
-exports.defArrayReader = defArrayReader;
-exports.defContext = defContext;
-exports.defGrammar = defGrammar;
-exports.defStringReader = defStringReader;
-exports.discard = discard;
-exports.dynamic = dynamic;
-exports.endsWith = endsWith;
-exports.entireLine = entireLine;
-exports.entirely = entirely;
-exports.expect = expect;
-exports.fail = fail;
-exports.hoist = hoist;
-exports.hoistResult = hoistResult;
-exports.inputEnd = inputEnd;
-exports.inputStart = inputStart;
-exports.join = join;
-exports.lineEnd = lineEnd;
-exports.lineStart = lineStart;
-exports.lit = lit;
-exports.litD = litD;
-exports.litP = litP;
-exports.lookahead = lookahead;
-exports.maybe = maybe;
-exports.nest = nest;
-exports.noneOf = noneOf;
-exports.noneOfD = noneOfD;
-exports.noneOfP = noneOfP;
-exports.not = not;
-exports.oneOf = oneOf;
-exports.oneOfD = oneOfD;
-exports.oneOfP = oneOfP;
-exports.oneOrMore = oneOrMore;
-exports.oneOrMoreD = oneOrMoreD;
-exports.parseError = parseError;
-exports.pass = pass;
-exports.passD = passD;
-exports.print = print;
-exports.range = range;
-exports.rangeD = rangeD;
-exports.rangeP = rangeP;
-exports.repeat = repeat;
-exports.repeatD = repeatD;
-exports.replace = replace;
-exports.satisfy = satisfy;
-exports.satisfyD = satisfyD;
-exports.seq = seq;
-exports.seqD = seqD;
-exports.skipWhile = skipWhile;
-exports.startsWith = startsWith;
-exports.string = string;
-exports.stringD = stringD;
-exports.stringOf = stringOf;
-exports.trim = trim;
-exports.utf16Range = utf16Range;
-exports.utf16RangeD = utf16RangeD;
-exports.utf16RangeP = utf16RangeP;
-exports.withID = withID;
-exports.wordBoundary = wordBoundary;
-exports.wordBoundaryP = wordBoundaryP;
-exports.wrap = wrap;
-exports.xfCollect = xfCollect;
-exports.xfCount = xfCount;
-exports.xfDiscard = xfDiscard;
-exports.xfFloat = xfFloat;
-exports.xfHoist = xfHoist;
-exports.xfHoistResult = xfHoistResult;
-exports.xfID = xfID;
-exports.xfInt = xfInt;
-exports.xfJoin = xfJoin;
-exports.xfNest = xfNest;
-exports.xfPrint = xfPrint;
-exports.xfReplace = xfReplace;
-exports.xfTrim = xfTrim;
-exports.xform = xform;
-exports.zeroOrMore = zeroOrMore;
-exports.zeroOrMoreD = zeroOrMoreD;