@claudiu-ceia/combine 0.2.4

package/esm/src/parsers.js

@@ -0,0 +1,256 @@
+import { any, either, many1, peek, seq, skipMany1 } from "./combinators.js";
+import { failure, success } from "./Parser.js";
+import { Trie } from "./Trie.js";
+import { map } from "./utility.js";
+/**
+ * Matches a given string.
+ */
+export const str = (match) => {
+    return (ctx) => {
+        const endIdx = ctx.index + match.length;
+        if (ctx.text.substring(ctx.index, endIdx) === match) {
+            return success({ ...ctx, index: endIdx }, match);
+        }
+        else {
+            return failure(ctx, match);
+        }
+    };
+};
+/**
+ * Matches any of the given strings by using a trie.
+ * Use instead of `any(str("..."), ...) when you want
+ * to match against many possible strings.
+ */
+export const trie = (matches) => {
+    // Build trie once at parser creation time, not on every parse
+    const t = new Trie();
+    t.insertMany(matches);
+    const longest = matches.reduce((acc, s) => (s.length > acc ? s.length : acc), 0);
+    return (ctx) => {
+        const candidate = ctx.text.substring(ctx.index, ctx.index + longest);
+        const [exists, match] = t.existsSubstring(candidate);
+        if (exists && match) {
+            return success({
+                ...ctx,
+                index: ctx.index + match.length,
+            }, match);
+        }
+        return failure(ctx, `Expected one of ${matches.join(", ")}`);
+    };
+};
+/**
+ * Matches a given character by UTF-16 code.
+ */
+export const char = (code) => {
+    return (ctx) => {
+        const match = String.fromCharCode(code);
+        return str(match)(ctx);
+    };
+};
+/**
+ * Matches any single character.
+ */
+export const anyChar = () => {
+    return (ctx) => {
+        if (ctx.index === ctx.text.length) {
+            return failure(ctx, "reached end of input");
+        }
+        return success({ ...ctx, index: ctx.index + 1 }, ctx.text.substring(ctx.index, ctx.index + 1));
+    };
+};
+/**
+ * Matches any character not matching the given UTF-16 code.
+ */
+export const notChar = (code) => {
+    return (ctx) => {
+        const res = char(code)(ctx);
+        const matchLength = String.fromCharCode(code).length;
+        if (!res.success) {
+            const endIdx = res.ctx.index + matchLength;
+            return success({ ...res.ctx, index: endIdx }, res.ctx.text.substring(res.ctx.index, endIdx));
+        }
+        return failure({ ...res.ctx, index: res.ctx.index - matchLength }, `found char "${res.value}"`);
+    };
+};
+/**
+ * Matches any character based on a predicate.
+ */
+export const charWhere = (pred) => {
+    return (ctx) => {
+        const res = regex(/./, "expected any single char")(ctx);
+        if (!res.success) {
+            return res;
+        }
+        const satisfied = pred(res.value.charCodeAt(0));
+        if (satisfied) {
+            return res;
+        }
+        return failure(res.ctx, `char ${res.value} failed the predicate`);
+    };
+};
+/**
+ * Skips matching any character not matching the given UTF-16 code.
+ */
+export const skipCharWhere = (pred) => {
+    return (ctx) => {
+        const res = charWhere(pred)(ctx);
+        if (!res.success) {
+            return res;
+        }
+        return success(res.ctx, null);
+    };
+};
+/**
+ * Matches any single decimal digit
+ */
+export const digit = () => {
+    return (ctx) => {
+        const isDigit = regex(/[0-9]/, "expected digit");
+        return map(isDigit, (digit) => {
+            return parseInt(digit, 10);
+        })(ctx);
+    };
+};
+/**
+ * Matches any single letter (case insesitive A-Z)
+ */
+export const letter = () => {
+    return (ctx) => {
+        return regex(/[a-zA-Z]/, "expected letter")(ctx);
+    };
+};
+/**
+ * Matches any whitespace
+ */
+export const space = () => {
+    return (ctx) => {
+        return regex(/\s+/, "expected whitespace")(ctx);
+    };
+};
+/**
+ * Matches any `count` characters as long as there's enough input
+ * left to parse.
+ */
+export const take = (count) => {
+    return (ctx) => {
+        const endIdx = ctx.index + count;
+        if (endIdx <= ctx.text.length) {
+            return success({ ...ctx, index: endIdx }, ctx.text.substring(ctx.index, endIdx));
+        }
+        else {
+            return failure(ctx, "unexpected end of input");
+        }
+    };
+};
+/**
+ * Matches the rest of the input.
+ */
+export const takeText = () => {
+    return (ctx) => {
+        return success({ ...ctx, index: ctx.text.length }, ctx.text.substring(ctx.index, ctx.text.length));
+    };
+};
+/**
+ * Matches an end of line marker
+ */
+export const eol = () => {
+    return (ctx) => {
+        return either(str("\n"), str("\r\n"))(ctx);
+    };
+};
+/**
+ * Matches if there's no input left to parse
+ */
+export const eof = () => {
+    return (ctx) => {
+        if (ctx.index < ctx.text.length) {
+            return failure(ctx, "eof not reached");
+        }
+        return success(ctx, null);
+    };
+};
+/**
+ * Matches horizontal space (spaces/tabs), if at least one space
+ * follows.
+ */
+export const horizontalSpace = () => {
+    return (ctx) => {
+        return skipMany1(charWhere((code) => String.fromCharCode(code).trim() === ""))(ctx);
+    };
+};
+/**
+ * Matches a positive integer
+ */
+export const int = () => {
+    return (ctx) => {
+        return map(many1(digit()), (digits) => parseInt(digits.join("")))(ctx);
+    };
+};
+/**
+ * Matches a dot-separated double
+ */
+export const double = () => {
+    return (ctx) => {
+        const comma = str(".");
+        const fractional = map(seq(comma, int()), (fraction) => fraction[1]);
+        return map(seq(int(), either(fractional, map(str("."), () => 0))), (double) => {
+            return parseFloat(double.join("."));
+        })(ctx);
+    };
+};
+/**
+ * Matches a hexadecimal digit
+ */
+export const hexDigit = () => {
+    return (ctx) => map(any(digit(), charWhere((code) => code >= 65 && code <= 70), // A-F
+    charWhere((code) => code >= 97 && code <= 102)), (digit) => digit.toString())(ctx);
+};
+/**
+ * Matches a hexadecimal number (`0x` lead not allowed)
+ */
+export const hex = () => {
+    return (ctx) => {
+        const lead = peek(str("0x"))(ctx);
+        if (lead.success) {
+            return failure(ctx, "unexpected 0x lead");
+        }
+        return map(many1(hexDigit()), (hex) => hex.join())(ctx);
+    };
+};
+/**
+ * Matches a positive decimal number
+ */
+export const number = () => {
+    return (ctx) => either(double(), int())(ctx);
+};
+/**
+ * Matches a signed decimal number (with explicit +/- sign)
+ */
+export const signed = (nParser = number()) => {
+    return (ctx) => {
+        return map(seq(either(str("+"), str("-")), nParser), (out) => {
+            const [sign, num] = out;
+            if (sign === "+") {
+                return num;
+            }
+            return -num;
+        })(ctx);
+    };
+};
+/**
+ * Matches input for given regex
+ */
+export const regex = (re, expected) => {
+    return (ctx) => {
+        // Non-global regexps don't support `lastIndex`
+        const globalRe = new RegExp(re.source, re.global ? re.flags : `${re.flags}g`);
+        globalRe.lastIndex = ctx.index;
+        const res = globalRe.exec(ctx.text);
+        if (res && res.index === ctx.index) {
+            return success({ ...ctx, index: ctx.index + res[0].length }, res[0]);
+        }
+        else {
+            return failure(ctx, expected);
+        }
+    };
+};

