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

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;

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

@@ -0,0 +1,69 @@
+import { current, advance, expect } from "./parser-context.js";
+import { ExpressionError } from "../errors/expression-error.js";
+import { parseExpression } from "./parse-expression.js";
+export function parseObjectLiteral(ctx) {
+    const start = expect(ctx, "Punctuation", "{").start;
+    const properties = [];
+    while (!(current(ctx).type === "Punctuation" && current(ctx).value === "}")) {
+        if (properties.length > 0)
+            expect(ctx, "Punctuation", ",");
+        if (current(ctx).type === "Punctuation" && current(ctx).value === "}")
+            break;
+        let key;
+        let computed = false;
+        if (current(ctx).type === "Punctuation" && current(ctx).value === "[") {
+            advance(ctx);
+            key = parseExpression(ctx, 0);
+            expect(ctx, "Punctuation", "]");
+            computed = true;
+        }
+        else {
+            const tok = current(ctx);
+            if (tok.type === "Identifier") {
+                advance(ctx);
+                key = { type: "Identifier", name: tok.value, start: tok.start, end: tok.end };
+                const next = current(ctx);
+                if (next.type === "Punctuation" && (next.value === "," || next.value === "}")) {
+                    const value = {
+                        type: "Identifier",
+                        name: tok.value,
+                        start: tok.start,
+                        end: tok.end,
+                    };
+                    properties.push({
+                        type: "ObjectProperty",
+                        key,
+                        value,
+                        computed: false,
+                        start: key.start,
+                        end: value.end,
+                    });
+                    continue;
+                }
+            }
+            else if (tok.type === "String") {
+                advance(ctx);
+                key = { type: "StringLiteral", value: tok.value.slice(1, -1), start: tok.start, end: tok.end };
+            }
+            else {
+                throw new ExpressionError(`Expected property name but got "${tok.value}"`, {
+                    source: ctx.source,
+                    start: tok.start,
+                    end: tok.end,
+                });
+            }
+        }
+        expect(ctx, "Punctuation", ":");
+        const value = parseExpression(ctx, 0);
+        properties.push({
+            type: "ObjectProperty",
+            key,
+            value,
+            computed,
+            start: key.start,
+            end: value.end,
+        });
+    }
+    const end = expect(ctx, "Punctuation", "}").end;
+    return { type: "ObjectLiteral", properties, start, end };
+}

package/dist/expressions/parser/parse-pipe-transform.d.ts

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

package/dist/expressions/parser/parse-pipe-transform.js

@@ -0,0 +1,26 @@
+import { current, advance, expect } from "./parser-context.js";
+import { parsePrimary } from "./parse-primary.js";
+import { parseExpression } from "./parse-expression.js";
+export function parsePipeTransform(ctx) {
+    let node = parsePrimary(ctx);
+    if (current(ctx).type === "Punctuation" && current(ctx).value === "(") {
+        advance(ctx);
+        const args = [];
+        while (!(current(ctx).type === "Punctuation" && current(ctx).value === ")")) {
+            if (args.length > 0)
+                expect(ctx, "Punctuation", ",");
+            if (current(ctx).type === "Punctuation" && current(ctx).value === ")")
+                break;
+            args.push(parseExpression(ctx, 0));
+        }
+        const end = expect(ctx, "Punctuation", ")").end;
+        node = {
+            type: "CallExpression",
+            callee: node,
+            args,
+            start: node.start,
+            end,
+        };
+    }
+    return node;
+}

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

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

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

@@ -0,0 +1,23 @@
+import { parsePrimary } from "./parse-primary.js";
+export function parsePostfix(ctx) {
+    let node = parsePrimary(ctx);
+    while (true) {
+        if (ctx.plugins) {
+            let handled = false;
+            for (const plugin of ctx.plugins) {
+                if (plugin.parsePostfix) {
+                    const result = plugin.parsePostfix(ctx, node);
+                    if (result) {
+                        node = result;
+                        handled = true;
+                        break;
+                    }
+                }
+            }
+            if (handled)
+                continue;
+        }
+        break;
+    }
+    return node;
+}

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

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

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

@@ -0,0 +1,35 @@
+import { current, advance, expect } from "./parser-context.js";
+import { ExpressionError } from "../errors/expression-error.js";
+import { parseExpression } from "./parse-expression.js";
+export function parsePrimary(ctx) {
+    // Plugin prefix hooks
+    if (ctx.plugins) {
+        for (const plugin of ctx.plugins) {
+            if (plugin.parsePrefix) {
+                const node = plugin.parsePrefix(ctx);
+                if (node)
+                    return node;
+            }
+        }
+    }
+    const tok = current(ctx);
+    // Core: number literals
+    if (tok.type === "Number") {
+        advance(ctx);
+        const raw = tok.value.replace(/_/g, "");
+        return { type: "NumberLiteral", value: Number(raw), start: tok.start, end: tok.end };
+    }
+    // Core: identifiers
+    if (tok.type === "Identifier") {
+        advance(ctx);
+        return { type: "Identifier", name: tok.value, start: tok.start, end: tok.end };
+    }
+    // Core: parenthesized expressions (grouping)
+    if (tok.type === "Punctuation" && tok.value === "(") {
+        advance(ctx);
+        const expr = parseExpression(ctx, 0);
+        expect(ctx, "Punctuation", ")");
+        return expr;
+    }
+    throw new ExpressionError(`Unexpected ${tok.type === "EOF" ? "end of expression" : `token "${tok.value}"`}`, { source: ctx.source, start: tok.start, end: tok.end });
+}

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

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

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

