tarsec 0.0.14 → 0.0.16

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./parsers";
-export * from "./combinators";
-export * from "./trace";
-export * from "./types";
+export * from "./parsers.js";
+export * from "./combinators.js";
+export * from "./trace.js";
+export * from "./types.js";

package/dist/index.js

@@ -1,30 +1,4 @@
-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);
-};
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./parsers", "./combinators", "./trace", "./types"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    __exportStar(require("./parsers"), exports);
-    __exportStar(require("./combinators"), exports);
-    __exportStar(require("./trace"), exports);
-    __exportStar(require("./types"), exports);
-});
+export * from "./parsers.js";
+export * from "./combinators.js";
+export * from "./trace.js";
+export * from "./types.js";

package/dist/parsers/within.d.ts

@@ -1,2 +1,2 @@
-import { WithinResult, Parser } from "../types";
+import { WithinResult, Parser } from "../types.js";
 export declare function within(parser: Parser<string>): Parser<WithinResult[]>;

package/dist/parsers/within.js

@@ -1,51 +1,37 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../trace", "../types"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.within = void 0;
-    const trace_1 = require("../trace");
-    const types_1 = require("../types");
-    function within(parser) {
-        return (0, trace_1.trace)("within", (input) => {
-            let start = 0;
-            let current = 0;
-            const results = [];
-            while (current < input.length) {
-                const parsed = parser(input.slice(current));
-                if (parsed.success) {
-                    const unmatchedValue = input.slice(start, current);
-                    if (unmatchedValue.length > 0) {
-                        results.push({
-                            type: "unmatched",
-                            value: unmatchedValue,
-                        });
-                    }
+import { trace } from "../trace.js";
+import { success } from "../types.js";
+export function within(parser) {
+    return trace("within", (input) => {
+        let start = 0;
+        let current = 0;
+        const results = [];
+        while (current < input.length) {
+            const parsed = parser(input.slice(current));
+            if (parsed.success) {
+                const unmatchedValue = input.slice(start, current);
+                if (unmatchedValue.length > 0) {
                     results.push({
-                        type: "matched",
-                        value: parsed.result,
+                        type: "unmatched",
+                        value: unmatchedValue,
                     });
-                    current += parsed.result.length;
-                    start = current;
                 }
-                else {
-                    current += 1;
-                }
-            }
-            if (start < current) {
                 results.push({
-                    type: "unmatched",
-                    value: input.slice(start, current),
+                    type: "matched",
+                    value: parsed.result,
                 });
+                current += parsed.result.length;
+                start = current;
+            }
+            else {
+                current += 1;
             }
-            return (0, types_1.success)(results, "");
-        });
-    }
-    exports.within = within;
-});
+        }
+        if (start < current) {
+            results.push({
+                type: "unmatched",
+                value: input.slice(start, current),
+            });
+        }
+        return success(results, "");
+    });
+}

package/dist/parsers.d.ts

@@ -1,5 +1,5 @@
-import { Parser } from "./types";
-export { within as betweenWithin } from "./parsers/within";
+import { CaptureParser, Parser, Prettify } from "./types.js";
+export { within as betweenWithin } from "./parsers/within.js";
 /**
  * Takes a character. Returns a parser that parses that character.
  *
@@ -80,3 +80,133 @@ export declare const quotedString: Parser<string>;
  * @returns - parser that matches the given regex
  */
 export declare function regexParser(str: string | RegExp, options?: string): Parser<string>;
