tarsec 0.0.8 → 0.0.9

package/README.md

@@ -19,14 +19,14 @@ npm install tarsec
 ## Hello world
 
 ```ts
-import { str, seq, space } from "tarsec";
+import { getResults, str, seq, space } from "tarsec";
 
 // define a parser
 const parser = seq([
     str("hello"),
     space,
     str("world")
-]);
+], getResults);
 
 // then use it
 parser("hello world"); // success
@@ -55,12 +55,12 @@ const parser = seq([
     */
     capture(many1WithJoin(noneOf("!")), "person"),
     char("!"),
-]);
+], getCaptures);
 
 // parse
-const result = parser("hello adit!");
+const parsed = parser("hello adit!");
 
-console.log(result.success); // true
-console.log(result.captures); // { person: "adit" }
+console.log(parsed.success); // true
+console.log(parsed.result); // { person: "adit" }
 ```
 

package/dist/combinators.d.ts

@@ -1,15 +1,17 @@
-import { Parser } from "./types";
+import { CaptureParser, GeneralParser, MergedCaptures, 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>;
 export declare function manyWithJoin(parser: Parser<string>): Parser<string>;
 export declare function many1WithJoin(parser: Parser<string>): Parser<string>;
-export declare function or<T>(parsers: Parser<T>[], name?: string): Parser<T>;
+export declare function or<const T extends readonly Parser<any>[]>(parsers: T, name?: string): Parser<MergedResults<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>;
 export declare function sepBy<S, P>(separator: Parser<S>, parser: Parser<P>): Parser<P[]>;
-export declare function seq<M, C extends string>(parsers: Parser<M>[], name?: string): Parser<M[], C>;
-export declare function capture<M, C extends string>(parser: Parser<M>, name: string): Parser<M, C>;
-export declare function captureCaptures<M, C extends string>(parser: Parser<M>, name: string): Parser<M, C>;
-export declare function shapeCaptures<M, C extends string>(parser: Parser<M>, func: (captures: Record<string, any>) => Record<string, any>, name: string): Parser<M, C>;
+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,25 +4,26 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./trace", "./utils"], factory);
+        define(["require", "exports", "./trace", "./types", "./utils"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.transform = exports.shapeCaptures = exports.captureCaptures = exports.capture = exports.seq = exports.sepBy = exports.between = exports.not = exports.optional = exports.or = exports.many1WithJoin = exports.manyWithJoin = exports.many1 = exports.many = void 0;
+    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;
     const trace_1 = require("./trace");
+    const types_1 = require("./types");
     const utils_1 = require("./utils");
     function many(parser) {
         return (0, trace_1.trace)("many", (input) => {
-            let match = [];
+            let results = [];
             let rest = input;
             while (true) {
-                let result = parser(rest);
-                if (!result.success) {
-                    return { success: true, match, rest };
+                let parsed = parser(rest);
+                if (!parsed.success) {
+                    return (0, types_1.success)(results, rest);
                 }
-                match.push(result.match);
-                rest = result.rest;
+                results.push(parsed.result);
+                rest = parsed.rest;
             }
         });
     }
@@ -42,6 +43,16 @@
         });
     }
     exports.many1 = many1;
+    function count(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);
+            }
+            return result;
+        });
+    }
+    exports.count = count;
     function manyWithJoin(parser) {
         return transform(many(parser), (x) => x.join(""));
     }
@@ -50,6 +61,10 @@
         return transform(many1(parser), (x) => x.join(""));
     }
     exports.many1WithJoin = many1WithJoin;
+    /* seq<, U>(
+      parsers: T,
+      transform: (results: MergedResults<T>[], captures: MergedCaptures<T>) => U,
+     */
     function or(parsers, name = "") {
         return (0, trace_1.trace)(`or(${name})`, (input) => {
             for (let parser of parsers) {
@@ -58,11 +73,7 @@
                     return result;
                 }
             }
-            return {
-                success: false,
-                rest: input,
-                message: "all parsers failed",
-            };
+            return (0, types_1.failure)(`all parsers failed`, input);
         });
     }
     exports.or = or;
@@ -72,7 +83,7 @@
             if (result.success) {
                 return result;
             }
-            return { success: true, match: null, rest: input };
+            return (0, types_1.success)(null, input);
         });
     }
     exports.optional = optional;
@@ -86,7 +97,7 @@
                     message: "unexpected match",
                 };
             }
