@hyperfixi/core 3.3.0 → 4.0.1

package/dist/expressions/index.cjs

@@ -1,4331 +0,0 @@
-'use strict';
-
-function createExpressionRegistry(...categories) {
-    const map = new Map();
-    for (const category of categories) {
-        for (const [name, impl] of Object.entries(category)) {
-            map.set(name, impl);
-        }
-    }
-    return map;
-}
-
-class ExpressionTypeRegistry {
-    constructor(config = {}) {
-        this.types = new Map();
-        this.coercionCache = new Map();
-        this.config = {
-            strictMode: false,
-            cacheCoercions: true,
-            ...config,
-        };
-        this.registerBuiltinTypes();
-    }
-    register(definition) {
-        if (this.types.has(definition.name)) {
-            console.warn(`ExpressionTypeRegistry: Overwriting existing type '${definition.name}'`);
-        }
-        this.types.set(definition.name, definition);
-    }
-    get(name) {
-        return this.types.get(name);
-    }
-    has(name) {
-        return this.types.has(name);
-    }
-    getTypeNames() {
-        return Array.from(this.types.keys());
-    }
-    inferType(value) {
-        for (const [name, def] of this.types) {
-            if (def.isType(value)) {
-                return name;
-            }
-        }
-        return 'Unknown';
-    }
-    getHyperScriptType(value) {
-        const typeName = this.inferType(value);
-        const typeDef = this.types.get(typeName);
-        return typeDef?.hyperscriptType ?? 'unknown';
-    }
-    coerce(value, targetType, context) {
-        const targetDef = this.types.get(targetType);
-        if (!targetDef) {
-            if (this.config.strictMode) {
-                throw new Error(`Unknown target type: ${targetType}`);
-            }
-            return null;
-        }
-        if (targetDef.isType(value)) {
-            return value;
-        }
-        if (this.config.cacheCoercions) {
-            const cacheKey = `${this.inferType(value)}:${targetType}:${JSON.stringify(value)}`;
-            if (this.coercionCache.has(cacheKey)) {
-                return this.coercionCache.get(cacheKey);
-            }
-        }
-        const sourceType = this.inferType(value);
-        const coerceFn = targetDef.coerceFrom?.[sourceType];
-        if (coerceFn) {
-            const result = coerceFn(value, context);
-            if (this.config.cacheCoercions && result !== null) {
-                const cacheKey = `${sourceType}:${targetType}:${JSON.stringify(value)}`;
-                this.coercionCache.set(cacheKey, result);
-            }
-            return result;
-        }
-        return targetDef.defaultValue;
-    }
-    canCoerce(value, targetType) {
-        const targetDef = this.types.get(targetType);
-        if (!targetDef)
-            return false;
-        if (targetDef.isType(value))
-            return true;
-        const sourceType = this.inferType(value);
-        return targetDef.coerceFrom?.[sourceType] !== undefined;
-    }
-    getCoercionInfo(sourceType, targetType) {
-        const targetDef = this.types.get(targetType);
-        if (!targetDef)
-            return { possible: false, direct: false };
-        if (sourceType === targetType) {
-            return { possible: true, direct: true };
-        }
-        if (targetDef.coerceFrom?.[sourceType]) {
-            return { possible: true, direct: true };
-        }
-        return { possible: false, direct: false };
-    }
-    clearCache() {
-        this.coercionCache.clear();
-    }
-    getStats() {
-        return {
-            typeCount: this.types.size,
-            cacheSize: this.coercionCache.size,
-            typeNames: this.getTypeNames(),
-        };
-    }
-    registerBuiltinTypes() {
-        this.register({
-            name: 'String',
-            hyperscriptType: 'string',
-            tsType: 'string',
-            isType: (v) => typeof v === 'string',
-            defaultValue: '',
-            description: 'Text string value',
-            examples: ['hello', 'world', ''],
-            coerceFrom: {
-                Number: v => String(v),
-                Boolean: v => String(v),
-                Null: () => '',
-                Undefined: () => '',
-                Array: v => (Array.isArray(v) ? v.join(', ') : null),
-                Object: v => {
-                    try {
-                        return JSON.stringify(v);
-                    }
-                    catch {
-                        return String(v);
-                    }
-                },
-                Element: v => (v instanceof Element ? (v.textContent ?? v.outerHTML) : null),
-            },
-        });
-        this.register({
-            name: 'Number',
-            hyperscriptType: 'number',
-            tsType: 'number',
-            isType: (v) => typeof v === 'number' && !isNaN(v),
-            defaultValue: 0,
-            description: 'Numeric value (integer or float)',
-            examples: [0, 1, 3.14, -42],
-            coerceFrom: {
-                String: v => {
-                    const n = parseFloat(v);
-                    return isNaN(n) ? null : n;
-                },
-                Boolean: v => (v ? 1 : 0),
-                Null: () => 0,
-                Undefined: () => null,
-            },
-        });
-        this.register({
-            name: 'Boolean',
-            hyperscriptType: 'boolean',
-            tsType: 'boolean',
-            isType: (v) => typeof v === 'boolean',
-            defaultValue: false,
-            description: 'True or false value',
-            examples: [true, false],
-            coerceFrom: {
-                String: v => {
-                    const s = v.toLowerCase().trim();
-                    if (s === 'true' || s === 'yes' || s === '1')
-                        return true;
-                    if (s === 'false' || s === 'no' || s === '0' || s === '')
-                        return false;
-                    return s.length > 0;
-                },
-                Number: v => v !== 0,
-                Null: () => false,
-                Undefined: () => false,
-                Array: v => (Array.isArray(v) ? v.length > 0 : false),
-                Element: v => v instanceof Element,
-                ElementList: v => Array.isArray(v) && v.length > 0,
-            },
-        });
-        this.register({
-            name: 'Element',
-            hyperscriptType: 'element',
-            tsType: 'Element | HTMLElement',
-            isType: (v) => v instanceof Element,
-            defaultValue: null,
-            description: 'DOM Element',
-            coerceFrom: {
-                String: (v, ctx) => {
-                    const selector = v;
-                    if (selector.startsWith('#') || selector.startsWith('.') || selector.match(/^[\w-]+$/)) {
-                        try {
-                            return document.querySelector(selector);
-                        }
-                        catch {
-                            return null;
-                        }
-                    }
-                    return null;
-                },
-                ElementList: v => (Array.isArray(v) && v.length > 0 ? v[0] : null),
-                NodeList: v => {
-                    const list = v;
-                    return list.length > 0 ? list[0] : null;
-                },
-            },
-        });
-        this.register({
-            name: 'ElementList',
-            hyperscriptType: 'element-list',
-            tsType: 'Element[]',
-            isType: (v) => Array.isArray(v) && v.length > 0 && v.every(item => item instanceof Element),
-            defaultValue: [],
-            description: 'Array of DOM Elements',
-            coerceFrom: {
-                Element: v => (v instanceof Element ? [v] : []),
-                NodeList: v => Array.from(v),
-                String: v => {
-                    try {
-                        return Array.from(document.querySelectorAll(v));
-                    }
-                    catch {
-                        return [];
-                    }
-                },
-                Array: v => {
-                    const arr = v;
-                    if (arr.every(item => item instanceof Element)) {
-                        return arr;
-                    }
-                    return [];
-                },
-            },
-        });
-        this.register({
-            name: 'Array',
-            hyperscriptType: 'array',
-            tsType: 'unknown[]',
-            isType: (v) => Array.isArray(v),
-            defaultValue: [],
-            description: 'Array of values',
-            coerceFrom: {
-                String: v => {
-                    const s = v;
-                    try {
-                        const parsed = JSON.parse(s);
-                        if (Array.isArray(parsed))
-                            return parsed;
-                    }
-                    catch {
-                    }
-                    return s.split(',').map(item => item.trim());
-                },
-                ElementList: v => v,
-                NodeList: v => Array.from(v),
-                Object: v => Object.values(v),
-            },
-        });
-        this.register({
-            name: 'Object',
-            hyperscriptType: 'object',
-            tsType: 'Record<string, unknown>',
-            isType: (v) => typeof v === 'object' && v !== null && !Array.isArray(v) && !(v instanceof Element),
-            defaultValue: {},
-            description: 'Plain JavaScript object',
-            coerceFrom: {
-                String: v => {
-                    try {
-                        const parsed = JSON.parse(v);
-                        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
-                            return parsed;
-                        }
-                    }
-                    catch {
-                    }
-                    return null;
-                },
-                Array: v => {
-                    const arr = v;
-                    const obj = {};
-                    arr.forEach((item, index) => {
-                        obj[String(index)] = item;
-                    });
-                    return obj;
-                },
-            },
-        });
-        this.register({
-            name: 'Null',
-            hyperscriptType: 'null',
-            tsType: 'null',
-            isType: (v) => v === null,
-            defaultValue: null,
-            description: 'Null value',
-        });
-        this.register({
-            name: 'Undefined',
-            hyperscriptType: 'undefined',
-            tsType: 'undefined',
-            isType: (v) => v === undefined,
-            defaultValue: undefined,
-            description: 'Undefined value',
-        });
-        this.register({
-            name: 'Function',
-            hyperscriptType: 'function',
-            tsType: 'Function',
-            isType: (v) => typeof v === 'function',
-            defaultValue: null,
-            description: 'JavaScript function',
-        });
-        this.register({
-            name: 'Event',
-            hyperscriptType: 'event',
-            tsType: 'Event',
-            isType: (v) => v instanceof Event,
-            defaultValue: null,
-            description: 'DOM Event',
-        });
-        this.register({
-            name: 'NodeList',
-            hyperscriptType: 'element-list',
-            tsType: 'NodeList',
-            isType: (v) => v instanceof NodeList,
-            defaultValue: null,
-            description: 'DOM NodeList (typically from querySelectorAll)',
-            coerceFrom: {
-                Array: v => {
-                    return null;
-                },
-            },
-        });
-        this.register({
-            name: 'Unknown',
-            hyperscriptType: 'unknown',
-            tsType: 'unknown',
-            isType: (_v) => true,
-            defaultValue: null,
-            description: 'Unknown/any value type',
-        });
-    }
-}
-const expressionTypeRegistry = new ExpressionTypeRegistry();
-
-function isString(value) {
-    const stringType = expressionTypeRegistry.get('String');
-    return stringType ? stringType.isType(value) : typeof value === 'string';
-}
-function isNumber(value) {
-    const numberType = expressionTypeRegistry.get('Number');
-    return numberType ? numberType.isType(value) : typeof value === 'number';
-}
-function isBoolean(value) {
-    const boolType = expressionTypeRegistry.get('Boolean');
-    return boolType ? boolType.isType(value) : typeof value === 'boolean';
-}
-function isObject(value) {
-    const objectType = expressionTypeRegistry.get('Object');
-    return objectType ? objectType.isType(value) : typeof value === 'object' && value !== null;
-}
-function isFunction(value) {
-    const funcType = expressionTypeRegistry.get('Function');
-    return funcType ? funcType.isType(value) : typeof value === 'function';
-}
-
-const NUMBER_WORDS = {
-    1: 'one',
-    2: 'two',
-    3: 'three',
-    4: 'four',
-    5: 'five',
-};
-function numberToWord(n) {
-    return NUMBER_WORDS[n] ?? String(n);
-}
-function validateArgCount(args, expected, expressionName, argNames) {
-    if (args.length !== expected) {
-        const argDesc = argNames ? ` (${argNames})` : '';
-        return `${expressionName} requires exactly ${numberToWord(expected)} argument${expected === 1 ? '' : 's'}${argDesc}`;
-    }
-    return null;
-}
-function validateArgIsString(args, index, expressionName, argName) {
-    if (typeof args[index] !== 'string') {
-        const name = argName || `argument ${index + 1}`;
-        return `${expressionName} ${name} must be a string`;
-    }
-    return null;
-}
-function validateArgIsNumber(args, index, expressionName, argName) {
-    if (typeof args[index] !== 'number') {
-        const name = argName;
-        return `${expressionName} ${name} must be a number`;
-    }
-    return null;
-}
-function validateSingleStringArg(args, expressionName, argName) {
-    return (validateArgCount(args, 1, expressionName, argName) ??
-        validateArgIsString(args, 0, expressionName, argName));
-}
-function validateTwoArgs(args, expressionName) {
-    return validateArgCount(args, 2, expressionName, 'left, right');
-}
-function validateNoArgs() {
-    return null;
-}
-function validateMaxArgs(args, maximum, expressionName, argNames) {
-    if (args.length > maximum) {
-        const argDesc = argNames ? ` (${argNames})` : '';
-        const maxStr = maximum === 1 ? 'one' : String(maximum);
-        return `${expressionName} expression takes at most ${maxStr} argument${maximum === 1 ? '' : 's'}${argDesc}`;
-    }
-    return null;
-}
-function validateArgRange(args, min, max, expressionName, argNames) {
-    if (args.length < min || args.length > max) {
-        const argDesc = argNames ? ` (${argNames})` : '';
-        return `${expressionName} requires ${min}-${max} arguments${argDesc}`;
-    }
-    return null;
-}
-
-const meExpression = {
-    name: 'me',
-    category: 'Reference',
-    evaluatesTo: 'Element',
-    async evaluate(context) {
-        return context.me ?? null;
-    },
-    validate: validateNoArgs,
-};
-const youExpression = {
-    name: 'you',
-    category: 'Reference',
-    evaluatesTo: 'Element',
-    async evaluate(context) {
-        return context.you ?? null;
-    },
-    validate: validateNoArgs,
-};
-const itExpression = {
-    name: 'it',
-    category: 'Reference',
-    evaluatesTo: 'Any',
-    async evaluate(context) {
-        return context.it ?? context.result;
-    },
-    validate: validateNoArgs,
-};
-const itsExpression$1 = {
-    name: 'its',
-    category: 'Reference',
-    evaluatesTo: 'Any',
-    async evaluate(context) {
-        return context.it ?? context.result;
-    },
-    validate: validateNoArgs,
-};
-const resultExpression = {
-    name: 'result',
-    category: 'Reference',
-    evaluatesTo: 'Any',
-    async evaluate(context) {
-        return context.result ?? context.it;
-    },
-    validate: validateNoArgs,
-};
-const querySelectorExpression = {
-    name: 'querySelector',
-    category: 'Reference',
-    evaluatesTo: 'Element',
-    async evaluate(_context, ...args) {
-        const [selector] = args;
-        if (typeof selector !== 'string') {
-            throw new Error('querySelector requires a string selector');
-        }
-        return document.querySelector(selector);
-    },
-    validate(args) {
-        return validateSingleStringArg(args, 'querySelector', 'selector');
-    },
-};
-const querySelectorAllExpression = {
-    name: 'querySelectorAll',
-    category: 'Reference',
-    evaluatesTo: 'Array',
-    async evaluate(_context, ...args) {
-        const selector = args[0];
-        if (typeof selector !== 'string') {
-            throw new Error('querySelectorAll requires a string selector');
-        }
-        const nodeList = document.querySelectorAll(selector);
-        return Array.from(nodeList);
-    },
-    validate(args) {
-        return validateSingleStringArg(args, 'querySelectorAll', 'selector');
-    },
-};
-const idExpression = {
-    name: 'getElementById',
-    category: 'Reference',
-    evaluatesTo: 'Element',
-    async evaluate(_context, ...args) {
-        const id = args[0];
-        if (typeof id !== 'string') {
-            throw new Error('getElementById requires a string ID');
-        }
-        return document.getElementById(id);
-    },
-    validate(args) {
-        return validateSingleStringArg(args, 'getElementById', 'ID');
-    },
-};
-const classExpression = {
-    name: 'getElementsByClassName',
-    category: 'Reference',
-    evaluatesTo: 'Array',
-    async evaluate(_context, ...args) {
-        const className = args[0];
-        if (typeof className !== 'string') {
-            throw new Error('getElementsByClassName requires a string class name');
-        }
-        const collection = document.getElementsByClassName(className);
-        return Array.from(collection);
-    },
-    validate(args) {
-        return validateSingleStringArg(args, 'getElementsByClassName', 'className');
-    },
-};
-const closestExpression = {
-    name: 'closest',
-    category: 'Reference',
-    evaluatesTo: 'Element',
-    async evaluate(context, ...args) {
-        let selector = args[0];
-        if (selector && typeof selector === 'object' && 'type' in selector) {
-            const node = selector;
-            if (node.type === 'identifier' && node.name) {
-                selector = node.name;
-            }
-            else if (node.type === 'literal' && typeof node.value === 'string') {
-                selector = node.value;
-            }
-        }
-        if (typeof selector !== 'string') {
-            throw new Error('closest requires a string selector');
-        }
-        const start = args.length > 1 ? args[1] : context.me;
-        if (!(start instanceof Element)) {
-            return null;
-        }
-        return start.closest(selector);
-    },
-    validate(args) {
-        if (args.length !== 1 && args.length !== 2) {
-            return 'closest requires a selector and, optionally, the element to start from';
-        }
-        const arg = args[0];
-        if (typeof arg === 'string')
-            return null;
-        if (arg && typeof arg === 'object' && 'type' in arg) {
-            const node = arg;
-            if (node.type === 'identifier' || node.type === 'literal')
-                return null;
-        }
-        return 'closest selector must be a string or identifier';
-    },
-};
-const parentExpression = {
-    name: 'parent',
-    category: 'Reference',
-    evaluatesTo: 'Element',
-    async evaluate(context) {
-        if (!context.me) {
-            return null;
-        }
-        return context.me.parentElement;
-    },
-    validate: validateNoArgs,
-};
-const windowExpression = {
-    name: 'window',
-    category: 'Reference',
-    evaluatesTo: 'Object',
-    async evaluate(_context) {
-        return window;
-    },
-    validate: validateNoArgs,
-};
-const documentExpression = {
-    name: 'document',
-    category: 'Reference',
-    evaluatesTo: 'Object',
-    async evaluate(_context) {
-        return document;
-    },
-    validate: validateNoArgs,
-};
-const elementWithSelectorExpression = {
-    name: 'elementWithSelector',
-    category: 'Reference',
-    evaluatesTo: 'Array',
-    async evaluate(context, ...args) {
-        const selector = args[0];
-        if (typeof selector !== 'string') {
-            throw new Error('Selector must be a string');
-        }
-        const doc = context?.me?.ownerDocument ??
-            (typeof document !== 'undefined' ? document : null);
-        if (!doc) {
-            throw new Error('DOM not available - cannot resolve element selector');
-        }
-        const elements = doc.querySelectorAll(selector);
-        return Array.from(elements);
-    },
-    validate(args) {
-        return validateSingleStringArg(args, 'elementWithSelector', 'selector');
-    },
-};
-function readStyleValue(target, property) {
-    if (property.startsWith('computed-')) {
-        const cssProperty = property.substring(9);
-        return getComputedStyle(target).getPropertyValue(cssProperty) || '';
-    }
-    const camel = property.replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
-    return target.style[camel];
-}
-const styleRefExpression = {
-    name: 'styleRef',
-    category: 'Reference',
-    evaluatesTo: 'String',
-    async evaluate(context, ...args) {
-        const property = args[0];
-        const element = args[1];
-        if (typeof property !== 'string') {
-            throw new Error('StyleRef requires a string property name');
-        }
-        const target = element || context.me;
-        if (!target || !(target instanceof HTMLElement)) {
-            return undefined;
-        }
-        return readStyleValue(target, property);
-    },
-    validate(args) {
-        return (validateArgRange(args, 1, 2, 'styleRef', 'property, optional element') ??
-            validateArgIsString(args, 0, 'styleRef', 'property') ??
-            (args.length === 2 && args[1] && typeof args[1] !== 'object'
-                ? 'styleRef element must be an HTMLElement'
-                : null));
-    },
-};
-const possessiveStyleRefExpression = {
-    name: 'possessiveStyleRef',
-    category: 'Reference',
-    evaluatesTo: 'String',
-    async evaluate(context, ...args) {
-        const possessor = args[0];
-        const property = args[1];
-        if (typeof possessor !== 'string' || typeof property !== 'string') {
-            throw new Error('Possessive styleRef requires possessor and property strings');
-        }
-        let target = null;
-        if (possessor === 'my' && context.me) {
-            target = context.me instanceof HTMLElement ? context.me : null;
-        }
-        else if (possessor === 'its' && context.it) {
-            target = context.it instanceof HTMLElement ? context.it : null;
-        }
-        if (!target) {
-            return undefined;
-        }
-        return readStyleValue(target, property);
-    },
-    validate(args) {
-        return (validateArgCount(args, 2, 'possessiveStyleRef', 'possessor, property') ??
-            validateArgIsString(args, 0, 'possessiveStyleRef', 'possessor') ??
-            validateArgIsString(args, 1, 'possessiveStyleRef', 'property'));
-    },
-};
-const ofStyleRefExpression = {
-    name: 'ofStyleRef',
-    category: 'Reference',
-    evaluatesTo: 'String',
-    async evaluate(context, ...args) {
-        const property = args[0];
-        const reference = args[1];
-        if (typeof property !== 'string' || typeof reference !== 'string') {
-            throw new Error('Of styleRef requires property and reference strings');
-        }
-        let target = null;
-        if (reference === 'me' && context.me) {
-            target = context.me instanceof HTMLElement ? context.me : null;
-        }
-        else if (reference === 'it' && context.it) {
-            target = context.it instanceof HTMLElement ? context.it : null;
-        }
-        if (!target) {
-            return undefined;
-        }
-        return readStyleValue(target, property);
-    },
-    validate(args) {
-        return (validateArgCount(args, 2, 'ofStyleRef', 'property, reference') ??
-            validateArgIsString(args, 0, 'ofStyleRef', 'property') ??
-            validateArgIsString(args, 1, 'ofStyleRef', 'reference'));
-    },
-};
-const referencesExpressions = {
-    me: meExpression,
-    you: youExpression,
-    it: itExpression,
-    its: itsExpression$1,
-    result: resultExpression,
-    querySelector: querySelectorExpression,
-    querySelectorAll: querySelectorAllExpression,
-    getElementById: idExpression,
-    getElementsByClassName: classExpression,
-    closest: closestExpression,
-    parent: parentExpression,
-    window: windowExpression,
-    document: documentExpression,
-    elementWithSelector: elementWithSelectorExpression,
-    styleRef: styleRefExpression,
-    possessiveStyleRef: possessiveStyleRefExpression,
-    ofStyleRef: ofStyleRefExpression,
-};
-
-function createValidationError(type, message, path, suggestions = []) {
-    return {
-        type,
-        message,
-        suggestions,
-        ...(path && { path }),
-    };
-}
-const isProduction = typeof process !== 'undefined' ? process.env.NODE_ENV === 'production' : false;
-const skipValidation = isProduction ||
-    (typeof process !== 'undefined' && process.env.HYPERFIXI_SKIP_VALIDATION === 'true') ||
-    (typeof globalThis !== 'undefined' && globalThis.HYPERFIXI_SKIP_VALIDATION === 'true');
-let addDescribeToValidator;
-function createPassthroughValidator() {
-    return addDescribeToValidator({
-        validate: (value) => ({
-            success: true,
-            data: value,
-        }),
-    });
-}
-function createStringValidator(options = {}) {
-    if (skipValidation) {
-        return createPassthroughValidator();
-    }
-    return addDescribeToValidator({
-        validate: (value) => {
-            if (options.optional && (value === undefined || value === null)) {
-                return { success: true, data: undefined };
-            }
-            if (typeof value !== 'string') {
-                return {
-                    success: false,
-                    error: createValidationError('type-mismatch', `Expected string, received ${typeof value}`),
-                };
-            }
-            if (options.minLength !== undefined && value.length < options.minLength) {
-                return {
-                    success: false,
-                    error: createValidationError('runtime-error', `String must be at least ${options.minLength} characters long`),
-                };
-            }
-            if (options.maxLength !== undefined && value.length > options.maxLength) {
-                return {
-                    success: false,
-                    error: createValidationError('runtime-error', `String must be at most ${options.maxLength} characters long`),
-                };
-            }
-            if (options.pattern && !options.pattern.test(value)) {
-                if (options.pattern.source.startsWith('^') && options.pattern.source.endsWith('$')) {
-                    const expected = options.pattern.source.slice(1, -1);
-                    return {
-                        success: false,
-                        error: createValidationError('runtime-error', `Expected "${expected}", received "${value}"`),
-                    };
-                }
-                return {
-                    success: false,
-                    error: createValidationError('missing-argument', `String does not match required pattern`),
-                };
-            }
-            return { success: true, data: value };
-        },
-        ...(options.description && { description: options.description }),
-    });
-}
-function createObjectValidator(fields, options) {
-    if (skipValidation) {
-        return createPassthroughValidator();
-    }
-    const validator = addDescribeToValidator({
-        validate: (value) => {
-            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-                return {
-                    success: false,
-                    error: createValidationError('type-mismatch', `Expected object, received ${typeof value}`),
-                };
-            }
-            const obj = value;
-            const result = {};
-            if (options?.strict) {
-                const allowedKeys = Object.keys(fields);
-                const actualKeys = Object.keys(obj);
-                const extraKeys = actualKeys.filter(key => !allowedKeys.includes(key));
-                if (extraKeys.length > 0) {
-                    return {
-                        success: false,
-                        error: createValidationError('runtime-error', `Unexpected properties: ${extraKeys.join(', ')}`),
-                    };
-                }
-            }
-            for (const [fieldName, validator] of Object.entries(fields)) {
-                const fieldValue = obj[fieldName];
-                const fieldExists = fieldName in obj;
-                if (!fieldExists && !validator._isOptional) {
-                    return {
-                        success: false,
-                        error: createValidationError('missing-argument', `Required field "${fieldName}" is missing`, fieldName),
-                    };
-                }
-                const fieldResult = validator.validate(fieldValue);
-                if (!fieldResult.success) {
-                    const errorPath = fieldResult.error.path
-                        ? `${fieldName}.${fieldResult.error.path}`
-                        : fieldName;
-                    return {
-                        success: false,
-                        error: createValidationError('validation-error', fieldResult.error.message || `Field "${fieldName}" validation failed`, errorPath),
-                    };
-                }
-                if (fieldResult.data !== undefined) {
-                    result[fieldName] = fieldResult.data;
-                }
-            }
-            return { success: true, data: result };
-        },
-    });
-    validator.strict = () => createObjectValidator(fields, { strict: true });
-    return validator;
-}
-function createArrayValidator(itemValidator) {
-    if (skipValidation) {
-        return createPassthroughValidator();
-    }
-    return addDescribeToValidator({
-        validate: (value) => {
-            if (!Array.isArray(value)) {
-                return {
-                    success: false,
-                    error: createValidationError('type-mismatch', `Expected array, received ${typeof value}`),
-                };
-            }
-            const result = [];
-            for (let i = 0; i < value.length; i++) {
-                const itemResult = itemValidator.validate(value[i]);
-                if (!itemResult.success) {
-                    const errorPath = itemResult.error.path ? `${i}.${itemResult.error.path}` : `${i}`;
-                    return {
-                        success: false,
-                        error: createValidationError('runtime-error', itemResult.error.message, errorPath),
-                    };
-                }
-                result.push(itemResult.data);
-            }
-            return { success: true, data: result };
-        },
-    });
-}
-function createTupleValidator(validators) {
-    if (skipValidation) {
-        return createPassthroughValidator();
-    }
-    return addDescribeToValidator({
-        validate: (value) => {
-            if (!Array.isArray(value)) {
-                return {
-                    success: false,
-                    error: createValidationError('type-mismatch', `Expected array, received ${typeof value}`),
-                };
-            }
-            if (value.length !== validators.length) {
-                return {
-                    success: false,
-                    error: createValidationError('runtime-error', `Expected tuple of length ${validators.length}, received length ${value.length}`),
-                };
-            }
-            const result = [];
-            for (let i = 0; i < validators.length; i++) {
-                const itemResult = validators[i].validate(value[i]);
-                if (!itemResult.success) {
-                    const errorPath = itemResult.error.path ? `${i}.${itemResult.error.path}` : `${i}`;
-                    return {
-                        success: false,
-                        error: createValidationError('runtime-error', itemResult.error.message, errorPath),
-                    };
-                }
-                result.push(itemResult.data);
-            }
-            return {
-                success: true,
-                data: result,
-            };
-        },
-    });
-}
-function createUnionValidator(validators) {
-    if (skipValidation) {
-        return createPassthroughValidator();
-    }
-    return addDescribeToValidator({
-        validate: (value) => {
-            const errors = [];
-            for (const validator of validators) {
-                const result = validator.validate(value);
-                if (result.success) {
-                    return result;
-                }
-                errors.push(result.error.message);
-            }
-            return {
-                success: false,
-                error: createValidationError('type-mismatch', 'Value does not match any union type'),
-            };
-        },
-    });
-}
-function createLiteralValidator(literalValue) {
-    if (skipValidation) {
-        return createPassthroughValidator();
-    }
-    return addDescribeToValidator({
-        validate: (value) => {
-            if (value === literalValue) {
-                return { success: true, data: value };
-            }
-            return {
-                success: false,
-                error: createValidationError('runtime-error', `Expected ${JSON.stringify(literalValue)}, received ${JSON.stringify(value)}`),
-            };
-        },
-    });
-}
-function createNumberValidator(options = {}) {
-    if (skipValidation) {
-        return createPassthroughValidator();
-    }
-    return addDescribeToValidator({
-        validate: (value) => {
-            const num = Number(value);
-            if (isNaN(num)) {
-                return {
-                    success: false,
-                    error: createValidationError('type-mismatch', `Expected number, received ${typeof value}`),
-                };
-            }
-            if (options.min !== undefined && num < options.min) {
-                return {
-                    success: false,
-                    error: createValidationError('runtime-error', `Number must be at least ${options.min}`),
-                };
-            }
-            if (options.max !== undefined && num > options.max) {
-                return {
-                    success: false,
-                    error: createValidationError('runtime-error', `Number must be at most ${options.max}`),
-                };
-            }
-            return { success: true, data: num };
-        },
-    });
-}
-function createBooleanValidator() {
-    if (skipValidation) {
-        return createPassthroughValidator();
-    }
-    return addDescribeToValidator({
-        validate: (value) => {
-            if (typeof value !== 'boolean') {
-                return {
-                    success: false,
-                    error: createValidationError('type-mismatch', `Expected boolean, received ${typeof value}`),
-                };
-            }
-            return { success: true, data: value };
-        },
-    });
-}
-function createCustomValidator(validator, errorMessage = 'Custom validation failed') {
-    if (skipValidation) {
-        return createPassthroughValidator();
-    }
-    return addDescribeToValidator({
-        validate: (value) => {
-            if (validator(value)) {
-                return { success: true, data: value };
-            }
-            return {
-                success: false,
-                error: createValidationError('runtime-error', errorMessage),
-            };
-        },
-    });
-}
-addDescribeToValidator = function (validator) {
-    if (!validator.describe) {
-        validator.describe = function (description) {
-            this.description = description;
-            return this;
-        };
-    }
-    if (!validator.safeParse) {
-        validator.safeParse = function (value) {
-            const result = this.validate(value);
-            if (result.success) {
-                return { success: true, data: result.data };
-            }
-            else {
-                return {
-                    success: false,
-                    error: { errors: result.error ? [result.error] : [] },
-                };
-            }
-        };
-    }
-    if (!validator.parse) {
-        validator.parse = function (value) {
-            const result = this.validate(value);
-            if (result.success && result.data !== undefined) {
-                return result.data;
-            }
-            throw new Error(result.error?.message || 'Validation failed');
-        };
-    }
-    if (!validator.optional) {
-        validator.optional = function () {
-            const originalValidate = this.validate.bind(this);
-            const optionalValidator = {
-                ...this,
-                _isOptional: true,
-                validate: (value) => {
-                    if (value === undefined || value === null) {
-                        return { success: true, data: undefined };
-                    }
-                    return originalValidate(value);
-                },
-            };
-            return addDescribeToValidator(optionalValidator);
-        };
-    }
-    if (!validator.min) {
-        validator.min = function (minLength) {
-            const originalValidate = this.validate.bind(this);
-            const minValidator = {
-                ...this,
-                validate: (value) => {
-                    const result = originalValidate(value);
-                    if (!result.success) {
-                        return result;
-                    }
-                    if (typeof result.data === 'string' && result.data.length < minLength) {
-                        return {
-                            success: false,
-                            error: createValidationError('runtime-error', `String must be at least ${minLength} characters long`),
-                        };
-                    }
-                    return result;
-                },
-            };
-            return addDescribeToValidator(minValidator);
-        };
-    }
-    if (!validator.max) {
-        validator.max = function (maxLength) {
-            const originalValidate = this.validate.bind(this);
-            const maxValidator = {
-                ...this,
-                validate: (value) => {
-                    const result = originalValidate(value);
-                    if (!result.success) {
-                        return result;
-                    }
-                    if (typeof result.data === 'string' && result.data.length > maxLength) {
-                        return {
-                            success: false,
-                            error: createValidationError('runtime-error', `String must be at most ${maxLength} characters long`),
-                        };
-                    }
-                    return result;
-                },
-            };
-            return addDescribeToValidator(maxValidator);
-        };
-    }
-    if (!validator.default) {
-        validator.default = function (defaultValue) {
-            const originalValidate = this.validate.bind(this);
-            const defaultValidator = {
-                ...this,
-                _defaultValue: defaultValue,
-                _hasDefault: true,
-                validate: (value) => {
-                    if (value === undefined) {
-                        return { success: true, data: defaultValue };
-                    }
-                    return originalValidate(value);
-                },
-            };
-            return addDescribeToValidator(defaultValidator);
-        };
-    }
-    if (!validator.rest) {
-        validator.rest = function (_restValidator) {
-            return this;
-        };
-    }
-    if (!validator.refine) {
-        validator.refine = function (refineFn, errorMessage) {
-            const originalValidate = this.validate.bind(this);
-            const refinedValidator = {
-                ...this,
-                validate: (value) => {
-                    const result = originalValidate(value);
-                    if (!result.success) {
-                        return result;
-                    }
-                    if (!refineFn(result.data)) {
-                        return {
-                            success: false,
-                            error: createValidationError('runtime-error', errorMessage || 'Refinement validation failed'),
-                        };
-                    }
-                    return result;
-                },
-            };
-            return addDescribeToValidator(refinedValidator);
-        };
-    }
-    return new Proxy(validator, {
-        get(target, prop, receiver) {
-            if (prop in target) {
-                return Reflect.get(target, prop, receiver);
-            }
-            if (typeof prop === 'string' &&
-                !prop.startsWith('_') &&
-                prop !== 'constructor' &&
-                prop !== 'validate' &&
-                prop !== 'then') {
-                return function (..._args) {
-                    return receiver;
-                };
-            }
-            return Reflect.get(target, prop, receiver);
-        },
-    });
-};
-function createRecordValidator(keyValidator, valueValidator) {
-    if (skipValidation) {
-        return createPassthroughValidator();
-    }
-    return addDescribeToValidator({
-        validate: (value) => {
-            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-                return {
-                    success: false,
-                    error: createValidationError('type-mismatch', `Expected record object, received ${typeof value}`),
-                };
-            }
-            const obj = value;
-            const result = {};
-            for (const [key, val] of Object.entries(obj)) {
-                const keyResult = keyValidator.validate(key);
-                if (!keyResult.success) {
-                    return {
-                        success: false,
-                        error: createValidationError('invalid-argument', `Invalid key "${key}": ${keyResult.error.message}`, key),
-                    };
-                }
-                const valueResult = valueValidator.validate(val);
-                if (!valueResult.success) {
-                    const errorPath = valueResult.error.path ? `${key}.${valueResult.error.path}` : key;
-                    return {
-                        success: false,
-                        error: createValidationError('runtime-error', valueResult.error.message, errorPath),
-                    };
-                }
-                result[key] = valueResult.data;
-            }
-            return { success: true, data: result };
-        },
-    });
-}
-function createEnumValidator(values) {
-    if (skipValidation) {
-        return createPassthroughValidator();
-    }
-    return addDescribeToValidator({
-        validate: (value) => {
-            if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
-                return {
-                    success: false,
-                    error: createValidationError('type-mismatch', `Expected string, received ${typeof value}`),
-                };
-            }
-            if (!values.includes(value)) {
-                return {
-                    success: false,
-                    error: createValidationError('runtime-error', `Expected one of [${values.join(', ')}], received "${value}"`),
-                };
-            }
-            return { success: true, data: value };
-        },
-    });
-}
-const v = {
-    string: (options) => createStringValidator(options || {}),
-    number: (options) => createNumberValidator(options || {}),
-    boolean: () => createBooleanValidator(),
-    object: (fields) => createObjectValidator(fields),
-    array: (itemValidator) => createArrayValidator(itemValidator),
-    tuple: (validators) => createTupleValidator(validators),
-    union: (validators) => createUnionValidator(validators),
-    literal: (value) => createLiteralValidator(value),
-    custom: (validator, errorMessage) => createCustomValidator(validator, errorMessage),
-    record: (keyValidator, valueValidator) => createRecordValidator(keyValidator, valueValidator),
-    enum: (values) => createEnumValidator(values),
-    function: () => createCustomValidator(value => typeof value === 'function', 'Expected function'),
-    unknown: () => createPassthroughValidator(),
-    any: () => createPassthroughValidator(),
-    null: () => createCustomValidator(value => value === null, 'Expected null'),
-    undefined: () => createCustomValidator(value => value === undefined, 'Expected undefined'),
-    instanceOf: (constructor) => createCustomValidator(value => value instanceof constructor, `Expected instance of ${constructor.name}`),
-    instanceof: (constructor) => createCustomValidator(value => value instanceof constructor, `Expected instance of ${constructor.name}`),
-};
-
-class LRUCache {
-    constructor(maxSize = 100, ttl = 5000) {
-        this.maxSize = maxSize;
-        this.ttl = ttl;
-        this.cache = new Map();
-        this.accessOrder = new Map();
-        this.accessCounter = 0;
-    }
-    get(key) {
-        const entry = this.cache.get(key);
-        if (!entry)
-            return undefined;
-        if (Date.now() - entry.timestamp > this.ttl) {
-            this.delete(key);
-            return undefined;
-        }
-        entry.accessCount++;
-        this.accessOrder.set(key, ++this.accessCounter);
-        return entry.result;
-    }
-    set(key, value) {
-        if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
-            this.evictLRU();
-        }
-        const entry = {
-            result: value,
-            timestamp: Date.now(),
-            accessCount: 1,
-        };
-        this.cache.set(key, entry);
-        this.accessOrder.set(key, ++this.accessCounter);
-    }
-    delete(key) {
-        this.accessOrder.delete(key);
-        return this.cache.delete(key);
-    }
-    clear() {
-        this.cache.clear();
-        this.accessOrder.clear();
-        this.accessCounter = 0;
-    }
-    size() {
-        return this.cache.size;
-    }
-    evictLRU() {
-        let lruKey;
-        let lruAccessOrder = Infinity;
-        for (const [key, accessOrder] of this.accessOrder) {
-            if (accessOrder < lruAccessOrder) {
-                lruAccessOrder = accessOrder;
-                lruKey = key;
-            }
-        }
-        if (lruKey !== undefined) {
-            this.delete(lruKey);
-        }
-    }
-    getStats() {
-        const entries = Array.from(this.cache.values());
-        const now = Date.now();
-        return {
-            size: this.cache.size,
-            maxSize: this.maxSize,
-            hitRate: entries.length > 0 ? entries.filter(e => e.accessCount > 1).length / entries.length : 0,
-            avgAge: entries.length > 0
-                ? entries.reduce((sum, e) => sum + (now - e.timestamp), 0) / entries.length
-                : 0,
-            totalAccesses: entries.reduce((sum, e) => sum + e.accessCount, 0),
-        };
-    }
-}
-class HyperscriptCache {
-    constructor() {
-        this.domQueryCache = new LRUCache(200, 3000);
-        this.exprResultCache = new LRUCache(500, 2000);
-        this.cssMatchCache = new LRUCache(100, 5000);
-        this.formValueCache = new LRUCache(50, 1000);
-        this.hits = 0;
-        this.misses = 0;
-    }
-    querySelector(selector) {
-        const cacheKey = `querySelector:${selector}`;
-        const cached = this.domQueryCache.get(cacheKey);
-        if (cached !== undefined) {
-            this.hits++;
-            return cached;
-        }
-        this.misses++;
-        const result = document.querySelector(selector);
-        this.domQueryCache.set(cacheKey, result);
-        return result;
-    }
-    querySelectorAll(selector) {
-        const cacheKey = `querySelectorAll:${selector}`;
-        const cached = this.domQueryCache.get(cacheKey);
-        if (cached !== undefined) {
-            this.hits++;
-            return cached;
-        }
-        this.misses++;
-        const result = Array.from(document.querySelectorAll(selector));
-        this.domQueryCache.set(cacheKey, result);
-        return result;
-    }
-    getElementById(id) {
-        const cacheKey = `getElementById:${id}`;
-        const cached = this.domQueryCache.get(cacheKey);
-        if (cached !== undefined) {
-            this.hits++;
-            return cached;
-        }
-        this.misses++;
-        const result = document.getElementById(id);
-        this.domQueryCache.set(cacheKey, result);
-        return result;
-    }
-    getElementsByClassName(className) {
-        const cacheKey = `getElementsByClassName:${className}`;
-        const cached = this.domQueryCache.get(cacheKey);
-        if (cached !== undefined) {
-            this.hits++;
-            return cached;
-        }
-        this.misses++;
-        const result = Array.from(document.getElementsByClassName(className));
-        this.domQueryCache.set(cacheKey, result);
-        return result;
-    }
-    matches(element, selector) {
-        const elementId = this.getElementCacheKey(element);
-        const cacheKey = `matches:${elementId}:${selector}`;
-        const cached = this.cssMatchCache.get(cacheKey);
-        if (cached !== undefined) {
-            this.hits++;
-            return cached;
-        }
-        this.misses++;
-        const result = element.matches(selector);
-        this.cssMatchCache.set(cacheKey, result);
-        return result;
-    }
-    getExpressionResult(exprKey) {
-        const cached = this.exprResultCache.get(exprKey);
-        if (cached !== undefined) {
-            this.hits++;
-            return cached;
-        }
-        this.misses++;
-        return undefined;
-    }
-    setExpressionResult(exprKey, result) {
-        this.exprResultCache.set(exprKey, result);
-    }
-    getFormValue(form) {
-        const formId = this.getElementCacheKey(form);
-        const cacheKey = `formValue:${formId}`;
-        const cached = this.formValueCache.get(cacheKey);
-        if (cached !== undefined) {
-            this.hits++;
-            return cached;
-        }
-        this.misses++;
-        return undefined;
-    }
-    setFormValue(form, value) {
-        const formId = this.getElementCacheKey(form);
-        const cacheKey = `formValue:${formId}`;
-        this.formValueCache.set(cacheKey, value);
-    }
-    invalidateElementCache(element) {
-        const elementId = this.getElementCacheKey(element);
-        for (const cache of [this.domQueryCache, this.cssMatchCache, this.formValueCache]) {
-            for (const key of Array.from(cache['cache'].keys())) {
-                if (typeof key === 'string' && key.includes(elementId)) {
-                    cache.delete(key);
-                }
-            }
-        }
-    }
-    invalidateAll() {
-        this.domQueryCache.clear();
-        this.exprResultCache.clear();
-        this.cssMatchCache.clear();
-        this.formValueCache.clear();
-        this.hits = 0;
-        this.misses = 0;
-    }
-    getElementCacheKey(element) {
-        if (element.id)
-            return `#${element.id}`;
-        const classes = Array.from(element.classList).sort().join('.');
-        const position = this.getElementPosition(element);
-        return `${element.tagName.toLowerCase()}${classes ? '.' + classes : ''}@${position}`;
-    }
-    getElementPosition(element) {
-        const siblings = Array.from(element.parentElement?.children || []);
-        const index = siblings.indexOf(element);
-        return `${index}`;
-    }
-    getPerformanceStats() {
-        const total = this.hits + this.misses;
-        const hitRate = total > 0 ? (this.hits / total) * 100 : 0;
-        return {
-            hits: this.hits,
-            misses: this.misses,
-            hitRate: Math.round(hitRate * 100) / 100,
-            domQueryCache: this.domQueryCache.getStats(),
-            exprResultCache: this.exprResultCache.getStats(),
-            cssMatchCache: this.cssMatchCache.getStats(),
-            formValueCache: this.formValueCache.getStats(),
-        };
-    }
-    cleanup() {
-        const now = Date.now();
-        [this.domQueryCache, this.exprResultCache, this.cssMatchCache, this.formValueCache].forEach(cache => {
-            const entries = Array.from(cache['cache'].entries());
-            entries.forEach(([key, entry]) => {
-                if (now - entry.timestamp > cache['ttl']) {
-                    cache.delete(key);
-                }
-            });
-        });
-    }
-}
-const globalCache = new HyperscriptCache();
-if (typeof window !== 'undefined') {
-    setInterval(() => {
-        globalCache.cleanup();
-    }, 10000);
-}
-
-var TokenKind;
-(function (TokenKind) {
-    TokenKind["IDENTIFIER"] = "identifier";
-    TokenKind["STRING"] = "string";
-    TokenKind["NUMBER"] = "number";
-    TokenKind["SELECTOR"] = "selector";
-    TokenKind["OPERATOR"] = "operator";
-    TokenKind["TIME"] = "time";
-    TokenKind["TEMPLATE"] = "template";
-    TokenKind["COMMENT"] = "comment";
-    TokenKind["SYMBOL"] = "symbol";
-    TokenKind["UNKNOWN"] = "unknown";
-})(TokenKind || (TokenKind = {}));
-
-class PerformanceTracker {
-    constructor() {
-        this.metrics = {
-            tokenizationTime: 0,
-            evaluationTime: 0,
-            cacheHitRate: 0,
-            memoryUsage: 0,
-            domOperations: 0,
-        };
-        this.startTimes = new Map();
-    }
-    startTimer(operation) {
-        this.startTimes.set(operation, performance.now());
-    }
-    endTimer(operation) {
-        const startTime = this.startTimes.get(operation);
-        if (startTime) {
-            const duration = performance.now() - startTime;
-            this.startTimes.delete(operation);
-            return duration;
-        }
-        return 0;
-    }
-    recordTokenization(duration) {
-        this.metrics.tokenizationTime += duration;
-    }
-    recordEvaluation(duration) {
-        this.metrics.evaluationTime += duration;
-    }
-    updateCacheMetrics() {
-        const cacheStats = globalCache.getPerformanceStats();
-        this.metrics.cacheHitRate = cacheStats.hitRate;
-    }
-    getMetrics() {
-        this.updateCacheMetrics();
-        return { ...this.metrics };
-    }
-    reset() {
-        this.metrics = {
-            tokenizationTime: 0,
-            evaluationTime: 0,
-            cacheHitRate: 0,
-            memoryUsage: 0,
-            domOperations: 0,
-        };
-    }
-}
-const performanceTracker = new PerformanceTracker();
-function matchesWithCache(element, selector) {
-    return globalCache.matches(element, selector);
-}
-function performCleanup() {
-    globalCache.cleanup();
-    const metrics = performanceTracker.getMetrics();
-    if (metrics.memoryUsage > 50 * 1024 * 1024) {
-        performanceTracker.reset();
-    }
-}
-let cleanupInterval = null;
-function enableAutoCleanup(intervalMs = 30000) {
-    if (cleanupInterval) {
-        clearInterval(cleanupInterval);
-    }
-    cleanupInterval = setInterval(performCleanup, intervalMs);
-}
-if (typeof window !== 'undefined') {
-    enableAutoCleanup();
-}
-
-function toNumber(value, context) {
-    if (typeof value === 'number') {
-        if (!Number.isFinite(value)) {
-            throw new Error(`${context} must be a finite number, got ${value}`);
-        }
-        return value;
-    }
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        if (trimmed === '') {
-            return 0;
-        }
-        const num = parseFloat(trimmed);
-        if (isNaN(num)) {
-            throw new Error(`${context} cannot be converted to number: "${value}"`);
-        }
-        return num;
-    }
-    if (typeof value === 'boolean') {
-        return value ? 1 : 0;
-    }
-    if (value === null || value === undefined) {
-        return 0;
-    }
-    if (typeof value === 'object' && value !== null) {
-        if (Array.isArray(value) && value.length === 1) {
-            const inner = value[0];
-            if (Array.isArray(inner)) {
-                throw new Error(`${context} is a nested array, cannot convert to number`);
-            }
-            return toNumber(inner, context);
-        }
-        const obj = value;
-        if (typeof obj.textContent === 'string' || 'value' in obj) {
-            const text = obj.value ?? obj.textContent;
-            if (text !== null && text !== undefined) {
-                const trimmed = String(text).trim();
-                if (trimmed === '')
-                    return 0;
-                const num = parseFloat(trimmed);
-                if (!isNaN(num))
-                    return num;
-            }
-        }
-        const primitive = value.valueOf();
-        if (typeof primitive === 'number' && Number.isFinite(primitive)) {
-            return primitive;
-        }
-    }
-    throw new Error(`${context} cannot be converted to number: ${typeof value}`);
-}
-function toNumberOrNull(value) {
-    if (typeof value === 'number') {
-        return Number.isFinite(value) ? value : null;
-    }
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        if (trimmed === '')
-            return 0;
-        const num = parseFloat(trimmed);
-        return isNaN(num) ? null : num;
-    }
-    if (typeof value === 'boolean') {
-        return value ? 1 : 0;
-    }
-    if (value === null || value === undefined) {
-        return 0;
-    }
-    return null;
-}
-function ensureFinite(num, operation) {
-    if (!Number.isFinite(num)) {
-        if (Number.isNaN(num)) {
-            throw new Error(`${operation} resulted in non-finite value: NaN`);
-        }
-        throw new Error(`${operation} resulted in non-finite value: ${num > 0 ? 'Infinity' : '-Infinity'}`);
-    }
-    return num;
-}
-function canBeNumeric(value) {
-    try {
-        toNumber(value, '_');
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function safeDivide(left, right, allowInfinity = true) {
-    if (right === 0) {
-        if (allowInfinity) {
-            return left === 0 ? NaN : left > 0 ? Infinity : -Infinity;
-        }
-        throw new Error('Division by zero');
-    }
-    return left / right;
-}
-function safeModulo(left, right) {
-    if (right === 0) {
-        throw new Error('Modulo by zero');
-    }
-    return left % right;
-}
-
-function compareValues(left, right, operator) {
-    if (operator === '===') {
-        return left === right;
-    }
-    if (operator === '!==') {
-        return left !== right;
-    }
-    if (left == null || right == null) {
-        return compareNullish(left, right, operator);
-    }
-    const [leftVal, rightVal] = coerceToComparable(left, right);
-    switch (operator) {
-        case '>':
-            return leftVal > rightVal;
-        case '<':
-            return leftVal < rightVal;
-        case '>=':
-            return leftVal >= rightVal;
-        case '<=':
-            return leftVal <= rightVal;
-        case '==':
-            return compareEquality(left, right);
-        case '!=':
-            return !compareEquality(left, right);
-        default:
-            return false;
-    }
-}
-function compareNullish(left, right, operator) {
-    const leftIsNullish = left == null;
-    const rightIsNullish = right == null;
-    if (leftIsNullish && rightIsNullish) {
-        switch (operator) {
-            case '==':
-            case '>=':
-            case '<=':
-                return true;
-            case '!=':
-            case '>':
-            case '<':
-                return false;
-            default:
-                return false;
-        }
-    }
-    switch (operator) {
-        case '==':
-            return false;
-        case '!=':
-            return true;
-        case '>':
-        case '<':
-        case '>=':
-        case '<=':
-            return false;
-        default:
-            return false;
-    }
-}
-function compareEquality(left, right) {
-    if (left === right) {
-        return true;
-    }
-    if (typeof left === typeof right) {
-        if (typeof left === 'string') {
-            return left === right;
-        }
-        if (typeof left === 'number') {
-            return left === right;
-        }
-        return false;
-    }
-    if (typeof left === 'number' && typeof right === 'string') {
-        const rightNum = parseFloat(right);
-        return !isNaN(rightNum) && left === rightNum;
-    }
-    if (typeof left === 'string' && typeof right === 'number') {
-        const leftNum = parseFloat(left);
-        return !isNaN(leftNum) && leftNum === right;
-    }
-    if (typeof left === 'boolean') {
-        return compareEquality(left ? 1 : 0, right);
-    }
-    if (typeof right === 'boolean') {
-        return compareEquality(left, right ? 1 : 0);
-    }
-    return String(left) === String(right);
-}
-function coerceToComparable(left, right) {
-    if (typeof left === 'number' && typeof right === 'number') {
-        return [left, right];
-    }
-    if (typeof left === 'string' && typeof right === 'string') {
-        const leftNum = parseFloat(left);
-        const rightNum = parseFloat(right);
-        if (!isNaN(leftNum) && !isNaN(rightNum)) {
-            return [leftNum, rightNum];
-        }
-        return [left, right];
-    }
-    const leftNum = toNumberOrNull(left);
-    const rightNum = toNumberOrNull(right);
-    if (leftNum !== null && rightNum !== null) {
-        return [leftNum, rightNum];
-    }
-    return [String(left), String(right)];
-}
-
-function validResult() {
-    return {
-        isValid: true,
-        errors: [],
-        suggestions: [],
-    };
-}
-function invalidResult(errors, suggestions = []) {
-    return {
-        isValid: false,
-        errors,
-        suggestions,
-    };
-}
-function createError(type, message, suggestions = [], severity = 'error') {
-    return { type, message, suggestions, severity };
-}
-function validateBinaryInput(input) {
-    if (input === null || input === undefined) {
-        return invalidResult([createError('missing-argument', 'Input is null or undefined')], ['Provide an object with left and right operands']);
-    }
-    if (typeof input !== 'object') {
-        return invalidResult([createError('type-mismatch', `Expected object, got ${typeof input}`)], ['Provide an object with left and right operands']);
-    }
-    const obj = input;
-    if (!('left' in obj) || !('right' in obj)) {
-        const missing = [];
-        if (!('left' in obj))
-            missing.push('left');
-        if (!('right' in obj))
-            missing.push('right');
-        return invalidResult([
-            createError('missing-argument', `Missing ${missing.join(' and ')} operand${missing.length > 1 ? 's' : ''}`),
-        ], ['Provide { left: value, right: value }']);
-    }
-    return validResult();
-}
-
-function trackEvaluation(expression, _context, args, result, startTime, success = true, error) {
-    return result;
-}
-
-function isDOMElement(value) {
-    return (value !== null &&
-        typeof value === 'object' &&
-        'nodeType' in value &&
-        value.nodeType === 1);
-}
-const ComparisonInputSchema = v.tuple([v.unknown(), v.unknown()]);
-const PatternMatchingInputSchema = v.tuple([v.unknown(), v.string()]);
-const equalsExpression = {
-    name: 'equals',
-    category: 'Comparison',
-    evaluatesTo: 'Boolean',
-    precedence: 10,
-    associativity: 'Left',
-    operators: ['is', '==', 'equals'],
-    async evaluate(context, left, right) {
-        const startTime = 0;
-        try {
-            const result = left == right;
-            return trackEvaluation(this, context, [left, right], result, startTime);
-        }
-        catch (error) {
-            throw error;
-        }
-    },
-    validate(args) {
-        return validateTwoArgs(args, 'equals');
-    },
-    inputSchema: ComparisonInputSchema,
-    metadata: {
-        category: 'Logical',
-        complexity: 'simple',
-        sideEffects: [],
-        dependencies: [],
-        returnTypes: ['Boolean'],
-        examples: [
-            {
-                input: 'value is 5',
-                description: 'Check if value equals 5 using loose equality',
-                expectedOutput: true,
-                context: { result: 5 },
-            },
-            {
-                input: '"5" == 5',
-                description: 'String "5" equals number 5 with type coercion',
-                expectedOutput: true,
-            },
-        ],
-        relatedExpressions: ['strictEquals', 'notEquals'],
-        performance: {
-            averageTime: 0.001,
-            complexity: 'O(1)',
-        },
-    },
-};
-const strictEqualsExpression = {
-    name: 'strictEquals',
-    category: 'Comparison',
-    evaluatesTo: 'Boolean',
-    precedence: 10,
-    associativity: 'Left',
-    operators: ['==='],
-    async evaluate(context, left, right) {
-        const result = left === right;
-        return result;
-    },
-    validate(args) {
-        return validateTwoArgs(args, 'strictEquals');
-    },
-};
-const notEqualsExpression = {
-    name: 'notEquals',
-    category: 'Comparison',
-    evaluatesTo: 'Boolean',
-    precedence: 10,
-    associativity: 'Left',
-    operators: ['!=', 'is not', 'does not equal'],
-    async evaluate(context, left, right) {
-        const result = left != right;
-        return result;
-    },
-    validate(args) {
-        return validateTwoArgs(args, 'notEquals');
-    },
-};
-const strictNotEqualsExpression = {
-    name: 'strictNotEquals',
-    category: 'Comparison',
-    evaluatesTo: 'Boolean',
-    precedence: 10,
-    associativity: 'Left',
-    operators: ['!=='],
-    async evaluate(context, left, right) {
-        const result = left !== right;
-        return result;
-    },
-    validate(args) {
-        return validateTwoArgs(args, 'strictNotEquals');
-    },
-};
-const lessThanExpression = {
-    name: 'lessThan',
-    category: 'Comparison',
-    evaluatesTo: 'Boolean',
-    precedence: 12,
-    associativity: 'Left',
-    operators: ['<', 'is less than'],
-    async evaluate(context, left, right) {
-        const result = compareValues(left, right, '<');
-        return result;
-    },
-    validate(args) {
-        return validateTwoArgs(args, 'lessThan');
-    },
-};
-const lessThanOrEqualExpression = {
-    name: 'lessThanOrEqual',
-    category: 'Comparison',
-    evaluatesTo: 'Boolean',
-    precedence: 12,
-    associativity: 'Left',
-    operators: ['<=', 'is less than or equal to'],
-    async evaluate(context, left, right) {
-        const result = compareValues(left, right, '<=');
-        return result;
-    },
-    validate(args) {
-        return validateTwoArgs(args, 'lessThanOrEqual');
-    },
-};
-const greaterThanExpression = {
-    name: 'greaterThan',
-    category: 'Comparison',
-    evaluatesTo: 'Boolean',
-    precedence: 12,
-    associativity: 'Left',
-    operators: ['>', 'is greater than'],
-    async evaluate(context, left, right) {
-        const result = compareValues(left, right, '>');
-        return result;
-    },
-    validate(args) {
-        return validateTwoArgs(args, 'greaterThan');
-    },
-};
-const greaterThanOrEqualExpression = {
-    name: 'greaterThanOrEqual',
-    category: 'Comparison',
-    evaluatesTo: 'Boolean',
-    precedence: 12,
-    associativity: 'Left',
-    operators: ['>=', 'is greater than or equal to'],
-    async evaluate(context, left, right) {
-        const result = compareValues(left, right, '>=');
-        return result;
-    },
-    validate(args) {
-        return validateTwoArgs(args, 'greaterThanOrEqual');
-    },
-};
-const andExpression = {
-    name: 'and',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    precedence: 6,
-    associativity: 'Left',
-    operators: ['and', '&&'],
-    async evaluate(context, left, right) {
-        const startTime = 0;
-        try {
-            const result = left && right;
-            return trackEvaluation(this, context, [left, right], result, startTime);
-        }
-        catch (error) {
-            throw error;
-        }
-    },
-    validate(args) {
-        return validateTwoArgs(args, 'and');
-    },
-    inputSchema: ComparisonInputSchema,
-    metadata: {
-        category: 'Logical',
-        complexity: 'simple',
-        sideEffects: [],
-        dependencies: [],
-        returnTypes: ['Boolean'],
-        examples: [
-            {
-                input: 'true and false',
-                description: 'Logical AND of boolean values',
-                expectedOutput: false,
-            },
-            {
-                input: 'name and age',
-                description: 'Both name and age must be truthy',
-                expectedOutput: true,
-                context: {
-                    variables: new Map([
-                        ['name', 'John'],
-                        ['age', 25],
-                    ]),
-                },
-            },
-        ],
-        relatedExpressions: ['or', 'not'],
-        performance: {
-            averageTime: 0.001,
-            complexity: 'O(1)',
-        },
-    },
-};
-const orExpression = {
-    name: 'or',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    precedence: 5,
-    associativity: 'Left',
-    operators: ['or', '||'],
-    async evaluate(context, left, right) {
-        const result = left || right;
-        return result;
-    },
-    validate(args) {
-        return validateTwoArgs(args, 'or');
-    },
-};
-const notExpression = {
-    name: 'not',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    precedence: 15,
-    associativity: 'Right',
-    operators: ['not', '!'],
-    async evaluate(context, operand) {
-        const result = !operand;
-        return result;
-    },
-    validate(args) {
-        return validateArgCount(args, 1, 'not', 'operand');
-    },
-};
-const isEmptyExpression = {
-    name: 'isEmpty',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    operators: ['is empty', 'isEmpty'],
-    async evaluate(context, value) {
-        let result;
-        if (value == null)
-            result = true;
-        else if (isString(value))
-            result = value.length === 0;
-        else if (Array.isArray(value))
-            result = value.length === 0;
-        else if (value instanceof NodeList)
-            result = value.length === 0;
-        else if (value instanceof Node || value instanceof Element)
-            result = false;
-        else if (isObject(value))
-            result = value.length === 0;
-        else
-            result = false;
-        return result;
-    },
-    validate(args) {
-        return validateArgCount(args, 1, 'isEmpty', 'value');
-    },
-};
-const noExpression = {
-    name: 'no',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    operators: ['no'],
-    async evaluate(context, value) {
-        let result;
-        if (value == null)
-            result = true;
-        else if (value === false)
-            result = true;
-        else if (Array.isArray(value))
-            result = value.length === 0;
-        else if (value instanceof NodeList)
-            result = value.length === 0;
-        else if (isString(value))
-            result = false;
-        else
-            result = false;
-        return result;
-    },
-    validate(args) {
-        return validateArgCount(args, 1, 'no', 'value');
-    },
-};
-const isNotEmptyExpression = {
-    name: 'isNotEmpty',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    operators: ['is not empty', 'isNotEmpty'],
-    async evaluate(context, value) {
-        const result = !(await isEmptyExpression.evaluate(context, value));
-        return result;
-    },
-    validate(args) {
-        return validateArgCount(args, 1, 'isNotEmpty', 'value');
-    },
-};
-const existsExpression = {
-    name: 'exists',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    operators: ['exists'],
-    async evaluate(context, value) {
-        const result = valueExists(value);
-        return result;
-    },
-    validate(args) {
-        return validateArgCount(args, 1, 'exists', 'value');
-    },
-};
-function valueExists(value) {
-    if (value == null)
-        return false;
-    if (Array.isArray(value))
-        return value.length > 0;
-    if (typeof NodeList !== 'undefined' && value instanceof NodeList)
-        return value.length > 0;
-    return true;
-}
-const doesNotExistExpression = {
-    name: 'doesNotExist',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    operators: ['does not exist', 'doesNotExist'],
-    async evaluate(context, value) {
-        const result = !valueExists(value);
-        return result;
-    },
-    validate(args) {
-        return validateArgCount(args, 1, 'doesNotExist', 'value');
-    },
-};
-const containsExpression = {
-    name: 'contains',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    operators: ['contains', 'includes', 'include'],
-    async evaluate(context, container, value) {
-        let result;
-        if (container && value) {
-            if (isDOMElement(container) && isDOMElement(value)) {
-                result = container.contains(value);
-                return result;
-            }
-            if (isString(container) && container.match(/^[.#][\w-]+$/)) {
-                const containerElement = document.querySelector(container);
-                if (containerElement && isDOMElement(value)) {
-                    result = containerElement.contains(value);
-                    return result;
-                }
-                if (containerElement && isString(value) && value.match(/^[.#][\w-]+$/)) {
-                    const valueElement = document.querySelector(value);
-                    result = valueElement ? containerElement.contains(valueElement) : false;
-                    return result;
-                }
-            }
-            if (isString(value) && value.match(/^[.#][\w-]+$/) && isDOMElement(container)) {
-                const valueElement = document.querySelector(value);
-                result = valueElement ? container.contains(valueElement) : false;
-                return result;
-            }
-        }
-        if (isString(container) && isString(value)) {
-            result = container.includes(value);
-        }
-        else if (Array.isArray(container) ||
-            (typeof NodeList !== 'undefined' && container instanceof NodeList)) {
-            const items = Array.from(container);
-            result =
-                items.includes(value) ||
-                    (value instanceof Node &&
-                        items.some(item => item instanceof Node && item.contains(value)));
-        }
-        else if (isObject(container) && isString(value)) {
-            result = value in container;
-        }
-        else {
-            result = false;
-        }
-        return result;
-    },
-    validate(args) {
-        return validateArgCount(args, 2, 'contains', 'container, value');
-    },
-};
-const doesNotContainExpression = {
-    name: 'doesNotContain',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    operators: ['does not contain', 'doesNotContain', 'does not include', 'doesNotInclude'],
-    async evaluate(context, container, value) {
-        const result = !(await containsExpression.evaluate(context, container, value));
-        return result;
-    },
-    validate(args) {
-        return validateArgCount(args, 2, 'doesNotContain', 'container, value');
-    },
-};
-const startsWithExpression = {
-    name: 'startsWith',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    operators: ['starts with', 'startsWith'],
-    async evaluate(context, str, prefix) {
-        const result = str != null && prefix != null ? String(str).startsWith(String(prefix)) : false;
-        return result;
-    },
-    validate(args) {
-        return validateArgCount(args, 2, 'startsWith', 'str, prefix');
-    },
-};
-const endsWithExpression = {
-    name: 'endsWith',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    operators: ['ends with', 'endsWith'],
-    async evaluate(context, str, suffix) {
-        const result = str != null && suffix != null ? String(str).endsWith(String(suffix)) : false;
-        return result;
-    },
-    validate(args) {
-        return validateArgCount(args, 2, 'endsWith', 'str, suffix');
-    },
-};
-const betweenExpression = {
-    name: 'between',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    operators: ['is between', 'between'],
-    async evaluate(context, value, min, max) {
-        let lo = min;
-        let hi = max;
-        if (lo != null && hi != null && lo > hi) {
-            const swap = lo;
-            lo = hi;
-            hi = swap;
-        }
-        const result = lo != null &&
-            hi != null &&
-            value >= lo &&
-            value <= hi;
-        return result;
-    },
-    validate(args) {
-        return validateArgCount(args, 3, 'between', 'value, min, max');
-    },
-};
-const matchesExpression = {
-    name: 'matches',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    operators: ['matches'],
-    async evaluate(context, element, selector) {
-        const startTime = 0;
-        try {
-            let result;
-            if (element instanceof Element && isString(selector)) {
-                const selectorStr = selector;
-                if (selectorStr.startsWith('.') ||
-                    selectorStr.startsWith('#') ||
-                    selectorStr.startsWith(':') ||
-                    selectorStr.startsWith('[') ||
-                    /^[a-zA-Z][\w-]*$/.test(selectorStr)) {
-                    try {
-                        result = matchesWithCache(element, selectorStr);
-                    }
-                    catch (error) {
-                        result = false;
-                    }
-                }
-                else {
-                    result = false;
-                }
-            }
-            else if (isString(element) && isString(selector)) {
-                const elementStr = element;
-                const selectorStr = selector;
-                try {
-                    const regex = selectorStr.startsWith('/') && selectorStr.endsWith('/')
-                        ? new RegExp(selectorStr.slice(1, -1))
-                        : new RegExp(selectorStr);
-                    result = regex.test(elementStr);
-                }
-                catch (error) {
-                    result = elementStr.includes(selectorStr);
-                }
-            }
-            else {
-                result = false;
-            }
-            return trackEvaluation(this, context, [element, selector], result, startTime);
-        }
-        catch (error) {
-            throw error;
-        }
-    },
-    validate(args) {
-        return validateArgCount(args, 2, 'matches', 'element, selector');
-    },
-    inputSchema: PatternMatchingInputSchema,
-    metadata: {
-        category: 'Logical',
-        complexity: 'medium',
-        sideEffects: ['dom-query'],
-        dependencies: [],
-        returnTypes: ['Boolean'],
-        examples: [
-            {
-                input: 'element matches ".active"',
-                description: 'Check if element has active class',
-                expectedOutput: true,
-            },
-            {
-                input: 'text matches "/^hello/"',
-                description: 'Check if text starts with "hello" using regex',
-                expectedOutput: true,
-                context: { variables: new Map([['text', 'hello world']]) },
-            },
-        ],
-        relatedExpressions: ['contains', 'startsWith', 'endsWith'],
-        performance: {
-            averageTime: 0.5,
-            complexity: 'O(n)',
-        },
-    },
-};
-const hasExpression = {
-    name: 'has',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    operators: ['has', 'have'],
-    async evaluate(context, element, selector) {
-        let result = false;
-        if (element instanceof Element && isString(selector)) {
-            const selectorStr = selector;
-            if (selectorStr.startsWith('.')) {
-                result = element.classList.contains(selectorStr.slice(1));
-            }
-            else if (selectorStr.startsWith('[') && selectorStr.endsWith(']')) {
-                result = element.hasAttribute(selectorStr.slice(1, -1));
-            }
-        }
-        return result;
-    },
-    validate(args) {
-        return validateArgCount(args, 2, 'has', 'element, selector');
-    },
-};
-const doesNotHaveExpression = {
-    name: 'doesNotHave',
-    category: 'Logical',
-    evaluatesTo: 'Boolean',
-    operators: ['does not have'],
-    async evaluate(context, element, selector) {
-        const result = !(await hasExpression.evaluate(context, element, selector));
-        return result;
-    },
-    validate(args) {
-        return validateArgCount(args, 2, 'doesNotHave', 'element, selector');
-    },
-};
-const logicalExpressions = {
-    equals: equalsExpression,
-    strictEquals: strictEqualsExpression,
-    notEquals: notEqualsExpression,
-    strictNotEquals: strictNotEqualsExpression,
-    lessThan: lessThanExpression,
-    lessThanOrEqual: lessThanOrEqualExpression,
-    greaterThan: greaterThanExpression,
-    greaterThanOrEqual: greaterThanOrEqualExpression,
-    and: andExpression,
-    or: orExpression,
-    not: notExpression,
-    no: noExpression,
-    isEmpty: isEmptyExpression,
-    isNotEmpty: isNotEmptyExpression,
-    exists: existsExpression,
-    doesNotExist: doesNotExistExpression,
-    contains: containsExpression,
-    doesNotContain: doesNotContainExpression,
-    startsWith: startsWithExpression,
-    endsWith: endsWithExpression,
-    between: betweenExpression,
-    matches: matchesExpression,
-    has: hasExpression,
-    doesNotHave: doesNotHaveExpression,
-};
-
-class BaseExpressionImpl {
-    trackPerformance(context, input, result, startTime) {
-    }
-    trackSimple(context, startTime, success, output = success ? 'success' : 'error') {
-    }
-    toBoolean(value) {
-        if (value === false ||
-            value === 0 ||
-            value === 0n ||
-            value === '' ||
-            value === null ||
-            value === undefined) {
-            return false;
-        }
-        if (isNumber(value) && isNaN(value)) {
-            return false;
-        }
-        return true;
-    }
-    success(value, type) {
-        return {
-            success: true,
-            value,
-            type,
-        };
-    }
-    failure(name, type, message, code, suggestions = []) {
-        return {
-            success: false,
-            error: {
-                name,
-                type,
-                message,
-                code,
-                suggestions,
-            },
-        };
-    }
-    validationSuccess() {
-        return {
-            isValid: true,
-            errors: [],
-            suggestions: [],
-        };
-    }
-    validationFailure(type, message, suggestions = []) {
-        return {
-            isValid: false,
-            errors: [{ type, message, suggestions }],
-            suggestions,
-        };
-    }
-    isElement(value) {
-        return (value !== null &&
-            typeof value === 'object' &&
-            'nodeType' in value &&
-            value.nodeType === 1 &&
-            'tagName' in value &&
-            typeof value.tagName === 'string');
-    }
-    inferType(value) {
-        if (value === null)
-            return 'null';
-        if (value === undefined)
-            return 'undefined';
-        if (this.isElement(value))
-            return 'element';
-        if (Array.isArray(value))
-            return 'array';
-        if (isObject(value))
-            return 'object';
-        return typeof value;
-    }
-    inferEvaluationType(value) {
-        if (value === undefined)
-            return 'Undefined';
-        if (value === null)
-            return 'Null';
-        if (isString(value))
-            return 'String';
-        if (isNumber(value))
-            return 'Number';
-        if (isBoolean(value))
-            return 'Boolean';
-        if (Array.isArray(value))
-            return 'Array';
-        if (this.isElement(value))
-            return 'Element';
-        return 'Object';
-    }
-    normalizeCollection(collection) {
-        if (Array.isArray(collection))
-            return collection;
-        if (collection instanceof NodeList)
-            return Array.from(collection);
-        if (isString(collection))
-            return collection.split('');
-        if (collection == null)
-            return [];
-        if (isObject(collection) && Symbol.iterator in collection) {
-            return Array.from(collection);
-        }
-        return [];
-    }
-    toNumber(value) {
-        if (isNumber(value) && Number.isFinite(value))
-            return value;
-        if (isString(value)) {
-            const num = Number(value);
-            return Number.isFinite(num) ? num : null;
-        }
-        if (isBoolean(value))
-            return value ? 1 : 0;
-        return null;
-    }
-}
-
-const LOCAL_READ_HOOKS = new Set();
-function report(kind, err) {
-    if (typeof console !== 'undefined') {
-        console.error(`[hyperfixi] ${kind} threw:`, err);
-    }
-}
-function notifyLocalRead(name, context) {
-    if (LOCAL_READ_HOOKS.size === 0)
-        return;
-    for (const hook of LOCAL_READ_HOOKS) {
-        try {
-            hook(name, context);
-        }
-        catch (err) {
-            report('localReadHook', err);
-        }
-    }
-}
-
-const StringLiteralInputSchema = v
-    .object({
-    value: v.string().describe('String literal value'),
-})
-    .strict();
-const NumberLiteralInputSchema = v
-    .object({
-    value: v.number().describe('Number literal value'),
-})
-    .strict();
-const BooleanLiteralInputSchema = v
-    .object({
-    value: v.boolean().describe('Boolean literal value'),
-})
-    .strict();
-const BinaryOperationInputSchema = v
-    .object({
-    left: v.unknown().describe('Left operand'),
-    right: v.unknown().describe('Right operand'),
-})
-    .strict();
-class StringLiteralExpression extends BaseExpressionImpl {
-    constructor() {
-        super(...arguments);
-        this.name = 'stringLiteral';
-        this.category = 'Special';
-        this.syntax = '"string" or \'string\'';
-        this.description = 'String literals with template interpolation support';
-        this.outputType = 'String';
-        this.inputSchema = StringLiteralInputSchema;
-        this.metadata = {
-            category: 'Special',
-            complexity: 'simple',
-        };
-    }
-    async evaluate(context, input) {
-        const startTime = Date.now();
-        try {
-            const validation = this.validate(input);
-            if (!validation.isValid) {
-                const result = this.failure('ValidationError', 'validation-error', validation.errors.map(e => e.message).join(', '), 'VALIDATION_FAILED', validation.suggestions);
-                this.trackSimple(context, startTime, false);
-                return result;
-            }
-            let resultValue = input.value;
-            if (resultValue.includes('${') || resultValue.includes('$')) {
-                resultValue = this.interpolateString(resultValue, context);
-            }
-            const result = this.success(resultValue, 'string');
-            this.trackSimple(context, startTime, true, resultValue);
-            return result;
-        }
-        catch (error) {
-            this.trackSimple(context, startTime, false);
-            return this.failure('StringEvaluationError', 'runtime-error', `String literal evaluation failed: ${error instanceof Error ? error.message : String(error)}`, 'STRING_EVALUATION_FAILED');
-        }
-    }
-    validate(input) {
-        try {
-            const parsed = this.inputSchema.safeParse(input);
-            if (!parsed.success) {
-                return this.validationFailure('type-mismatch', parsed.error?.errors.map(err => err.message).join(', ') || 'Invalid string literal input', ['Provide a value parameter', 'Ensure value is a string']);
-            }
-            return this.validationSuccess();
-        }
-        catch (_error) {
-            return this.validationFailure('runtime-error', 'Validation failed with exception', [
-                'Check input structure and types',
-            ]);
-        }
-    }
-    interpolateString(template, context) {
-        let result = template.replace(/\$\{([^}]+)\}/g, (_match, expression) => {
-            try {
-                const value = this.resolveExpression(expression.trim(), context);
-                return value !== undefined ? String(value) : '';
-            }
-            catch (_error) {
-                return '';
-            }
-        });
-        result = result.replace(/\$([a-zA-Z_$][a-zA-Z0-9_.$]*)/g, (_match, varName) => {
-            try {
-                const value = this.resolveVariable(varName, context);
-                return value !== undefined ? String(value) : '';
-            }
-            catch (_error) {
-                return '';
-            }
-        });
-        return result;
-    }
-    resolveExpression(expression, context) {
-        if (expression.includes('.')) {
-            const parts = expression.split('.');
-            let value = this.resolveVariable(parts[0], context);
-            for (let i = 1; i < parts.length && value != null; i++) {
-                value = value[parts[i]];
-            }
-            return value;
-        }
-        return this.resolveVariable(expression, context);
-    }
-    resolveVariable(varName, context) {
-        if (varName === 'me' && context.me)
-            return context.me;
-        if (varName === 'you' && context.you)
-            return context.you;
-        if (varName === 'it' && context.it)
-            return context.it;
-        if (varName === 'result' && context.result)
-            return context.result;
-        if (context.locals?.has(varName)) {
-            notifyLocalRead(varName, context);
-            return context.locals.get(varName);
-        }
-        if (context.globals?.has(varName)) {
-            return context.globals.get(varName);
-        }
-        return undefined;
-    }
-}
-class NumberLiteralExpression extends BaseExpressionImpl {
-    constructor() {
-        super(...arguments);
-        this.name = 'numberLiteral';
-        this.category = 'Special';
-        this.syntax = '123 or 3.14';
-        this.description = 'Numeric literal with validation';
-        this.inputSchema = NumberLiteralInputSchema;
-        this.outputType = 'Number';
-        this.metadata = {
-            category: 'Special',
-            complexity: 'simple',
-        };
-    }
-    async evaluate(context, input) {
-        const startTime = Date.now();
-        try {
-            const validation = this.validate(input);
-            if (!validation.isValid) {
-                this.trackSimple(context, startTime, false);
-                return this.failure('ValidationError', 'validation-error', validation.errors.map(e => e.message).join(', '), 'VALIDATION_FAILED', validation.suggestions);
-            }
-            if (!Number.isFinite(input.value)) {
-                this.trackSimple(context, startTime, false);
-                return this.failure('NumberValidationError', 'invalid-argument', 'Number literal must be finite', 'NUMBER_NOT_FINITE');
-            }
-            this.trackSimple(context, startTime, true, input.value);
-            return this.success(input.value, 'number');
-        }
-        catch (error) {
-            this.trackSimple(context, startTime, false);
-            return this.failure('NumberEvaluationError', 'runtime-error', `Number literal evaluation failed: ${error instanceof Error ? error.message : String(error)}`, 'NUMBER_EVALUATION_FAILED');
-        }
-    }
-    validate(input) {
-        try {
-            const parsed = this.inputSchema.safeParse(input);
-            if (!parsed.success) {
-                return this.validationFailure('type-mismatch', parsed.error?.errors.map(err => err.message).join(', ') || 'Invalid number literal input', ['Provide a value parameter', 'Ensure value is a number']);
-            }
-            if (!Number.isFinite(parsed.data.value)) {
-                return this.validationFailure('invalid-argument', 'Number literal value must be finite', [
-                    'Use finite numbers only',
-                    'Avoid Infinity and NaN values',
-                ]);
-            }
-            return this.validationSuccess();
-        }
-        catch (_error) {
-            return this.validationFailure('runtime-error', 'Validation failed with exception', [
-                'Check input structure and types',
-            ]);
-        }
-    }
-}
-class BooleanLiteralExpression extends BaseExpressionImpl {
-    constructor() {
-        super(...arguments);
-        this.name = 'booleanLiteral';
-        this.category = 'Special';
-        this.syntax = 'true or false';
-        this.description = 'Boolean literal values';
-        this.inputSchema = BooleanLiteralInputSchema;
-        this.outputType = 'Boolean';
-        this.metadata = {
-            category: 'Special',
-            complexity: 'simple',
-        };
-    }
-    async evaluate(context, input) {
-        const startTime = Date.now();
-        try {
-            const validation = this.validate(input);
-            if (!validation.isValid) {
-                this.trackSimple(context, startTime, false);
-                return this.failure('ValidationError', 'validation-error', validation.errors.map(e => e.message).join(', '), 'VALIDATION_FAILED', validation.suggestions);
-            }
-            this.trackSimple(context, startTime, true, input.value);
-            return this.success(input.value, 'boolean');
-        }
-        catch (error) {
-            this.trackSimple(context, startTime, false);
-            return this.failure('BooleanEvaluationError', 'runtime-error', `Boolean literal evaluation failed: ${error instanceof Error ? error.message : String(error)}`, 'BOOLEAN_EVALUATION_FAILED');
-        }
-    }
-    validate(input) {
-        try {
-            const parsed = this.inputSchema.safeParse(input);
-            if (!parsed.success) {
-                return this.validationFailure('type-mismatch', parsed.error?.errors.map(err => err.message).join(', ') ||
-                    'Invalid boolean literal input', ['Provide a value parameter', 'Ensure value is a boolean']);
-            }
-            return this.validationSuccess();
-        }
-        catch (_error) {
-            return this.validationFailure('runtime-error', 'Validation failed with exception', [
-                'Check input structure and types',
-            ]);
-        }
-    }
-}
-class StringConcatenationExpression extends BaseExpressionImpl {
-    constructor() {
-        super(...arguments);
-        this.name = 'stringConcatenation';
-        this.category = 'Special';
-        this.syntax = 'left + right (string concatenation)';
-        this.description = 'Concatenation of two values into a string';
-        this.inputSchema = BinaryOperationInputSchema;
-        this.outputType = 'String';
-        this.metadata = {
-            category: 'Special',
-            complexity: 'simple',
-        };
-    }
-    async evaluate(context, input) {
-        const startTime = Date.now();
-        try {
-            const validation = this.validate(input);
-            if (!validation.isValid) {
-                this.trackSimple(context, startTime, false);
-                return this.failure('ValidationError', 'validation-error', validation.errors[0]?.message || 'Invalid input', 'STRING_CONCATENATION_VALIDATION_FAILED', validation.suggestions);
-            }
-            const leftStr = this.convertToString(input.left);
-            const rightStr = this.convertToString(input.right);
-            const result = leftStr + rightStr;
-            this.trackSimple(context, startTime, true, result);
-            return this.success(result, 'string');
-        }
-        catch (error) {
-            this.trackSimple(context, startTime, false);
-            return this.failure('StringConcatenationError', 'runtime-error', error instanceof Error ? error.message : 'String concatenation failed', 'STRING_CONCATENATION_ERROR', ['Check that operands can be converted to strings']);
-        }
-    }
-    validate(input) {
-        const parsed = BinaryOperationInputSchema.safeParse(input);
-        if (!parsed.success) {
-            return this.validationFailure('type-mismatch', parsed.error?.errors.map(err => err.message).join(', ') ||
-                'Invalid string concatenation input', ['Provide left and right operands for concatenation']);
-        }
-        return this.validationSuccess();
-    }
-    convertToString(value) {
-        if (value === null)
-            return 'null';
-        if (value === undefined)
-            return 'undefined';
-        if (isString(value))
-            return value;
-        if (isNumber(value))
-            return value.toString();
-        if (isBoolean(value))
-            return value.toString();
-        if (value instanceof Date)
-            return value.toString();
-        try {
-            return String(value);
-        }
-        catch {
-            return '[object Object]';
-        }
-    }
-}
-function createStringLiteralExpression() {
-    return new StringLiteralExpression();
-}
-function createNumberLiteralExpression() {
-    return new NumberLiteralExpression();
-}
-function createBooleanLiteralExpression() {
-    return new BooleanLiteralExpression();
-}
-function createStringConcatenationExpression() {
-    return new StringConcatenationExpression();
-}
-const specialExpressions = {
-    stringLiteral: createStringLiteralExpression(),
-    numberLiteral: createNumberLiteralExpression(),
-    booleanLiteral: createBooleanLiteralExpression(),
-    stringConcatenation: createStringConcatenationExpression(),
-};
-
-class AdditionExpression {
-    constructor() {
-        this.name = 'addition';
-        this.category = 'Special';
-        this.syntax = 'left + right';
-        this.outputType = 'number';
-        this.metadata = { category: 'Special', complexity: 'simple' };
-    }
-    async evaluate(_context, input) {
-        const validation = this.validate(input);
-        if (!validation.isValid) {
-            return { success: false, errors: validation.errors, suggestions: validation.suggestions };
-        }
-        try {
-            const { left, right } = input;
-            const leftNum = toNumber(left, 'left operand');
-            const rightNum = toNumber(right, 'right operand');
-            const result = ensureFinite(leftNum + rightNum, 'addition');
-            return { success: true, value: result, type: 'number' };
-        }
-        catch (error) {
-            return {
-                success: false,
-                errors: [
-                    createError('runtime-error', `Addition failed: ${error instanceof Error ? error.message : String(error)}`),
-                ],
-                suggestions: ['Ensure both operands are numeric'],
-            };
-        }
-    }
-    validate(input) {
-        const result = validateBinaryInput(input);
-        if (!result.isValid)
-            return result;
-        const { left, right } = input;
-        if (!canBeNumeric(left)) {
-            return {
-                isValid: false,
-                errors: [
-                    createError('type-mismatch', `Left operand cannot be converted to number: ${String(left)}`),
-                ],
-                suggestions: ['Provide a numeric value for left operand'],
-            };
-        }
-        if (!canBeNumeric(right)) {
-            return {
-                isValid: false,
-                errors: [
-                    createError('type-mismatch', `Right operand cannot be converted to number: ${String(right)}`),
-                ],
-                suggestions: ['Provide a numeric value for right operand'],
-            };
-        }
-        return { isValid: true, errors: [], suggestions: [] };
-    }
-}
-class SubtractionExpression {
-    constructor() {
-        this.name = 'subtraction';
-        this.category = 'Special';
-        this.syntax = 'left - right';
-        this.outputType = 'number';
-        this.metadata = { category: 'Special', complexity: 'simple' };
-    }
-    async evaluate(_context, input) {
-        const validation = this.validate(input);
-        if (!validation.isValid) {
-            return { success: false, errors: validation.errors, suggestions: validation.suggestions };
-        }
-        try {
-            const { left, right } = input;
-            const leftNum = toNumber(left, 'left operand');
-            const rightNum = toNumber(right, 'right operand');
-            const result = ensureFinite(leftNum - rightNum, 'subtraction');
-            return { success: true, value: result, type: 'number' };
-        }
-        catch (error) {
-            return {
-                success: false,
-                errors: [
-                    createError('runtime-error', `Subtraction failed: ${error instanceof Error ? error.message : String(error)}`),
-                ],
-                suggestions: ['Ensure both operands are numeric'],
-            };
-        }
-    }
-    validate(input) {
-        const addExpr = new AdditionExpression();
-        return addExpr.validate(input);
-    }
-}
-class MultiplicationExpression {
-    constructor() {
-        this.name = 'multiplication';
-        this.category = 'Special';
-        this.syntax = 'left * right';
-        this.outputType = 'number';
-        this.metadata = { category: 'Special', complexity: 'simple' };
-    }
-    async evaluate(_context, input) {
-        const validation = this.validate(input);
-        if (!validation.isValid) {
-            return { success: false, errors: validation.errors, suggestions: validation.suggestions };
-        }
-        try {
-            const { left, right } = input;
-            const leftNum = toNumber(left, 'left operand');
-            const rightNum = toNumber(right, 'right operand');
-            const result = ensureFinite(leftNum * rightNum, 'multiplication');
-            return { success: true, value: result, type: 'number' };
-        }
-        catch (error) {
-            return {
-                success: false,
-                errors: [
-                    createError('runtime-error', `Multiplication failed: ${error instanceof Error ? error.message : String(error)}`),
-                ],
-                suggestions: ['Ensure both operands are numeric'],
-            };
-        }
-    }
-    validate(input) {
-        const addExpr = new AdditionExpression();
-        return addExpr.validate(input);
-    }
-}
-class DivisionExpression {
-    constructor() {
-        this.name = 'division';
-        this.category = 'Special';
-        this.syntax = 'left / right';
-        this.outputType = 'number';
-        this.metadata = { category: 'Special', complexity: 'simple' };
-    }
-    async evaluate(_context, input) {
-        const validation = this.validate(input);
-        if (!validation.isValid) {
-            return { success: false, errors: validation.errors, suggestions: validation.suggestions };
-        }
-        try {
-            const { left, right } = input;
-            const leftNum = toNumber(left, 'left operand');
-            const rightNum = toNumber(right, 'right operand');
-            const result = safeDivide(leftNum, rightNum, true);
-            return { success: true, value: result, type: 'number' };
-        }
-        catch (error) {
-            return {
-                success: false,
-                errors: [
-                    createError('runtime-error', `Division failed: ${error instanceof Error ? error.message : String(error)}`),
-                ],
-                suggestions: ['Ensure both operands are numeric'],
-            };
-        }
-    }
-    validate(input) {
-        const addExpr = new AdditionExpression();
-        return addExpr.validate(input);
-    }
-}
-class ModuloExpression {
-    constructor() {
-        this.name = 'modulo';
-        this.category = 'Special';
-        this.syntax = 'left mod right';
-        this.outputType = 'number';
-        this.metadata = { category: 'Special', complexity: 'simple' };
-    }
-    async evaluate(_context, input) {
-        const validation = this.validate(input);
-        if (!validation.isValid) {
-            return { success: false, errors: validation.errors, suggestions: validation.suggestions };
-        }
-        try {
-            const { left, right } = input;
-            const leftNum = toNumber(left, 'left operand');
-            const rightNum = toNumber(right, 'right operand');
-            const result = safeModulo(leftNum, rightNum);
-            return { success: true, value: result, type: 'number' };
-        }
-        catch (error) {
-            return {
-                success: false,
-                errors: [
-                    createError('runtime-error', `Modulo failed: ${error instanceof Error ? error.message : String(error)}`),
-                ],
-                suggestions: ['Ensure both operands are numeric and divisor is not zero'],
-            };
-        }
-    }
-    validate(input) {
-        const addExpr = new AdditionExpression();
-        return addExpr.validate(input);
-    }
-}
-class PowerExpression {
-    constructor() {
-        this.name = 'power';
-        this.category = 'Special';
-        this.syntax = 'left ** right';
-        this.outputType = 'number';
-        this.metadata = { category: 'Special', complexity: 'simple' };
-    }
-    async evaluate(_context, input) {
-        const validation = this.validate(input);
-        if (!validation.isValid) {
-            return { success: false, errors: validation.errors, suggestions: validation.suggestions };
-        }
-        try {
-            const { left, right } = input;
-            const leftNum = toNumber(left, 'left operand');
-            const rightNum = toNumber(right, 'right operand');
-            const result = ensureFinite(Math.pow(leftNum, rightNum), 'power');
-            return { success: true, value: result, type: 'number' };
-        }
-        catch (error) {
-            return {
-                success: false,
-                errors: [
-                    createError('runtime-error', `Power failed: ${error instanceof Error ? error.message : String(error)}`),
-                ],
-                suggestions: ['Ensure both operands are numeric'],
-            };
-        }
-    }
-    validate(input) {
-        const addExpr = new AdditionExpression();
-        return addExpr.validate(input);
-    }
-}
-function createAdditionExpression() {
-    return new AdditionExpression();
-}
-function createSubtractionExpression() {
-    return new SubtractionExpression();
-}
-function createMultiplicationExpression() {
-    return new MultiplicationExpression();
-}
-function createDivisionExpression() {
-    return new DivisionExpression();
-}
-function createModuloExpression() {
-    return new ModuloExpression();
-}
-function createPowerExpression() {
-    return new PowerExpression();
-}
-const mathematicalExpressions = {
-    addition: createAdditionExpression(),
-    subtraction: createSubtractionExpression(),
-    multiplication: createMultiplicationExpression(),
-    division: createDivisionExpression(),
-    modulo: createModuloExpression(),
-    power: createPowerExpression(),
-};
-
-function createCoreRegistry() {
-    return createExpressionRegistry(referencesExpressions, logicalExpressions, specialExpressions, mathematicalExpressions);
-}
-
-const conversionConfig = {
-    conversions: { dynamicResolvers: [] },
-};
-const defaultConversions = {
-    Array: (value) => {
-        if (Array.isArray(value))
-            return value;
-        if (value instanceof NodeList)
-            return Array.from(value);
-        if (value == null)
-            return [];
-        return [value];
-    },
-    String: (value) => {
-        if (value == null)
-            return '';
-        if (isString(value))
-            return value;
-        if (isObject(value))
-            return JSON.stringify(value);
-        return String(value);
-    },
-    Boolean: (value) => {
-        if (isBoolean(value))
-            return value;
-        if (value == null)
-            return false;
-        if (isString(value)) {
-            const lowerValue = value.toLowerCase().trim();
-            if (lowerValue === 'false' || lowerValue === '0' || lowerValue === '')
-                return false;
-            return true;
-        }
-        if (isNumber(value)) {
-            return value !== 0 && !isNaN(value);
-        }
-        return Boolean(value);
-    },
-    Number: (value) => {
-        if (isNumber(value))
-            return value;
-        if (value == null)
-            return 0;
-        const num = Number(value);
-        return isNaN(num) ? 0 : num;
-    },
-    Math: (value) => {
-        if (isNumber(value))
-            return value;
-        if (value == null)
-            return 0;
-        const expression = String(value).trim();
-        if (!expression)
-            return 0;
-        try {
-            return evaluateMathExpression(expression);
-        }
-        catch (error) {
-            console.warn('Math conversion failed:', error);
-            return 0;
-        }
-    },
-    Int: (value) => {
-        const num = defaultConversions.Number(value);
-        return Math.trunc(num);
-    },
-    Float: (value) => {
-        const num = defaultConversions.Number(value);
-        return parseFloat(num.toString());
-    },
-    Date: (value) => {
-        if (value instanceof Date)
-            return value;
-        if (value == null)
-            return new Date(NaN);
-        if (isString(value) && /^\d{4}-\d{2}-\d{2}$/.test(value)) {
-            const [year, month, day] = value.split('-').map(Number);
-            return new Date(year, month - 1, day);
-        }
-        const date = new Date(value);
-        return date;
-    },
-    JSON: (value) => {
-        if (!isString(value))
-            return value;
-        try {
-            return JSON.parse(value);
-        }
-        catch {
-            return value;
-        }
-    },
-    JSONString: (value) => {
-        try {
-            return JSON.stringify(value);
-        }
-        catch {
-            return '{}';
-        }
-    },
-    Object: (value) => {
-        if (isObject(value))
-            return value;
-        if (isString(value)) {
-            try {
-                return JSON.parse(value);
-            }
-            catch (error) {
-                return {};
-            }
-        }
-        return {};
-    },
-    Fragment: (value) => {
-        const frag = document.createDocumentFragment();
-        const items = Array.isArray(value) || value instanceof NodeList
-            ? Array.from(value)
-            : [value];
-        for (const item of items) {
-            if (item instanceof Node) {
-                frag.append(item);
-            }
-            else {
-                const template = document.createElement('template');
-                template.innerHTML = item == null ? '' : String(item);
-                frag.append(template.content);
-            }
-        }
-        return frag;
-    },
-    HTML: (value) => {
-        if (isString(value))
-            return value;
-        if (value instanceof NodeList) {
-            return Array.from(value)
-                .map(node => (node instanceof Element ? node.outerHTML : node.textContent || ''))
-                .join('');
-        }
-        if (Array.isArray(value)) {
-            return value
-                .map(item => (item instanceof Element ? item.outerHTML : defaultConversions.String(item)))
-                .join('');
-        }
-        if (value instanceof Element) {
-            return value.outerHTML;
-        }
-        return defaultConversions.String(value);
-    },
-    Values: (value, _context) => {
-        if (value instanceof HTMLFormElement) {
-            return getFormValuesProcessed(value);
-        }
-        if (value instanceof HTMLElement) {
-            const inputs = value.querySelectorAll('input, select, textarea');
-            const values = {};
-            inputs.forEach((input) => {
-                const htmlInput = input;
-                if (htmlInput.name) {
-                    values[htmlInput.name] = getInputValue(htmlInput);
-                }
-            });
-            return values;
-        }
-        return {};
-    },
-    FormEncoded: (value, context) => {
-        const values = value instanceof HTMLElement ? defaultConversions.Values(value, context) : value;
-        if (!isObject(values))
-            return '';
-        const params = new URLSearchParams();
-        for (const [k, v] of Object.entries(values)) {
-            if (v === undefined || v === null)
-                continue;
-            if (Array.isArray(v)) {
-                for (const item of v)
-                    params.append(k, String(item));
-            }
-            else {
-                params.append(k, String(v));
-            }
-        }
-        return params.toString();
-    },
-    Set: (value) => new Set(value),
-    Map: (value) => new Map(Object.entries((value ?? {}))),
-    Keys: (value) => {
-        if (value instanceof Map)
-            return Array.from(value.keys());
-        return Object.keys((value ?? {}));
-    },
-    Entries: (value) => {
-        if (value instanceof Map)
-            return Array.from(value.entries());
-        return Object.entries((value ?? {}));
-    },
-    Reversed: (value) => Array.from(value).reverse(),
-    Unique: (value) => [...new Set(value)],
-    Flat: (value) => Array.from(value).flat(),
-    'Values:Form': (value, context) => {
-        const values = defaultConversions.Values(value, context);
-        return defaultConversions.FormEncoded(values, context);
-    },
-    'Values:JSON': (value, context) => {
-        const values = defaultConversions.Values(value, context);
-        return JSON.stringify(values);
-    },
-};
-function evaluateMathExpression(expression) {
-    expression = expression.replace(/\s/g, '');
-    if (!/^[0-9+\-*/().]+$/.test(expression)) {
-        throw new Error('Invalid characters in math expression');
-    }
-    try {
-        const result = new Function(`"use strict"; return (${expression})`)();
-        if (!isNumber(result) || !isFinite(result)) {
-            throw new Error('Expression did not evaluate to a finite number');
-        }
-        return result;
-    }
-    catch (error) {
-        throw new Error(`Math expression evaluation failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-function getFormValuesProcessed(form) {
-    const values = {};
-    const elements = form.querySelectorAll('input, select, textarea');
-    elements.forEach(element => {
-        const input = element;
-        if (input.name) {
-            const value = getInputValue(input);
-            if (value !== undefined) {
-                if (values[input.name] !== undefined) {
-                    if (!Array.isArray(values[input.name])) {
-                        values[input.name] = [values[input.name]];
-                    }
-                    values[input.name].push(value);
-                }
-                else {
-                    values[input.name] = value;
-                }
-            }
-        }
-    });
-    return values;
-}
-function getInputValue(input) {
-    if (input instanceof HTMLInputElement) {
-        switch (input.type) {
-            case 'checkbox':
-                return input.checked;
-            case 'radio':
-                return input.checked ? input.value : undefined;
-            case 'number':
-            case 'range':
-                return input.valueAsNumber;
-            case 'date':
-            case 'datetime-local':
-                return input.valueAsDate;
-            case 'file':
-                return input.files;
-            default:
-                return input.value;
-        }
-    }
-    if (input instanceof HTMLSelectElement) {
-        if (input.multiple) {
-            return Array.from(input.selectedOptions).map(option => option.value);
-        }
-        return input.value;
-    }
-    return input.value;
-}
-function parseFixedPrecision(type) {
-    const match = type.match(/^Fixed(?::(\d+))?$/);
-    if (match) {
-        return { precision: match[1] ? parseInt(match[1], 10) : 0 };
-    }
-    return {};
-}
-const TYPE_ALIASES = {
-    boolean: 'Boolean',
-    bool: 'Boolean',
-    string: 'String',
-    str: 'String',
-    number: 'Number',
-    num: 'Number',
-    int: 'Int',
-    integer: 'Int',
-    float: 'Float',
-    array: 'Array',
-    object: 'Object',
-    obj: 'Object',
-    date: 'Date',
-    json: 'JSON',
-    jsonstring: 'JSONString',
-    formencoded: 'FormEncoded',
-};
-function convertValue(value, type, context) {
-    if (typeof type !== 'string') {
-        throw new Error('Conversion type must be a string');
-    }
-    if (type.startsWith('Fixed')) {
-        const { precision } = parseFixedPrecision(type);
-        const num = defaultConversions.Number(value);
-        return num.toFixed(precision ?? 0);
-    }
-    if (value == null) {
-        return value;
-    }
-    let converter = defaultConversions[type];
-    if (converter) {
-        return converter(value, context);
-    }
-    const aliasedType = TYPE_ALIASES[type.toLowerCase()];
-    if (aliasedType) {
-        converter = defaultConversions[aliasedType];
-        if (converter) {
-            return converter(value, context);
-        }
-    }
-    const named = conversionConfig.conversions[type];
-    if (typeof named === 'function') {
-        return named(value, context);
-    }
-    for (const resolver of conversionConfig.conversions.dynamicResolvers) {
-        const resolved = resolver(type, value);
-        if (resolved !== undefined) {
-            return resolved;
-        }
-    }
-    console.warn(`Unknown conversion type: ${type}`);
-    return value;
-}
-const asExpression = {
-    name: 'as',
-    category: 'Conversion',
-    evaluatesTo: 'Any',
-    precedence: 20,
-    associativity: 'Left',
-    operators: ['as'],
-    async evaluate(context, ...args) {
-        const [value, type] = args;
-        return convertValue(value, type, context);
-    },
-    validate(args) {
-        return (validateArgCount(args, 2, 'as', 'value, type') ??
-            validateArgIsString(args, 1, 'as', 'conversion type'));
-    },
-};
-const isExpression = {
-    name: 'is',
-    category: 'Conversion',
-    evaluatesTo: 'Boolean',
-    precedence: 10,
-    associativity: 'Left',
-    operators: ['is a', 'is an'],
-    async evaluate(_context, ...args) {
-        const [value, type] = args;
-        if (!isString(type)) {
-            throw new Error('Type check requires a string type');
-        }
-        switch (type.toLowerCase()) {
-            case 'null':
-                return value === null;
-            case 'undefined':
-                return value === undefined;
-            case 'string':
-                return isString(value);
-            case 'number':
-                return isNumber(value) && !isNaN(value);
-            case 'boolean':
-                return isBoolean(value);
-            case 'object':
-                return isObject(value);
-            case 'array':
-                return Array.isArray(value);
-            case 'function':
-                return isFunction(value);
-            case 'date':
-                return value instanceof Date;
-            case 'element':
-                return value instanceof Element;
-            case 'node':
-                return value instanceof Node;
-            case 'nodelist':
-                return value instanceof NodeList;
-            case 'empty':
-                return (value == null ||
-                    value === '' ||
-                    (Array.isArray(value) && value.length === 0) ||
-                    (isObject(value) && Object.keys(value).length === 0));
-            default:
-                return value?.constructor?.name?.toLowerCase() === type.toLowerCase();
-        }
-    },
-    validate(args) {
-        return (validateArgCount(args, 2, 'is', 'value, type') ?? validateArgIsString(args, 1, 'is', 'type'));
-    },
-};
-const asyncExpression = {
-    name: 'async',
-    category: 'Conversion',
-    evaluatesTo: 'Any',
-    precedence: 25,
-    associativity: 'Right',
-    operators: ['async'],
-    async evaluate(_context, expression) {
-        return expression;
-    },
-    validate(args) {
-        return validateArgCount(args, 1, 'async', 'expression');
-    },
-};
-const conversionExpressions = {
-    as: asExpression,
-    is: isExpression,
-    async: asyncExpression,
-};
-
-const firstExpression = {
-    name: 'first',
-    category: 'Reference',
-    evaluatesTo: 'Any',
-    operators: ['first'],
-    async evaluate(context, collection) {
-        const target = collection !== undefined ? collection : context.it;
-        if (target == null) {
-            return null;
-        }
-        if (Array.isArray(target)) {
-            return target.length > 0 ? target[0] : null;
-        }
-        if (target instanceof NodeList || target instanceof HTMLCollection) {
-            return target.length > 0 ? target[0] : null;
-        }
-        if (target instanceof Element) {
-            return target.children.length > 0 ? target.children[0] : null;
-        }
-        if (isString(target)) {
-            const strTarget = target;
-            return strTarget.length > 0 ? strTarget[0] : null;
-        }
-        if (isObject(target) && 'length' in target && isNumber(target.length)) {
-            const objTarget = target;
-            return objTarget.length > 0 ? objTarget[0] : null;
-        }
-        return null;
-    },
-    validate(args) {
-        return validateMaxArgs(args, 1, 'first', 'collection');
-    },
-};
-const lastExpression = {
-    name: 'last',
-    category: 'Reference',
-    evaluatesTo: 'Any',
-    operators: ['last'],
-    async evaluate(context, collection) {
-        const target = collection !== undefined ? collection : context.it;
-        if (target == null) {
-            return null;
-        }
-        if (Array.isArray(target)) {
-            return target.length > 0 ? target[target.length - 1] : null;
-        }
-        if (target instanceof NodeList || target instanceof HTMLCollection) {
-            return target.length > 0 ? target[target.length - 1] : null;
-        }
-        if (target instanceof Element) {
-            const children = target.children;
-            return children.length > 0 ? children[children.length - 1] : null;
-        }
-        if (isString(target)) {
-            const strTarget = target;
-            return strTarget.length > 0 ? strTarget[strTarget.length - 1] : null;
-        }
-        if (isObject(target) && 'length' in target && isNumber(target.length)) {
-            const objTarget = target;
-            return objTarget.length > 0 ? objTarget[objTarget.length - 1] : null;
-        }
-        return null;
-    },
-    validate(args) {
-        return validateMaxArgs(args, 1, 'last', 'collection');
-    },
-};
-const atExpression = {
-    name: 'at',
-    category: 'Reference',
-    evaluatesTo: 'Any',
-    operators: ['at'],
-    async evaluate(context, ...args) {
-        const [index, collection] = args;
-        if (!isNumber(index)) {
-            throw new Error('Index must be a number');
-        }
-        const numIndex = index;
-        const target = collection !== undefined ? collection : context.it;
-        if (target == null) {
-            return null;
-        }
-        if (Array.isArray(target)) {
-            const actualIndex = numIndex < 0 ? target.length + numIndex : numIndex;
-            return actualIndex >= 0 && actualIndex < target.length ? target[actualIndex] : null;
-        }
-        if (target instanceof NodeList || target instanceof HTMLCollection) {
-            const actualIndex = numIndex < 0 ? target.length + numIndex : numIndex;
-            return actualIndex >= 0 && actualIndex < target.length ? target[actualIndex] : null;
-        }
-        if (target instanceof Element) {
-            const children = target.children;
-            const actualIndex = numIndex < 0 ? children.length + numIndex : numIndex;
-            return actualIndex >= 0 && actualIndex < children.length ? children[actualIndex] : null;
-        }
-        if (isString(target)) {
-            const strTarget = target;
-            const actualIndex = numIndex < 0 ? strTarget.length + numIndex : numIndex;
-            return actualIndex >= 0 && actualIndex < strTarget.length ? strTarget[actualIndex] : null;
-        }
-        if (isObject(target) && 'length' in target && isNumber(target.length)) {
-            const objTarget = target;
-            const actualIndex = numIndex < 0 ? objTarget.length + numIndex : numIndex;
-            return actualIndex >= 0 && actualIndex < objTarget.length ? objTarget[actualIndex] : null;
-        }
-        return null;
-    },
-    validate(args) {
-        return (validateArgRange(args, 1, 2, 'at', 'index, optional collection') ??
-            validateArgIsNumber(args, 0, 'at', 'index'));
-    },
-};
-const nextExpression = {
-    name: 'next',
-    category: 'Reference',
-    evaluatesTo: 'Element',
-    operators: ['next'],
-    async evaluate(context, ...args) {
-        const [selector, fromElement, options] = args;
-        const startElement = fromElement || context.me;
-        if (!startElement || !(startElement instanceof Element)) {
-            return null;
-        }
-        if (!selector) {
-            return startElement.nextElementSibling;
-        }
-        if (options) {
-            return scanRelative(startElement, selector, options, true);
-        }
-        return findNextElementInDOM(startElement, selector);
-    },
-    validate(args) {
-        const maxError = validateMaxArgs(args, 3, 'next', 'optional selector, optional fromElement, optional modifiers');
-        if (maxError)
-            return maxError;
-        if (args.length >= 1 && args[0] != null && typeof args[0] !== 'string') {
-            return 'selector must be a string';
-        }
-        if (args.length >= 2 && args[1] != null && !(args[1] instanceof Element)) {
-            return 'fromElement must be an Element';
-        }
-        return null;
-    },
-};
-const previousExpression = {
-    name: 'previous',
-    category: 'Reference',
-    evaluatesTo: 'Element',
-    operators: ['previous', 'prev'],
-    async evaluate(context, ...args) {
-        const [selector, fromElement, options] = args;
-        const startElement = fromElement || context.me;
-        if (!startElement || !(startElement instanceof Element)) {
-            return null;
-        }
-        if (!selector) {
-            return startElement.previousElementSibling;
-        }
-        if (options) {
-            return scanRelative(startElement, selector, options, false);
-        }
-        return findPreviousElementInDOM(startElement, selector);
-    },
-    validate(args) {
-        const maxError = validateMaxArgs(args, 3, 'previous', 'optional selector, optional fromElement, optional modifiers');
-        if (maxError)
-            return maxError;
-        if (args.length >= 1 && args[0] != null && typeof args[0] !== 'string') {
-            return 'selector must be a string';
-        }
-        if (args.length >= 2 && args[1] != null && !(args[1] instanceof Element)) {
-            return 'fromElement must be an Element';
-        }
-        return null;
-    },
-};
-function findNextElementInDOM(startElement, selector) {
-    let current = startElement.nextElementSibling;
-    while (current) {
-        if (current.matches(selector)) {
-            return current;
-        }
-        const found = current.querySelector(selector);
-        if (found) {
-            return found;
-        }
-        current = current.nextElementSibling;
-    }
-    const parent = startElement.parentElement;
-    if (parent && parent !== document.documentElement) {
-        return findNextElementInDOM(parent, selector);
-    }
-    return null;
-}
-function findPreviousElementInDOM(startElement, selector) {
-    let current = startElement.previousElementSibling;
-    while (current) {
-        const descendants = Array.from(current.querySelectorAll(selector)).reverse();
-        if (descendants.length > 0) {
-            return descendants[0];
-        }
-        if (current.matches(selector)) {
-            return current;
-        }
-        current = current.previousElementSibling;
-    }
-    const parent = startElement.parentElement;
-    if (parent && parent !== document.documentElement) {
-        return findPreviousElementInDOM(parent, selector);
-    }
-    return null;
-}
-const DOCUMENT_POSITION_PRECEDING = 2;
-const DOCUMENT_POSITION_FOLLOWING = 4;
-function scanForwardQuery(start, root, match, wrap) {
-    const results = root.querySelectorAll(match);
-    for (let i = 0; i < results.length; i++) {
-        const elt = results[i];
-        if (elt.compareDocumentPosition(start) === DOCUMENT_POSITION_PRECEDING) {
-            return elt;
-        }
-    }
-    return wrap ? results[0] : undefined;
-}
-function scanBackwardsQuery(start, root, match, wrap) {
-    const results = root.querySelectorAll(match);
-    for (let i = results.length - 1; i >= 0; i--) {
-        const elt = results[i];
-        if (elt.compareDocumentPosition(start) === DOCUMENT_POSITION_FOLLOWING) {
-            return elt;
-        }
-    }
-    return wrap ? results[results.length - 1] : undefined;
-}
-function scanForwardArray(start, arrayLike, match, wrap) {
-    const array = Array.from(arrayLike ?? []);
-    const matches = [];
-    for (const elt of array) {
-        if ((elt.matches && elt.matches(match)) || elt === start) {
-            matches.push(elt);
-        }
-    }
-    for (let i = 0; i < matches.length - 1; i++) {
-        if (matches[i] === start) {
-            return matches[i + 1];
-        }
-    }
-    if (wrap) {
-        const first = matches[0];
-        if (first && first.matches && first.matches(match)) {
-            return first;
-        }
-    }
-    return undefined;
-}
-function scanRelative(start, selector, options, forward) {
-    if (options.inSearch) {
-        if (options.inElt == null)
-            return undefined;
-        const array = forward
-            ? Array.from(options.inElt)
-            : Array.from(options.inElt).reverse();
-        return scanForwardArray(start, array, selector, !!options.wrapping);
-    }
-    const root = options.within ?? (typeof document !== 'undefined' ? document.body : null);
-    if (!root)
-        return undefined;
-    return forward
-        ? scanForwardQuery(start, root, selector, !!options.wrapping)
-        : scanBackwardsQuery(start, root, selector, !!options.wrapping);
-}
-const nextWithinExpression = {
-    name: 'nextWithin',
-    category: 'Reference',
-    evaluatesTo: 'Element',
-    operators: ['next within'],
-    async evaluate(context, ...args) {
-        const [selector, withinSelector, fromElement] = args;
-        const startElement = fromElement || context.me;
-        if (!startElement || !(startElement instanceof Element)) {
-            return null;
-        }
-        const container = startElement.closest(withinSelector);
-        if (!container) {
-            return null;
-        }
-        return findNextElementWithinContainer(startElement, selector, container);
-    },
-    validate(args) {
-        const rangeError = validateArgRange(args, 2, 3, 'nextWithin', 'selector, withinSelector, optional fromElement');
-        if (rangeError)
-            return rangeError;
-        if (typeof args[0] !== 'string') {
-            return 'selector must be a string';
-        }
-        if (typeof args[1] !== 'string') {
-            return 'withinSelector must be a string';
-        }
-        if (args.length >= 3 && args[2] != null && !(args[2] instanceof Element)) {
-            return 'fromElement must be an Element';
-        }
-        return null;
-    },
-};
-const previousWithinExpression = {
-    name: 'previousWithin',
-    category: 'Reference',
-    evaluatesTo: 'Element',
-    operators: ['previous within'],
-    async evaluate(context, ...args) {
-        const [selector, withinSelector, fromElement] = args;
-        const startElement = fromElement || context.me;
-        if (!startElement || !(startElement instanceof Element)) {
-            return null;
-        }
-        const container = startElement.closest(withinSelector);
-        if (!container) {
-            return null;
-        }
-        return findPreviousElementWithinContainer(startElement, selector, container);
-    },
-    validate(args) {
-        const rangeError = validateArgRange(args, 2, 3, 'previousWithin', 'selector, withinSelector, optional fromElement');
-        if (rangeError)
-            return rangeError;
-        if (typeof args[0] !== 'string') {
-            return 'selector must be a string';
-        }
-        if (typeof args[1] !== 'string') {
-            return 'withinSelector must be a string';
-        }
-        if (args.length >= 3 && args[2] != null && !(args[2] instanceof Element)) {
-            return 'fromElement must be an Element';
-        }
-        return null;
-    },
-};
-function findNextElementWithinContainer(startElement, selector, container) {
-    const matches = Array.from(container.querySelectorAll(selector));
-    const startPosition = getElementPosition(startElement);
-    for (const element of matches) {
-        const position = getElementPosition(element);
-        if (position > startPosition) {
-            return element;
-        }
-    }
-    return null;
-}
-function findPreviousElementWithinContainer(startElement, selector, container) {
-    const matches = Array.from(container.querySelectorAll(selector));
-    const startPosition = getElementPosition(startElement);
-    for (let i = matches.length - 1; i >= 0; i--) {
-        const element = matches[i];
-        const position = getElementPosition(element);
-        if (position < startPosition) {
-            return element;
-        }
-    }
-    return null;
-}
-function getElementPosition(element) {
-    let position = 0;
-    let current = element;
-    while (current && current.parentElement) {
-        const siblings = Array.from(current.parentElement.children);
-        position += siblings.indexOf(current);
-        current = current.parentElement;
-        position += 1000;
-    }
-    return position;
-}
-const positionalExpressions = {
-    first: firstExpression,
-    last: lastExpression,
-    at: atExpression,
-    next: nextExpression,
-    previous: previousExpression,
-    nextWithin: nextWithinExpression,
-    previousWithin: previousWithinExpression,
-};
-
-function createCommonRegistry() {
-    return createExpressionRegistry(referencesExpressions, logicalExpressions, specialExpressions, mathematicalExpressions, conversionExpressions, positionalExpressions);
-}
-
-function isInputElement(el) {
-    return (el !== null && typeof el === 'object' && 'tagName' in el && el.tagName === 'INPUT');
-}
-function isHTMLElement$1(el) {
-    return (el !== null &&
-        typeof el === 'object' &&
-        'nodeType' in el &&
-        el.nodeType === 1 &&
-        'style' in el);
-}
-function isOptionElement(el) {
-    return (el !== null &&
-        typeof el !== 'undefined' &&
-        typeof el === 'object' &&
-        'tagName' in el &&
-        el.tagName === 'OPTION');
-}
-
-function isHTMLElement(value) {
-    return value instanceof HTMLElement;
-}
-const BOOLEAN_ATTRIBUTES = new Set([
-    'disabled',
-    'readonly',
-    'required',
-    'checked',
-    'selected',
-    'hidden',
-    'open',
-    'autofocus',
-    'autoplay',
-    'controls',
-    'loop',
-    'muted',
-    'multiple',
-    'reversed',
-    'defer',
-    'async',
-    'novalidate',
-    'formnovalidate',
-    'ismap',
-]);
-function accessAttribute(element, attrName) {
-    if (BOOLEAN_ATTRIBUTES.has(attrName.toLowerCase())) {
-        return element.hasAttribute(attrName);
-    }
-    return element.getAttribute(attrName);
-}
-function hasAttribute(element, attrName) {
-    return element.hasAttribute(attrName);
-}
-const SPECIAL_DOM_PROPERTIES = {
-    id: el => el.id,
-    classname: el => el.className,
-    class: el => el.className,
-    tagname: el => el.tagName.toLowerCase(),
-    innertext: el => el.textContent?.trim(),
-    innerHTML: el => el.innerHTML,
-    outerhtml: el => el.outerHTML,
-    value: el => ('value' in el ? el.value : undefined),
-    checked: el => (isInputElement(el) ? el.checked : undefined),
-    disabled: el => ('disabled' in el ? el.disabled : undefined),
-    selected: el => (isOptionElement(el) ? el.selected : undefined),
-    tabindex: el => (isHTMLElement$1(el) ? el.tabIndex : undefined),
-    hidden: el => (isHTMLElement$1(el) ? el.hidden : undefined),
-    style: el => getComputedStyle(el),
-    children: el => Array.from(el.children),
-    parent: el => el.parentElement,
-    firstchild: el => el.firstElementChild,
-    lastchild: el => el.lastElementChild,
-    nextsibling: el => el.nextElementSibling,
-    previoussibling: el => el.previousElementSibling,
-    next: el => el.nextElementSibling,
-    previous: el => el.previousElementSibling,
-    values: el => collectFormValues(el),
-};
-function collectFormValues(el) {
-    if (el instanceof HTMLFormElement)
-        return new FormData(el);
-    const fd = new FormData();
-    el.querySelectorAll('input, select, textarea').forEach((input) => {
-        const name = input.getAttribute('name');
-        if (name && 'value' in input)
-            fd.append(name, input.value);
-    });
-    return fd;
-}
-function getElementStyleValue(element, styleProp) {
-    if (!isHTMLElement(element))
-        return undefined;
-    if (styleProp.startsWith('computed-')) {
-        return getComputedStyle(element).getPropertyValue(styleProp.slice('computed-'.length)) || '';
-    }
-    const camel = styleProp.replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
-    return element.style[camel];
-}
-function getElementProperty(element, property) {
-    if (property.startsWith('*')) {
-        return getElementStyleValue(element, property.slice(1));
-    }
-    if (property.startsWith('computed-')) {
-        const cssProperty = property.slice('computed-'.length);
-        if (isHTMLElement(element)) {
-            const computedStyle = getComputedStyle(element);
-            return computedStyle.getPropertyValue(cssProperty);
-        }
-        return undefined;
-    }
-    if (property.startsWith('@')) {
-        const attrName = property.slice(1);
-        return accessAttribute(element, attrName);
-    }
-    const specialHandler = SPECIAL_DOM_PROPERTIES[property.toLowerCase()];
-    if (specialHandler) {
-        return specialHandler(element);
-    }
-    if (hasAttribute(element, property)) {
-        return accessAttribute(element, property);
-    }
-    const value = element[property];
-    if (isFunction(value)) {
-        return value.bind(element);
-    }
-    return value;
-}
-
-const UNSAFE_PROPS = new Set(['__proto__', 'constructor', 'prototype']);
-function readPossessiveValue(element, property) {
-    if (element instanceof Element) {
-        return getElementProperty(element, property);
-    }
-    if (isObject(element)) {
-        if (UNSAFE_PROPS.has(property))
-            return undefined;
-        return element[property];
-    }
-    return element[property];
-}
-function isMappableCollection(v) {
-    let items;
-    if (Array.isArray(v)) {
-        items = v;
-    }
-    else if ((typeof NodeList !== 'undefined' && v instanceof NodeList) ||
-        (typeof HTMLCollection !== 'undefined' && v instanceof HTMLCollection)) {
-        items = Array.from(v);
-    }
-    else {
-        return false;
-    }
-    if (items.length === 0)
-        return false;
-    return items.every(item => item instanceof Element ||
-        (item != null &&
-            typeof item === 'object' &&
-            item.constructor !== Object &&
-            !Array.isArray(item)));
-}
-const possessiveExpression = {
-    name: 'possessive',
-    category: 'Reference',
-    evaluatesTo: 'Any',
-    operators: ["'s", 's'],
-    async evaluate(_context, ...args) {
-        const [element, property] = args;
-        if (element == null) {
-            return undefined;
-        }
-        if (typeof property !== 'string') {
-            throw new Error('Property name must be a string');
-        }
-        if (isMappableCollection(element) && !(property in element)) {
-            return Array.from(element, item => readPossessiveValue(item, property));
-        }
-        return readPossessiveValue(element, property);
-    },
-    validate(args) {
-        return (validateArgCount(args, 2, 'possessive', 'element, property') ??
-            validateArgIsString(args, 1, 'possessive', 'property name'));
-    },
-};
-const myExpression = {
-    name: 'my',
-    category: 'Reference',
-    evaluatesTo: 'Any',
-    operators: ['my'],
-    async evaluate(context, ...args) {
-        const [property] = args;
-        if (!context.me) {
-            return undefined;
-        }
-        if (typeof property !== 'string') {
-            throw new Error('Property name must be a string');
-        }
-        if (context.me instanceof Element) {
-            return getElementProperty(context.me, property);
-        }
-        if (isObject(context.me)) {
-            if (UNSAFE_PROPS.has(property))
-                return undefined;
-            return context.me[property];
-        }
-        return context.me[property];
-    },
-    validate(args) {
-        return validateSingleStringArg(args, 'my', 'property');
-    },
-};
-const itsExpression = {
-    name: 'its',
-    category: 'Reference',
-    evaluatesTo: 'Any',
-    operators: ['its'],
-    async evaluate(context, ...args) {
-        const [property] = args;
-        if (context.it == null) {
-            return undefined;
-        }
-        if (typeof property !== 'string') {
-            throw new Error('Property name must be a string');
-        }
-        const target = context.it;
-        if (target instanceof Element) {
-            return getElementProperty(target, property);
-        }
-        if (isObject(target)) {
-            if (UNSAFE_PROPS.has(property))
-                return undefined;
-            return target[property];
-        }
-        return target[property];
-    },
-    validate(args) {
-        return validateSingleStringArg(args, 'its', 'property');
-    },
-};
-const yourExpression = {
-    name: 'your',
-    category: 'Reference',
-    evaluatesTo: 'Any',
-    operators: ['your'],
-    async evaluate(context, ...args) {
-        const [property] = args;
-        if (!context.you) {
-            return undefined;
-        }
-        if (typeof property !== 'string') {
-            throw new Error('Property name must be a string');
-        }
-        if (context.you instanceof Element) {
-            return getElementProperty(context.you, property);
-        }
-        if (isObject(context.you)) {
-            if (UNSAFE_PROPS.has(property))
-                return undefined;
-            return context.you[property];
-        }
-        return context.you[property];
-    },
-    validate(args) {
-        return validateSingleStringArg(args, 'your', 'property');
-    },
-};
-const ofExpression = {
-    name: 'of',
-    category: 'Reference',
-    evaluatesTo: 'Any',
-    operators: ['of'],
-    async evaluate(_context, ...args) {
-        const [property, object] = args;
-        if (object == null) {
-            return undefined;
-        }
-        if (typeof property !== 'string') {
-            throw new Error('Property name must be a string');
-        }
-        if (object instanceof Element) {
-            return getElementProperty(object, property);
-        }
-        if (isObject(object)) {
-            if (UNSAFE_PROPS.has(property))
-                return undefined;
-            return object[property];
-        }
-        return object[property];
-    },
-    validate(args) {
-        return (validateArgCount(args, 2, 'of', 'property, object') ??
-            validateArgIsString(args, 0, 'of', 'property name'));
-    },
-};
-const attributeExpression = {
-    name: 'attribute',
-    category: 'Reference',
-    evaluatesTo: 'String',
-    operators: ['@'],
-    async evaluate(context, ...args) {
-        const [attributeName, element] = args;
-        if (typeof attributeName !== 'string') {
-            throw new Error('Attribute name must be a string');
-        }
-        const target = element || context.me;
-        if (!target || !(target instanceof Element)) {
-            return null;
-        }
-        return target.getAttribute(attributeName);
-    },
-    validate(args) {
-        return (validateArgRange(args, 1, 2, 'attribute', 'attributeName, optional element') ??
-            validateArgIsString(args, 0, 'attribute', 'attribute name') ??
-            (args.length >= 2 && args[1] != null && !(args[1] instanceof Element)
-                ? 'attribute element must be an Element'
-                : null));
-    },
-};
-const attributeWithValueExpression = {
-    name: 'attributeWithValue',
-    category: 'Reference',
-    evaluatesTo: 'Boolean',
-    operators: ['@='],
-    async evaluate(context, ...args) {
-        const [attributeName, expectedValue, element] = args;
-        if (typeof attributeName !== 'string') {
-            throw new Error('Attribute name must be a string');
-        }
-        if (typeof expectedValue !== 'string') {
-            throw new Error('Expected value must be a string');
-        }
-        const target = element || context.me;
-        if (!target || !(target instanceof Element)) {
-            return false;
-        }
-        const actualValue = target.getAttribute(attributeName);
-        return actualValue === expectedValue;
-    },
-    validate(args) {
-        return (validateArgRange(args, 2, 3, 'attributeWithValue', 'attributeName, expectedValue, optional element') ??
-            validateArgIsString(args, 0, 'attributeWithValue', 'attribute name') ??
-            validateArgIsString(args, 1, 'attributeWithValue', 'expected value') ??
-            (args.length >= 3 && args[2] != null && !(args[2] instanceof Element)
-                ? 'attributeWithValue element must be an Element'
-                : null));
-    },
-};
-const classReferenceExpression = {
-    name: 'classReference',
-    category: 'Reference',
-    evaluatesTo: 'Array',
-    operators: ['.'],
-    async evaluate(_context, ...args) {
-        const [className] = args;
-        if (typeof className !== 'string') {
-            throw new Error('Class name must be a string');
-        }
-        const cleanClassName = className.startsWith('.') ? className.slice(1) : className;
-        const elements = document.getElementsByClassName(cleanClassName);
-        return Array.from(elements);
-    },
-    validate(args) {
-        return validateSingleStringArg(args, 'classReference', 'className');
-    },
-};
-const idReferenceExpression = {
-    name: 'idReference',
-    category: 'Reference',
-    evaluatesTo: 'Element',
-    operators: ['#'],
-    async evaluate(_context, ...args) {
-        const [idValue] = args;
-        if (typeof idValue !== 'string') {
-            throw new Error('ID value must be a string');
-        }
-        const cleanId = idValue.startsWith('#') ? idValue.slice(1) : idValue;
-        return document.getElementById(cleanId);
-    },
-    validate(args) {
-        return validateSingleStringArg(args, 'idReference', 'idValue');
-    },
-};
-const propertiesExpressions = {
-    possessive: possessiveExpression,
-    my: myExpression,
-    its: itsExpression,
-    your: yourExpression,
-    of: ofExpression,
-    attribute: attributeExpression,
-    attributeWithValue: attributeWithValueExpression,
-    classReference: classReferenceExpression,
-    idReference: idReferenceExpression,
-};
-
-function createFullRegistry() {
-    return createExpressionRegistry(referencesExpressions, logicalExpressions, specialExpressions, mathematicalExpressions, conversionExpressions, positionalExpressions, propertiesExpressions);
-}
-
-function createFullExpressionRegistry() {
-    return createExpressionRegistry(referencesExpressions, logicalExpressions, conversionExpressions, positionalExpressions, propertiesExpressions, specialExpressions, mathematicalExpressions);
-}
-
-exports.conversion = conversionExpressions;
-exports.conversionExpressions = conversionExpressions;
-exports.createCommonRegistry = createCommonRegistry;
-exports.createCoreRegistry = createCoreRegistry;
-exports.createExpressionRegistry = createExpressionRegistry;
-exports.createFullExpressionRegistry = createFullExpressionRegistry;
-exports.createFullRegistry = createFullRegistry;
-exports.logical = logicalExpressions;
-exports.logicalExpressions = logicalExpressions;
-exports.mathematical = mathematicalExpressions;
-exports.positional = positionalExpressions;
-exports.positionalExpressions = positionalExpressions;
-exports.properties = propertiesExpressions;
-exports.propertiesExpressions = propertiesExpressions;
-exports.references = referencesExpressions;
-exports.referencesExpressions = referencesExpressions;
-exports.special = specialExpressions;
-exports.specialExpressions = specialExpressions;
-//# sourceMappingURL=index.cjs.map