@cornjs/parser 0.11.0

package/README.md

@@ -0,0 +1,19 @@
+# Corn.JS
+
+Native Typescript implementation of the Corn parser.
+
+This is compliant with the (currently unfinished) v0.11 spec.
+
+>![NOTE]
+> Not yet published to NPM.
+
+Usage:
+
+```ts
+import { parse } from '<TBD>';
+
+const corn = "{ let $foo = 42 } in { value = $foo }";
+const res = parse(corn);
+
+if(res.ok) console.log(res.value); // { value: 42 }
+```

package/dist/evaluator.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Evaluator = void 0;
+const utils_1 = require("./utils");
+const dedent_1 = __importDefault(require("dedent"));
+class Evaluator {
+    inputs = {};
+    evaluate(rule) {
+        if (rule.assignBlock) {
+            const res = this.evaluateAssignBlock(rule.assignBlock);
+            if (!res.ok)
+                return res;
+        }
+        const obj = this.evaluateObject(rule.object);
+        if (!obj.ok)
+            return obj;
+        return (0, utils_1.ok)(obj.value);
+    }
+    evaluateAssignBlock(rule) {
+        for (const pair of rule.assignments) {
+            const value = this.evaluateValue(pair.value);
+            if (!value.ok)
+                return value;
+            this.inputs[pair.key] = value.value;
+        }
+        return (0, utils_1.ok)(undefined);
+    }
+    evaluateObject(rule) {
+        const obj = {};
+        for (const pair of rule.pairs) {
+            switch (pair.type) {
+                case "pair": {
+                    const value = this.evaluateValue(pair.value);
+                    if (!value.ok)
+                        return value;
+                    const res = this.addAtPath(obj, pair.path.value, value.value);
+                    if (!res.ok)
+                        return res;
+                    break;
+                }
+                case "spread": {
+                    const value = this.evaluateInput(pair);
+                    if (!value.ok)
+                        return value;
+                    if (!(0, utils_1.isObject)(value.value))
+                        return (0, utils_1.err)(`input is not an object: ${pair.value}`);
+                    for (const key in value.value) {
+                        obj[key] = value.value[key];
+                    }
+                    break;
+                }
+                default:
+                    (0, utils_1.assertNever)(pair);
+            }
+        }
+        return (0, utils_1.ok)(obj);
+    }
+    addAtPath(obj, path, value) {
+        for (let i = 0; i < path.length; i++) {
+            const key = path[i];
+            if (i === path.length - 1) {
+                obj[key] = value;
+                break;
+            }
+            const existingObject = obj[key];
+            if (existingObject === undefined) {
+                obj[key] = {};
+            }
+            else if (!(0, utils_1.isObject)(existingObject)) {
+                return (0, utils_1.err)(`expected object at path ${path.slice(0, i + 1).join(".")}`);
+            }
+            obj = obj[key];
+        }
+        return (0, utils_1.ok)(undefined);
+    }
+    evaluateArray(rule) {
+        const array = [];
+        for (const value of rule.values) {
+            switch (value.type) {
+                case "spread": {
+                    const inputVal = this.evaluateInput(value);
+                    if (!inputVal.ok)
+                        return inputVal;
+                    if (!Array.isArray(inputVal.value))
+                        return (0, utils_1.err)(`input is not an array: ${value.value}`);
+                    array.push(...inputVal.value);
+                    break;
+                }
+                default: {
+                    const val = this.evaluateValue(value);
+                    if (!val.ok)
+                        return val;
+                    array.push(val.value);
+                }
+            }
+        }
+        return (0, utils_1.ok)(array);
+    }
+    evaluateString(rule) {
+        const result = [];
+        for (const part of rule.value) {
+            switch (part.type) {
+                case "charSequence":
+                case "charEscape":
+                    result.push(part.value);
+                    break;
+                case "unicodeEscape": {
+                    const MAX = 0x10ffff;
+                    if (part.value > MAX) {
+                        return (0, utils_1.err)("invalid code point");
+                    }
+                    result.push(String.fromCodePoint(part.value));
+                    break;
+                }
+                case "input": {
+                    const value = this.evaluateInput(part);
+                    if (!value.ok)
+                        return value;
+                    if (typeof value.value !== "string")
+                        return (0, utils_1.err)(`input is not a string: ${part.value}`);
+                    result.push(...value.value);
+                    break;
+                }
+                default:
+                    (0, utils_1.assertNever)(part);
+            }
+        }
+        let str = result.join("");
+        if (str.includes("\n")) {
+            str = this.trimMultilineString(str);
+        }
+        return (0, utils_1.ok)(str);
+    }
+    trimMultilineString(str) {
+        if (str.startsWith("\r")) {
+            str = str.slice(1);
+        }
+        if (str.startsWith("\n")) {
+            str = str.slice(1);
+        }
+        return dedent_1.default.withOptions({ trimWhitespace: false })(str);
+    }
+    evaluateValue(rule) {
+        switch (rule.type) {
+            case "boolean":
+            case "integer":
+            case "float":
+                return (0, utils_1.ok)(rule.value);
+            case "input":
+                return this.evaluateInput(rule);
+            case "string":
+                return this.evaluateString(rule);
+            case "array":
+                return this.evaluateArray(rule);
+            case "object":
+                return this.evaluateObject(rule);
+            case "null":
+                return (0, utils_1.ok)(null);
+            default:
+                (0, utils_1.assertNever)(rule);
+        }
+    }
+    evaluateInput(rule) {
+        let value;
+        if (rule.value.startsWith("$env_")) {
+            value = process.env[rule.value.slice("$env_".length)];
+        }
+        if (!value) {
+            value = this.inputs[rule.value];
+        }
+        if (!value)
+            return (0, utils_1.err)(`input not found: ${rule.value}`);
+        return (0, utils_1.ok)(value);
+    }
+}
+exports.Evaluator = Evaluator;