-            return { success: true, match: null, rest: input };
+            return (0, types_1.success)(null, input);
         });
     }
     exports.not = not;
@@ -104,95 +115,157 @@
             if (!result2.success) {
                 return result2;
             }
-            return { success: true, match: parserResult.match, rest: result2.rest };
+            return (0, types_1.success)(parserResult.result, result2.rest);
         };
     }
     exports.between = between;
     function sepBy(separator, parser) {
         return (input) => {
-            let match = [];
+            let results = [];
             let rest = input;
             while (true) {
                 const result = parser(rest);
                 if (!result.success) {
-                    return { success: true, match, rest };
+                    return (0, types_1.success)(results, rest);
                 }
-                match.push(result.match);
+                results.push(result.result);
                 rest = result.rest;
                 const sepResult = separator(rest);
                 if (!sepResult.success) {
-                    return { success: true, match, rest };
+                    return (0, types_1.success)(results, rest);
                 }
                 rest = sepResult.rest;
             }
         };
     }
     exports.sepBy = sepBy;
-    function seq(parsers, name = "") {
-        return (0, trace_1.trace)(`seq(${name})`, (input) => {
-            let match = [];
+    function getResults(results, captures) {
+        return results;
+    }
+    exports.getResults = getResults;
+    function getCaptures(results, captures) {
+        return captures;
+    }
+    exports.getCaptures = getCaptures;
+    function seq(parsers, transform, debugName = "") {
+        return (0, trace_1.trace)(`seq(${debugName})`, (input) => {
+            const results = [];
             let rest = input;
-            // @ts-ignore
-            let captures = {};
+            const captures = {};
             for (let parser of parsers) {
-                let result = parser(rest);
-                if (!result.success) {
-                    return result;
+                let parsed = parser(rest);
+                if (!parsed.success) {
+                    return parsed;
                 }
-                match.push(result.match);
-                rest = result.rest;
-                if (result.captures) {
-                    captures = (0, utils_1.mergeCaptures)(captures, result.captures);
+                results.push(parsed.result);
+                rest = parsed.rest;
+                if ((0, types_1.isCaptureResult)(parsed)) {
+                    for (const key in parsed.captures) {
+                        captures[key] = parsed.captures[key];
+                    }
                 }
             }
-            return { success: true, match, rest, captures };
+            const result = transform(results, captures);
+            return (0, types_1.success)(result, rest);
         });
     }
     exports.seq = seq;
     function capture(parser, name) {
-        return (0, trace_1.trace)(`captures(${(0, utils_1.escape)(name)})`, (input) => {
+        return (0, trace_1.trace)(`capture(${(0, utils_1.escape)(name)})`, (input) => {
             let result = parser(input);
             if (result.success) {
                 const captures = {
-                    [name]: result.match,
+                    [name]: result.result,
                 };
-                return Object.assign(Object.assign({}, result), { captures: (0, utils_1.mergeCaptures)(result.captures || {}, captures) });
+                return Object.assign(Object.assign({}, result), { captures });
             }
             return result;
         });
     }
     exports.capture = capture;
-    function captureCaptures(parser, name) {
-        return (0, trace_1.trace)(`captures(${(0, utils_1.escape)(name)})`, (input) => {
+    function wrap(parser, name) {
+        return (0, trace_1.trace)(`capture(${(0, utils_1.escape)(name)})`, (input) => {
             let result = parser(input);
             if (result.success) {
-                const captures = {
-                    [name]: result.captures,
-                };
-                return Object.assign(Object.assign({}, result), { captures: (0, utils_1.mergeCaptures)(result.captures || {}, captures) });
+                return Object.assign(Object.assign({}, result), { result: {
+                        [name]: result.result,
+                    } });
             }
             return result;
         });
     }
-    exports.captureCaptures = captureCaptures;
-    function shapeCaptures(parser, func, name) {
-        return (0, trace_1.trace)(`captures(${(0, utils_1.escape)(name)})`, (input) => {
-            let result = parser(input);
-            if (result.success) {
-                const captures = result.captures || {};
-                return Object.assign(Object.assign({}, result), { captures: func(captures) });
-            }
-            return result;
-        });
+    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;
+      });
     }
-    exports.shapeCaptures = shapeCaptures;
+    
+     */
+    /* 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;
+      });
+    } */
     function transform(parser, transformerFunc) {
         return (0, trace_1.trace)(`transform(${transformerFunc})`, (input) => {
-            let result = parser(input);
-            if (result.success) {
-                return Object.assign(Object.assign({}, result), { match: transformerFunc(result.match) });
+            let parsed = parser(input);
+            if (parsed.success) {
+                return Object.assign(Object.assign({}, parsed), { result: transformerFunc(parsed.result) });
             }
-            return result;
+            return parsed;
         });
     }
     exports.transform = transform;

package/dist/lib/combinators.d.ts

@@ -0,0 +1,17 @@
+import { CaptureParser, GeneralParser, MergedCaptures, 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>;
+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>>;
+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>;
+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/lib/combinators.js

@@ -0,0 +1,272 @@
+(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", "./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;
+    const trace_1 = require("./trace");
+    const types_1 = require("./types");
+    const utils_1 = require("./utils");
+    function many(parser) {
+        return (0, trace_1.trace)("many", (input) => {
+            let results = [];
+            let rest = input;
+            while (true) {
+                let parsed = parser(rest);
+                if (!parsed.success) {
+                    return (0, types_1.success)(results, rest);
+                }
+                results.push(parsed.result);
+                rest = parsed.rest;
+            }
+        });
+    }
+    exports.many = many;
+    function many1(parser) {
+        return (0, trace_1.trace)(`many1`, (input) => {
+            let result = many(parser)(input);
+            // this logic doesn't work with optional and not
+            if (result.rest !== input) {
+                return result;
+            }
+            return {
+                success: false,
+                rest: input,
+                message: "expected at least one match",
+            };
+        });
+    }
+    exports.many1 = many1;
+    function count(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);
+            }
+            return result;
+        });
+    }
+    exports.count = count;
+    function manyWithJoin(parser) {
+        return transform(many(parser), (x) => x.join(""));
+    }
+    exports.manyWithJoin = manyWithJoin;
+    function many1WithJoin(parser) {
+        return transform(many1(parser), (x) => x.join(""));
+    }
+    exports.many1WithJoin = many1WithJoin;
+    /* seq<, U>(
+      parsers: T,
+      transform: (results: MergedResults<T>[], captures: MergedCaptures<T>) => U,
+     */
+    function or(parsers, name = "") {
+        return (0, trace_1.trace)(`or(${name})`, (input) => {
+            for (let parser of parsers) {
+                let result = parser(input);
+                if (result.success) {
+                    return result;
+                }
+            }
+            return (0, types_1.failure)(`all parsers failed`, input);
+        });
+    }
+    exports.or = or;
+    function optional(parser) {
+        return (0, trace_1.trace)("optional", (input) => {
+            let result = parser(input);
+            if (result.success) {
+                return result;
+            }
+            return (0, types_1.success)(null, input);
+        });
+    }
+    exports.optional = optional;
+    function not(parser) {
+        return (0, trace_1.trace)("not", (input) => {
+            let result = parser(input);
+            if (result.success) {
+                return {
+                    success: false,
+                    rest: input,
+                    message: "unexpected match",
+                };
+            }
+            return (0, types_1.success)(null, input);
+        });
+    }
+    exports.not = not;
+    function between(open, close, parser) {
+        return (input) => {
+            const result1 = open(input);
+            if (!result1.success) {
+                return result1;
+            }
+            const parserResult = parser(result1.rest);
+            if (!parserResult.success) {
+                return parserResult;
+            }
+            const result2 = close(parserResult.rest);
+            if (!result2.success) {
+                return result2;
+            }
+            return (0, types_1.success)(parserResult.result, result2.rest);
+        };
+    }
+    exports.between = between;
+    function sepBy(separator, parser) {
+        return (input) => {
+            let results = [];
+            let rest = input;
+            while (true) {
+                const result = parser(rest);
+                if (!result.success) {
+                    return (0, types_1.success)(results, rest);
+                }
+                results.push(result.result);
+                rest = result.rest;
+                const sepResult = separator(rest);
+                if (!sepResult.success) {
+                    return (0, types_1.success)(results, rest);
+                }
+                rest = sepResult.rest;
+            }
+        };
+    }
+    exports.sepBy = sepBy;
+    function getResults(results, captures) {
+        return results;
+    }
+    exports.getResults = getResults;
+    function getCaptures(results, captures) {
+        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);
+            if (result.success) {
+                const captures = {
+                    [name]: result.result,
+                };
+                return Object.assign(Object.assign({}, result), { captures });
+            }
+            return result;
+        });
+    }
+    exports.capture = capture;
+    function wrap(parser, name) {
+        return (0, trace_1.trace)(`capture(${(0, utils_1.escape)(name)})`, (input) => {
+            let result = parser(input);
+            if (result.success) {
+                return Object.assign(Object.assign({}, result), { result: {
+                        [name]: result.result,
+                    } });
+            }
+            return result;
+        });
+    }
+    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;
+      });
+    }
+    
+     */
+    /* 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;
+      });
+    } */
+    function transform(parser, transformerFunc) {
+        return (0, trace_1.trace)(`transform(${transformerFunc})`, (input) => {
+            let parsed = parser(input);
+            if (parsed.success) {
+                return Object.assign(Object.assign({}, parsed), { result: transformerFunc(parsed.result) });
+            }
+            return parsed;
+        });
+    }
+    exports.transform = transform;
+});

