tarsec 0.0.7 → 0.0.9

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.7",
+  "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"
   }
 }

package/dist/lib/parsers.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/parsers.test.js

@@ -1,235 +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", "vitest", "./parsers", "../vitest.globals.js", "./combinators"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    const vitest_1 = require("vitest");
-    const parsers_1 = require("./parsers");
-    const vitest_globals_js_1 = require("../vitest.globals.js");
-    const combinators_1 = require("./combinators");
-    vitest_1.test.skip("hello", () => {
-        (0, vitest_1.describe)("Parser Tests", () => {
-            (0, vitest_1.describe)("optional parser", () => {
-                const parser = (0, combinators_1.optional)((0, parsers_1.char)("a"));
-                (0, vitest_1.it)("should parse the character if it exists", () => {
-                    const result = parser("a");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.success)({ rest: "", match: "a" }));
-                });
-                (0, vitest_1.it)("should return an empty string if the character is missing", () => {
-                    const result = parser("b");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.success)({ rest: "b", match: "" }));
-                });
-                (0, vitest_1.it)("should not consume any input if it fails", () => {
-                    // @ts-ignore
-                    const parser2 = (0, combinators_1.optional)((0, combinators_1.seq)((0, combinators_1.many1WithJoin)(parsers_1.letter), (0, parsers_1.char)("!")));
-                    const result1 = parser2("hello!");
-                    (0, vitest_1.expect)(result1).toEqual((0, vitest_globals_js_1.success)({ rest: "", match: "hello!", captures: {} }));
-                    const result2 = parser2("hello");
-                    (0, vitest_1.expect)(result2).toEqual((0, vitest_globals_js_1.success)({ rest: "hello", match: "" }));
-                });
-            });
-            (0, vitest_1.describe)("not parser", () => {
-                const parser = (0, combinators_1.not)((0, parsers_1.char)("a"));
-                (0, vitest_1.it)("should fail if the character is present", () => {
-                    const result = parser("a");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.failure)({ rest: "a", message: "unexpected match" }));
-                });
-                (0, vitest_1.it)("should return an empty string if the character is missing", () => {
-                    const result = parser("b");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.success)({ rest: "b", match: "" }));
-                });
-            });
-            (0, vitest_1.describe)("space parser", () => {
-                (0, vitest_1.it)("should parse a space character", () => {
-                    const result = (0, parsers_1.space)(" ");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.success)({ rest: "", match: " " }));
-                });
-                (0, vitest_1.it)("should fail if the character is not a space", () => {
-                    const result = (0, parsers_1.space)("a");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.failure)({ rest: "a", message: "expected  , got a" }));
-                });
-            });
-            (0, vitest_1.describe)("spaces parser", () => {
-                (0, vitest_1.it)("should parse multiple space characters", () => {
-                    const result = (0, parsers_1.spaces)("  ");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.success)({ rest: "", match: "  " }));
-                });
-                (0, vitest_1.it)("should fail if no space characters found", () => {
-                    const result = (0, parsers_1.spaces)("abc");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.failure)({ rest: "abc", message: "expected at least one match" }));
-                });
-            });
-            (0, vitest_1.describe)("digit parser", () => {
-                (0, vitest_1.it)("should parse a single digit", () => {
-                    const result = (0, parsers_1.digit)("1");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.success)({ rest: "", match: "1" }));
-                });
-                (0, vitest_1.it)("should fail if the character is not a digit", () => {
-                    const result = (0, parsers_1.digit)("a");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.failure)({ rest: "a", message: "expected one of 0123456789" }));
-                });
-            });
-            (0, vitest_1.describe)("letter parser", () => {
-                (0, vitest_1.it)("should parse a single letter", () => {
-                    const result = (0, parsers_1.letter)("a");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.success)({ rest: "", match: "a" }));
-                });
-                (0, vitest_1.it)("should fail if the character is not a letter", () => {
-                    const result = (0, parsers_1.letter)("1");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.failure)({
-                        rest: "1",
-                        message: "expected one of abcdefghijklmnopqrstuvwxyz",
-                    }));
-                });
-            });
-            (0, vitest_1.describe)("alphanum parser", () => {
-                (0, vitest_1.it)("should parse a single alphanumeric character", () => {
-                    const result = (0, parsers_1.alphanum)("1");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.success)({ rest: "", match: "1" }));
-                });
-                (0, vitest_1.it)("should fail if the character is not alphanumeric", () => {
-                    const result = (0, parsers_1.alphanum)("_");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.failure)({
-                        rest: "_",
-                        message: "expected one of abcdefghijklmnopqrstuvwxyz0123456789",
-                    }));
-                });
-            });
-            (0, vitest_1.describe)("word parser", () => {
-                const parser = parsers_1.word;
-                (0, vitest_1.it)("should parse a single word", () => {
-                    const result = parser("hello");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.success)({ rest: "", match: "hello" }));
-                });
-                (0, vitest_1.it)("should fail if no word characters found", () => {
-                    const result = parser("123");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.failure)({ rest: "123", message: "expected at least one match" }));
-                });
-            });
-            (0, vitest_1.describe)("number parser", () => {
-                const parser = parsers_1.num;
-                (0, vitest_1.it)("should parse a single number", () => {
-                    const result = parser("123");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.success)({ rest: "", match: "123" }));
-                });
-                (0, vitest_1.it)("should fail if no number characters found", () => {
-                    const result = parser("abc");
-                    (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.failure)({ rest: "abc", message: "expected at least one match" }));
-                });
-            });
-        });
-        (0, vitest_1.describe)("seq parser", () => {
-            const parser = (0, combinators_1.seq)([(0, parsers_1.char)("a"), (0, parsers_1.char)("b")]);
-            (0, vitest_1.it)("should parse both characters in sequence", () => {
-                const result = parser("ab");
-                (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.success)({ rest: "", match: "ab", captures: {} }));
-            });
-            (0, vitest_1.it)("should fail if any of the parsers fail", () => {
-                const result = parser("ac");
-                (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.failure)({ rest: "c", message: "expected b, got c" }));
-            });
-        });
-        (0, vitest_1.describe)("seq parser - hello world", () => {
-            (0, vitest_1.it)("multiple char parsers", () => {
-                const parser = (0, combinators_1.seq)([
-                    (0, parsers_1.char)("h"),
-                    (0, parsers_1.char)("e"),
-                    (0, parsers_1.char)("l"),
-                    (0, parsers_1.char)("l"),
-                    (0, parsers_1.char)("o"),
-                ]);
-                const result = parser("hello world");
-                (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.success)({ match: "hello", rest: " world", captures: {} }));
-            });
-            (0, vitest_1.it)("multiple str parsers", () => {
-                const parser = (0, combinators_1.seq)([(0, parsers_1.str)("hello"), parsers_1.space, (0, parsers_1.str)("world")]);
-                const result = parser("hello world");
-                (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.success)({ match: "hello world", rest: "", captures: {} }));
-            });
-            (0, vitest_1.it)("multiple str parsers + capture", () => {
-                const parser = (0, combinators_1.seq)([(0, parsers_1.str)("hello"), parsers_1.space, (0, combinators_1.capture)((0, parsers_1.str)("world"), "name")]);
-                const result = parser("hello world");
-                (0, vitest_1.expect)(result).toEqual((0, vitest_globals_js_1.success)({ match: "hello world", rest: "", captures: { name: "world" } }));
-            });
-        });
-        /* test("quote parser - single quote", () => {
-        const input = "'";
-        const result = quote(input);
-        expect(result).toEqual(success({ rest: "", match: "'", captures: {} }));
-      });
-      
-      test("quote parser - double quote", () => {
-        const input = '"';
-        const result = quote(input);
-        expect(result).toEqual(success({ rest: "", match: '"', captures: {} }));
-      });
-      
-      test("quote parser - invalid quote", () => {
-        const input = "`";
-        const result = quote(input);
-        expect(result).toEqual(
-          failure({ rest: "`", message: "unexpected end of input" })
-        );
-      });
-      
-      // Test for anyChar parser
-      test("anyChar parser - non-empty input", () => {
-        const input = "abc";
-        const result = anyChar(input);
-        expect(result).toEqual(success({ rest: "bc", match: "a", captures: {} }));
-      });
-      
-      test("anyChar parser - empty input", () => {
-        const input = "";
-        const result = anyChar(input);
-        expect(result).toEqual(
-          failure({ rest: "", message: "unexpected end of input" })
-        );
-      });
-      
-      // Test for between parser
-      test("between parser - valid input", () => {
-        const open = quote;
-        const close = quote;
-        const parser = anyChar;
-        const input = "'abc'";
-        const result = between(open, close, parser)(input);
-        expect(result).toEqual(success({ rest: "", match: "a", captures: {} }));
-      });
-      
-      test("between parser - invalid input", () => {
-        const open = quote;
-        const close = quote;
-        const parser = anyChar;
-        const input = "\"abc'";
-        const result = between(open, close, parser)(input);
-        expect(result).toEqual(
-          failure({ rest: "abc'", message: "unexpected end of input" })
-        );
-      });
-      
-      // Test for sepBy parser
-      test("sepBy parser - valid input", () => {
-        const separator = anyChar;
-        const parser = anyChar;
-        const input = "a,b,c";
-        const result = sepBy(separator, parser)(input);
-        expect(result).toEqual(success({ rest: "", match: "abc", captures: {} }));
-      });
-      
-      test("sepBy parser - invalid input", () => {
-        const separator = quote;
-        const parser = anyChar;
-        const input = '"a"bc';
-        const result = sepBy(separator, parser)(input);
-        expect(result).toEqual(success({ rest: "bc", match: "a", captures: {} }));
-      });
-       */
-    });
-});

