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

package/dist/expressions/errors/format-error.js

@@ -0,0 +1,27 @@
+import { clampOffset } from "./clamp-offset.js";
+import { getLineStart } from "./get-line-start.js";
+import { getLineEnd } from "./get-line-end.js";
+import { offsetToPosition } from "./offset-to-position.js";
+/** Format an error message with source context, caret display, and position info. */
+export function formatError(message, location, suggestion) {
+    const { source } = location;
+    const start = clampOffset(source, location.start);
+    const rawEnd = clampOffset(source, location.end);
+    const end = Math.max(start + 1, rawEnd);
+    const startPos = offsetToPosition(source, start);
+    const lineStart = getLineStart(source, start);
+    const lineEnd = getLineEnd(source, start);
+    const lineText = source.slice(lineStart, lineEnd);
+    const caretStart = start - lineStart;
+    const caretEnd = Math.min(end, lineEnd);
+    const caretLength = Math.max(1, caretEnd - start);
+    const gutter = `${startPos.line} | `;
+    const padding = " ".repeat(gutter.length + caretStart);
+    const carets = "^".repeat(caretLength);
+    let result = `${message}\n\n${gutter}${lineText}\n${padding}${carets}`;
+    if (suggestion) {
+        result += ` Did you mean "${suggestion}"?`;
+    }
+    result += `\n\nat line ${startPos.line}, column ${startPos.column} (offset ${start}-${end})`;
+    return result;
+}

package/dist/expressions/errors/get-line-end.d.ts

@@ -0,0 +1 @@
+export declare function getLineEnd(source: string, offset: number): number;

package/dist/expressions/errors/get-line-end.js

@@ -0,0 +1,8 @@
+import { clampOffset } from "./clamp-offset.js";
+const NEWLINE_CODE = 10;
+export function getLineEnd(source, offset) {
+    let index = clampOffset(source, offset);
+    while (index < source.length && source.charCodeAt(index) !== NEWLINE_CODE)
+        index++;
+    return index;
+}

package/dist/expressions/errors/get-line-start.d.ts

@@ -0,0 +1 @@
+export declare function getLineStart(source: string, offset: number): number;

package/dist/expressions/errors/get-line-start.js

@@ -0,0 +1,8 @@
+import { clampOffset } from "./clamp-offset.js";
+const NEWLINE_CODE = 10;
+export function getLineStart(source, offset) {
+    let index = clampOffset(source, offset);
+    while (index > 0 && source.charCodeAt(index - 1) !== NEWLINE_CODE)
+        index--;
+    return index;
+}

package/dist/expressions/errors/index.d.ts

@@ -0,0 +1,7 @@
+export type { SourcePosition, ErrorLocation } from "./types.js";
+export { clampOffset } from "./clamp-offset.js";
+export { getLineStart } from "./get-line-start.js";
+export { getLineEnd } from "./get-line-end.js";
+export { offsetToPosition } from "./offset-to-position.js";
+export { formatError } from "./format-error.js";
+export { ExpressionError } from "./expression-error.js";

package/dist/expressions/errors/index.js

@@ -0,0 +1,6 @@
+export { clampOffset } from "./clamp-offset.js";
+export { getLineStart } from "./get-line-start.js";
+export { getLineEnd } from "./get-line-end.js";
+export { offsetToPosition } from "./offset-to-position.js";
+export { formatError } from "./format-error.js";
+export { ExpressionError } from "./expression-error.js";

package/dist/expressions/errors/offset-to-position.d.ts

@@ -0,0 +1,2 @@
+import type { SourcePosition } from "./types.js";
+export declare function offsetToPosition(source: string, offset: number): SourcePosition;

package/dist/expressions/errors/offset-to-position.js

@@ -0,0 +1,17 @@
+import { clampOffset } from "./clamp-offset.js";
+const NEWLINE_CODE = 10;
+export function offsetToPosition(source, offset) {
+    const safeOffset = clampOffset(source, offset);
+    let line = 1;
+    let column = 1;
+    for (let index = 0; index < safeOffset; index++) {
+        if (source.charCodeAt(index) === NEWLINE_CODE) {
+            line++;
+            column = 1;
+        }
+        else {
+            column++;
+        }
+    }
+    return { line, column, offset: safeOffset };
+}

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

@@ -0,0 +1,10 @@
+export interface SourcePosition {
+    line: number;
+    column: number;
+    offset: number;
+}
+export interface ErrorLocation {
+    source: string;
+    start: number;
+    end: number;
+}

package/dist/expressions/errors/types.js

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

package/dist/expressions/evaluator/evaluate-binary.d.ts

@@ -0,0 +1,4 @@
+import type { BinaryExpression } from "../parser/types.js";
+import type { Plugin } from "../plugin.js";
+import type { RunOptions } from "./evaluate.js";
+export declare function evaluateBinary(node: BinaryExpression, context: Record<string, unknown>, depth: number, plugins?: Plugin[], options?: RunOptions): unknown;

package/dist/expressions/evaluator/evaluate-binary.js

@@ -0,0 +1,21 @@
+import { evaluateNode } from "./evaluate.js";
+export function evaluateBinary(node, context, depth, plugins, options) {
+    const left = evaluateNode(node.left, context, depth + 1, plugins, options);
+    const right = evaluateNode(node.right, context, depth + 1, plugins, options);
+    switch (node.operator) {
+        case "+":
+            return left + right;
+        case "-":
+            return left - right;
+        case "*":
+            return left * right;
+        case "/":
+            return left / right;
+        case "%":
+            return left % right;
+        case "**":
+            return left ** right;
+        default:
+            throw new Error(`Unknown binary operator: ${node.operator}`);
+    }
+}