package/esm/src/utility.d.ts

@@ -0,0 +1,91 @@
+import { type Context, type Failure, type Parser } from "./Parser.js";
+/**
+ * Map the result of a parser using a given function. Useful for building
+ * AST nodes or interpreting the parse results. The mapping function receives
+ * the result of the parser, as well as the state of the input before and after
+ * the parser being applied.
+ */
+export declare const map: <A, B>(parser: Parser<A>, fn: (val: A, before: Context, after: Context, measurement?: string) => B, opts?: {
+    trace: boolean;
+    name: string;
+}) => Parser<B>;
+/**
+ * A simple parser used to collapse a string array parser back into a string.
+ * Useful for smaller parsing tasks.
+ */
+export declare const mapJoin: (parser: Parser<string[]>) => Parser<string>;
+export declare const lazy: <A>(fn: () => Parser<A>) => Parser<A>;
+export declare const peekAnd: <A, B>(peek: Parser<A>, and: Parser<B>) => Parser<B | null>;
+/**
+ * @param peek A parser to probe the waters with
+ * @param continueWith A parser to continue parsing with, if the previous
+ * one succeeded. Note that this will take off from where the peek parser
+ * left off.
+ * @returns
+ */
+export declare const ifPeek: <A, B>(peek: Parser<A>, continueWith: Parser<B>) => Parser<B | null>;
+/**
+ * Map the result of a parser using a given function. Useful for building
+ * AST nodes or interpreting the parse results. The mapping function receives
+ * the result of the parser, as well as the state of the input before and after
+ * the parser being applied.
+ */
+export declare const onFailure: <T>(parser: Parser<T>, onFail: (f: Failure) => Failure) => Parser<T>;
+export declare const trim: <T>(p: Parser<T>) => Parser<T>;
+/**
+ * Add context to a parser's error messages by pushing a frame onto the error stack.
+ * This creates TypeScript-style error traces showing where in the grammar the error occurred:
+ *
+ * ```
+ * expected '}' at line 5, column 3
+ *   in function body at line 2, column 1
+ *   in function declaration at line 2, column 1
+ *   in program at line 1, column 1
+ * ```
+ *
+ * @param contextLabel - A human-readable description of the parsing context (e.g., "in function body")
+ * @param parser - The parser to wrap with context
+ * @returns A parser that adds the label to the error stack on failure
+ *
+ * @example
+ * ```ts
+ * const fnDecl = context("in function declaration",
+ *   seq(str("fn"), identifier, str("("), params, str(")"), block)
+ * );
+ * ```
+ */
+export declare const context: <T>(contextLabel: string, parser: Parser<T>) => Parser<T>;
+/**
+ * Mark a point of no return in parsing. After `cut`, if the inner parser fails,
+ * the failure becomes fatal and will not be caught by alternative parsers like `any` or `either`.
+ *
+ * This is useful after parsing enough to "commit" to a grammar branch. For example,
+ * after seeing "if", we're committed to parsing an if-expression and shouldn't backtrack.
+ *
+ * @param parser - The parser that, if it fails, should produce a fatal error
+ * @param expected - Optional custom error message for the fatal failure
+ * @returns A parser that produces fatal failures
+ *
+ * @example
+ * ```ts
+ * // After seeing "if", we're committed - don't backtrack if "then" is missing
+ * const ifExpr = seq(
+ *   str("if"),
+ *   cut(expr, "condition after 'if'"),
+ *   cut(str("then"), "'then' keyword"),
+ *   cut(expr, "expression after 'then'"),
+ *   cut(str("else"), "'else' keyword"),
+ *   cut(expr, "expression after 'else'")
+ * );
+ * ```
+ */
+export declare const cut: <T>(parser: Parser<T>, expected?: string) => Parser<T>;
+/**
+ * Attempt a parser, but if it fails with a fatal error, convert it back to a
+ * non-fatal failure. This allows catching committed parse errors in specific contexts.
+ *
+ * @param parser - The parser whose fatal errors should be caught
+ * @returns A parser that converts fatal failures to non-fatal ones
+ */
+export declare const attempt: <T>(parser: Parser<T>) => Parser<T>;
+//# sourceMappingURL=utility.d.ts.map

