@thi.ng/parse 2.4.8 → 2.4.10

package/error.js

@@ -1,6 +1,9 @@
 import { defError } from "@thi.ng/errors/deferror";
 const ParseError = defError(() => `ParseError`);
-export const parseError = (ctx, msg) => {
-    const info = ctx.reader.format(ctx.scope.state);
-    throw new ParseError(msg + (info ? ` @ ${info}` : ""));
+const parseError = (ctx, msg) => {
+  const info = ctx.reader.format(ctx.scope.state);
+  throw new ParseError(msg + (info ? ` @ ${info}` : ""));
+};
+export {
+  parseError
 };

package/grammar.js

@@ -19,7 +19,13 @@ import { FLOAT, INT, UINT } from "./presets/numbers.js";
 import { STRING } from "./presets/string.js";
 import { DNL, NL, WS, WS0, WS1 } from "./presets/whitespace.js";
 import { always, alwaysD } from "./prims/always.js";
-import { inputEnd, inputStart, lineEnd, lineStart, wordBoundary, } from "./prims/anchor.js";
+import {
+  inputEnd,
+  inputStart,
+  lineEnd,
+  lineStart,
+  wordBoundary
+} from "./prims/anchor.js";
 import { lit, litD } from "./prims/lit.js";
 import { noneOf } from "./prims/none-of.js";
 import { oneOf } from "./prims/one-of.js";
@@ -39,32 +45,50 @@ import { xfTrim } from "./xform/trim.js";
 import { withID } from "./xform/with-id.js";
 const apos = litD("'");
 const dash = litD("-");
-const REPEAT = maybe(alt([
+const REPEAT = maybe(
+  alt([
     oneOf("?*+", "repeat"),
-    collect(seq([litD("{"), UINT, maybe(lit(",")), maybe(UINT), litD("}")], "repeatN")),
-]));
-const DISCARD = maybe(lit("!"), undefined, "discard");
+    collect(
+      seq(
+        [litD("{"), UINT, maybe(lit(",")), maybe(UINT), litD("}")],
+        "repeatN"
+      )
+    )
+  ])
+);
+const DISCARD = maybe(lit("!"), void 0, "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([
+const CHAR_SEL = seq(
+  [
     litD("["),
     maybe(lit("^", "invert")),
     oneOrMore(alt([CHAR_RANGE, UNICODE, noneOf("]", "char")]), "choice"),
-    litD("]"),
-], "charSel");
+    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 LOOK_AHEAD = maybe(
+  seq(
+    [
+      stringD("(?"),
+      oneOf("-+"),
+      seq([TERM_BODY, REPEAT, DISCARD], "lhterm"),
+      litD(")")
+    ],
+    "lhspec"
+  ),
+  void 0,
+  "lhnone"
+);
 const TERM = seq([TERM_BODY, REPEAT, DISCARD, LOOK_AHEAD], "term");
-const ALT = seq([
+const ALT = seq(
+  [
     litD("("),
     WS0,
     TERM,
@@ -73,10 +97,15 @@ const ALT = seq([
     litD(")"),
     REPEAT,
     DISCARD,
-    LOOK_AHEAD,
-], "alt");
-const RULE_XF = hoist(seq([stringD("=>"), WS1, alt([SYM, RULE_REF, STRING]), WS1], "xform"));
-const RULE = seq([
+    LOOK_AHEAD
+  ],
+  "alt"
+);
+const RULE_XF = hoist(
+  seq([stringD("=>"), WS1, alt([SYM, RULE_REF, STRING]), WS1], "xform")
+);
+const RULE = seq(
+  [
     WS0,
     SYM,
     WS0,
@@ -84,204 +113,231 @@ const RULE = seq([
     oneOrMore(alt([TERM, ALT, WS1]), "body"),
     maybe(RULE_XF),
     litD(";"),
-    WS0,
-], "rule");
+    WS0
+  ],
+  "rule"
+);
 const COMMENT = seqD([WS0, litD("#"), lookahead(always(), DNL)]);
-export const GRAMMAR = zeroOrMore(alt([RULE, COMMENT]), "rules");
+const GRAMMAR = zeroOrMore(alt([RULE, COMMENT]), "rules");
 const first = ($) => $.children[0];
 const nth = ($, n) => $.children[n];
-const compile = defmulti((scope) => scope.id, {
-    unicode: "char",
-}, {
+const compile = defmulti(
+  (scope) => scope.id,
+  {
+    unicode: "char"
+  },
+  {
     [DEFAULT]: ($) => unsupported(`unknown op: ${$.id}`),
     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;
+      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)
-                illegalArgs(`missing xform: ${xf.result}`);
-            parser = xform(parser, $xf);
-        }
-        else if (xf.id === "ref") {
-            const $id = first(xf).result;
-            if ($id === id)
-                illegalArgs(`self-referential: ${$id}`);
-            const $xf = lang.rules[$id];
-            if (!$xf)
-                illegalArgs(`missing xform rule: ${$id}`);
-            parser = nest(parser, $xf);
-        }
-        else if (xf.id === "string") {
-            parser = xform(parser, xfReplace(xf.result));
-        }
-        return parser;
+      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)
+          illegalArgs(`missing xform: ${xf.result}`);
+        parser = xform(parser, $xf);
+      } else if (xf.id === "ref") {
+        const $id = first(xf).result;
+        if ($id === id)
+          illegalArgs(`self-referential: ${$id}`);
+        const $xf = lang.rules[$id];
+        if (!$xf)
+          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
-            : illegalArgs(`invalid rule ref: ${id}`);
+      const id = first($).result;
+      opts.debug && console.log(`ref: ${id}`, flags);
+      const ref = lang.rules[id];
+      return ref ? flags.discard ? discard(ref) : ref : 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, { ...flags, discard }), repeat, discard, lookahead, lang, opts);
+      const [term, repeat2, discard2, lookahead2] = $.children;
+      opts.debug && console.log(`term: ${term.id}`, flags);
+      return compileRDL(
+        (discard3) => compile(term, lang, opts, { ...flags, discard: discard3 }),
+        repeat2,
+        discard2,
+        lookahead2,
+        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, { ...flags, discard }), repeat, discard, opts);
+      const [term, repeat2, discard2] = $.children;
+      opts.debug && console.log(`lhterm: ${term.id}`);
+      return compileRD(
+        (discard3) => compile(term, lang, opts, { ...flags, discard: discard3 }),
+        repeat2,
+        discard2,
+        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));
-            }
+      opts.debug && console.log(`alt: ${$.id}`, flags);
+      const [term0, { children: terms }, repeat2, disc, lookahead2] = $.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);
+      }
+      return compileRDL(
+        (optimize) => optimize || flags.discard ? acc.length > 1 ? altD(acc) : discard(acc[0]) : acc.length > 1 ? alt(acc) : acc[0],
+        repeat2,
+        disc,
+        lookahead2,
+        lang,
+        opts
+      );
     },
     any: (_, __, opts, flags) => {
-        opts.debug && console.log(`any`, flags);
-        return flags.discard ? alwaysD() : always("any");
+      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);
+      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);
+      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);
+      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;
-    },
-});
-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;
-        }
+      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;
     }
