@thi.ng/parse 2.4.9 → 2.4.11

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-18T13:41:20Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -90,7 +90,7 @@ For Node.js REPL:
 const parse = await import("@thi.ng/parse");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 5.23 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 5.21 KB
 
 ## Dependencies
 

package/api.js

@@ -1 +0,0 @@
-export {};

package/combinators/alt.js

@@ -1,25 +1,19 @@
 import { string } from "../prims/string.js";
 import { discard } from "../xform/discard.js";
-export 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;
-        }
-    }
+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 altS = (strings) => alt(strings.map((x) => string(x)));
+const altD = (parsers) => discard(alt(parsers));
+export {
+  alt,
+  altD,
+  altS
 };
-/**
- * Syntax sugar for {@link alt}. Takes an array of strings to match and creates
- * parsers for each before passing them to `alt()`.
- *
- * @param strings
- */
-export const altS = (strings) => alt(strings.map((x) => string(x)));
-/**
- * Wrapped version of {@link alt} which discards results if successful match.
- *
- * @param parsers
- */
-export const altD = (parsers) => discard(alt(parsers));

package/combinators/boundary.js

@@ -1,6 +1,12 @@
 import { inputEnd, inputStart, lineEnd, lineStart } from "../prims/anchor.js";
 import { seq } from "./seq.js";
-export const startsWith = (parser) => seq([inputStart, parser]);
-export const endsWith = (parser) => seq([parser, inputEnd]);
-export const entireLine = (parser) => seq([lineStart, parser, lineEnd]);
-export const entirely = (parser) => seq([inputStart, parser, inputEnd]);
+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]);
+export {
+  endsWith,
+  entireLine,
+  entirely,
+  startsWith
+};

package/combinators/check.js

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

package/combinators/dynamic.js

@@ -1,19 +1,9 @@
-/**
- * Returns a parser function placeholder, whose implementation can be
- * set at a later stage via calling `.set()`.
- *
- * @examples
- * ```ts
- * const parser = dynamic<string>();
- * parser.set(lit("a"));
- *
- * parser(defContext("a"));
- * // true
- * ```
- */
-export const dynamic = () => {
-    let impl;
-    const wrapper = (ctx) => (impl ? impl(ctx) : false);
-    wrapper.set = (p) => (impl = p);
-    return wrapper;
+const dynamic = () => {
+  let impl;
+  const wrapper = (ctx) => impl ? impl(ctx) : false;
+  wrapper.set = (p) => impl = p;
+  return wrapper;
+};
+export {
+  dynamic
 };

package/combinators/expect.js

@@ -1,2 +1,5 @@
 import { parseError } from "../error.js";
-export const expect = (parser, err) => (ctx) => parser(ctx) || parseError(ctx, err);
+const expect = (parser, err) => (ctx) => parser(ctx) || parseError(ctx, err);
+export {
+  expect
+};

package/combinators/lookahead.js

@@ -1,79 +1,19 @@
-/**
- * Repeatedly runs `main` and look-`ahead` parsers for as long as the
- * former succeeds and UNTIL the latter passes or end of input is
- * reached. If the `ahead` parser never passes, the entire parser fails
- * and any partial matches are discarded.
- *
- * @remarks
- * Depending on `capture` (default: false), the result of the `ahead`
- * parser is captured or omitted and the final read position is adjusted
- * accordingly.
- *
- * Currently, iff `capture` is disabled, the `ahead` parser MUST discard
- * its own result (e.g. via {@link discard}). On successful match the
- * final read position will then be restored to the beginning of `ahead`
- * pattern.
- *
- * Iff `capture` is enabled, the `ahead` parser MAY discard its own
- * result, but the final read position will not be re-adjusted as in the
- * non-capturing version.
- *
- * **Important:** Since the main term will be repeated automatically, DO
- * NOT use repetition modifiers `?` or `*`, since both of these will
- * cause the parser to go into an infinite loop. This is expected
- * behavior and not a bug.
- *
- * @example
- * ```ts
- * const ctx = defContext("ababaaabbabba");
- *
- * // consume while 'a' or `b` and until 1st occurrence of "abba"...
- * // note the use of `stringD()` to discard lookahead result
- *
- * // non-capturing lookahead
- * join(lookahead(oneOf("ab"), stringD("abba")))(ctx)
- * // true
- *
- * ctx.result
- * // "ababaa"
- *
- * ctx.state
- * // { p: 6, l: 1, c: 7, done: false, last: 'a' }
- * ```
- *
- * @example
- * ```ts
- * const ctx = defContext("ababaaabbabba");
- *
- * // capturing lookahead
- * join(lookahead(oneOf("ab"), string("abba"), true))(ctx)
- * // true
- *
- * ctx.result
- * // "ababaaabba"
- *
- * ctx.state
- * // { p: 10, l: 1, c: 11, done: false, last: 'a' }
- * ```
- *
- * @param parser -
- * @param ahead -
- * @param capture -
- * @param id -
- */
-export 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 : { ...ctx.state };
-        if (ahead(ctx)) {
-            !capture && (ctx.state = state);
-            return pass ? ctx.end() : ctx.discard();
-        }
-        if (!parser(ctx))
-            return ctx.discard();
-        pass = true;
+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 : { ...ctx.state };
+    if (ahead(ctx)) {
+      !capture && (ctx.state = state);
+      return pass ? ctx.end() : ctx.discard();
     }
+    if (!parser(ctx))
+      return ctx.discard();
+    pass = true;
+  }
+};
+export {
+  lookahead
 };

