@hyperfixi/core 3.3.0 → 4.0.1

package/dist/expressions/logical/index.d.ts

@@ -1,61 +0,0 @@
-import type { RuntimeValidator } from '../../validation/lightweight-validators';
-import type { ExpressionImplementation } from '../../types/core';
-import type { ExpressionMetadata, LLMDocumentation } from '../../types/expression-types';
-interface EnhancedExpressionImplementation extends ExpressionImplementation {
-    metadata?: ExpressionMetadata;
-    documentation?: LLMDocumentation;
-    inputSchema?: RuntimeValidator<unknown>;
-}
-export declare const equalsExpression: EnhancedExpressionImplementation;
-export declare const strictEqualsExpression: ExpressionImplementation;
-export declare const notEqualsExpression: ExpressionImplementation;
-export declare const strictNotEqualsExpression: ExpressionImplementation;
-export declare const lessThanExpression: ExpressionImplementation;
-export declare const lessThanOrEqualExpression: ExpressionImplementation;
-export declare const greaterThanExpression: ExpressionImplementation;
-export declare const greaterThanOrEqualExpression: ExpressionImplementation;
-export declare const andExpression: EnhancedExpressionImplementation;
-export declare const orExpression: ExpressionImplementation;
-export declare const notExpression: ExpressionImplementation;
-export declare const isEmptyExpression: ExpressionImplementation;
-export declare const noExpression: ExpressionImplementation;
-export declare const isNotEmptyExpression: ExpressionImplementation;
-export declare const existsExpression: ExpressionImplementation;
-export declare const doesNotExistExpression: ExpressionImplementation;
-export declare const containsExpression: ExpressionImplementation;
-export declare const doesNotContainExpression: ExpressionImplementation;
-export declare const startsWithExpression: ExpressionImplementation;
-export declare const endsWithExpression: ExpressionImplementation;
-export declare const betweenExpression: ExpressionImplementation;
-export declare const matchesExpression: EnhancedExpressionImplementation;
-export declare const hasExpression: ExpressionImplementation;
-export declare const doesNotHaveExpression: ExpressionImplementation;
-export declare const logicalExpressions: {
-    readonly equals: EnhancedExpressionImplementation;
-    readonly strictEquals: ExpressionImplementation;
-    readonly notEquals: ExpressionImplementation;
-    readonly strictNotEquals: ExpressionImplementation;
-    readonly lessThan: ExpressionImplementation;
-    readonly lessThanOrEqual: ExpressionImplementation;
-    readonly greaterThan: ExpressionImplementation;
-    readonly greaterThanOrEqual: ExpressionImplementation;
-    readonly and: EnhancedExpressionImplementation;
-    readonly or: ExpressionImplementation;
-    readonly not: ExpressionImplementation;
-    readonly no: ExpressionImplementation;
-    readonly isEmpty: ExpressionImplementation;
-    readonly isNotEmpty: ExpressionImplementation;
-    readonly exists: ExpressionImplementation;
-    readonly doesNotExist: ExpressionImplementation;
-    readonly contains: ExpressionImplementation;
-    readonly doesNotContain: ExpressionImplementation;
-    readonly startsWith: ExpressionImplementation;
-    readonly endsWith: ExpressionImplementation;
-    readonly between: ExpressionImplementation;
-    readonly matches: EnhancedExpressionImplementation;
-    readonly has: ExpressionImplementation;
-    readonly doesNotHave: ExpressionImplementation;
-};
-export type LogicalExpressionName = keyof typeof logicalExpressions;
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/expressions/mathematical/index.d.ts

