tarsec 0.0.9 → 0.0.11

package/README.md

@@ -33,34 +33,15 @@ parser("hello world"); // success
 parser("hello there"); // failure
 ```
 
-## A longer example
-
-```ts
-// define a parser to parse "hello, <name>!"
-const parser = seq([
-    str("hello"),
-    space,
-
-    /*
-    
-    Capture group to capture the name.
-    
-    `many1(noneOf("!"))` parses one or more characters
-    that are not an exclamation mark.
-    `many1` returns an array of characters,
-    `many1WithJoin` joins them into a string.
-    
-    This capture group is then given the name "person".
-    
-    */
-    capture(many1WithJoin(noneOf("!")), "person"),
-    char("!"),
-], getCaptures);
-
-// parse
-const parsed = parser("hello adit!");
-
-console.log(parsed.success); // true
-console.log(parsed.result); // { person: "adit" }
-```
-
+## Learning tarsec
+- [A five minute introduction](/tutorials/5-minute-intro.md)
+- [The three building blocks in tarsec](/tutorials/three-building-blocks.md)
+- [API reference](https://egonschiele.github.io/tarsec/)
+
+## Features
+- tarsec is entirely TypeScript. There's nothing to compile.
+- [Debug mode](/tutorials/debugging.md) that prints what's happening step-by-step
+- Derived types: tarsec will generate TypeScript types for your parser
+- Partial [backtracking](/tutorials/backtracking.md) support
+
+Read more about [use cases for tarsec](/tutorials/use-case.md).

package/dist/combinators/seq.d.ts

@@ -0,0 +1,2 @@
+import { GeneralParser, MergedResults, MergedCaptures, Parser } from "@/lib/types";
+export declare function seq<const T extends readonly GeneralParser<any, any>[], U>(parsers: T, transform: (results: MergedResults<T>[], captures: MergedCaptures<T>) => U, debugName?: string): Parser<U>;

package/dist/combinators/seq.js

@@ -0,0 +1,123 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "@/lib/trace", "@/lib/types", "@/lib/utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.seq = void 0;
+    const trace_1 = require("@/lib/trace");
+    const types_1 = require("@/lib/types");
+    const utils_1 = require("@/lib/utils");
+    /*
+    To add backtracking support requires a fairly big change. Here's an example that needs backtracking.
+    
+    ```ts
+      const parser = seq([
+            str("hello "),
+            or([str("world"), str("world!")]),
+            optional("?")
+        ], getResults);
+    ```
+    
+    If we try to parse `"hello world!"`, the first parser in the OR will succeed, but then we'll get stuck at the `optional`. Instead, we need to go back up the tree and try the second parser in the OR. A few things need to happen.
+    
+    1. instead of just processing these parsers sequentially in a for loop, we need to model them as a tree
+    2. the OR parser needs to let us know that there are other branches to try.
+    
+    For #2, there's an optional `nextParser` key on a parser success. The or parser can use this to say "a parser succeeded and here's the result, but there are other parsers that could be tried". `nextParser` is a parser that runs the remaining branches. So in this example, the OR would return a success with `nextParser = or([str("world")])`.
+    
+    Next, we need to model this as a tree. Each node in the tree has a parent and child and the parser for that node.
+    
+    ```ts
+      parent: Node;
+      parser: GeneralParser<any, any> | null;
+      child: Node;
+    ```
+    
+    Hopefully that is self-explanatory. We start at the root of the tree, try the parser there, then use `.child` to go to the next node and so on. We don't model multiple paths as multiple children. To keep the code simple, we do something else.
+    
+    Each node also has a `closed` key. Once we've run the parser for a node, we mark it `closed`. Closed means there are no more branches here. UNLESS, the parser returns a `nextParser`. In that case, we *don't* mark it closed because there are still other options to try. In that case, we also *replace* the parser on that node with nextParser.
+    
+    So, going back to the hello world example, let's say we're stuck at the `optional`:
+    
+    ```ts
+      const parser = seq([
+            str("hello "),
+            or([str("world"), str("world!")]),
+            optional("?")
+        ], getResults);
+    ```
+    
+    We use `.parent` to go back up the tree. We're looking for a node that isn't closed. If we find one, we start again from there. In this case, we'd find an open node at the or with parser `or([str("world")])`. We can restart from there, but there's a bunch of state to reset.
+    
+    1. From the new `or` parser, we need to go to the optional parser. We're doing it all again in the same order. This is one reason why it's easier to model this without multiple children. Otherwise, all the children would have to point to the next level, the next level would have to point to all the children in the previous level, and you'd have multiple parents, which is awful to deal with.
+    
+    2. We have consumed input and added to the results. We need to undo that. At this point, the input is `!`, because we've consumed `hello world`. And the results array is `["hello ", "world"]`. We need to rewind both of those.
+    
+    To do that, I count how many levels up we've gone to find another branch, and just pop that many elements off the results array. So results is now `["hello "]`. The input is trickier. How would I keep track of what the input was when we were at the OR the last time?
+    
+    This is where the final key on a tree node comes in. Nodes also have an optional `input` key.
+    
+    IF a parser succeeds, and
+    IF there's a nextParser,
+    We know we may come back to this node. So we save the current input as `.input` on the node.
+    
+    This approach has some issues. Notably, it doesn't work if you need to backtrack at multiple points in the tree. The test `backtracking-deep.test.ts` shows this.
+    
+    The code is also complex and it would be easy to have bugs in this logic. I wish there was a cleaner solution for rewinding state.
+    */
+    function seq(parsers, transform, debugName = "") {
+        return (0, trace_1.trace)(`seq(${debugName})`, (input) => {
+            const results = [];
+            let rest = input;
+            const captures = {};
+            const rootNode = (0, types_1.createTree)(parsers);
+            let current = rootNode;
+            while (current) {
+                const parser = current.parser;
+                if (!parser) {
+                    console.log({ current, parser, results, captures });
+                    throw new Error("parser is null");
+                }
+                const parsed = parser(rest);
+                current.closed = true;
+                /*       console.log({ parsed }); */
+                if (!parsed.success) {
+                    const [ancestor, count] = (0, utils_1.findAncestorWithNextParser)(current);
+                    if (ancestor) {
+                        current = ancestor;
+                        rest = ancestor.input;
+                        (0, utils_1.popMany)(results, count);
+                        continue;
+                    }
+                    else {
+                        // don't consume input if we're failing
+                        return Object.assign(Object.assign({}, parsed), { rest: input });
+                    }
+                }
+                results.push(parsed.result);
+                if (parsed.nextParser) {
+                    /* console.log("setting next parser", parsed.nextParser); */
+                    current.parser = parsed.nextParser;
+                    current.input = rest;
+                    current.closed = false;
+                }
+                rest = parsed.rest;
+                if ((0, types_1.isCaptureResult)(parsed)) {
+                    for (const key in parsed.captures) {
+                        captures[key] = parsed.captures[key];
+                    }
+                }
+                current = current.child;
+            }
+            const result = transform(results, captures);
+            return (0, types_1.success)(result, rest);
+        });
+    }
+    exports.seq = seq;
+});

package/dist/combinators.d.ts

@@ -1,7 +1,15 @@
-import { CaptureParser, GeneralParser, MergedCaptures, MergedResults, Parser, Prettify } from "./types";
+export { seq } from "./combinators/seq";
+import { CaptureParser, MergedResults, Parser, Prettify } from "./types";
 export declare function many<T>(parser: Parser<T>): Parser<T[]>;
 export declare function many1<T>(parser: Parser<T>): Parser<T[]>;
-export declare function count<T>(parser: Parser<T>): Parser<number>;
+/**
+ * Takes a parser, runs it n times, and returns the results as an array.
+ * If it cannot run the parser n times, it fails without consuming input.
+ * @param num - number of times to run the parser
+ * @param parser - parser to run
+ * @returns - parser that runs the given parser `num` times and returns an array of the results
+ */
+export declare function count<T>(num: number, parser: Parser<T>): Parser<T[]>;
 export declare function manyWithJoin(parser: Parser<string>): Parser<string>;
 export declare function many1WithJoin(parser: Parser<string>): Parser<string>;
 export declare function or<const T extends readonly Parser<any>[]>(parsers: T, name?: string): Parser<MergedResults<T>>;
@@ -11,7 +19,6 @@ export declare function between<O, C, P>(open: Parser<O>, close: Parser<C>, pars
 export declare function sepBy<S, P>(separator: Parser<S>, parser: Parser<P>): Parser<P[]>;
 export declare function getResults<R, C>(results: R, captures: C): R;
 export declare function getCaptures<R, C>(results: R, captures: C): C;
-export declare function seq<const T extends readonly GeneralParser<any, any>[], U>(parsers: T, transform: (results: MergedResults<T>[], captures: MergedCaptures<T>) => U, debugName?: string): Parser<U>;
 export declare function capture<T, const S extends string>(parser: Parser<T>, name: S): CaptureParser<T, Record<S, T>>;
 export declare function wrap<T, const S extends string>(parser: Parser<T>, name: S): Parser<Prettify<Record<S, T>>>;
 export declare function transform<T, X>(parser: Parser<T>, transformerFunc: (x: T) => X): Parser<X>;

package/dist/combinators.js

@@ -4,12 +4,14 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./trace", "./types", "./utils"], factory);
+        define(["require", "exports", "./combinators/seq", "./trace", "./types", "./utils"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.transform = exports.wrap = exports.capture = exports.seq = exports.getCaptures = exports.getResults = exports.sepBy = exports.between = exports.not = exports.optional = exports.or = exports.many1WithJoin = exports.manyWithJoin = exports.count = exports.many1 = exports.many = void 0;
+    exports.transform = exports.wrap = exports.capture = exports.getCaptures = exports.getResults = exports.sepBy = exports.between = exports.not = exports.optional = exports.or = exports.many1WithJoin = exports.manyWithJoin = exports.count = exports.many1 = exports.many = exports.seq = void 0;
+    var seq_1 = require("./combinators/seq");
+    Object.defineProperty(exports, "seq", { enumerable: true, get: function () { return seq_1.seq; } });
     const trace_1 = require("./trace");
     const types_1 = require("./types");
     const utils_1 = require("./utils");
@@ -43,13 +45,26 @@
         });
     }
     exports.many1 = many1;
-    function count(parser) {
+    /**
+     * Takes a parser, runs it n times, and returns the results as an array.
+     * If it cannot run the parser n times, it fails without consuming input.
+     * @param num - number of times to run the parser
+     * @param parser - parser to run
+     * @returns - parser that runs the given parser `num` times and returns an array of the results
+     */
+    function count(num, parser) {
         return (0, trace_1.trace)("count", (input) => {
-            const result = many(parser)(input);
-            if (result.success) {
-                return (0, types_1.success)(result.result.length, result.rest);
+            let results = [];
+            let rest = input;
+            for (let i = 0; i < num; i++) {
+                let parsed = parser(rest);
+                if (!parsed.success) {
+                    return (0, types_1.failure)(`expected ${num} matches, got ${i}`, input);
+                }
+                results.push(parsed.result);
+                rest = parsed.rest;
             }
-            return result;
+            return (0, types_1.success)(results, rest);
         });
     }
     exports.count = count;
@@ -67,10 +82,14 @@
      */
     function or(parsers, name = "") {
         return (0, trace_1.trace)(`or(${name})`, (input) => {
-            for (let parser of parsers) {
-                let result = parser(input);
+            for (let i = 0; i < parsers.length; i++) {
+                let result = parsers[i](input);
                 if (result.success) {
-                    return result;
+                    if (i === parsers.length - 1)
+                        return result;
+                    const nextParser = or(parsers.slice(i + 1), name);
+                    /* console.log({ nextParser }, parsers.slice(i + 1)); */
+                    return Object.assign(Object.assign({}, result), { nextParser });
                 }
             }
             return (0, types_1.failure)(`all parsers failed`, input);
@@ -147,29 +166,6 @@
         return captures;
     }
     exports.getCaptures = getCaptures;
-    function seq(parsers, transform, debugName = "") {
-        return (0, trace_1.trace)(`seq(${debugName})`, (input) => {
-            const results = [];
-            let rest = input;
-            const captures = {};
-            for (let parser of parsers) {
-                let parsed = parser(rest);
-                if (!parsed.success) {
-                    return parsed;
-                }
-                results.push(parsed.result);
-                rest = parsed.rest;
-                if ((0, types_1.isCaptureResult)(parsed)) {
-                    for (const key in parsed.captures) {
-                        captures[key] = parsed.captures[key];
-                    }
-                }
-            }
-            const result = transform(results, captures);
-            return (0, types_1.success)(result, rest);
-        });
-    }
-    exports.seq = seq;
     function capture(parser, name) {
         return (0, trace_1.trace)(`capture(${(0, utils_1.escape)(name)})`, (input) => {
             let result = parser(input);

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./parsers";
 export * from "./combinators";
 export * from "./trace";
+export * from "./types";

package/dist/index.js

@@ -18,7 +18,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./parsers", "./combinators", "./trace"], factory);
+        define(["require", "exports", "./parsers", "./combinators", "./trace", "./types"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -26,4 +26,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     __exportStar(require("./parsers"), exports);
     __exportStar(require("./combinators"), exports);
     __exportStar(require("./trace"), exports);
+    __exportStar(require("./types"), exports);
 });

package/dist/parsers/betweenWithin.d.ts

@@ -0,0 +1,2 @@
+import { BetweenWithinResult, Parser } from "../types";
+export declare function betweenWithin(parser: Parser<string>): Parser<BetweenWithinResult[]>;

package/dist/parsers/betweenWithin.js

@@ -0,0 +1,68 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../trace", "../types"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.betweenWithin = void 0;
+    const trace_1 = require("../trace");
+    const types_1 = require("../types");
+    function betweenWithin(parser) {
+        return (0, trace_1.trace)("betweenWithin", (input) => {
+            let start = 0;
+            let current = 0;
+            let currentlyMatching = false;
+            const results = [];
+            while (current < input.length) {
+                const parsed = parser(input.slice(current));
+                if (parsed.success) {
+                    if (currentlyMatching) {
+                        const value = input.slice(start, current + parsed.result.length);
+                        if (value.length > 0) {
+                            results.push({
+                                type: "matched",
+                                value,
+                            });
+                        }
+                        current += parsed.result.length;
+                        start = current;
+                        currentlyMatching = false;
+                    }
+                    else {
+                        const value = input.slice(start, current);
+                        if (value.length > 0) {
+                            results.push({
+                                type: "unmatched",
+                                value,
+                            });
+                        }
+                        currentlyMatching = true;
+                        start = current;
+                        current += parsed.result.length;
+                    }
+                }
+                else {
+                    current += 1;
+                }
+            }
+            if (start < current) {
+                if (currentlyMatching) {
+                    return (0, types_1.failure)("unexpected end of input", "");
+                }
+                else {
+                    results.push({
+                        type: "unmatched",
+                        value: input.slice(start, current),
+                    });
+                }
+            }
+            return (0, types_1.success)(results, "");
+        });
+    }
+    exports.betweenWithin = betweenWithin;
+});

package/dist/parsers.d.ts

@@ -1,9 +1,43 @@
 import { Parser } from "./types";
-export declare function char(c: string): Parser<string>;
-export declare function str(s: string): Parser<string>;
+export { betweenWithin } from "./parsers/betweenWithin";
+/**
+ * Takes a character. Returns a parser that parses that character.
+ *
+ * @param c - character to parse
+ * @returns - parser that parses the given character
+ */
+export declare function char<const S extends string>(c: S): Parser<S>;
+/**
+ * Takes a string. Returns a parser that parses that string.
+ *
+ * @param s - string to parse
+ * @returns - parser that parses the given string
+ */
+export declare function str<const S extends string>(s: S): Parser<S>;
+/**
+ * Takes a string. Returns a parser that parses
+ * one of the characters in that string.
+ *
+ * @param chars - string of possible characters
+ * @returns - parser that parses one of the given characters
+ */
 export declare function oneOf(chars: string): Parser<string>;
+/**
+ * Takes a string. Returns a parser that parses one character
+ * that's not any of the characters in the given string
+ *
+ * @param chars - string of characters to avoid
+ * @returns - parser that parses a character that is not in the given string
+ */
 export declare function noneOf(chars: string): Parser<string>;
-export declare function anyChar(input: string): Parser<string>;
+/**
+ * A parser that parses any one character.
+ * Fails on empty strings, succeeds otherwise.
+ *
+ * @param input - input string
+ * @returns - ParserResult
+ */
+export declare const anyChar: any;
 export declare const space: Parser<string>;
 export declare const spaces: Parser<string>;
 export declare const digit: Parser<string>;
@@ -14,4 +48,5 @@ export declare const num: Parser<string>;
 export declare const quote: Parser<string>;
 export declare const tab: Parser<string>;
 export declare const newline: Parser<string>;
+export declare const eof: Parser<null>;
 export declare const quotedString: Parser<string>;

package/dist/parsers.js

@@ -4,16 +4,24 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./combinators", "./trace", "./types", "./utils"], factory);
+        define(["require", "exports", "./combinators", "./trace", "./types", "./utils", "./parsers/betweenWithin"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.quotedString = exports.newline = exports.tab = exports.quote = exports.num = exports.word = exports.alphanum = exports.letter = exports.digit = exports.spaces = exports.space = exports.anyChar = exports.noneOf = exports.oneOf = exports.str = exports.char = void 0;
+    exports.quotedString = exports.eof = exports.newline = exports.tab = exports.quote = exports.num = exports.word = exports.alphanum = exports.letter = exports.digit = exports.spaces = exports.space = exports.anyChar = exports.noneOf = exports.oneOf = exports.str = exports.char = exports.betweenWithin = void 0;
     const combinators_1 = require("./combinators");
     const trace_1 = require("./trace");
     const types_1 = require("./types");
     const utils_1 = require("./utils");
+    var betweenWithin_1 = require("./parsers/betweenWithin");
+    Object.defineProperty(exports, "betweenWithin", { enumerable: true, get: function () { return betweenWithin_1.betweenWithin; } });
+    /**
+     * Takes a character. Returns a parser that parses that character.
+     *
+     * @param c - character to parse
+     * @returns - parser that parses the given character
+     */
     function char(c) {
         return (0, trace_1.trace)(`char(${(0, utils_1.escape)(c)})`, (input) => {
             if (input.length === 0) {
@@ -26,10 +34,16 @@
             if (input[0] === c) {
                 return (0, types_1.success)(c, input.slice(1));
             }
-            return (0, types_1.failure)(`expected ${c}, got ${input[0]}`, input);
+            return (0, types_1.failure)(`expected ${(0, utils_1.escape)(c)}, got ${(0, utils_1.escape)(input[0])}`, input);
         });
     }
     exports.char = char;
+    /**
+     * Takes a string. Returns a parser that parses that string.
+     *
+     * @param s - string to parse
+     * @returns - parser that parses the given string
+     */
     function str(s) {
         return (0, trace_1.trace)(`str(${(0, utils_1.escape)(s)})`, (input) => {
             if (input.substring(0, s.length) === s) {
@@ -39,6 +53,13 @@
         });
     }
     exports.str = str;
+    /**
+     * Takes a string. Returns a parser that parses
+     * one of the characters in that string.
+     *
+     * @param chars - string of possible characters
+     * @returns - parser that parses one of the given characters
+     */
     function oneOf(chars) {
         return (0, trace_1.trace)(`oneOf(${(0, utils_1.escape)(chars)})`, (input) => {
             if (input.length === 0) {
@@ -52,6 +73,13 @@
         });
     }
     exports.oneOf = oneOf;
+    /**
+     * Takes a string. Returns a parser that parses one character
+     * that's not any of the characters in the given string
+     *
+     * @param chars - string of characters to avoid
+     * @returns - parser that parses a character that is not in the given string
+     */
     function noneOf(chars) {
         return (0, trace_1.trace)(`noneOf(${(0, utils_1.escape)(chars)})`, (input) => {
             if (input.length === 0) {
@@ -64,15 +92,19 @@
         });
     }
     exports.noneOf = noneOf;
-    function anyChar(input) {
-        return (0, trace_1.trace)("anyChar", (input) => {
-            if (input.length === 0) {
-                return (0, types_1.failure)("unexpected end of input", input);
-            }
-            return { success: true, match: input[0], rest: input.slice(1) };
-        });
-    }
-    exports.anyChar = anyChar;
+    /**
+     * A parser that parses any one character.
+     * Fails on empty strings, succeeds otherwise.
+     *
+     * @param input - input string
+     * @returns - ParserResult
+     */
+    exports.anyChar = (0, trace_1.trace)("anyChar", (input) => {
+        if (input.length === 0) {
+            return (0, types_1.failure)("unexpected end of input", input);
+        }
+        return (0, types_1.success)(input[0], input.slice(1));
+    });
     exports.space = oneOf(" \t\n\r");
     exports.spaces = (0, combinators_1.many1WithJoin)(exports.space);
     exports.digit = oneOf("0123456789");
@@ -83,5 +115,12 @@
     exports.quote = oneOf(`'"`);
     exports.tab = char("\t");
     exports.newline = char("\n");