package/combinators/maybe.js

@@ -1,2 +1,5 @@
 import { pass } from "../prims/pass.js";
-export const maybe = (parser, result, id = "maybe") => (ctx) => parser(ctx) || pass(result, id)(ctx);
+const maybe = (parser, result, id = "maybe") => (ctx) => parser(ctx) || pass(result, id)(ctx);
+export {
+  maybe
+};

package/combinators/not.js

@@ -1,19 +1,12 @@
 import { always } from "../prims/always.js";
-/**
- * Runs `parser`, discards its result and if it passed returns false,
- * else runs `fail` parser and returns its result. By default `fail` is
- * using {@link always}, which consumes a single character and always
- * succeeds. To avoid consuming a character on first `parser`'s failure,
- * use {@link pass} or {@link passD} instead.
- *
- * @param parser -
- * @param fail -
- */
-export 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 not = (parser, fail = always()) => (ctx) => {
+  if (ctx.done)
+    return false;
+  ctx.start("");
+  const res = parser(ctx);
+  ctx.discard();
+  return res ? false : fail(ctx);
+};
+export {
+  not
 };

package/combinators/repeat.js

@@ -1,21 +1,29 @@
 import { discard } from "../xform/discard.js";
-export const repeat = (parser, min, max, id = "repeat") => (ctx) => {
-    if (ctx.done) {
-        return min < 1 ? ctx.addChild(id) : false;
+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;
     }
-    ctx.start(id);
-    for (let i = 0; i < max; i++) {
-        if (!parser(ctx)) {
-            if (i < min) {
-                return ctx.discard();
-            }
-            break;
-        }
-    }
-    return ctx.end();
+  }
+  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);
+export {
+  oneOrMore,
+  oneOrMoreD,
+  repeat,
+  repeatD,
+  zeroOrMore,
+  zeroOrMoreD
 };
-export const zeroOrMore = (parser, id = "repeat0", max = Infinity) => repeat(parser, 0, max, id);
-export const oneOrMore = (parser, id = "repeat1", max = Infinity) => repeat(parser, 1, max, id);
-export const repeatD = (parser, min, max) => discard(repeat(parser, min, max));
-export const zeroOrMoreD = (parser, max = Infinity) => repeatD(parser, 0, max);
-export const oneOrMoreD = (parser, max = Infinity) => repeatD(parser, 1, max);

package/combinators/seq.js

@@ -1,13 +1,17 @@
 import { discard } from "../xform/discard.js";
-export 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();
-        }
+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();
+  }
+  return ctx.end();
+};
+const seqD = (parsers) => discard(seq(parsers));
+export {
+  seq,
+  seqD
 };
-export const seqD = (parsers) => discard(seq(parsers));

package/combinators/wrap.js

@@ -1,4 +1,7 @@
 import { litD } from "../prims/lit.js";
 import { hoist } from "../xform/hoist.js";
 import { seq } from "./seq.js";
-export const wrap = (parser, pre, post = pre) => hoist(seq([litD(pre), parser, litD(post)]));
+const wrap = (parser, pre, post = pre) => hoist(seq([litD(pre), parser, litD(post)]));
+export {
+  wrap
+};

package/combinators/xform.js

