tarsec 0.0.3 → 0.0.5

package/README.md

@@ -19,6 +19,8 @@ npm install tarsec
 ## Hello world
 
 ```ts
+import { str, char } from "tarsec";
+
 // define a parser
 const parser = seq([
     str("hello"),

package/dist/combinators.js

@@ -1,189 +1,199 @@
-"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;
-const trace_1 = require("./trace");
-const utils_1 = require("./utils");
-function many(parser) {
-    return (0, trace_1.trace)("many", (input) => {
-        let match = [];
-        let rest = input;
-        while (true) {
-            let result = parser(rest);
-            if (!result.success) {
-                return { success: true, match, rest };
+(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", "./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;
+    const trace_1 = require("./trace");
+    const utils_1 = require("./utils");
+    function many(parser) {
+        return (0, trace_1.trace)("many", (input) => {
+            let match = [];
+            let rest = input;
+            while (true) {
+                let result = parser(rest);
+                if (!result.success) {
+                    return { success: true, match, rest };
+                }
+                match.push(result.match);
+                rest = result.rest;
             }
-            match.push(result.match);
-            rest = result.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 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;
-function or(parsers, name = "") {
-    return (0, trace_1.trace)(`or(${name})`, (input) => {
-        for (let parser of parsers) {
-            let result = parser(input);
-            if (result.success) {
+        });
+    }
+    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: "all parsers failed",
-        };
-    });
-}
-exports.or = or;
-function optional(parser) {
-    return (0, trace_1.trace)("optional", (input) => {
-        let result = parser(input);
-        if (result.success) {
-            return result;
-        }
-        return { success: true, match: null, rest: 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",
+                message: "expected at least one match",
             };
-        }
-        return { success: true, match: null, rest: 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 { success: true, match: parserResult.match, rest: result2.rest };
-    };
-}
-exports.between = between;
-function sepBy(separator, parser) {
-    return (input) => {
-        let match = [];
-        let rest = input;
-        while (true) {
-            const result = parser(rest);
-            if (!result.success) {
-                return { success: true, match, rest };
-            }
-            match.push(result.match);
-            rest = result.rest;
-            const sepResult = separator(rest);
-            if (!sepResult.success) {
-                return { success: true, match, rest };
+        });
+    }
+    exports.many1 = many1;
+    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;
+    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;
+                }
             }
-            rest = sepResult.rest;
-        }
-    };
-}
-exports.sepBy = sepBy;
-function seq(parsers, name = "") {
-    return (0, trace_1.trace)(`seq(${name})`, (input) => {
-        let match = [];
-        let rest = input;
-        // @ts-ignore
-        let captures = {};
-        for (let parser of parsers) {
-            let result = parser(rest);
-            if (!result.success) {
+            return {
+                success: false,
+                rest: input,
+                message: "all parsers failed",
+            };
+        });
+    }
+    exports.or = or;
+    function optional(parser) {
+        return (0, trace_1.trace)("optional", (input) => {
+            let result = parser(input);
+            if (result.success) {
                 return result;
             }
-            match.push(result.match);
-            rest = result.rest;
-            if (result.captures) {
-                captures = (0, utils_1.mergeCaptures)(captures, result.captures);
+            return { success: true, match: null, rest: 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 { success: true, match: null, rest: input };
+        });
+    }
+    exports.not = not;
+    function between(open, close, parser) {
+        return (input) => {
+            const result1 = open(input);
+            if (!result1.success) {
+                return result1;
             }
-        }
-        return { success: true, match, rest, captures };
-    });
-}
-exports.seq = seq;
-function capture(parser, name) {
-    return (0, trace_1.trace)(`captures(${(0, utils_1.escape)(name)})`, (input) => {
-        let result = parser(input);
-        if (result.success) {
-            const captures = {
-                [name]: result.match,
-            };
-            return Object.assign(Object.assign({}, result), { captures: (0, utils_1.mergeCaptures)(result.captures || {}, captures) });
-        }
-        return result;
-    });
-}
-exports.capture = capture;
-function captureCaptures(parser, name) {
-    return (0, trace_1.trace)(`captures(${(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 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.shapeCaptures = shapeCaptures;
-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) });
-        }
-        return result;
-    });
-}
-exports.transform = transform;
+            const parserResult = parser(result1.rest);
+            if (!parserResult.success) {
+                return parserResult;
+            }
+            const result2 = close(parserResult.rest);
+            if (!result2.success) {
+                return result2;
+            }
+            return { success: true, match: parserResult.match, rest: result2.rest };
+        };
+    }
+    exports.between = between;
+    function sepBy(separator, parser) {
+        return (input) => {
+            let match = [];
+            let rest = input;
+            while (true) {
+                const result = parser(rest);
+                if (!result.success) {
+                    return { success: true, match, rest };
+                }
+                match.push(result.match);
+                rest = result.rest;
+                const sepResult = separator(rest);
+                if (!sepResult.success) {
+                    return { success: true, match, rest };
+                }
+                rest = sepResult.rest;
+            }
+        };
+    }
+    exports.sepBy = sepBy;
+    function seq(parsers, name = "") {
+        return (0, trace_1.trace)(`seq(${name})`, (input) => {
+            let match = [];
+            let rest = input;
+            // @ts-ignore
+            let captures = {};
+            for (let parser of parsers) {
+                let result = parser(rest);
+                if (!result.success) {
+                    return result;
+                }
+                match.push(result.match);
+                rest = result.rest;
+                if (result.captures) {
+                    captures = (0, utils_1.mergeCaptures)(captures, result.captures);
+                }
+            }
+            return { success: true, match, rest, captures };
+        });
+    }
+    exports.seq = seq;
+    function capture(parser, name) {
+        return (0, trace_1.trace)(`captures(${(0, utils_1.escape)(name)})`, (input) => {
+            let result = parser(input);
+            if (result.success) {
+                const captures = {
+                    [name]: result.match,
+                };
+                return Object.assign(Object.assign({}, result), { captures: (0, utils_1.mergeCaptures)(result.captures || {}, captures) });
+            }
+            return result;
+        });
+    }
+    exports.capture = capture;
+    function captureCaptures(parser, name) {
+        return (0, trace_1.trace)(`captures(${(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 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.shapeCaptures = shapeCaptures;
+    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) });
+            }
+            return result;
+        });
+    }
+    exports.transform = transform;
+});

package/dist/index.js

@@ -1,4 +1,3 @@
-"use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -13,7 +12,18 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./parsers"), exports);
-__exportStar(require("./combinators"), exports);
-__exportStar(require("./trace"), exports);
+(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/parsers.js

@@ -1,104 +1,114 @@
-"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 utils_1 = require("./utils");
-function char(c) {
-    return (0, trace_1.trace)(`char(${(0, utils_1.escape)(c)})`, (input) => {
-        if (input.length === 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", "./combinators", "./trace", "./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 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 { success: true, match: c, rest: input.slice(1) };
+            }
             return {
                 success: false,
                 rest: input,
-                message: "unexpected end of input",
+                message: `expected ${c}, got ${input[0]}`,
             };
-        }
-        if (input[0] === c) {
-            return { success: true, match: c, rest: input.slice(1) };
-        }
-        return {
-            success: false,
-            rest: input,
-            message: `expected ${c}, got ${input[0]}`,
-        };
-    });
-}
-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 {
-            success: false,
-            rest: input,
-            message: `expected ${s}, got ${input.substring(0, s.length)}`,
-        };
-    });
-}
-exports.str = str;
-function oneOf(chars) {
-    return (0, trace_1.trace)(`oneOf(${(0, utils_1.escape)(chars)})`, (input) => {
-        if (input.length === 0) {
+        });
+    }
+    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 {
                 success: false,
                 rest: input,
-                message: "unexpected end of input",
+                message: `expected ${s}, got ${input.substring(0, s.length)}`,
             };
-        }
-        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}`,
-        };
-    });
-}
-exports.oneOf = oneOf;
-function noneOf(chars) {
-    return (0, trace_1.trace)(`noneOf(${(0, utils_1.escape)(chars)})`, (input) => {
-        if (input.length === 0) {
+        });
+    }
+    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",
+                };
+            }
+            const c = input[0];
+            if (chars.includes(c)) {
+                return char(c)(input);
+            }
             return {
                 success: false,
                 rest: input,
-                message: "unexpected end of input",
+                message: `expected one of ${(0, utils_1.escape)(chars)}, got ${c}`,
             };
