@1771technologies/lytenyte-pro 2.0.4-dev.3 → 2.0.4-dev.4

package/dist/expressions/index.js

@@ -0,0 +1,3 @@
+export { Evaluator } from "./evaluator/evaluate.js";
+export { accessPlugin, arrowsPlugin, booleansPlugin, collectionsPlugin, comparisonPlugin, logicalPlugin, membershipPlugin, pipePlugin, standardPlugins, stringsPlugin, ternaryPlugin, } from "./plugins/standard.js";
+export { createResolvedIdentifierPlugin } from "./plugins/resolved-identifier.js";

package/dist/expressions/lexer/predicates/is-alpha-numeric.d.ts

@@ -0,0 +1 @@
+export declare function isAlphaNumeric(ch: string): boolean;

package/dist/expressions/lexer/predicates/is-alpha-numeric.js

@@ -0,0 +1,5 @@
+import { isAlpha } from "./is-alpha.js";
+import { isDigit } from "./is-digit.js";
+export function isAlphaNumeric(ch) {
+    return isAlpha(ch) || isDigit(ch);
+}

package/dist/expressions/lexer/predicates/is-alpha.d.ts

@@ -0,0 +1 @@
+export declare function isAlpha(ch: string): boolean;

package/dist/expressions/lexer/predicates/is-alpha.js

@@ -0,0 +1,3 @@
+export function isAlpha(ch) {
+    return (ch >= "a" && ch <= "z") || (ch >= "A" && ch <= "Z") || ch === "_" || ch === "$";
+}

package/dist/expressions/lexer/predicates/is-binary-digit.d.ts

@@ -0,0 +1 @@
+export declare function isBinaryDigit(ch: string): ch is "0" | "1";

package/dist/expressions/lexer/predicates/is-binary-digit.js

@@ -0,0 +1,3 @@
+export function isBinaryDigit(ch) {
+    return ch === "0" || ch === "1";
+}

package/dist/expressions/lexer/predicates/is-digit.d.ts

@@ -0,0 +1 @@
+export declare function isDigit(ch: string): boolean;

package/dist/expressions/lexer/predicates/is-digit.js

@@ -0,0 +1,3 @@
+export function isDigit(ch) {
+    return ch >= "0" && ch <= "9";
+}

package/dist/expressions/lexer/predicates/is-hex-digit.d.ts

@@ -0,0 +1 @@
+export declare function isHexDigit(ch: string): boolean;

package/dist/expressions/lexer/predicates/is-hex-digit.js

@@ -0,0 +1,4 @@
+import { isDigit } from "./is-digit.js";
+export function isHexDigit(ch) {
+    return isDigit(ch) || (ch >= "a" && ch <= "f") || (ch >= "A" && ch <= "F");
+}

package/dist/expressions/lexer/predicates/is-octal-digit.d.ts

@@ -0,0 +1 @@
+export declare function isOctalDigit(ch: string): boolean;

package/dist/expressions/lexer/predicates/is-octal-digit.js

@@ -0,0 +1,3 @@
+export function isOctalDigit(ch) {
+    return ch >= "0" && ch <= "7";
+}

package/dist/expressions/lexer/tokenize/consume-digits.d.ts

@@ -0,0 +1 @@
+export declare function consumeDigits(source: string, pos: number, predicate: (ch: string) => boolean): number;

package/dist/expressions/lexer/tokenize/consume-digits.js

@@ -0,0 +1,5 @@
+export function consumeDigits(source, pos, predicate) {
+    while (pos < source.length && (predicate(source[pos]) || source[pos] === "_"))
+        pos++;
+    return pos;
+}

package/dist/expressions/lexer/tokenize/scan-identifier.d.ts

@@ -0,0 +1,6 @@
+import type { Token } from "../types.js";
+export declare function scanIdentifier(source: string, start: number): {
+    type: Token["type"];
+    value: string;
+    end: number;
+};

package/dist/expressions/lexer/tokenize/scan-identifier.js