@@ -1,80 +0,0 @@
-import type { ValidationResult, TypedExecutionContext as TypedExpressionContext, EvaluationType, ExpressionMetadata, TypedResult, ExpressionCategory } from '../../types/index';
-interface BaseTypedExpression<T> {
-    readonly name: string;
-    readonly category: string;
-    readonly syntax: string;
-    readonly outputType: EvaluationType;
-    readonly metadata: ExpressionMetadata;
-    evaluate(context: TypedExpressionContext, input: unknown): Promise<TypedResult<T>>;
-    validate(input: unknown): ValidationResult;
-}
-export declare class AdditionExpression implements BaseTypedExpression<number> {
-    readonly name = "addition";
-    readonly category: ExpressionCategory;
-    readonly syntax = "left + right";
-    readonly outputType: EvaluationType;
-    readonly metadata: ExpressionMetadata;
-    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<number>>;
-    validate(input: unknown): ValidationResult;
-}
-export declare class SubtractionExpression implements BaseTypedExpression<number> {
-    readonly name = "subtraction";
-    readonly category: ExpressionCategory;
-    readonly syntax = "left - right";
-    readonly outputType: EvaluationType;
-    readonly metadata: ExpressionMetadata;
-    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<number>>;
-    validate(input: unknown): ValidationResult;
-}
-export declare class MultiplicationExpression implements BaseTypedExpression<number> {
-    readonly name = "multiplication";
-    readonly category: ExpressionCategory;
-    readonly syntax = "left * right";
-    readonly outputType: EvaluationType;
-    readonly metadata: ExpressionMetadata;
-    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<number>>;
-    validate(input: unknown): ValidationResult;
-}
-export declare class DivisionExpression implements BaseTypedExpression<number> {
-    readonly name = "division";
-    readonly category: ExpressionCategory;
-    readonly syntax = "left / right";
-    readonly outputType: EvaluationType;
-    readonly metadata: ExpressionMetadata;
-    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<number>>;
-    validate(input: unknown): ValidationResult;
-}
-export declare class ModuloExpression implements BaseTypedExpression<number> {
-    readonly name = "modulo";
-    readonly category: ExpressionCategory;
-    readonly syntax = "left mod right";
-    readonly outputType: EvaluationType;
-    readonly metadata: ExpressionMetadata;
-    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<number>>;
-    validate(input: unknown): ValidationResult;
-}
-export declare class PowerExpression implements BaseTypedExpression<number> {
-    readonly name = "power";
-    readonly category: ExpressionCategory;
-    readonly syntax = "left ** right";
-    readonly outputType: EvaluationType;
-    readonly metadata: ExpressionMetadata;
-    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<number>>;
-    validate(input: unknown): ValidationResult;
-}
-export declare function createAdditionExpression(): AdditionExpression;
-export declare function createSubtractionExpression(): SubtractionExpression;
-export declare function createMultiplicationExpression(): MultiplicationExpression;
-export declare function createDivisionExpression(): DivisionExpression;
-export declare function createModuloExpression(): ModuloExpression;
-export declare function createPowerExpression(): PowerExpression;
-export declare const mathematicalExpressions: {
-    readonly addition: AdditionExpression;
-    readonly subtraction: SubtractionExpression;
-    readonly multiplication: MultiplicationExpression;
-    readonly division: DivisionExpression;
-    readonly modulo: ModuloExpression;
-    readonly power: PowerExpression;
-};
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/expressions/positional/index.d.ts

@@ -1,31 +0,0 @@
-import type { ExpressionImplementation } from '../../types/core';
-export declare const firstExpression: ExpressionImplementation;
-export declare const lastExpression: ExpressionImplementation;
-export declare const atExpression: ExpressionImplementation;
-export interface RelativePositionalOptions {
-    within?: Element | null;
-    inElt?: unknown;
-    inSearch?: boolean;
-    wrapping?: boolean;
-}
-export declare const nextExpression: ExpressionImplementation;
-export declare const previousExpression: ExpressionImplementation;
-declare function findNextElementInDOM(startElement: Element, selector: string): HTMLElement | null;
-declare function findPreviousElementInDOM(startElement: Element, selector: string): HTMLElement | null;
-export declare const nextWithinExpression: ExpressionImplementation;
-export declare const previousWithinExpression: ExpressionImplementation;
-declare function findNextElementWithinContainer(startElement: Element, selector: string, container: Element): HTMLElement | null;
-declare function findPreviousElementWithinContainer(startElement: Element, selector: string, container: Element): HTMLElement | null;
-declare function getElementPosition(element: Element): number;
-export declare const positionalExpressions: {
-    readonly first: ExpressionImplementation;
-    readonly last: ExpressionImplementation;
-    readonly at: ExpressionImplementation;
-    readonly next: ExpressionImplementation;
-    readonly previous: ExpressionImplementation;
-    readonly nextWithin: ExpressionImplementation;
-    readonly previousWithin: ExpressionImplementation;
-};
-export type PositionalExpressionName = keyof typeof positionalExpressions;
-export { findNextElementInDOM, findPreviousElementInDOM, findNextElementWithinContainer, findPreviousElementWithinContainer, getElementPosition, };
-//# sourceMappingURL=index.d.ts.map

