tarsec 0.0.11 → 0.0.12

package/dist/combinators/seq.d.ts

@@ -1,2 +1 @@
-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>;
+export {};

package/dist/combinators/seq.js

@@ -4,120 +4,9 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "@/lib/trace", "@/lib/types", "@/lib/utils"], factory);
+        define(["require", "exports"], 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,5 +1,4 @@
-export { seq } from "./combinators/seq";
-import { CaptureParser, MergedResults, Parser, Prettify } from "./types";
+import { CaptureParser, GeneralParser, MergedCaptures, MergedResults, Parser, PickParserType, Prettify } from "./types";
 export declare function many<T>(parser: Parser<T>): Parser<T[]>;
 export declare function many1<T>(parser: Parser<T>): Parser<T[]>;
 /**
@@ -12,7 +11,33 @@ export declare function many1<T>(parser: Parser<T>): Parser<T[]>;
 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>>;
+/**
+ * `or` takes an array of parsers and runs them sequentially.
+ * It returns the results of the first parser that succeeds.
+ * You can use `capture` in an `or`:
+ *
+ * ```ts
+ * const parser = or(capture(digit, "num"), capture(word, "name"));
+ * ```
+ *
+ * `or` supports backtracking by returning a `nextParser`:
+ *
+ * ```ts
+ * const parser = or(str("hello"), str("hello!"));
+ *
+ * // this will match the first parser
+ * const result = parser("hello");
+ *
+ * // but or returns the untried parsers as a new parser
+ * result.nextParser("hello!"); // works
+ *
+ * // result.nextParser is the same as or(str("hello!"))
+ * ```
+ *
+ * @param parsers - parsers to try
+ * @returns - a parser that tries each parser in order. Returns the result of the first parser that succeeds.
+ */
+export declare function or<const T extends readonly GeneralParser<any, any>[]>(...parsers: T): PickParserType<T>;
 export declare function optional<T>(parser: Parser<T>): Parser<T | null>;
 export declare function not(parser: Parser<any>): Parser<null>;
 export declare function between<O, C, P>(open: Parser<O>, close: Parser<C>, parser: Parser<P>): Parser<P>;
@@ -21,4 +46,33 @@ 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 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 manyTill<T>(parser: Parser<T>): Parser<string>;
 export declare function transform<T, X>(parser: Parser<T>, transformerFunc: (x: T) => X): Parser<X>;
+export declare function search(parser: Parser<string>): Parser<string[]>;
+/**
+ * seq takes an array of parsers and runs them sequentially.
+ * If any of the parsers fail, seq fails without consuming any input.
+ *
+ * The second argument to seq is a function.
+ * The first argument of that function is an array of results:
+ * one result from each of the parsers you gave to seq.
+ * The second is an object containing any captures.
+ * You can use this second argument, the transformer function,
+ * to transform these however you want and return a result
+ *
+ * Tarsec includes the utility functions `getResults` and `getCaptures`
+ * to just return the results array or captures object respectively for you.
+ *
+ * Finally, you don't need to use seq at all. You can just hand write the logic.
+ * But you'll need to do the error handling
+ * and pass the remaining input to the next parser yourself.
+ * seq also does some backtracking for you that you will need to do yourself.
+ *
+ * @param parsers - parsers to run sequentially
+ * @param transform - function to transform the results and captures. The params are the results and captures
+ * @param debugName - optional name for trace debugging
+ * @returns
+ */
+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 seqR<const T extends readonly GeneralParser<any, any>[]>(...parsers: T): Parser<MergedResults<T>[]>;
+export declare function seqC<const T extends readonly GeneralParser<any, any>[]>(...parsers: T): Parser<MergedCaptures<T>>;

package/dist/combinators.js

@@ -4,14 +4,13 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./combinators/seq", "./trace", "./types", "./utils"], factory);
+        define(["require", "exports", "./parsers/within", "./trace", "./types", "./utils"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    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; } });
+    exports.seqC = exports.seqR = exports.seq = exports.search = exports.transform = exports.manyTill = 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 = void 0;
+    const within_1 = require("./parsers/within");
     const trace_1 = require("./trace");
     const types_1 = require("./types");
     const utils_1 = require("./utils");
@@ -76,18 +75,40 @@
         return transform(many1(parser), (x) => x.join(""));
     }
     exports.many1WithJoin = many1WithJoin;