-    exports.quotedString = (0, combinators_1.transform)((0, combinators_1.seq)([exports.quote, exports.word, exports.quote], combinators_1.getResults), (x) => x.join(""));
+    const eof = (input) => {
+        if (input === "") {
+            return (0, types_1.success)(null, input);
+        }
+        return (0, types_1.failure)("expected end of input", input);
+    };
+    exports.eof = eof;
+    exports.quotedString = (0, combinators_1.seq)([exports.quote, exports.word, exports.quote], (results) => results.join(""));
 });

package/dist/types.d.ts

@@ -3,6 +3,7 @@ export type ParserSuccess<T> = {
     success: true;
     result: T;
     rest: string;
+    nextParser?: GeneralParser<any, any>;
 };
 export type CaptureParserSuccess<T, C extends PlainObject> = ParserSuccess<T> & {
     captures: C;
@@ -30,4 +31,24 @@ type ExtractCaptures<T> = T extends CaptureParser<any, infer U> ? U : never;
 type ExtractCaptureParsers<T extends readonly GeneralParser<any, any>[]> = Extract<T[number], CaptureParser<any, any>>;
 export type MergedCaptures<T extends readonly GeneralParser<any, any>[]> = Prettify<UnionToIntersection<ExtractCaptures<ExtractCaptureParsers<T>>>>;
 export type MergedResults<T extends readonly GeneralParser<any, any>[]> = ExtractResults<T[number]>;
+export type Node = ParserNode | EmptyNode;
+export type ParserNode = {
+    parent: Node;
+    parser: GeneralParser<any, any> | null;
+    input?: string;
+    child: Node;
+    closed: boolean;
+};
+export type EmptyNode = null;
+export declare function createNode(parent: Node | null, parser: GeneralParser<any, any>): ParserNode;
+export declare function createTree(parsers: readonly GeneralParser<any, any>[]): Node;
+export type Matched = {
+    type: "matched";
+    value: string;
+};
+export type Unmatched = {
+    type: "unmatched";
+    value: string;
+};
+export type BetweenWithinResult = Matched | Unmatched;
 export {};

package/dist/types.js

@@ -9,7 +9,7 @@
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.failure = exports.captureSuccess = exports.success = exports.isCaptureResult = void 0;
+    exports.createTree = exports.createNode = exports.failure = exports.captureSuccess = exports.success = exports.isCaptureResult = void 0;
     function isCaptureResult(result) {
         return "captures" in result;
     }
@@ -26,24 +26,26 @@
         return { success: false, message, rest };
     }
     exports.failure = failure;
