@thi.ng/parse 2.4.8 → 2.4.10

package/presets/hex.js

@@ -3,16 +3,11 @@ import { oneOrMore, repeat } from "../combinators/repeat.js";
 import { xform } from "../combinators/xform.js";
 import { oneOf } from "../prims/one-of.js";
 import { xfInt } from "../xform/number.js";
-/**
- * Matches single hex digit (case insensitive).
- */
-export const HEX_DIGIT = oneOf(HEX);
-/**
- * Matches one or more {@link HEX_DIGIT}s.
- */
-export const HEX_DIGITS = oneOrMore(HEX_DIGIT);
-/**
- * Matches 1-8 successive {@link HEX_DIGIT} and transforms with
- * {@link xfInt} to JS number.
- */
-export const HEX_UINT = xform(repeat(HEX_DIGIT, 1, 8, "uint"), xfInt(16));
+const HEX_DIGIT = oneOf(HEX);
+const HEX_DIGITS = oneOrMore(HEX_DIGIT);
+const HEX_UINT = xform(repeat(HEX_DIGIT, 1, 8, "uint"), xfInt(16));
+export {
+  HEX_DIGIT,
+  HEX_DIGITS,
+  HEX_UINT
+};

package/presets/numbers.js

@@ -10,31 +10,20 @@ import { join } from "../xform/join.js";
 import { xfFloat, xfInt } from "../xform/number.js";
 import { xfID } from "../xform/with-id.js";
 import { DIGIT, DIGITS } from "./digits.js";
-/**
- * Matches single `+` or `-` char.
- */
-export const SIGN = maybe(oneOf("-+"));
-/**
- * Matches optionally signed {@link DIGITS} and result transformed w/
- * {@link xfInt} to JS number.
- */
-export const INT = xform(seq([SIGN, DIGITS], "int"), xfInt());
-/**
- * Matches same as {@link DIGITS} but result transformed w/
- * {@link xfInt} to JS number.
- */
-export const UINT = xform(DIGITS, comp(xfID("uint"), xfInt()));
+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");
-/**
- * Matches IEEE754 floating point number.
- */
-export const REAL = join(_REAL);
-/**
- * Like {@link REAL} but transforms result w/ {@link xfFloat} to JS
- * number.
- */
-export const FLOAT = xform(_REAL, xfFloat);
+const REAL = join(_REAL);
+const FLOAT = xform(_REAL, xfFloat);
+export {
+  FLOAT,
+  INT,
+  REAL,
+  SIGN,
+  UINT
+};

package/presets/string.js

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

package/presets/whitespace.js

@@ -1,35 +1,21 @@
 import { WS as _WS } from "@thi.ng/strings/groups";
 import { oneOrMoreD, zeroOrMoreD } from "../combinators/repeat.js";
 import { oneOf, oneOfD } from "../prims/one-of.js";
-/**
- * Matches & discards single whitespace char: ` \t\n\r`.
- */
-export const WS = oneOfD(_WS);
-/**
- * Matches & discards single space or tab char.
- */
-export const SPACE = oneOfD(" \t");
-/**
- * Matches single `\n` or `\r` char.
- */
-export const NL = oneOf("\n\r");
-/**
- * Matches & discards single `\n` or `\r` char.
- */
-export const DNL = oneOfD("\n\r");
-/**
- * Zero or more {@link WS}. Result will be discarded.
- */
-export const WS0 = zeroOrMoreD(WS);
-/**
- * One or more {@link WS}. Result will be discarded.
- */
-export const WS1 = oneOrMoreD(WS);
-/**
- * Zero or more {@link SPACE}. Result will be discarded.
- */
-export const SPACES0 = zeroOrMoreD(SPACE);
-/**
- * One or more {@link SPACE}. Result will be discarded.
- */
-export const SPACES = oneOrMoreD(SPACE);
+const WS = oneOfD(_WS);
+const SPACE = oneOfD(" 	");
+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);
+export {
+  DNL,
+  NL,
+  SPACE,
+  SPACES,
+  SPACES0,
+  WS,
+  WS0,
+  WS1
+};

