tarsec 0.1.9 → 0.2.0

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export * from "./trace.js";
 export * from "./types.js";
 export * from "./tarsecError.js";
 export * from "./position.js";
+export * from "./rightmostFailure.js";

package/dist/index.js

@@ -4,3 +4,4 @@ export * from "./trace.js";
 export * from "./types.js";
 export * from "./tarsecError.js";
 export * from "./position.js";
+export * from "./rightmostFailure.js";

package/dist/parsers.d.ts

@@ -44,6 +44,16 @@ export declare function noneOf(chars: string): Parser<string>;
  * @returns - ParserResult
  */
 export declare const anyChar: Parser<string>;
+/**
+ * Wraps a parser with a human-readable label for error reporting.
+ * On failure, suppresses any inner failure recordings and records only the label.
+ * This produces clean error messages like `expected a digit` instead of `expected one of "0123456789"`.
+ *
+ * @param name - human-readable description of what the parser expects
+ * @param parser - the parser to wrap
+ * @returns - a parser that records the label on failure
+ */
+export declare function label<T>(name: string, parser: Parser<T>): Parser<T>;
 /** A parser that matches one of " \t\n\r". */
 export declare const space: Parser<string>;
 /** A parser that matches one or more spaces. */

package/dist/parsers.js

@@ -1,5 +1,6 @@
 import { many1WithJoin, manyWithJoin, seq } from "./combinators.js";
 import { trace } from "./trace.js";
+import { recordFailure, saveRightmostFailure, restoreRightmostFailure } from "./rightmostFailure.js";
 import { captureSuccess, failure, success, } from "./types.js";
 import { escape } from "./utils.js";
 export { within } from "./parsers/within.js";
@@ -12,15 +13,13 @@ export { within } from "./parsers/within.js";
 export function char(c) {
     return trace(`char(${escape(c)})`, (input) => {
         if (input.length === 0) {
-            return {
-                success: false,
-                rest: input,
-                message: "unexpected end of input",
-            };
+            recordFailure(input, `"${c}"`);
+            return failure("unexpected end of input", input);
         }
         if (input[0] === c) {
             return success(c, input.slice(1));
         }
+        recordFailure(input, `"${c}"`);
         return failure(`expected ${escape(c)}, got ${escape(input[0])}`, input);
     });
 }
@@ -35,6 +34,7 @@ export function str(s) {
         if (input.substring(0, s.length) === s) {
             return success(s, input.slice(s.length));
         }
+        recordFailure(input, `"${s}"`);
         return failure(`expected ${s}, got ${input.substring(0, s.length)}`, input);
     });
 }
@@ -48,6 +48,7 @@ export function istr(s) {
         if (input.substring(0, s.length).toLocaleLowerCase() === s.toLocaleLowerCase()) {
             return success(input.substring(0, s.length), input.slice(s.length));
         }
+        recordFailure(input, `"${s}"`);
         return failure(`expected ${s}, got ${input.substring(0, s.length)}`, input);
     });
 }