package/dist/expressions/properties/index.d.ts

@@ -1,27 +0,0 @@
-import type { ExpressionImplementation } from '../../types/core';
-import { getElementProperty } from '../property-access-utils';
-export { getElementProperty };
-export declare function isMappableCollection(v: unknown): boolean;
-export declare const possessiveExpression: ExpressionImplementation;
-export declare const myExpression: ExpressionImplementation;
-export declare const itsExpression: ExpressionImplementation;
-export declare const yourExpression: ExpressionImplementation;
-export declare const ofExpression: ExpressionImplementation;
-export declare const attributeExpression: ExpressionImplementation;
-export declare const attributeWithValueExpression: ExpressionImplementation;
-export declare const classReferenceExpression: ExpressionImplementation;
-export declare const idReferenceExpression: ExpressionImplementation;
-export { isDataAttribute, isAriaAttribute } from '../property-access-utils';
-export declare const propertiesExpressions: {
-    readonly possessive: ExpressionImplementation;
-    readonly my: ExpressionImplementation;
-    readonly its: ExpressionImplementation;
-    readonly your: ExpressionImplementation;
-    readonly of: ExpressionImplementation;
-    readonly attribute: ExpressionImplementation;
-    readonly attributeWithValue: ExpressionImplementation;
-    readonly classReference: ExpressionImplementation;
-    readonly idReference: ExpressionImplementation;
-};
-export type PropertyExpressionName = keyof typeof propertiesExpressions;
-//# sourceMappingURL=index.d.ts.map

package/dist/expressions/property-access-utils.d.ts

@@ -1,23 +0,0 @@
-export declare function isElement(value: unknown): value is Element;
-export declare function isHTMLElement(value: unknown): value is HTMLElement;
-export declare function isDataAttribute(property: string): boolean;
-export declare function isAriaAttribute(property: string): boolean;
-export declare function accessStyleProperty(element: Element, styleProp: string): string | null;
-export declare function accessAttribute(element: Element, attrName: string): boolean | string | null;
-export declare function hasAttribute(element: Element, attrName: string): boolean;
-export declare function getElementProperty(element: Element, property: string): unknown;
-export declare function accessObjectProperty(object: unknown, property: string): unknown;
-export declare function accessProperty(object: unknown, property: string): Promise<unknown>;
-export declare const propertyAccessUtils: {
-    readonly isElement: typeof isElement;
-    readonly isHTMLElement: typeof isHTMLElement;
-    readonly isDataAttribute: typeof isDataAttribute;
-    readonly isAriaAttribute: typeof isAriaAttribute;
-    readonly accessStyleProperty: typeof accessStyleProperty;
-    readonly accessAttribute: typeof accessAttribute;
-    readonly hasAttribute: typeof hasAttribute;
-    readonly getElementProperty: typeof getElementProperty;
-    readonly accessObjectProperty: typeof accessObjectProperty;
-    readonly accessProperty: typeof accessProperty;
-};
-//# sourceMappingURL=property-access-utils.d.ts.map

package/dist/expressions/references/index.d.ts