-    /* seq<, U>(
-      parsers: T,
-      transform: (results: MergedResults<T>[], captures: MergedCaptures<T>) => U,
+    /**
+     * `or` takes an array of parsers and runs them sequentially.
+     * It returns the results of the first parser that succeeds.
+     * You can use `capture` in an `or`:
+     *
+     * ```ts
+     * const parser = or(capture(digit, "num"), capture(word, "name"));
+     * ```
+     *
+     * `or` supports backtracking by returning a `nextParser`:
+     *
+     * ```ts
+     * const parser = or(str("hello"), str("hello!"));
+     *
+     * // this will match the first parser
+     * const result = parser("hello");
+     *
+     * // but or returns the untried parsers as a new parser
+     * result.nextParser("hello!"); // works
+     *
+     * // result.nextParser is the same as or(str("hello!"))
+     * ```
+     *
+     * @param parsers - parsers to try
+     * @returns - a parser that tries each parser in order. Returns the result of the first parser that succeeds.
      */
-    function or(parsers, name = "") {
-        return (0, trace_1.trace)(`or(${name})`, (input) => {
+    function or(...parsers) {
+        return (0, trace_1.trace)(`or()`, (input) => {
             for (let i = 0; i < parsers.length; i++) {
                 let result = parsers[i](input);
                 if (result.success) {
                     if (i === parsers.length - 1)
                         return result;
-                    const nextParser = or(parsers.slice(i + 1), name);
+                    const nextParser = or(...parsers.slice(i + 1));
                     /* console.log({ nextParser }, parsers.slice(i + 1)); */
                     return Object.assign(Object.assign({}, result), { nextParser });
                 }
@@ -191,70 +212,20 @@
         });
     }
     exports.wrap = wrap;
-    /*
-    export function setCapturesAsMatch<M, C extends PlainObject>(
-      parser: Parser<M, C>
-    ): Parser<C> {
-      return trace(`setCapturesAsMatch`, (input: string) => {
-        let result = parser(input);
-        if (result.success) {
-          return {
-            ...result,
-            match: result.captures as any,
-            captures: {},
-          };
-        }
-        return result;
-      });
-    }
-    
-    export function captureCaptures<
-      M,
-      C extends PlainObject,
-      const S extends string
-    >(parser: Parser<M, C>, name: S): Parser<C, Record<S, C>> {
-      return trace(`captureCaptures(${escape(name)})`, (input: string) => {
-        return capture(setCapturesAsMatch(parser), name)(input);
-      });
-    } */
-    /* export function captureCaptures<M, C extends string>(
-      parser: Parser<M>,
-      name: string
-    ): Parser<M, C> {
-      return trace(`captures(${escape(name)})`, (input: string) => {
-        let result = parser(input);
-        if (result.success) {
-          const captures: Record<string, any> = {
-            [name]: result.captures,
-          };
-          return {
-            ...result,
-            captures: mergeCaptures(result.captures || {}, captures),
-          };
-        }
-        return result;
-      });
+    function manyTill(parser) {
+        return (input) => {
+            let current = 0;
+            while (current < input.length) {
+                const parsed = parser(input.slice(current));
+                if (parsed.success) {
+                    return (0, types_1.success)(input.slice(0, current), input.slice(current));
+                }
+                current++;
+            }
+            return (0, types_1.success)(input, "");
+        };
     }
-    
-     */
-    /* export function shapeCaptures<M, C extends string>(
-      parser: Parser<M>,
-      func: (captures: Record<string, any>) => Record<string, any>,
-      name: string
-    ): Parser<M, C> {
-      return trace(`captures(${escape(name)})`, (input: string) => {
-        let result = parser(input);
-        if (result.success) {
-          const captures: Record<string, any> = result.captures || {};
-    
-          return {
-            ...result,
-            captures: func(captures),
-          };
-        }
-        return result;
-      });
-    } */
+    exports.manyTill = manyTill;
     function transform(parser, transformerFunc) {
         return (0, trace_1.trace)(`transform(${transformerFunc})`, (input) => {
             let parsed = parser(input);
@@ -265,4 +236,167 @@
         });
     }
     exports.transform = transform;
+    function search(parser) {
+        return (0, trace_1.trace)("search", (input) => {
+            let parsed = (0, within_1.within)(parser)(input);
+            if (parsed.success) {
+                const result = parsed.result
+                    .filter((x) => x.type === "matched")
+                    .map((x) => x.value);
+                const rest = parsed.result
+                    .filter((x) => x.type === "unmatched")
+                    .map((x) => x.value)
+                    .join(" ");
+                return (0, types_1.success)(result, rest);
+            }
+            return (0, types_1.success)("", input);
+        });
+    }
+    exports.search = search;
+    /*
+    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.
+    */
+    /**
+     * seq takes an array of parsers and runs them sequentially.
+     * If any of the parsers fail, seq fails without consuming any input.
+     *
+     * The second argument to seq is a function.
+     * The first argument of that function is an array of results:
+     * one result from each of the parsers you gave to seq.
+     * The second is an object containing any captures.
+     * You can use this second argument, the transformer function,
+     * to transform these however you want and return a result
+     *
+     * Tarsec includes the utility functions `getResults` and `getCaptures`
+     * to just return the results array or captures object respectively for you.
+     *
+     * Finally, you don't need to use seq at all. You can just hand write the logic.
+     * But you'll need to do the error handling
+     * and pass the remaining input to the next parser yourself.
+     * seq also does some backtracking for you that you will need to do yourself.
+     *
+     * @param parsers - parsers to run sequentially
+     * @param transform - function to transform the results and captures. The params are the results and captures
+     * @param debugName - optional name for trace debugging
+     * @returns
+     */
+    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;
+    function seqR(...parsers) {
+        return seq(parsers, getResults);
+    }
+    exports.seqR = seqR;
+    function seqC(...parsers) {
+        return seq(parsers, getCaptures);
+    }
+    exports.seqC = seqC;
 });
+/*
+export function seqX<const T extends readonly GeneralParser<any, any>[], U>(
+  parsers: T,
+  transform: (results: MergedResults<T>[], captures: MergedCaptures<T>) => U,
+  debugName: string = ""
+): Parser<U> {
+ */

package/dist/parsers/within.d.ts

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

package/dist/parsers/within.js

@@ -0,0 +1,51 @@
+(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.within = void 0;
+    const trace_1 = require("../trace");
+    const types_1 = require("../types");
+    function within(parser) {
+        return (0, trace_1.trace)("within", (input) => {
+            let start = 0;
+            let current = 0;
+            const results = [];
+            while (current < input.length) {
+                const parsed = parser(input.slice(current));
+                if (parsed.success) {
+                    const unmatchedValue = input.slice(start, current);
+                    if (unmatchedValue.length > 0) {
+                        results.push({
+                            type: "unmatched",
+                            value: unmatchedValue,
+                        });
+                    }
+                    results.push({
+                        type: "matched",
+                        value: parsed.result,
+                    });
+                    current += parsed.result.length;
+                    start = current;
+                }
+                else {
+                    current += 1;
+                }
+            }
+            if (start < current) {
+                results.push({
+                    type: "unmatched",
+                    value: input.slice(start, current),
+                });
+            }
+            return (0, types_1.success)(results, "");
+        });
+    }
+    exports.within = within;
+});

package/dist/parsers.d.ts

@@ -1,5 +1,5 @@
 import { Parser } from "./types";
-export { betweenWithin } from "./parsers/betweenWithin";
+export { within as betweenWithin } from "./parsers/within";
 /**
  * Takes a character. Returns a parser that parses that character.
  *

package/dist/parsers.js

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./combinators", "./trace", "./types", "./utils", "./parsers/betweenWithin"], factory);
+        define(["require", "exports", "./combinators", "./trace", "./types", "./utils", "./parsers/within"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -14,8 +14,8 @@
     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; } });
+    var within_1 = require("./parsers/within");
+    Object.defineProperty(exports, "betweenWithin", { enumerable: true, get: function () { return within_1.within; } });
     /**
      * Takes a character. Returns a parser that parses that character.
      *
@@ -122,5 +122,5 @@
         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(""));
+    exports.quotedString = (0, combinators_1.seq)([exports.quote, (0, combinators_1.manyWithJoin)(noneOf(`"'`)), exports.quote], (results) => results.join(""));
 });

package/dist/types.d.ts

@@ -29,7 +29,17 @@ export type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) ex
 type ExtractResults<T> = T extends Parser<infer U> ? U : never;
 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 MergedCaptures<T extends readonly GeneralParser<any, any>[]> = Prettify<UnionToIntersection<UnionOfCaptures<T>>>;
+export type UnionOfCaptures<T extends readonly GeneralParser<any, any>[]> = Prettify<ExtractCaptures<ExtractCaptureParsers<T>>>;
+export type HasCaptureParsers<T extends readonly GeneralParser<any, any>[]> = ExtractCaptureParsers<T> extends never ? false : true;
+/**
+ * For a given array of GeneralParsers, if any of them is a CaptureParser,
+ * PickParserType says the array is an array of CaptureParsers,
+ * otherwise it's an array of Parsers. It also correctly merges
+ * the result and capture types. This is useful for a combinator like `or`
+ * which is not able to infer its return type correctly.
+ */
+export type PickParserType<T extends readonly GeneralParser<any, any>[]> = HasCaptureParsers<T> extends true ? CaptureParser<MergedResults<T>, UnionOfCaptures<T>> : Parser<MergedResults<T>>;
 export type MergedResults<T extends readonly GeneralParser<any, any>[]> = ExtractResults<T[number]>;
 export type Node = ParserNode | EmptyNode;
 export type ParserNode = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tarsec",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "A parser combinator library for TypeScript, inspired by Parsec.",
   "homepage": "https://github.com/egonSchiele/tarsec",
   "scripts": {

package/dist/parsers/betweenWithin.d.ts

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

package/dist/parsers/betweenWithin.js

@@ -1,68 +0,0 @@
-(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;
-});