@@ -61,12 +62,14 @@ export function istr(s) {
 export function oneOf(chars) {
     return trace(`oneOf(${escape(chars)})`, (input) => {
         if (input.length === 0) {
+            recordFailure(input, `one of "${chars}"`);
             return failure("unexpected end of input", input);
         }
         const c = input[0];
         if (chars.includes(c)) {
             return char(c)(input);
         }
+        recordFailure(input, `one of "${chars}"`);
         return failure(`expected one of ${escape(chars)}, got ${c}`, input);
     });
 }
@@ -80,9 +83,11 @@ export function oneOf(chars) {
 export function noneOf(chars) {
     return trace(`noneOf(${escape(chars)})`, (input) => {
         if (input.length === 0) {
+            recordFailure(input, `none of "${chars}"`);
             return failure("unexpected end of input", input);
         }
         if (chars.includes(input[0])) {
+            recordFailure(input, `none of "${chars}"`);
             return failure(`expected none of ${escape(chars)}, got ${input[0]}`, input);
         }
         return char(input[0])(input);
@@ -97,26 +102,46 @@ export function noneOf(chars) {
  */
 export const anyChar = trace("anyChar", (input) => {
     if (input.length === 0) {
+        recordFailure(input, "any character");
         return failure("unexpected end of input", input);
     }
     return success(input[0], input.slice(1));
 });
+/**
+ * Wraps a parser with a human-readable label for error reporting.
+ * On failure, suppresses any inner failure recordings and records only the label.
+ * This produces clean error messages like `expected a digit` instead of `expected one of "0123456789"`.
+ *
+ * @param name - human-readable description of what the parser expects
+ * @param parser - the parser to wrap
+ * @returns - a parser that records the label on failure
+ */
+export function label(name, parser) {
+    return (input) => {
+        const saved = saveRightmostFailure();
+        const result = parser(input);
+        restoreRightmostFailure(saved);
+        if (!result.success)
+            recordFailure(input, name);
+        return result;
+    };
+}
 /** A parser that matches one of " \t\n\r". */
-export const space = oneOf(" \t\n\r");
+export const space = label("whitespace", oneOf(" \t\n\r"));
 /** A parser that matches one or more spaces. */
 export const spaces = many1WithJoin(space);
 /** A parser that matches one digit. */
-export const digit = oneOf("0123456789");
+export const digit = label("a digit", oneOf("0123456789"));
 /** A parser that matches one letter, case insensitive. */
-export const letter = oneOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
+export const letter = label("a letter", oneOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"));
 /** A parser that matches one digit or letter, case insensitive. */
-export const alphanum = oneOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
+export const alphanum = label("a letter or digit", oneOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"));
 /** A parser that matches one word, case insensitive. */
-export const word = regexParser("^[a-z]+", "ui");
+export const word = label("a word", regexParser("^[a-z]+", "ui"));
 /** A parser that matches one or more digits. */
-export const num = regexParser("^[0-9]+");
+export const num = label("a number", regexParser("^[0-9]+"));
 /** A parser that matches one single or double quote. */
-export const quote = oneOf(`'"`);
+export const quote = label("a quote", oneOf(`'"`));
 /** A parser that matches one tab character. */
 export const tab = char("\t");
 /** A parser that matches one newline ("\n" only) character. */
@@ -126,6 +151,7 @@ export const eof = (input) => {
     if (input === "") {
         return success(null, input);
     }
+    recordFailure(input, "end of input");
     return failure("expected end of input", input);
 };
 /** A parser that matches a quoted string, in single or double quotes.
@@ -154,6 +180,7 @@ export function regexParser(str, options = "") {
         if (match) {
             return success(match[0], input.slice(match[0].length));
         }
+        recordFailure(input, `${str}`);
         return failure(`expected ${str}, got ${input.slice(0, 10)}`, input);
     });
 }
@@ -187,6 +214,7 @@ export function captureRegex(str, options = "", ...captureNames) {
             const captures = Object.assign({}, Object.fromEntries(match.slice(1).map((value, index) => [captureNames[index], value])));
             return success(captures, input.slice(match[0].length));
         }
+        recordFailure(input, `${str}`);
         return failure(`expected ${str}, got ${input.slice(0, 10)}`, input);
     };
     return trace(`captureRegex(${str})`, _parser);

package/dist/rightmostFailure.d.ts

@@ -0,0 +1,32 @@
+export declare function resetRightmostFailure(): void;
+/**
+ * Record an expected alternative at the current failure position.
+ * If this position is further right than any previous failure, it replaces the previous.
+ * If it's at the same position, it adds to the list of expectations (with dedup).
+ * No-op if `setInputStr` has not been called.
+ *
+ * @param input - the remaining input at the point of failure
+ * @param expected - a human-readable description of what was expected
+ */
+export declare function recordFailure(input: string, expected: string): void;
+/**
+ * Returns the current rightmost failure position and expected alternatives,
+ * or `null` if no failures have been recorded.
+ */
+export declare function getRightmostFailure(): {
+    pos: number;
+    expected: string[];
+} | null;
+type SavedRightmostFailure = {
+    pos: number;
+    expected: string[];
+};
+export declare function saveRightmostFailure(): SavedRightmostFailure;
+export declare function restoreRightmostFailure(saved: SavedRightmostFailure): void;
+/**
+ * Formats the rightmost failure into a human-readable error message with line and column info.
+ * Returns `null` if no failures have been recorded.
+ * Requires `setInputStr` to have been called.
+ */
+export declare function getErrorMessage(): string | null;
+export {};

package/dist/rightmostFailure.js

@@ -0,0 +1,70 @@
+import { getInputStr } from "./trace.js";
+import { buildLineTable, offsetToPosition } from "./position.js";
+let rightmostFailurePos = -1;
+let rightmostFailureExpected = [];
+export function resetRightmostFailure() {
+    rightmostFailurePos = -1;
+    rightmostFailureExpected = [];
+}
+/**
+ * Record an expected alternative at the current failure position.
+ * If this position is further right than any previous failure, it replaces the previous.
+ * If it's at the same position, it adds to the list of expectations (with dedup).
+ * No-op if `setInputStr` has not been called.
+ *
+ * @param input - the remaining input at the point of failure
+ * @param expected - a human-readable description of what was expected
+ */
+export function recordFailure(input, expected) {
+    const source = getInputStr();
+    if (source.length === 0)
+        return;
+    const pos = source.length - input.length;
+    if (pos > rightmostFailurePos) {
+        rightmostFailurePos = pos;
+        rightmostFailureExpected = [expected];
+    }
+    else if (pos === rightmostFailurePos) {
+        if (!rightmostFailureExpected.includes(expected)) {
+            rightmostFailureExpected.push(expected);
+        }
+    }
+}
+/**
+ * Returns the current rightmost failure position and expected alternatives,
+ * or `null` if no failures have been recorded.
+ */
+export function getRightmostFailure() {
+    if (rightmostFailurePos < 0)
+        return null;
+    return { pos: rightmostFailurePos, expected: [...rightmostFailureExpected] };
+}
+export function saveRightmostFailure() {
+    return { pos: rightmostFailurePos, expected: [...rightmostFailureExpected] };
+}
+export function restoreRightmostFailure(saved) {
+    rightmostFailurePos = saved.pos;
+    rightmostFailureExpected = [...saved.expected];
+}
+function formatExpected(expected) {
+    if (expected.length === 1)
+        return expected[0];
+    if (expected.length === 2)
+        return `${expected[0]} or ${expected[1]}`;
+    return expected.slice(0, -1).join(", ") + ", or " + expected[expected.length - 1];
+}
+/**
+ * Formats the rightmost failure into a human-readable error message with line and column info.
+ * Returns `null` if no failures have been recorded.
+ * Requires `setInputStr` to have been called.
+ */
+export function getErrorMessage() {
+    if (rightmostFailurePos < 0)
+        return null;
+    const source = getInputStr();
+    const lineTable = buildLineTable(source);
+    const pos = offsetToPosition(lineTable, rightmostFailurePos);
+    const line = pos.line + 1;
+    const column = pos.column + 1;
+    return `Line ${line}, col ${column}: expected ${formatExpected(rightmostFailureExpected)}`;
+}

package/dist/trace.js

@@ -1,6 +1,7 @@
 import { escape, round, shorten } from "./utils.js";
 import process from "process";
 import { execSync } from "child_process";
+import { resetRightmostFailure } from "./rightmostFailure.js";
 const isNode = typeof process !== "undefined" &&
     process.versions != null &&
     process.versions.node != null;
@@ -194,6 +195,7 @@ let inputStr = "";
  */
 export function setInputStr(s) {
     inputStr = s;
+    resetRightmostFailure();
 }
 export function getInputStr() {
     return inputStr;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tarsec",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "A parser combinator library for TypeScript, inspired by Parsec.",
   "homepage": "https://github.com/egonSchiele/tarsec",
   "scripts": {