+/**
+ * Like `regexParser`, but you can name your capture groups
+ * and get them back as the result instead.
+ * Fails if it doesn't have the same number of names as capture groups.
+ *
+ * @param str - regex string or RegExp instance to match
+ * @param options - string of regex options (i = ignore case, g = global, m = multiline, u = unicode)
+ * @param captureNames - names of the captures
+ * @returns - parser that matches the given regex
+ */
+export declare function captureRegex<const T extends string[]>(str: string | RegExp, options?: string, ...captureNames: T): Parser<Prettify<Record<(typeof captureNames)[number], string>>>;
+/**
+ * Return a parser that takes a key and a value.
+ * The parser consumes no input and always succeeds,
+ * and returns `null` as the result. It also returns a captures object
+ * with that key-value pair set. This is useful when you need to inject
+ * a key-value pair into captures for a `seq`.
+ *
+ * For example, here is a Markdown heading parser.
+
+ * ```ts
+ * export const headingParser: Parser<Heading> = seqC(
+ *   capture(count(char("#")), "level"),
+ *   spaces,
+ *   capture(many1Till(or(char("\n"), eof)), "content")
+ * );
+```
+ *
+ * This parser returns
+ *
+ * ```ts
+ * {
+ *   level: number,
+ *   content: string
+ * }
+ * ```
+ * but the type of heading is actually
+ *
+ * ```ts
+ * type Heading = {
+ *   type: "heading";
+ *   level: number;
+ *   content: string;
+ * };
+ * ```
+ *
+ * The `type` key is missing. You can use `set` to inject the `type`
+ * key-value pair into captures:
+ *
+ * ```ts
+ * export const headingParser: Parser<Heading> = seqC(
+ *   set("type", "heading"),
+ *   capture(count(char("#")), "level"),
+ *   spaces,
+ *   capture(many1Till(or(char("\n"), eof)), "content")
+ * );
+ * ```
+ *
+ * @param key - key to set on captures object
+ * @param value - value to set on captures object
+ * @returns
+ */
+export declare function set<const K extends string, const V>(key: K, value: V): CaptureParser<null, Record<K, V>>;
+/**
+ * A parser that always succeeds with the given value.
+ * @param value - value to succeed with
+ * @returns value
+ */
+export declare function succeed<T, I = string>(value: T): Parser<T>;
+/**
+ * A parser that always fails with the given message.
+ * @param message - message to fail with
+ * @returns failure
+ */
+export declare function fail<I = string>(message: string): Parser<never>;
+/**
+ * Takes a string. Succeeds if the given input contains that string.
+ * Consumes no input.
+ *
+ * @param substr - substring to find
+ * @returns - parser that succeeds if the given input contains that string
+ */
+export declare function includes<const S extends string>(substr: S): Parser<S>;
+/**
+ * Like `includes`, but case-insensitive.
+ *
+ * @param substr - substring to find
+ * @returns - parser that succeeds if the given input contains that string
+ */
+export declare function iIncludes<const S extends string>(substr: S): Parser<S>;
+/**
+ * Returns a parser that takes some input, runs the transformer function over it,
+ * and returns the result as `rest`, so it can be chained to another parser.
+ * It always returns null as its result. Always succeeds.
+ *
+ * `shape` is useful for modifying the user's input before running parsers over it.
+ * For example, here is a parser that takes in a chapter
+ * and checks that its title starts with "Once upon a time"
+ *
+ * ```ts
+ * const parser = seqR(
+ * shape((c: Chapter) => c.title),
+ *   istr("Once upon a time"),
+ *   )
+ * );
+ * ```
+ *
+ * Now you might be thinking, why not just use the chapter's title as input?
+ * `shape` is most useful when you want to parse multiple properties.
+ *
+ * ```ts
+ * const titleParser = seqR(
+ *   shape((c: Chapter) => c.title),
+ *   istr("Once upon a time"),
+ * );
+ *
+ * const textParser = seqR(
+ *   shape((c: Chapter) => c.text),
+ *   istr("There was a princess"),
+ * );
+ *
+ * const parser = and(titleParser, textParser);
+ * ```
+ *
+ * `parser` now takes a chapter as input and parses its title and text correctly.
+ *
+ * @param transformer - function to transform the input
+ * @returns a parser that takes some input and runs the transformer function over it
+ */
+export declare function shape<const X, const I>(transformer: (item: X) => I): Parser<null>;