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

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,
+};

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

@@ -0,0 +1,97 @@
+import type { BinaryExpressionOperator, UnaryOperator } from "../lexer/types.js";
+interface BaseNode {
+    start: number;
+    end: number;
+}
+export interface NumberLiteral extends BaseNode {
+    type: "NumberLiteral";
+    value: number;
+}
+export interface StringLiteral extends BaseNode {
+    type: "StringLiteral";
+    value: string;
+}
+export interface BooleanLiteral extends BaseNode {
+    type: "BooleanLiteral";
+    value: boolean;
+}
+export interface NullLiteral extends BaseNode {
+    type: "NullLiteral";
+    value: null;
+}
+export interface UndefinedLiteral extends BaseNode {
+    type: "UndefinedLiteral";
+    value: undefined;
+}
+export interface Identifier extends BaseNode {
+    type: "Identifier";
+    name: string;
+}
+export interface BinaryExpression extends BaseNode {
+    type: "BinaryExpression";
+    operator: BinaryExpressionOperator;
+    left: ASTNode;
+    right: ASTNode;
+}
+export interface UnaryExpression extends BaseNode {
+    type: "UnaryExpression";
+    operator: UnaryOperator;
+    operand: ASTNode;
+}
+export interface ConditionalExpression extends BaseNode {
+    type: "ConditionalExpression";
+    test: ASTNode;
+    consequent: ASTNode;
+    alternate: ASTNode;
+}
+export interface MemberExpression extends BaseNode {
+    type: "MemberExpression";
+    object: ASTNode;
+    property: ASTNode;
+    computed: boolean;
+}
+export interface OptionalMemberExpression extends BaseNode {
+    type: "OptionalMemberExpression";
+    object: ASTNode;
+    property: ASTNode;
+    computed: boolean;
+}
+export interface ArrayLiteral extends BaseNode {
+    type: "ArrayLiteral";
+    readonly elements: readonly (ASTNode | SpreadElement)[];
+}
+export interface ObjectLiteral extends BaseNode {
+    type: "ObjectLiteral";
+    readonly properties: readonly ObjectProperty[];
+}
+export interface ObjectProperty extends BaseNode {
+    type: "ObjectProperty";
+    key: ASTNode;
+    value: ASTNode;
+    computed: boolean;
+}
+export interface CallExpression extends BaseNode {
+    type: "CallExpression";
+    callee: ASTNode;
+    readonly args: readonly ASTNode[];
+}
+export interface PipeExpression extends BaseNode {
+    type: "PipeExpression";
+    input: ASTNode;
+    transform: ASTNode;
+}
+export interface TemplateLiteral extends BaseNode {
+    type: "TemplateLiteral";
+    readonly parts: readonly (StringLiteral | ASTNode)[];
+}
+export interface SpreadElement extends BaseNode {
+    type: "SpreadElement";
+    argument: ASTNode;
+}
+export interface ArrowFunctionExpression extends BaseNode {
+    type: "ArrowFunctionExpression";
+    params: string[];
+    body: ASTNode;
+}
+export type ASTNode = NumberLiteral | StringLiteral | BooleanLiteral | NullLiteral | UndefinedLiteral | Identifier | BinaryExpression | UnaryExpression | ConditionalExpression | MemberExpression | OptionalMemberExpression | ArrayLiteral | ObjectLiteral | CallExpression | PipeExpression | TemplateLiteral | SpreadElement | ArrowFunctionExpression;
+export {};

package/dist/expressions/parser/types.js

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

package/dist/expressions/plugin.d.ts

@@ -0,0 +1,20 @@
+import type { ASTNode } from "./parser/types.js";
+import type { ParserContext } from "./parser/parser-context.js";
+export type EvalFn = (node: ASTNode, context: Record<string, unknown>) => unknown;
+export interface Plugin {
+    name: string;
+    scan?: (source: string, pos: number) => {
+        type: string;
+        value: string;
+        end: number;
+    } | null;
+    parsePrefix?: (ctx: ParserContext) => ASTNode | null;
+    parseInfix?: (ctx: ParserContext, left: ASTNode, minPrec: number) => ASTNode | null;
+    parsePostfix?: (ctx: ParserContext, node: ASTNode) => ASTNode | null;
+    parseUnary?: (ctx: ParserContext, parseNext: (ctx: ParserContext) => ASTNode) => ASTNode | null;
+    infixPrecedence?: (ctx: ParserContext) => number | undefined;
+    optimize?: (node: ASTNode, optimize: (n: ASTNode) => ASTNode) => ASTNode | null;
+    evaluate?: (node: ASTNode, context: Record<string, unknown>, evaluate: EvalFn) => {
+        value: unknown;
+    } | null;
+}