package/dist/lib/index.d.ts

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

package/dist/lib/index.js

@@ -0,0 +1,29 @@
+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);
+};
+(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", "./parsers", "./combinators", "./trace"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require("./parsers"), exports);
+    __exportStar(require("./combinators"), exports);
+    __exportStar(require("./trace"), exports);
+});

package/dist/lib/parsers.d.ts

@@ -0,0 +1,17 @@
+import { Parser } from "./types";
+export declare function char(c: string): Parser<string>;
+export declare function str(s: string): Parser<string>;
+export declare function oneOf(chars: string): Parser<string>;
+export declare function noneOf(chars: string): Parser<string>;
+export declare function anyChar(input: string): Parser<string>;
+export declare const space: Parser<string>;
+export declare const spaces: Parser<string>;
+export declare const digit: Parser<string>;
+export declare const letter: Parser<string>;
+export declare const alphanum: Parser<string>;
+export declare const word: Parser<string>;
+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 quotedString: Parser<string>;

package/dist/lib/parsers.js

@@ -0,0 +1,87 @@
+(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", "./combinators", "./trace", "./types", "./utils"], 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;
+    const combinators_1 = require("./combinators");
+    const trace_1 = require("./trace");
+    const types_1 = require("./types");
+    const utils_1 = require("./utils");
+    function char(c) {
+        return (0, trace_1.trace)(`char(${(0, utils_1.escape)(c)})`, (input) => {
+            if (input.length === 0) {
+                return {
+                    success: false,
+                    rest: input,
+                    message: "unexpected end of input",
+                };
+            }
+            if (input[0] === c) {
+                return (0, types_1.success)(c, input.slice(1));
+            }
+            return (0, types_1.failure)(`expected ${c}, got ${input[0]}`, input);
+        });
+    }
+    exports.char = char;
+    function str(s) {
+        return (0, trace_1.trace)(`str(${(0, utils_1.escape)(s)})`, (input) => {
+            if (input.substring(0, s.length) === s) {
+                return (0, types_1.success)(s, input.slice(s.length));
+            }
+            return (0, types_1.failure)(`expected ${s}, got ${input.substring(0, s.length)}`, input);
+        });
+    }
+    exports.str = str;
+    function oneOf(chars) {
+        return (0, trace_1.trace)(`oneOf(${(0, utils_1.escape)(chars)})`, (input) => {
+            if (input.length === 0) {
+                return (0, types_1.failure)("unexpected end of input", input);
+            }
+            const c = input[0];
+            if (chars.includes(c)) {
+                return char(c)(input);
+            }
+            return (0, types_1.failure)(`expected one of ${(0, utils_1.escape)(chars)}, got ${c}`, input);
+        });
+    }
+    exports.oneOf = oneOf;
+    function noneOf(chars) {
+        return (0, trace_1.trace)(`noneOf(${(0, utils_1.escape)(chars)})`, (input) => {
+            if (input.length === 0) {
+                return (0, types_1.failure)("unexpected end of input", input);
+            }
+            if (chars.includes(input[0])) {
+                return (0, types_1.failure)(`expected none of ${(0, utils_1.escape)(chars)}, got ${input[0]}`, input);
+            }
+            return char(input[0])(input);
+        });
+    }
+    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;
+    exports.space = oneOf(" \t\n\r");
+    exports.spaces = (0, combinators_1.many1WithJoin)(exports.space);
+    exports.digit = oneOf("0123456789");
+    exports.letter = oneOf("abcdefghijklmnopqrstuvwxyz");
+    exports.alphanum = oneOf("abcdefghijklmnopqrstuvwxyz0123456789");
+    exports.word = (0, combinators_1.many1WithJoin)(exports.letter);
+    exports.num = (0, combinators_1.many1WithJoin)(exports.digit);
+    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(""));
+});