@@ -1,39 +0,0 @@
-import type { ExpressionImplementation } from '../../types/core';
-export declare const meExpression: ExpressionImplementation;
-export declare const youExpression: ExpressionImplementation;
-export declare const itExpression: ExpressionImplementation;
-export declare const itsExpression: ExpressionImplementation;
-export declare const resultExpression: ExpressionImplementation;
-export declare const querySelectorExpression: ExpressionImplementation;
-export declare const querySelectorAllExpression: ExpressionImplementation;
-export declare const idExpression: ExpressionImplementation;
-export declare const classExpression: ExpressionImplementation;
-export declare const closestExpression: ExpressionImplementation;
-export declare const parentExpression: ExpressionImplementation;
-export declare const windowExpression: ExpressionImplementation;
-export declare const documentExpression: ExpressionImplementation;
-export declare const elementWithSelectorExpression: ExpressionImplementation;
-export declare const styleRefExpression: ExpressionImplementation;
-export declare const possessiveStyleRefExpression: ExpressionImplementation;
-export declare const ofStyleRefExpression: ExpressionImplementation;
-export declare const referencesExpressions: {
-    readonly me: ExpressionImplementation;
-    readonly you: ExpressionImplementation;
-    readonly it: ExpressionImplementation;
-    readonly its: ExpressionImplementation;
-    readonly result: ExpressionImplementation;
-    readonly querySelector: ExpressionImplementation;
-    readonly querySelectorAll: ExpressionImplementation;
-    readonly getElementById: ExpressionImplementation;
-    readonly getElementsByClassName: ExpressionImplementation;
-    readonly closest: ExpressionImplementation;
-    readonly parent: ExpressionImplementation;
-    readonly window: ExpressionImplementation;
-    readonly document: ExpressionImplementation;
-    readonly elementWithSelector: ExpressionImplementation;
-    readonly styleRef: ExpressionImplementation;
-    readonly possessiveStyleRef: ExpressionImplementation;
-    readonly ofStyleRef: ExpressionImplementation;
-};
-export type ReferenceExpressionName = keyof typeof referencesExpressions;
-//# sourceMappingURL=index.d.ts.map

package/dist/expressions/shared/comparison-utils.d.ts

@@ -1,10 +0,0 @@
-export type ComparisonOperator = '>' | '<' | '>=' | '<=' | '==' | '!=' | '===' | '!==';
-export declare function compareValues(left: unknown, right: unknown, operator: ComparisonOperator): boolean;
-export declare function coerceToComparable(left: unknown, right: unknown): [number, number] | [string, string];
-export declare function areStrictlyEqual(left: unknown, right: unknown): boolean;
-export declare function areLooselyEqual(left: unknown, right: unknown): boolean;
-export declare function isGreaterThan(left: unknown, right: unknown): boolean;
-export declare function isLessThan(left: unknown, right: unknown): boolean;
-export declare function isGreaterThanOrEqual(left: unknown, right: unknown): boolean;
-export declare function isLessThanOrEqual(left: unknown, right: unknown): boolean;
-//# sourceMappingURL=comparison-utils.d.ts.map

package/dist/expressions/shared/index.d.ts

@@ -1,10 +0,0 @@
-export { toNumber, toNumberOrNull, ensureFinite, isNumeric, canBeNumeric, safeDivide, safeModulo, } from './number-utils';
-export { setEvaluationTracker, getEvaluationTracker, isTrackingEvaluations, collectEvaluations, type EvaluationRecord, type EvaluationTracker, } from './tracking';
-export { compareValues, coerceToComparable, areStrictlyEqual, areLooselyEqual, isGreaterThan, isLessThan, isGreaterThanOrEqual, isLessThanOrEqual, type ComparisonOperator, } from './comparison-utils';
-export { validResult, invalidResult, createError, toValidationResult, validateBinaryInput, validateUnaryInput, validateNotNull, validateNumber, validateString, validateBoolean, combineValidations, } from './validation-utils';
-export { isString, isNumber, isBoolean, isObject, isFunction, isArray, isElement, isArrayLike, inferType, } from '../type-helpers';
-export declare function trackEvaluation<T>(expression: {
-    name: string;
-    category: string;
-}, _context: unknown, args: unknown[], result: T, startTime: number, success?: boolean, error?: Error): T;
-//# sourceMappingURL=index.d.ts.map

package/dist/expressions/shared/number-utils.d.ts

@@ -1,8 +0,0 @@
-export declare function toNumber(value: unknown, context: string): number;
-export declare function toNumberOrNull(value: unknown): number | null;
-export declare function ensureFinite(num: number, operation: string): number;
-export declare function canBeNumeric(value: unknown): boolean;
-export declare function isNumeric(value: unknown): boolean;
-export declare function safeDivide(left: number, right: number, allowInfinity?: boolean): number;
-export declare function safeModulo(left: number, right: number): number;
-//# sourceMappingURL=number-utils.d.ts.map