package/dist/tests/combinators/many.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/combinators/many.test.js

@@ -1,27 +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", "@/lib/combinators", "@/lib/parsers", "vitest", "vitest.globals"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    const combinators_1 = require("@/lib/combinators");
-    const parsers_1 = require("@/lib/parsers");
-    const vitest_1 = require("vitest");
-    const vitest_globals_1 = require("vitest.globals");
-    (0, vitest_1.describe)("many combinator", () => {
-        const parser = (0, combinators_1.many)(parsers_1.digit);
-        (0, vitest_1.it)("should parse multiple digits", () => {
-            const result = parser("1234");
-            (0, vitest_1.expect)(result).toEqual((0, vitest_globals_1.success)({ rest: "", match: ["1", "2", "3", "4"] }));
-        });
-        (0, vitest_1.it)("should return an empty string if no matches found", () => {
-            const result = parser("abc");
-            (0, vitest_1.expect)(result).toEqual((0, vitest_globals_1.success)({ rest: "abc", match: [] }));
-        });
-    });
-});

package/dist/tests/combinators/many1.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/combinators/many1.test.js

@@ -1,27 +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", "@/lib/combinators", "@/lib/parsers", "vitest", "vitest.globals"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    const combinators_1 = require("@/lib/combinators");
-    const parsers_1 = require("@/lib/parsers");
-    const vitest_1 = require("vitest");
-    const vitest_globals_1 = require("vitest.globals");
-    (0, vitest_1.describe)("many1 combinator", () => {
-        const parser = (0, combinators_1.many1)(parsers_1.digit);
-        (0, vitest_1.it)("should parse multiple digits", () => {
-            const result = parser("1234");
-            (0, vitest_1.expect)(result).toEqual((0, vitest_globals_1.success)({ rest: "", match: ["1", "2", "3", "4"] }));
-        });
-        (0, vitest_1.it)("should fail if no matches found", () => {
-            const result = parser("abc");
-            (0, vitest_1.expect)(result).toEqual((0, vitest_globals_1.failure)({ rest: "abc", message: "expected at least one match" }));
-        });
-    });
-});