package/prims/always.js

@@ -1,3 +1,7 @@
 import { satisfy, satisfyD } from "./satisfy.js";
-export const always = (id = "always") => satisfy(() => true, id);
-export const alwaysD = () => satisfyD(() => true);
+const always = (id = "always") => satisfy(() => true, id);
+const alwaysD = () => satisfyD(() => true);
+export {
+  always,
+  alwaysD
+};

package/prims/anchor.js

@@ -1,26 +1,29 @@
 import { ALPHA_NUM } from "@thi.ng/strings/groups";
-export const anchor = (fn) => (ctx) => {
-    const state = ctx.state;
-    return fn(state.last, state.done ? null : ctx.reader.read(state));
+const anchor = (fn) => (ctx) => {
+  const state = ctx.state;
+  return fn(state.last, state.done ? null : ctx.reader.read(state));
 };
-export const inputStart = (ctx) => ctx.state.last == null;
-export const inputEnd = (ctx) => ctx.state.done || ctx.reader.read(ctx.state) === undefined;
-export const lineStart = (ctx) => {
-    const l = ctx.state.last;
-    return l == null || l === "\n" || l === "\r";
+const inputStart = (ctx) => ctx.state.last == null;
+const inputEnd = (ctx) => ctx.state.done || ctx.reader.read(ctx.state) === void 0;
+const lineStart = (ctx) => {
+  const l = ctx.state.last;
+  return l == null || l === "\n" || l === "\r";
 };
-export const lineEnd = (ctx) => {
-    const state = ctx.state;
-    let c;
-    return state.done || (c = ctx.reader.read(state)) === "\n" || c === "\r";
+const lineEnd = (ctx) => {
+  const state = ctx.state;
+  let c;
+  return state.done || (c = ctx.reader.read(state)) === "\n" || c === "\r";
 };
-export const wordBoundaryP = (prev, next) => {
-    return prev
-        ? next
-            ? ALPHA_NUM[prev] && !ALPHA_NUM[next]
-            : ALPHA_NUM[prev]
-        : next
-            ? ALPHA_NUM[next]
-            : false;
+const wordBoundaryP = (prev, next) => {
+  return prev ? next ? ALPHA_NUM[prev] && !ALPHA_NUM[next] : ALPHA_NUM[prev] : next ? ALPHA_NUM[next] : false;
+};
+const wordBoundary = anchor(wordBoundaryP);
+export {
+  anchor,
+  inputEnd,
+  inputStart,
+  lineEnd,
+  lineStart,
+  wordBoundary,
+  wordBoundaryP
 };
-export const wordBoundary = anchor(wordBoundaryP);

package/prims/fail.js

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

package/prims/lit.js

@@ -1,20 +1,9 @@
 import { satisfyD, satisfy } from "./satisfy.js";
-/**
- * HOF predicate for matching given single char literal.
- *
- * @param c -
- */
-export const litP = (c) => (x) => x === c;
-/**
- * Matches single char/value `c`.
- *
- * @param c -
- * @param id -
- */
-export const lit = (c, id = "lit") => satisfy(litP(c), id);
-/**
- * Discarded literal. Same as {@link lit}, but result will be discarded.
- *
- * @param c -
- */
-export const litD = (c) => satisfyD(litP(c));
+const litP = (c) => (x) => x === c;
+const lit = (c, id = "lit") => satisfy(litP(c), id);
+const litD = (c) => satisfyD(litP(c));
+export {
+  lit,
+  litD,
+  litP
+};

package/prims/none-of.js

@@ -1,20 +1,15 @@
 import { isPlainObject } from "@thi.ng/checks/is-plain-object";
 import { isSet } from "@thi.ng/checks/is-set";
 import { satisfy, satisfyD } from "./satisfy.js";
-/**
- * HOF predicate for matching single char against given options. Returns
- * true if there's no match.
- *
- * @param opts -
- */
-export const noneOfP = (opts) => isSet(opts)
-    ? (x) => !opts.has(x)
-    : isPlainObject(opts)
-        ? (x) => !opts[x]
-        : (x) => opts.indexOf(x) < 0;
-export function noneOf(opts, id = "noneOf") {
-    return satisfy(noneOfP(opts), id);
+const noneOfP = (opts) => isSet(opts) ? (x) => !opts.has(x) : isPlainObject(opts) ? (x) => !opts[x] : (x) => opts.indexOf(x) < 0;
+function noneOf(opts, id = "noneOf") {
+  return satisfy(noneOfP(opts), id);
 }
-export function noneOfD(opts) {
-    return satisfyD(noneOfP(opts));
+function noneOfD(opts) {
+  return satisfyD(noneOfP(opts));
 }
+export {
+  noneOf,
+  noneOfD,
+  noneOfP
+};

package/prims/one-of.js

@@ -1,19 +1,15 @@
 import { isPlainObject } from "@thi.ng/checks/is-plain-object";
 import { isSet } from "@thi.ng/checks/is-set";
 import { satisfy, satisfyD } from "./satisfy.js";
-/**
- * HOF predicate for matching single char against given options.
- *
- * @param opts -
- */
-export const oneOfP = (opts) => isSet(opts)
-    ? (x) => opts.has(x)
-    : isPlainObject(opts)
-        ? (x) => opts[x]
-        : (x) => opts.indexOf(x) >= 0;
-export function oneOf(opts, id = "oneOf") {
-    return satisfy(oneOfP(opts), id);
+const oneOfP = (opts) => isSet(opts) ? (x) => opts.has(x) : isPlainObject(opts) ? (x) => opts[x] : (x) => opts.indexOf(x) >= 0;
+function oneOf(opts, id = "oneOf") {
+  return satisfy(oneOfP(opts), id);
 }
-export function oneOfD(opts) {
-    return satisfyD(oneOfP(opts));
+function oneOfD(opts) {
+  return satisfyD(oneOfP(opts));
 }
+export {
+  oneOf,
+  oneOfD,
+  oneOfP
+};

package/prims/pass.js

@@ -1,13 +1,7 @@
 import { isFunction } from "@thi.ng/checks/is-function";
-/**
- * Parser which consumes no input and always succeeds. Adds new AST node
- * with `result`.
- *
- * @param result -
- * @param id -
- */
-export const pass = (result, id = "pass") => (ctx) => ctx.addChild(id, isFunction(result) ? result() : result);
-/**
- * Parser which consumes no input and always succeeds. No AST creation.
- */
-export const passD = () => true;
+const pass = (result, id = "pass") => (ctx) => ctx.addChild(id, isFunction(result) ? result() : result);
+const passD = () => true;
+export {
+  pass,
+  passD
+};

package/prims/range.js

@@ -1,41 +1,22 @@
 import { satisfy, satisfyD } from "./satisfy.js";
-/**
- * HOF predicate for matching single char within given range.
- *
- * @param min -
- * @param max -
- */
-export const rangeP = (min, max) => (x) => x >= min && x <= max;
-/**
- * HOF predicate for matching single char within given UTF16 codepoint
- * range.
- *
- * @param min -
- * @param max -
- */
-export const utf16RangeP = (min, max) => (x) => {
-    const c = x.charCodeAt(0);
-    return c >= min && c <= max;
+const rangeP = (min, max) => (x) => x >= min && x <= max;
+const utf16RangeP = (min, max) => (x) => {
+  const c = x.charCodeAt(0);
+  return c >= min && c <= max;
 };
-export function range(min, max, id = "lit") {
-    return satisfy(rangeP(min, max), id);
+function range(min, max, id = "lit") {
+  return satisfy(rangeP(min, max), id);
 }
-export function rangeD(min, max) {
-    return satisfyD(rangeP(min, max));
+function rangeD(min, max) {
+  return satisfyD(rangeP(min, max));
 }
-/**
- * Matches single char in given UTF-16 codepoint range.
- *
- * @param min -
- * @param max -
- * @param id -
- */
-export const utf16Range = (min, max, id = "utfLit") => satisfy(utf16RangeP(min, max), id);
-/**
- * Matches single char in given UTF-16 codepoint range.
- *
- * @param min -
- * @param max -
- * @param id -
- */
-export const utf16RangeD = (min, max) => satisfyD(utf16RangeP(min, max));
+const utf16Range = (min, max, id = "utfLit") => satisfy(utf16RangeP(min, max), id);
+const utf16RangeD = (min, max) => satisfyD(utf16RangeP(min, max));
+export {
+  range,
+  rangeD,
+  rangeP,
+  utf16Range,
+  utf16RangeD,
+  utf16RangeP
+};

package/prims/satisfy.js

@@ -1,19 +1,17 @@
-export 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;
-});
-/**
- * Like {@link satisfy}, but avoids creating AST node and discards
- * result.
- *
- * @param pred -
- */
-export 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 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;
+};
+export {
+  satisfy,
+  satisfyD
+};

package/prims/skip.js

@@ -1,31 +1,14 @@
-/**
- * Consumes input, but ignores it as long as given `pred` predicate fn
- * returns true. The char for which `pred` fails will NOT be consumed
- * and the context state will be forwarded to that position. If the end
- * of the input is reached, this parser will return true.
- *
- * @example
- * ```ts
- * const comment = seqD([litD("#"), skipWhile(noneOfP("\n")), NL]);
- *
- * const ctx = defContext("# ignore more!\n");
- * comment(ctx);
- * // true
- *
- * ctx.state
- * // { p: 15, l: 2, c: 1, done: true, last: '\n' }
- * ```
- *
- * @param pred -
- */
-export const skipWhile = (pred) => (ctx) => {
-    const state = { ...ctx.state };
-    const reader = ctx.reader;
-    while (!state.done) {
-        if (!pred(reader.read(state)))
-            break;
-        reader.next(state);
-    }
-    ctx.state = state;
-    return true;
+const skipWhile = (pred) => (ctx) => {
+  const state = { ...ctx.state };
+  const reader = ctx.reader;
+  while (!state.done) {
+    if (!pred(reader.read(state)))
+      break;
+    reader.next(state);
+  }
+  ctx.state = state;
+  return true;
+};
+export {
+  skipWhile
 };

package/prims/string.js

@@ -1,48 +1,53 @@
-export 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);
+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();
     }
-    scope.result = str;
-    return ctx.end();
+    reader.next(state);
+  }
+  scope.result = str;
+  return ctx.end();
 };
-export const stringD = (str) => (ctx) => {
-    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;
-        const r = reader.read(state);
-        if (r !== str[i]) {
-            return false;
-        }
-        reader.next(state);
+const stringD = (str) => (ctx) => {
+  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;
+    const r = reader.read(state);
+    if (r !== str[i]) {
+      return false;
     }
-    ctx.state = state;
-    return true;
+    reader.next(state);
+  }
+  ctx.state = state;
+  return true;
 };
-export const stringOf = (pred, id = "string", reduce = (x) => x.join("")) => (ctx) => {
-    const state = { ...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 stringOf = (pred, id = "string", reduce = (x) => x.join("")) => (ctx) => {
+  const state = { ...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);
+};
+export {
+  string,
+  stringD,
+  stringOf
 };

package/readers/array-reader.js

@@ -1,22 +1,24 @@
 class ArrayReader {
-    _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];
-        state.done = ++state.p >= this._src.length;
-    }
-    isDone(state) {
-        return (state.done = state.p >= this._src.length);
-    }
-    format(state) {
-        return `offset ${state.p}`;
-    }
+  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}`;
+  }
 }
-export const defArrayReader = (input) => new ArrayReader(input);
+const defArrayReader = (input) => new ArrayReader(input);
+export {
+  defArrayReader
+};