-    else if (rspec.id === "repeatN") {
-        const [n, sep, m] = rspec.result;
-        return repeat(parser, n, sep ? m || Infinity : m || n);
+  }
+);
+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;
     }
-    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;
+  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;
+  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 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);
-export const defGrammar = (rules, env, opts) => {
-    opts = { debug: false, optimize: true, ...opts };
-    env = {
-        binary: xfInt(2),
-        collect: xfCollect,
-        count: xfCount,
-        discard: xfDiscard,
-        float: xfFloat,
-        hex: xfInt(16),
-        hoist: xfHoist,
-        hoistR: xfHoistResult,
-        int: xfInt(10),
-        join: xfJoin,
-        json: xfJson,
-        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 defGrammar = (rules, env, opts) => {
+  opts = { debug: false, optimize: true, ...opts };
+  env = {
+    binary: xfInt(2),
+    collect: xfCollect,
+    count: xfCount,
+    discard: xfDiscard,
+    float: xfFloat,
+    hex: xfInt(16),
+    hoist: xfHoist,
+    hoistR: xfHoistResult,
+    int: xfInt(10),
+    join: xfJoin,
+    json: xfJson,
+    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,
+      {}
+    );
+  }
+};
+export {
+  GRAMMAR,
+  defGrammar
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/parse",
-  "version": "2.4.8",
+  "version": "2.4.10",
   "description": "Purely functional parser combinators & AST generation for generic inputs",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc combinators presets prims readers xform",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,15 +35,15 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.10",
-    "@thi.ng/checks": "^3.4.10",
-    "@thi.ng/defmulti": "^3.0.8",
-    "@thi.ng/errors": "^2.4.4",
-    "@thi.ng/strings": "^3.7.1"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/defmulti": "^3.0.10",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/strings": "^3.7.3"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
-    "@thi.ng/testament": "^0.4.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -240,5 +242,5 @@
     ],
     "year": 2020
   },