package/dist/tests/combinators/or.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/combinators/or.test.js

@@ -1,31 +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", "@/lib/combinators", "@/lib/parsers", "vitest", "vitest.globals"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    const combinators_1 = require("@/lib/combinators");
-    const parsers_1 = require("@/lib/parsers");
-    const vitest_1 = require("vitest");
-    const vitest_globals_1 = require("vitest.globals");
-    (0, vitest_1.describe)("or parser", () => {
-        const parser = (0, combinators_1.or)([(0, parsers_1.char)("a"), (0, parsers_1.char)("b")]);
-        (0, vitest_1.it)("should parse the first parser if it succeeds", () => {
-            const result = parser("a");
-            (0, vitest_1.expect)(result).toEqual((0, vitest_globals_1.success)({ rest: "", match: "a" }));
-        });
-        (0, vitest_1.it)("should parse the second parser if the first one fails", () => {
-            const result = parser("b");
-            (0, vitest_1.expect)(result).toEqual((0, vitest_globals_1.success)({ rest: "", match: "b" }));
-        });
-        (0, vitest_1.it)("should fail if all parsers fail", () => {
-            const result = parser("c");
-            (0, vitest_1.expect)(result).toEqual((0, vitest_globals_1.failure)({ rest: "c", message: "all parsers failed" }));
-        });
-    });
-});

