parser-combinators 1.2.1 → 1.2.3

package/dist-esm/parsers/utilities.js

@@ -0,0 +1,85 @@
+import { failure, isFailure, success } 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 function ref(parser, check, expected) {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (!isFailure(res) && !check(res.value)) {
+            return failure(res.ctx, expected ?? 'check', [`ref: ${expected ?? 'check'}`]);
+        }
+        return res;
+    };
+}
+/** Changes the expected value for when the parser fails.
+ * @returns A parser returning the same but with a different expected value.
+ */
+export function expect(parser, expected) {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (isFailure(res)) {
+            return failure(res.ctx, expected, [expected, ...res.history]);
+        }
+        return res;
+    };
+}
+/** 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 function expectErase(parser, expected) {
+    return (ctx) => {
+        const res = parser(ctx);
+        if (isFailure(res)) {
+            return failure(res.ctx, expected, [expected]);
+        }
+        return res;
+    };
+}
+/**
+ * Marks a parser as a branch that has to be executed to the end by the {@link any} parser
+ */
+export function surely(parser) {
+    return expect(parser, 'surely');
+}
+/**
+ * Wraps the value returned by the parser with the token information (the start and end index in the text)
+ * @returns A parser returning the value wrapped in token information.
+ */
+export function token(parser) {
+    return (ctx) => {
+        const result = parser(ctx);
+        if (result.success) {
+            return {
+                ...result,
+                value: {
+                    value: result.value,
+                    start: ctx.index,
+                    end: result.ctx.index
+                }
+            };
+        }
+        return result;
+    };
+}
+/**
+ * Checks whether the parser parses successfully, but doesn't move the cursor forward
+ */
+export function lookaround(parser) {
+    return (ctx) => {
+        const result = parser(ctx);
+        if (result.success) {
+            return success(ctx, void 0);
+        }
+        return failure(ctx, result.expected, ['lookaround', ...result.history]);
+    };
+}
+/**
+ * Turns a function creating a parser into a parser. Useful for recursive grammars.
+ */
+export function lazy(parserGetter) {
+    let parser;
+    return (ctx) => {
+        parser ??= parserGetter();
+        return parser(ctx);
+    };
+}

package/dist-esm/parsers/values.d.ts

@@ -0,0 +1,31 @@
+import { Parser } from '../types';
+/** Parses 0 or more spaces
+ */
+export declare const spaces: Parser<string>;
+/** Parses 1 or more spaces
+ */
+export declare const spacesPlus: Parser<string>;
+/** Parses 0 or more whitespace characters
+ */
+export declare const wspaces: Parser<string | null>;
+/** Parses a boolean (true or false) and returns a string
+ */
+export declare const bool: Parser<'true' | 'false'>;
+/** Parses a boolean (true or false) and returns a boolean
+ */
+export declare const boolP: Parser<boolean>;
+/** Parses an integer and returns a string
+ */
+export declare const int: Parser<string>;
+/** Parses an integer and returns a number
+ */
+export declare const intP: Parser<number>;
+/** Parses a standard real number (X.X) and returns a string
+ */
+export declare const real: Parser<`${number}.${number}`>;
+/** Parses a standard real number (X.X) and returns a number
+ */
+export declare const realP: Parser<number>;
+/** Parses an end of text/file. Fails if the parser is not at the end.
+ */
+export declare const eof: Parser<void>;

package/dist-esm/parsers/values.js

@@ -0,0 +1,44 @@
+import { failure, success } from '../types';
+import { map } from './map';
+import { opt } from './opt';
+import { regex } from './regex';
+import { seq } from './seq';
+import { str } from './str';
+import { expect } from './utilities';
+/** Parses 0 or more spaces
+ */
+export const spaces = regex(/ */, 'spaces');
+/** Parses 1 or more spaces
+ */
+export const spacesPlus = regex(/ +/, 'spaces');
+/** Parses 0 or more whitespace characters
+ */
+export const wspaces = opt(regex(/(?:\s|\t|\n|\r)+/, 'whitespace characters'));
+/** Parses a boolean (true or false) and returns a string
+ */
+export const bool = regex(/true|false/, 'boolean');
+/** Parses a boolean (true or false) and returns a boolean
+ */
+export const boolP = map(bool, val => val === 'true');
+/** Parses an integer and returns a string
+ */
+export const int = regex(/\d+/, 'integer');
+/** Parses an integer and returns a number
+ */
+export const intP = map(int, seq => parseInt(seq, 10));
+/** Parses a standard real number (X.X) and returns a string
+ */
+export const real = expect(map(seq(int, str('.'), int), ([intPart, , decimalPart]) => `${intPart}.${decimalPart}`), 'real');
+/** Parses a standard real number (X.X) and returns a number
+ */
+export const realP = map(real, (seq) => parseFloat(seq));
+/** Parses an end of text/file. Fails if the parser is not at the end.
+ */
+export const eof = (ctx) => {
+    if (ctx.index === ctx.text.length) {
+        return success(ctx, void 0);
+    }
+    else {
+        return failure(ctx, "End Of File", ["EOF"]);
+    }
+};

package/dist-esm/types.d.ts