-  "gitHead": "04d1de79f256d7a53c6b5fd157b37f49bc88e11d\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/presets/alpha.js

@@ -1,19 +1,16 @@
-import { ALPHA as _ALPHA, ALPHA_NUM as _ALPHA_NUM, } from "@thi.ng/strings/groups";
+import {
+  ALPHA as _ALPHA,
+  ALPHA_NUM as _ALPHA_NUM
+} from "@thi.ng/strings/groups";
 import { oneOf } from "../prims/one-of.js";
 import { range } from "../prims/range.js";
-/**
- * Matches single char in `a` - `z` range.
- */
-export const LOWER_CASE = range("a", "z");
-/**
- * Matches single char in `A` - `Z` range.
- */
-export const UPPER_CASE = range("A", "Z");
-/**
- * Matches single in {@link LOWER_CASE} or {@link UPPER_CASE}.
- */
-export const ALPHA = oneOf(_ALPHA);
-/**
- * Matches single in {@link ALPHA} or {@link DIGIT}.
- */
-export const ALPHA_NUM = oneOf(_ALPHA_NUM);
+const LOWER_CASE = range("a", "z");
+const UPPER_CASE = range("A", "Z");
+const ALPHA = oneOf(_ALPHA);
+const ALPHA_NUM = oneOf(_ALPHA_NUM);
+export {
+  ALPHA,
+  ALPHA_NUM,
+  LOWER_CASE,
+  UPPER_CASE
+};

package/presets/bits.js

@@ -2,5 +2,9 @@ import { repeat } from "../combinators/repeat.js";
 import { xform } from "../combinators/xform.js";
 import { oneOf } from "../prims/one-of.js";
 import { xfInt } from "../xform/number.js";
-export const BIT = oneOf("01");
-export const BINARY_UINT = xform(repeat(BIT, 1, 32, "uint"), xfInt(2));
+const BIT = oneOf("01");
+const BINARY_UINT = xform(repeat(BIT, 1, 32, "uint"), xfInt(2));
+export {
+  BINARY_UINT,
+  BIT
+};

package/presets/digits.js

@@ -1,10 +1,8 @@
 import { oneOrMore } from "../combinators/repeat.js";
 import { range } from "../prims/range.js";
-/**
- * Matches single decimal digit.
- */
-export const DIGIT = range("0", "9", "digit");
-/**
- * Matches one or more {@link DIGIT}s.
- */
-export const DIGITS = oneOrMore(DIGIT);
+const DIGIT = range("0", "9", "digit");
+const DIGITS = oneOrMore(DIGIT);
+export {
+  DIGIT,
+  DIGITS
+};

package/presets/escape.js

@@ -7,15 +7,18 @@ import { litD } from "../prims/lit.js";
 import { stringD } from "../prims/string.js";
 import { xfInt } from "../xform/number.js";
 import { HEX_DIGIT } from "./hex.js";
-export const ESC = xform(seq([litD("\\"), always()], "esc"), ($) => {
-    const id = $.children[0].result;
-    const resolved = ESCAPES[id];
-    $.result = resolved !== undefined ? resolved : `\\${id}`;
-    $.children = null;
-    return $;
+const ESC = xform(seq([litD("\\"), always()], "esc"), ($) => {
+  const id = $.children[0].result;
+  const resolved = ESCAPES[id];
+  $.result = resolved !== void 0 ? resolved : `\\${id}`;
+  $.children = null;
+  return $;
 });
-/**
- * Matches a single `\uNNNN` escaped unicode hex literal and transforms
- * it into it actual character via `String.fromCharCode()`.
- */
-export const UNICODE = xform(seq([stringD("\\u"), repeat(HEX_DIGIT, 4, 4)], "unicode"), ($, ctx) => (($.result = String.fromCharCode(xfInt(16)($, ctx).result)), $));
+const UNICODE = xform(
+  seq([stringD("\\u"), repeat(HEX_DIGIT, 4, 4)], "unicode"),
+  ($, ctx) => ($.result = String.fromCharCode(xfInt(16)($, ctx).result), $)
+);
+export {
+  ESC,
+  UNICODE
+};