@hyperfixi/core 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 HyperFixi Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,218 @@
+# @lokascript/core
+
+🚀 **Complete hyperscript implementation with 100% \_hyperscript compatibility**
+
+An experimental hyperscript engine that provides fast parsing, command execution, and comprehensive error handling for web applications. Built with TypeScript-first design and full compatibility with the official \_hyperscript library.
+
+## Features
+
+- 🎯 **100% \_hyperscript Compatible** - Full compatibility with official \_hyperscript library
+- 🚀 **High Performance** - Optimized tokenizer and parser for large expressions
+- 🔧 **TypeScript First** - Complete type safety with comprehensive type definitions
+- 🧪 **Thoroughly Tested** - 2800+ tests with 98.5%+ reliability
+- 🌊 **Complete Command System** - All major commands implemented (PUT, SET, ADD, SHOW/HIDE, etc.)
+- ⚡ **HTML Integration** - Automatic `_=""` attribute processing and event binding
+- 🛡️ **Error Recovery** - Graceful handling of syntax errors with helpful guidance
+
+## Installation
+
+```bash
+npm install @lokascript/core
+# or
+yarn add @lokascript/core
+```
+
+## Quick Start
+
+```typescript
+import { hyperscript } from '@lokascript/core';
+
+// Simple expression evaluation
+const result = await hyperscript.run('5 + 3 * 2'); // Returns 11
+
+// DOM manipulation with commands
+const button = document.getElementById('myButton');
+const context = hyperscript.createContext(button);
+
+await hyperscript.run('hide me', context); // Hides the button
+await hyperscript.run('put "Hello World" into my innerHTML', context);
+await hyperscript.run('set my className to "active"', context);
+```
+
+### HTML Integration (Automatic)
+
+```html
+<!-- Automatic attribute processing - works out of the box -->
+<button _="on click put 'Hello!' into #output">Click me</button>
+<div id="output"></div>
+
+<!-- Complex interactions -->
+<button _="on click set my innerHTML to 'Clicked!' then wait 1s then hide me">
+  Temporary Button
+</button>
+```
+
+## Debugging
+
+LokaScript includes a built-in debug control API for troubleshooting compilation and execution issues.
+
+### Enable Debug Logging
+
+```javascript
+// In browser console
+lokascript.debugControl.enable(); // Enable detailed logging
+// Reload page to see logs
+
+lokascript.debugControl.disable(); // Disable logging
+lokascript.debugControl.isEnabled(); // Check if enabled
+lokascript.debugControl.status(); // Get detailed status
+```
+
+Debug settings persist across page reloads via localStorage. Logs include:
+
+- Parser selection (semantic vs traditional)
+- Expression evaluation steps
+- Command execution flow
+- Event handling
+
+### Compilation Metadata
+
+Every compilation returns metadata about parser usage and warnings:
+
+```javascript
+const result = lokascript.compile('toggle .active');
+console.log(result.metadata);
+// {
+//   parserUsed: 'semantic',
+//   semanticConfidence: 0.98,
+//   semanticLanguage: 'en',
+//   warnings: []
+// }
+```
+
+## Runtime Hooks
+
+LokaScript provides a hooks system for observing and intercepting command execution:
+
+```javascript
+import { HookRegistry, createHooks } from '@lokascript/core';
+
+// Create hooks for logging, analytics, or debugging
+const hooks = createHooks({
+  beforeExecute: ctx => {
+    console.log(`Executing: ${ctx.commandName}`);
+  },
+  afterExecute: (ctx, result) => {
+    console.log(`Completed: ${ctx.commandName}`, result);
+  },
+  onError: (ctx, error) => {
+    console.error(`Error in ${ctx.commandName}:`, error);
+    return error; // Can transform or wrap the error
+  },
+  interceptCommand: (name, ctx) => {
+    // Return true to skip command execution
+    return name === 'disabled-command';
+  },
+});
+
+// Register hooks with the runtime
+lokascript.registerHooks('my-hooks', hooks);
+```
+
+Built-in hook utilities:
+
+- `loggingHooks()` - Pre-configured debug logging hooks
+- `createTimingHooks()` - Performance timing hooks
+
+## Cleanup & Memory Management
+
+The runtime automatically tracks event listeners and observers for cleanup when elements are removed from the DOM. You can also manually trigger cleanup:
+
+```javascript
+// Clean up a specific element
+lokascript.cleanup(element);
+
+// Clean up element and all descendants
+lokascript.cleanupTree(containerElement);
+
+// Get cleanup statistics
+const stats = lokascript.getCleanupStats();
+// { elementsTracked: 5, listeners: 12, observers: 2, ... }
+
+// Full runtime shutdown
+lokascript.destroy();
+```
+
+## API Reference
+
+For complete API documentation, see [API.md](./docs/API.md).
+
+### Main Methods
+
+- `hyperscript.compile(code)` - Compile hyperscript to AST
+- `hyperscript.execute(ast, context)` - Execute compiled AST
+- `hyperscript.run(code, context)` - Compile and execute in one step
+- `hyperscript.createContext(element)` - Create execution context
+- `evalHyperScript(code, context)` - \_hyperscript compatibility API
+- `hyperscript.registerHooks(name, hooks)` - Register runtime hooks
+- `hyperscript.cleanup(element)` - Clean up element resources
+- `hyperscript.destroy()` - Full runtime shutdown
+
+## Supported Features
+
+### Commands (All Implemented)
+
+- **DOM Manipulation**: `hide me`, `show me`, `toggle me`
+- **Content Management**: `put "text" into me`, `set my innerHTML to "content"`
+- **CSS Classes**: `add .class to me`, `remove .class from me`
+- **Data Operations**: `increment x`, `decrement y`
+- **Control Flow**: `if condition`, `repeat N times`, `break`, `continue`
+- **Async Operations**: `wait 500ms`, `fetch "/api/data"`
+- **Events**: `send customEvent to me`
+
+### Expressions (100% \_hyperscript Compatible)
+
+- **Arithmetic**: `5 + 3 * 2`, `value / 2`, `x mod 3`
+- **Logical**: `true and false`, `value > 10`, `x contains y`
+- **Property Access**: `my property`, `element.property`, `object's method()`
+- **Context Variables**: `me`, `it`, `you`, `result`
+- **Type Conversion**: `"123" as Int`, `form as Values`
+- **CSS Selectors**: `<button/>`, `closest <form/>`
+
+### HTML Integration
+
+- **Automatic Processing**: All `_=""` attributes processed automatically
+- **Event Binding**: `on click`, `on submit`, `on change` etc.
+- **DOM Context**: Automatic `me`, `you`, `it` context setup
+
+## Examples
+
+See [EXAMPLES.md](./docs/EXAMPLES.md) for comprehensive usage examples.
+
+## Compatibility Testing
+
+This package includes compatibility tests that validate LokaScript against the official \_hyperscript library:
+
+```bash
+# Run compatibility tests with official hyperscript test suite
+npm run test:browser
+
+# Run only command compatibility tests
+npx playwright test --grep "Command Tests"
+
+# Run only expression compatibility tests
+npx playwright test --grep "Expression Tests"
+```
+
+The compatibility tests measure:
+
+- **Expression compatibility**: **100%** (15/15 tests passing) ✅
+- **Command compatibility**: **100%** (2/2 core tests passing) ✅
+- **HTML Integration**: **100%** (3/3 integration tests passing) ✅
+- **Overall compatibility**: **~95%** across all hyperscript features ✅
+
+View detailed test results at `http://localhost:9323` after running browser tests.
+
+## License
+
+MIT - see [LICENSE](../../LICENSE) file for details.