@@ -0,0 +1,41 @@
+import { advance } from "./parser-context.js";
+import { parse } from "./parse.js";
+export function parseTemplateLiteral(ctx) {
+    const tok = advance(ctx);
+    const raw = tok.value.slice(1, -1);
+    const parts = [];
+    let i = 0;
+    let textStart = 0;
+    while (i < raw.length) {
+        if (raw[i] === "$" && i + 1 < raw.length && raw[i + 1] === "{") {
+            if (i > textStart) {
+                const text = raw.slice(textStart, i);
+                parts.push({ type: "StringLiteral", value: text, start: tok.start, end: tok.end });
+            }
+            i += 2;
+            let depth = 1;
+            const exprStart = i;
+            while (i < raw.length && depth > 0) {
+                if (raw[i] === "{")
+                    depth++;
+                else if (raw[i] === "}")
+                    depth--;
+                if (depth > 0)
+                    i++;
+            }
+            const exprSource = raw.slice(exprStart, i);
+            i++;
+            textStart = i;
+            const exprAst = parse(exprSource, ctx.depth + 1, ctx.plugins);
+            parts.push(exprAst);
+        }
+        else {
+            i++;
+        }
+    }
+    if (textStart < raw.length) {
+        const text = raw.slice(textStart);
+        parts.push({ type: "StringLiteral", value: text, start: tok.start, end: tok.end });
+    }
+    return { type: "TemplateLiteral", parts, start: tok.start, end: tok.end };
+}

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

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

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

@@ -0,0 +1,28 @@
+import { current, advance } from "./parser-context.js";
+import { parsePostfix } from "./parse-postfix.js";
+export function parseUnary(ctx) {
+    // Plugin unary hooks
+    if (ctx.plugins) {
+        for (const plugin of ctx.plugins) {
+            if (plugin.parseUnary) {
+                const node = plugin.parseUnary(ctx, parseUnary);
+                if (node)
+                    return node;
+            }
+        }
+    }
+    const tok = current(ctx);
+    // Core: arithmetic unary (-, +)
+    if (tok.type === "Operator" && (tok.value === "-" || tok.value === "+")) {
+        advance(ctx);
+        const operand = parseUnary(ctx);
+        return {
+            type: "UnaryExpression",
+            operator: tok.value,
+            operand,
+            start: tok.start,
+            end: operand.end,
+        };
+    }
+    return parsePostfix(ctx);
+}

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

@@ -0,0 +1,3 @@
+import type { ASTNode } from "./types.js";
+import type { Plugin } from "../plugin.js";
+export declare function parse(source: string, depth?: number, plugins?: Plugin[]): ASTNode;

package/dist/expressions/parser/parse.js

@@ -0,0 +1,26 @@
+import { current } from "./parser-context.js";
+import { tokenize } from "../lexer/tokenize/tokenize.js";
+import { ExpressionError } from "../errors/expression-error.js";
+import { parseExpression } from "./parse-expression.js";
+const MAX_PARSE_DEPTH = 32;
+export function parse(source, depth = 0, plugins) {
+    if (depth > MAX_PARSE_DEPTH) {
+        throw new ExpressionError("Maximum template nesting depth exceeded", {
+            source,
+            start: 0,
+            end: source.length,
+        });
+    }
+    const tokens = tokenize(source, plugins);
+    const ctx = { tokens, pos: 0, source, depth, plugins };
+    const result = parseExpression(ctx, 0);
+    if (current(ctx).type !== "EOF") {
+        const tok = current(ctx);
+        throw new ExpressionError(`Unexpected token "${tok.value}"`, {
+            source,
+            start: tok.start,
+            end: tok.end,
+        });
+    }
+    return result;
+}

package/dist/expressions/parser/parser-context.d.ts

@@ -0,0 +1,12 @@
+import type { Token } from "../lexer/types.js";
+import type { Plugin } from "../plugin.js";
+export interface ParserContext {
+    tokens: Token[];
+    pos: number;
+    source: string;
+    depth: number;
+    plugins?: Plugin[];
+}
+export declare function current(ctx: ParserContext): Token;
+export declare function advance(ctx: ParserContext): Token;
+export declare function expect(ctx: ParserContext, type: string, value?: string): Token;

package/dist/expressions/parser/parser-context.js

@@ -0,0 +1,14 @@
+import { ExpressionError } from "../errors/expression-error.js";
+export function current(ctx) {
+    return ctx.tokens[ctx.pos];
+}
+export function advance(ctx) {
+    return ctx.tokens[ctx.pos++];
+}
+export function expect(ctx, type, value) {
+    const tok = current(ctx);
+    if (tok.type !== type || (value !== undefined && tok.value !== value)) {
+        throw new ExpressionError(`Expected ${value ? `"${value}"` : type} but got ${tok.value ? `"${tok.value}"` : tok.type}`, { source: ctx.source, start: tok.start, end: tok.end });
+    }
+    return advance(ctx);
+}

package/dist/expressions/parser/precedence.d.ts

@@ -0,0 +1 @@
+export declare const PRECEDENCE: Readonly<Record<string, number | undefined>>;

package/dist/expressions/parser/precedence.js

@@ -0,0 +1,8 @@
+export const PRECEDENCE = {
+    "+": 50,
+    "-": 50,
+    "*": 60,
+    "/": 60,
+    "%": 60,
+    "**": 70,
+};