package/dist/expressions/shared/tracking.d.ts

@@ -1,20 +0,0 @@
-export interface EvaluationRecord {
-    expressionName: string;
-    category: string;
-    input: unknown;
-    output: unknown;
-    timestamp: number;
-    duration: number;
-    success: boolean;
-    error?: Error;
-}
-export interface EvaluationTracker {
-    record(entry: EvaluationRecord): void;
-}
-export declare function setEvaluationTracker(next: EvaluationTracker | null): EvaluationTracker | null;
-export declare function getEvaluationTracker(): EvaluationTracker | null;
-export declare function isTrackingEvaluations(): boolean;
-export declare function collectEvaluations(): EvaluationTracker & {
-    readonly records: EvaluationRecord[];
-};
-//# sourceMappingURL=tracking.d.ts.map

package/dist/expressions/shared/validation-utils.d.ts

@@ -1,13 +0,0 @@
-import type { ValidationResult, ValidationError } from '../../types/base-types';
-export declare function validResult(): ValidationResult;
-export declare function invalidResult(errors: ValidationError[], suggestions?: string[]): ValidationResult;
-export declare function createError(type: ValidationError['type'], message: string, suggestions?: string[], severity?: 'error' | 'warning' | 'info'): ValidationError;
-export declare function validateBinaryInput(input: unknown): ValidationResult;
-export declare function validateUnaryInput(input: unknown): ValidationResult;
-export declare function validateNotNull(value: unknown, name: string): ValidationResult;
-export declare function validateNumber(value: unknown, name: string): ValidationResult;
-export declare function validateString(value: unknown, name: string): ValidationResult;
-export declare function validateBoolean(value: unknown, name: string): ValidationResult;
-export declare function toValidationResult(result: string | null): ValidationResult;
-export declare function combineValidations(...results: ValidationResult[]): ValidationResult;
-//# sourceMappingURL=validation-utils.d.ts.map

package/dist/expressions/special/index.d.ts

@@ -1,78 +0,0 @@
-import { type RuntimeValidator } from '../../validation/lightweight-validators';
-import type { TypedExpressionContext, EvaluationType, ExpressionMetadata, ValidationResult, EvaluationResult } from '../../types/base-types';
-import type { ExpressionCategory } from '../../types/expression-types';
-import { BaseExpressionImpl } from '../base-expression';
-type StringLiteralInput = {
-    value: string;
-};
-type NumberLiteralInput = {
-    value: number;
-};
-type BooleanLiteralInput = {
-    value: boolean;
-};
-type BinaryOperationInput = {
-    left: unknown;
-    right: unknown;
-};
-export declare class StringLiteralExpression extends BaseExpressionImpl<StringLiteralInput, string> {
-    readonly name = "stringLiteral";
-    readonly category: ExpressionCategory;
-    readonly syntax = "\"string\" or 'string'";
-    readonly description = "String literals with template interpolation support";
-    readonly outputType: EvaluationType;
-    readonly inputSchema: RuntimeValidator<StringLiteralInput>;
-    readonly metadata: ExpressionMetadata;
-    evaluate(context: TypedExpressionContext, input: StringLiteralInput): Promise<EvaluationResult<string>>;
-    validate(input: unknown): ValidationResult;
-    private interpolateString;
-    private resolveExpression;
-    private resolveVariable;
-}
-export declare class NumberLiteralExpression extends BaseExpressionImpl<NumberLiteralInput, number> {
-    readonly name = "numberLiteral";
-    readonly category: ExpressionCategory;
-    readonly syntax = "123 or 3.14";
-    readonly description = "Numeric literal with validation";
-    readonly inputSchema: RuntimeValidator<NumberLiteralInput>;
-    readonly outputType: EvaluationType;
-    readonly metadata: ExpressionMetadata;
-    evaluate(context: TypedExpressionContext, input: NumberLiteralInput): Promise<EvaluationResult<number>>;
-    validate(input: unknown): ValidationResult;
-}
-export declare class BooleanLiteralExpression extends BaseExpressionImpl<BooleanLiteralInput, boolean> {
-    readonly name = "booleanLiteral";
-    readonly category: ExpressionCategory;
-    readonly syntax = "true or false";
-    readonly description = "Boolean literal values";
-    readonly inputSchema: RuntimeValidator<BooleanLiteralInput>;
-    readonly outputType: EvaluationType;
-    readonly metadata: ExpressionMetadata;
-    evaluate(context: TypedExpressionContext, input: BooleanLiteralInput): Promise<EvaluationResult<boolean>>;
-    validate(input: unknown): ValidationResult;
-}
-export declare class StringConcatenationExpression extends BaseExpressionImpl<BinaryOperationInput, string> {
-    readonly name = "stringConcatenation";
-    readonly category: ExpressionCategory;
-    readonly syntax = "left + right (string concatenation)";
-    readonly description = "Concatenation of two values into a string";
-    readonly inputSchema: RuntimeValidator<BinaryOperationInput>;
-    readonly outputType: EvaluationType;
-    readonly metadata: ExpressionMetadata;
-    evaluate(context: TypedExpressionContext, input: BinaryOperationInput): Promise<EvaluationResult<string>>;
-    validate(input: unknown): ValidationResult;
-    private convertToString;
-}
-export declare function createStringLiteralExpression(): StringLiteralExpression;
-export declare function createNumberLiteralExpression(): NumberLiteralExpression;
-export declare function createBooleanLiteralExpression(): BooleanLiteralExpression;
-export declare function createStringConcatenationExpression(): StringConcatenationExpression;
-export declare const specialExpressions: {
-    readonly stringLiteral: StringLiteralExpression;
-    readonly numberLiteral: NumberLiteralExpression;
-    readonly booleanLiteral: BooleanLiteralExpression;
-    readonly stringConcatenation: StringConcatenationExpression;
-};
-export type SpecialExpressionName = keyof typeof specialExpressions;
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/expressions/type-helpers.d.ts