package/dist/__test-utils__/context-builders.d.ts

@@ -0,0 +1,42 @@
+import type { TestExpressionContext } from '../test-utilities';
+export interface TestContextOptions {
+    element?: Element;
+    me?: Element;
+    you?: Element;
+    it?: unknown;
+    result?: unknown;
+    target?: EventTarget;
+    event?: Event;
+    globals?: Record<string, unknown>;
+    locals?: Map<string, unknown>;
+    meta?: Map<string, unknown> | Record<string, unknown>;
+    [key: string]: unknown;
+}
+export declare class TestContextBuilder {
+    private options;
+    withElement(element: Element): this;
+    withMe(me: Element): this;
+    withYou(you: Element): this;
+    withIt(it: unknown): this;
+    withResult(result: unknown): this;
+    withTarget(target: EventTarget): this;
+    withEvent(event: Event): this;
+    withGlobal<T>(key: string, value: T): this;
+    withGlobals(globals: Record<string, unknown>): this;
+    withLocal<T>(key: string, value: T): this;
+    withLocals(locals: Record<string, unknown>): this;
+    withMeta(key: string, value: unknown): this;
+    withProperty<T>(key: string, value: T): this;
+    build(): TestExpressionContext;
+}
+export declare function createTestContext(options?: TestContextOptions): TestExpressionContext;
+export declare function createMinimalContext(element?: Element): TestExpressionContext;
+export declare function createMockElement(tagName?: string, attributes?: Record<string, string>): Element;
+export declare function createMockEvent(type: string, options?: {
+    target?: EventTarget;
+    currentTarget?: EventTarget;
+    bubbles?: boolean;
+    cancelable?: boolean;
+    [key: string]: unknown;
+}): Event;
+//# sourceMappingURL=context-builders.d.ts.map