@@ -1,16 +1,18 @@
-export 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;
+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 false;
+    return true;
+  }
+  return false;
+};
+export {
+  xform
 };

package/context.js

@@ -4,144 +4,141 @@ import { parseError } from "./error.js";
 import { defArrayReader } from "./readers/array-reader.js";
 import { defStringReader } from "./readers/string-reader.js";
 import { indent } from "./utils.js";
-export class ParseContext {
-    reader;
-    opts;
-    _scopes;
-    _curr;
-    _maxDepth;
-    _peakDepth;
-    _debug;
-    _retain;
-    constructor(reader, opts) {
-        this.reader = reader;
-        this.opts = { maxDepth: 64, debug: false, retain: false, ...opts };
-        this._maxDepth = this.opts.maxDepth;
-        this._debug = this.opts.debug;
-        this._retain = this.opts.retain;
-        this.reset();
+class ParseContext {
+  constructor(reader, opts) {
+    this.reader = reader;
+    this.opts = { maxDepth: 64, debug: false, retain: false, ...opts };
+    this._maxDepth = this.opts.maxDepth;
+    this._debug = this.opts.debug;
+    this._retain = this.opts.retain;
+    this.reset();
+  }
+  opts;
+  _scopes;
+  _curr;
+  _maxDepth;
+  _peakDepth;
+  _debug;
+  _retain;
+  reset() {
+    this._curr = {
+      id: "root",
+      state: { p: 0, l: 1, c: 1 },
+      children: null,
+      result: null
+    };
+    this._scopes = [this._curr];
+    this._peakDepth = 1;
+    this.reader.isDone(this._curr.state);
+    return this;
+  }
+  start(id) {
+    if (this._scopes.length >= this._maxDepth) {
+      parseError(this, `recursion limit reached ${this._maxDepth}`);
     }
-    reset() {
-        this._curr = {
-            id: "root",
-            state: { p: 0, l: 1, c: 1 },
-            children: null,
-            result: null,
-        };
-        this._scopes = [this._curr];
-        this._peakDepth = 1;
-        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: { ...scopes[scopes.length - 1].state },
-            children: null,
-            result: null,
-        };
-        scopes.push(scope);
-        this._peakDepth = Math.max(this._peakDepth, scopes.length);
-        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;
-    }
-    /**
-     * Returns root node.
-     */
-    get root() {
-        return this._scopes[0];
-    }
-    /**
-     * Returns root node's `result` or `undefined`.
-     */
-    get result() {
-        const children = this.root.children;
-        return children ? children[0].result : undefined;
-    }
-    /**
-     * Returns root node's children or `undefined`.
-     */
-    get children() {
-        const children = this.root.children;
-        return children ? children[0].children : undefined;
-    }
-    /**
-     * Returns max. recursion depth which was actually reached. Will always be
-     * less or equal configured {@link ContextOpts.maxDepth}.
-     */
-    get peakDepth() {
-        return this._peakDepth;
+    const scopes = this._scopes;
+    const scope = {
+      id,
+      state: { ...scopes[scopes.length - 1].state },
+      children: null,
+      result: null
+    };
+    scopes.push(scope);
+    this._peakDepth = Math.max(this._peakDepth, scopes.length);
+    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;
+  }
+  /**
+   * Returns root node.
+   */
+  get root() {
+    return this._scopes[0];
+  }
+  /**
+   * Returns root node's `result` or `undefined`.
+   */
+  get result() {
+    const children = this.root.children;
+    return children ? children[0].result : void 0;
+  }
+  /**
+   * Returns root node's children or `undefined`.
+   */
+  get children() {
+    const children = this.root.children;
+    return children ? children[0].children : void 0;
+  }
+  /**
+   * Returns max. recursion depth which was actually reached. Will always be
+   * less or equal configured {@link ContextOpts.maxDepth}.
+   */
+  get peakDepth() {
+    return this._peakDepth;
+  }
 }
-export function defContext(input, opts) {
-    return new ParseContext(isString(input)
-        ? defStringReader(input)
-        : isArrayLike(input)
-            ? defArrayReader(input)
-            : input, opts);
+function defContext(input, opts) {
+  return new ParseContext(
+    isString(input) ? defStringReader(input) : isArrayLike(input) ? defArrayReader(input) : input,
+    opts
+  );
 }
+export {
+  ParseContext,
+  defContext
+};