@@ -1,11 +0,0 @@
-export declare function isString(value: unknown): boolean;
-export declare function isNumber(value: unknown): boolean;
-export declare function isBoolean(value: unknown): boolean;
-export declare function isObject(value: unknown): boolean;
-export declare function isFunction(value: unknown): boolean;
-export declare function isArray(value: unknown): boolean;
-export declare function isElement(value: unknown): boolean;
-export declare function toNumber(value: unknown): number | null;
-export declare function isArrayLike(value: unknown): boolean;
-export declare function inferType(value: unknown): 'string' | 'number' | 'boolean' | 'element' | 'array' | 'object' | 'null' | 'undefined' | 'function' | 'unknown';
-//# sourceMappingURL=type-helpers.d.ts.map

package/dist/expressions/type-registry.d.ts

@@ -1,57 +0,0 @@
-import type { ExecutionContext, HyperScriptValueType } from '../types/base-types';
-export type JSRuntimeType = 'string' | 'number' | 'boolean' | 'null' | 'undefined' | 'object' | 'array' | 'function' | 'element' | 'element-list' | 'node-list' | 'event' | 'date' | 'regexp' | 'promise' | 'symbol' | 'unknown';
-export type CoercionFn<TFrom = unknown, TTo = unknown> = (value: TFrom, context?: ExecutionContext) => TTo | null;
-export type TypeGuardFn<T = unknown> = (value: unknown) => value is T;
-export interface ExpressionTypeDefinition<T = unknown> {
-    readonly name: string;
-    readonly hyperscriptType: HyperScriptValueType;
-    readonly tsType: string;
-    readonly isType: TypeGuardFn<T>;
-    readonly defaultValue: T | null;
-    readonly coerceFrom?: Partial<Record<string, CoercionFn<unknown, T>>>;
-    readonly description?: string;
-    readonly examples?: T[];
-}
-export interface ExpressionTypeRegistryConfig {
-    strictMode?: boolean;
-    cacheCoercions?: boolean;
-}
-export declare class ExpressionTypeRegistry {
-    private types;
-    private coercionCache;
-    private config;
-    constructor(config?: ExpressionTypeRegistryConfig);
-    register<T>(definition: ExpressionTypeDefinition<T>): void;
-    get(name: string): ExpressionTypeDefinition | undefined;
-    has(name: string): boolean;
-    getTypeNames(): string[];
-    inferType(value: unknown): string;
-    getHyperScriptType(value: unknown): HyperScriptValueType;
-    coerce<T>(value: unknown, targetType: string, context?: ExecutionContext): T | null;
-    canCoerce(value: unknown, targetType: string): boolean;
-    getCoercionInfo(sourceType: string, targetType: string): {
-        possible: boolean;
-        direct: boolean;
-        via?: string;
-    };
-    clearCache(): void;
-    getStats(): {
-        typeCount: number;
-        cacheSize: number;
-        typeNames: string[];
-    };
-    private registerBuiltinTypes;
-}
-export declare const expressionTypeRegistry: ExpressionTypeRegistry;
-export declare function inferExpressionType(value: unknown): string;
-export declare function coerceToType<T>(value: unknown, targetType: string, context?: ExecutionContext): T | null;
-export declare function canCoerceToType(value: unknown, targetType: string): boolean;
-export declare function getHyperScriptTypeName(value: unknown): HyperScriptValueType;
-export declare function coerceToString(value: unknown, context?: ExecutionContext): string;
-export declare function coerceToNumber(value: unknown, context?: ExecutionContext): number | null;
-export declare function coerceToBoolean(value: unknown, context?: ExecutionContext): boolean;
-export declare function coerceToElement(value: unknown, context?: ExecutionContext): Element | null;
-export declare function coerceToElementList(value: unknown, context?: ExecutionContext): Element[];
-export declare function coerceToArray(value: unknown, context?: ExecutionContext): unknown[];
-export declare function coerceToObject(value: unknown, context?: ExecutionContext): Record<string, unknown> | null;
-//# sourceMappingURL=type-registry.d.ts.map