package/dist/lib/trace.d.ts

@@ -0,0 +1,3 @@
+import { ParserResult } from "./types";
+export declare function resultToString<T>(name: string, result: ParserResult<T>): string;
+export declare function trace(name: string, parser: any): any;

package/dist/lib/trace.js

@@ -0,0 +1,42 @@
+(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", "./utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.trace = exports.resultToString = void 0;
+    const utils_1 = require("./utils");
+    const STEP = 2;
+    function resultToString(name, result) {
+        if (result.success) {
+            return `✅ ${name} -- match: ${(0, utils_1.escape)(result.result)}, rest: ${(0, utils_1.escape)(result.rest)}`;
+        }
+        return `❌ ${name} -- message: ${(0, utils_1.escape)(result.message)}, rest: ${(0, utils_1.escape)(result.rest)}`;
+    }
+    exports.resultToString = resultToString;
+    let level = 0;
+    function trace(name, parser) {
+        return (input) => {
+            if (process.env.DEBUG) {
+                console.log(" ".repeat(level) + `🔍 ${name} -- input: ${(0, utils_1.escape)(input)}`);
+            }
+            level += STEP;
+            const result = parser(input);
+            level -= STEP;
+            if (process.env.DEBUG) {
+                console.log(" ".repeat(level) + resultToString(name, result));
+                if (result.success && result.captures) {
+                    console.log(" ".repeat(level) +
+                        `⭐ ${name} -- captures: ${JSON.stringify(result.captures)}`);
+                }
+            }
+            return result;
+        };
+    }
+    exports.trace = trace;
+});