-        }
-        if (chars.includes(input[0])) {
-            return {
-                success: false,
-                rest: input,
-                message: `expected none of ${chars}`,
-            };
-        }
-        return char(input[0])(input);
-    });
-}
-exports.noneOf = noneOf;
-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 { 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], "quotedString"), (x) => x.join(""));
+        });
+    }
+    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",
+                };
+            }
+            if (chars.includes(input[0])) {
+                return {
+                    success: false,
+                    rest: input,
+                    message: `expected none of ${chars}`,
+                };
+            }
+            return char(input[0])(input);
+        });
+    }
+    exports.noneOf = noneOf;
+    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 { 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], "quotedString"), (x) => x.join(""));
+});

package/dist/trace.js

@@ -1,32 +1,42 @@
-"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.match)}, rest: ${(0, utils_1.escape)(result.rest)}`;
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
     }
-    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)}`);
+    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.match)}, rest: ${(0, utils_1.escape)(result.rest)}`;
         }
-        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 `❌ ${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)}`);
             }
-        }
-        return result;
-    };
-}
-exports.trace = trace;
+            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/types.js

@@ -1,2 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+(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 });
+});

package/dist/utils.js

@@ -1,38 +1,48 @@
-"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];
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
     }
-    else if (Array.isArray(a)) {
-        return [...a, b];
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
     }
-    else if (Array.isArray(b)) {
-        return [a, ...b];
+})(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);
     }
-    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]);
+    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 {
-            result[key] = b[key];
+            return [a, b];
         }
-    });
-    return result;
-}
-exports.mergeCaptures = mergeCaptures;
+    }
+    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/package.json

@@ -1,20 +1,21 @@
 {
   "name": "tarsec",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "A parser combinator library for TypeScript, inspired by Parsec.",
   "homepage": "https://github.com/egonSchiele/tarsec",
+ 
   "scripts": {
     "test": "vitest",
     "build": "tsc",
     "start": "cd dist && node index.js"
   },
-  "files": ["./dist"],
+  "files": [
+    "./dist"
+  ],
   "keywords": [],
   "author": "",
   "license": "ISC",
-  "exports": {
-    "*": "./dist/*"
-  },
+  "types": "./dist/index.d.ts",
   "devDependencies": {
     "@types/node": "^20.11.28",
     "vitest": "^1.4.0"