+    function createNode(parent, parser) {
+        return {
+            parent,
+            parser,
+            child: null,
+            closed: false,
+        };
+    }
+    exports.createNode = createNode;
+    function createTree(parsers) {
+        if (parsers.length === 0) {
+            return null;
+        }
+        const rootNode = createNode(null, parsers[0]);
+        let currentNode = rootNode;
+        for (let i = 1; i < parsers.length; i++) {
+            currentNode.child = createNode(currentNode, parsers[i]);
+            currentNode = currentNode.child;
+        }
+        return rootNode;
+    }
+    exports.createTree = createTree;
 });
-/* export type Merge2<O extends Array<T>, T = any> = Prettify<
-  UnionToIntersection<O[number]>
->;
-
-export type NonNullObject<T> = {
-  [K in keyof T]: T[K] extends null | undefined ? never : T[K];
-}; */
-/* export type NonNullableUnionOfObjects<T> = T extends object
-  ? RemoveNeverKeys<DeepNonNullable<T>>
-  : T;
-
-export type DeepNonNullable<T> = {
-  [P in keyof T]-?: NonNullable<T[P]>;
-}; */
-/* export type FilterNeverKeys<T> = {
-  [K in keyof T]: T[K] extends never ? never : K;
-};
- */
-/* type ValueOf<T> = T[keyof T]; */
-/* type RemoveNeverKeys<T> = Pick<T, ValueOf<FilterNeverKeys<T>>>; */

package/dist/utils.d.ts

@@ -1,3 +1,6 @@
+import { Node } from "./types";
 export declare function escape(str: any): string;
 export declare function merge(a: any | any[], b: any | any[]): any[];
 export declare function mergeCaptures(a: Record<string, any>, b: Record<string, any>): Record<string, any>;
+export declare function findAncestorWithNextParser(node: Node, count?: number): [Node, number];
+export declare function popMany(arr: any[], count: number): void;