@zigsterz/parzing 1.0.0

package/dist/combinators/ManyCombinator.d.ts

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

package/dist/combinators/ManyCombinator.js

@@ -0,0 +1,101 @@
+"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;
+    }
+    ManyCombinator.prototype.parse = function (parserContext) {
+        var output = [];
+        var pce = parserContext.cutEncountered;
+        var mustParseElement = false;
+        try {
+            do {
+                // Parse element
+                var bm = parserContext.input.getBookmark();
+                parserContext.cutEncountered = false;
+                var psr = this._parser.parse(parserContext);
+                if (psr.successful) {
+                    output.push(psr.result);
+                }
+                else {
+                    if (mustParseElement || parserContext.cutEncountered) {
+                        return psr;
+                    }
+                    else {
+                        parserContext.input.seekToBookmark(bm);
+                        break;
+                    }
+                }
+                mustParseElement = false;
+                // Parse WS
+                parserContext.cutEncountered = false;
+                var wpr = this.parseWhitespace(parserContext);
+                if (!wpr.successful) {
+                    return wpr;
+                }
+                // Attempt parse sep
+                if (this._sepParser) {
+                    parserContext.cutEncountered = false;
+                    bm = parserContext.input.getBookmark();
+                    var sepr = this._sepParser.parse(parserContext);
+                    if (sepr.successful) {
+                        mustParseElement = true;
+                        // Parse WS post separator
+                        parserContext.cutEncountered = false;
+                        wpr = this.parseWhitespace(parserContext);
+                        if (!wpr.successful) {
+                            return wpr;
+                        }
+                    }
+                    else {
+                        if (parserContext.cutEncountered) {
+                            return sepr;
+                        }
+                        else {
+                            parserContext.input.seekToBookmark(bm);
+                            break;
+                        }
+                    }
+                }
+            } 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));
+            }
+            else {
+                return core_1.ParseResult.successful(output);
+            }
+        }
+        finally {
+            parserContext.cutEncountered = pce;
+        }
+    };
+    return ManyCombinator;
+}(core_1.ParserWithInternalWhitespaceSupport));
+exports.ManyCombinator = ManyCombinator;

package/dist/combinators/MapParser.d.ts

@@ -0,0 +1,7 @@
+import { Parser, ParserContext, ParseResult, ParserType } from "../core";
+export declare class MapParser<V extends Parser<unknown>, T> implements Parser<T> {
+    private _parser;
+    private _fn;
+    constructor(_parser: V, _fn: (i: ParserType<V>) => T);
+    parse(parserContext: ParserContext): ParseResult<T>;
+}

package/dist/combinators/MapParser.js

