@hyperfixi/core 2.0.0

package/dist/multilingual/index.js

@@ -0,0 +1,285 @@
+'use strict';
+
+var semantic = require('@lokascript/semantic');
+
+let _semanticModule = null;
+async function getSemanticModule() {
+    if (!_semanticModule) {
+        _semanticModule = await import('@lokascript/semantic');
+    }
+    return _semanticModule;
+}
+class SemanticGrammarBridge {
+    constructor(config = {}) {
+        this.analyzer = null;
+        this.config = {
+            confidenceThreshold: config.confidenceThreshold ?? semantic.DEFAULT_CONFIDENCE_THRESHOLD,
+            fallbackOnLowConfidence: config.fallbackOnLowConfidence ?? true,
+        };
+    }
+    async initialize() {
+        const semantic = await getSemanticModule();
+        this.analyzer = semantic.createSemanticAnalyzer();
+    }
+    isInitialized() {
+        return this.analyzer !== null;
+    }
+    async transform(input, sourceLang, targetLang) {
+        if (!this.isInitialized()) {
+            await this.initialize();
+        }
+        if (sourceLang === targetLang) {
+            return {
+                output: input,
+                usedSemantic: false,
+                confidence: 1.0,
+                sourceLang,
+                targetLang,
+            };
+        }
+        const semantic = await getSemanticModule();
+        try {
+            const output = semantic.translate(input, sourceLang, targetLang);
+            if (output !== input) {
+                return {
+                    output,
+                    usedSemantic: true,
+                    confidence: 0.9,
+                    sourceLang,
+                    targetLang,
+                };
+            }
+        }
+        catch {
+        }
+        return {
+            output: input,
+            usedSemantic: false,
+            confidence: 0,
+            sourceLang,
+            targetLang,
+        };
+    }
+    async parse(input, lang) {
+        if (!this.isInitialized()) {
+            await this.initialize();
+        }
+        if (!this.analyzer)
+            return null;
+        const result = this.analyzer.analyze(input, lang);
+        return result.node ?? null;
+    }
+    async render(node, targetLang) {
+        const semantic = await getSemanticModule();
+        return semantic.render(node, targetLang);
+    }
+    async parseToAST(input, lang) {
+        if (!this.isInitialized()) {
+            await this.initialize();
+        }
+        if (!this.analyzer)
+            return null;
+        const result = this.analyzer.analyze(input, lang);
+        if (result.confidence >= this.config.confidenceThreshold && result.node) {
+            const semantic = await getSemanticModule();
+            try {
+                const buildResult = semantic.buildAST(result.node);
+                return buildResult.ast;
+            }
+            catch (error) {
+                console.warn('[SemanticGrammarBridge] AST build failed, using fallback:', error);
+            }
+        }
+        return null;
+    }
+    async parseToASTWithDetails(input, lang) {
+        if (!this.isInitialized()) {
+            await this.initialize();
+        }
+        if (!this.analyzer) {
+            return {
+                ast: null,
+                usedDirectPath: false,
+                confidence: 0,
+                lang,
+                fallbackText: null,
+            };
+        }
+        const result = this.analyzer.analyze(input, lang);
+        const semantic = await getSemanticModule();
+        if (result.confidence >= this.config.confidenceThreshold && result.node) {
+            try {
+                const buildResult = semantic.buildAST(result.node);
+                return {
+                    ast: buildResult.ast,
+                    usedDirectPath: true,
+                    confidence: result.confidence,
+                    lang,
+                    fallbackText: null,
+                    warnings: buildResult.warnings,
+                };
+            }
+            catch {
+            }
+        }
+        if (result.node && this.config.fallbackOnLowConfidence) {
+            const englishText = semantic.render(result.node, 'en');
+            return {
+                ast: null,
+                usedDirectPath: false,
+                confidence: result.confidence,
+                lang,
+                fallbackText: englishText,
+            };
+        }
+        return {
+            ast: null,
+            usedDirectPath: false,
+            confidence: result.confidence,
+            lang,
+            fallbackText: null,
+        };
+    }
+    async getAllTranslations(input, sourceLang) {
+        const semantic = await getSemanticModule();
+        const languages = semantic.getSupportedLanguages();
+        const results = {};
+        for (const lang of languages) {
+            results[lang] = await this.transform(input, sourceLang, lang);
+        }
+        return results;
+    }
+}
+let _defaultBridge = null;
+async function getDefaultBridge() {
+    if (!_defaultBridge) {
+        _defaultBridge = new SemanticGrammarBridge();
+        await _defaultBridge.initialize();
+    }
+    return _defaultBridge;
+}
+async function translate(input, sourceLang, targetLang) {
+    const bridge = await getDefaultBridge();
+    const result = await bridge.transform(input, sourceLang, targetLang);
+    return result.output;
+}
+
+class MultilingualHyperscript {
+    constructor(config = {}) {
+        this.initialized = false;
+        this.bridge = new SemanticGrammarBridge(config);
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        await this.bridge.initialize();
+        this.initialized = true;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    async ensureInitialized() {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+    }
+    async parse(input, lang = 'en') {
+        await this.ensureInitialized();
+        return this.bridge.parse(input, lang);
+    }
+    async parseToAST(input, lang = 'en') {
+        await this.ensureInitialized();
+        return this.bridge.parseToAST(input, lang);
+    }
+    async parseToASTWithDetails(input, lang = 'en') {
+        await this.ensureInitialized();
+        return this.bridge.parseToASTWithDetails(input, lang);
+    }
+    async translate(input, from, to) {
+        await this.ensureInitialized();
+        const result = await this.bridge.transform(input, from, to);
+        return result.output;
+    }
+    async translateWithDetails(input, from, to) {
+        await this.ensureInitialized();
+        return this.bridge.transform(input, from, to);
+    }
+    async render(node, lang) {
+        await this.ensureInitialized();
+        return this.bridge.render(node, lang);
+    }
+    async getAllTranslations(input, from) {
+        await this.ensureInitialized();
+        return this.bridge.getAllTranslations(input, from);
+    }
+    getSupportedLanguages() {
+        return [
+            'en',
+            'ja',
+            'ar',
+            'es',
+            'ko',
+            'zh',
+            'tr',
+            'pt',
+            'fr',
+            'de',
+            'id',
+            'qu',
+            'sw',
+        ];
+    }
+    isLanguageSupported(lang) {
+        return this.getSupportedLanguages().includes(lang);
+    }
+    getLanguageInfo(lang) {
+        return LANGUAGE_INFO[lang];
+    }
+    getAllLanguageInfo() {
+        return { ...LANGUAGE_INFO };
+    }
+}
+const LANGUAGE_INFO = {
+    en: { code: 'en', name: 'English', nativeName: 'English', direction: 'ltr', wordOrder: 'SVO' },
+    ja: { code: 'ja', name: 'Japanese', nativeName: '日本語', direction: 'ltr', wordOrder: 'SOV' },
+    ar: { code: 'ar', name: 'Arabic', nativeName: 'العربية', direction: 'rtl', wordOrder: 'VSO' },
+    es: { code: 'es', name: 'Spanish', nativeName: 'Español', direction: 'ltr', wordOrder: 'SVO' },
+    ko: { code: 'ko', name: 'Korean', nativeName: '한국어', direction: 'ltr', wordOrder: 'SOV' },
+    zh: { code: 'zh', name: 'Chinese', nativeName: '中文', direction: 'ltr', wordOrder: 'SVO' },
+    tr: { code: 'tr', name: 'Turkish', nativeName: 'Türkçe', direction: 'ltr', wordOrder: 'SOV' },
+    pt: {
+        code: 'pt',
+        name: 'Portuguese',
+        nativeName: 'Português',
+        direction: 'ltr',
+        wordOrder: 'SVO',
+    },
+    fr: { code: 'fr', name: 'French', nativeName: 'Français', direction: 'ltr', wordOrder: 'SVO' },
+    de: { code: 'de', name: 'German', nativeName: 'Deutsch', direction: 'ltr', wordOrder: 'SVO' },
+    id: {
+        code: 'id',
+        name: 'Indonesian',
+        nativeName: 'Bahasa Indonesia',
+        direction: 'ltr',
+        wordOrder: 'SVO',
+    },
+    qu: { code: 'qu', name: 'Quechua', nativeName: 'Runasimi', direction: 'ltr', wordOrder: 'SOV' },
+    sw: { code: 'sw', name: 'Swahili', nativeName: 'Kiswahili', direction: 'ltr', wordOrder: 'SVO' },
+};
+let _defaultInstance = null;
+async function getMultilingual() {
+    if (!_defaultInstance) {
+        _defaultInstance = new MultilingualHyperscript();
+        await _defaultInstance.initialize();
+    }
+    return _defaultInstance;
+}
+const multilingual = new MultilingualHyperscript();
+
+exports.MultilingualHyperscript = MultilingualHyperscript;
+exports.SemanticGrammarBridge = SemanticGrammarBridge;
+exports.getDefaultBridge = getDefaultBridge;
+exports.getMultilingual = getMultilingual;
+exports.multilingual = multilingual;
+exports.translate = translate;
+//# sourceMappingURL=index.js.map

package/dist/multilingual/index.mjs

@@ -0,0 +1,278 @@
+import { DEFAULT_CONFIDENCE_THRESHOLD } from '@lokascript/semantic';
+
+let _semanticModule = null;
+async function getSemanticModule() {
+    if (!_semanticModule) {
+        _semanticModule = await import('@lokascript/semantic');
+    }
+    return _semanticModule;
+}
+class SemanticGrammarBridge {
+    constructor(config = {}) {
+        this.analyzer = null;
+        this.config = {
+            confidenceThreshold: config.confidenceThreshold ?? DEFAULT_CONFIDENCE_THRESHOLD,
+            fallbackOnLowConfidence: config.fallbackOnLowConfidence ?? true,
+        };
+    }
+    async initialize() {
+        const semantic = await getSemanticModule();
+        this.analyzer = semantic.createSemanticAnalyzer();
+    }
+    isInitialized() {
+        return this.analyzer !== null;
+    }
+    async transform(input, sourceLang, targetLang) {
+        if (!this.isInitialized()) {
+            await this.initialize();
+        }
+        if (sourceLang === targetLang) {
+            return {
+                output: input,
+                usedSemantic: false,
+                confidence: 1.0,
+                sourceLang,
+                targetLang,
+            };
+        }
+        const semantic = await getSemanticModule();
+        try {
+            const output = semantic.translate(input, sourceLang, targetLang);
+            if (output !== input) {
+                return {
+                    output,
+                    usedSemantic: true,
+                    confidence: 0.9,
+                    sourceLang,
+                    targetLang,
+                };
+            }
+        }
+        catch {
+        }
+        return {
+            output: input,
+            usedSemantic: false,
+            confidence: 0,
+            sourceLang,
+            targetLang,
+        };
+    }
+    async parse(input, lang) {
+        if (!this.isInitialized()) {
+            await this.initialize();
+        }
+        if (!this.analyzer)
+            return null;
+        const result = this.analyzer.analyze(input, lang);
+        return result.node ?? null;
+    }
+    async render(node, targetLang) {
+        const semantic = await getSemanticModule();
+        return semantic.render(node, targetLang);
+    }
+    async parseToAST(input, lang) {
+        if (!this.isInitialized()) {
+            await this.initialize();
+        }
+        if (!this.analyzer)
+            return null;
+        const result = this.analyzer.analyze(input, lang);
+        if (result.confidence >= this.config.confidenceThreshold && result.node) {
+            const semantic = await getSemanticModule();
+            try {
+                const buildResult = semantic.buildAST(result.node);
+                return buildResult.ast;
+            }
+            catch (error) {
+                console.warn('[SemanticGrammarBridge] AST build failed, using fallback:', error);
+            }
+        }
+        return null;
+    }
+    async parseToASTWithDetails(input, lang) {
+        if (!this.isInitialized()) {
+            await this.initialize();
+        }
+        if (!this.analyzer) {
+            return {
+                ast: null,
+                usedDirectPath: false,
+                confidence: 0,
+                lang,
+                fallbackText: null,
+            };
+        }
+        const result = this.analyzer.analyze(input, lang);
+        const semantic = await getSemanticModule();
+        if (result.confidence >= this.config.confidenceThreshold && result.node) {
+            try {
+                const buildResult = semantic.buildAST(result.node);
+                return {
+                    ast: buildResult.ast,
+                    usedDirectPath: true,
+                    confidence: result.confidence,
+                    lang,
+                    fallbackText: null,
+                    warnings: buildResult.warnings,
+                };
+            }
+            catch {
+            }
+        }
+        if (result.node && this.config.fallbackOnLowConfidence) {
+            const englishText = semantic.render(result.node, 'en');
+            return {
+                ast: null,
+                usedDirectPath: false,
+                confidence: result.confidence,
+                lang,
+                fallbackText: englishText,
+            };
+        }
+        return {
+            ast: null,
+            usedDirectPath: false,
+            confidence: result.confidence,
+            lang,
+            fallbackText: null,
+        };
+    }
+    async getAllTranslations(input, sourceLang) {
+        const semantic = await getSemanticModule();
+        const languages = semantic.getSupportedLanguages();
+        const results = {};
+        for (const lang of languages) {
+            results[lang] = await this.transform(input, sourceLang, lang);
+        }
+        return results;
+    }
+}
+let _defaultBridge = null;
+async function getDefaultBridge() {
+    if (!_defaultBridge) {
+        _defaultBridge = new SemanticGrammarBridge();
+        await _defaultBridge.initialize();
+    }
+    return _defaultBridge;
+}
+async function translate(input, sourceLang, targetLang) {
+    const bridge = await getDefaultBridge();
+    const result = await bridge.transform(input, sourceLang, targetLang);
+    return result.output;
+}
+
+class MultilingualHyperscript {
+    constructor(config = {}) {
+        this.initialized = false;
+        this.bridge = new SemanticGrammarBridge(config);
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        await this.bridge.initialize();
+        this.initialized = true;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    async ensureInitialized() {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+    }
+    async parse(input, lang = 'en') {
+        await this.ensureInitialized();
+        return this.bridge.parse(input, lang);
+    }
+    async parseToAST(input, lang = 'en') {
+        await this.ensureInitialized();
+        return this.bridge.parseToAST(input, lang);
+    }
+    async parseToASTWithDetails(input, lang = 'en') {
+        await this.ensureInitialized();
+        return this.bridge.parseToASTWithDetails(input, lang);
+    }
+    async translate(input, from, to) {
+        await this.ensureInitialized();
+        const result = await this.bridge.transform(input, from, to);
+        return result.output;
+    }
+    async translateWithDetails(input, from, to) {
+        await this.ensureInitialized();
+        return this.bridge.transform(input, from, to);
+    }
+    async render(node, lang) {
+        await this.ensureInitialized();
+        return this.bridge.render(node, lang);
+    }
+    async getAllTranslations(input, from) {
+        await this.ensureInitialized();
+        return this.bridge.getAllTranslations(input, from);
+    }
+    getSupportedLanguages() {
+        return [
+            'en',
+            'ja',
+            'ar',
+            'es',
+            'ko',
+            'zh',
+            'tr',
+            'pt',
+            'fr',
+            'de',
+            'id',
+            'qu',
+            'sw',
+        ];
+    }
+    isLanguageSupported(lang) {
+        return this.getSupportedLanguages().includes(lang);
+    }
+    getLanguageInfo(lang) {
+        return LANGUAGE_INFO[lang];
+    }
+    getAllLanguageInfo() {
+        return { ...LANGUAGE_INFO };
+    }
+}
+const LANGUAGE_INFO = {
+    en: { code: 'en', name: 'English', nativeName: 'English', direction: 'ltr', wordOrder: 'SVO' },
+    ja: { code: 'ja', name: 'Japanese', nativeName: '日本語', direction: 'ltr', wordOrder: 'SOV' },
+    ar: { code: 'ar', name: 'Arabic', nativeName: 'العربية', direction: 'rtl', wordOrder: 'VSO' },
+    es: { code: 'es', name: 'Spanish', nativeName: 'Español', direction: 'ltr', wordOrder: 'SVO' },
+    ko: { code: 'ko', name: 'Korean', nativeName: '한국어', direction: 'ltr', wordOrder: 'SOV' },
+    zh: { code: 'zh', name: 'Chinese', nativeName: '中文', direction: 'ltr', wordOrder: 'SVO' },
+    tr: { code: 'tr', name: 'Turkish', nativeName: 'Türkçe', direction: 'ltr', wordOrder: 'SOV' },
+    pt: {
+        code: 'pt',
+        name: 'Portuguese',
+        nativeName: 'Português',
+        direction: 'ltr',
+        wordOrder: 'SVO',
+    },
+    fr: { code: 'fr', name: 'French', nativeName: 'Français', direction: 'ltr', wordOrder: 'SVO' },
+    de: { code: 'de', name: 'German', nativeName: 'Deutsch', direction: 'ltr', wordOrder: 'SVO' },
+    id: {
+        code: 'id',
+        name: 'Indonesian',
+        nativeName: 'Bahasa Indonesia',
+        direction: 'ltr',
+        wordOrder: 'SVO',
+    },
+    qu: { code: 'qu', name: 'Quechua', nativeName: 'Runasimi', direction: 'ltr', wordOrder: 'SOV' },
+    sw: { code: 'sw', name: 'Swahili', nativeName: 'Kiswahili', direction: 'ltr', wordOrder: 'SVO' },
+};
+let _defaultInstance = null;
+async function getMultilingual() {
+    if (!_defaultInstance) {
+        _defaultInstance = new MultilingualHyperscript();
+        await _defaultInstance.initialize();
+    }
+    return _defaultInstance;
+}
+const multilingual = new MultilingualHyperscript();
+
+export { MultilingualHyperscript, SemanticGrammarBridge, getDefaultBridge, getMultilingual, multilingual, translate };
+//# sourceMappingURL=index.mjs.map

package/dist/parser/__types__/test-helpers.d.ts

@@ -0,0 +1,25 @@
+import type { CommandNode, ASTNode, Token } from '../types';
+import type { ParserContext } from '../parser-types';
+export interface ParsedStatementResult {
+    node: CommandNode;
+    tokens: Token[];
+    context?: ParserContext;
+    metadata?: ParsingMetadata;
+}
+export interface ParsingMetadata {
+    duration?: number;
+    warnings?: string[];
+    [key: string]: unknown;
+}
+export interface ASTNodeAssertable extends CommandNode {
+    name: string;
+    type: 'Command';
+    children?: CommandNode[];
+    arguments: ASTNode[];
+    target?: ASTNode;
+}
+export declare function isCommandNode(node: unknown): node is CommandNode;
+export declare function assertCommandNode(node: unknown): asserts node is CommandNode;
+export declare function getNodeProperty<T = unknown>(node: unknown, property: string): T | undefined;
+export declare function assertNodeHasProperty<T = unknown>(node: unknown, property: string): asserts node is Record<string, T>;
+//# sourceMappingURL=test-helpers.d.ts.map

package/dist/parser/command-node-builder.d.ts

@@ -0,0 +1,45 @@
+import type { Token, CommandNode, ExpressionNode, ASTNode, StatementNode } from '../types/core';
+export declare class CommandNodeBuilder {
+    private name;
+    private args;
+    private body?;
+    private implicitTarget?;
+    private isBlocking;
+    private modifiers?;
+    private originalCmd?;
+    private startPos?;
+    private endPos?;
+    private constructor();
+    static from(token: Token): CommandNodeBuilder;
+    static fromIdentifier(node: {
+        name: string;
+        start?: number;
+        end?: number;
+        line?: number;
+        column?: number;
+    }): CommandNodeBuilder;
+    static named(name: string): CommandNodeBuilder;
+    withArgs(...args: ASTNode[]): this;
+    withBody(body: StatementNode[]): this;
+    withImplicitTarget(target: ExpressionNode): this;
+    withModifier(key: string, value: ExpressionNode): this;
+    withModifiers(modifiers: Record<string, ExpressionNode>): this;
+    withName(name: string): this;
+    withOriginalCommand(name: string): this;
+    blocking(value?: boolean): this;
+    startingAt(source: Token | {
+        start?: number;
+        end?: number;
+        line?: number;
+        column?: number;
+    }): this;
+    endingAt(position: {
+        start?: number;
+        end: number;
+        line?: number;
+        column?: number;
+    }): this;
+    build(): CommandNode;
+    clone(): CommandNodeBuilder;
+}
+//# sourceMappingURL=command-node-builder.d.ts.map

package/dist/parser/command-parsers/animation-commands.d.ts

@@ -0,0 +1,5 @@
+import type { ParserContext, IdentifierNode } from '../parser-types';
+import type { Token } from '../../types/core';
+export declare function parseMeasureCommand(ctx: ParserContext, identifierNode: IdentifierNode): import("../../types/core").CommandNode;
+export declare function parseTransitionCommand(ctx: ParserContext, commandToken: Token): import("../../types/core").CommandNode;
+//# sourceMappingURL=animation-commands.d.ts.map

package/dist/parser/command-parsers/async-commands.d.ts

@@ -0,0 +1,5 @@
+import type { ParserContext } from '../parser-types';
+import type { Token } from '../../types/core';
+export declare function parseWaitCommand(ctx: ParserContext, commandToken: Token): import("../../types/core").CommandNode;
+export declare function parseInstallCommand(ctx: ParserContext, commandToken: Token): import("../../types/core").CommandNode;
+//# sourceMappingURL=async-commands.d.ts.map

package/dist/parser/command-parsers/control-flow-commands.d.ts

@@ -0,0 +1,7 @@
+import type { ParserContext, IdentifierNode } from '../parser-types';
+import type { CommandNode, Token } from '../../types/core';
+export declare function parseHaltCommand(ctx: ParserContext, identifierNode: IdentifierNode): CommandNode | null;
+export declare function parseRepeatCommand(ctx: ParserContext, commandToken: Token): CommandNode;
+export declare function parseIfCommand(ctx: ParserContext, commandToken: Token): CommandNode;
+export declare function parseForCommand(ctx: ParserContext, commandToken: Token): CommandNode;
+//# sourceMappingURL=control-flow-commands.d.ts.map

package/dist/parser/command-parsers/dom-commands.d.ts

@@ -0,0 +1,8 @@
+import type { ParserContext, IdentifierNode } from '../parser-types';
+import type { Token } from '../../types/core';
+export declare function parseRemoveCommand(ctx: ParserContext, identifierNode: IdentifierNode): import("../../types/core").CommandNode;
+export declare function parseToggleCommand(ctx: ParserContext, identifierNode: IdentifierNode): import("../../types/core").CommandNode;
+export declare function parseAddCommand(ctx: ParserContext, commandToken: Token): import("../../types/core").CommandNode;
+export declare function parsePutCommand(ctx: ParserContext, identifierNode: IdentifierNode): import("../../types/core").CommandNode | null;
+export declare function parseSwapCommand(ctx: ParserContext, identifierNode: IdentifierNode): import("../../types/core").CommandNode;
+//# sourceMappingURL=dom-commands.d.ts.map

package/dist/parser/command-parsers/event-commands.d.ts

@@ -0,0 +1,4 @@
+import type { ParserContext, IdentifierNode } from '../parser-types';
+import type { CommandNode } from '../../types/core';
+export declare function parseTriggerCommand(ctx: ParserContext, identifierNode: IdentifierNode): CommandNode | null;
+//# sourceMappingURL=event-commands.d.ts.map

package/dist/parser/command-parsers/utility-commands.d.ts

@@ -0,0 +1,9 @@
+import type { ParserContext, IdentifierNode } from '../parser-types';
+import type { Token, CommandNode } from '../../types/core';
+export declare function parseCompoundCommand(ctx: ParserContext, identifierNode: IdentifierNode): CommandNode | null;
+export declare function parseRegularCommand(ctx: ParserContext, identifierNode: IdentifierNode): CommandNode;
+export declare function parseMultiWordCommand(ctx: ParserContext, commandToken: Token, commandName: string): CommandNode | null;
+export declare function parseFetchCommand(ctx: ParserContext, commandToken: Token): CommandNode;
+export declare function parseJsCommand(ctx: ParserContext, identifierNode: IdentifierNode): CommandNode;
+export declare function parseTellCommand(ctx: ParserContext, identifierNode: IdentifierNode): CommandNode;
+//# sourceMappingURL=utility-commands.d.ts.map