package/dist/evaluator.test.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const glob_1 = require("glob");
+const evaluator_1 = require("./evaluator");
+const lexer_1 = require("./lexer");
+const parser_1 = require("./parser");
+const index_1 = require("./index");
+const positiveCases = glob_1.glob
+    .sync("test-suite/corn/**/*.pos.corn")
+    .map((p) => p.replaceAll("\\", "/"));
+const negativeCases = glob_1.glob
+    .sync("test-suite/corn/**/*.neg.corn")
+    .map((p) => p.replaceAll("\\", "/"));
+function makeTree(cases) {
+    const testGroups = {};
+    cases.forEach(function (path) {
+        path
+            .replace("test-suite/corn/", "")
+            .split("/")
+            .reduce((group, section, i, arr) => {
+            if (i === arr.length - 1) {
+                group[section.replace(".pos.corn", "").replace(".neg.corn", "")] =
+                    path;
+                return group;
+            }
+            if (!group[section]) {
+                group[section] = {};
+            }
+            return group[section];
+        }, testGroups);
+    });
+    return testGroups;
+}
+function positiveTest(key, value) {
+    const jsonPath = value
+        .replace("/corn/", "/json/")
+        .replace(".pos.corn", ".json");
+    const corn = fs_1.default.readFileSync(value, "utf-8").replaceAll("\r\n", "\n"); // CRLF --> LF, thanks Windows
+    const jsonFile = fs_1.default.readFileSync(jsonPath, "utf-8");
+    const json = JSON.parse(jsonFile);
+    test(key, () => {
+        const result = (0, index_1.parse)(corn);
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+            return;
+        expect(result.value).toEqual(json);
+    });
+}
+function negativeTest(key, value) {
+    const corn = fs_1.default.readFileSync(value, "utf-8").replaceAll("\r\n", "\n"); // CRLF --> LF, thanks Windows
+    test(key, () => {
+        let hasErr = false;
+        let err;
+        const tokens = new lexer_1.Lexer().tokenizeInput(corn);
+        if (!tokens.ok) {
+            hasErr = true;
+            err = tokens.error;
+        }
+        else {
+            const ast = (0, parser_1.parseTokens)(tokens.value.map((t) => t.token));
+            if (!ast.ok) {
+                hasErr = true;
+                err = ast.error;
+            }
+            else {
+                const evaluator = new evaluator_1.Evaluator();
+                const result = evaluator.evaluate(ast.value);
+                if (!result.ok) {
+                    hasErr = true;
+                    err = result.error;
+                }
+            }
+        }
+        console.log(err);
+        expect(hasErr).toBe(true);
+    });
+}
+function evaluate(group, tester) {
+    for (const key in group) {
+        const value = group[key];
+        if (typeof value === "object") {
+            describe(key, () => {
+                evaluate(value, tester);
+            });
+        }
+        else {
+            tester(key, value);
+        }
+    }
+}
+describe("positive", () => evaluate(makeTree(positiveCases), positiveTest));
+describe("negative", () => evaluate(makeTree(negativeCases), negativeTest));

package/dist/index.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = parse;
+const lexer_1 = require("./lexer");
+const parser_1 = require("./parser");
+const evaluator_1 = require("./evaluator");
+const utils_1 = require("./utils");
+/**
+ * Parses the provided corn string
+ * into an object.
+ *
+ * @typeParam T output object type
+ * @param corn input string
+ * @returns result containing output object on success,
+ * or error variant on any failure.
+ */
+function parse(corn) {
+    // strip bom
+    if (corn.charCodeAt(0) === 0xfeff) {
+        corn = corn.slice(1);
+    }
+    const lexer = new lexer_1.Lexer();
+    const tokensRes = lexer.tokenizeInput(corn);
+    if (!tokensRes.ok)
+        return (0, utils_1.err)(tokensRes.error);
+    const tokens = tokensRes.value;
+    const astRes = (0, parser_1.parseTokens)(tokens.map((t) => t.token));
+    if (!astRes.ok)
+        return (0, utils_1.err)(astRes.error);
+    const ast = astRes.value;
+    const evaluator = new evaluator_1.Evaluator();
+    return evaluator.evaluate(ast);
+}
+/* ---- */
+// import fs from "fs";
+// const input = fs
+//   .readFileSync("test-suite/corn/input/basic.pos.corn", "utf-8");
+//
+// console.log(input);
+//
+// const tokens = new Lexer().tokenizeInput(input);
+//
+// if(!tokens.ok) {
+//   console.error(tokens.error);
+//   process.exit(1);
+// }
+//
+// console.log('TOKENS', tokens.value);
+//
+// console.log("\n---------------\n");
+//
+// const ast = parseTokens(tokens.value.map(t => t.token));
+//
+// if(!ast.ok) {
+//   console.error(ast.error);
+//   process.exit(1);
+// }
+//
+// console.log("\nAST:");
+// console.dir(ast.value, { depth: null });
+//
+// console.log("\n---------------\n");
+//
+// const obj = new Evaluator().evaluate(ast.value);
+//
+// if(!obj.ok) {
+//   console.error(obj.error);
+//   process.exit(1);
+// }
+//
+// console.log("\nOBJ:");
+// console.dir(obj.value, { depth: null });