package/esm/src/utility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility.d.ts","sourceRoot":"","sources":["../../src/src/utility.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,OAAO,EAIZ,KAAK,MAAM,EAGZ,MAAM,aAAa,CAAC;AAGrB;;;;;GAKG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,UACd,MAAM,CAAC,CAAC,CAAC,MACb,CAAC,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,MAAM,KAAK,CAAC,SACjE;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,KACtC,MAAM,CAAC,CAAC,CAsBV,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,OAAO,WAAY,MAAM,CAAC,MAAM,EAAE,CAAC,KAAG,MAAM,CAAC,MAAM,CAE/D,CAAC;AAEF,eAAO,MAAM,IAAI,GAAI,CAAC,MAAM,MAAM,MAAM,CAAC,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,CAErD,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,QACpB,MAAM,CAAC,CAAC,CAAC,OACV,MAAM,CAAC,CAAC,CAAC,KACb,MAAM,CAAC,CAAC,GAAG,IAAI,CASjB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,QACnB,MAAM,CAAC,CAAC,CAAC,gBACD,MAAM,CAAC,CAAC,CAAC,KACtB,MAAM,CAAC,CAAC,GAAG,IAAI,CASjB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,UACjB,MAAM,CAAC,CAAC,CAAC,UACT,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO,KAC9B,MAAM,CAAC,CAAC,CAiBV,CAAC;AAEF,eAAO,MAAM,IAAI,GAAI,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,CAE9C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,gBACT,MAAM,UACZ,MAAM,CAAC,CAAC,CAAC,KAChB,MAAM,CAAC,CAAC,CAUV,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,UAAU,MAAM,CAAC,CAAC,CAAC,aAAa,MAAM,KAAG,MAAM,CAAC,CAAC,CAmBrE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,UAAU,MAAM,CAAC,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,CActD,CAAC"}