package/dist/tests/combinators/seq.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/combinators/seq.test.js

@@ -1,41 +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", "@/lib/combinators", "@/lib/parsers", "vitest", "vitest.globals"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    const combinators_1 = require("@/lib/combinators");
-    const parsers_1 = require("@/lib/parsers");
-    const vitest_1 = require("vitest");
-    const vitest_globals_1 = require("vitest.globals");
-    (0, vitest_1.describe)("seq parser - hello world", () => {
-        (0, vitest_1.it)("multiple char parsers", () => {
-            const parser = (0, combinators_1.seq)([(0, parsers_1.char)("h"), (0, parsers_1.char)("e"), (0, parsers_1.char)("l"), (0, parsers_1.char)("l"), (0, parsers_1.char)("o")]);
-            const result = parser("hello world");
-            (0, vitest_1.expect)(result).toEqual((0, vitest_globals_1.success)({
-                match: ["h", "e", "l", "l", "o"],
-                rest: " world",
-                captures: {},
-            }));
-        });
-        (0, vitest_1.it)("multiple str parsers", () => {
-            const parser = (0, combinators_1.seq)([(0, parsers_1.str)("hello"), parsers_1.space, (0, parsers_1.str)("world")]);
-            const result = parser("hello world");
-            (0, vitest_1.expect)(result).toEqual((0, vitest_globals_1.success)({ match: ["hello", " ", "world"], rest: "", captures: {} }));
-        });
-        (0, vitest_1.it)("multiple str parsers + capture", () => {
-            const parser = (0, combinators_1.seq)([(0, parsers_1.str)("hello"), parsers_1.space, (0, combinators_1.capture)((0, parsers_1.str)("world"), "name")]);
-            const result = parser("hello world");
-            (0, vitest_1.expect)(result).toEqual((0, vitest_globals_1.success)({
-                match: ["hello", " ", "world"],
-                rest: "",
-                captures: { name: "world" },
-            }));
-        });
-    });
-});

package/dist/tests/integration/hello_capture.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/integration/hello_capture.test.js