package/dist/__test-utils__/error-testing.d.ts

@@ -0,0 +1,18 @@
+export declare function assertIsError(value: unknown): asserts value is Error;
+export declare function assertErrorType<T extends Error>(value: unknown, ErrorType: new (...args: unknown[]) => T): asserts value is T;
+export declare function expectErrorMessage(error: unknown, pattern: string | RegExp): void;
+export declare function expectThrows<T extends Error = Error>(fn: () => void, ErrorType?: new (...args: unknown[]) => T, messagePattern?: string | RegExp): T;
+export declare function expectThrowsAsync<T extends Error = Error>(fn: () => Promise<void>, ErrorType?: new (...args: unknown[]) => T, messagePattern?: string | RegExp): Promise<T>;
+export declare function handleError<T>(error: unknown, handler: (error: Error) => T, fallback?: (value: unknown) => T): T;
+export declare function hasErrorProperty<K extends string>(error: unknown, property: K): error is Error & Record<K, unknown>;
+export declare function getErrorProperty<T = unknown>(error: unknown, property: string): T | undefined;
+export declare function assertErrorHasProperty<K extends string>(error: unknown, property: K): asserts error is Error & Record<K, unknown>;
+export interface ErrorExpectation<T extends Error = Error> {
+    type?: new (...args: unknown[]) => T;
+    message?: string | RegExp;
+    code?: string;
+    properties?: Record<string, unknown>;
+}
+export declare function expectThrowsMatching<T extends Error = Error>(fn: () => void, expectation: ErrorExpectation<T>): T;
+export declare function expectThrowsMatchingAsync<T extends Error = Error>(fn: () => Promise<void>, expectation: ErrorExpectation<T>): Promise<T>;
+//# sourceMappingURL=error-testing.d.ts.map

package/dist/__test-utils__/index.d.ts

@@ -0,0 +1,6 @@
+export * from './parser-helpers';
+export * from './mock-types';
+export * from './error-testing';
+export * from './context-builders';
+export { isCommandNode, assertCommandNode, assertNodeHasProperty, type ParsedStatementResult, type ParsingMetadata, type ASTNodeAssertable, } from '../parser/__types__/test-helpers';
+//# sourceMappingURL=index.d.ts.map

package/dist/__test-utils__/mock-types.d.ts

@@ -0,0 +1,57 @@
+export interface MockFunction<TArgs extends unknown[] = unknown[], TReturn = unknown> {
+    (...args: TArgs): TReturn;
+    calls: TArgs[];
+    lastCall?: TArgs;
+    returnValue?: TReturn;
+    callCount: number;
+}
+export declare function createMockFunction<TArgs extends unknown[] = unknown[], TReturn = unknown>(implementation?: (...args: TArgs) => TReturn): MockFunction<TArgs, TReturn>;
+export interface MockWebSocketAPI {
+    postMessage<T extends Record<string, unknown> = Record<string, unknown>>(data: T, transferables?: Transferable[]): void;
+    addEventListener(event: string, handler: EventListener): void;
+    removeEventListener(event: string, handler: EventListener): void;
+    close(): void;
+    readyState: number;
+    url: string;
+}
+export declare function createMockWebSocket(url?: string): MockWebSocketAPI;
+export interface MockEventSourceAPI {
+    simulateMessage<T = string>(data: T, eventType?: 'message' | 'open' | 'error', lastEventId?: string): void;
+    addEventListener(event: string, handler: EventListener): void;
+    removeEventListener(event: string, handler: EventListener): void;
+    close(): void;
+    readyState: number;
+    url: string;
+}
+export declare function createMockEventSource(url?: string): MockEventSourceAPI;
+export interface MockWorkerAPI {
+    postMessage<T = unknown>(message: T, transfer?: Transferable[]): void;
+    addEventListener(type: string, listener: EventListener): void;
+    removeEventListener(type: string, listener: EventListener): void;
+    terminate(): void;
+    onmessage: ((event: MessageEvent) => void) | null;
+    onerror: ((event: ErrorEvent) => void) | null;
+}
+export declare function createMockWorker(): MockWorkerAPI;
+export interface MockExpressResponse<T = unknown> {
+    json(data: T): this;
+    send(data: T): this;
+    status(code: number): this;
+    header(name: string, value: string): this;
+    contentType(type: string): this;
+    getStatusCode(): number;
+    getData(): T | undefined;
+    getHeaders(): Record<string, string>;
+}
+export declare function createMockExpressResponse<T = unknown>(): MockExpressResponse<T>;
+export interface MockExpressRequest<T = unknown> {
+    method: string;
+    url: string;
+    body: T;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    headers: Record<string, string>;
+    get(header: string): string | undefined;
+}
+export declare function createMockExpressRequest<T = unknown>(options?: Partial<MockExpressRequest<T>>): MockExpressRequest<T>;
+//# sourceMappingURL=mock-types.d.ts.map

