@zigsterz/parzing 1.0.0 → 1.2.0

package/README.md

@@ -1,7 +1,9 @@
 # Parzing: TypesSript Parser Combinator Library
 
 ## Overview
-This package implements a parser combinator system, allowing client code to easily create parsers in JavaScript or TypeScript. When used with TypeScript accurate types are computed for parsed and intermediate results, allowing quick and safe implementation and utilization of parsers.
+This package is Parzing: a parser combinator library, allowing client code to easily create parsers in JavaScript or TypeScript. When used with TypeScript accurate types are computed for parsed and intermediate results, allowing easy and safe implementation and use of parsers.
+
+This page provides instructions on how to use and customize Parzing. For more insights about the library, [see this blog](https://www.imonlydoingthis.benhaim.net/home/categories/parzing).
 
 ## Installation
 
@@ -13,7 +15,7 @@ npm install --save @zigsterz/parzing
 
 Parzing exposes a `parse` function for invoking a parser on content. To use it, we first construct a parser, and then pass the parser along with the content to parse.  `parse` will either return a the result of succesfuly parsing the content, or throw an error describing a failure to parse.
 
-The `ParserBuilder` class exposes a set of helper factory functions for constructing parser.
+The parser passed to `parse` is usually built using the `ParserBuilder` class. This class exposes a set of helper factory functions for constructing parsers.
 
 The example below demonstrates how to parse a sequence of 1 to 3 digits by first constructing a `ParserBuilder`, then using it to create an `AnyOfParser` parser and finally running the parser using `parse`.
 
@@ -29,11 +31,11 @@ assert(result == "123");
 
 ### Parsing Results
 The result of parsing content may be a value of any type. A Parzing parser has an associated result type that describes the type of the parsing result returned by that parser.
-
+The return type from `parse` will match the result type of the parser passed to it.
 
 ### Basic Parsers
 
-`pb.anyOf` creates the Any Of *basic parser*. Basic parsers are the atomic building blocks for parsing. They may be combined using [*parser combinators*](#parser-combinators) to construct more complex parsers. 
+In the example above, `pb.anyOf` creates the Any Of *basic parser*. Basic parsers are the atomic building blocks for parsing. They may be combined using [*parser combinators*](#parser-combinators) to construct more complex parsers. 
 
 Parzing offers the following basic parsers out of the box:
 
@@ -41,17 +43,18 @@ Parzing offers the following basic parsers out of the box:
 | ------------------ | ----------- | ----------- | 
 | `ParserBuilder.anyOf(chars, min, max)` | Parses a minimum of *min* characters, and up to *max* characters, all out the characters listed in *chars*. | `string` |
 | `ParserBuilder.token(token)` | Parses the exact string specified by *token*. | `string` |
+| `ParserBuilder.regex(regex)` | Parses the regular expression specified by *regex*. | `string` |
 | `ParserBuilder.pass()` | This is a no-op parser. It consumes no input and always succeeds. | `void` |
 | `ParserBuilder.fail(message)` | Fail parsing with the error message provided in *message*. | `void` |
 
-In addition to these parsers, you can create [custom parsers](#custom-parsers) to parse arbitrary complex "atoms". Customer parsers may provide any result type.
+In addition to these parsers, you can create [custom parsers](#custom-parsers) to parse arbitrary complex "atoms". Custom parsers may provide any result type.
 
 ## Creating Complex Parsers
 
 ### Parser Combinators
-*Parser Combinators* are parsers that are constructed based on other parsers, and combine these parsers in some form to generate a more complex parser. 
+*Parser Combinators* are parsers constructed based on other parsers that combine these parsers in some form to generate a more complex parser. 
 
-Perhaps the simplest example of a paser combinator is the Sequence combinator. 
+Perhaps the simplest example of a parser combinator is the Sequence combinator. 
 The sequence combinator is constructed based on a sequence of underlying parsers, using the `ParserBuilder.sequence(...)` factory method.
 When parsing input content, the combinator will invoke each of the underlying parsers to parse consecutive fragments of the content. 
 If any underlying parser fails, the sequence parser fails as well. 
@@ -76,7 +79,7 @@ const result = parse(sample_parser, "1-2-3", true);
 assert.deepEqual(result, ["1", "-", "2", "-", "3"]);
 ```
 
-In addition to the `sequence` parser combinator, the following parser combinators offered by Parzing out-of-the box:
+In addition to the `sequence` parser combinator, the following parser combinators are offered by Parzing out-of-the box:
 
 | Parser constructor | Description | Result type |
 | ------------------ | ----------- | ----------- | 
@@ -91,13 +94,13 @@ In addition to the `sequence` parser combinator, the following parser combinator
 
 ### Whitespace Support
 
-Parsers that derive from `ParserWithInternalWhitespaceSupport` support ignoring whitespace within the content. Exactly where whitespace is ignored depends on the specific parser (see table below). 
+Parsers that derive from `ParserWithInternalWhitespaceSupport` support ignoring whitespace within parsed content. Exactly where whitespace is ignored depends on the specific parser as per the table below. 
 
 For all of these parsers, the ignored "whitespace" is defined as content that can be parsed by the *whitespace parser*. The whitespace parser can be set by invoking `target_parser.whitespace(whitespace_parser)`. 
-If this method is not invoked on the parser, and the parser was created using `ParserBuilder`, then the whitespace parser is set as the default whitespace parser for the builder. The default whitespace parser for a `ParserBuilder` can be set by passing it on construction.
-
 If there's no set whitespace parser on a `ParserWithInternalWhitespaceSupport`, no whitespace will be ignored.
 
+If the `whitespace` method is not invoked on a parser, and the parser was created using `ParserBuilder`, then the whitespace parser is set as the default whitespace parser for the builder. The default whitespace parser for a `ParserBuilder` can be set by passing it on construction.
+
 The `WhitespaceParser` class implements a parser that accepts common whitespace patterns. 
 
 The following code example illustrates a few ways to set whitespace parsers:
@@ -167,9 +170,10 @@ This parser will fail, but the failure will be reported by the `choice` combinat
 ParseError { message: 'Parser rejected input' }
 ```
 
-Clearly, for the input `number a123` a more approach would be to not even try the second alternative in the `choice` combinator above, and immediately bail out if we've encountered the `number` token. 
-This kind of behavior can be achieved using cuts. A cut is a special parser, constructed using `ParserBuilder.cut`, that doesn't attempt to consume any input. Rather, 
-When a cut 'parses', the fact that it was encountered is recored in the parsing context. Backtracking parsers, such as the ones listed above, will not attempt to backtrack parsing if a cut was encountered by one of their underlying parsers. Rather they will immediate fail with whatever failure that would have caused them to backtrack.
+Clearly, for the input `number a123` a more reasonable behavior would be if the parser didn't even try the second alternative in the `choice` combinator above, and immediately bail out if we've encountered the `number` token. In Parzing, This kind of behavior can be achieved using *cuts*. 
+
+A cut is a special parser, constructed using `ParserBuilder.cut`, that doesn't attempt to consume any input. Rather, 
+When a cut 'parses', the fact that it was encountered is recored in the parsing context. Backtracking parsers, such as the ones listed above, will not attempt to backtrack parsing if a cut was encountered by one of their underlying parsers. Rather they will immediately fail with whatever failure that would have caused them to backtrack.
 
 Fixing the example above using cuts, we can write:
 
@@ -202,7 +206,7 @@ which would now result in the following exception:
 ParseError { message: "Expecting AnyOf 0123456789 at 7 ('a123')" }
 ```
 
-Clearly a more useful error message. Note that in addition to yielding clearer errors, cuts may also improve parsing performance since by preventing backtracks.
+Clearly a more useful error message. Note that in addition to yielding clearer errors, cuts may also improve parsing performance by preventing backtracks.
 
 There are cases where you may want to reuse the same parser in different contexts -- where in some contexts you want the cut to appear but in others you want the cut to be ignored. This is achieved by invoking ``ParserBuilder.attempt`` on the parser which will return an ``AttemptCombinator``. This combinator parser will "swallow" any cut encountered indication within the underlying parser.
 
@@ -250,12 +254,14 @@ Parzing offers the following operators out of the box. Note that you can also cr
     
 ### Recursive Parsers
 
-In many cases a language may include recursive grammar definitions. Consider for example the following simple expresion parser grammer: 
+Grammars often include recursive definitions. Consider for example the following simple expresion parser grammer: 
 
+```
 expression := addition | subtraction
 addition := term '+' term
 subtraction := term '-' term
 term := number | '(' expression ')'
+````
 
 How would we define this using Parzing? 
 
@@ -289,9 +295,9 @@ const subtraction = pb.sequence(
 const expression = pb.choice(addition, subtraction);
 ```
 
-Note the comment "Ooops!" above. The recursive nature of the parser creates a circular declaration in Typescript, which is disallowed.
+Note the comment "Ooops!" above. The recursive nature of the parser creates a circular declaration, which is disallowed in Typescript.
 
-The `ParserBuilder.ref` method allows coping with this situation by receiving a parameterless function returning a parser, and creating a parser that lazily resolves to the function's return value. 
+The `ParserBuilder.ref` method allows solving  this problem by receiving a parameterless function returning a parser, and creating a parser that lazily resolves to the function's return value. 
 Using this mechanism, our recursive parser becomes possible by modifying the code above as follows:
 
 

package/dist/builder.d.ts

@@ -6,8 +6,9 @@ import { OptionalCombinator } from "./combinators/OptionalCombinator";
 import { SequenceCombinator } from "./combinators/SequenceCombinator";
 import { CutParser, FailParser, Parser, ParserType, PassParser, RefParser } from "./core";
 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>;
@@ -17,7 +18,8 @@ export declare class ParserBuilder {
     parser<T extends Parser<any>>(p: T): WithPostfixSupport<T>;
     token(tok: string): WithPostfixSupport<TokenParser>;
     anyOf(alts: string, minLen?: number | null, maxLen?: number | null): WithPostfixSupport<AnyOfParser>;
-    fail(message?: string): WithPostfixSupport<FailParser>;
+    regex(re: RegExp): WithPostfixSupport<RegexParser>;
+    fail(message: string): WithPostfixSupport<FailParser>;
     pass(): WithPostfixSupport<PassParser>;
     cut(): WithPostfixSupport<CutParser>;
     ref<T>(f: () => Parser<T>): WithPostfixSupport<RefParser<T>>;
@@ -25,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,88 +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 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.fail = function (message) {
-        if (message === void 0) { message = null; }
+    }
+    regex(re) {
+        return this.postProcessParser(new RegexParser_1.RegexParser(re));
+    }
+    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>> {