@@ -1,30 +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", "@/lib/combinators", "@/lib/parsers", "vitest"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    const combinators_1 = require("@/lib/combinators");
-    const parsers_1 = require("@/lib/parsers");
-    const vitest_1 = require("vitest");
-    (0, vitest_1.describe)("hello world", () => {
-        (0, vitest_1.it)("parses + captures name", () => {
-            const parser = (0, combinators_1.seq)([
-                (0, parsers_1.str)("hello"),
-                parsers_1.space,
-                (0, combinators_1.capture)((0, combinators_1.many1WithJoin)((0, parsers_1.noneOf)("!")), "name"),
-                (0, parsers_1.char)("!"),
-            ]);
-            const result = parser("hello adit!");
-            (0, vitest_1.expect)(result.success).toEqual(true);
-            (0, vitest_1.expect)(result.captures).toEqual({
-                name: "adit",
-            });
-        });
-    });
-});

package/dist/tests/integration/hello_world.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/integration/hello_world.test.js

@@ -1,23 +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", "@/lib/combinators", "@/lib/parsers", "vitest", "vitest.globals"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    const combinators_1 = require("@/lib/combinators");
-    const parsers_1 = require("@/lib/parsers");
-    const vitest_1 = require("vitest");
-    const vitest_globals_1 = require("vitest.globals");
-    (0, vitest_1.describe)("hello world", () => {
-        (0, vitest_1.it)("parses", () => {
-            const parser = (0, combinators_1.seq)([(0, parsers_1.str)("hello"), parsers_1.space, (0, parsers_1.str)("world")]);
-            const result = parser("hello world");
-            (0, vitest_1.expect)(result).toEqual((0, vitest_globals_1.success)({ match: ["hello", " ", "world"], rest: "", captures: {} }));
-        });
-    });
-});

package/dist/tests/parsers/char.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/parsers/char.test.js

@@ -1,35 +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", "@/lib/parsers.js", "vitest", "vitest.globals"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    const parsers_js_1 = require("@/lib/parsers.js");
-    const vitest_1 = require("vitest");
-    const vitest_globals_1 = require("vitest.globals");
-    (0, vitest_1.describe)("char parser", () => {
-        (0, vitest_1.it)("should parse correct character", () => {
-            const parser = (0, parsers_js_1.char)("a");
-            (0, vitest_1.expect)(parser("abc")).toEqual((0, vitest_globals_1.success)({ match: "a", rest: "bc" }));
-        });
-        (0, vitest_1.it)("should handle unexpected end of input", () => {
-            const parser = (0, parsers_js_1.char)("a");
-            (0, vitest_1.expect)(parser("")).toEqual((0, vitest_globals_1.failure)({
-                rest: "",
-                message: "unexpected end of input",
-            }));
-        });
-        (0, vitest_1.it)("should handle incorrect character", () => {
-            const parser = (0, parsers_js_1.char)("a");
-            (0, vitest_1.expect)(parser("bcd")).toEqual((0, vitest_globals_1.failure)({
-                rest: "bcd",
-                message: "expected a, got b",
-            }));
-        });
-    });
-});

package/dist/tests/parsers/noneOf.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/parsers/noneOf.test.js

@@ -1,26 +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", "@/lib/parsers", "vitest", "vitest.globals"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    const parsers_1 = require("@/lib/parsers");
-    const vitest_1 = require("vitest");
-    const vitest_globals_1 = require("vitest.globals");
-    (0, vitest_1.describe)("noneOf parser", () => {
-        const parser = (0, parsers_1.noneOf)("xyz");
-        (0, vitest_1.it)("should parse any character that is not one of the given characters", () => {
-            const result = parser("a");
-            (0, vitest_1.expect)(result).toEqual((0, vitest_globals_1.success)({ rest: "", match: "a" }));
-        });
-        (0, vitest_1.it)("should fail if any of the given characters match", () => {
-            const result = parser("x");
-            (0, vitest_1.expect)(result).toEqual((0, vitest_globals_1.failure)({ rest: "x", message: "expected none of xyz" }));
-        });
-    });
-});

package/dist/tests/parsers/oneOf.test.d.ts

@@ -1 +0,0 @@
-export {};