package/dist/lexer.js

@@ -0,0 +1,634 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lexer = void 0;
+const utils_1 = require("./utils");
+const WHITESPACE = "\n\r\t ";
+class Lexer {
+    row = 0;
+    col = 0;
+    MATCHERS = {
+        [0 /* State.TopLevel */]: [
+            createMatcher(this.matchLiteral("{"), {
+                action: "push",
+                state: 3 /* State.Object */,
+            }),
+            createMatcher(this.matchLiteral("let"), {
+                action: "push",
+                state: 1 /* State.AssignBlock */,
+            }),
+        ],
+        [1 /* State.AssignBlock */]: [
+            createMatcher(this.matchLiteral("in"), { action: "pop" }),
+            createMatcher(this.matchLiteral("{")),
+            createMatcher(this.matchLiteral("}")),
+            createMatcher(this.matchInput.bind(this)),
+            createMatcher(this.matchLiteral("="), {
+                action: "push",
+                state: 2 /* State.Value */,
+            }),
+        ],
+        [2 /* State.Value */]: [
+            createMatcher(this.matchLiteral("{"), {
+                action: "replace",
+                state: 3 /* State.Object */,
+            }),
+            createMatcher(this.matchLiteral("["), {
+                action: "replace",
+                state: 4 /* State.Array */,
+            }),
+            createMatcher(this.matchLiteral("true"), { action: "pop" }, [
+                ...WHITESPACE,
+                "}",
+            ]),
+            createMatcher(this.matchLiteral("false"), { action: "pop" }, [
+                ...WHITESPACE,
+                "}",
+            ]),
+            createMatcher(this.matchLiteral("null"), { action: "pop" }, [
+                ...WHITESPACE,
+                "}",
+            ]),
+            createMatcher(this.matchLiteral('"'), {
+                action: "replace",
+                state: 5 /* State.String */,
+            }),
+            createMatcher(this.matchInput.bind(this), { action: "pop" }, [
+                ...WHITESPACE,
+                "}",
+            ]),
+            createMatcher(this.matchFloat.bind(this), { action: "pop" }, [
+                ...WHITESPACE,
+                "}",
+            ]),
+            createMatcher(this.matchInteger.bind(this), { action: "pop" }, [
+                ...WHITESPACE,
+                "}",
+            ]),
+            createMatcher(this.matchLiteral("]"), { action: "pop" }),
+        ],
+        [3 /* State.Object */]: [
+            createMatcher(this.matchLiteral("}"), { action: "pop" }),
+            createMatcher(this.matchLiteral("="), {
+                action: "push",
+                state: 2 /* State.Value */,
+            }),
+            createMatcher(this.matchLiteral("..")),
+            createMatcher(this.matchLiteral(".")),
+            createMatcher(this.matchInput.bind(this)),
+            createMatcher(this.matchQuotedPathSegment.bind(this)),
+            createMatcher(this.matchPathSegment.bind(this)),
+        ],
+        [4 /* State.Array */]: [
+            createMatcher(this.matchLiteral("]"), { action: "pop" }),
+            createMatcher(this.matchLiteral("{"), {
+                action: "push",
+                state: 3 /* State.Object */,
+            }),
+            createMatcher(this.matchLiteral("["), {
+                action: "push",
+                state: 4 /* State.Array */,
+            }),
+            createMatcher(this.matchLiteral('"'), {
+                action: "push",
+                state: 5 /* State.String */,
+            }),
+            createMatcher(this.matchLiteral("..")),
+            createMatcher(this.matchLiteral("true"), undefined, [...WHITESPACE, "]"]),
+            createMatcher(this.matchLiteral("false"), undefined, [
+                ...WHITESPACE,
+                "]",
+            ]),
+            createMatcher(this.matchLiteral("null"), undefined, [...WHITESPACE, "]"]),
+            createMatcher(this.matchInput.bind(this), undefined, [
+                ...WHITESPACE,
+                "]",
+            ]),
+            createMatcher(this.matchFloat.bind(this), undefined, [
+                ...WHITESPACE,
+                "]",
+            ]),
+            createMatcher(this.matchInteger.bind(this), undefined, [
+                ...WHITESPACE,
+                "]",
+            ]),
+        ],
+        [5 /* State.String */]: [
+            createMatcher(this.matchLiteral('"'), { action: "pop" }),
+            createMatcher(this.matchInterpolatedInput.bind(this)),
+            createMatcher(this.matchCharEscape.bind(this)),
+            createMatcher(this.matchCharSequence.bind(this)),
+        ],
+    };
+    tokenizeInput(inputString) {
+        const input = inputString.split("");
+        const tokens = [];
+        const state = [0 /* State.TopLevel */];
+        while (input.length > 0) {
+            const currLength = input.length;
+            const currentState = state[state.length - 1];
+            const char = input[0];
+            if (!char)
+                return (0, utils_1.err)({
+                    message: "lexer error - expected char",
+                    span: this.getAbsoluteSpan({ startCol: 0, endCol: 0, endRow: 0 }),
+                });
+            if (currentState !== 5 /* State.String */ && WHITESPACE.includes(char)) {
+                if (char === "\n") {
+                    this.row++;
+                    this.col = 0;
+                }
+                else {
+                    this.col++;
+                }
+                input.shift();
+                continue;
+            }
+            if (currentState !== 5 /* State.String */ && take(input, "/", "/")) {
+                takeWhile(input, (char) => char !== "\n");
+                continue;
+            }
+            const matchers = this.MATCHERS[currentState];
+            let hasMatch = false;
+            for (const matcher of matchers) {
+                const match = matcher.func(input);
+                if (!match.ok)
+                    return match;
+                if (!match.value)
+                    continue;
+                hasMatch = true;
+                tokens.push(match.value);
+                this.setSpan(match.value.span);
+                switch (matcher.stateChange.action) {
+                    case "push":
+                        state.push(matcher.stateChange.state);
+                        break;
+                    case "replace":
+                        state[state.length - 1] = matcher.stateChange.state;
+                        break;
+                    case "pop":
+                        state.pop();
+                        break;
+                    case "none":
+                        break;
+                    default:
+                        (0, utils_1.assertNever)(matcher.stateChange);
+                }
+                // some tokens cannot be next to other tokens
+                // (for example, to prevent `[truefalsenull]` in an array).
+                if (matcher.requiredChars.length) {
+                    const nextChar = input[0];
+                    if (!matcher.requiredChars.includes(nextChar)) {
+                        return (0, utils_1.err)({
+                            message: `expected whitespace after ${match.value.token.type}`,
+                            span: match.value.span,
+                        });
+                    }
+                }
+                break;
+            }
+            if (!hasMatch) {
+                return (0, utils_1.err)({
+                    message: `Unexpected token: ${char}`,
+                    span: this.getAbsoluteSpan({
+                        startCol: 0,
+                        endCol: 1,
+                        endRow: 0,
+                    }),
+                });
+            }
+            if (input.length === currLength) {
+                throw new Error(`no match for char ${char} in state ${currentState} - input length is unchanged. This is a lexer bug!`);
+            }
+        }
+        return (0, utils_1.ok)(tokens);
+    }
+    matchPathSegment(input) {
+        const value = takeWhile(input, (char) => !WHITESPACE.includes(char) &&
+            char !== "." &&
+            char !== "=" &&
+            char !== "'" &&
+            char !== '"');
+        if (value.length) {
+            const token = { type: "pathSegment", value: value.join("") };
+            return (0, utils_1.ok)({
+                token,
+                span: this.getAbsoluteSpan({
+                    startCol: 0,
+                    endCol: value.length,
+                    endRow: 0,
+                }),
+            });
+        }
+        return (0, utils_1.ok)(undefined);
+    }
+    matchQuotedPathSegment(input) {
+        if (!take(input, "'"))
+            return (0, utils_1.ok)(undefined);
+        let escaping = false;
+        const value = takeWhile(input, (char) => {
+            if (char === "\\")
+                escaping = true;
+            if (char === "'" && !escaping)
+                return false;
+            if (char === "'" && escaping) {
+                escaping = false;
+                return true;
+            }
+            return char !== "'";
+        });
+        if (!take(input, "'")) {
+            return (0, utils_1.err)({
+                message: "expected closing quote",
+                span: this.getAbsoluteSpan({
+                    startCol: 0,
+                    endCol: value.length,
+                    endRow: 0,
+                }),
+            });
+        }
+        const token = {
+            type: "pathSegment",
+            value: value.filter((c) => c !== "\\").join(""),
+        };
+        return (0, utils_1.ok)({
+            token,
+            span: this.getAbsoluteSpan({
+                startCol: 0,
+                endCol: value.length + 1,
+                endRow: 0,
+            }),
+        });
+    }
+    matchInteger(input) {
+        if (input.length < 2)
+            return (0, utils_1.err)({
+                message: "unexpected end of input",
+                span: this.getAbsoluteSpan({
+                    startCol: 0,
+                    endCol: 1,
+                    endRow: 0,
+                }),
+            });
+        const isNegative = take(input, "-");
+        let base = 10;
+        let matcher = utils_1.isDigit;
+        switch (true) {
+            case !!take(input, "0", "b"):
+                base = 2;
+                matcher = (char) => char === "0" || char === "1";
+                break;
+            case !!take(input, "0", "x"):
+                base = 16;
+                matcher = utils_1.isHexDigit;
+                break;
+            case !!take(input, "0", "o"):
+                base = 8;
+                matcher = (char) => char >= "0" && char <= "7";
+                break;
+        }
+        const value = [];
+        let char = input[0];
+        while (char && (matcher(char) || char === "_")) {
+            const match = takeWhile(input, matcher);
+            if (!match.length)
+                return (0, utils_1.ok)(undefined);
+            value.push(...match);
+            char = input[0];
+            take(input, "_");
+        }
+        if (value.length) {
+            let num = Number.parseInt(value.join(""), base);
+            if (!Number.isSafeInteger(num)) {
+                return (0, utils_1.err)({
+                    message: "integer out of range",
+                    span: this.getAbsoluteSpan({
+                        startCol: 0,
+                        endCol: value.length,
+                        endRow: 0,
+                    }),
+                });
+            }
+            if (Number.isNaN(num))
+                return (0, utils_1.err)({
+                    message: "invalid integer",
+                    span: this.getAbsoluteSpan({
+                        startCol: 0,
+                        endCol: value.length,
+                        endRow: 0,
+                    }),
+                });
+            if (isNegative)
+                num *= -1;
+            const token = { type: "integer", value: num };
+            return (0, utils_1.ok)({
+                token,
+                span: this.getAbsoluteSpan({
+                    startCol: 0,
+                    endCol: value.length,
+                    endRow: 0,
+                }),
+            });
+        }
+        return (0, utils_1.ok)(undefined);
+    }
+    matchFloat(input) {
+        if (input.length < 2) {
+            return (0, utils_1.err)({
+                message: "unexpected end of input",
+                span: this.getAbsoluteSpan({
+                    startCol: 0,
+                    endCol: 1,
+                    endRow: 0,
+                }),
+            });
+        }
+        const isNegative = peek(input, "-");
+        const negOffset = isNegative ? 1 : 0;
+        const intPartChars = peekWhile(input.slice(negOffset), utils_1.isDigit);
+        if (input[intPartChars.length + negOffset] !== ".")
+            return (0, utils_1.ok)(undefined);
+        input.splice(0, intPartChars.length + negOffset + 1);
+        const floatPartChars = takeWhile(input, utils_1.isDigit);
+        let exponent = "";
+        if (take(input, "e")) {
+            exponent += "e";
+            const expSign = take(input, "+") || take(input, "-");
+            if (!expSign) {
+                return (0, utils_1.err)({
+                    message: "expected one of `+` or `-`",
+                    span: this.getAbsoluteSpan({
+                        startCol: intPartChars.length + floatPartChars.length + 1,
+                        endCol: intPartChars.length + floatPartChars.length + 2,
+                        endRow: 0,
+                    }),
+                });
+            }
+            exponent += expSign;
+            const expPartChars = takeWhile(input, utils_1.isDigit);
+            exponent += expPartChars.join("");
+        }
+        const fullString = `${intPartChars.join("")}.${floatPartChars.join("")}${exponent}`;
+        let num = parseFloat(fullString);
+        if (Number.isNaN(num)) {
+            return (0, utils_1.err)({
+                message: "invalid float",
+                span: this.getAbsoluteSpan({
+                    startCol: 0,
+                    endCol: fullString.length,
+                    endRow: 0,
+                }),
+            });
+        }
+        if (isNegative)
+            num *= -1;
+        const token = { type: "float", value: num };
+        return (0, utils_1.ok)({
+            token,
+            span: this.getAbsoluteSpan({
+                startCol: 0,
+                endCol: fullString.length,
+                endRow: 0,
+            }),
+        });
+    }
+    matchInterpolatedInput(input) {
+        if (!take(input, "$", "{"))
+            return (0, utils_1.ok)(undefined);
+        const name = "$" +
+            takeWhile(input, (char) => (0, utils_1.isAlphanumeric)(char) || char === "_").join("");
+        if (!take(input, "}"))
+            return (0, utils_1.ok)(undefined);
+        const token = { type: "input", value: name };
+        return (0, utils_1.ok)({
+            token,
+            span: this.getAbsoluteSpan({
+                startCol: 0,
+                endCol: name.length + 2,
+                endRow: 0,
+            }),
+        });
+    }
+    matchCharEscape(input) {
+        if (!take(input, "\\"))
+            return (0, utils_1.ok)(undefined);
+        const span = this.getAbsoluteSpan({ startCol: 0, endCol: 2, endRow: 0 });
+        switch (input.shift()) {
+            case "n":
+                return (0, utils_1.ok)({ token: { type: "charEscape", value: "\n" }, span });
+            case "r":
+                return (0, utils_1.ok)({ token: { type: "charEscape", value: "\r" }, span });
+            case "t":
+                return (0, utils_1.ok)({ token: { type: "charEscape", value: "\t" }, span });
+            case "\\":
+                return (0, utils_1.ok)({ token: { type: "charEscape", value: "\\" }, span });
+            case '"':
+                return (0, utils_1.ok)({ token: { type: "charEscape", value: '"' }, span });
+            case "$":
+                return (0, utils_1.ok)({ token: { type: "charEscape", value: "$" }, span });
+            case "u":
+                return this.matchUnicodeEscape(input);
+            default:
+                return (0, utils_1.err)({ message: "invalid char escape", span });
+        }
+    }
+    matchUnicodeEscape(input) {
+        // since this runs effectively after charEscape,
+        // we only need to start matching from the brace.
+        const SPAN_ROW_OFFSET = 2;
+        if (!take(input, "{")) {
+            return (0, utils_1.err)({
+                message: "expected {",
+                span: this.getAbsoluteSpan({
+                    startCol: SPAN_ROW_OFFSET,
+                    endCol: SPAN_ROW_OFFSET + 1,
+                    endRow: 0,
+                }),
+            });
+        }
+        const hex = takeWhile(input, utils_1.isHexDigit);
+        if (!take(input, "}")) {
+            return (0, utils_1.err)({
+                message: "expected }",
+                span: this.getAbsoluteSpan({
+                    startCol: SPAN_ROW_OFFSET + hex.length,
+                    endCol: SPAN_ROW_OFFSET + hex.length + 1,
+                    endRow: 0,
+                }),
+            });
+        }
+        if (!hex.length) {
+            return (0, utils_1.err)({
+                message: "unicode escape cannot be empty",
+                span: this.getAbsoluteSpan({
+                    startCol: SPAN_ROW_OFFSET,
+                    endCol: SPAN_ROW_OFFSET + 2,
+                    endRow: 0,
+                }),
+            });
+        }
+        const value = parseInt(hex.join(""), 16);
+        return (0, utils_1.ok)({
+            token: { type: "unicodeEscape", value },
+            span: this.getAbsoluteSpan({
+                startCol: 0,
+                endCol: hex.length + 4,
+                endRow: 0,
+            }),
+        });
+    }
+    matchCharSequence(input) {
+        const value = takeWhile(input, (char, next) => char !== '"' && char !== "\\" && (char !== "$" || next !== "{"));
+        if (value.length) {
+            const rows = value.filter((c) => c === "\n").length;
+            const lastColumnIndex = value.lastIndexOf("\n") + 1;
+            const endColumn = value.length - lastColumnIndex;
+            const token = { type: "charSequence", value: value.join("") };
+            return (0, utils_1.ok)({
+                token: token,
+                span: this.getAbsoluteSpan({
+                    startCol: 0,
+                    endCol: endColumn,
+                    endRow: rows,
+                }),
+            });
+        }
+        return (0, utils_1.ok)(undefined);
+    }
+    matchInput(input) {
+        if (!take(input, "$"))
+            return (0, utils_1.ok)(undefined);
+        if (!(0, utils_1.isLetter)(input[0]) && input[0] !== "_")
+            return (0, utils_1.ok)(undefined);
+        const name = "$" +
+            takeWhile(input, (char) => (0, utils_1.isAlphanumeric)(char) || char === "_").join("");
+        const token = { type: "input", value: name };
+        return (0, utils_1.ok)({
+            token,
+            span: this.getAbsoluteSpan({
+                startCol: 0,
+                endCol: name.length,
+                endRow: 0,
+            }),
+        });
+    }
+    /**
+     * Returns a matcher function for a literal token.
+  
+     * @param str Literal token value.
+     * @private
+     */
+    matchLiteral(str) {
+        return (input) => {
+            if (take(input, ...str)) {
+                return (0, utils_1.ok)({
+                    token: { type: str },
+                    span: this.getAbsoluteSpan({
+                        startCol: 0,
+                        endCol: str.length,
+                        endRow: 0,
+                    }),
+                });
+            }
+            return (0, utils_1.ok)(undefined);
+        };
+    }
+    /**
+     * Applies a relative span to the current row/col
+     * to get an absolute span.
+     *
+     * @param relativeSpan
+     * @private
+     */
+    getAbsoluteSpan(relativeSpan) {
+        const endCol = relativeSpan.endRow > 1 ? 0 : this.col;
+        return {
+            startCol: this.col + relativeSpan.startCol,
+            startRow: this.row,
+            endCol: endCol + relativeSpan.endCol,
+            endRow: this.row + relativeSpan.endRow,
+        };
+    }
+    setSpan(span) {
+        this.row = span.endRow;
+        this.col = span.endCol;
+    }
+}
+exports.Lexer = Lexer;
+/**
+ * Creates a new matcher object.
+ * @param func
+ * @param stateChange
+ * @param requiredChars
+ */
+function createMatcher(func, stateChange, requiredChars = []) {
+    return {
+        func,
+        stateChange: stateChange ?? { action: "none" },
+        requiredChars,
+    };
+}
+/**
+ * Checks if the provided chars are present at the start of the input.
+ * Characters are not consumed.
+ *
+ * @param input Input chars
+ * @param chars Check chars, in order.
+ * @returns Whether chars exist at start of input.
+ */
+function peek(input, ...chars) {
+    for (let i = 0; i < chars.length; i++) {
+        if (input[i] !== chars[i])
+            return false;
+    }
+    return true;
+}
+/**
+ * Like {@link takeWhile},
+ * but does not take the characters from `input`.
+ *
+ * @param input Input chars
+ * @param predicate Check function.
+ */
+function peekWhile(input, predicate) {
+    const result = [];
+    let char = input[0];
+    let i = 0;
+    while (predicate(input[i], input[i + 1]) && i < input.length) {
+        result.push(char);
+        char = input[++i];
+    }
+    return result;
+}
+/**
+ * Attempts to take `chars` from the start of `input`.
+ * If any of `chars` is not present, returns `false` and does nothing.
+ *
+ * If all `chars` are present, they are removed from the front of `input`
+ * and returned.
+ *
+ * @param input Input chars
+ * @param chars chars to take, in order
+ * @returns taken chars, or `false`.
+ */
+function take(input, ...chars) {
+    const res = peek(input, ...chars);
+    if (res)
+        input.splice(0, chars.length);
+    return res ? chars : false;
+}
+/**
+ * Takes chars from the start of `input`
+ * for as long as `predicate` is true.
+ *
+ * The predicate function takes the current and next char,
+ * and returns a boolean.
+ *
+ * @param input Input chars.
+ * @param predicate Check function.
+ */
+function takeWhile(input, predicate) {
+    const res = peekWhile(input, predicate);
+    if (res.length)
+        input.splice(0, res.length);
+    return res;
+}