@@ -0,0 +1,20 @@
+import { isAlphaNumeric } from "../predicates/is-alpha-numeric.js";
+const KEYWORDS = new Map([
+    ["true", { type: "Boolean", value: "true" }],
+    ["false", { type: "Boolean", value: "false" }],
+    ["null", { type: "Null", value: "null" }],
+    ["undefined", { type: "Undefined", value: "undefined" }],
+    ["in", { type: "Operator", value: "in" }],
+    ["not", { type: "Operator", value: "not" }],
+]);
+export function scanIdentifier(source, start) {
+    let i = start;
+    while (i < source.length && isAlphaNumeric(source[i]))
+        i++;
+    const value = source.slice(start, i);
+    const kw = KEYWORDS.get(value);
+    if (kw) {
+        return { type: kw.type, value: kw.value, end: i };
+    }
+    return { type: "Identifier", value, end: i };
+}

package/dist/expressions/lexer/tokenize/scan-number.d.ts

@@ -0,0 +1,4 @@
+export declare function scanNumber(source: string, start: number): {
+    value: string;
+    end: number;
+};

package/dist/expressions/lexer/tokenize/scan-number.js

@@ -0,0 +1,32 @@
+import { isDigit } from "../predicates/is-digit.js";
+import { isHexDigit } from "../predicates/is-hex-digit.js";
+import { isOctalDigit } from "../predicates/is-octal-digit.js";
+import { isBinaryDigit } from "../predicates/is-binary-digit.js";
+import { consumeDigits } from "./consume-digits.js";
+export function scanNumber(source, start) {
+    const ch = source[start];
+    const next = source[start + 1];
+    let i = start;
+    if (ch === "0" && (next === "x" || next === "X")) {
+        i = consumeDigits(source, i + 2, isHexDigit);
+    }
+    else if (ch === "0" && (next === "o" || next === "O")) {
+        i = consumeDigits(source, i + 2, isOctalDigit);
+    }
+    else if (ch === "0" && (next === "b" || next === "B")) {
+        i = consumeDigits(source, i + 2, isBinaryDigit);
+    }
+    else {
+        i = consumeDigits(source, i, isDigit);
+        if (i < source.length && source[i] === "." && i + 1 < source.length && isDigit(source[i + 1])) {
+            i = consumeDigits(source, i + 1, isDigit);
+        }
+        if (i < source.length && (source[i] === "e" || source[i] === "E")) {
+            i++;
+            if (i < source.length && (source[i] === "+" || source[i] === "-"))
+                i++;
+            i = consumeDigits(source, i, isDigit);
+        }
+    }
+    return { value: source.slice(start, i), end: i };
+}

package/dist/expressions/lexer/tokenize/scan-operator.d.ts

@@ -0,0 +1,6 @@
+import type { Token } from "../types.js";
+export declare function scanOperator(source: string, start: number): {
+    type: Token["type"];
+    value: string;
+    end: number;
+};

package/dist/expressions/lexer/tokenize/scan-operator.js

