@hyperfixi/core 3.3.0 → 4.0.1

package/dist/lse/index.cjs

@@ -1,84 +0,0 @@
-'use strict';
-
-let _fw = null;
-async function getFramework() {
-    if (!_fw) {
-        try {
-            _fw = await import('@lokascript/framework');
-        }
-        catch {
-            throw new Error('@lokascript/framework is required for LSE support. ' +
-                'Install it: npm install @lokascript/framework');
-        }
-    }
-    return _fw;
-}
-function isLSEAvailable() {
-    if (_fw)
-        return true;
-    try {
-        require.resolve('@lokascript/framework');
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function parseExplicit(input, options) {
-    const fw = await getFramework();
-    return fw.parseExplicit(input, options);
-}
-async function isExplicitSyntax(input) {
-    const fw = await getFramework();
-    return fw.isExplicitSyntax(input);
-}
-async function renderExplicit(node) {
-    const fw = await getFramework();
-    return fw.renderExplicit(node);
-}
-async function fromInterchangeNode(node) {
-    const fw = await getFramework();
-    return fw.fromInterchangeNode(node);
-}
-async function toProtocolJSON(node) {
-    const fw = await getFramework();
-    return fw.toProtocolJSON(node);
-}
-async function fromProtocolJSON(json) {
-    const fw = await getFramework();
-    return fw.fromProtocolJSON(json);
-}
-async function validateProtocolJSON(json) {
-    const fw = await getFramework();
-    return fw.validateProtocolJSON(json);
-}
-async function toEnvelopeJSON(envelope) {
-    const fw = await getFramework();
-    return fw.toEnvelopeJSON(envelope);
-}
-async function fromEnvelopeJSON(json) {
-    const fw = await getFramework();
-    return fw.fromEnvelopeJSON(json);
-}
-async function isEnvelope(json) {
-    const fw = await getFramework();
-    return fw.isEnvelope(json);
-}
-async function semanticNodeToRuntimeAST(node) {
-    const fw = await getFramework();
-    return fw.semanticNodeToRuntimeAST(node);
-}
-
-exports.fromEnvelopeJSON = fromEnvelopeJSON;
-exports.fromInterchangeNode = fromInterchangeNode;
-exports.fromProtocolJSON = fromProtocolJSON;
-exports.isEnvelope = isEnvelope;
-exports.isExplicitSyntax = isExplicitSyntax;
-exports.isLSEAvailable = isLSEAvailable;
-exports.parseExplicit = parseExplicit;
-exports.renderExplicit = renderExplicit;
-exports.semanticNodeToRuntimeAST = semanticNodeToRuntimeAST;
-exports.toEnvelopeJSON = toEnvelopeJSON;
-exports.toProtocolJSON = toProtocolJSON;
-exports.validateProtocolJSON = validateProtocolJSON;
-//# sourceMappingURL=index.cjs.map

package/dist/lse/index.d.ts

@@ -1,15 +0,0 @@
-export type { SemanticNode, CommandSemanticNode, EventHandlerSemanticNode, ConditionalSemanticNode, CompoundSemanticNode, LoopSemanticNode, SemanticValue, LiteralValue, SelectorValue, ReferenceValue, PropertyPathValue, ExpressionValue, FlagValue, SemanticMetadata, ActionType, SemanticRoleType, Annotation, ProtocolDiagnostic, LSEEnvelope, Diagnostic, DiagnosticSeverity, DiagnosticResult, } from '@lokascript/framework';
-export type { SemanticJSON, SchemaLookup, ParseExplicitOptions, IRDiagnostic, ProtocolNodeJSON, ProtocolValueJSON, ProtocolDiagnosticJSON, AnnotationJSON, MatchArmJSON, LSEEnvelopeJSON, RuntimeASTNode, RuntimeCommandNode, RuntimeEventNode, } from '@lokascript/framework';
-export declare function isLSEAvailable(): boolean;
-export declare function parseExplicit(input: string, options?: import('@lokascript/framework').ParseExplicitOptions): Promise<import("@lokascript/intent").SemanticNode>;
-export declare function isExplicitSyntax(input: string): Promise<boolean>;
-export declare function renderExplicit(node: import('@lokascript/framework').SemanticNode): Promise<string>;
-export declare function fromInterchangeNode(node: unknown): Promise<import("@lokascript/intent").SemanticNode>;
-export declare function toProtocolJSON(node: import('@lokascript/framework').SemanticNode): Promise<import("@lokascript/intent").ProtocolNodeJSON>;
-export declare function fromProtocolJSON(json: import('@lokascript/framework').ProtocolNodeJSON): Promise<import("@lokascript/intent").SemanticNode>;
-export declare function validateProtocolJSON(json: unknown): Promise<import("@lokascript/intent").IRDiagnostic[]>;
-export declare function toEnvelopeJSON(envelope: import('@lokascript/framework').LSEEnvelope): Promise<import("@lokascript/intent").LSEEnvelopeJSON>;
-export declare function fromEnvelopeJSON(json: import('@lokascript/framework').LSEEnvelopeJSON): Promise<import("@lokascript/intent").LSEEnvelope>;
-export declare function isEnvelope(json: unknown): Promise<boolean>;
-export declare function semanticNodeToRuntimeAST(node: import('@lokascript/framework').SemanticNode): Promise<import("@lokascript/framework").RuntimeASTNode>;
-//# sourceMappingURL=index.d.ts.map

package/dist/lse/index.mjs

@@ -1,71 +0,0 @@
-let _fw = null;
-async function getFramework() {
-    if (!_fw) {
-        try {
-            _fw = await import('@lokascript/framework');
-        }
-        catch {
-            throw new Error('@lokascript/framework is required for LSE support. ' +
-                'Install it: npm install @lokascript/framework');
-        }
-    }
-    return _fw;
-}
-function isLSEAvailable() {
-    if (_fw)
-        return true;
-    try {
-        require.resolve('@lokascript/framework');
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function parseExplicit(input, options) {
-    const fw = await getFramework();
-    return fw.parseExplicit(input, options);
-}
-async function isExplicitSyntax(input) {
-    const fw = await getFramework();
-    return fw.isExplicitSyntax(input);
-}
-async function renderExplicit(node) {
-    const fw = await getFramework();
-    return fw.renderExplicit(node);
-}
-async function fromInterchangeNode(node) {
-    const fw = await getFramework();
-    return fw.fromInterchangeNode(node);
-}
-async function toProtocolJSON(node) {
-    const fw = await getFramework();
-    return fw.toProtocolJSON(node);
-}
-async function fromProtocolJSON(json) {
-    const fw = await getFramework();
-    return fw.fromProtocolJSON(json);
-}
-async function validateProtocolJSON(json) {
-    const fw = await getFramework();
-    return fw.validateProtocolJSON(json);
-}
-async function toEnvelopeJSON(envelope) {
-    const fw = await getFramework();
-    return fw.toEnvelopeJSON(envelope);
-}
-async function fromEnvelopeJSON(json) {
-    const fw = await getFramework();
-    return fw.fromEnvelopeJSON(json);
-}
-async function isEnvelope(json) {
-    const fw = await getFramework();
-    return fw.isEnvelope(json);
-}
-async function semanticNodeToRuntimeAST(node) {
-    const fw = await getFramework();
-    return fw.semanticNodeToRuntimeAST(node);
-}
-
-export { fromEnvelopeJSON, fromInterchangeNode, fromProtocolJSON, isEnvelope, isExplicitSyntax, isLSEAvailable, parseExplicit, renderExplicit, semanticNodeToRuntimeAST, toEnvelopeJSON, toProtocolJSON, validateProtocolJSON };
-//# sourceMappingURL=index.mjs.map

package/dist/multilingual/bridge.d.ts

@@ -1,38 +0,0 @@
-import type { SemanticNode, ASTNode } from '@lokascript/semantic';
-import type { FrontEnd } from '../parser/semantic-integration';
-export interface BridgeConfig {
-    confidenceThreshold?: number;
-    fallbackOnLowConfidence?: boolean;
-}
-export interface BridgeResult {
-    output: string;
-    usedSemantic: boolean;
-    confidence: number;
-    sourceLang: string;
-    targetLang: string;
-}
-export interface ParseToASTResult {
-    ast: ASTNode | null;
-    usedDirectPath: boolean;
-    confidence: number;
-    lang: string;
-    fallbackText: string | null;
-    warnings?: string[];
-}
-export declare class SemanticGrammarBridge {
-    private _initialized;
-    private config;
-    constructor(config?: BridgeConfig);
-    initialize(): Promise<void>;
-    isInitialized(): boolean;
-    transform(input: string, sourceLang: string, targetLang: string): Promise<BridgeResult>;
-    parse(input: string, lang: string): Promise<SemanticNode | null>;
-    render(node: SemanticNode, targetLang: string): Promise<string>;
-    parseToAST(input: string, lang: string): Promise<ASTNode | null>;
-    parseToASTWithDetails(input: string, lang: string): Promise<ParseToASTResult>;
-    getAllTranslations(input: string, sourceLang: string): Promise<Record<string, BridgeResult>>;
-}
-export declare function createBridgeFrontEnd(bridge: SemanticGrammarBridge): FrontEnd;
-export declare function getDefaultBridge(): Promise<SemanticGrammarBridge>;
-export declare function translate(input: string, sourceLang: string, targetLang: string): Promise<string>;
-//# sourceMappingURL=bridge.d.ts.map

package/dist/multilingual/schema-roles.d.ts

@@ -1,3 +0,0 @@
-import type { RoleInferrer } from '../ast-utils/interchange/from-core';
-export declare const schemaRoleInferrer: RoleInferrer;
-//# sourceMappingURL=schema-roles.d.ts.map

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

@@ -1,25 +0,0 @@
-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-grammar.d.ts

@@ -1,14 +0,0 @@
-export type PositionalRule = 'none' | 'expression' | 'primary';
-export interface CommandGrammar {
-    readonly positional: PositionalRule;
-    readonly markers: readonly string[];
-    readonly commaList?: readonly string[];
-    readonly namedArgs?: readonly string[];
-    readonly continuation?: readonly string[];
-    readonly syntax: string;
-}
-export declare const DEDICATED_PARSER_COMMANDS: ReadonlySet<string>;
-export declare const COMMAND_GRAMMAR: Readonly<Record<string, CommandGrammar>>;
-export declare const PLUGIN_COMMAND_GRAMMAR: CommandGrammar;
-export declare function grammarOf(commandName: string): CommandGrammar | null;
-//# sourceMappingURL=command-grammar.d.ts.map

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

@@ -1,46 +0,0 @@
-import type { Token, CommandNode, ExpressionNode, ASTNode, StatementNode } from '../types/core';
-import type { SlotKey, SlotMap, SlottedCommandName } from '../ast/command-slots';
-export declare class CommandNodeBuilder<K extends SlottedCommandName = SlottedCommandName> {
-    private name;
-    private args;
-    private body?;
-    private implicitTarget?;
-    private isBlocking;
-    private modifiers?;
-    private originalCmd?;
-    private startPos?;
-    private endPos?;
-    private constructor();
-    static from<K extends SlottedCommandName = SlottedCommandName>(token: Token): CommandNodeBuilder<K>;
-    static fromIdentifier<K extends SlottedCommandName = SlottedCommandName>(node: {
-        name: string;
-        start?: number;
-        end?: number;
-        line?: number;
-        column?: number;
-    }): CommandNodeBuilder<K>;
-    static named<K extends SlottedCommandName = SlottedCommandName>(name: string): CommandNodeBuilder<K>;
-    withArgs(...args: ASTNode[]): this;
-    withBody(body: StatementNode[]): this;
-    withImplicitTarget(target: ExpressionNode): this;
-    withModifier(key: SlotKey<K>, value: ExpressionNode): this;
-    withModifiers(modifiers: SlotMap<K>): 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

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

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

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

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

@@ -1,7 +0,0 @@
-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/declared-commands.d.ts

@@ -1,6 +0,0 @@
-import type { ASTNode } from '../../types/base-types';
-import type { ParserContext } from '../parser-types';
-import type { Token } from '../../types/core';
-import type { CommandGrammar } from '../command-grammar';
-export declare function parseDeclaredCommand(ctx: ParserContext, commandToken: Token, name: string, grammar: CommandGrammar): ASTNode;
-//# sourceMappingURL=declared-commands.d.ts.map

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

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

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

@@ -1,4 +0,0 @@
-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/navigation-commands.d.ts

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

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

@@ -1,14 +0,0 @@
-import type { ParserContext, IdentifierNode } from '../parser-types';
-import type { ASTNode, Token, CommandNode } from '../../types/core';
-type DedicatedCommandParser = (ctx: ParserContext, identifierNode: IdentifierNode) => CommandNode | null;
-export declare const COMPOUND_COMMAND_PARSERS: ReadonlyMap<string, DedicatedCommandParser>;
-export declare const COMPOUND_COMMAND_NAMES: ReadonlySet<string>;
-export declare function parseCompoundCommand(ctx: ParserContext, identifierNode: IdentifierNode): CommandNode | null;
-export declare function isNakedURLStart(ctx: ParserContext): boolean;
-export declare function parseBareURLPath(ctx: ParserContext): ASTNode | 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;
-export declare function parsePickCommand(ctx: ParserContext, identifierNode: IdentifierNode): CommandNode;
-export {};
-//# sourceMappingURL=utility-commands.d.ts.map

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

@@ -1,12 +0,0 @@
-import type { ParserContext, IdentifierNode } from '../parser-types';
-import type { ASTNode, Token } from '../../types/core';
-export declare function parseColonVariable(ctx: ParserContext): IdentifierNode | null;
-export declare function parseScopedVariable(ctx: ParserContext): IdentifierNode | null;
-export declare function parsePropertyOfTarget(ctx: ParserContext, startPosition: number): ASTNode | null;
-export declare function parseTargetFallback(ctx: ParserContext): {
-    expression: ASTNode | null;
-    tokens: ASTNode[];
-};
-export declare function parseSetCommand(ctx: ParserContext, identifierNode: IdentifierNode): import("../..").CommandNode;
-export declare function parseIncrementDecrementCommand(ctx: ParserContext, commandToken: Token): import("../..").CommandNode;
-//# sourceMappingURL=variable-commands.d.ts.map

package/dist/parser/error-handler.d.ts

@@ -1,34 +0,0 @@
-import type { Token, ParseError } from '../types/core';
-export interface ErrorContext {
-    parsing: 'expression' | 'binary_op' | 'unary_op' | 'call' | 'member' | 'primary' | 'parentheses' | 'string' | 'command';
-    expected?: string[];
-    operators?: string[];
-    lastValidToken?: Token;
-}
-export interface EnhancedParseError extends ParseError {
-    context?: ErrorContext;
-    suggestion?: string;
-    recovery?: string;
-}
-export declare class ErrorHandler {
-    private errors;
-    private tokens;
-    private position;
-    constructor(tokens: Token[], position?: number);
-    addError(message: string, context: ErrorContext, token?: Token): EnhancedParseError;
-    getPrimaryError(): EnhancedParseError | undefined;
-    getAllErrors(): EnhancedParseError[];
-    private enhanceErrorMessage;
-    private generateSuggestion;
-    private generateRecoveryStrategy;
-    private checkTypos;
-    private isTypo;
-    private levenshteinDistance;
-    advance(): void;
-    setPosition(position: number): void;
-    getPosition(): number;
-    private getCurrentToken;
-    static detectErrorPatterns(tokens: Token[]): EnhancedParseError[];
-}
-export declare function createErrorHandler(tokens: Token[], position?: number): ErrorHandler;
-//# sourceMappingURL=error-handler.d.ts.map

package/dist/parser/extensions.d.ts

@@ -1,43 +0,0 @@
-import type { BindingPowerEntry, InfixHandler, PrefixHandler } from './pratt-parser';
-import type { ASTNode, ExecutionContext } from '../types/base-types';
-import type { Token } from '../types/core';
-import type { ParserContext } from './parser-types';
-export { setGlobal, notifyGlobalRead, notifyLocalWrite, notifyLocalRead, getGlobalWriteHooks, getLocalWriteHooks, type GlobalWriteHook, type GlobalReadHook, type LocalWriteHook, type LocalReadHook, } from '../core/scope-hooks';
-import type { GlobalWriteHook, GlobalReadHook, LocalWriteHook, LocalReadHook } from '../core/scope-hooks';
-export type FeatureParseFn = (ctx: ParserContext, token: Token) => ASTNode | null;
-export type NodeEvaluatorFn = (node: ASTNode, context: ExecutionContext) => unknown | Promise<unknown>;
-export type NodeWriterFn = (node: ASTNode, value: unknown, context: ExecutionContext) => void | Promise<void>;
-export declare function getRegisteredFeature(name: string): FeatureParseFn | undefined;
-export declare function getRegisteredNodeEvaluator(type: string): NodeEvaluatorFn | undefined;
-export declare function getRegisteredNodeWriter(type: string): NodeWriterFn | undefined;
-export interface ParserExtensionSnapshot {
-    commands: string[];
-    operators: string[];
-    prattEntries: Array<[string, BindingPowerEntry]>;
-    features: Array<[string, FeatureParseFn]>;
-    nodeEvaluators: Array<[string, NodeEvaluatorFn]>;
-    nodeWriters: Array<[string, NodeWriterFn]>;
-    globalWriteHooks: GlobalWriteHook[];
-    globalReadHooks: GlobalReadHook[];
-    localWriteHooks: LocalWriteHook[];
-    localReadHooks: LocalReadHook[];
-}
-export declare class ParserExtensionRegistry {
-    registerCommand(name: string): void;
-    registerCompoundOperator(token: string): void;
-    registerInfixOperator(token: string, leftBp: number, rightBp: number, handler: InfixHandler): void;
-    registerPrefixOperator(token: string, bp: number, handler: PrefixHandler): void;
-    hasCommand(name: string): boolean;
-    registerFeature(keyword: string, parseFn: FeatureParseFn): void;
-    hasFeature(name: string): boolean;
-    registerNodeEvaluator(nodeType: string, fn: NodeEvaluatorFn): void;
-    registerNodeWriter(nodeType: string, fn: NodeWriterFn): void;
-    registerGlobalWriteHook(hook: GlobalWriteHook): () => void;
-    registerGlobalReadHook(hook: GlobalReadHook): () => void;
-    registerLocalWriteHook(hook: LocalWriteHook): () => void;
-    registerLocalReadHook(hook: LocalReadHook): () => void;
-    snapshot(): ParserExtensionSnapshot;
-    restore(snapshot: ParserExtensionSnapshot): void;
-}
-export declare function getParserExtensionRegistry(): ParserExtensionRegistry;
-//# sourceMappingURL=extensions.d.ts.map