package/dist/parser.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTokens = parseTokens;
+const utils_1 = require("./utils");
+/**
+ * Attempts to parse the provided token array
+ * into an AST of rules.
+ *
+ * @param tokens The token array.
+ * @returns A result containing the AST if successfully parsed,
+ * or an error message if not.
+ */
+function parseTokens(tokens) {
+    if (tokens.length === 0)
+        return (0, utils_1.err)("no tokens");
+    const token = tokens[0];
+    let assignBlock;
+    if (token.type === "let") {
+        assignBlock = parseAssignBlock(tokens);
+        if (!assignBlock.ok)
+            return assignBlock;
+    }
+    const object = parseObject(tokens);
+    if (!object.ok)
+        return object;
+    return (0, utils_1.ok)({
+        type: "config",
+        assignBlock: assignBlock?.value,
+        object: object.value,
+    });
+}
+function parseAssignBlock(tokens) {
+    let lit = consumeLiteral(tokens, "let");
+    if (!lit.ok)
+        return lit;
+    lit = consumeLiteral(tokens, "{");
+    if (!lit.ok)
+        return lit;
+    const rule = { type: "assignBlock", assignments: [] };
+    while (tokens[0].type !== "}") {
+        const name = tokens.shift();
+        if (name?.type !== "input")
+            return (0, utils_1.err)("expected input declaration");
+        lit = consumeLiteral(tokens, "=");
+        if (!lit.ok)
+            return lit;
+        const value = parseValue(tokens);
+        if (!value.ok)
+            return value;
+        rule.assignments.push({
+            type: "assignment",
+            key: name.value,
+            value: value.value,
+        });
+    }
+    lit = consumeLiteral(tokens, "}");
+    if (!lit.ok)
+        return lit;
+    lit = consumeLiteral(tokens, "in");
+    if (!lit.ok)
+        return lit;
+    return (0, utils_1.ok)(rule);
+}
+function parseObject(tokens) {
+    let lit = consumeLiteral(tokens, "{");
+    if (!lit.ok)
+        return lit;
+    const object = { type: "object", pairs: [] };
+    let token = tokens[0];
+    while (token && token.type !== "}") {
+        switch (token.type) {
+            case "..": {
+                const spread = parseSpread(tokens);
+                if (!spread.ok)
+                    return spread;
+                object.pairs.push(spread.value);
+                break;
+            }
+            case "pathSegment": {
+                const pair = parsePair(tokens);
+                if (!pair.ok)
+                    return pair;
+                object.pairs.push(pair.value);
+                break;
+            }
+            default:
+                return (0, utils_1.err)("expected `..` or path segment, got: " + token.type);
+        }
+        token = tokens[0];
+    }
+    lit = consumeLiteral(tokens, "}");
+    if (!lit.ok)
+        return lit;
+    return (0, utils_1.ok)(object);
+}
+function parsePair(tokens) {
+    if (tokens.length < 3)
+        return (0, utils_1.err)("not enough tokens");
+    const path = parsePath(tokens);
+    if (!path.ok)
+        return path;
+    const lit = consumeLiteral(tokens, "=");
+    if (!lit.ok)
+        return lit;
+    const value = parseValue(tokens);
+    if (!value.ok)
+        return value;
+    return (0, utils_1.ok)({ type: "pair", path: path.value, value: value.value });
+}
+function parsePath(tokens) {
+    const rule = { type: "path", value: [] };
+    const token = tokens.shift();
+    if (token?.type !== "pathSegment")
+        return (0, utils_1.err)("expected path segment");
+    rule.value.push(token.value);
+    while (tokens[0].type !== "=") {
+        const lit = consumeLiteral(tokens, ".");
+        if (!lit.ok)
+            return lit;
+        const token = tokens.shift();
+        if (token?.type !== "pathSegment")
+            return (0, utils_1.err)("expected path segment");
+        rule.value.push(token.value);
+    }
+    return (0, utils_1.ok)(rule);
+}
+function parseValue(tokens) {
+    const token = tokens[0];
+    if (!token)
+        return (0, utils_1.err)("expected value");
+    switch (token.type) {
+        case "input":
+        case "integer":
+        case "float":
+            tokens.shift();
+            return (0, utils_1.ok)(token);
+        case "true":
+            tokens.shift();
+            return (0, utils_1.ok)({ type: "boolean", value: true });
+        case "false":
+            tokens.shift();
+            return (0, utils_1.ok)({ type: "boolean", value: false });
+        case "null":
+            tokens.shift();
+            return (0, utils_1.ok)({ type: "null" });
+        case '"':
+            return parseString(tokens);
+        case "{":
+            return parseObject(tokens);
+        case "[":
+            return parseArray(tokens);
+        default:
+            return (0, utils_1.err)("expected value token, got: " + token.type);
+    }
+}
+function parseString(tokens) {
+    let lit = consumeLiteral(tokens, '"');
+    if (!lit.ok)
+        return lit;
+    const rule = { type: "string", value: [] };
+    let token = tokens[0];
+    while (token && token.type !== '"') {
+        switch (token.type) {
+            case "charSequence":
+            case "charEscape":
+            case "unicodeEscape":
+            case "input":
+                tokens.shift();
+                rule.value.push(token);
+                break;
+            default:
+                return (0, utils_1.err)("expected one of {char sequence, char escape, unicode escape, input}, got: " +
+                    token.type);
+        }
+        token = tokens[0];
+    }
+    lit = consumeLiteral(tokens, '"');
+    if (!lit.ok)
+        return lit;
+    return (0, utils_1.ok)(rule);
+}
+function parseArray(tokens) {
+    let lit = consumeLiteral(tokens, "[");
+    if (!lit.ok)
+        return lit;
+    const rule = { type: "array", values: [] };
+    let token = tokens[0];
+    while (token.type !== "]") {
+        switch (token.type) {
+            case "..": {
+                const spread = parseSpread(tokens);
+                if (!spread.ok)
+                    return spread;
+                rule.values.push(spread.value);
+                break;
+            }
+            default: {
+                const value = parseValue(tokens);
+                if (!value.ok)
+                    return value;
+                rule.values.push(value.value);
+                break;
+            }
+        }
+        token = tokens[0];
+    }
+    lit = consumeLiteral(tokens, "]");
+    if (!lit.ok)
+        return lit;
+    return (0, utils_1.ok)(rule);
+}
+function parseSpread(tokens) {
+    const lit = consumeLiteral(tokens, "..");
+    if (!lit.ok)
+        return lit;
+    const input = tokens.shift();
+    if (input?.type !== "input")
+        return (0, utils_1.err)("expected input");
+    return (0, utils_1.ok)({ type: "spread", value: input.value });
+}
+/**
+ * Consumes a literal token,
+ * returning an error if is not present.
+ *
+ * @param tokens Token array
+ * @param tokenType Token to consume
+ */
+function consumeLiteral(tokens, tokenType) {
+    if (tokens.length === 0)
+        return (0, utils_1.err)("no tokens");
+    const nextToken = tokens.shift();
+    if (nextToken?.type !== tokenType) {
+        return (0, utils_1.err)(`expected '${tokenType}', got '${nextToken?.type}'`);
+    }
+    return (0, utils_1.ok)(undefined);
+}