package/dist/__test-utils__/parser-context-mock.d.ts

@@ -0,0 +1,7 @@
+import type { ParserContext } from '../parser/parser-types';
+import type { Token } from '../types/core';
+export declare function createMockParserContext(tokens?: Token[], overrides?: Record<string, any>): ParserContext;
+export declare function createToken(value: string, kind?: string, start?: number): Token;
+export declare function createTokenStream(values: string[], kinds?: string[]): Token[];
+export declare function createMockParserContextAt(tokens: Token[], position: number, overrides?: Record<string, any>): ParserContext;
+//# sourceMappingURL=parser-context-mock.d.ts.map

package/dist/__test-utils__/parser-helpers.d.ts

@@ -0,0 +1,38 @@
+import type { CommandNode, ASTNode, Token, ParseError } from '../parser/types';
+export interface ParserTestSuccess {
+    success: true;
+    node: CommandNode;
+    tokens: Token[];
+    errors?: ParseError[];
+}
+export interface ParserTestFailure {
+    success: false;
+    error: Error | ParseError;
+    input: string;
+    tokens?: Token[];
+}
+export type ParserTestResult = ParserTestSuccess | ParserTestFailure;
+export declare function isParseSuccess(result: ParserTestResult): result is ParserTestSuccess;
+export declare function isParseFailure(result: ParserTestResult): result is ParserTestFailure;
+export declare function assertParseSuccess(result: ParserTestResult): asserts result is ParserTestSuccess;
+export declare function assertParseFailure(result: ParserTestResult): asserts result is ParserTestFailure;
+export declare function expectASTStructure(node: ASTNode | CommandNode, expected: Partial<CommandNode | ASTNode>): void;
+export declare function expectNodeProperty<T = unknown>(node: ASTNode | CommandNode, property: string, expectedValue?: T): void;
+export declare function expectCommandNode(node: ASTNode, expectedName: string): asserts node is CommandNode;
+export declare function expectNodeType<T extends ASTNode>(node: ASTNode, expectedType: T['type']): asserts node is T;
+export declare function getCommandArguments(node: ASTNode): ASTNode[];
+export declare function getCommandTarget(node: ASTNode): ASTNode | undefined;
+export declare function getNodeProperty<T = unknown>(node: ASTNode | CommandNode, property: string): T | undefined;
+export declare class TestNodeBuilder {
+    private node;
+    withName(name: string): this;
+    withArguments(...args: ASTNode[]): this;
+    withTarget(target: ASTNode): this;
+    withPosition(start: number, end: number, line?: number, column?: number): this;
+    build(): CommandNode;
+}
+export declare function createTestCommandNode(name: string, args?: ASTNode[]): CommandNode;
+export declare function createTestLiteral(value: string | number | boolean | null): ASTNode;
+export declare function createTestIdentifier(name: string): ASTNode;
+export declare function createTestSelector(selector: string): ASTNode;
+//# sourceMappingURL=parser-helpers.d.ts.map

package/dist/api/dom-processor.d.ts

