@thi.ng/parse 2.4.41 → 2.4.43

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2024-04-23T07:02:18Z
+- **Last updated**: 2024-06-21T19:34:38Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,13 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+### [2.4.43](https://github.com/thi-ng/umbrella/tree/@thi.ng/parse@2.4.43) (2024-06-21)
+
+#### ♻️ Refactoring
+
+- rename various rest args to be more semantically meaningful ([8088a56](https://github.com/thi-ng/umbrella/commit/8088a56))
+- enforce uniform naming convention of internal functions ([56992b2](https://github.com/thi-ng/umbrella/commit/56992b2))
+
 ### [2.4.5](https://github.com/thi-ng/umbrella/tree/@thi.ng/parse@2.4.5) (2023-11-09)
 
 #### ♻️ Refactoring

package/README.md

@@ -7,7 +7,7 @@
 [![Mastodon Follow](https://img.shields.io/mastodon/follow/109331703950160316?domain=https%3A%2F%2Fmastodon.thi.ng&style=social)](https://mastodon.thi.ng/@toxi)
 
 > [!NOTE]
-> This is one of 192 standalone projects, maintained as part
+> This is one of 193 standalone projects, maintained as part
 > of the [@thi.ng/umbrella](https://github.com/thi-ng/umbrella/) monorepo
 > and anti-framework.
 >
@@ -47,7 +47,9 @@
 
 Purely functional parser combinators & AST generation for generic inputs.
 
-There's a 2h 45m long video tutorial (live stream) introducing this package: [Building a web editor for creating/testing parse grammars](https://www.youtube.com/watch?v=mXp92s_VP40)
+There's a 2h 45m long video tutorial (live stream) introducing this package:
+[Building a web editor for creating/testing parse
+grammars](https://makertube.net/w/ursFuQNJQQskmejx1ydL7q)
 
 ### Features
 

package/combinators/alt.js

@@ -1,8 +1,7 @@
 import { string } from "../prims/string.js";
 import { discard } from "../xform/discard.js";
 const alt = (parsers) => (ctx) => {
-  if (ctx.done)
-    return false;
+  if (ctx.done) return false;
   for (let i = 0, n = parsers.length; i < n; i++) {
     if (parsers[i](ctx)) {
       return true;

package/combinators/check.js

@@ -1,8 +1,7 @@
 import { parseError } from "../error.js";
 import { xform } from "./xform.js";
 const check = (parser, pred, msg = "check failed") => xform(parser, (scope, ctx) => {
-  if (!pred(scope))
-    parseError(ctx, msg);
+  if (!pred(scope)) parseError(ctx, msg);
   return scope;
 });
 export {

package/combinators/dynamic.d.ts

@@ -1,16 +1,17 @@
 import type { DynamicParser } from "../api.js";
 /**
- * Returns a parser function placeholder, whose implementation can be
- * set at a later stage via calling `.set()`.
+ * Returns a parser function placeholder, whose implementation can be set at a
+ * later stage via calling `.set()`. The parser always fails until set, after
+ * which it then delegates to the chosen impl.
  *
  * @examples
- * ```ts
- * import { defContext, dynamic } from "@thi.ng/parse";
+ * ```ts tangle:../../export/dynamic.ts
+ * import { defContext, dynamic,lit  } from "@thi.ng/parse";
  *
  * const parser = dynamic<string>();
  * parser.set(lit("a"));
  *
- * parser(defContext("a"));
+ * console.log(parser(defContext("a")));
  * // true
  * ```
  */

package/combinators/lookahead.d.ts

@@ -25,8 +25,8 @@ import type { Parser } from "../api.js";
  * behavior and not a bug.
  *
  * @example
- * ```ts
- * import { defContext, lookahead, oneOf, stringD } from "@thi.ng/parse";
+ * ```ts tangle:../../export/lookahead.ts
+ * import { defContext, join, lookahead, oneOf, stringD } from "@thi.ng/parse";
  *
  * const ctx = defContext("ababaaabbabba");
  *
@@ -34,30 +34,34 @@ import type { Parser } from "../api.js";
  * // note the use of `stringD()` to discard lookahead result
  *
  * // non-capturing lookahead
- * join(lookahead(oneOf("ab"), stringD("abba")))(ctx)
+ * console.log(
+ *   join(lookahead(oneOf("ab"), stringD("abba")))(ctx)
+ * );
  * // true
  *
- * ctx.result
+ * console.log(ctx.result);
  * // "ababaa"
  *
- * ctx.state
+ * console.log(ctx.state);
  * // { p: 6, l: 1, c: 7, done: false, last: 'a' }
  * ```
  *
  * @example
- * ```ts
- * import { defContext, lookahead, oneOf, string } from "@thi.ng/parse";
+ * ```ts tangle:../../export/lookahead-2.ts
+ * import { defContext, join, lookahead, oneOf, string } from "@thi.ng/parse";
  *
  * const ctx = defContext("ababaaabbabba");
  *
  * // capturing lookahead
- * join(lookahead(oneOf("ab"), string("abba"), true))(ctx)
+ * console.log(
+ *   join(lookahead(oneOf("ab"), string("abba"), true))(ctx)
+ * );
  * // true
  *
- * ctx.result
+ * console.log(ctx.result);
  * // "ababaaabba"
  *
- * ctx.state
+ * console.log(ctx.state);
  * // { p: 10, l: 1, c: 11, done: false, last: 'a' }
  * ```
  *

package/combinators/lookahead.js

@@ -1,6 +1,5 @@
 const lookahead = (parser, ahead, capture = false, id = "lookahead") => (ctx) => {
-  if (ctx.done)
-    return false;
+  if (ctx.done) return false;
   ctx.start(id);
   let pass = false;
   while (true) {
@@ -9,8 +8,7 @@ const lookahead = (parser, ahead, capture = false, id = "lookahead") => (ctx) =>
       !capture && (ctx.state = state);
       return pass ? ctx.end() : ctx.discard();
     }
-    if (!parser(ctx))
-      return ctx.discard();
+    if (!parser(ctx)) return ctx.discard();
     pass = true;
   }
 };

package/combinators/not.js

@@ -1,7 +1,6 @@
 import { always } from "../prims/always.js";
 const not = (parser, fail = always()) => (ctx) => {
-  if (ctx.done)
-    return false;
+  if (ctx.done) return false;
   ctx.start("");
   const res = parser(ctx);
   ctx.discard();

package/combinators/seq.js

@@ -1,7 +1,6 @@
 import { discard } from "../xform/discard.js";
 const seq = (parsers, id = "seq") => (ctx) => {
-  if (ctx.done)
-    return false;
+  if (ctx.done) return false;
   ctx.start(id);
   for (let i = 0, n = parsers.length; i < n; i++) {
     if (!parsers[i](ctx)) {

package/context.js

@@ -3,7 +3,7 @@ import { isString } from "@thi.ng/checks/is-string";
 import { parseError } from "./error.js";
 import { defArrayReader } from "./readers/array-reader.js";
 import { defStringReader } from "./readers/string-reader.js";
-import { indent } from "./utils.js";
+import { __indent } from "./utils.js";
 class ParseContext {
   constructor(reader, opts) {
     this.reader = reader;
@@ -46,7 +46,7 @@ class ParseContext {
     scopes.push(scope);
     this._peakDepth = Math.max(this._peakDepth, scopes.length);
     this._debug && console.log(
-      `${indent(scopes.length)}start: ${id} (${scope.state.p})`
+      `${__indent(scopes.length)}start: ${id} (${scope.state.p})`
     );
     return this._curr = scope;
   }
@@ -54,7 +54,7 @@ class ParseContext {
     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}`);
+    this._debug && console.log(`${__indent(scopes.length + 1)}discard: ${child.id}`);
     return false;
   }
   end() {
@@ -64,7 +64,7 @@ class ParseContext {
     const cstate = child.state;
     let pstate;
     this._debug && console.log(
-      `${indent(scopes.length + 1)}end: ${child.id} (${cstate.p})`
+      `${__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;
@@ -83,7 +83,7 @@ class ParseContext {
       result
     };
     this._debug && console.log(
-      `${indent(this._scopes.length + 1)}addChild: ${id} (${cstate.p})`
+      `${__indent(this._scopes.length + 1)}addChild: ${id} (${cstate.p})`
     );
     const children = curr.children;
     children ? children.push(child) : curr.children = [child];

package/grammar.js

@@ -43,8 +43,8 @@ import { print, xfPrint } from "./xform/print.js";
 import { xfReplace } from "./xform/replace.js";
 import { xfTrim } from "./xform/trim.js";
 import { withID } from "./xform/with-id.js";
-const apos = litD("'");
-const dash = litD("-");
+const APOS = litD("'");
+const DASH = litD("-");
 const REPEAT = maybe(
   alt([
     oneOf("?*+", "repeat"),
@@ -58,7 +58,7 @@ const REPEAT = maybe(
 );
 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_RANGE = seq([CHAR_OR_ESC, DASH, CHAR_OR_ESC], "charRange");
 const CHAR_SEL = seq(
   [
     litD("["),
@@ -69,7 +69,7 @@ const CHAR_SEL = seq(
   "charSel"
 );
 const ANY = lit(".", "any");
-const LIT = hoistResult(seq([apos, CHAR_OR_ESC, apos], "char"));
+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]);
@@ -119,9 +119,9 @@ const RULE = seq(
 );
 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(
+const __first = ($) => $.children[0];
+const __nth = ($, n) => $.children[n];
+const __compile = defmulti(
   (scope) => scope.id,
   {
     unicode: "char"
@@ -129,15 +129,15 @@ const compile = defmulti(
   {
     [DEFAULT]: ($) => unsupported(`unknown op: ${$.id}`),
     root: ($, lang, opts, flags) => {
-      const rules = first($).children;
+      const rules = __first($).children;
       rules.reduce(
-        (acc, r) => (acc[first(r).result] = dynamic(), acc),
+        (acc, r) => (acc[__first(r).result] = dynamic(), acc),
         lang.rules
       );
       for (let r of rules) {
-        const id = first(r).result;
+        const id = __first(r).result;
         lang.rules[id].set(
-          compile(r, lang, opts, flags)
+          __compile(r, lang, opts, flags)
         );
       }
       return lang;
@@ -147,22 +147,19 @@ const compile = defmulti(
       opts.debug && console.log(`rule: ${id.result}`, xf);
       const acc = [];
       for (let b of body.children) {
-        const c = compile(b, lang, opts, flags);
+        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}`);
+        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 $id = __first(xf).result;
+        if ($id === id) illegalArgs(`self-referential: ${$id}`);
         const $xf = lang.rules[$id];
-        if (!$xf)
-          illegalArgs(`missing xform rule: ${$id}`);
+        if (!$xf) illegalArgs(`missing xform rule: ${$id}`);
         parser = nest(parser, $xf);
       } else if (xf.id === "string") {
         parser = xform(parser, xfReplace(xf.result));
@@ -170,7 +167,7 @@ const compile = defmulti(
       return parser;
     },
     ref: ($, lang, opts, flags) => {
-      const id = first($).result;
+      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}`);
@@ -178,8 +175,8 @@ const compile = defmulti(
     term: ($, lang, opts, flags) => {
       const [term, repeat2, discard2, lookahead2] = $.children;
       opts.debug && console.log(`term: ${term.id}`, flags);
-      return compileRDL(
-        (discard3) => compile(term, lang, opts, { ...flags, discard: discard3 }),
+      return __compileRDL(
+        (discard3) => __compile(term, lang, opts, { ...flags, discard: discard3 }),
         repeat2,
         discard2,
         lookahead2,
@@ -190,8 +187,8 @@ const compile = defmulti(
     lhterm: ($, lang, opts, flags) => {
       const [term, repeat2, discard2] = $.children;
       opts.debug && console.log(`lhterm: ${term.id}`);
-      return compileRD(
-        (discard3) => compile(term, lang, opts, { ...flags, discard: discard3 }),
+      return __compileRD(
+        (discard3) => __compile(term, lang, opts, { ...flags, discard: discard3 }),
         repeat2,
         discard2,
         opts
@@ -200,13 +197,13 @@ const compile = defmulti(
     alt: ($, 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)];
+      const acc = [__compile(term0, lang, opts, flags)];
       if (terms) {
         for (let c of terms) {
-          acc.push(compile(first(c), lang, opts, flags));
+          acc.push(__compile(__first(c), lang, opts, flags));
         }
       }
-      return compileRDL(
+      return __compileRDL(
         (optimize) => optimize || flags.discard ? acc.length > 1 ? altD(acc) : discard(acc[0]) : acc.length > 1 ? alt(acc) : acc[0],
         repeat2,
         disc,
@@ -236,17 +233,17 @@ const compile = defmulti(
     },
     charSel: ($, lang, opts, flags) => {
       opts.debug && console.log("charSel", flags);
-      const choices = nth($, 1).children.map(
-        (c) => compile(c, lang, opts, flags)
+      const choices = __nth($, 1).children.map(
+        (c) => __compile(c, lang, opts, flags)
       );
-      const invert = first($).result;
+      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) => {
+const __compileRepeat = (parser, rspec, opts) => {
   opts.debug && console.log(`repeat: ${rspec.id}`);
   if (rspec.id === "repeat") {
     switch (rspec.result) {
@@ -265,24 +262,29 @@ const compileRepeat = (parser, rspec, opts) => {
   }
   return parser;
 };
-const compileDiscard = (parser, dspec, opts) => {
+const __compileDiscard = (parser, dspec, opts) => {
   opts.debug && console.log(`discard:`, dspec.result);
   return dspec.result === "!" ? discard(parser) : parser;
 };
-const compileLookahead = (parser, spec, lang, opts) => {
+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 === "+"
+    __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),
+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 __compileRDL = (parser, rspec, dspec, lhspec, lang, opts) => __compileLookahead(
+  __compileRD(parser, rspec, dspec, opts),
+  lhspec,
+  lang,
+  opts
+);
 const defGrammar = (rules, env, opts) => {
   opts = { debug: false, optimize: true, ...opts };
   env = {
@@ -304,7 +306,7 @@ const defGrammar = (rules, env, opts) => {
   const ctx = defContext(rules);
   const result = (opts.debug ? print(GRAMMAR) : GRAMMAR)(ctx);
   if (result) {
-    return compile(
+    return __compile(
       ctx.root,
       {
         env,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/parse",
-  "version": "2.4.41",
+  "version": "2.4.43",
   "description": "Purely functional parser combinators & AST generation for generic inputs",
   "type": "module",
   "module": "./index.js",
@@ -10,7 +10,7 @@
     "type": "git",
     "url": "https://github.com/thi-ng/umbrella.git"
   },
-  "homepage": "https://github.com/thi-ng/umbrella/tree/develop/packages/parse#readme",
+  "homepage": "https://thi.ng/parse",
   "funding": [
     {
       "type": "github",
@@ -36,17 +36,17 @@
     "tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.11.1",
-    "@thi.ng/checks": "^3.6.3",
-    "@thi.ng/defmulti": "^3.0.38",
-    "@thi.ng/errors": "^2.5.6",
-    "@thi.ng/strings": "^3.7.32"
+    "@thi.ng/api": "^8.11.3",
+    "@thi.ng/checks": "^3.6.5",
+    "@thi.ng/defmulti": "^3.0.40",
+    "@thi.ng/errors": "^2.5.8",
+    "@thi.ng/strings": "^3.7.34"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.43.0",
-    "esbuild": "^0.20.2",
-    "typedoc": "^0.25.12",
-    "typescript": "^5.4.3"
+    "@microsoft/api-extractor": "^7.47.0",
+    "esbuild": "^0.21.5",
+    "typedoc": "^0.25.13",
+    "typescript": "^5.5.2"
   },
   "keywords": [
     "ast",
@@ -241,5 +241,5 @@
     ],
     "year": 2020
   },
-  "gitHead": "5dd66c18a3862a3af69a5b2f49563f7cbdd960c2\n"
+  "gitHead": "154c95cf9d6bab32174498ec3b5b5d87e42be7f9\n"
 }

package/presets/string.js

@@ -5,9 +5,9 @@ import { litD } from "../prims/lit.js";
 import { noneOf } from "../prims/none-of.js";
 import { join } from "../xform/join.js";
 import { ESC, UNICODE } from "./escape.js";
-const quote = litD('"');
+const QUOTE = litD('"');
 const STRING = join(
-  seq([quote, zeroOrMore(alt([UNICODE, ESC, noneOf('"')])), quote], "string")
+  seq([QUOTE, zeroOrMore(alt([UNICODE, ESC, noneOf('"')])), QUOTE], "string")
 );
 export {
   STRING

package/prims/satisfy.js

@@ -1,12 +1,10 @@
 const satisfy = (pred, id = "satisfy") => (ctx) => {
-  if (ctx.done)
-    return false;
+  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;
+  if (ctx.done) return false;
   const state = ctx.state;
   const reader = ctx.reader;
   return pred(reader.read(state)) ? (reader.next(state), true) : false;

package/prims/skip.d.ts

@@ -7,16 +7,17 @@ import type { Parser } from "../api.js";
  * of the input is reached, this parser will return true.
  *
  * @example
- * ```ts
- * import { defContext, litD, noneOfP, seqD, skipWhile } from "@thi.ng/parse";
+ * ```ts tangle:../../export/skip-while.ts
+ * import { defContext, litD, NL, noneOfP, seqD, skipWhile } from "@thi.ng/parse";
  *
  * const comment = seqD([litD("#"), skipWhile(noneOfP("\n")), NL]);
  *
  * const ctx = defContext("# ignore more!\n");
- * comment(ctx);
+ *
+ * console.log(comment(ctx));
  * // true
  *
- * ctx.state
+ * console.log(ctx.state);
  * // { p: 15, l: 2, c: 1, done: true, last: '\n' }
  * ```
  *

package/prims/skip.js

@@ -2,8 +2,7 @@ const skipWhile = (pred) => (ctx) => {
   const state = { ...ctx.state };
   const reader = ctx.reader;
   while (!state.done) {
-    if (!pred(reader.read(state)))
-      break;
+    if (!pred(reader.read(state))) break;
     reader.next(state);
   }
   ctx.state = state;

package/prims/string.js

@@ -1,12 +1,10 @@
 const string = (str, id = "string") => (ctx) => {
-  if (ctx.done)
-    return false;
+  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;
+    if (state.done) return false;
     const r = reader.read(state);
     if (r !== str[i]) {
       return ctx.discard();
@@ -17,13 +15,11 @@ const string = (str, id = "string") => (ctx) => {
   return ctx.end();
 };
 const stringD = (str) => (ctx) => {
-  if (ctx.done)
-    return false;
+  if (ctx.done) return false;
   const state = { ...ctx.state };
   const reader = ctx.reader;
   for (let i = 0, n = str.length; i < n; i++) {
-    if (state.done)
-      return false;
+    if (state.done) return false;
     const r = reader.read(state);
     if (r !== str[i]) {
       return false;
@@ -39,8 +35,7 @@ const stringOf = (pred, id = "string", reduce = (x) => x.join("")) => (ctx) => {
   let acc = [];
   while (!state.done) {
     const r = reader.read(state);
-    if (!pred(r))
-      break;
+    if (!pred(r)) break;
     acc.push(r);
     reader.next(state);
   }

package/readers/array-reader.js

@@ -6,8 +6,7 @@ class ArrayReader {
     return this._src[state.p];
   }
   next(state) {
-    if (state.done)
-      return;
+    if (state.done) return;
     state.last = this._src[state.p];
     state.done = ++state.p >= this._src.length;
   }

package/readers/string-reader.js

@@ -6,8 +6,7 @@ class StringReader {
     return this._src[state.p];
   }
   next(state) {
-    if (state.done)
-      return;
+    if (state.done) return;
     state.last = this._src[state.p];
     if (state.last === "\n") {
       state.l++;

package/utils.d.ts

@@ -5,5 +5,5 @@
  *
  * @internal
  */
-export declare const indent: (x: number) => string;
+export declare const __indent: (x: number) => string;
 //# sourceMappingURL=utils.d.ts.map

package/utils.js

@@ -1,5 +1,5 @@
-const cache = [];
-const indent = (x) => cache[x] = "  ".repeat(x);
+const CACHE = [];
+const __indent = (x) => CACHE[x] = "  ".repeat(x);
 export {
-  indent
+  __indent
 };

package/xform/comp.d.ts

@@ -3,7 +3,7 @@ import type { ScopeTransform } from "../api.js";
  * Takes any number of {@link ScopeTransform}s and composes them into
  * new xform w/ left to right order of execution.
  *
- * @param xs -
+ * @param xforms -
  */
-export declare const comp: <T>(...xs: ScopeTransform<T>[]) => ScopeTransform<T>;
+export declare const comp: <T>(...xforms: ScopeTransform<T>[]) => ScopeTransform<T>;
 //# sourceMappingURL=comp.d.ts.map

package/xform/comp.js

@@ -1,6 +1,6 @@
-const comp = (...xs) => {
-  const [a, b, c, d] = xs;
-  switch (xs.length) {
+const comp = (...xforms) => {
+  const [a, b, c, d] = xforms;
+  switch (xforms.length) {
     case 0:
       return (x) => x;
     case 1:
@@ -12,7 +12,7 @@ const comp = (...xs) => {
     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((scope2, x) => x(scope2, ctx, user), scope);
+      return (scope, ctx, user) => xforms.reduce((scope2, x) => x(scope2, ctx, user), scope);
   }
 };
 export {

package/xform/join.js

@@ -1,12 +1,10 @@
 import { xform } from "../combinators/xform.js";
 const xfJoin = (scope) => {
-  if (!scope || !scope.children)
-    return null;
+  if (!scope || !scope.children) return null;
   const res = [];
   for (let c of scope.children) {
     xfJoin(c);
-    if (c.result)
-      res.push(c.result);
+    if (c.result) res.push(c.result);
   }
   scope.result = res.join("");
   scope.children = null;

package/xform/nest.js

@@ -2,8 +2,7 @@ import { xform } from "../combinators/xform.js";
 import { defContext } from "../context.js";
 import { xfJoin } from "./join.js";
 const xfNest = (parser) => (scope, ctx) => {
-  if (!scope)
-    return;
+  if (!scope) return;
   const src = scope.result || xfJoin({ ...scope }).result;
   const inner = defContext(src, ctx.opts);
   const state = scope.state;

package/xform/print.d.ts

@@ -18,16 +18,16 @@ export declare const xfPrint: (fn?: Fn<string, void>) => ScopeTransform<any>;
  * Syntax sugar for `xform(parser, xfPrint)`.
  *
  * @example
- * ```ts
- * import { defContext, lit, oneOrMore, seq, ALPHA } from "@thi.ng/parse";
+ * ```ts tangle:../../export/print.ts
+ * import { ALPHA, defContext, lit, oneOrMore, print, seq } from "@thi.ng/parse";
  *
- * print(seq([lit("["), oneOrMore(ALPHA), lit("]")]))(defContext("[abc]"))
+ * print(seq([lit("["), oneOrMore(ALPHA), lit("]")]))(defContext("[abc]"));
  * // seq: null
  * //   lit: "["
  * //   repeat1: null
- * //     lit: "a"
- * //     lit: "b"
- * //     lit: "c"
+ * //     oneOf: "a"
+ * //     oneOf: "b"
+ * //     oneOf: "c"
  * //   lit: "]"
  * ```
  *

package/xform/print.js

@@ -1,10 +1,9 @@
 import { xform } from "../combinators/xform.js";
-import { indent } from "../utils.js";
+import { __indent } from "../utils.js";
 const xfPrint = (fn = console.log) => {
   const $print = (scope, _, level = 0) => {
-    if (!scope)
-      return;
-    const prefix = indent(level);
+    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)}`);