package/dist/utils.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ok = ok;
+exports.err = err;
+exports.assertNever = assertNever;
+exports.isDigit = isDigit;
+exports.isHexDigit = isHexDigit;
+exports.isLetter = isLetter;
+exports.isAlphanumeric = isAlphanumeric;
+exports.isObject = isObject;
+/**
+ * Creates an ok (success) variant of `Result`.
+ * @param value
+ */
+function ok(value) {
+    return { ok: true, value };
+}
+/**
+ * Creates an error variant of `Result`.
+ * @param error
+ */
+function err(error) {
+    return { ok: false, error };
+}
+/**
+ * Throws an "unreachable" error if it ever runs.
+ *
+ * This is used as an exhaustive typeguard check on switch blocks,
+ * causing the type checker to error if a non-never type is passed in.
+ * @param _
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function assertNever(_) {
+    throw new Error("unreachable");
+}
+/**
+ * Determines if the given character is a numeric digit (0-9).
+ *
+ * @param {string} char - A single character to evaluate.
+ * @return {boolean} True if the character is a digit, otherwise false.
+ */
+function isDigit(char) {
+    return char.charCodeAt(0) >= 48 && char.charCodeAt(0) <= 57;
+}
+/**
+ * Determines if the given character is a hex digit (0-F), case-insensitive.
+ *
+ * @param {string} char - A single character to evaluate.
+ * @return {boolean} True if the character is a digit, otherwise false.
+ */
+function isHexDigit(char) {
+    return (isDigit(char) ||
+        (char >= "a" && char <= "f") ||
+        (char >= "A" && char <= "F"));
+}
+/**
+ * Determines if a given character is a letter (uppercase or lowercase) `[a-zA-Z]`.
+ *
+ * @param {string} char - The character to be checked.
+ * @return {boolean} Returns true if the character is a letter, otherwise false.
+ */
+function isLetter(char) {
+    return ((char.charCodeAt(0) >= 65 && char.charCodeAt(0) <= 90) ||
+        (char.charCodeAt(0) >= 97 && char.charCodeAt(0) <= 122));
+}
+function isAlphanumeric(char) {
+    return isDigit(char) || isLetter(char);
+}
+function isObject(val) {
+    return typeof val === "object" && val !== null && !Array.isArray(val);
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@cornjs/parser",
+  "author": {
+    "email": "mail@jstanger.dev",
+    "name": "Jake Stanger",
+    "url": "https://github.com/jakestanger"
+  },
+  "files": [
+    "dist"
+  ],
+  "version": "0.11.0",
+  "description": " Native Typescript Corn parser",
+  "homepage": "https://cornlang.dev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jakestanger/corn.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jakestanger/corn/issues"
+  },
+  "keywords": [
+    "corn",
+    "config",
+    "parser",
+    "language",
+    "typescript"
+  ],
+  "main": "dist/index.js",
+  "dependencies": {
+    "dedent": "^1.6.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.0",
+    "@babel/preset-env": "^7.28.0",
+    "@babel/preset-typescript": "^7.27.1",
+    "@eslint/js": "^9.32.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "22.13.14",
+    "babel-jest": "^30.0.5",
+    "eslint": "^9.32.0",
+    "glob": "^13.0.0",
+    "jest": "^30.0.5",
+    "prettier": "^3.6.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.3",
+    "typescript-eslint": "^8.38.0"
+  },
+  "volta": {
+    "node": "22.17.1"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src",
+    "test": "jest"
+  }
+}