@@ -0,0 +1,71 @@
+import { ExpressionError } from "../../errors/index.js";
+export function scanOperator(source, start) {
+    const ch = source[start];
+    const next = start + 1 < source.length ? source[start + 1] : "";
+    // Spread operator ...
+    if (ch === "." && next === "." && start + 2 < source.length && source[start + 2] === ".") {
+        return { type: "Spread", value: "...", end: start + 3 };
+    }
+    // Dot (punctuation)
+    if (ch === ".") {
+        return { type: "Punctuation", value: ".", end: start + 1 };
+    }
+    // Pipe |> or logical ||
+    if (ch === "|" && next === ">") {
+        return { type: "Pipe", value: "|>", end: start + 2 };
+    }
+    if (ch === "|" && next === "|") {
+        return { type: "Operator", value: "||", end: start + 2 };
+    }
+    // &&
+    if (ch === "&" && next === "&") {
+        return { type: "Operator", value: "&&", end: start + 2 };
+    }
+    // => (arrow)
+    if (ch === "=" && next === ">") {
+        return { type: "Arrow", value: "=>", end: start + 2 };
+    }
+    // == !=
+    if (ch === "=" && next === "=") {
+        return { type: "Operator", value: "==", end: start + 2 };
+    }
+    if (ch === "!" && next === "=") {
+        return { type: "Operator", value: "!=", end: start + 2 };
+    }
+    // ! (logical not) - must come after != check
+    if (ch === "!") {
+        return { type: "Operator", value: "!", end: start + 1 };
+    }
+    // <= >= < >
+    if (ch === "<") {
+        if (next === "=")
+            return { type: "Operator", value: "<=", end: start + 2 };
+        return { type: "Operator", value: "<", end: start + 1 };
+    }
+    if (ch === ">") {
+        if (next === "=")
+            return { type: "Operator", value: ">=", end: start + 2 };
+        return { type: "Operator", value: ">", end: start + 1 };
+    }
+    // ** (exponentiation) — must come before single *
+    if (ch === "*" && next === "*") {
+        return { type: "Operator", value: "**", end: start + 2 };
+    }
+    // ?. (optional chaining) or ?? (nullish coalescing) or ? (ternary)
+    if (ch === "?") {
+        if (next === ".")
+            return { type: "OptionalChain", value: "?.", end: start + 2 };
+        if (next === "?")
+            return { type: "NullishCoalescing", value: "??", end: start + 2 };
+        return { type: "Punctuation", value: "?", end: start + 1 };
+    }
+    // Single-character operators
+    if (ch === "+" || ch === "-" || ch === "*" || ch === "/" || ch === "%") {
+        return { type: "Operator", value: ch, end: start + 1 };
+    }
+    // Punctuation
+    if ("()[]{},:".includes(ch)) {
+        return { type: "Punctuation", value: ch, end: start + 1 };
+    }
+    throw new ExpressionError(`Unexpected character "${ch}"`, { source, start, end: start + 1 });
+}

package/dist/expressions/lexer/tokenize/scan-string-literal.d.ts

@@ -0,0 +1,4 @@
+export declare function scanStringLiteral(source: string, start: number): {
+    raw: string;
+    end: number;
+};

package/dist/expressions/lexer/tokenize/scan-string-literal.js

@@ -0,0 +1,22 @@
+import { ExpressionError } from "../../errors/index.js";
+export function scanStringLiteral(source, start) {
+    const quote = source[start];
+    let raw = quote;
+    let i = start + 1;
+    while (i < source.length && source[i] !== quote) {
+        if (source[i] === "\\" && i + 1 < source.length) {
+            raw += source[i] + source[i + 1];
+            i += 2;
+        }
+        else {
+            raw += source[i];
+            i++;
+        }
+    }
+    if (i >= source.length) {
+        throw new ExpressionError("Unterminated string", { source, start, end: i });
+    }
+    raw += source[i];
+    i++;
+    return { raw, end: i };
+}

package/dist/expressions/lexer/tokenize/scan-string.d.ts

@@ -0,0 +1,4 @@
+export declare function scanString(source: string, start: number): {
+    value: string;
+    end: number;
+};

package/dist/expressions/lexer/tokenize/scan-string.js

