@zigsterz/parzing 1.1.0 → 1.2.0

package/dist/builder.d.ts

@@ -8,7 +8,7 @@ import { CutParser, FailParser, Parser, ParserType, PassParser, RefParser } from
 import { AnyOfParser } from "./parsers/AnyOfParser";
 import { RegexParser } from "./parsers/RegexParser";
 import { TokenParser } from "./parsers/TokenParser";
-declare type WithPostfixSupport<T> = T & {
+type WithPostfixSupport<T> = T & {
     _<R>(f: (target: WithPostfixSupport<T>) => R): WithPostfixSupport<R>;
 };
 export declare function addPostfixSupport<T>(who: T): WithPostfixSupport<T>;
@@ -19,7 +19,7 @@ export declare class ParserBuilder {
     token(tok: string): WithPostfixSupport<TokenParser>;
     anyOf(alts: string, minLen?: number | null, maxLen?: number | null): WithPostfixSupport<AnyOfParser>;
     regex(re: RegExp): WithPostfixSupport<RegexParser>;
-    fail(message?: string): WithPostfixSupport<FailParser>;
+    fail(message: string): WithPostfixSupport<FailParser>;
     pass(): WithPostfixSupport<PassParser>;
     cut(): WithPostfixSupport<CutParser>;
     ref<T>(f: () => Parser<T>): WithPostfixSupport<RefParser<T>>;
@@ -27,7 +27,7 @@ export declare class ParserBuilder {
     map<V extends Parser<unknown>, T>(parser: V, mapper: (i: ParserType<V>) => T): WithPostfixSupport<MapParser<V, T>>;
     sequence<TS extends Parser<unknown>[]>(...s: TS): WithPostfixSupport<SequenceCombinator<TS>>;
     choice<T extends Parser<any>[]>(...parsers: T): ChooseCombinator<T>;
-    many<T>(parser: Parser<T>, sep?: Parser<unknown> | null, min?: number, max?: number): WithPostfixSupport<ManyCombinator<T>>;
+    many<T>(parser: Parser<T>, sep?: Parser<unknown>, min?: number, max?: number): WithPostfixSupport<ManyCombinator<T>>;
     optional<T>(parser: Parser<T>): WithPostfixSupport<OptionalCombinator<T>>;
     private _ws;
 }

package/dist/builder.js

@@ -1,92 +1,76 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParserBuilder = exports.addPostfixSupport = void 0;
-var AttemptParser_1 = require("./combinators/AttemptParser");
-var ChooseCombinator_1 = require("./combinators/ChooseCombinator");
-var ManyCombinator_1 = require("./combinators/ManyCombinator");
-var MapParser_1 = require("./combinators/MapParser");
-var OptionalCombinator_1 = require("./combinators/OptionalCombinator");
-var SequenceCombinator_1 = require("./combinators/SequenceCombinator");
-var core_1 = require("./core");
-var AnyOfParser_1 = require("./parsers/AnyOfParser");
-var RegexParser_1 = require("./parsers/RegexParser");
-var TokenParser_1 = require("./parsers/TokenParser");
+exports.ParserBuilder = void 0;
+exports.addPostfixSupport = addPostfixSupport;
+const AttemptParser_1 = require("./combinators/AttemptParser");
+const ChooseCombinator_1 = require("./combinators/ChooseCombinator");
+const ManyCombinator_1 = require("./combinators/ManyCombinator");
+const MapParser_1 = require("./combinators/MapParser");
+const OptionalCombinator_1 = require("./combinators/OptionalCombinator");
+const SequenceCombinator_1 = require("./combinators/SequenceCombinator");
+const core_1 = require("./core");
+const AnyOfParser_1 = require("./parsers/AnyOfParser");
+const RegexParser_1 = require("./parsers/RegexParser");
+const TokenParser_1 = require("./parsers/TokenParser");
 function addPostfixSupport(who) {
-    var ret = who;
+    const ret = who;
     ret._ = function (f) {
         return addPostfixSupport(f(ret));
     };
     return ret;
 }
-exports.addPostfixSupport = addPostfixSupport;
-var ParserBuilder = /** @class */ (function () {
-    function ParserBuilder(whitespaceParser) {
-        if (whitespaceParser === void 0) { whitespaceParser = null; }
+class ParserBuilder {
+    constructor(whitespaceParser = null) {
         this._ws = whitespaceParser;
     }
-    ParserBuilder.prototype.postProcessParser = function (parser) {
-        var p = parser;
+    postProcessParser(parser) {
+        let p = parser;
         if (p instanceof core_1.ParserWithInternalWhitespaceSupport && this._ws) {
             p = p.whitespace(this._ws);
         }
         return addPostfixSupport(p);
-    };
-    ParserBuilder.prototype.parser = function (p) {
+    }
+    parser(p) {
         return this.postProcessParser(p);
-    };
-    ParserBuilder.prototype.token = function (tok) {
+    }
+    token(tok) {
         return this.postProcessParser(new TokenParser_1.TokenParser(tok));
-    };
-    ParserBuilder.prototype.anyOf = function (alts, minLen, maxLen) {
-        if (minLen === void 0) { minLen = 1; }
-        if (maxLen === void 0) { maxLen = null; }
+    }
+    anyOf(alts, minLen = 1, maxLen = null) {
         return this.postProcessParser(new AnyOfParser_1.AnyOfParser(alts, minLen, maxLen));
-    };
-    ParserBuilder.prototype.regex = function (re) {
+    }
+    regex(re) {
         return this.postProcessParser(new RegexParser_1.RegexParser(re));
-    };
-    ParserBuilder.prototype.fail = function (message) {
-        if (message === void 0) { message = null; }
+    }
+    fail(message) {
         return this.postProcessParser(new core_1.FailParser(message));
-    };
-    ParserBuilder.prototype.pass = function () {
+    }
+    pass() {
         return this.postProcessParser(new core_1.PassParser());
-    };
-    ParserBuilder.prototype.cut = function () {
+    }
+    cut() {
         return this.postProcessParser(new core_1.CutParser());
-    };
-    ParserBuilder.prototype.ref = function (f) {
+    }
+    ref(f) {
         return this.postProcessParser(new core_1.RefParser(f));
-    };
-    ParserBuilder.prototype.attempt = function (p) {
+    }
+    attempt(p) {
         return this.postProcessParser(new AttemptParser_1.AttemptParser(p));
-    };
-    ParserBuilder.prototype.map = function (parser, mapper) {
+    }
+    map(parser, mapper) {
         return this.postProcessParser(new MapParser_1.MapParser(parser, mapper));
-    };
-    ParserBuilder.prototype.sequence = function () {
-        var s = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            s[_i] = arguments[_i];
-        }
+    }
+    sequence(...s) {
         return this.postProcessParser(new SequenceCombinator_1.SequenceCombinator(s));
-    };
-    ParserBuilder.prototype.choice = function () {
-        var parsers = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            parsers[_i] = arguments[_i];
-        }
+    }
+    choice(...parsers) {
         return new ChooseCombinator_1.ChooseCombinator(parsers);
-    };
-    ParserBuilder.prototype.many = function (parser, sep, min, max) {
-        if (sep === void 0) { sep = null; }
-        if (min === void 0) { min = 0; }
-        if (max === void 0) { max = 0; }
+    }
+    many(parser, sep, min = 0, max = 0) {
         return this.postProcessParser(new ManyCombinator_1.ManyCombinator(parser, sep, min, max));
-    };
-    ParserBuilder.prototype.optional = function (parser) {
+    }
+    optional(parser) {
         return this.postProcessParser(new OptionalCombinator_1.OptionalCombinator(parser));
-    };
-    return ParserBuilder;
-}());
+    }
+}
 exports.ParserBuilder = ParserBuilder;

package/dist/combinators/AstBuilder.js

@@ -1,29 +1,18 @@
 "use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AstBuilder = void 0;
-var core_1 = require("../core");
-var AstBuilder = /** @class */ (function () {
-    function AstBuilder(_parser, _ctor) {
+const core_1 = require("../core");
+class AstBuilder {
+    constructor(_parser, _ctor) {
         this._parser = _parser;
         this._ctor = _ctor;
     }
-    AstBuilder.prototype.parse = function (parserContext) {
-        var _a;
-        var s = this._parser.parse(parserContext);
+    parse(parserContext) {
+        const s = this._parser.parse(parserContext);
         if (!s.successful) {
             return s;
         }
-        return core_1.ParseResult.successful(new ((_a = this._ctor).bind.apply(_a, __spreadArray([void 0], s.result, false)))());
-    };
-    return AstBuilder;
-}());
+        return core_1.ParseResult.successful(new this._ctor(...s.result));
+    }
+}
 exports.AstBuilder = AstBuilder;

package/dist/combinators/AttemptParser.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AttemptParser = void 0;
-var AttemptParser = /** @class */ (function () {
-    function AttemptParser(_parser) {
+class AttemptParser {
+    constructor(_parser) {
         this._parser = _parser;
     }
-    AttemptParser.prototype.parse = function (parserContext) {
-        var s = this._parser.parse(parserContext);
+    parse(parserContext) {
+        const s = this._parser.parse(parserContext);
         parserContext.cutEncountered = false;
         return s;
-    };
-    return AttemptParser;
-}());
+    }
+}
 exports.AttemptParser = AttemptParser;

package/dist/combinators/ChooseCombinator.d.ts

@@ -1,5 +1,5 @@
 import { Parser, ParserContext, ParseResult, ParserType } from "../core";
-declare type ChooseResult<E> = E extends [infer Head, ...infer Tails] ? ParserType<Head> | ChooseResult<Tails> : never;
+type ChooseResult<E> = E extends [infer Head, ...infer Tails] ? ParserType<Head> | ChooseResult<Tails> : never;
 export declare class ChooseCombinator<E extends Parser<any>[]> implements Parser<ChooseResult<E>> {
     private _parsers;
     constructor(_parsers: E);

package/dist/combinators/ChooseCombinator.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChooseCombinator = void 0;
-var core_1 = require("../core");
-var ChooseCombinator = /** @class */ (function () {
-    function ChooseCombinator(_parsers) {
+const core_1 = require("../core");
+class ChooseCombinator {
+    constructor(_parsers) {
         this._parsers = _parsers;
     }
-    ChooseCombinator.prototype.parse = function (parserContext) {
-        var input = parserContext.input;
-        var bm = input.getBookmark();
-        for (var i = 0; i < this._parsers.length; i++) {
-            var combOpt = this._parsers[i].parse(parserContext);
+    parse(parserContext) {
+        const input = parserContext.input;
+        const bm = input.getBookmark();
+        for (let i = 0; i < this._parsers.length; i++) {
+            const combOpt = this._parsers[i].parse(parserContext);
             if (combOpt.successful || parserContext.cutEncountered) {
                 return combOpt;
             }
@@ -19,7 +19,6 @@ var ChooseCombinator = /** @class */ (function () {
             }
         }
         return core_1.ParseResult.failed(core_1.ParseError.parserRejected(this, parserContext));
-    };
-    return ChooseCombinator;
-}());
+    }
+}
 exports.ChooseCombinator = ChooseCombinator;

package/dist/combinators/ManyCombinator.d.ts

@@ -1,9 +1,9 @@
 import { Parser, ParserContext, ParseResult, ParserWithInternalWhitespaceSupport } from "../core";
 export declare class ManyCombinator<T> extends ParserWithInternalWhitespaceSupport<T[]> {
     private _parser;
-    private _sepParser;
+    private _sepParser?;
     private _min;
     private _max;
-    constructor(_parser: Parser<T>, _sepParser?: Parser<unknown>, _min?: number, _max?: number);
+    constructor(_parser: Parser<T>, _sepParser?: Parser<unknown> | undefined, _min?: number, _max?: number);
     parse(parserContext: ParserContext): ParseResult<T[]>;
 }

package/dist/combinators/ManyCombinator.js

@@ -1,45 +1,25 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ManyCombinator = void 0;
-var core_1 = require("../core");
-var ManyCombinator = /** @class */ (function (_super) {
-    __extends(ManyCombinator, _super);
-    function ManyCombinator(_parser, _sepParser, _min, _max) {
-        if (_sepParser === void 0) { _sepParser = null; }
-        if (_min === void 0) { _min = 0; }
-        if (_max === void 0) { _max = 0; }
-        var _this = _super.call(this) || this;
-        _this._parser = _parser;
-        _this._sepParser = _sepParser;
-        _this._min = _min;
-        _this._max = _max;
-        return _this;
+const core_1 = require("../core");
+class ManyCombinator extends core_1.ParserWithInternalWhitespaceSupport {
+    constructor(_parser, _sepParser, _min = 0, _max = 0) {
+        super();
+        this._parser = _parser;
+        this._sepParser = _sepParser;
+        this._min = _min;
+        this._max = _max;
     }
-    ManyCombinator.prototype.parse = function (parserContext) {
-        var output = [];
-        var pce = parserContext.cutEncountered;
-        var mustParseElement = false;
+    parse(parserContext) {
+        const output = [];
+        const pce = parserContext.cutEncountered;
+        let mustParseElement = false;
         try {
             do {
                 // Parse element
-                var bm = parserContext.input.getBookmark();
+                let bm = parserContext.input.getBookmark();
                 parserContext.cutEncountered = false;
-                var psr = this._parser.parse(parserContext);
+                const psr = this._parser.parse(parserContext);
                 if (psr.successful) {
                     output.push(psr.result);
                 }
@@ -55,7 +35,7 @@ var ManyCombinator = /** @class */ (function (_super) {
                 mustParseElement = false;
                 // Parse WS
                 parserContext.cutEncountered = false;
-                var wpr = this.parseWhitespace(parserContext);
+                let wpr = this.parseWhitespace(parserContext);
                 if (!wpr.successful) {
                     return wpr;
                 }
@@ -63,7 +43,7 @@ var ManyCombinator = /** @class */ (function (_super) {
                 if (this._sepParser) {
                     parserContext.cutEncountered = false;
                     bm = parserContext.input.getBookmark();
-                    var sepr = this._sepParser.parse(parserContext);
+                    const sepr = this._sepParser.parse(parserContext);
                     if (sepr.successful) {
                         mustParseElement = true;
                         // Parse WS post separator
@@ -84,9 +64,9 @@ var ManyCombinator = /** @class */ (function (_super) {
                     }
                 }
             } while (true);
-            if ((output.length < this._min) ||
-                ((this._max > 0) && output.length > this._max)) {
-                return core_1.ParseResult.failed(core_1.ParseError.parserRejected(this, parserContext, "Expected occurences in range {" + this._min + ", " + this._max + "}; found " + output.length));
+            if (output.length < this._min ||
+                (this._max > 0 && output.length > this._max)) {
+                return core_1.ParseResult.failed(core_1.ParseError.parserRejected(this, parserContext, `Expected occurences in range {${this._min}, ${this._max}}; found ${output.length}`));
             }
             else {
                 return core_1.ParseResult.successful(output);
@@ -95,7 +75,6 @@ var ManyCombinator = /** @class */ (function (_super) {
         finally {
             parserContext.cutEncountered = pce;
         }
-    };
-    return ManyCombinator;
-}(core_1.ParserWithInternalWhitespaceSupport));
+    }
+}
 exports.ManyCombinator = ManyCombinator;

package/dist/combinators/MapParser.js

@@ -1,19 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MapParser = void 0;
-var core_1 = require("../core");
-var MapParser = /** @class */ (function () {
-    function MapParser(_parser, _fn) {
+const core_1 = require("../core");
+class MapParser {
+    constructor(_parser, _fn) {
         this._parser = _parser;
         this._fn = _fn;
     }
-    MapParser.prototype.parse = function (parserContext) {
-        var s = this._parser.parse(parserContext);
+    parse(parserContext) {
+        const s = this._parser.parse(parserContext);
         if (!s.successful) {
             return s;
         }
         return core_1.ParseResult.successful(this._fn(s.result));
-    };
-    return MapParser;
-}());
+    }
+}
 exports.MapParser = MapParser;

package/dist/combinators/OptionalCombinator.js

@@ -1,24 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OptionalCombinator = void 0;
-var core_1 = require("../core");
-var OptionalCombinator = /** @class */ (function () {
-    function OptionalCombinator(_parser) {
+const core_1 = require("../core");
+class OptionalCombinator {
+    constructor(_parser) {
         this._parser = _parser;
     }
-    OptionalCombinator.prototype.parse = function (parserContext) {
-        var input = parserContext.input;
-        var bm = input.getBookmark();
-        var pce = parserContext.cutEncountered;
+    parse(parserContext) {
+        const input = parserContext.input;
+        const bm = input.getBookmark();
+        const pce = parserContext.cutEncountered;
         parserContext.cutEncountered = false;
-        var ret = this._parser.parse(parserContext);
+        let ret = this._parser.parse(parserContext);
         if (!ret.successful && !parserContext.cutEncountered) {
             input.seekToBookmark(bm);
             ret = core_1.ParseResult.successful(null);
         }
         parserContext.cutEncountered = pce;
         return ret;
-    };
-    return OptionalCombinator;
-}());
+    }
+}
 exports.OptionalCombinator = OptionalCombinator;

package/dist/combinators/ParserWithIndices.d.ts

@@ -1,5 +1,5 @@
 import { Parser, ParserContext, ParseResult } from "../core";
-declare type ResultWithIndices<T> = {
+type ResultWithIndices<T> = {
     result: T;
     start: number;
     length: number;

package/dist/combinators/ParserWithIndices.js

@@ -1,20 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParserWithIndices = void 0;
-var core_1 = require("../core");
-var ParserWithIndices = /** @class */ (function () {
-    function ParserWithIndices(_underlying) {
+const core_1 = require("../core");
+class ParserWithIndices {
+    constructor(_underlying) {
         this._underlying = _underlying;
     }
-    ParserWithIndices.prototype.parse = function (parserContext) {
-        var startOfs = parserContext.input.tell();
-        var ret = this._underlying.parse(parserContext);
-        var endOfs = parserContext.input.tell();
+    parse(parserContext) {
+        const startOfs = parserContext.input.tell();
+        const ret = this._underlying.parse(parserContext);
+        const endOfs = parserContext.input.tell();
         if (!ret.successful) {
             return ret;
         }
         return core_1.ParseResult.successful({ result: ret.result, start: startOfs, length: endOfs - startOfs });
-    };
-    return ParserWithIndices;
-}());
+    }
+}
 exports.ParserWithIndices = ParserWithIndices;

package/dist/combinators/SequenceCombinator.d.ts

@@ -1,6 +1,6 @@
 import { Parser, ParserContext, ParseResult, ParserType, ParserWithInternalWhitespaceSupport } from "../core";
-export declare type FilterVoid<T> = T extends [infer Head, ...infer Rest] ? (Head extends void ? [...FilterVoid<Rest>] : [Head, ...FilterVoid<Rest>]) : T;
-export declare type SeqType<TS extends Parser<unknown>[]> = FilterVoid<{
+export type FilterVoid<T> = T extends [infer Head, ...infer Rest] ? (Head extends void ? [...FilterVoid<Rest>] : [Head, ...FilterVoid<Rest>]) : T;
+export type SeqType<TS extends Parser<unknown>[]> = FilterVoid<{
     [i in keyof TS]: ParserType<TS[i]>;
 }>;
 export declare class SequenceCombinator<TS extends Parser<unknown>[]> extends ParserWithInternalWhitespaceSupport<SeqType<TS>> {

package/dist/combinators/SequenceCombinator.js

@@ -1,39 +1,22 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SequenceCombinator = void 0;
-var core_1 = require("../core");
-var SequenceCombinator = /** @class */ (function (_super) {
-    __extends(SequenceCombinator, _super);
-    function SequenceCombinator(_parsers) {
-        var _this = _super.call(this) || this;
-        _this._parsers = _parsers;
-        return _this;
+const core_1 = require("../core");
+class SequenceCombinator extends core_1.ParserWithInternalWhitespaceSupport {
+    constructor(_parsers) {
+        super();
+        this._parsers = _parsers;
     }
-    SequenceCombinator.prototype.parse = function (parserContext) {
-        var results = [];
-        for (var i = 0; i < this._parsers.length; i++) {
+    parse(parserContext) {
+        const results = [];
+        for (let i = 0; i < this._parsers.length; i++) {
             if (i) {
-                var wsr = this.parseWhitespace(parserContext);
+                const wsr = this.parseWhitespace(parserContext);
                 if (!wsr.successful) {
                     return wsr;
                 }
             }
-            var psr = this._parsers[i].parse(parserContext);
+            const psr = this._parsers[i].parse(parserContext);
             if (psr.successful) {
                 if (psr.result !== undefined) {
                     results.push(psr.result);
@@ -44,7 +27,6 @@ var SequenceCombinator = /** @class */ (function (_super) {
             }
         }
         return core_1.ParseResult.successful(results);
-    };
-    return SequenceCombinator;
-}(core_1.ParserWithInternalWhitespaceSupport));
+    }
+}
 exports.SequenceCombinator = SequenceCombinator;

package/dist/core.d.ts

@@ -6,7 +6,7 @@ export interface ParserInput {
     readRegex?(regex: RegExp): string | null;
     peekRegex?(regex: RegExp): string | null;
     getBookmark(): ParserInputBookmark;
-    seekToBookmark(bm: ParserInputBookmark): any;
+    seekToBookmark(bm: ParserInputBookmark): void;
     eof(): boolean;
     tell(): number;
 }
@@ -33,7 +33,7 @@ export declare class ParserContext {
     get input(): ParserInput;
     cutEncountered: boolean;
 }
-export declare type ParseResult<T> = {
+export type ParseResult<T> = {
     successful: true;
     failed: false;
     result: T;
@@ -54,8 +54,8 @@ export interface Parser<T> {
 export declare function isParser(p: any): p is Parser<unknown>;
 export declare class FailParser implements Parser<unknown> {
     private _message;
-    constructor(_message?: string);
-    parse(parserContext: ParserContext): any;
+    constructor(_message: string);
+    parse(parserContext: ParserContext): ParseResult<unknown>;
 }
 export declare class PassParser implements Parser<void> {
     parse(parserContext: ParserContext): ParseResult<void>;
@@ -67,9 +67,9 @@ export declare class RefParser<T> implements Parser<T> {
     private _parserProvider;
     constructor(_parserProvider: () => Parser<T>);
     parse(parserContext: ParserContext): ParseResult<T>;
-    private _parser;
+    private _parser?;
 }
-export declare type ParserType<pt> = pt extends Parser<infer T> ? T : never;
+export type ParserType<pt> = pt extends Parser<infer T> ? T : never;
 export declare class ParserWithInternalWhitespaceSupport<T> implements Parser<T> {
     parse(parserContext: ParserContext): ParseResult<T>;
     whitespace(whitespaceParser: Parser<unknown> | null): ParserWithInternalWhitespaceSupport<T>;

package/dist/core.js

@@ -1,32 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParseError = exports.parse = exports.ParserWithInternalWhitespaceSupport = exports.RefParser = exports.CutParser = exports.PassParser = exports.FailParser = exports.isParser = exports.ParseResult = exports.ParserContext = exports.StringParserInput = void 0;
-var StringParserInput = /** @class */ (function () {
-    function StringParserInput(_text) {
+exports.ParseError = exports.ParserWithInternalWhitespaceSupport = exports.RefParser = exports.CutParser = exports.PassParser = exports.FailParser = exports.ParseResult = exports.ParserContext = exports.StringParserInput = void 0;
+exports.isParser = isParser;
+exports.parse = parse;
+class StringParserInput {
+    constructor(_text) {
         this._text = _text;
         this._index = 0;
     }
-    StringParserInput.prototype.read = function (readLen) {
+    read(readLen) {
         if (this._index + readLen > this._text.length) {
             this._index = this._text.length;
-            throw new ParseError(this, this.getBookmark(), null, "Attempt to read beyond EOF");
+            throw new ParseError(this, this.getBookmark(), null, `Attempt to read beyond EOF`);
         }
-        var ret = this._text.substr(this._index, readLen);
+        const ret = this._text.substr(this._index, readLen);
         this._index += readLen;
         return ret;
-    };
-    StringParserInput.prototype.peek = function (readLen) {
+    }
+    peek(readLen) {
         return this._text.substr(this._index, readLen);
-    };
-    StringParserInput.prototype.readRegex = function (regex) {
-        var ret = this.peekRegex(regex);
+    }
+    readRegex(regex) {
+        const ret = this.peekRegex(regex);
         if (ret) {
             this._index += ret.length;
         }
         return ret;
-    };
-    StringParserInput.prototype.peekRegex = function (regex) {
-        var matchResult = regex.exec(this._text.substring(this._index));
+    }
+    peekRegex(regex) {
+        let matchResult = regex.exec(this._text.substring(this._index));
         if (!matchResult) {
             return null;
         }
@@ -34,49 +36,42 @@ var StringParserInput = /** @class */ (function () {
             return null;
         }
         return matchResult[0];
-    };
-    StringParserInput.prototype.getBookmark = function () {
+    }
+    getBookmark() {
         return this._index;
-    };
-    StringParserInput.prototype.seekToBookmark = function (bm) {
+    }
+    seekToBookmark(bm) {
         this._index = bm;
-    };
-    StringParserInput.prototype.eof = function () {
+    }
+    eof() {
         return this._index >= this._text.length;
-    };
-    StringParserInput.prototype.remainder = function () {
+    }
+    remainder() {
         return this._text.substr(this._index);
-    };
-    StringParserInput.prototype.skip = function (howMuch) {
+    }
+    skip(howMuch) {
         this._index += howMuch;
-    };
-    StringParserInput.prototype.tell = function () {
+    }
+    tell() {
         return this._index;
-    };
-    return StringParserInput;
-}());
+    }
+}
 exports.StringParserInput = StringParserInput;
-var ParserContext = /** @class */ (function () {
-    function ParserContext(_input, _whitespaceParser) {
-        if (_whitespaceParser === void 0) { _whitespaceParser = null; }
+class ParserContext {
+    constructor(_input, _whitespaceParser = null) {
         this._input = _input;
         this._whitespaceParser = _whitespaceParser;
         this.cutEncountered = false;
     }
-    ParserContext.prototype.parseWhitespace = function () {
+    parseWhitespace() {
         if (this._whitespaceParser) {
             this._whitespaceParser.parse(this);
         }
-    };
-    Object.defineProperty(ParserContext.prototype, "input", {
-        get: function () {
-            return this._input;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return ParserContext;
-}());
+    }
+    get input() {
+        return this._input;
+    }
+}
 exports.ParserContext = ParserContext;
 var ParseResult;
 (function (ParseResult) {
@@ -85,7 +80,7 @@ var ParseResult;
     }
     ParseResult.successful = successful;
     function voidSuccessful() {
-        return { successful: true, failed: false, result: undefined };
+        return { successful: true, failed: false, result: void 0 };
     }
     ParseResult.voidSuccessful = voidSuccessful;
     function failed(r) {
@@ -96,108 +91,93 @@ var ParseResult;
         if (p.successful) {
             return p.result;
         }
-        else if (p.failed) {
+        else {
             throw p.parseError;
         }
     }
     ParseResult.resultOrThrow = resultOrThrow;
-})(ParseResult = exports.ParseResult || (exports.ParseResult = {}));
-;
+})(ParseResult || (exports.ParseResult = ParseResult = {}));
 function isParser(p) {
-    return 'parse' in p;
+    return "parse" in p;
 }
-exports.isParser = isParser;
-var FailParser = /** @class */ (function () {
-    function FailParser(_message) {
-        if (_message === void 0) { _message = null; }
+class FailParser {
+    constructor(_message) {
         this._message = _message;
     }
-    FailParser.prototype.parse = function (parserContext) {
+    parse(parserContext) {
         return ParseResult.failed(ParseError.parserRejected(this, parserContext, this._message));
-    };
-    return FailParser;
-}());
-exports.FailParser = FailParser;
-var PassParser = /** @class */ (function () {
-    function PassParser() {
     }
-    PassParser.prototype.parse = function (parserContext) {
+}
+exports.FailParser = FailParser;
+class PassParser {
+    parse(parserContext) {
         return ParseResult.voidSuccessful();
-    };
-    return PassParser;
-}());
-exports.PassParser = PassParser;
-var CutParser = /** @class */ (function () {
-    function CutParser() {
     }
-    CutParser.prototype.parse = function (parserContext) {
+}
+exports.PassParser = PassParser;
+class CutParser {
+    parse(parserContext) {
         parserContext.cutEncountered = true;
         return ParseResult.voidSuccessful();
-    };
-    return CutParser;
-}());
+    }
+}
 exports.CutParser = CutParser;
-var RefParser = /** @class */ (function () {
-    function RefParser(_parserProvider) {
+class RefParser {
+    constructor(_parserProvider) {
         this._parserProvider = _parserProvider;
     }
-    RefParser.prototype.parse = function (parserContext) {
+    parse(parserContext) {
         if (!this._parser) {
             this._parser = this._parserProvider();
         }
         return this._parser.parse(parserContext);
-    };
-    return RefParser;
-}());
+    }
+}
 exports.RefParser = RefParser;
-var ParserWithInternalWhitespaceSupport = /** @class */ (function () {
-    function ParserWithInternalWhitespaceSupport() {
+class ParserWithInternalWhitespaceSupport {
+    constructor() {
         this._whitespace = null;
     }
-    ParserWithInternalWhitespaceSupport.prototype.parse = function (parserContext) {
-        throw new Error('Method not implemented');
-    };
-    ParserWithInternalWhitespaceSupport.prototype.whitespace = function (whitespaceParser) {
+    parse(parserContext) {
+        throw new Error("Method not implemented");
+    }
+    whitespace(whitespaceParser) {
         this._whitespace = whitespaceParser;
         return this;
-    };
-    ParserWithInternalWhitespaceSupport.prototype.parseWhitespace = function (parserContext) {
+    }
+    parseWhitespace(parserContext) {
         if (this._whitespace) {
             return this._whitespace.parse(parserContext);
         }
         else {
             return ParseResult.voidSuccessful();
         }
-    };
-    return ParserWithInternalWhitespaceSupport;
-}());
+    }
+}
 exports.ParserWithInternalWhitespaceSupport = ParserWithInternalWhitespaceSupport;
-function parse(parser, input, allowPartial) {
-    if (allowPartial === void 0) { allowPartial = false; }
-    if (typeof (input) === 'string') {
+function parse(parser, input, allowPartial = false) {
+    if (typeof input === "string") {
         input = new StringParserInput(input);
     }
-    var context = new ParserContext(input);
-    var ret = parser.parse(context);
+    let context = new ParserContext(input);
+    const ret = parser.parse(context);
     if (!allowPartial && !input.eof()) {
-        throw new ParseError(input, input.getBookmark(), null, "End of input expected");
+        throw new ParseError(input, input.getBookmark(), null, `End of input expected`);
     }
     return ParseResult.resultOrThrow(ret);
 }
-exports.parse = parse;
-var ParseError = /** @class */ (function () {
-    function ParseError(input, bookmark, parser, contentMessage) {
+class ParseError {
+    constructor(input, bookmark, parser, contentMessage) {
         this.message = contentMessage;
         if (bookmark) {
-            this.message = this.message + " at " + bookmark + " ('" + input.peek(5) + "')";
+            this.message = `${this.message} at ${bookmark} ('${input.peek(5)}')`;
         }
     }
-    ParseError.prototype.toString = function () {
-        return "Error: " + this.message;
-    };
-    ParseError.parserRejected = function (parser, context, message) {
-        return new ParseError(context.input, context.input.getBookmark(), parser, message || "Parser rejected input");
-    };
-    return ParseError;
-}());
+    toString() {
+        return `Error: ${this.message}`;
+    }
+    static parserRejected(parser, context, message) {
+        return new ParseError(context.input, context.input.getBookmark(), parser, message || `Parser rejected input`);
+    }
+}
 exports.ParseError = ParseError;

package/dist/operators.js

@@ -1,46 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParserOperators = void 0;
-var AstBuilder_1 = require("./combinators/AstBuilder");
-var MapParser_1 = require("./combinators/MapParser");
-var OptionalCombinator_1 = require("./combinators/OptionalCombinator");
-var ParserWithIndices_1 = require("./combinators/ParserWithIndices");
+const AstBuilder_1 = require("./combinators/AstBuilder");
+const MapParser_1 = require("./combinators/MapParser");
+const OptionalCombinator_1 = require("./combinators/OptionalCombinator");
+const ParserWithIndices_1 = require("./combinators/ParserWithIndices");
 var ParserOperators;
 (function (ParserOperators) {
     function map(mapper) {
-        return function (p) {
+        return (p) => {
             return new MapParser_1.MapParser(p, mapper);
         };
     }
     ParserOperators.map = map;
     function optional() {
-        return function (p) {
+        return (p) => {
             return new OptionalCombinator_1.OptionalCombinator(p);
         };
     }
     ParserOperators.optional = optional;
     function build(ctor) {
-        return function (p) {
+        return (p) => {
             return new AstBuilder_1.AstBuilder(p, ctor);
         };
     }
     ParserOperators.build = build;
     function omit() {
-        return function (p) {
-            return new MapParser_1.MapParser(p, function (a) { });
+        return (p) => {
+            return new MapParser_1.MapParser(p, (a) => { });
         };
     }
     ParserOperators.omit = omit;
     function whitespace(ws) {
-        return function (p) {
+        return (p) => {
             return p.whitespace(ws);
         };
     }
     ParserOperators.whitespace = whitespace;
     function withIndices() {
-        return function (p) {
+        return (p) => {
             return new ParserWithIndices_1.ParserWithIndices(p);
         };
     }
     ParserOperators.withIndices = withIndices;
-})(ParserOperators = exports.ParserOperators || (exports.ParserOperators = {}));
+})(ParserOperators || (exports.ParserOperators = ParserOperators = {}));

package/dist/parsers/AnyOfParser.js

@@ -1,20 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnyOfParser = void 0;
-var core_1 = require("../core");
-var AnyOfParser = /** @class */ (function () {
-    function AnyOfParser(_characters, _minLen, _maxLen) {
-        if (_minLen === void 0) { _minLen = 1; }
-        if (_maxLen === void 0) { _maxLen = null; }
+const core_1 = require("../core");
+class AnyOfParser {
+    constructor(_characters, _minLen = 1, _maxLen = null) {
         this._characters = _characters;
         this._minLen = _minLen;
         this._maxLen = _maxLen;
-        var charBitmap = [];
+        const charBitmap = [];
         this._charBitmap = charBitmap;
-        for (var i = 0; i < _characters.length; i++) {
-            var ccode = _characters.charCodeAt(i);
+        for (let i = 0; i < _characters.length; i++) {
+            const ccode = _characters.charCodeAt(i);
             if (ccode < 256) {
-                charBitmap[ccode >> 3] = (charBitmap[ccode >> 3] || 0) | (1 << (ccode & 7));
+                charBitmap[ccode >> 3] =
+                    (charBitmap[ccode >> 3] || 0) | (1 << (ccode & 7));
             }
             else {
                 this._charBitmap = null;
@@ -22,14 +21,14 @@ var AnyOfParser = /** @class */ (function () {
             }
         }
     }
-    AnyOfParser.prototype.parse = function (parserContext) {
-        var ret = [];
-        var cont = true;
-        var input = parserContext.input;
+    parse(parserContext) {
+        let ret = [];
+        let cont = true;
+        const input = parserContext.input;
         while (cont && !input.eof()) {
-            var str = input.peek(1);
+            const str = input.peek(1);
             if (this._charBitmap) {
-                var ccode = str.charCodeAt(0);
+                const ccode = str.charCodeAt(0);
                 cont = (this._charBitmap[ccode >> 3] & (1 << (ccode & 7))) != 0;
             }
             else {
@@ -42,10 +41,9 @@ var AnyOfParser = /** @class */ (function () {
         }
         if ((this._maxLen != null && ret.length > this._maxLen) ||
             (this._minLen != null && ret.length < this._minLen)) {
-            return core_1.ParseResult.failed(core_1.ParseError.parserRejected(this, parserContext, "Expecting AnyOf " + this._characters));
+            return core_1.ParseResult.failed(core_1.ParseError.parserRejected(this, parserContext, `Expecting AnyOf ${this._characters}`));
         }
-        return core_1.ParseResult.successful(ret.join(''));
-    };
-    return AnyOfParser;
-}());
+        return core_1.ParseResult.successful(ret.join(""));
+    }
+}
 exports.AnyOfParser = AnyOfParser;

package/dist/parsers/RegexParser.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegexParser = void 0;
-var core_1 = require("../core");
-var RegexParser = /** @class */ (function () {
-    function RegexParser(_regex) {
+const core_1 = require("../core");
+class RegexParser {
+    constructor(_regex) {
         this._regex = _regex;
+        this._charBitmap = null;
     }
-    RegexParser.prototype.parse = function (parserContext) {
+    parse(parserContext) {
         if (!parserContext.input.readRegex) {
             throw core_1.ParseError.parserRejected(this, parserContext, "Input doesn't support regex parsing");
         }
-        var reResult = parserContext.input.readRegex(this._regex);
+        const reResult = parserContext.input.readRegex(this._regex);
         if (!reResult) {
-            return core_1.ParseResult.failed(core_1.ParseError.parserRejected(this, parserContext, "Expected " + this._regex.source));
+            return core_1.ParseResult.failed(core_1.ParseError.parserRejected(this, parserContext, `Expected ${this._regex.source}`));
         }
         return core_1.ParseResult.successful(reResult);
-    };
-    return RegexParser;
-}());
+    }
+}
 exports.RegexParser = RegexParser;

package/dist/parsers/TokenParser.js

@@ -1,23 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenParser = void 0;
-var core_1 = require("../core");
-var TokenParser = /** @class */ (function () {
-    function TokenParser(_token) {
+const core_1 = require("../core");
+class TokenParser {
+    constructor(_token) {
         this._token = _token;
     }
-    TokenParser.prototype.parse = function (parserContext) {
+    parse(parserContext) {
         try {
-            var str = parserContext.input.read(this._token.length);
+            const str = parserContext.input.read(this._token.length);
             if (str !== this._token) {
-                return core_1.ParseResult.failed(core_1.ParseError.parserRejected(this, parserContext, "Expected token " + this._token));
+                return core_1.ParseResult.failed(core_1.ParseError.parserRejected(this, parserContext, `Expected token ${this._token}`));
             }
             return core_1.ParseResult.successful(str);
         }
         catch (e) {
-            return core_1.ParseResult.failed(e);
+            if (e instanceof core_1.ParseError) {
+                return core_1.ParseResult.failed(e);
+            }
+            throw e;
         }
-    };
-    return TokenParser;
-}());
+    }
+}
 exports.TokenParser = TokenParser;

package/dist/parsers/WhitespaceParser.d.ts

@@ -1,6 +1,6 @@
-import { Parser, ParserContext } from "../core";
+import { Parser, ParserContext, ParseResult } from "../core";
 export declare class WhitespaceParser implements Parser<void> {
     private _mandatory;
     constructor(_mandatory: boolean);
-    parse(parserContext: ParserContext): any;
+    parse(parserContext: ParserContext): ParseResult<void>;
 }

package/dist/parsers/WhitespaceParser.js

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WhitespaceParser = void 0;
-var core_1 = require("../core");
-var WhitespaceParser = /** @class */ (function () {
-    function WhitespaceParser(_mandatory) {
+const core_1 = require("../core");
+class WhitespaceParser {
+    constructor(_mandatory) {
         this._mandatory = _mandatory;
     }
-    WhitespaceParser.prototype.parse = function (parserContext) {
-        var input = parserContext.input;
-        var c;
-        var found = false;
-        while (!input.eof() && (c = input.peek(1), c == ' ' || c == '\t' || c == '\n')) {
+    parse(parserContext) {
+        const input = parserContext.input;
+        let c;
+        let found = false;
+        while (!input.eof() &&
+            ((c = input.peek(1)), c == " " || c == "\t" || c == "\n")) {
             input.read(1);
             found = true;
         }
@@ -20,7 +21,6 @@ var WhitespaceParser = /** @class */ (function () {
         else {
             return core_1.ParseResult.voidSuccessful();
         }
-    };
-    return WhitespaceParser;
-}());
+    }
+}
 exports.WhitespaceParser = WhitespaceParser;

package/dist/parzing.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];

package/package.json

@@ -1,11 +1,14 @@
-{  
+{
   "name": "@zigsterz/parzing",
-  "version": "1.1.0",  
+  "version": "1.2.0",
   "description": "Parser combinators library",
+  "keywords": [
+    "parser",
+    "grammar"
+  ],
   "scripts": {
     "test": "ts-mocha test/**.ts",
     "build": "tsc && npm pack"
-
   },
   "main": "dist/parzing.js",
   "types": "dist/parzing.d.ts",
@@ -14,18 +17,15 @@
   ],
   "author": "Eldan Ben-Haim",
   "license": "MIT",
-  "repository": {    
+  "repository": {
     "url": "https://github.com/eldanb/parzing"
   },
   "devDependencies": {
     "@types/mocha": "^9.0.0",
     "@types/node": "^16.10.3",
-    "mocha": "^9.1.2",
-    "ts-mocha": "^8.0.0",
-    "typescript": "^4.4.3",
-    "assert": "^2.0.0"
-  },
-  "dependencies": {
-    
+    "assert": "^2.0.0",
+    "mocha": "^11.7.6",
+    "ts-mocha": "^11.1.0",
+    "typescript": "^6.0.3"
   }
 }