@thi.ng/parse 2.4.9 → 2.4.10

package/readers/string-reader.js

@@ -1,29 +1,30 @@
 class StringReader {
-    _src;
-    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})`;
+  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})`;
+  }
 }
-export const defStringReader = (input) => new StringReader(input);
+const defStringReader = (input) => new StringReader(input);
+export {
+  defStringReader
+};

package/utils.js

@@ -1,10 +1,5 @@
-// thing:no-export
 const cache = [];
-/**
- * Memoized indentation.
- *
- * @param x -
- *
- * @internal
- */
-export const indent = (x) => (cache[x] = "  ".repeat(x));
+const indent = (x) => cache[x] = "  ".repeat(x);
+export {
+  indent
+};

package/xform/collect.js

@@ -1,18 +1,11 @@
 import { xform } from "../combinators/xform.js";
-/**
- * Collects results of all direct children into an array, then discards
- * children. Also see {@link collect}.
- *
- * @param scope -
- */
-export const xfCollect = (scope) => {
-    scope.result = scope.children.map((c) => c.result);
-    scope.children = null;
-    return scope;
+const xfCollect = (scope) => {
+  scope.result = scope.children.map((c) => c.result);
+  scope.children = null;
+  return scope;
+};
+const collect = (parser) => xform(parser, xfCollect);
+export {
+  collect,
+  xfCollect
 };
-/**
- * Syntax sugar for `xform(parser, xfCollect)`.
- *
- * @param parser -
- */
-export const collect = (parser) => xform(parser, xfCollect);

package/xform/comp.js

@@ -1,23 +1,20 @@
-/**
- * Takes any number of {@link ScopeTransform}s and composes them into
- * new xform w/ left to right order of execution.
- *
- * @param xs -
- */
-export 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 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((scope2, x) => x(scope2, ctx, user), scope);
+  }
+};
+export {
+  comp
 };

package/xform/count.js

@@ -1,18 +1,11 @@
 import { xform } from "../combinators/xform.js";