package/dist/expressions/evaluator/evaluate-unary.d.ts

@@ -0,0 +1,2 @@
+import type { UnaryOperator } from "../lexer/types.js";
+export declare function evaluateUnary(operator: UnaryOperator, operand: unknown): unknown;

package/dist/expressions/evaluator/evaluate-unary.js

@@ -0,0 +1,10 @@
+export function evaluateUnary(operator, operand) {
+    switch (operator) {
+        case "-":
+            return -operand;
+        case "+":
+            return +operand;
+        default:
+            throw new Error(`Unknown unary operator: ${operator}`);
+    }
+}

package/dist/expressions/evaluator/evaluate.d.ts

@@ -0,0 +1,15 @@
+import type { ASTNode } from "../parser/types.js";
+import type { Token } from "../lexer/types.js";
+import type { Plugin } from "../plugin.js";
+export interface RunOptions {
+    undefinedIdentifierFallback?: unknown;
+}
+export declare class Evaluator {
+    private plugins?;
+    constructor(plugins?: Plugin[]);
+    run: (input: string | ASTNode, context?: Record<string, unknown>, options?: RunOptions) => unknown;
+    ast: (input: string) => ASTNode;
+    tokens: (input: string, tokensizeWhitespace?: boolean) => Token[];
+    tokensSafe: (input: string, tokensizeWhitespace?: boolean) => Token[];
+}
+export declare function evaluateNode(node: ASTNode, context: Record<string, unknown>, depth: number, plugins?: Plugin[], options?: RunOptions): unknown;

package/dist/expressions/evaluator/evaluate.js

@@ -0,0 +1,62 @@
+import { parse } from "../parser/parse.js";
+import { compile } from "../compiler/compile.js";
+import { tokenize, tokenizeSafe } from "../lexer/tokenize/tokenize.js";
+import { evaluateBinary } from "./evaluate-binary.js";
+import { evaluateUnary } from "./evaluate-unary.js";
+const MAX_DEPTH = 1000;
+export class Evaluator {
+    plugins;
+    constructor(plugins) {
+        this.plugins = plugins;
+    }
+    run = (input, context = {}, options) => {
+        const node = typeof input === "string" ? compile(parse(input, 0, this.plugins), this.plugins) : input;
+        return evaluateNode(node, context, 0, this.plugins, options);
+    };
+    ast = (input) => {
+        return compile(parse(input, 0, this.plugins), this.plugins);
+    };
+    tokens = (input, tokensizeWhitespace) => {
+        return tokenize(input, this.plugins, tokensizeWhitespace);
+    };
+    tokensSafe = (input, tokensizeWhitespace) => {
+        return tokenizeSafe(input, this.plugins, tokensizeWhitespace);
+    };
+}
+export function evaluateNode(node, context, depth, plugins, options) {
+    if (depth > MAX_DEPTH) {
+        throw new Error("Maximum evaluation depth exceeded");
+    }
+    // Try plugin evaluation first
+    if (plugins) {
+        const evalFn = (n, ctx) => evaluateNode(n, ctx, depth + 1, plugins, options);
+        for (const plugin of plugins) {
+            if (plugin.evaluate) {
+                const result = plugin.evaluate(node, context, evalFn);
+                if (result !== null)
+                    return result.value;
+            }
+        }
+    }
+    // Core built-in evaluation
+    switch (node.type) {
+        case "NumberLiteral":
+            return node.value;
+        case "Identifier": {
+            if (!(node.name in context)) {
+                if (options && "undefinedIdentifierFallback" in options)
+                    return options.undefinedIdentifierFallback;
+                throw new Error(`Identifier "${node.name}" is not defined`);
+            }
+            return context[node.name];
+        }
+        case "BinaryExpression":
+            return evaluateBinary(node, context, depth, plugins, options);
+        case "UnaryExpression":
+            return evaluateUnary(node.operator, evaluateNode(node.operand, context, depth + 1, plugins, options));
+        case "SpreadElement":
+            throw new Error("Unexpected spread element outside of array literal");
+        default:
+            throw new Error(`Unknown node type: ${node.type}`);
+    }
+}

package/dist/expressions/index.d.ts

@@ -0,0 +1,7 @@
+export { Evaluator } from "./evaluator/evaluate.js";
+export type { Plugin, EvalFn } from "./plugin.js";
+export type { Token } from "./lexer/types.js";
+export { accessPlugin, arrowsPlugin, booleansPlugin, collectionsPlugin, comparisonPlugin, logicalPlugin, membershipPlugin, pipePlugin, standardPlugins, stringsPlugin, ternaryPlugin, quotedIdentifierPlugin, } from "./plugins/standard.js";
+export { createResolvedIdentifierPlugin } from "./plugins/resolved-identifier.js";
+export { dateLiteralPlugin } from "./plugins/date-literal.js";
+export { createDateIdentifierPlugin } from "./plugins/date-identifier.js";

package/dist/expressions/index.js

@@ -0,0 +1,5 @@
+export { Evaluator } from "./evaluator/evaluate.js";
+export { accessPlugin, arrowsPlugin, booleansPlugin, collectionsPlugin, comparisonPlugin, logicalPlugin, membershipPlugin, pipePlugin, standardPlugins, stringsPlugin, ternaryPlugin, quotedIdentifierPlugin, } from "./plugins/standard.js";
+export { createResolvedIdentifierPlugin } from "./plugins/resolved-identifier.js";
+export { dateLiteralPlugin } from "./plugins/date-literal.js";
+export { createDateIdentifierPlugin } from "./plugins/date-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;
+};