@@ -0,0 +1,98 @@
+import { ExpressionError } from "../../errors/index.js";
+import { isHexDigit } from "../predicates/is-hex-digit.js";
+const MAX_CODE_POINT = 0x10ffff;
+const HEX_CODE_POINT_SIZE = 5;
+export function scanString(source, start) {
+    const quote = source[start];
+    let value = "";
+    let i = start + 1;
+    while (i < source.length && source[i] !== quote) {
+        if (source[i] === "\\") {
+            i++;
+            const escaped = source[i];
+            if (escaped === "n")
+                value += "\n";
+            else if (escaped === "t")
+                value += "\t";
+            else if (escaped === "r")
+                value += "\r";
+            else if (escaped === "\\")
+                value += "\\";
+            else if (escaped === "0")
+                value += "\0";
+            else if (escaped === "x") {
+                const hex = source.slice(i + 1, i + 3);
+                if (hex.length < 2 || !isHexDigit(hex[0]) || !isHexDigit(hex[1])) {
+                    throw new ExpressionError("Invalid \\x escape", { source, start, end: i });
+                }
+                value += String.fromCharCode(parseInt(hex, 16));
+                i += 3;
+                continue;
+            }
+            else if (escaped === "u") {
+                if (source[i + 1] === "{") {
+                    i += 2;
+                    let hex = "";
+                    while (i < source.length && source[i] !== "}" && source[i] !== quote) {
+                        if (!isHexDigit(source[i])) {
+                            throw new ExpressionError("Invalid \\u escape: non-hex digit", {
+                                source,
+                                start,
+                                end: i,
+                            });
+                        }
+                        hex += source[i];
+                        i++;
+                    }
+                    if (i >= source.length || source[i] !== "}") {
+                        throw new ExpressionError("Invalid \\u escape: missing closing brace", {
+                            source,
+                            start,
+                            end: i,
+                        });
+                    }
+                    if (hex.length === 0) {
+                        throw new ExpressionError("Invalid \\u escape: empty code point", {
+                            source,
+                            start,
+                            end: i,
+                        });
+                    }
+                    const codePoint = parseInt(hex, 16);
+                    if (codePoint > MAX_CODE_POINT) {
+                        throw new ExpressionError("Invalid \\u escape: code point out of range", {
+                            source,
+                            start,
+                            end: i,
+                        });
+                    }
+                    value += String.fromCodePoint(codePoint);
+                    i++;
+                    continue;
+                }
+                else {
+                    const hex = source.slice(i + 1, i + HEX_CODE_POINT_SIZE);
+                    if (hex.length < 4 || ![...hex].every(isHexDigit)) {
+                        throw new ExpressionError("Invalid \\u escape", { source, start, end: i });
+                    }
+                    value += String.fromCharCode(parseInt(hex, 16));
+                    i += HEX_CODE_POINT_SIZE;
+                    continue;
+                }
+            }
+            else {
+                value += escaped;
+            }
+        }
+        else {
+            value += source[i];
+        }
+        i++;
+    }
+    if (i >= source.length) {
+        throw new ExpressionError("Unterminated string", { source, start, end: i });
+    }
+    i++;
+    // We keep the string literals in the token.
+    return { value: quote + value + quote, end: i };
+}

package/dist/expressions/lexer/tokenize/scan-template-literal.d.ts

@@ -0,0 +1,4 @@
+export declare function scanTemplateLiteral(source: string, start: number): {
+    raw: string;
+    end: number;
+};

package/dist/expressions/lexer/tokenize/scan-template-literal.js

@@ -0,0 +1,51 @@
+import { ExpressionError } from "../../errors/index.js";
+import { scanStringLiteral } from "./scan-string-literal.js";
+export function scanTemplateLiteral(source, start) {
+    let raw = "`";
+    let i = start + 1;
+    while (i < source.length && source[i] !== "`") {
+        if (source[i] === "\\" && i + 1 < source.length) {
+            raw += source[i] + source[i + 1];
+            i += 2;
+            continue;
+        }
+        if (source[i] === "$" && i + 1 < source.length && source[i + 1] === "{") {
+            raw += "${";
+            i += 2;
+            let depth = 1;
+            while (i < source.length && depth > 0) {
+                const c = source[i];
+                if (c === '"' || c === "'") {
+                    const result = scanStringLiteral(source, i);
+                    raw += result.raw;
+                    i = result.end;
+                    continue;
+                }
+                if (c === "`") {
+                    const result = scanTemplateLiteral(source, i);
+                    raw += result.raw;
+                    i = result.end;
+                    continue;
+                }
+                if (c === "{")
+                    depth++;
+                else if (c === "}")
+                    depth--;
+                if (depth > 0)
+                    raw += c;
+                i++;
+            }
+            raw += "}";
+        }
+        else {
+            raw += source[i];
+            i++;
+        }
+    }
+    if (i >= source.length) {
+        throw new ExpressionError("Unterminated template literal", { source, start, end: i });
+    }
+    raw += "`";
+    i++;
+    return { raw, end: i };
+}

package/dist/expressions/lexer/tokenize/tokenize.d.ts

@@ -0,0 +1,4 @@
+import type { Token } from "../types.js";
+import type { Plugin } from "../../plugin.js";
+export declare function tokenizeSafe(source: string, plugins?: Plugin[], tokensizeWhitespace?: boolean): Token[];
+export declare function tokenize(source: string, plugins?: Plugin[], tokensizeWhitespace?: boolean): Token[];