@@ -0,0 +1,17 @@
+import type { ASTNode, ExecutionContext } from '../types/core';
+import type { CompileResult } from './hyperscript-api';
+type CompileFunction = (code: string, options?: any) => CompileResult;
+type CompileAsyncFunction = (code: string, options?: any) => Promise<CompileResult>;
+type GetRuntimeFunction = () => any;
+export declare function initializeDOMProcessor(compileSync: CompileFunction, compileAsync: CompileAsyncFunction, getRuntime: GetRuntimeFunction): void;
+export declare function detectLanguage(element: Element): string;
+export declare function extractEventInfo(ast: ASTNode): {
+    eventType: string;
+    body: ASTNode;
+} | null;
+export declare function setupEventHandler(element: Element, ast: ASTNode, context: ExecutionContext): void;
+export declare function createHyperscriptContext(element?: HTMLElement | null): ExecutionContext;
+export declare function processHyperscriptAttribute(element: Element, hyperscriptCode: string): void;
+export declare function process(element: Element): void;
+export {};
+//# sourceMappingURL=dom-processor.d.ts.map

package/dist/api/hyperscript-api.d.ts

@@ -0,0 +1,68 @@
+import { Runtime, type RuntimeOptions } from '../runtime/runtime';
+import type { ASTNode, ExecutionContext } from '../types/base-types';
+import type { RuntimeHooks } from '../types/hooks';
+declare global {
+    interface Window {
+        _hyperscript?: {
+            runtime?: Runtime;
+            behaviors?: Runtime['behaviorAPI'];
+        };
+    }
+}
+export interface HyperscriptConfig {
+    semantic: boolean;
+    language: string;
+    confidenceThreshold: number;
+}
+export declare const config: HyperscriptConfig;
+export interface CompileError {
+    message: string;
+    line: number;
+    column: number;
+    suggestion?: string;
+}
+export interface NewCompileOptions {
+    language?: string;
+    traditional?: boolean;
+}
+export interface CompileResult {
+    ok: boolean;
+    ast?: ASTNode;
+    errors?: CompileError[];
+    meta: {
+        parser: 'semantic' | 'traditional';
+        confidence?: number;
+        language: string;
+        timeMs: number;
+        directPath?: boolean;
+    };
+}
+export interface ValidateResult {
+    valid: boolean;
+    errors?: CompileError[];
+}
+export interface HyperscriptAPI {
+    compile(code: string, options?: NewCompileOptions): Promise<CompileResult>;
+    compileSync(code: string, options?: NewCompileOptions): CompileResult;
+    execute(ast: ASTNode, context?: ExecutionContext): Promise<unknown>;
+    eval(code: string, context?: ExecutionContext | Element, options?: NewCompileOptions): Promise<unknown>;
+    validate(code: string, options?: NewCompileOptions): Promise<ValidateResult>;
+    process(element: Element): void;
+    createContext(element?: HTMLElement | null, parent?: ExecutionContext): ExecutionContext;
+    version: string;
+    config: HyperscriptConfig;
+    createRuntime(options?: RuntimeOptions): Runtime;
+    registerHooks(name: string, hooks: RuntimeHooks): void;
+    unregisterHooks(name: string): boolean;
+    getRegisteredHooks(): string[];
+    clearCache(): void;
+    getCacheStats(): {
+        size: number;
+        hits: number;
+        misses: number;
+        hitRate: number;
+    };
+}
+export declare const hyperscript: HyperscriptAPI;
+export declare const _hyperscript: HyperscriptAPI;
+//# sourceMappingURL=hyperscript-api.d.ts.map

package/dist/api/lokascript-api.d.ts

@@ -0,0 +1,9 @@
+import { hyperscript, config } from './hyperscript-api.js';
+import type { HyperscriptAPI } from './hyperscript-api.js';
+export declare const lokascript: HyperscriptAPI;
+export declare const _lokascript: HyperscriptAPI;
+export { hyperscript };
+export { config };
+export type LokascriptAPI = HyperscriptAPI;
+export type { HyperscriptAPI, HyperscriptConfig, CompileResult, CompileError, NewCompileOptions, ValidateResult, } from './hyperscript-api.js';
+//# sourceMappingURL=lokascript-api.d.ts.map

package/dist/ast-utils/analyzer.d.ts

@@ -0,0 +1,19 @@
+import type { ASTNode, ComplexityMetrics, CodeSmell, AnalysisResult, DependencyGraph, CodeSuggestion, PatternMatch } from './types.js';
+export declare function calculateComplexity(ast: ASTNode): ComplexityMetrics;
+export declare function detectCodeSmells(ast: ASTNode): CodeSmell[];
+export declare function analyzeDependencies(ast: ASTNode): DependencyGraph;
+export declare function findDeadCode(ast: ASTNode): Array<{
+    type: 'unused-variable' | 'unreachable-code';
+    name?: string;
+    location: {
+        start?: number;
+        end?: number;
+        line?: number;
+        column?: number;
+    };
+    message: string;
+}>;
+export declare function suggestOptimizations(ast: ASTNode): CodeSuggestion[];
+export declare function analyzePatterns(ast: ASTNode): PatternMatch[];
+export declare function analyzeMetrics(ast: ASTNode): AnalysisResult;
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/ast-utils/documentation.d.ts