package/dist/lib/types.d.ts

@@ -0,0 +1,33 @@
+export type PlainObject = Record<string, unknown>;
+export type ParserSuccess<T> = {
+    success: true;
+    result: T;
+    rest: string;
+};
+export type CaptureParserSuccess<T, C extends PlainObject> = ParserSuccess<T> & {
+    captures: C;
+};
+export type ParserFailure = {
+    success: false;
+    rest: string;
+    message: string;
+};
+export type ParserResult<T> = ParserSuccess<T> | ParserFailure;
+export type CaptureParserResult<T, C extends PlainObject> = CaptureParserSuccess<T, C> | ParserFailure;
+export type Parser<T> = (input: string) => ParserResult<T>;
+export type CaptureParser<T, C extends PlainObject> = (input: string) => CaptureParserResult<T, C>;
+export type GeneralParser<T, C extends PlainObject> = Parser<T> | CaptureParser<T, C>;
+export declare function isCaptureResult<T, C extends PlainObject>(result: ParserResult<T>): result is CaptureParserSuccess<T, C>;
+export declare function success<T>(result: T, rest: string): ParserSuccess<T>;
+export declare function captureSuccess<T, C extends PlainObject>(result: T, rest: string, captures: C): CaptureParserSuccess<T, C>;
+export declare function failure(message: string, rest: string): ParserFailure;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+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 MergedResults<T extends readonly GeneralParser<any, any>[]> = ExtractResults<T[number]>;
+export {};

package/dist/lib/types.js