package/dist/expressions/lexer/tokenize/tokenize.js

@@ -0,0 +1,99 @@
+import { isDigit } from "../predicates/is-digit.js";
+import { isAlpha } from "../predicates/is-alpha.js";
+import { scanTemplateLiteral } from "./scan-template-literal.js";
+import { scanNumber } from "./scan-number.js";
+import { scanString } from "./scan-string.js";
+import { scanIdentifier } from "./scan-identifier.js";
+import { scanOperator } from "./scan-operator.js";
+import { ExpressionError } from "../../errors/expression-error.js";
+export function tokenizeSafe(source, plugins, tokensizeWhitespace = false) {
+    const tokens = [];
+    try {
+        let i = 0;
+        while (i < source.length) {
+            const ch = source[i];
+            if (/\s/.test(ch)) {
+                if (tokensizeWhitespace) {
+                    tokens.push({
+                        value: ch,
+                        start: i,
+                        end: i + 1,
+                        type: "Whitespace",
+                    });
+                }
+                i++;
+                continue;
+            }
+            const start = i;
+            let result = null;
+            if (plugins) {
+                for (const plugin of plugins) {
+                    if (plugin.scan) {
+                        result = plugin.scan(source, i);
+                        if (result)
+                            break;
+                    }
+                }
+            }
+            if (!result) {
+                if (isDigit(ch)) {
+                    const r = scanNumber(source, i);
+                    result = { type: "Number", value: r.value, end: r.end };
+                }
+                else if (ch === '"' || ch === "'") {
+                    const r = scanString(source, i);
+                    result = { type: "String", value: r.value, end: r.end };
+                }
+                else if (ch === "`") {
+                    const r = scanTemplateLiteral(source, i);
+                    result = { type: "TemplateLiteral", value: r.raw, end: r.end };
+                }
+                else if (isAlpha(ch)) {
+                    result = scanIdentifier(source, i);
+                }
+                else {
+                    result = scanOperator(source, i);
+                }
+            }
+            i = result.end;
+            tokens.push({ type: result.type, value: result.value, start, end: i });
+        }
+        tokens.push({ type: "EOF", value: "", start: i, end: i });
+    }
+    catch (e) {
+        if (e instanceof ExpressionError) {
+            const error = {
+                type: "ExpressionError",
+                start: e.start,
+                end: e.end,
+                value: source.slice(e.start, e.end),
+                error: e,
+            };
+            tokens.push(error);
+            const left = source.slice(e.end);
+            if (left) {
+                const remaining = {
+                    type: "Unparsed",
+                    start: e.end,
+                    end: source.length,
+                    value: left,
+                };
+                tokens.push(remaining);
+            }
+            tokens.push({ type: "EOF", value: "", start: source.length, end: source.length });
+            return tokens;
+        }
+        else {
+            throw e;
+        }
+    }
+    return tokens;
+}
+export function tokenize(source, plugins, tokensizeWhitespace) {
+    const result = tokenizeSafe(source, plugins, tokensizeWhitespace);
+    if (result.at(-2)?.type === "ExpressionError")
+        throw result.at(-2).error;
+    if (result.at(-3)?.type === "ExpressionError")
+        throw result.at(-3).error;
+    return result;
+}

package/dist/expressions/lexer/types.d.ts

@@ -0,0 +1,12 @@
+export type BinaryOperator = "||" | "&&" | "==" | "!=" | "<" | ">" | "<=" | ">=" | "+" | "-" | "*" | "/" | "%" | "**" | "in" | "not";
+export type UnaryOperator = "!" | "-" | "+";
+export type BinaryExpressionOperator = Exclude<BinaryOperator, "not"> | "not in" | "??";
+export type OperatorValue = BinaryOperator | UnaryOperator;
+export type PunctuationValue = "(" | ")" | "[" | "]" | "{" | "}" | "," | "." | ":" | "?";
+export interface Token {
+    readonly type: string;
+    readonly start: number;
+    readonly end: number;
+    readonly value: string;
+    readonly error?: unknown;
+}

