@zigsterz/parzing 1.0.0 → 1.2.0

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

@@ -3,8 +3,10 @@ export interface ParserInputBookmark {
 export interface ParserInput {
     read(readLen: number): string;
     peek(peekLen: number): string;
+    readRegex?(regex: RegExp): string | null;
+    peekRegex?(regex: RegExp): string | null;
     getBookmark(): ParserInputBookmark;
-    seekToBookmark(bm: ParserInputBookmark): any;
+    seekToBookmark(bm: ParserInputBookmark): void;
     eof(): boolean;
     tell(): number;
 }
@@ -14,6 +16,8 @@ export declare class StringParserInput implements ParserInput {
     constructor(_text: String);
     read(readLen: number): string;
     peek(readLen: number): string;
+    readRegex(regex: RegExp): string | null;
+    peekRegex(regex: RegExp): string | null;
     getBookmark(): ParserInputBookmark;
     seekToBookmark(bm: ParserInputBookmark): void;
     eof(): boolean;
@@ -29,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;
@@ -48,10 +52,10 @@ 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> {
+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>;
@@ -63,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,65 +1,77 @@
 "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.getBookmark = function () {
+    }
+    readRegex(regex) {
+        const ret = this.peekRegex(regex);
+        if (ret) {
+            this._index += ret.length;
+        }
+        return ret;
+    }
+    peekRegex(regex) {
+        let matchResult = regex.exec(this._text.substring(this._index));
+        if (!matchResult) {
+            return null;
+        }
+        if (matchResult.index != 0) {
+            return null;
+        }
+        return matchResult[0];
+    }
+    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) {
@@ -68,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) {
@@ -79,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.d.ts

@@ -0,0 +1,7 @@
+import { Parser, ParserContext, ParseResult } from "../core";
+export declare class RegexParser implements Parser<string> {
+    private _regex;
+    _charBitmap: number[] | null;
+    constructor(_regex: RegExp);
+    parse(parserContext: ParserContext): ParseResult<string>;
+}

package/dist/parsers/RegexParser.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegexParser = void 0;
+const core_1 = require("../core");
+class RegexParser {
+    constructor(_regex) {
+        this._regex = _regex;
+        this._charBitmap = null;
+    }
+    parse(parserContext) {
+        if (!parserContext.input.readRegex) {
+            throw core_1.ParseError.parserRejected(this, parserContext, "Input doesn't support regex parsing");
+        }
+        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.successful(reResult);
+    }
+}
+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];