@@ -0,0 +1,49 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.failure = exports.captureSuccess = exports.success = exports.isCaptureResult = void 0;
+    function isCaptureResult(result) {
+        return "captures" in result;
+    }
+    exports.isCaptureResult = isCaptureResult;
+    function success(result, rest) {
+        return { success: true, result, rest };
+    }
+    exports.success = success;
+    function captureSuccess(result, rest, captures) {
+        return { success: true, result, rest, captures };
+    }
+    exports.captureSuccess = captureSuccess;
+    function failure(message, rest) {
+        return { success: false, message, rest };
+    }
+    exports.failure = failure;
+});
+/* 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/lib/utils.d.ts

@@ -0,0 +1,3 @@
+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>;

package/dist/lib/utils.js

@@ -0,0 +1,48 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.mergeCaptures = exports.merge = exports.escape = void 0;
+    function escape(str) {
+        return JSON.stringify(str);
+    }
+    exports.escape = escape;
+    function merge(a, b) {
+        if (Array.isArray(a) && Array.isArray(b)) {
+            return [...a, ...b];
+        }
+        else if (Array.isArray(a)) {
+            return [...a, b];
+        }
+        else if (Array.isArray(b)) {
+            return [a, ...b];
+        }
+        else {
+            return [a, b];
+        }
+    }
+    exports.merge = merge;
+    function mergeCaptures(a, b) {
+        const result = {};
+        Object.keys(a).forEach((key) => {
+            result[key] = a[key];
+        });
+        Object.keys(b).forEach((key) => {
+            if (result[key]) {
+                result[key] = merge(result[key], b[key]);
+            }
+            else {
+                result[key] = b[key];
+            }
+        });
+        return result;
+    }
+    exports.mergeCaptures = mergeCaptures;
+});

package/dist/parsers.d.ts

@@ -14,4 +14,4 @@ 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 quotedString: Parser<string, string>;
+export declare const quotedString: Parser<string>;

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", "./utils"], factory);
+        define(["require", "exports", "./combinators", "./trace", "./types", "./utils"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -12,6 +12,7 @@
     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;
     const combinators_1 = require("./combinators");
     const trace_1 = require("./trace");
+    const types_1 = require("./types");
     const utils_1 = require("./utils");
     function char(c) {
         return (0, trace_1.trace)(`char(${(0, utils_1.escape)(c)})`, (input) => {
@@ -23,65 +24,41 @@
                 };
             }
             if (input[0] === c) {
-                return { success: true, match: c, rest: input.slice(1) };
+                return (0, types_1.success)(c, input.slice(1));
             }
-            return {
-                success: false,
-                rest: input,
-                message: `expected ${c}, got ${input[0]}`,
-            };
+            return (0, types_1.failure)(`expected ${c}, got ${input[0]}`, input);
         });
     }
     exports.char = char;
     function str(s) {
         return (0, trace_1.trace)(`str(${(0, utils_1.escape)(s)})`, (input) => {
             if (input.substring(0, s.length) === s) {
-                return { success: true, match: s, rest: input.slice(s.length) };
+                return (0, types_1.success)(s, input.slice(s.length));
             }
-            return {
-                success: false,
-                rest: input,
-                message: `expected ${s}, got ${input.substring(0, s.length)}`,
-            };
+            return (0, types_1.failure)(`expected ${s}, got ${input.substring(0, s.length)}`, input);
         });
     }
     exports.str = str;
     function oneOf(chars) {
         return (0, trace_1.trace)(`oneOf(${(0, utils_1.escape)(chars)})`, (input) => {
             if (input.length === 0) {
-                return {
-                    success: false,
-                    rest: input,
-                    message: "unexpected end of input",
-                };
+                return (0, types_1.failure)("unexpected end of input", input);
             }
             const c = input[0];
             if (chars.includes(c)) {
                 return char(c)(input);
             }
-            return {
-                success: false,
-                rest: input,
-                message: `expected one of ${(0, utils_1.escape)(chars)}, got ${c}`,
-            };
+            return (0, types_1.failure)(`expected one of ${(0, utils_1.escape)(chars)}, got ${c}`, input);
         });
     }
     exports.oneOf = oneOf;
     function noneOf(chars) {
         return (0, trace_1.trace)(`noneOf(${(0, utils_1.escape)(chars)})`, (input) => {
             if (input.length === 0) {
-                return {
-                    success: false,
-                    rest: input,
-                    message: "unexpected end of input",
-                };
+                return (0, types_1.failure)("unexpected end of input", input);
             }
             if (chars.includes(input[0])) {
-                return {
-                    success: false,
-                    rest: input,
-                    message: `expected none of ${chars}`,
-                };
+                return (0, types_1.failure)(`expected none of ${(0, utils_1.escape)(chars)}, got ${input[0]}`, input);
             }
             return char(input[0])(input);
         });
@@ -90,11 +67,7 @@
     function anyChar(input) {
         return (0, trace_1.trace)("anyChar", (input) => {
             if (input.length === 0) {
-                return {
-                    success: false,
-                    rest: input,
-                    message: "unexpected end of input",
-                };
+                return (0, types_1.failure)("unexpected end of input", input);
             }
             return { success: true, match: input[0], rest: input.slice(1) };
         });
@@ -110,5 +83,5 @@
     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], "quotedString"), (x) => x.join(""));
+    exports.quotedString = (0, combinators_1.transform)((0, combinators_1.seq)([exports.quote, exports.word, exports.quote], combinators_1.getResults), (x) => x.join(""));
 });

package/dist/trace.d.ts

@@ -1,3 +1,3 @@
-import { ParserResult, Parser } from "./types";
-export declare function resultToString<T>(name: string, result: ParserResult<T, string>): string;
-export declare function trace<T>(name: string, parser: Parser<T>): Parser<T>;
+import { ParserResult } from "./types";
+export declare function resultToString<T>(name: string, result: ParserResult<T>): string;
+export declare function trace(name: string, parser: any): any;

package/dist/trace.js

@@ -14,7 +14,7 @@
     const STEP = 2;
     function resultToString(name, result) {
         if (result.success) {
-            return `✅ ${name} -- match: ${(0, utils_1.escape)(result.match)}, rest: ${(0, utils_1.escape)(result.rest)}`;
+            return `✅ ${name} -- match: ${(0, utils_1.escape)(result.result)}, rest: ${(0, utils_1.escape)(result.rest)}`;
         }
         return `❌ ${name} -- message: ${(0, utils_1.escape)(result.message)}, rest: ${(0, utils_1.escape)(result.rest)}`;
     }

package/dist/types.d.ts

@@ -1,17 +1,33 @@
-export type Object = Record<string, string>;
-export type ParserSuccess<M, C extends string> = {
+export type PlainObject = Record<string, unknown>;
+export type ParserSuccess<T> = {
     success: true;
-    match: M;
-    captures?: Record<C, any>;
+    result: T;
     rest: string;
 };
+export type CaptureParserSuccess<T, C extends PlainObject> = ParserSuccess<T> & {
+    captures: C;
+};
 export type ParserFailure = {
     success: false;
     rest: string;
     message: string;
 };
-export type ParserOptions = {
-    capture: string;
-};
-export type ParserResult<M, C extends string> = ParserSuccess<M, C> | ParserFailure;
-export type Parser<M, C extends string = string> = (input: string) => ParserResult<M, C>;
+export type ParserResult<T> = ParserSuccess<T> | ParserFailure;
+export type CaptureParserResult<T, C extends PlainObject> = CaptureParserSuccess<T, C> | ParserFailure;
+export type Parser<T> = (input: string) => ParserResult<T>;
+export type CaptureParser<T, C extends PlainObject> = (input: string) => CaptureParserResult<T, C>;
+export type GeneralParser<T, C extends PlainObject> = Parser<T> | CaptureParser<T, C>;
+export declare function isCaptureResult<T, C extends PlainObject>(result: ParserResult<T>): result is CaptureParserSuccess<T, C>;
+export declare function success<T>(result: T, rest: string): ParserSuccess<T>;
+export declare function captureSuccess<T, C extends PlainObject>(result: T, rest: string, captures: C): CaptureParserSuccess<T, C>;
+export declare function failure(message: string, rest: string): ParserFailure;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+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 MergedResults<T extends readonly GeneralParser<any, any>[]> = ExtractResults<T[number]>;
+export {};

package/dist/types.js

@@ -9,4 +9,41 @@
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
+    exports.failure = exports.captureSuccess = exports.success = exports.isCaptureResult = void 0;
+    function isCaptureResult(result) {
+        return "captures" in result;
+    }
+    exports.isCaptureResult = isCaptureResult;
+    function success(result, rest) {
+        return { success: true, result, rest };
+    }
+    exports.success = success;
+    function captureSuccess(result, rest, captures) {
+        return { success: true, result, rest, captures };
+    }
+    exports.captureSuccess = captureSuccess;
+    function failure(message, rest) {
+        return { success: false, message, rest };
+    }
+    exports.failure = failure;
 });
+/* 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/package.json

@@ -1,9 +1,8 @@
 {
   "name": "tarsec",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "A parser combinator library for TypeScript, inspired by Parsec.",
   "homepage": "https://github.com/egonSchiele/tarsec",
- 
   "scripts": {
     "test": "vitest",
     "build": "tsc",
@@ -11,7 +10,7 @@
   },
   "files": [
     "./dist"
-  ],  
+  ],
   "exports": {
     ".": {
       "import": "./dist/index.js",
@@ -23,6 +22,7 @@
   "license": "ISC",
   "devDependencies": {
     "@types/node": "^20.11.28",
+    "typescript": "^5.4.2",
     "vitest": "^1.4.0"
   }
 }