package/esm/src/utility.js

@@ -0,0 +1,178 @@
+import * as dntShim from "../_dnt.shims.js";
+import { optional, seq } from "./combinators.js";
+import { failure, fatalFailure, isFatal, pushFrame, success, } from "./Parser.js";
+import { space } from "./parsers.js";
+/**
+ * Map the result of a parser using a given function. Useful for building
+ * AST nodes or interpreting the parse results. The mapping function receives
+ * the result of the parser, as well as the state of the input before and after
+ * the parser being applied.
+ */
+export const map = (parser, fn, opts) => {
+    return (ctx) => {
+        const now = () => {
+            // Avoid relying on DOM lib typings; works in Deno and Node.
+            const perf = dntShim.dntGlobalThis
+                .performance;
+            return typeof perf?.now === "function" ? perf.now() : Date.now();
+        };
+        let a = 0, b = 0;
+        opts?.trace && (a = now());
+        const res = parser(ctx);
+        opts?.trace && (b = now());
+        return res.success
+            ? success(res.ctx, fn(res.value, ctx, res.ctx, opts && (b - a).toFixed(5)))
+            : res;
+    };
+};
+/**
+ * A simple parser used to collapse a string array parser back into a string.
+ * Useful for smaller parsing tasks.
+ */
+export const mapJoin = (parser) => {
+    return (ctx) => map(parser, (parts) => parts.join(""))(ctx);
+};
+export const lazy = (fn) => {
+    return (ctx) => fn()(ctx);
+};
+export const peekAnd = (peek, and) => {
+    return (ctx) => {
+        const res = peek(ctx);
+        if (res.success) {
+            return and(ctx);
+        }
+        return failure(ctx, `Peek unsuccesful: expected ${res.expected}`);
+    };
+};
+/**
+ * @param peek A parser to probe the waters with
+ * @param continueWith A parser to continue parsing with, if the previous
+ * one succeeded. Note that this will take off from where the peek parser
+ * left off.
+ * @returns
+ */
+export const ifPeek = (peek, continueWith) => {
+    return (ctx) => {
+        const res = peek(ctx);
+        if (res.success) {
+            return continueWith(res.ctx);
+        }
+        return success(ctx, null);
+    };
+};
+/**
+ * Map the result of a parser using a given function. Useful for building
+ * AST nodes or interpreting the parse results. The mapping function receives
+ * the result of the parser, as well as the state of the input before and after
+ * the parser being applied.
+ */
+export const onFailure = (parser, onFail) => {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (res.success) {
+            return res;
+        }
+        const rewritten = onFail(res);
+        return {
+            ...rewritten,
+            variants: [
+                ...rewritten.variants,
+                ...res.variants,
+                failure(res.ctx, res.expected),
+            ],
+        };
+    };
+};
+export const trim = (p) => {
+    return map(seq(optional(space()), p, optional(space())), ([_, p]) => p);
+};
+/**
+ * Add context to a parser's error messages by pushing a frame onto the error stack.
+ * This creates TypeScript-style error traces showing where in the grammar the error occurred:
+ *
+ * ```
+ * expected '}' at line 5, column 3
+ *   in function body at line 2, column 1
+ *   in function declaration at line 2, column 1
+ *   in program at line 1, column 1
+ * ```
+ *
+ * @param contextLabel - A human-readable description of the parsing context (e.g., "in function body")
+ * @param parser - The parser to wrap with context
+ * @returns A parser that adds the label to the error stack on failure
+ *
+ * @example
+ * ```ts
+ * const fnDecl = context("in function declaration",
+ *   seq(str("fn"), identifier, str("("), params, str(")"), block)
+ * );
+ * ```
+ */
+export const context = (contextLabel, parser) => {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (res.success) {
+            return res;
+        }
+        // Add context frame to the error stack
+        return pushFrame(res, contextLabel, ctx);
+    };
+};
+/**
+ * Mark a point of no return in parsing. After `cut`, if the inner parser fails,
+ * the failure becomes fatal and will not be caught by alternative parsers like `any` or `either`.
+ *
+ * This is useful after parsing enough to "commit" to a grammar branch. For example,
+ * after seeing "if", we're committed to parsing an if-expression and shouldn't backtrack.
+ *
+ * @param parser - The parser that, if it fails, should produce a fatal error
+ * @param expected - Optional custom error message for the fatal failure
+ * @returns A parser that produces fatal failures
+ *
+ * @example
+ * ```ts
+ * // After seeing "if", we're committed - don't backtrack if "then" is missing
+ * const ifExpr = seq(
+ *   str("if"),
+ *   cut(expr, "condition after 'if'"),
+ *   cut(str("then"), "'then' keyword"),
+ *   cut(expr, "expression after 'then'"),
+ *   cut(str("else"), "'else' keyword"),
+ *   cut(expr, "expression after 'else'")
+ * );
+ * ```
+ */
+export const cut = (parser, expected) => {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (res.success) {
+            return res;
+        }
+        // If it's already fatal, preserve it
+        if (isFatal(res)) {
+            return res;
+        }
+        // Make this failure fatal
+        return fatalFailure(res.ctx, expected ?? res.expected, res.stack);
+    };
+};
+/**
+ * Attempt a parser, but if it fails with a fatal error, convert it back to a
+ * non-fatal failure. This allows catching committed parse errors in specific contexts.
+ *
+ * @param parser - The parser whose fatal errors should be caught
+ * @returns A parser that converts fatal failures to non-fatal ones
+ */
+export const attempt = (parser) => {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (res.success) {
+            return res;
+        }
+        // Convert fatal back to non-fatal
+        if (res.fatal) {
+            return { ...res, fatal: false };
+        }
+        return res;
+    };
+};

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@claudiu-ceia/combine",
+  "version": "0.2.4",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ClaudiuCeia/combine.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ClaudiuCeia/combine/issues"
+  },
+  "main": "./script/mod.js",
+  "module": "./esm/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/mod.js",
+      "require": "./script/mod.js"
+    }
+  },
+  "_generatedBy": "dnt@dev"
+}

package/script/_dnt.shims.d.ts

@@ -0,0 +1,2 @@
+export declare const dntGlobalThis: Omit<typeof globalThis, never>;
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/script/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gCAA2C,CAAC"}

package/script/_dnt.shims.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = void 0;
+const dntGlobals = {};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/mod.d.ts

@@ -0,0 +1,6 @@
+export * from "./src/Parser.js";
+export * from "./src/combinators.js";
+export * from "./src/parsers.js";
+export * from "./src/utility.js";
+export * from "./src/language.js";
+//# sourceMappingURL=mod.d.ts.map

package/script/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC"}

package/script/mod.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/Parser.js"), exports);
+__exportStar(require("./src/combinators.js"), exports);
+__exportStar(require("./src/parsers.js"), exports);
+__exportStar(require("./src/utility.js"), exports);
+__exportStar(require("./src/language.js"), exports);

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}