package/dist/expressions/lexer/types.js

@@ -0,0 +1 @@
+export {};

package/dist/expressions/parser/parse-array-literal.d.ts

@@ -0,0 +1,3 @@
+import type { ASTNode } from "./types.js";
+import type { ParserContext } from "./parser-context.js";
+export declare function parseArrayLiteral(ctx: ParserContext): ASTNode;

package/dist/expressions/parser/parse-array-literal.js

@@ -0,0 +1,15 @@
+import { current, expect } from "./parser-context.js";
+import { parseExpression } from "./parse-expression.js";
+export function parseArrayLiteral(ctx) {
+    const start = expect(ctx, "Punctuation", "[").start;
+    const elements = [];
+    while (!(current(ctx).type === "Punctuation" && current(ctx).value === "]")) {
+        if (elements.length > 0)
+            expect(ctx, "Punctuation", ",");
+        if (current(ctx).type === "Punctuation" && current(ctx).value === "]")
+            break;
+        elements.push(parseExpression(ctx, 0));
+    }
+    const end = expect(ctx, "Punctuation", "]").end;
+    return { type: "ArrayLiteral", elements, start, end };
+}

package/dist/expressions/parser/parse-expression.d.ts

@@ -0,0 +1,3 @@
+import type { ASTNode } from "./types.js";
+import type { ParserContext } from "./parser-context.js";
+export declare function parseExpression(ctx: ParserContext, minPrec?: number): ASTNode;

package/dist/expressions/parser/parse-expression.js

@@ -0,0 +1,74 @@
+import { current, advance } from "./parser-context.js";
+import { PRECEDENCE } from "./precedence.js";
+import { parseUnary } from "./parse-unary.js";
+export function parseExpression(ctx, minPrec = 0) {
+    let left = parseUnary(ctx);
+    while (true) {
+        const tok = current(ctx);
+        let prec;
+        // Core precedence (arithmetic only)
+        if (tok.type === "Operator") {
+            prec = PRECEDENCE[tok.value];
+        }
+        // Plugin precedence
+        if (prec === undefined && ctx.plugins) {
+            for (const plugin of ctx.plugins) {
+                if (plugin.infixPrecedence) {
+                    prec = plugin.infixPrecedence(ctx);
+                    if (prec !== undefined)
+                        break;
+                }
+            }
+        }
+        if (prec !== undefined && prec >= minPrec) {
+            // Try plugin parseInfix first (for ternary, pipe, membership, etc.)
+            if (ctx.plugins) {
+                let handled = false;
+                for (const plugin of ctx.plugins) {
+                    if (plugin.parseInfix) {
+                        const node = plugin.parseInfix(ctx, left, minPrec);
+                        if (node) {
+                            left = node;
+                            handled = true;
+                            break;
+                        }
+                    }
+                }
+                if (handled)
+                    continue;
+            }
+            // Default: standard binary expression
+            const op = advance(ctx);
+            const isRightAssoc = op.value === "**";
+            const nextMinPrec = isRightAssoc ? prec : prec + 1;
+            const right = parseExpression(ctx, nextMinPrec);
+            left = {
+                type: "BinaryExpression",
+                operator: op.value,
+                left,
+                right,
+                start: left.start,
+                end: right.end,
+            };
+            continue;
+        }
+        // No precedence — try plugin parseInfix (for things without precedence entry)
+        if (prec === undefined && ctx.plugins) {
+            let handled = false;
+            for (const plugin of ctx.plugins) {
+                if (plugin.parseInfix) {
+                    const node = plugin.parseInfix(ctx, left, minPrec);
+                    if (node) {
+                        left = node;
+                        handled = true;
+                        break;
+                    }
+                }
+            }
+            if (handled)
+                continue;
+        }
+        break;
+    }
+    return left;
+}

package/dist/expressions/parser/parse-object-literal.d.ts

@@ -0,0 +1,3 @@
+import type { ASTNode } from "./types.js";
+import type { ParserContext } from "./parser-context.js";
+export declare function parseObjectLiteral(ctx: ParserContext): ASTNode;