-/**
- * Stores number of children as result, then discards children. Also see
- * {@link count}.
- *
- * @param scope -
- */
-export const xfCount = (scope) => {
-    scope.result = scope.children ? scope.children.length : 0;
-    scope.children = null;
-    return scope;
+const xfCount = (scope) => {
+  scope.result = scope.children ? scope.children.length : 0;
+  scope.children = null;
+  return scope;
+};
+const count = (parser) => xform(parser, xfCount);
+export {
+  count,
+  xfCount
 };
-/**
- * Syntax sugar for `xform(parser, xfCount)`.
- *
- * @param parser -
- */
-export const count = (parser) => xform(parser, xfCount);

package/xform/discard.js

@@ -1,11 +1,7 @@
 import { xform } from "../combinators/xform.js";
-/**
- * Discards AST node and any of its children.
- */
-export const xfDiscard = () => null;
-/**
- * Syntax sugar for `xform(parser, xfDiscard)`.
- *
- * @param parser -
- */
-export const discard = (parser) => xform(parser, xfDiscard);
+const xfDiscard = () => null;
+const discard = (parser) => xform(parser, xfDiscard);
+export {
+  discard,
+  xfDiscard
+};

package/xform/hoist.js

@@ -1,33 +1,18 @@
 import { xform } from "../combinators/xform.js";
-/**
- * Replace AST node with its first child node. Also see {@link hoist}.
- *
- * @param scope -
- */
-export const xfHoist = (scope) => {
-    Object.assign(scope, scope.children[0]);
-    return scope;
+const xfHoist = (scope) => {
+  Object.assign(scope, scope.children[0]);
+  return scope;
 };
-/**
- * Moves the result of first child node to this node, then discards all
- * children. Also see {@link hoistR}.
- *
- * @param scope -
- */
-export const xfHoistResult = (scope) => {
-    scope.result = scope.children[0].result;
-    scope.children = null;
-    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);
+export {
+  hoist,
+  hoistResult,
+  xfHoist,
+  xfHoistResult
 };
-/**
- * Syntax sugar for `xform(parser, xfHoist)`.
- *
- * @param parser -
- */
-export const hoist = (parser) => xform(parser, xfHoist);
-/**
- * Syntax sugar for `xform(parser, xfHoistR)`.
- *
- * @param parser -
- */
-export const hoistResult = (parser) => xform(parser, xfHoistResult);

package/xform/join.js

@@ -1,26 +1,19 @@
 import { xform } from "../combinators/xform.js";
-/**
- * Recursively joins non-null results of all children into a single
- * string, then discards children. Also see {@link join}.
- *
- * @param scope -
- */
-export 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 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);
+export {
+  join,
+  xfJoin
 };
-/**
- * Syntax sugar for `xform(parser, xfJoin)`.
- *
- * @param parser -
- */
-export const join = (parser) => xform(parser, xfJoin);

package/xform/json.js

@@ -1,18 +1,11 @@
 import { xform } from "../combinators/xform.js";
 import { xfJoin } from "./join.js";
-/**
- * First joins all children via {@link xfJoin}, then parses resulting string
- * using `JSON.parse()`.
- *
- * @param scope -
- */
-export const xfJson = (scope) => {
-    scope.result = JSON.parse(xfJoin(scope).result);
-    return scope;
+const xfJson = (scope) => {
+  scope.result = JSON.parse(xfJoin(scope).result);
+  return scope;
+};
+const json = (parser) => xform(parser, xfJson);
+export {
+  json,
+  xfJson
 };
-/**
- * Syntax sugar for `xform(parser, xfJson)`.
- *
- * @param parser -
- */
-export const json = (parser) => xform(parser, xfJson);

package/xform/nest.js

@@ -1,36 +1,25 @@
 import { xform } from "../combinators/xform.js";
 import { defContext } from "../context.js";
 import { xfJoin } from "./join.js";
-/**
- * HOF scope transform which applies given parser to result of given scope's
- * result, or if result is null, first joins children using {@link xfJoin}.
- *
- * @remarks
- * The nested parser is applied to a separate {@link ParseContext} and if
- * successful, the resulting AST will be transplated into the current parse
- * scope. If the nested parser fails, the scope will remain untouched.
- *
- * If the current parse context retains line/column details, the inner parse
- * context will be configured to produce true absolute offsets for its results
- * as if they were in the main context.
- *
- * @param parser -
- */
-export const xfNest = (parser) => (scope, ctx) => {
-    if (!scope)
-        return;
-    const src = scope.result || xfJoin({ ...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 xfNest = (parser) => (scope, ctx) => {
+  if (!scope)
+    return;
+  const src = scope.result || xfJoin({ ...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));
+export {
+  nest,
+  xfNest
 };
-export const nest = (outer, inner) => xform(outer, xfNest(inner));

package/xform/number.js

@@ -1,40 +1,20 @@
 import { xform } from "../combinators/xform.js";
 import { xfJoin } from "./join.js";
-/**
- * Higher order transform. First joins all children via {@link xfJoin},
- * then parses resulting string into an integer with given `radix`.
- *
- * @param radix -
- */
-export const xfInt = (radix = 10) => (scope) => {
-    scope.result = parseInt(xfJoin(scope).result, radix);
-    return scope;
+const xfInt = (radix = 10) => (scope) => {
+  scope.result = parseInt(xfJoin(scope).result, radix);
+  return scope;
 };
-/**
- * Syntax sugar for `xform(parser, xfInt(10))`
- *
- * @param parser
- */
-export const int = (parser) => xform(parser, xfInt(10));
-/**
- * Syntax sugar for `xform(parser, xfInt(16))`
- *
- * @param parser
- */
-export const hexInt = (parser) => xform(parser, xfInt(16));
-/**
- * First joins all children via {@link xfJoin}, then parses resulting
- * string into a floating point value.
- *
- * @param scope -
- */
-export const xfFloat = (scope) => {
-    scope.result = parseFloat(xfJoin(scope).result);
-    return scope;
+const int = (parser) => xform(parser, xfInt(10));
+const hexInt = (parser) => xform(parser, xfInt(16));
+const xfFloat = (scope) => {
+  scope.result = parseFloat(xfJoin(scope).result);
+  return scope;
+};
+const float = (parser) => xform(parser, xfFloat);
+export {
+  float,
+  hexInt,
+  int,
+  xfFloat,
+  xfInt
 };
-/**
- * Syntax sugar for `xform(parser, xfFloat)`
- *
- * @param parser
- */
-export const float = (parser) => xform(parser, xfFloat);

package/xform/print.js

@@ -1,50 +1,24 @@
 import { xform } from "../combinators/xform.js";
 import { indent } from "../utils.js";
-/**
- * Side effect only. Higher order scope transform. Traverses current AST
- * node and all children and prints each node's ID, result and reader
- * state (if available). Also see {@link print}.
- *
- * @remarks
- * The optional `fn` function is used to print each AST node (default:
- * `console.log`).
- *
- * @param scope -
- * @param ctx -
- * @param level -
- */
-export 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 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));
+export {
+  print,
+  xfPrint
 };
-/**
- * Syntax sugar for `xform(parser, xfPrint)`.
- *
- * @example
- * ```ts
- * print(seq([lit("["), oneOrMore(ALPHA), lit("]")]))(defContext("[abc]"))
- * // seq: null
- * //   lit: "["
- * //   repeat1: null
- * //     lit: "a"
- * //     lit: "b"
- * //     lit: "c"
- * //   lit: "]"
- * ```
- *
- * @param parser -
- */
-export const print = (parser, fn) => xform(parser, xfPrint(fn));

package/xform/replace.js

@@ -1,19 +1,11 @@
 import { xform } from "../combinators/xform.js";
-/**
- * HOF scope transform which replaces a node's result with given pre-configured
- * value and discards node's children. Also see {@link replace}.
- *
- * @param result - replacement value
- */
-export const xfReplace = (result) => (scope) => {
-    scope.result = result;
-    scope.children = null;
-    return scope;
+const xfReplace = (result) => (scope) => {
+  scope.result = result;
+  scope.children = null;
+  return scope;
+};
+const replace = (parser, result) => xform(parser, xfReplace(result));
+export {
+  replace,
+  xfReplace
 };
-/**
- * Syntax sugar for `xform(parser, xfReplace(result))`.
- *
- * @param parser -
- * @param result -
- */
-export const replace = (parser, result) => xform(parser, xfReplace(result));

package/xform/trim.js

@@ -1,19 +1,10 @@
 import { xform } from "../combinators/xform.js";
-/**
- * Uses `String.trim()` to remove leading and trailing white space and
- * linebreak chars from node result.
- *
- * {@link trim}.
- *
- * @param scope -
- */
-export const xfTrim = (scope) => {
-    scope.result = scope.result.trim();
-    return scope;
+const xfTrim = (scope) => {
+  scope.result = scope.result.trim();
+  return scope;
+};
+const trim = (parser) => xform(parser, xfTrim);
+export {
+  trim,
+  xfTrim
 };
-/**
- * Syntax sugar for `xform(parser, xfTrim)`.
- *
- * @param parser -
- */
-export const trim = (parser) => xform(parser, xfTrim);

package/xform/with-id.js

@@ -1,9 +1,7 @@
 import { xform } from "../combinators/xform.js";
-/**
- * Assigns given `id` to AST node. E.g. used for re-labeling parser
- * results defined by {@link defGrammar}.
- *
- * @param id -
- */
-export const xfID = (id) => (scope) => ((scope.id = id), scope);
-export const withID = (id, parser) => xform(parser, xfID(id));
+const xfID = (id) => (scope) => (scope.id = id, scope);
+const withID = (id, parser) => xform(parser, xfID(id));
+export {
+  withID,
+  xfID
+};