parser-combinators 1.0.7 → 1.1.3

package/LICENSE

@@ -0,0 +1,12 @@
+Copyright 2022 Michał Isalski
+
+Permission to use, copy, modify, and/or distribute
+this software for any purpose with or without fee is hereby granted,
+provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
+OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -6,7 +6,6 @@
 
 ![NPM](https://img.shields.io/npm/l/parser-combinators)
 [![NPM Version](https://badge.fury.io/js/parser-combinators.svg)](https://badge.fury.io/js/parser-combinators)
-[![No Dependencies](https://status.david-dm.org/gh/michalusio/parser.svg)](https://status.david-dm.org/)
 
 A library of parser combinators, with which you can create your own parsers.
 
@@ -38,6 +37,8 @@ A library of parser combinators, with which you can create your own parsers.
 - Utility combinators:
   - `ref`er
   - `expect`
+  - `expectErase`
+  - `surely`
 - Ready-made value combinators:
   - `spaces`
   - `spacesPlus`
@@ -45,6 +46,9 @@ A library of parser combinators, with which you can create your own parsers.
   - `bool` (and `boolP`)
   - `int` (and `intP`)
   - `real` (and `realP`)
+- Whole parsers:
+  - Extended Backus-Naur Form (`EBNF`)
+  - JavaScript Object Notation (`JSON`)
 
 ### Example usage:
 

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./parsers";
+export * from "./parser";

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./parsers"), exports);
+__exportStar(require("./parser"), exports);

package/{parser.js → dist/parser.js}

@@ -23,7 +23,7 @@ exports.ParseFile = ParseFile;
  */
 function ParseText(text, parser, path = '') {
     const res = parser({ text, path, index: 0 });
-    if (types_1.isFailure(res)) {
+    if ((0, types_1.isFailure)(res)) {
         throw new types_1.ParseError(`Parse error, expected ${[...res.history].pop()} at char ${res.ctx.index}`, text, res.ctx.index, res.history);
     }
     if (res.ctx.index !== text.length) {

package/{parsers → dist/parsers}/any.d.ts

@@ -13,3 +13,5 @@ export declare function any<T, U, V, W>(...parsers: [Parser<T>, Parser<U>, Parse
 export declare function any<T, U, V>(...parsers: [Parser<T>, Parser<U>, Parser<V>]): Parser<T | U | V>;
 export declare function any<T, U>(...parsers: [Parser<T>, Parser<U>]): Parser<T | U>;
 export declare function any<T>(...parsers: [Parser<T>]): Parser<T>;
+export declare function any<T>(...parsers: Parser<T>[]): Parser<T>;
+export declare function surely<T>(parser: Parser<T>): Parser<T>;

package/dist/parsers/any.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.surely = exports.any = void 0;
+const _1 = require(".");
+const types_1 = require("../types");
+function any(...parsers) {
+    return (ctx) => {
+        const expected = [];
+        for (const parser of parsers) {
+            const res = parser(ctx);
+            if ((0, types_1.isFailure)(res)) {
+                if (res.history.includes('surely')) {
+                    console.log('shot');
+                    return (0, types_1.failure)(res.ctx, res.expected, res.history.filter(h => h !== 'surely'));
+                }
+                expected.push(res);
+            }
+            else
+                return res;
+        }
+        const longest = expected.reduce((a, b) => a.history.length > b.history.length ? a : b);
+        return (0, types_1.failure)(longest.ctx, longest.expected, ['any', ...longest.history]);
+    };
+}
+exports.any = any;
+function surely(parser) {
+    return (0, _1.expect)(parser, 'surely');
+}
+exports.surely = surely;

package/{parsers → dist/parsers}/between.js

@@ -2,20 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.between = void 0;
 const types_1 = require("../types");
-const map_1 = require("./map");
 const seq_1 = require("./seq");
 /** Parses a sequence of three parsers.
  * @returns A parser returning only the middle parser's result.
  */
 function between(left, parser, right) {
+    const sequence = (0, seq_1.seq)(left, parser, right);
     return (ctx) => {
-        const res = map_1.map(seq_1.seq(left, parser, right), val => val[1])(ctx);
-        if (types_1.isFailure(res)) {
+        const res = sequence(ctx);
+        if ((0, types_1.isFailure)(res)) {
             const newHistory = [...res.history];
-            newHistory.splice(0, 2);
-            return types_1.failure(res.ctx, res.expected, ['between', ...newHistory]);
+            newHistory.splice(0, 1);
+            return (0, types_1.failure)(res.ctx, res.expected, ['between', ...newHistory]);
         }
-        return res;
+        return { ...res, value: res.value[1] };
     };
 }
 exports.between = between;

package/{parsers → dist/parsers}/exhaust.js

@@ -11,16 +11,16 @@ function exhaust(parser, until = null) {
         // eslint-disable-next-line no-constant-condition
         while (true) {
             const res = parser(ctx);
-            if (types_1.isFailure(res)) {
-                if (until === null || types_1.isFailure(until(ctx))) {
-                    return types_1.failure(res.ctx, res.expected, ['exhaust', ...res.history]);
+            if ((0, types_1.isFailure)(res)) {
+                if (until === null || (0, types_1.isFailure)(until(ctx))) {
+                    return (0, types_1.failure)(res.ctx, res.expected, ['exhaust', ...res.history]);
                 }
-                return types_1.success(ctx, results);
+                return (0, types_1.success)(ctx, results);
             }
             ctx = res.ctx;
             results.push(res.value);
             if (res.ctx.index === res.ctx.text.length)
-                return types_1.success(res.ctx, results);
+                return (0, types_1.success)(res.ctx, results);
         }
     };
 }

package/{parsers → dist/parsers}/index.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/{parsers → dist/parsers}/many.d.ts

@@ -10,7 +10,7 @@ export declare function zeroOrMany<T, V>(item: Parser<T>, separator: Parser<V>):
 /** Parses one or more occurences of the given parser, separated with the separator parser.
  * @returns A parser returning an array of many parses, omitting the separator.
  */
-export declare function oneOrMany<T, V>(item: Parser<T>, separator: Parser<V>): Parser<T[]>;
+export declare function oneOrMany<T, V>(item: Parser<T>, separator?: Parser<V> | undefined): Parser<T[]>;
 /** Parses one or more occurences of the given parser, separated with the separator parser.
  * @returns A parser returning the result of many parses, reduced using the `reducer` function passed in.
  */

package/{parsers → dist/parsers}/many.js

@@ -14,8 +14,8 @@ function many(parser) {
         // eslint-disable-next-line no-constant-condition
         while (true) {
             const res = parser(ctx);
-            if (types_1.isFailure(res)) {
-                return types_1.success(ctx, results);
+            if ((0, types_1.isFailure)(res)) {
+                return (0, types_1.success)(ctx, results);
             }
             ctx = res.ctx;
             results.push(res.value);
@@ -27,19 +27,22 @@ exports.many = many;
  * @returns A parser returning an array of many parses, omitting the separator.
  */
 function zeroOrMany(item, separator) {
-    return map_1.map(opt_1.opt(oneOrMany(item, separator)), t => t ?? []);
+    return (0, map_1.map)((0, opt_1.opt)(oneOrMany(item, separator)), t => t !== null && t !== void 0 ? t : []);
 }
 exports.zeroOrMany = zeroOrMany;
 /** Parses one or more occurences of the given parser, separated with the separator parser.
  * @returns A parser returning an array of many parses, omitting the separator.
  */
-function oneOrMany(item, separator) {
+function oneOrMany(item, separator = undefined) {
+    const sequencer = (0, map_1.map)((0, seq_1.seq)(item, many(separator
+        ? (0, map_1.map)((0, seq_1.seq)(separator, item), ([, t]) => t)
+        : item)), ([t, ts]) => ([t, ...ts]));
     return (ctx) => {
-        const res = map_1.map(seq_1.seq(item, many(map_1.map(seq_1.seq(separator, item), ([, t]) => t))), ([t, ts]) => ([t, ...ts]))(ctx);
-        if (types_1.isFailure(res)) {
+        const res = sequencer(ctx);
+        if ((0, types_1.isFailure)(res)) {
             const newHistory = [...res.history];
             newHistory.splice(0, 2);
-            return types_1.failure(res.ctx, res.expected, ['oneOrMany', ...newHistory]);
+            return (0, types_1.failure)(res.ctx, res.expected, ['oneOrMany', ...newHistory]);
         }
         return res;
     };
@@ -49,7 +52,7 @@ exports.oneOrMany = oneOrMany;
  * @returns A parser returning the result of many parses, reduced using the `reducer` function passed in.
  */
 function oneOrManyRed(item, separator, reducer) {
-    return map_1.map(map_1.map(seq_1.seq(map_1.map(item, (x) => [null, x]), many(seq_1.seq(separator, item))), ([t, ts]) => ([t, ...ts])), ts => {
+    return (0, map_1.map)((0, map_1.map)((0, seq_1.seq)((0, map_1.map)(item, (x) => [null, x]), many((0, seq_1.seq)(separator, item))), ([t, ts]) => ([t, ...ts])), ts => {
         let result = ts[0][1];
         for (let i = 1; i < ts.length; i++) {
             result = reducer(result, ts[i][1], ts[i][0]);

package/{parsers → dist/parsers}/map.js

@@ -8,15 +8,14 @@ const types_1 = require("../types");
 function map(parser, mapper) {
     return (ctx) => {
         const res = parser(ctx);
-        if (types_1.isFailure(res))
-            return types_1.failure(res.ctx, res.expected, ['map', ...res.history]);
+        if ((0, types_1.isFailure)(res))
+            return (0, types_1.failure)(res.ctx, res.expected, ['map', ...res.history]);
         try {
             const newValue = mapper(res.value);
-            return types_1.success(res.ctx, newValue);
+            return (0, types_1.success)(res.ctx, newValue);
         }
         catch (e) {
-            console.trace('Error while mapping: ', e);
-            return types_1.failure(res.ctx, 'Error while mapping', ['map']);
+            return (0, types_1.failure)(res.ctx, 'Error while mapping', ['map']);
         }
     };
 }

package/{parsers → dist/parsers}/opt.js

@@ -8,8 +8,8 @@ const types_1 = require("../types");
 function opt(parser) {
     return (ctx) => {
         const parseResult = parser(ctx);
-        if (types_1.isFailure(parseResult)) {
-            return types_1.success(ctx, null);
+        if ((0, types_1.isFailure)(parseResult)) {
+            return (0, types_1.success)(ctx, null);
         }
         return parseResult;
     };

package/dist/parsers/regex.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regex = void 0;
+const types_1 = require("../types");
+/** Parses a regex and returns the matched result of the parse.
+ * @returns A parser parsing a given regex and returning a match.
+ */
+function regex(match, expected) {
+    const regexp = new RegExp(match, typeof match === 'string' ? 'y' : match.flags + 'y');
+    return (ctx) => {
+        regexp.lastIndex = ctx.index;
+        const regexMatch = regexp.exec(ctx.text);
+        if (regexMatch !== null && regexMatch.index === ctx.index) {
+            return (0, types_1.success)({ ...ctx, index: ctx.index + regexMatch[0].length }, regexMatch[0]);
+        }
+        else {
+            return (0, types_1.failure)(ctx, expected, [expected]);
+        }
+    };
+}
+exports.regex = regex;

package/{parsers → dist/parsers}/seq.d.ts

@@ -12,3 +12,5 @@ export declare function seq<T, U, V, W, X>(...parsers: [Parser<T>, Parser<U>, Pa
 export declare function seq<T, U, V, W>(...parsers: [Parser<T>, Parser<U>, Parser<V>, Parser<W>]): Parser<[T, U, V, W]>;
 export declare function seq<T, U, V>(...parsers: [Parser<T>, Parser<U>, Parser<V>]): Parser<[T, U, V]>;
 export declare function seq<T, U>(...parsers: [Parser<T>, Parser<U>]): Parser<[T, U]>;
+export declare function seq<T>(...parsers: [Parser<T>]): Parser<[T]>;
+export declare function seq<T>(...parsers: Parser<T>[]): Parser<T[]>;

package/{parsers → dist/parsers}/seq.js

@@ -8,11 +8,11 @@ function seq(...parsers) {
         for (const parser of parsers) {
             const res = parser(ctx);
             ctx = res.ctx;
-            if (types_1.isFailure(res))
-                return types_1.failure(res.ctx, res.expected, ['seq', ...res.history]);
+            if ((0, types_1.isFailure)(res))
+                return (0, types_1.failure)(res.ctx, res.expected, ['seq', ...res.history]);
             values.push(res.value);
         }
-        return types_1.success(ctx, values);
+        return (0, types_1.success)(ctx, values);
     };
 }
 exports.seq = seq;

package/{parsers → dist/parsers}/str.js

@@ -7,11 +7,11 @@ const types_1 = require("../types");
  */
 function str(match) {
     return (ctx) => {
-        if (ctx.text.substr(ctx.index, match.length) === match) {
-            return types_1.success({ ...ctx, index: ctx.index + match.length }, match);
+        if (ctx.text.startsWith(match, ctx.index)) {
+            return (0, types_1.success)({ ...ctx, index: ctx.index + match.length }, match);
         }
         else {
-            return types_1.failure(ctx, match, [match]);
+            return (0, types_1.failure)(ctx, match, [match]);
         }
     };
 }

package/{parsers → dist/parsers}/utilities.d.ts

@@ -2,8 +2,12 @@ import { Parser } from '../types';
 /** Allows to make a condition on the result of the parsing function.
  * @returns A parser returning the same but also performing a given check on the result.
  */
-export declare function ref<T>(parser: Parser<T>, check: ((p: T) => boolean), expected: string): Parser<T>;
+export declare function ref<T>(parser: Parser<T>, check: ((p: T) => boolean), expected?: string): Parser<T>;
 /** Changes the expected value for when the parser fails.
  * @returns A parser returning the same but with a different expected value.
  */
 export declare function expect<T>(parser: Parser<T>, expected: string): Parser<T>;
+/** Changes the expected value for when the parser fails. Erases the previous history.
+ * @returns A parser returning the same but with a different expected value.
+ */
+export declare function expectErase<T>(parser: Parser<T>, expected: string): Parser<T>;

package/dist/parsers/utilities.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectErase = exports.expect = exports.ref = void 0;
+const types_1 = require("../types");
+/** Allows to make a condition on the result of the parsing function.
+ * @returns A parser returning the same but also performing a given check on the result.
+ */
+function ref(parser, check, expected) {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (!(0, types_1.isFailure)(res) && !check(res.value)) {
+            return (0, types_1.failure)(res.ctx, expected !== null && expected !== void 0 ? expected : 'check', [`ref: ${expected !== null && expected !== void 0 ? expected : 'check'}`]);
+        }
+        return res;
+    };
+}
+exports.ref = ref;
+/** Changes the expected value for when the parser fails.
+ * @returns A parser returning the same but with a different expected value.
+ */
+function expect(parser, expected) {
+    return (ctx) => {
+        const res = parser(ctx);
+        if ((0, types_1.isFailure)(res)) {
+            return (0, types_1.failure)(res.ctx, expected, [expected, ...res.history]);
+        }
+        return res;
+    };
+}
+exports.expect = expect;
+/** Changes the expected value for when the parser fails. Erases the previous history.
+ * @returns A parser returning the same but with a different expected value.
+ */
+function expectErase(parser, expected) {
+    return (ctx) => {
+        const res = parser(ctx);
+        if ((0, types_1.isFailure)(res)) {
+            return (0, types_1.failure)(res.ctx, expected, [expected]);
+        }
+        return res;
+    };
+}
+exports.expectErase = expectErase;

package/{parsers → dist/parsers}/values.js

@@ -9,28 +9,28 @@ const str_1 = require("./str");
 const utilities_1 = require("./utilities");
 /** Parses 0 or more spaces
  */
-exports.spaces = regex_1.regex(/ */, 'spaces');
+exports.spaces = (0, regex_1.regex)(/ */, 'spaces');
 /** Parses 1 or more spaces
  */
-exports.spacesPlus = regex_1.regex(/ +/, 'spaces');
+exports.spacesPlus = (0, regex_1.regex)(/ +/, 'spaces');
 /** Parses 0 or more whitespace characters
  */
-exports.wspaces = opt_1.opt(regex_1.regex(/(?:\s|\t|\n|\r)+/, 'whitespace characters'));
+exports.wspaces = (0, opt_1.opt)((0, regex_1.regex)(/(?:\s|\t|\n|\r)+/, 'whitespace characters'));
 /** Parses a boolean (true or false) and returns a string
  */
-exports.bool = regex_1.regex(/true|false/, 'boolean');
+exports.bool = (0, regex_1.regex)(/true|false/, 'boolean');
 /** Parses a boolean (true or false) and returns a boolean
  */
-exports.boolP = map_1.map(exports.bool, val => val === 'true');
+exports.boolP = (0, map_1.map)(exports.bool, val => val === 'true');
 /** Parses an integer and returns a string
  */
-exports.int = regex_1.regex(/\d+/, 'integer');
+exports.int = (0, regex_1.regex)(/\d+/, 'integer');
 /** Parses an integer and returns a number
  */
-exports.intP = map_1.map(exports.int, seq => parseInt(seq, 10));
+exports.intP = (0, map_1.map)(exports.int, seq => parseInt(seq, 10));
 /** Parses a standard real number (X.X) and returns a string
  */
-exports.real = utilities_1.expect(map_1.map(seq_1.seq(exports.int, str_1.str('.'), exports.int), ([intPart, , decimalPart]) => `${intPart}.${decimalPart}`), 'real');
+exports.real = (0, utilities_1.expect)((0, map_1.map)((0, seq_1.seq)(exports.int, (0, str_1.str)('.'), exports.int), ([intPart, , decimalPart]) => `${intPart}.${decimalPart}`), 'real');
 /** Parses a standard real number (X.X) and returns a number
  */
-exports.realP = map_1.map(exports.real, (seq) => parseFloat(seq));
+exports.realP = (0, map_1.map)(exports.real, (seq) => parseFloat(seq));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parser-combinators",
-  "version": "1.0.7",
+  "version": "1.1.3",
   "license": "ISC",
   "maintainers": [
     "Micha_i"
@@ -16,33 +16,26 @@
   "description": "A library of parser combinators, with which you can create your own parsers. The library will be continuously improved in time.",
   "scripts": {
     "build": "tsc",
-    "publishing:prepare": "copy package.json dist && copy README.md dist",
-    "publishing:patch": "npm version patch && npm run publishing:prepare",
-    "publishing:minor": "npm version minor && npm run publishing:prepare",
-    "publishing:major": "npm version major && npm run publishing:prepare",
     "start": "tsc && node .",
     "lint": "eslint . --ext .ts",
-    "test:unit": "cross-env TS_NODE_PROJECT=tsconfig.spec.json mocha",
+    "test:unit": "cross-env TS_NODE_PROJECT=tsconfig.spec.json mocha tests/**/*.ts",
     "test": "nyc -e '.ts' --r html -r lcov -r text npm run test:unit",
-    "test:report": "nyc report --reporter=json > coverage/coverage.json && codecov"
+    "test:report": "nyc report --reporter=json > coverage/coverage.json"
   },
   "author": "Micha_i <isalski.michal@gmail.com> (https://github.com/michalusio)",
-  "main": "./parser.js",
-  "types": "./parser.d.ts",
-  "dependencies": {},
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "devDependencies": {
-    "@types/mocha": "^9.0.0",
-    "@types/node": "^16.7.6",
-    "@typescript-eslint/eslint-plugin": "^4.14.2",
-    "@typescript-eslint/parser": "^4.14.2",
-    "codecov": "^3.8.3",
-    "cross-env": "^7.0.3",
-    "eslint": "^7.15.0",
-    "istanbul": "1.1.0-alpha.1",
-    "mocha": "^9.1.0",
-    "nyc": "^15.1.0",
-    "ts-node": "^10.2.1",
-    "typescript": "^4.2.4"
+    "@types/mocha": "10.0.0",
+    "@types/node": "18.11.3",
+    "@typescript-eslint/eslint-plugin": "5.40.1",
+    "@typescript-eslint/parser": "5.40.1",
+    "cross-env": "7.0.3",
+    "eslint": "8.25.0",
+    "mocha": "10.1.0",
+    "nyc": "15.1.0",
+    "ts-node": "10.9.1",
+    "typescript": "4.8.4"
   },
   "keywords": [
     "parser",

package/parsers/any.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.any = void 0;
-const types_1 = require("../types");
-function any(...parsers) {
-    return (ctx) => {
-        const expected = [];
-        for (const parser of parsers) {
-            const res = parser(ctx);
-            if (types_1.isFailure(res)) {
-                expected.push(res);
-            }
-            else
-                return res;
-        }
-        const longest = expected.reduce((a, b) => a.ctx.index > b.ctx.index ? a : b);
-        return types_1.failure(longest.ctx, longest.expected, ['any', ...longest.history]);
-    };
-}
-exports.any = any;

package/parsers/regex.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.regex = void 0;
-const types_1 = require("../types");
-/** Parses a regex and returns the matched result of the parse.
- * @returns A parser parsing a given regex and returning a match.
- */
-function regex(match, expected) {
-    return (ctx) => {
-        const regexMatch = ctx.text.substr(ctx.index).match(match);
-        if (regexMatch !== undefined && regexMatch !== null && regexMatch.index === 0) {
-            return types_1.success({ ...ctx, index: ctx.index + regexMatch[0].length }, ctx.text.substr(ctx.index, regexMatch[0].length));
-        }
-        else {
-            return types_1.failure(ctx, expected, [expected]);
-        }
-    };
-}
-exports.regex = regex;

package/parsers/utilities.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.expect = exports.ref = void 0;
-const types_1 = require("../types");
-/** Allows to make a condition on the result of the parsing function.
- * @returns A parser returning the same but also performing a given check on the result.
- */
-function ref(parser, check, expected) {
-    return (ctx) => {
-        const res = parser(ctx);
-        if (!types_1.isFailure(res) && !check(res.value)) {
-            return types_1.failure(res.ctx, expected, [`ref: ${expected}`]);
-        }
-        return res;
-    };
-}
-exports.ref = ref;
-/** Changes the expected value for when the parser fails.
- * @returns A parser returning the same but with a different expected value.
- */
-function expect(parser, expected) {
-    return (ctx) => {
-        const res = parser(ctx);
-        if (types_1.isFailure(res)) {
-            return types_1.failure(res.ctx, expected, [expected, ...res.history]);
-        }
-        return res;
-    };
-}
-exports.expect = expect;