package/dist/expressions/plugin.js

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

package/dist/expressions/plugins/access.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "../plugin.js";
+export declare const accessPlugin: Plugin;

package/dist/expressions/plugins/access.js

@@ -0,0 +1,138 @@
+import { current, advance, expect } from "../parser/parser-context.js";
+import { parseExpression } from "../parser/parse-expression.js";
+export const accessPlugin = {
+    name: "access",
+    parsePostfix: (ctx, node) => {
+        const tok = current(ctx);
+        // Member access: .prop
+        if (tok.type === "Punctuation" && tok.value === ".") {
+            advance(ctx);
+            const prop = expect(ctx, "Identifier");
+            return {
+                type: "MemberExpression",
+                object: node,
+                property: { type: "Identifier", name: prop.value, start: prop.start, end: prop.end },
+                computed: false,
+                start: node.start,
+                end: prop.end,
+            };
+        }
+        // Computed member access: [expr]
+        if (tok.type === "Punctuation" && tok.value === "[") {
+            advance(ctx);
+            const property = parseExpression(ctx, 0);
+            const end = expect(ctx, "Punctuation", "]").end;
+            return {
+                type: "MemberExpression",
+                object: node,
+                property,
+                computed: true,
+                start: node.start,
+                end,
+            };
+        }
+        // Optional chaining: ?.prop or ?.[expr]
+        if (tok.type === "OptionalChain") {
+            advance(ctx);
+            if (current(ctx).type === "Punctuation" && current(ctx).value === "[") {
+                advance(ctx);
+                const property = parseExpression(ctx, 0);
+                const end = expect(ctx, "Punctuation", "]").end;
+                return {
+                    type: "OptionalMemberExpression",
+                    object: node,
+                    property,
+                    computed: true,
+                    start: node.start,
+                    end,
+                };
+            }
+            const prop = expect(ctx, "Identifier");
+            return {
+                type: "OptionalMemberExpression",
+                object: node,
+                property: { type: "Identifier", name: prop.value, start: prop.start, end: prop.end },
+                computed: false,
+                start: node.start,
+                end: prop.end,
+            };
+        }
+        // Function call: (args)
+        if (tok.type === "Punctuation" && tok.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;
+            return {
+                type: "CallExpression",
+                callee: node,
+                args,
+                start: node.start,
+                end,
+            };
+        }
+        return null;
+    },
+    optimize: (node, opt) => {
+        if (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") {
+            const n = node;
+            return {
+                ...node,
+                object: opt(n.object),
+                property: n.computed ? opt(n.property) : n.property,
+            };
+        }
+        if (node.type === "CallExpression") {
+            const n = node;
+            return { ...node, callee: opt(n.callee), args: n.args.map((a) => opt(a)) };
+        }
+        return null;
+    },
+    evaluate: (node, context, evalFn) => {
+        if (node.type === "MemberExpression") {
+            const n = node;
+            const object = evalFn(n.object, context);
+            if (n.computed) {
+                const property = evalFn(n.property, context);
+                return { value: object[property] };
+            }
+            return { value: object[n.property.name] };
+        }
+        if (node.type === "OptionalMemberExpression") {
+            const n = node;
+            const object = evalFn(n.object, context);
+            if (object == null)
+                return { value: undefined };
+            if (n.computed) {
+                const property = evalFn(n.property, context);
+                return { value: object[property] };
+            }
+            return { value: object[n.property.name] };
+        }
+        if (node.type === "CallExpression") {
+            const n = node;
+            const args = n.args.map((a) => evalFn(a, context));
+            // Method call — preserve this binding
+            if (n.callee.type === "MemberExpression" || n.callee.type === "OptionalMemberExpression") {
+                const obj = evalFn(n.callee.object, context);
+                if (n.callee.type === "OptionalMemberExpression" && obj == null) {
+                    return { value: undefined };
+                }
+                const prop = n.callee.computed
+                    ? evalFn(n.callee.property, context)
+                    : n.callee.property.name;
+                const method = obj[prop];
+                return { value: method.apply(obj, args) };
+            }
+            const fn = evalFn(n.callee, context);
+            return { value: fn(...args) };
+        }
+        return null;
+    },
+};

package/dist/expressions/plugins/arrows.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "../plugin.js";
+export declare const arrowsPlugin: Plugin;