@hyperfixi/core 3.3.0 → 4.0.1

package/dist/ast-utils/index.cjs

@@ -2189,819 +2189,88 @@ function minifyAST(ast) {
     return normalizeVisitResult(visitor.visit(ast, createVisitorContext()), ast);
 }
 
-function fromCoreAST(node, options) {
-    return convertNode(node, options?.inferRoles ?? null);
-}
-function pos(node) {
-    const p = {};
-    if (typeof node.start === 'number')
-        p.start = node.start;
-    if (typeof node.end === 'number')
-        p.end = node.end;
-    if (typeof node.line === 'number')
-        p.line = node.line;
-    if (typeof node.column === 'number')
-        p.column = node.column;
-    return p;
-}
-function convertNode(node, infer) {
-    if (!node)
-        return { type: 'literal', value: null };
-    switch (node.type) {
-        case 'eventHandler':
-            return convertEventHandler(node, infer);
-        case 'command':
-            return convertCommand$1(node, infer);
-        case 'CommandSequence':
-            return convertCommandSequence(node, infer);
-        case 'Program': {
-            const statements = (node.statements ?? []);
-            if (statements.length === 0) {
-                return { type: 'literal', value: null, ...pos(node) };
-            }
-            if (statements.length === 1) {
-                return convertNode(statements[0], infer);
-            }
-            return convertNode(statements[0], infer);
-        }
-        case 'block':
-            return convertBlock(node, infer);
-        case 'errorCommand':
-            return {
-                type: 'error',
-                message: node.message ?? 'Parse error',
-                token: node.token ?? undefined,
-                ...pos(node),
-            };
-        case 'literal':
-            return {
-                type: 'literal',
-                value: node.value,
-                ...pos(node),
-            };
-        case 'string':
-            return { type: 'literal', value: node.value, ...pos(node) };
-        case 'selector':
-            return {
-                type: 'selector',
-                value: (node.value ?? node.selector ?? ''),
-                ...pos(node),
-            };
-        case 'contextReference':
-            return {
-                type: 'identifier',
-                value: (node.name ?? node.contextType ?? ''),
-                ...pos(node),
-            };
-        case 'identifier':
-            if (node.scope === 'element' || node.scope === 'local' || node.scope === 'global') {
-                return {
-                    type: 'variable',
-                    name: (node.name ?? ''),
-                    scope: node.scope,
-                    ...pos(node),
-                };
-            }
-            return {
-                type: 'identifier',
-                value: (node.name ?? node.value ?? ''),
-                name: (node.name ?? ''),
-                ...pos(node),
-            };
-        case 'propertyAccess':
-        case 'possessiveExpression':
-            return convertPossessive(node, infer);
-        case 'memberExpression':
-            return convertMember(node, infer);
-        case 'binaryExpression':
-            return convertBinary(node, infer);
-        case 'callExpression':
-            return convertCall(node, infer);
-        case 'unaryExpression':
-            return {
-                type: 'unary',
-                operator: node.operator,
-                operand: convertNode(node.argument ?? node.operand, infer),
-                ...pos(node),
-            };
-        case 'typeCheckExpression':
-            return {
-                type: 'typeCheck',
-                value: convertNode(node.value, infer),
-                typeName: String(node.typeName),
-                nullOk: node.nullOk !== false,
-                negated: node.negated === true,
-                ...pos(node),
-            };
-        case 'timeExpression':
-            return { type: 'literal', value: node.value, ...pos(node) };
-        case 'templateLiteral':
-            return { type: 'literal', value: (node.raw ?? ''), ...pos(node) };
-        case 'variable':
-            return {
-                type: 'variable',
-                name: (node.name ?? ''),
-                scope: (node.scope ?? 'local'),
-                ...pos(node),
-            };
-        case 'arrayLiteral':
-            return {
-                type: 'array',
-                elements: (node.elements ?? []).map(element => convertNode(element, infer)),
-                ...pos(node),
-            };
-        case 'attributeAccess':
-            return {
-                type: 'possessive',
-                object: { type: 'identifier', value: 'me' },
-                property: `@${node.attributeName}`,
-                ...pos(node),
-            };
-        case 'propertyOfExpression': {
-            const property = node.property;
-            return {
-                type: 'possessive',
-                object: convertNode(node.target, infer),
-                property: (property?.name ?? property?.value ?? ''),
-                ...pos(node),
-            };
-        }
-        case 'htmlSelector':
-            return {
-                type: 'selector',
-                value: (node.value ?? node.selector ?? ''),
-                ...pos(node),
-            };
-        case 'positional':
-            return {
-                type: 'positional',
-                position: node.position,
-                ...(node.target ? { target: convertNode(node.target, infer) } : {}),
-                ...pos(node),
-            };
-        case 'positionalExpression':
-            return {
-                type: 'positional',
-                position: node.operator,
-                ...(node.argument ? { target: convertNode(node.argument, infer) } : {}),
-                ...pos(node),
-            };
-        default:
-            return {
-                type: 'error',
-                message: `Unknown core AST node type: ${node.type}`,
-                ...pos(node),
-            };
-    }
-}
-function convertEventHandler(node, infer) {
-    const event = (node.event ?? 'click');
-    const commands = (node.commands ?? node.body ?? []);
-    const body = commands.map(cmd => convertNode(cmd, infer));
-    const modifiers = buildEventModifiers(node);
-    return { type: 'event', event, modifiers, body, ...pos(node) };
-}
-function convertCommand$1(node, infer) {
-    const name = node.name;
-    if (name === '__ERROR__') {
-        return {
-            type: 'error',
-            message: node.diagnostics?.[0]
-                ?.message ?? 'Parse error',
-            ...pos(node),
-        };
-    }
-    if (name === 'if' || name === 'unless') {
-        return convertIfCommand(node, infer);
-    }
-    if (name === 'repeat') {
-        return convertRepeatCommand(node, infer);
-    }
-    const original = node.originalCommand;
-    const sum = node.modifiers?.to;
-    const counted = node.args?.[0];
-    if (name === 'set' &&
-        (original === 'increment' || original === 'decrement') &&
-        sum?.type === 'binaryExpression' &&
-        counted) {
-        return convertCommand$1({
-            ...node,
-            name: original,
-            args: [counted],
-            modifiers: { by: sum.right },
-            originalCommand: undefined,
-        }, infer);
-    }
-    const args = (node.args ?? []).map(arg => convertNode(arg, infer));
-    const target = node.target ? convertNode(node.target, infer) : undefined;
-    const modifiers = node.modifiers
-        ? convertModifiers(node.modifiers, infer)
-        : undefined;
-    const roles = inferRoles(name, args, modifiers, target, infer);
-    return {
-        type: 'command',
-        name,
-        args,
-        ...(target ? { target } : {}),
-        ...(modifiers && Object.keys(modifiers).length > 0 ? { modifiers } : {}),
-        ...(roles ? { roles } : {}),
-        ...(node.partial ? { partial: true } : {}),
-        ...pos(node),
-    };
-}
-function convertIfCommand(node, infer) {
-    const args = (node.args ?? []);
-    let condition;
-    let thenBranch;
-    let elseBranch;
-    if (node.condition) {
-        condition = convertNode(node.condition, infer);
-        thenBranch = (node.thenBranch ?? node.then ?? []).map(n => convertNode(n, infer));
-        elseBranch = node.elseBranch
-            ? node.elseBranch.map(n => convertNode(n, infer))
-            : node.else
-                ? node.else.map(n => convertNode(n, infer))
-                : undefined;
-    }
-    else {
-        condition = args[0] ? convertNode(args[0], infer) : { type: 'literal', value: true };
-        thenBranch = extractBlockCommands(args[1], infer);
-        elseBranch = args[2] ? extractBlockCommands(args[2], infer) : undefined;
-    }
-    if (node.name === 'unless') {
-        condition = { type: 'unary', operator: 'not', operand: condition };
-    }
-    return {
-        type: 'if',
-        condition,
-        thenBranch,
-        ...(elseBranch ? { elseBranch } : {}),
-        ...pos(node),
-    };
-}
-function convertRepeatCommand(node, infer) {
-    const slots = (node.modifiers ?? {});
-    const form = slotText(slots.loopType);
-    if (form === undefined)
-        return convertPositionalRepeat(node, infer);
-    const [bodyBlock, elseBlock] = (node.args ?? []);
-    const body = extractBlockCommands(bodyBlock, infer);
-    const indexName = slotText(slots.index);
-    const shared = {
-        ...(indexName ? { indexName } : {}),
-        ...(elseBlock ? { elseBody: extractBlockCommands(elseBlock, infer) } : {}),
-        ...pos(node),
-    };
-    const operand = (slot) => (slot ? convertNode(slot, infer) : undefined);
-    switch (form) {
-        case 'for':
-            return {
-                type: 'foreach',
-                itemName: slotText(slots.for) ?? 'it',
-                collection: operand(slots.in) ?? { type: 'literal', value: null },
-                body,
-                ...shared,
-            };
-        case 'times':
-            return { type: 'repeat', count: operand(slots.times), body, ...shared };
-        case 'while':
-        case 'until': {
-            const test = operand(slots[form]) ?? { type: 'literal', value: form === 'until' };
-            return {
-                type: 'while',
-                condition: form === 'until' ? { type: 'unary', operator: 'not', operand: test } : test,
-                ...(slots.bottomTested?.value === true ? { bottomTested: true } : {}),
-                body,
-                ...shared,
-            };
-        }
-        case 'until-event': {
-            const event = slotText(slots.event);
-            if (!event) {
-                return { type: 'error', message: "'repeat until event' has no event name", ...pos(node) };
-            }
-            const target = operand(slots.from);
-            return {
-                type: 'repeat',
-                untilEvent: event,
-                ...(target ? { untilEventTarget: target } : {}),
-                body,
-                ...shared,
-            };
-        }
-        default:
-            return { type: 'repeat', body, ...shared };
-    }
-}
-function slotText(slot) {
-    const text = slot?.value ?? slot?.name;
-    return typeof text === 'string' ? text : undefined;
-}
-function convertPositionalRepeat(node, infer) {
-    const args = (node.args ?? []);
-    if (args.length === 0) {
-        return { type: 'repeat', body: [], ...pos(node) };
-    }
-    const loopTypeNode = args[0];
-    const loopType = (loopTypeNode?.name ?? loopTypeNode?.value ?? 'forever');
-    const bodyBlock = args[args.length - 1];
-    switch (loopType) {
-        case 'times': {
-            const count = args[1] ? convertNode(args[1], infer) : undefined;
-            return {
-                type: 'repeat',
-                count,
-                body: extractBlockCommands(bodyBlock, infer),
-                ...pos(node),
-            };
-        }
-        case 'for': {
-            const itemName = (args[1]?.value ?? 'item');
-            const collection = args[2]
-                ? convertNode(args[2], infer)
-                : { type: 'identifier', value: '[]' };
-            return {
-                type: 'foreach',
-                itemName,
-                collection,
-                body: extractBlockCommands(bodyBlock, infer),
-                ...pos(node),
-            };
-        }
-        case 'while': {
-            const condition = args[1]
-                ? convertNode(args[1], infer)
-                : { type: 'literal', value: true };
-            return {
-                type: 'while',
-                condition,
-                body: extractBlockCommands(bodyBlock, infer),
-                ...pos(node),
-            };
-        }
-        default:
-            return {
-                type: 'repeat',
-                body: extractBlockCommands(bodyBlock, infer),
-                ...pos(node),
-            };
-    }
-}
-function convertCommandSequence(node, infer) {
-    const commands = (node.commands ?? []);
-    if (commands.length === 1) {
-        return convertNode(commands[0], infer);
-    }
-    return {
-        type: 'event',
-        event: 'click',
-        body: commands.map(cmd => convertNode(cmd, infer)),
-        ...pos(node),
-    };
-}
-function convertBlock(node, infer) {
-    const commands = (node.commands ?? []);
-    if (commands.length === 1) {
-        return convertNode(commands[0], infer);
-    }
-    return {
-        type: 'event',
-        event: 'click',
-        body: commands.map(cmd => convertNode(cmd, infer)),
-        ...pos(node),
-    };
-}
-function convertPossessive(node, infer) {
-    const object = node.object
-        ? convertNode(node.object, infer)
-        : { type: 'identifier', value: 'me' };
-    const property = typeof node.property === 'string'
-        ? node.property
-        : (node.property?.name ?? node.property?.value ?? '');
-    return { type: 'possessive', object, property, ...pos(node) };
-}
-function convertMember(node, infer) {
-    const object = node.object
-        ? convertNode(node.object, infer)
-        : { type: 'identifier', value: 'me' };
-    const property = typeof node.property === 'string'
-        ? node.property
-        : node.property
-            ? convertNode(node.property, infer)
-            : { type: 'literal', value: '' };
-    return {
-        type: 'member',
-        object,
-        property,
-        computed: (node.computed ?? false),
-        ...pos(node),
-    };
-}
-function convertBinary(node, infer) {
-    return {
-        type: 'binary',
-        operator: (node.operator ?? ''),
-        left: convertNode(node.left, infer),
-        right: convertNode(node.right, infer),
-        ...pos(node),
-    };
-}
-function convertCall(node, infer) {
-    const callee = typeof node.callee === 'string'
-        ? { type: 'identifier', value: node.callee, name: node.callee }
-        : convertNode(node.callee, infer);
-    const args = (node.arguments ?? node.args ?? []).map(a => convertNode(a, infer));
-    return { type: 'call', callee, args, ...pos(node) };
-}
-function convertModifiers(modifiers, infer) {
-    const result = {};
-    for (const [key, value] of Object.entries(modifiers)) {
-        result[key] = convertNode(value, infer);
-    }
-    return result;
-}
-function buildEventModifiers(node) {
-    return {
-        ...(node.once ? { once: true } : {}),
-        ...(node.debounce ? { debounce: node.debounce } : {}),
-        ...(node.throttle ? { throttle: node.throttle } : {}),
-        ...(node.prevent ? { prevent: true } : {}),
-        ...(node.stop ? { stop: true } : {}),
-        ...(node.capture ? { capture: true } : {}),
-        ...(node.passive ? { passive: true } : {}),
-        ...(node.from ? { from: node.from } : {}),
-        ...(node.selector && !node.from ? { from: node.selector } : {}),
-    };
-}
-function extractBlockCommands(block, infer) {
-    if (!block)
-        return [];
-    if (block.type === 'block') {
-        return (block.commands ?? []).map(cmd => convertNode(cmd, infer));
-    }
-    return [convertNode(block, infer)];
-}
-function inferRoles(name, args, modifiers, target, infer) {
-    const roles = {};
-    switch (name) {
-        case 'set': {
-            const toVal = modifiers?.to;
-            const second = args[1];
-            const marksTo = second?.type === 'identifier' &&
-                String(second.name ?? second.value ?? '').toLowerCase() === 'to';
-            if (marksTo && !toVal) {
-                return infer
-                    ? infer(name, args, modifiers, target)
-                    : null;
-            }
-            if (args[0])
-                roles.destination = args[0];
-            if (toVal && typeof toVal === 'object' && 'type' in toVal) {
-                roles.patient = toVal;
-            }
-            else if (args[1]) {
-                roles.patient = args[1];
-            }
-            break;
-        }
-        case 'go': {
-            const kw = (n) => {
-                if (!n || typeof n !== 'object')
-                    return undefined;
-                const v = n;
-                if (v.type === 'identifier') {
-                    if (typeof v.name === 'string' && v.name !== '')
-                        return v.name;
-                    return typeof v.value === 'string' ? v.value : undefined;
-                }
-                if (v.type === 'literal' && typeof v.value === 'string')
-                    return v.value;
-                return undefined;
-            };
-            const asNode = (x) => x && typeof x === 'object' && 'type' in x ? x : undefined;
-            let destination;
-            let method;
-            const onMod = asNode(modifiers?.on);
-            const slotUrl = asNode(modifiers?.url);
-            const slotOf = asNode(modifiers?.of);
-            const slotHistory = kw(asNode(modifiers?.back)) ?? kw(asNode(modifiers?.forward));
-            if (slotHistory === 'back' || slotHistory === 'forward') {
-                destination = { type: 'identifier', value: slotHistory, name: slotHistory };
-            }
-            else if (slotUrl) {
-                destination = slotUrl;
-                method = { type: 'literal', value: 'url' };
-            }
-            else if (slotOf) {
-                destination = slotOf;
-            }
-            else if (args.length === 0 && onMod) {
-                destination = onMod;
-                if (kw(asNode(modifiers?.method)) === 'url') {
-                    method = { type: 'literal', value: 'url' };
-                }
-            }
-            else {
-                const words = args.map(kw);
-                const urlIdx = words.indexOf('url');
-                if (urlIdx !== -1 && args[urlIdx + 1]) {
-                    destination = args[urlIdx + 1];
-                    method = { type: 'literal', value: 'url' };
-                }
-                else {
-                    const SKIP = new Set(['to', 'the']);
-                    const POSITION = new Set([
-                        'top',
-                        'middle',
-                        'bottom',
-                        'left',
-                        'center',
-                        'right',
-                        'smoothly',
-                        'instantly',
-                        'in',
-                        'new',
-                        'window',
-                    ]);
-                    const headIdx = args.findIndex((_, i) => {
-                        const w = words[i];
-                        return w === undefined || !SKIP.has(w);
-                    });
-                    const headWord = headIdx !== -1 ? words[headIdx] : undefined;
-                    const ofIdx = words.indexOf('of');
-                    if (headWord === 'back' || headWord === 'forward') {
-                        destination = { type: 'identifier', value: headWord, name: headWord };
-                    }
-                    else if (ofIdx !== -1 && args[ofIdx + 1]) {
-                        destination = kw(args[ofIdx + 1]) === 'the' ? args[ofIdx + 2] : args[ofIdx + 1];
-                    }
-                    else if (headIdx !== -1 && !POSITION.has(headWord ?? '')) {
-                        destination = args[headIdx];
-                    }
-                }
-            }
-            const destWord = kw(destination);
-            if ((destWord === 'back' || destWord === 'forward') && destination?.type !== 'identifier') {
-                destination = { type: 'identifier', value: destWord, name: destWord };
-            }
-            if (!destination && target)
-                destination = target;
-            if (destination)
-                roles.destination = destination;
-            if (method)
-                roles.method = method;
-            break;
-        }
-        default:
-            return infer
-                ? infer(name, args, modifiers, target)
-                : null;
-    }
-    return Object.keys(roles).length > 0 ? roles : null;
-}
-
-const POS = { start: 0, end: 0, line: 1, column: 0 };
-function nodePos(node) {
-    return {
-        start: node.start ?? POS.start,
-        end: node.end ?? POS.end,
-        line: node.line ?? POS.line,
-        column: node.column ?? POS.column,
-    };
-}
-function toCoreAST(node) {
-    if (!node)
-        return { type: 'literal', value: null, raw: 'null', ...POS };
+const isRecord = (value) => typeof value === 'object' && value !== null;
+const isEngineSpan = (value) => isRecord(value) &&
+    typeof value.type === 'string' &&
+    typeof value.start === 'number' &&
+    typeof value.end === 'number';
+const COMMAND_TYPES = {
+    call: ['getCommand'],
+    trigger: ['sendCommand'],
+    toggle: ['toggleCommand', 'toggleElementCommand'],
+    transition: ['transitionCommand', 'viewTransitionCommand'],
+};
+function engineTypesFor(node) {
     switch (node.type) {
         case 'event':
-            return convertEvent(node);
-        case 'command':
-            return convertCommand(node);
+            return ['onFeature'];
         case 'if':
-            return convertIf(node);
+            return ['ifCommand'];
         case 'repeat':
-            return convertRepeat(node);
         case 'foreach':
-            return convertForEach(node);
         case 'while':
-            return convertWhile(node);
-        case 'literal':
-            return {
-                type: 'literal',
-                value: node.value,
-                raw: node.value === null ? 'null' : node.value === undefined ? '' : String(node.value),
-                ...nodePos(node),
-            };
-        case 'identifier':
-            return { type: 'identifier', name: node.name ?? node.value, ...nodePos(node) };
-        case 'selector':
-            return { type: 'selector', value: node.value, ...nodePos(node) };
-        case 'variable':
-            return { type: 'identifier', name: node.name, scope: node.scope, ...nodePos(node) };
-        case 'binary':
-            return {
-                type: 'binaryExpression',
-                operator: node.operator,
-                left: toCoreAST(node.left),
-                right: toCoreAST(node.right),
-                ...nodePos(node),
-            };
-        case 'unary':
-            return {
-                type: 'unaryExpression',
-                operator: node.operator,
-                argument: toCoreAST(node.operand),
-                prefix: true,
-                ...nodePos(node),
-            };
-        case 'typeCheck':
-            return {
-                type: 'typeCheckExpression',
-                value: toCoreAST(node.value),
-                typeName: node.typeName,
-                nullOk: node.nullOk,
-                negated: node.negated,
-                ...nodePos(node),
-            };
-        case 'member':
-            return {
-                type: 'memberExpression',
-                object: toCoreAST(node.object),
-                property: typeof node.property === 'string'
-                    ? { type: 'identifier', name: node.property, ...POS }
-                    : toCoreAST(node.property),
-                computed: node.computed ?? false,
-                ...nodePos(node),
-            };
-        case 'array':
-            return {
-                type: 'arrayLiteral',
-                elements: node.elements.map(element => toCoreAST(element)),
-                ...nodePos(node),
-            };
-        case 'possessive':
-            return {
-                type: 'possessiveExpression',
-                object: toCoreAST(node.object),
-                property: { type: 'identifier', name: node.property, ...POS },
-                ...nodePos(node),
-            };
-        case 'call':
-            return {
-                type: 'callExpression',
-                callee: toCoreAST(node.callee),
-                arguments: (node.args ?? []).map(a => toCoreAST(a)),
-                ...nodePos(node),
-            };
-        case 'positional':
-            return {
-                type: 'callExpression',
-                callee: { type: 'identifier', name: node.position, ...POS },
-                arguments: node.target ? [toCoreAST(node.target)] : [],
-                ...nodePos(node),
-            };
-        case 'error':
-            return { type: 'literal', value: null, raw: 'null', ...POS };
-        default: {
-            return { type: 'literal', value: null, raw: 'null', ...POS };
-        }
-    }
-}
-function convertEvent(node) {
-    const commands = (node.body ?? []).map(cmd => toCoreAST(cmd));
-    const modifiers = flattenEventModifiers(node.modifiers);
-    return {
-        type: 'eventHandler',
-        event: node.event,
-        commands,
-        ...modifiers,
-        ...nodePos(node),
-    };
-}
-function convertCommand(node) {
-    const result = {
-        type: 'command',
-        name: node.name,
-        args: (node.args ?? []).map(a => toCoreAST(a)),
-        isBlocking: false,
-        ...nodePos(node),
-    };
-    if (node.target) {
-        result.target = toCoreAST(node.target);
-    }
-    if (node.modifiers && Object.keys(node.modifiers).length > 0) {
-        const convertedModifiers = {};
-        for (const [key, value] of Object.entries(node.modifiers)) {
-            convertedModifiers[key] =
-                value && typeof value === 'object' && 'type' in value
-                    ? toCoreAST(value)
-                    : value;
+            return ['repeatCommand'];
+        case 'command': {
+            const name = typeof node.name === 'string' ? node.name : '';
+            return COMMAND_TYPES[name] ?? [`${name}Command`];
         }
-        result.modifiers = convertedModifiers;
-    }
-    return result;
-}
-function block(nodes) {
-    return { type: 'block', commands: nodes.map(n => toCoreAST(n)), ...POS };
-}
-function convertIf(node) {
-    const [elseIf, ...laterElseIfs] = node.elseIfBranches ?? [];
-    const elseBranch = elseIf
-        ? [
-            {
-                type: 'if',
-                condition: elseIf.condition,
-                thenBranch: elseIf.body,
-                elseIfBranches: laterElseIfs,
-                ...(node.elseBranch ? { elseBranch: node.elseBranch } : {}),
-            },
-        ]
-        : node.elseBranch;
-    return {
-        type: 'command',
-        name: 'if',
-        isBlocking: true,
-        args: [
-            toCoreAST(node.condition),
-            block(node.thenBranch),
-            ...(elseBranch ? [block(elseBranch)] : []),
-        ],
-        ...nodePos(node),
+        default:
+            return [];
+    }
+}
+function engineSpans(tree, out = []) {
+    if (Array.isArray(tree)) {
+        for (const item of tree)
+            engineSpans(item, out);
+        return out;
+    }
+    if (!isRecord(tree))
+        return out;
+    if (isEngineSpan(tree) && /(Command|Feature)$/.test(tree.type))
+        out.push(tree);
+    for (const value of Object.values(tree)) {
+        if (typeof value === 'object' && value !== null)
+            engineSpans(value, out);
+    }
+    return out;
+}
+function withEnginePositions(nodes, source, engineTree) {
+    const spans = engineSpans(engineTree);
+    let cursor = 0;
+    const lineStarts = [0];
+    for (let i = 0; i < source.length; i++)
+        if (source[i] === '\n')
+            lineStarts.push(i + 1);
+    const lineAndColumn = (offset) => {
+        let line = 0;
+        while (line + 1 < lineStarts.length && (lineStarts[line + 1] ?? Infinity) <= offset)
+            line++;
+        return { line: line + 1, column: offset - (lineStarts[line] ?? 0) };
     };
-}
-function loopCommand(node, form, operands) {
-    const modifiers = { loopType: slotString(form) };
-    for (const [slot, value] of Object.entries(operands)) {
-        if (value)
-            modifiers[slot] = value;
-    }
-    if (node.indexName)
-        modifiers.index = slotString(node.indexName);
-    return {
-        type: 'command',
-        name: 'repeat',
-        isBlocking: true,
-        args: [block(node.body), ...(node.elseBody ? [block(node.elseBody)] : [])],
-        modifiers,
-        ...nodePos(node),
+    const place = (value) => {
+        if (Array.isArray(value))
+            return value.map(place);
+        if (!isRecord(value) || typeof value.type !== 'string')
+            return value;
+        let span = typeof value.start === 'number' && typeof value.end === 'number'
+            ? { start: value.start, end: value.end }
+            : undefined;
+        const kinds = engineTypesFor(value);
+        if (kinds.length > 0) {
+            const index = spans.findIndex((s, i) => i >= cursor && kinds.includes(s.type));
+            const match = spans[index];
+            if (match) {
+                span = { start: match.start, end: match.end };
+                cursor = index + 1;
+            }
+        }
+        const out = {};
+        for (const [key, child] of Object.entries(value)) {
+            out[key] = typeof child === 'object' ? place(child) : child;
+        }
+        return span ? { ...out, ...span, ...lineAndColumn(span.start) } : out;
     };
-}
-function slotString(value) {
-    return { type: 'string', value, ...POS };
-}
-function convertRepeat(node) {
-    if (node.count !== undefined) {
-        const times = typeof node.count === 'number'
-            ? { type: 'literal', value: node.count, raw: String(node.count), ...POS }
-            : toCoreAST(node.count);
-        return loopCommand(node, 'times', { times });
-    }
-    if (node.whileCondition !== undefined) {
-        return loopCommand(node, 'while', { while: toCoreAST(node.whileCondition) });
-    }
-    if (node.untilEvent !== undefined) {
-        return loopCommand(node, 'until-event', {
-            event: slotString(node.untilEvent),
-            from: node.untilEventTarget ? toCoreAST(node.untilEventTarget) : undefined,
-        });
-    }
-    return loopCommand(node, 'forever', {});
-}
-function convertForEach(node) {
-    return loopCommand(node, 'for', {
-        for: slotString(node.itemName),
-        in: toCoreAST(node.collection),
-    });
-}
-function convertWhile(node) {
-    return loopCommand(node, 'while', {
-        while: toCoreAST(node.condition),
-        bottomTested: node.bottomTested
-            ? { type: 'literal', value: true, raw: 'true', ...POS }
-            : undefined,
-    });
-}
-function flattenEventModifiers(modifiers) {
-    if (!modifiers)
-        return {};
-    const flat = {};
-    if (modifiers.once)
-        flat.once = true;
-    if (modifiers.prevent)
-        flat.prevent = true;
-    if (modifiers.stop)
-        flat.stop = true;
-    if (modifiers.capture)
-        flat.capture = true;
-    if (modifiers.passive)
-        flat.passive = true;
-    if (modifiers.debounce)
-        flat.debounce = modifiers.debounce;
-    if (modifiers.throttle)
-        flat.throttle = modifiers.throttle;
-    if (modifiers.from)
-        flat.from = modifiers.from;
-    return flat;
+    return nodes.map(node => place(node));
 }
 
 var DiagnosticSeverity;
@@ -3645,7 +2914,6 @@ exports.findDeadCode = findDeadCode;
 exports.findFirst = findFirst;
 exports.findNodes = findNodes;
 exports.format = format;
-exports.fromCoreAST = fromCoreAST;
 exports.generate = generate;
 exports.generateCommand = generateCommand;
 exports.generateDocumentation = generateDocumentation;
@@ -3669,7 +2937,7 @@ exports.query = query;
 exports.queryAll = queryAll;
 exports.queryXPath = queryXPath;
 exports.suggestOptimizations = suggestOptimizations;
-exports.toCoreAST = toCoreAST;
 exports.transform = transform;
 exports.visit = visit;
+exports.withEnginePositions = withEnginePositions;
 //# sourceMappingURL=index.cjs.map