package/dist/expressions/validation-helpers.d.ts

@@ -1,15 +0,0 @@
-import type { ValidationResult } from '../types/base-types';
-export declare function validateArgCount(args: unknown[], expected: number, expressionName: string, argNames?: string): string | null;
-export declare function validateMinArgs(args: unknown[], minimum: number, expressionName: string): string | null;
-export declare function validateArgIsString(args: unknown[], index: number, expressionName: string, argName?: string): string | null;
-export declare function validateArgIsNumber(args: unknown[], index: number, expressionName: string, argName?: string): string | null;
-export declare function validateArgIsElement(args: unknown[], index: number, expressionName: string, argName?: string): string | null;
-export declare function validateArgIsArrayLike(args: unknown[], index: number, expressionName: string, argName?: string): string | null;
-export declare function validateArgNotNull(args: unknown[], index: number, expressionName: string, argName?: string): string | null;
-export declare function validateSingleStringArg(args: unknown[], expressionName: string, argName: string): string | null;
-export declare function validateTwoArgs(args: unknown[], expressionName: string): string | null;
-export declare function validateNoArgs(): string | null;
-export declare function validateMaxArgs(args: unknown[], maximum: number, expressionName: string, argNames?: string): string | null;
-export declare function validateArgRange(args: unknown[], min: number, max: number, expressionName: string, argNames?: string): string | null;
-export declare function fromValidationResult(result: ValidationResult): string | null;
-//# sourceMappingURL=validation-helpers.d.ts.map

package/dist/htmx/hcon.d.ts

@@ -1,9 +0,0 @@
-export type HconPrimitive = string | number | boolean | null;
-export type HconValue = HconPrimitive | HconValue[] | {
-    [key: string]: HconValue;
-};
-export type HconObject = Record<string, HconValue>;
-export declare function parse(input: string): HconObject;
-export declare function split(input: string): string[];
-export declare function merge(source: HconObject | string, target: HconObject): HconObject;
-//# sourceMappingURL=hcon.d.ts.map

package/dist/htmx/htmx-attribute-processor.d.ts