@@ -0,0 +1,19 @@
+"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) {
+        this._parser = _parser;
+        this._fn = _fn;
+    }
+    MapParser.prototype.parse = function (parserContext) {
+        var 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.d.ts

@@ -0,0 +1,6 @@
+import { Parser, ParserContext, ParseResult } from "../core";
+export declare class OptionalCombinator<T> implements Parser<T | null> {
+    private _parser;
+    constructor(_parser: Parser<T>);
+    parse(parserContext: ParserContext): ParseResult<T | null>;
+}

package/dist/combinators/OptionalCombinator.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionalCombinator = void 0;
+var core_1 = require("../core");
+var OptionalCombinator = /** @class */ (function () {
+    function OptionalCombinator(_parser) {
+        this._parser = _parser;
+    }
+    OptionalCombinator.prototype.parse = function (parserContext) {
+        var input = parserContext.input;
+        var bm = input.getBookmark();
+        var pce = parserContext.cutEncountered;
+        parserContext.cutEncountered = false;
+        var 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

@@ -0,0 +1,12 @@
+import { Parser, ParserContext, ParseResult } from "../core";
+declare type ResultWithIndices<T> = {
+    result: T;
+    start: number;
+    length: number;
+};
+export declare class ParserWithIndices<T> implements Parser<ResultWithIndices<T>> {
+    private _underlying;
+    constructor(_underlying: Parser<T>);
+    parse(parserContext: ParserContext): ParseResult<ResultWithIndices<T>>;
+}
+export {};

package/dist/combinators/ParserWithIndices.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserWithIndices = void 0;
+var core_1 = require("../core");
+var ParserWithIndices = /** @class */ (function () {
+    function ParserWithIndices(_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();
+        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

@@ -0,0 +1,10 @@
+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<{
+    [i in keyof TS]: ParserType<TS[i]>;
+}>;
+export declare class SequenceCombinator<TS extends Parser<unknown>[]> extends ParserWithInternalWhitespaceSupport<SeqType<TS>> {
+    private _parsers;
+    constructor(_parsers: TS);
+    parse(parserContext: ParserContext): ParseResult<SeqType<TS>>;
+}

package/dist/combinators/SequenceCombinator.js

@@ -0,0 +1,50 @@
+"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;
+    }
+    SequenceCombinator.prototype.parse = function (parserContext) {
+        var results = [];
+        for (var i = 0; i < this._parsers.length; i++) {
+            if (i) {
+                var wsr = this.parseWhitespace(parserContext);
+                if (!wsr.successful) {
+                    return wsr;
+                }
+            }
+            var psr = this._parsers[i].parse(parserContext);
+            if (psr.successful) {
+                if (psr.result !== undefined) {
+                    results.push(psr.result);
+                }
+            }
+            else {
+                return psr;
+            }
+        }
+        return core_1.ParseResult.successful(results);
+    };
+    return SequenceCombinator;
+}(core_1.ParserWithInternalWhitespaceSupport));
+exports.SequenceCombinator = SequenceCombinator;

package/dist/core.d.ts

@@ -0,0 +1,89 @@
+export interface ParserInputBookmark {
+}
+export interface ParserInput {
+    read(readLen: number): string;
+    peek(peekLen: number): string;
+    getBookmark(): ParserInputBookmark;
+    seekToBookmark(bm: ParserInputBookmark): any;
+    eof(): boolean;
+    tell(): number;
+}
+export declare class StringParserInput implements ParserInput {
+    private _text;
+    private _index;
+    constructor(_text: String);
+    read(readLen: number): string;
+    peek(readLen: number): string;
+    getBookmark(): ParserInputBookmark;
+    seekToBookmark(bm: ParserInputBookmark): void;
+    eof(): boolean;
+    remainder(): string;
+    skip(howMuch: number): void;
+    tell(): number;
+}
+export declare class ParserContext {
+    private _input;
+    private _whitespaceParser;
+    constructor(_input: ParserInput, _whitespaceParser?: Parser<unknown> | null);
+    parseWhitespace(): void;
+    get input(): ParserInput;
+    cutEncountered: boolean;
+}
+export declare type ParseResult<T> = {
+    successful: true;
+    failed: false;
+    result: T;
+} | {
+    successful: false;
+    failed: true;
+    parseError: ParseError;
+};
+export declare namespace ParseResult {
+    function successful<T>(r: T): ParseResult<T>;
+    function voidSuccessful(): ParseResult<void>;
+    function failed<T>(r: ParseError): ParseResult<T>;
+    function resultOrThrow<T>(p: ParseResult<T>): T;
+}
+export interface Parser<T> {
+    parse(parserContext: ParserContext): ParseResult<T>;
+}
+export declare function isParser(p: any): p is Parser<unknown>;
+export declare class FailParser implements Parser<void> {
+    private _message;
+    constructor(_message?: string);
+    parse(parserContext: ParserContext): any;
+}
+export declare class PassParser implements Parser<void> {
+    parse(parserContext: ParserContext): ParseResult<void>;
+}
+export declare class CutParser implements Parser<void> {
+    parse(parserContext: ParserContext): ParseResult<void>;
+}
+export declare class RefParser<T> implements Parser<T> {
+    private _parserProvider;
+    constructor(_parserProvider: () => Parser<T>);
+    parse(parserContext: ParserContext): ParseResult<T>;
+    private _parser;
+}
+export declare 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>;
+    protected parseWhitespace(parserContext: ParserContext): {
+        successful: false;
+        failed: true;
+        parseError: ParseError;
+    } | {
+        successful: true;
+        failed: false;
+        result: unknown;
+    };
+    private _whitespace;
+}
+export declare function parse<T>(parser: Parser<T>, input: ParserInput | string, allowPartial?: boolean): T;
+export declare class ParseError {
+    message: string;
+    constructor(input: ParserInput, bookmark: ParserInputBookmark | null, parser: Parser<unknown> | null, contentMessage: string);
+    toString(): string;
+    static parserRejected(parser: Parser<unknown>, context: ParserContext, message?: string): ParseError;
+}

package/dist/core.js

@@ -0,0 +1,186 @@
+"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) {
+        this._text = _text;
+        this._index = 0;
+    }
+    StringParserInput.prototype.read = function (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");
+        }
+        var ret = this._text.substr(this._index, readLen);
+        this._index += readLen;
+        return ret;
+    };
+    StringParserInput.prototype.peek = function (readLen) {
+        return this._text.substr(this._index, readLen);
+    };
+    StringParserInput.prototype.getBookmark = function () {
+        return this._index;
+    };
+    StringParserInput.prototype.seekToBookmark = function (bm) {
+        this._index = bm;
+    };
+    StringParserInput.prototype.eof = function () {
+        return this._index >= this._text.length;
+    };
+    StringParserInput.prototype.remainder = function () {
+        return this._text.substr(this._index);
+    };
+    StringParserInput.prototype.skip = function (howMuch) {
+        this._index += howMuch;
+    };
+    StringParserInput.prototype.tell = function () {
+        return this._index;
+    };
+    return StringParserInput;
+}());
+exports.StringParserInput = StringParserInput;
+var ParserContext = /** @class */ (function () {
+    function ParserContext(_input, _whitespaceParser) {
+        if (_whitespaceParser === void 0) { _whitespaceParser = null; }
+        this._input = _input;
+        this._whitespaceParser = _whitespaceParser;
+        this.cutEncountered = false;
+    }
+    ParserContext.prototype.parseWhitespace = function () {
+        if (this._whitespaceParser) {
+            this._whitespaceParser.parse(this);
+        }
+    };
+    Object.defineProperty(ParserContext.prototype, "input", {
+        get: function () {
+            return this._input;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ParserContext;
+}());
+exports.ParserContext = ParserContext;
+var ParseResult;
+(function (ParseResult) {
+    function successful(r) {
+        return { successful: true, failed: false, result: r };
+    }
+    ParseResult.successful = successful;
+    function voidSuccessful() {
+        return { successful: true, failed: false, result: undefined };
+    }
+    ParseResult.voidSuccessful = voidSuccessful;
+    function failed(r) {
+        return { successful: false, failed: true, parseError: r };
+    }
+    ParseResult.failed = failed;
+    function resultOrThrow(p) {
+        if (p.successful) {
+            return p.result;
+        }
+        else if (p.failed) {
+            throw p.parseError;
+        }
+    }
+    ParseResult.resultOrThrow = resultOrThrow;
+})(ParseResult = exports.ParseResult || (exports.ParseResult = {}));
+;
+function isParser(p) {
+    return 'parse' in p;
+}
+exports.isParser = isParser;
+var FailParser = /** @class */ (function () {
+    function FailParser(_message) {
+        if (_message === void 0) { _message = null; }
+        this._message = _message;
+    }
+    FailParser.prototype.parse = function (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) {
+        return ParseResult.voidSuccessful();
+    };
+    return PassParser;
+}());
+exports.PassParser = PassParser;
+var CutParser = /** @class */ (function () {
+    function CutParser() {
+    }
+    CutParser.prototype.parse = function (parserContext) {
+        parserContext.cutEncountered = true;
+        return ParseResult.voidSuccessful();
+    };
+    return CutParser;
+}());
+exports.CutParser = CutParser;
+var RefParser = /** @class */ (function () {
+    function RefParser(_parserProvider) {
+        this._parserProvider = _parserProvider;
+    }
+    RefParser.prototype.parse = function (parserContext) {
+        if (!this._parser) {
+            this._parser = this._parserProvider();
+        }
+        return this._parser.parse(parserContext);
+    };
+    return RefParser;
+}());
+exports.RefParser = RefParser;
+var ParserWithInternalWhitespaceSupport = /** @class */ (function () {
+    function ParserWithInternalWhitespaceSupport() {
+        this._whitespace = null;
+    }
+    ParserWithInternalWhitespaceSupport.prototype.parse = function (parserContext) {
+        throw new Error('Method not implemented');
+    };
+    ParserWithInternalWhitespaceSupport.prototype.whitespace = function (whitespaceParser) {
+        this._whitespace = whitespaceParser;
+        return this;
+    };
+    ParserWithInternalWhitespaceSupport.prototype.parseWhitespace = function (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') {
+        input = new StringParserInput(input);
+    }
+    var context = new ParserContext(input);
+    var ret = parser.parse(context);
+    if (!allowPartial && !input.eof()) {
+        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) {
+        this.message = contentMessage;
+        if (bookmark) {
+            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;
+}());
+exports.ParseError = ParseError;

package/dist/operators.d.ts

@@ -0,0 +1,13 @@
+import { AstBuilder } from "./combinators/AstBuilder";
+import { MapParser } from "./combinators/MapParser";
+import { OptionalCombinator } from "./combinators/OptionalCombinator";
+import { ParserWithIndices } from "./combinators/ParserWithIndices";
+import { Parser, ParserWithInternalWhitespaceSupport } from "./core";
+export declare namespace ParserOperators {
+    function map<S, T>(mapper: (s: S) => T): (p: Parser<S>) => MapParser<Parser<S>, T>;
+    function optional<T>(): (p: Parser<T>) => OptionalCombinator<T>;
+    function build<Args extends [...any], Ctor extends new (...args: Args) => any>(ctor: Ctor): (p: Parser<Args>) => AstBuilder<Args, Ctor>;
+    function omit(): (p: Parser<unknown>) => MapParser<Parser<unknown>, void>;
+    function whitespace<T>(ws: Parser<unknown>): (p: ParserWithInternalWhitespaceSupport<T>) => ParserWithInternalWhitespaceSupport<T>;
+    function withIndices<T>(): (p: Parser<T>) => ParserWithIndices<T>;
+}

package/dist/operators.js

@@ -0,0 +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");
+var ParserOperators;
+(function (ParserOperators) {
+    function map(mapper) {
+        return function (p) {
+            return new MapParser_1.MapParser(p, mapper);
+        };
+    }
+    ParserOperators.map = map;
+    function optional() {
+        return function (p) {
+            return new OptionalCombinator_1.OptionalCombinator(p);
+        };
+    }
+    ParserOperators.optional = optional;
+    function build(ctor) {
+        return function (p) {
+            return new AstBuilder_1.AstBuilder(p, ctor);
+        };
+    }
+    ParserOperators.build = build;
+    function omit() {
+        return function (p) {
+            return new MapParser_1.MapParser(p, function (a) { });
+        };
+    }
+    ParserOperators.omit = omit;
+    function whitespace(ws) {
+        return function (p) {
+            return p.whitespace(ws);
+        };
+    }
+    ParserOperators.whitespace = whitespace;
+    function withIndices() {
+        return function (p) {
+            return new ParserWithIndices_1.ParserWithIndices(p);
+        };
+    }
+    ParserOperators.withIndices = withIndices;
+})(ParserOperators = exports.ParserOperators || (exports.ParserOperators = {}));

package/dist/parsers/AnyOfParser.d.ts

@@ -0,0 +1,9 @@
+import { Parser, ParserContext, ParseResult } from "../core";
+export declare class AnyOfParser implements Parser<string> {
+    private _characters;
+    private _minLen;
+    private _maxLen;
+    _charBitmap: number[] | null;
+    constructor(_characters: string, _minLen?: number | null, _maxLen?: number | null);
+    parse(parserContext: ParserContext): ParseResult<string>;
+}

package/dist/parsers/AnyOfParser.js

@@ -0,0 +1,51 @@
+"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; }
+        this._characters = _characters;
+        this._minLen = _minLen;
+        this._maxLen = _maxLen;
+        var charBitmap = [];
+        this._charBitmap = charBitmap;
+        for (var i = 0; i < _characters.length; i++) {
+            var ccode = _characters.charCodeAt(i);
+            if (ccode < 256) {
+                charBitmap[ccode >> 3] = (charBitmap[ccode >> 3] || 0) | (1 << (ccode & 7));
+            }
+            else {
+                this._charBitmap = null;
+                break;
+            }
+        }
+    }
+    AnyOfParser.prototype.parse = function (parserContext) {
+        var ret = [];
+        var cont = true;
+        var input = parserContext.input;
+        while (cont && !input.eof()) {
+            var str = input.peek(1);
+            if (this._charBitmap) {
+                var ccode = str.charCodeAt(0);
+                cont = (this._charBitmap[ccode >> 3] & (1 << (ccode & 7))) != 0;
+            }
+            else {
+                cont = this._characters.indexOf(str) >= 0;
+            }
+            if (cont) {
+                ret.push(str);
+                input.read(1);
+            }
+        }
+        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.successful(ret.join(''));
+    };
+    return AnyOfParser;
+}());
+exports.AnyOfParser = AnyOfParser;

package/dist/parsers/TokenParser.d.ts

@@ -0,0 +1,6 @@
+import { Parser, ParserContext, ParseResult } from "../core";
+export declare class TokenParser implements Parser<string> {
+    private _token;
+    constructor(_token: String);
+    parse(parserContext: ParserContext): ParseResult<string>;
+}