@@ -0,0 +1,40 @@
+export type Parser<T> = (ctx: Context) => Result<T>;
+export type Context = Readonly<{
+    text: string;
+    path: string;
+    index: number;
+}>;
+export type Result<T> = Success<T> | Failure;
+export type Success<T> = Readonly<{
+    success: true;
+    value: T;
+    ctx: Context;
+}>;
+export type Failure = Readonly<{
+    success: false;
+    expected: string;
+    ctx: Context;
+    history: string[];
+}>;
+export type TokenRange = {
+    start: number;
+    end: number;
+};
+export type Token<T> = TokenRange & {
+    value: T;
+};
+export declare function isFailure(input: unknown): input is Failure;
+export declare function success<T>(ctx: Context, value: T): Success<T>;
+export declare function failure(ctx: Context, expected: string, history: string[]): Failure;
+export declare function result<T>(value: T): Parser<T>;
+export declare function fail<T>(reason: string): Parser<T>;
+export declare class ParseError extends Error {
+    readonly index: number;
+    readonly history: string[];
+    readonly line: string;
+    readonly column: number;
+    readonly row: number;
+    constructor(message: string, input: string, index: number, history: string[]);
+    private getInputData;
+    getPrettyErrorMessage(): string;
+}

package/dist-esm/types.js

@@ -0,0 +1,38 @@
+export function isFailure(input) {
+    return !input.success;
+}
+export function success(ctx, value) {
+    return { success: true, value, ctx };
+}
+export function failure(ctx, expected, history) {
+    return { success: false, expected, ctx, history };
+}
+export function result(value) {
+    return (ctx) => success(ctx, value);
+}
+export function fail(reason) {
+    return (ctx) => failure(ctx, reason, [reason]);
+}
+export class ParseError extends Error {
+    constructor(message, input, index, history) {
+        super(message);
+        this.index = index;
+        this.history = history;
+        [this.line, this.column, this.row] = this.getInputData(input, index);
+    }
+    getInputData(input, index) {
+        const lines = input.split('\n');
+        let row = 0;
+        while (index > 0) {
+            if (lines[row].length > index) {
+                return [lines[row], index + 1, row + 1];
+            }
+            index -= lines[row].length + 1;
+            row += 1;
+        }
+        return [lines[row], index + 1, row + 1];
+    }
+    getPrettyErrorMessage() {
+        return `${this.message} (line ${this.row}, col ${this.column}):\n${this.line}\n${(this.column > 0 ? '-'.repeat(this.column - 1) : '') + '^'}`;
+    }
+}

package/package.json

@@ -1,56 +1,61 @@
-{
-  "name": "parser-combinators",
-  "version": "1.2.1",
-  "license": "ISC",
-  "maintainers": [
-    "Micha_i"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/michalusio/Parser.git"
-  },
-  "bugs": {
-    "url": "https://github.com/michalusio/Parser/issues"
-  },
-  "homepage": "https://github.com/michalusio/Parser#readme",
-  "description": "A library of parser combinators, with which you can create your own parsers. The library will be continuously improved in time.",
-  "scripts": {
-    "start": "tsc && node .",
-    "lint": "eslint src --ext .ts",
-    "build": "tsc",
-    "minify": "esbuild dist/index.js --minify=true --bundle --outfile=dist/index.min.js",
-    "bundle": "npm run lint && npm run build && npm run minify",
-    "test:mutate": "stryker run",
-    "test:unit": "mocha",
-    "test": "nyc -e '.ts' --r html -r lcov -r text npm run test:unit"
-  },
-  "author": "Micha_i <isalski.michal@gmail.com> (https://github.com/michalusio)",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "engines": {
-    "node": ">=18"
-  },
-  "devDependencies": {
-    "@stryker-mutator/core": "^9.4.0",
-    "@stryker-mutator/mocha-runner": "^9.4.0",
-    "@stryker-mutator/typescript-checker": "^9.4.0",
-    "@types/mocha": "10.0.10",
-    "@types/node": "25.0.9",
-    "cross-env": "10.1.0",
-    "esbuild": "0.27.2",
-    "eslint": "9.39.2",
-    "mocha": "11.7.5",
-    "nyc": "17.1.0",
-    "ts-node": "10.9.2",
-    "typescript": "5.9.3",
-    "typescript-eslint": "8.53.0"
-  },
-  "keywords": [
-    "parser",
-    "combinator",
-    "parser-combinator",
-    "parsing",
-    "combining",
-    "functional"
-  ]
-}
+{
+  "name": "parser-combinators",
+  "version": "1.2.3",
+  "license": "ISC",
+  "maintainers": [
+    "Micha_i"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/michalusio/Parser.git"
+  },
+  "bugs": {
+    "url": "https://github.com/michalusio/Parser/issues"
+  },
+  "homepage": "https://github.com/michalusio/Parser#readme",
+  "description": "A library of parser combinators, with which you can create your own parsers. The library will be continuously improved in time.",
+  "scripts": {
+    "start": "tsc && node .",
+    "lint": "eslint src --ext .ts",
+    "build": "tsc",
+    "build-esm": "tsc --project tsconfig.esm.json",
+    "bundle": "npm run lint && npm run build && npm run build-esm",
+    "test:mutate": "stryker run",
+    "test:unit": "mocha",
+    "test": "nyc -e '.ts' --r html -r lcov -r text npm run test:unit"
+  },
+  "author": "Micha_i <isalski.michal@gmail.com> (https://github.com/michalusio)",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@stryker-mutator/core": "^9.4.0",
+    "@stryker-mutator/mocha-runner": "^9.4.0",
+    "@stryker-mutator/typescript-checker": "^9.4.0",
+    "@types/mocha": "10.0.10",
+    "@types/node": "25.0.9",
+    "cross-env": "10.1.0",
+    "esbuild": "0.27.2",
+    "eslint": "9.39.2",
+    "mocha": "11.7.5",
+    "nyc": "17.1.0",
+    "ts-node": "10.9.2",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.53.0"
+  },
+  "keywords": [
+    "parser",
+    "combinator",
+    "parser-combinator",
+    "parsing",
+    "combining",
+    "functional"
+  ],
+  "prettier": {
+    "tabWidth": 4,
+    "useTabs": false
+  }
+}