@@ -0,0 +1,8 @@
+import type { ASTNode, DocumentationOutput, MarkdownOptions } from './types.js';
+export declare function generateDocumentation(ast: ASTNode): DocumentationOutput;
+export declare function generateMarkdown(ast: ASTNode, options?: MarkdownOptions): string;
+export declare function generateHTML(ast: ASTNode, options?: {
+    title?: string;
+}): string;
+export declare function generateJSON(ast: ASTNode): string;
+//# sourceMappingURL=documentation.d.ts.map

package/dist/ast-utils/generator.d.ts

@@ -0,0 +1,9 @@
+import type { ASTNode, GeneratorOptions, GeneratorResult } from './types.js';
+export type { GeneratorOptions, GeneratorResult };
+export declare function generate(ast: ASTNode, options?: GeneratorOptions): string;
+export declare function generateWithMetadata(ast: ASTNode, options?: GeneratorOptions): GeneratorResult;
+export declare function generateCommand(node: ASTNode, opts?: GeneratorOptions): string;
+export declare function generateExpression(node: ASTNode, opts?: GeneratorOptions): string;
+export declare function minify(ast: ASTNode): string;
+export declare function format(ast: ASTNode, indentation?: string): string;
+//# sourceMappingURL=generator.d.ts.map

package/dist/ast-utils/index.d.ts

@@ -0,0 +1,12 @@
+export type { ASTNode as ASTUtilNode, VisitorContext, VisitorHandlers, QueryMatch, ComplexityMetrics, CodeSmell, AnalysisResult, PatternMatch, TransformOptions, OptimizationPass, DependencyGraph, VariableUsage, CodeSuggestion, GeneratorOptions, GeneratorResult, DocumentationOutput, EventHandlerDoc, BehaviorDoc, FunctionDoc, CommandDoc, CodeMetrics, MarkdownOptions, } from './types.js';
+export { ASTVisitor, visit, findNodes, findFirst, getAncestors, createTypeCollector, measureDepth, countNodeTypes, createVisitorContext, } from './visitor.js';
+export { calculateComplexity, detectCodeSmells, analyzeMetrics, analyzeDependencies, findDeadCode, suggestOptimizations, analyzePatterns, } from './analyzer.js';
+export { generate, generateWithMetadata, generateCommand, generateExpression, minify, format, } from './generator.js';
+export { generateDocumentation, generateMarkdown, generateHTML, generateJSON, } from './documentation.js';
+export { query, queryAll, parseSelector, queryXPath } from './query.js';
+export { transform, optimize, applyOptimizationPasses, normalize, inlineVariables, extractCommonExpressions, createOptimizationPass, } from './transformer.js';
+export type { InterchangeNode, BaseNode as InterchangeBaseNode, EventNode as InterchangeEventNode, CommandNode as InterchangeCommandNode, LiteralNode as InterchangeLiteralNode, IdentifierNode as InterchangeIdentifierNode, SelectorNode as InterchangeSelectorNode, VariableNode as InterchangeVariableNode, BinaryNode as InterchangeBinaryNode, UnaryNode as InterchangeUnaryNode, MemberNode as InterchangeMemberNode, PossessiveNode as InterchangePossessiveNode, CallNode as InterchangeCallNode, IfNode as InterchangeIfNode, RepeatNode as InterchangeRepeatNode, ForEachNode as InterchangeForEachNode, WhileNode as InterchangeWhileNode, PositionalNode as InterchangePositionalNode, EventModifiers as InterchangeEventModifiers, } from './interchange/index.js';
+export { fromCoreAST, toCoreAST } from './interchange/index.js';
+export { interchangeToLSPDiagnostics, interchangeToLSPSymbols, interchangeToLSPHover, interchangeToLSPCompletions, calculateCyclomatic, calculateCognitive, } from './interchange/index.js';
+export type { LSPPosition, LSPRange, LSPDiagnostic, LSPDiagnosticSeverity, LSPDocumentSymbol, LSPSymbolKind, LSPCompletionItem, LSPCompletionItemKind, LSPHoverInfo, } from './interchange/index.js';
+//# sourceMappingURL=index.d.ts.map