@@ -1,120 +0,0 @@
-import { type HtmxConfig } from './htmx-translator.js';
-import { SSEConnection, type SSEEventSourceCtor } from './sse.js';
-import { WSConnection, type WSEventSourceCtor } from './ws.js';
-export interface HtmxConfiguringEventDetail {
-    config: HtmxConfig;
-    element: Element;
-}
-export interface HtmxBeforeRequestEventDetail {
-    element: Element;
-    url: string | undefined;
-    method: string;
-}
-export interface HtmxAfterSettleEventDetail {
-    element: Element;
-    target: string | undefined;
-}
-export interface HtmxErrorEventDetail {
-    element: Element;
-    error: Error;
-}
-export interface FxInitEventDetail {
-    element: Element;
-    options: EventListenerOptions;
-}
-export interface FxConfigEventDetail {
-    cfg: {
-        trigger: string;
-        method: string;
-        action: string | undefined;
-        headers: Record<string, string>;
-        target: string | undefined;
-        swap: string;
-        body: FormData | null;
-        drop: number;
-        transition: boolean | ((callback: () => void) => void);
-        preventTrigger: boolean;
-        signal: AbortSignal;
-        confirm?: () => Promise<boolean>;
-    };
-    element: Element;
-}
-export interface FxAfterEventDetail {
-    cfg: FxConfigEventDetail['cfg'] & {
-        response: Response | null;
-        text: string;
-    };
-    element: Element;
-}
-export interface FxFinallyEventDetail {
-    element: Element;
-    success: boolean;
-}
-export interface HtmxProcessorOptions {
-    processExisting?: boolean;
-    watchMutations?: boolean;
-    debug?: boolean;
-    root?: Element;
-    requestDropping?: boolean;
-    fixiEvents?: boolean;
-    eventSourceCtor?: SSEEventSourceCtor;
-    wsEventSourceCtor?: WSEventSourceCtor;
-}
-declare const HTMX_ALL_ATTRS: string[];
-declare const SSE_ATTRS: string[];
-declare const WS_ATTRS: string[];
-declare const FIXI_ATTRS: string[];
-export declare class HtmxAttributeProcessor {
-    private options;
-    private observer;
-    private processedElements;
-    private executeCallback;
-    private pendingRequests;
-    private sseConnections;
-    private sseConnectionsSet;
-    private wsConnections;
-    private wsConnectionsSet;
-    private wsSendListeners;
-    private onHandlerListeners;
-    private onHandlerElements;
-    private localizedAttrSet;
-    private unsubscribeVocab;
-    private swapTemplateCache;
-    private getSwapTemplate;
-    private eventSourceCtor;
-    private wsEventSourceCtor;
-    private dispatchLifecycleEvent;
-    constructor(options?: HtmxProcessorOptions);
-    init(executeCallback: (code: string, element: Element) => Promise<void>): void;
-    destroy(): void;
-    attachSSE(element: Element): SSEConnection | null;
-    getSSEConnection(element: Element): SSEConnection | null;
-    detachSSE(element: Element): void;
-    private detachSSESubtree;
-    attachWS(element: Element): WSConnection | null;
-    private wireWSSendDescendants;
-    getWSConnection(element: Element): WSConnection | null;
-    detachWS(element: Element): void;
-    private detachWSSubtree;
-    private installOnHandlers;
-    private detachOnHandlers;
-    private detachOnHandlersSubtree;
-    scanForHtmxElements(root?: Element): Element[];
-    private findHxOnElements;
-    collectAttributes(element: Element): HtmxConfig;
-    collectFxAttributes(element: Element): HtmxConfig;
-    private isFxElement;
-    processElement(element: Element): void;
-    processSubtree(root: Element): void;
-    private startObserver;
-    private computeAttributeFilter;
-    private refreshLocalizedAttrs;
-    manualProcess(element: Element): string;
-    hasPendingRequest(element: Element): boolean;
-    abortPendingRequest(element: Element): boolean;
-}
-export { FIXI_ATTRS, HTMX_ALL_ATTRS as HTMX_ATTRS, SSE_ATTRS, WS_ATTRS };
-export { translateToHyperscript, type HtmxConfig } from './htmx-translator.js';
-export { SSEConnection, type SSEEventSourceCtor, type SSEEventSourceLike } from './sse.js';
-export { WSConnection, collectWSSendPayload, type WSEventSourceCtor, type WSEventSourceLike, type WSSwapEnvelope, } from './ws.js';
-//# sourceMappingURL=htmx-attribute-processor.d.ts.map