tarsec 0.0.9 → 0.0.10

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "tarsec",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "A parser combinator library for TypeScript, inspired by Parsec.",
   "homepage": "https://github.com/egonSchiele/tarsec",
   "scripts": {
     "test": "vitest",
-    "build": "tsc",
+    "build": "rm -rf dist && tsc",
     "start": "cd dist && node index.js"
   },
   "files": [

package/dist/lib/combinators.d.ts

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

@@ -1,272 +0,0 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./trace", "./types", "./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

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

package/dist/lib/index.js

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

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

@@ -1,87 +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", "./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

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

@@ -1,42 +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", "./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

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

@@ -1,49 +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"], 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

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

@@ -1,48 +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"], 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;
-});