@lokascript/compilation-service 3.1.1 → 3.3.0

package/dist/{dist-WWPF6XTQ.js → dist-6EMM5HXE.js}

@@ -1,7 +1,7 @@
 import {
   CoreParserAdapter,
   createCoreParserAdapter
-} from "./chunk-T2AN3WRD.js";
+} from "./chunk-PEL4Z7TK.js";
 import {
   SemanticParserAdapter,
   createSemanticAdapter
@@ -427,6 +427,13 @@ var AnalysisVisitor = class {
   }
   visitCommand(node) {
     this.commandsUsed.add(node.name);
+    if (["set", "increment", "decrement", "default"].includes(node.name)) {
+      const target = node.roles?.destination ?? node.roles?.patient ?? node.args?.[0];
+      const name = target?.type === "identifier" ? target.value : void 0;
+      if (name && /^[A-Za-z_]\w*$/.test(name)) {
+        this.registerVariable(name, "local", "write");
+      }
+    }
     switch (node.name) {
       case "fetch":
         this.hasAsync = true;
@@ -508,32 +515,37 @@ var AnalysisVisitor = class {
     if (node.whileCondition) {
       this.visit(node.whileCondition);
     }
-    for (const child of node.body) {
-      this.visit(child);
+    if (node.untilEvent !== void 0) {
+      this.hasAsync = true;
+      this.runtimeHelpers.add("wait");
+      if (node.untilEventTarget) this.visit(node.untilEventTarget);
     }
+    this.visitLoopBody(node);
     this.exitNesting();
   }
   visitForEach(node) {
     this.hasLoops = true;
     this.enterNesting();
     this.registerVariable(node.itemName, "local", "write");
-    if (node.indexName) {
-      this.registerVariable(node.indexName, "local", "write");
-    }
     this.visit(node.collection);
-    for (const child of node.body) {
-      this.visit(child);
-    }
+    this.visitLoopBody(node);
     this.exitNesting();
   }
   visitWhile(node) {
     this.hasLoops = true;
     this.enterNesting();
     this.visit(node.condition);
-    for (const child of node.body) {
+    this.visitLoopBody(node);
+    this.exitNesting();
+  }
+  /** The parts every loop form shares: its `index` local, body, and `else`. */
+  visitLoopBody(node) {
+    if (node.indexName) {
+      this.registerVariable(node.indexName, "local", "write");
+    }
+    for (const child of [...node.body, ...node.elseBody ?? []]) {
       this.visit(child);
     }
-    this.exitNesting();
   }
   visitVariable(node, access) {
     const name = node.name.startsWith(":") || node.name.startsWith("$") ? node.name.slice(1) : node.name;
@@ -686,11 +698,15 @@ function analyze(ast) {
   const analyzer = new Analyzer();
   return analyzer.analyze(ast);
 }
-var CLASS_COMMANDS = /* @__PURE__ */ new Set(["add", "remove", "toggle"]);
+var TARGET_SLOTS = /* @__PURE__ */ new Map([
+  ["add", "to"],
+  ["remove", "from"],
+  ["toggle", "on"]
+]);
 function extractClassOp(node) {
   if (node.type !== "command") return null;
   const cmd = node;
-  if (!CLASS_COMMANDS.has(cmd.name)) return null;
+  if (!TARGET_SLOTS.has(cmd.name)) return null;
   const args = cmd.args ?? [];
   if (args.length === 0) return null;
   const arg = args[0];
@@ -699,48 +715,32 @@ function extractClassOp(node) {
   if (!selector.startsWith(".")) return null;
   const className = selector.slice(1);
   if (!className) return null;
-  return {
-    command: cmd.name,
-    className,
-    hasExplicitTarget: !!cmd.target
-  };
+  return { command: cmd.name, className };
 }
-function isSameTarget(a, b) {
-  if (a.type !== "command" || b.type !== "command") return false;
-  const cmdA = a;
-  const cmdB = b;
-  if (!cmdA.target && !cmdB.target) return true;
-  if (cmdA.target && cmdB.target) {
-    return getTargetKey(cmdA.target) === getTargetKey(cmdB.target);
-  }
-  return false;
+function classTarget(cmd) {
+  if (cmd.target) return cmd.target;
+  const slot = cmd.modifiers?.[TARGET_SLOTS.get(cmd.name)];
+  return slot && typeof slot === "object" && "type" in slot ? slot : void 0;
 }
-function getTargetKey(target) {
-  if (target.type === "selector") {
-    return `selector:${target.value}`;
-  }
-  if (target.type === "identifier") {
-    return `identifier:${target.value}`;
+function batchTargetKey(cmd) {
+  const target = classTarget(cmd);
+  if (!target) return "me";
+  if (target.type === "identifier" && target.value === "me") return "me";
+  if (target.type === "selector" && /^#[\w-]+$/.test(target.value)) {
+    return target.value;
   }
   return null;
 }
-function resolveTarget(cmd) {
-  if (!cmd.target) return "_ctx.me";
-  if (cmd.target.type === "selector") {
-    const sel = cmd.target.value;
-    if (sel.startsWith("#") && !sel.includes(" ") && !sel.includes(".")) {
-      return `document.getElementById('${sel.slice(1)}')`;
-    }
-    return `document.querySelector('${sel}')`;
-  }
-  if (cmd.target.type === "identifier") {
-    const val = cmd.target.value;
-    if (val === "me") return "_ctx.me";
-    return val;
-  }
-  return "_ctx.me";
+function resolveTarget(key) {
+  return key === "me" ? "_ctx.me" : `document.getElementById('${key.slice(1)}')`;
 }
-function createBatchNode(run) {
+function reordersClass(run, op) {
+  return run.some((node) => {
+    const other = extractClassOp(node);
+    return other.command !== op.command && other.className === op.className;
+  });
+}
+function createBatchNode(run, targetKey) {
   const adds = [];
   const removes = [];
   const toggles = [];
@@ -758,10 +758,9 @@ function createBatchNode(run) {
         break;
     }
   }
-  const target = resolveTarget(run[0]);
   return {
     type: "batchedClassOps",
-    target,
+    target: resolveTarget(targetKey),
     adds,
     removes,
     toggles
@@ -770,9 +769,10 @@ function createBatchNode(run) {
 function batchBody(nodes) {
   const result = [];
   let currentRun = [];
+  let runKey = "";
   function flushRun() {
     if (currentRun.length >= 2) {
-      result.push(createBatchNode(currentRun));
+      result.push(createBatchNode(currentRun, runKey));
     } else if (currentRun.length === 1) {
       result.push(currentRun[0]);
     }
@@ -780,12 +780,14 @@ function batchBody(nodes) {
   }
   for (const node of nodes) {
     const op = extractClassOp(node);
-    if (op) {
-      if (currentRun.length > 0 && isSameTarget(currentRun[0], node)) {
+    const key = op && batchTargetKey(node);
+    if (op && key) {
+      if (currentRun.length > 0 && key === runKey && !reordersClass(currentRun, op)) {
         currentRun.push(node);
       } else {
         flushRun();
         currentRun = [node];
+        runKey = key;
       }
     } else {
       flushRun();
@@ -1112,6 +1114,9 @@ var LoopUnrollingPass = class {
     if (this.usesIndex(body)) {
       return null;
     }
+    if (repeatNode.indexName !== void 0 || repeatNode.elseBody !== void 0) {
+      return null;
+    }
     const unrolled = [];
     for (let i = 0; i < count; i++) {
       unrolled.push(...this.cloneBody(body));
@@ -1431,6 +1436,8 @@ var ExpressionCodegen = class {
         return this.generateTemplate(node);
       case "unary":
         return this.generateUnary(node);
+      case "typeCheck":
+        return this.generateTypeCheck(node);
       case "conditional":
         return this.generateConditional(node);
       case "sequence":
@@ -1505,6 +1512,9 @@ var ExpressionCodegen = class {
           this.ctx.requireHelper("globals");
           return `_rt.globals.get('${varName}')`;
         }
+        if (this.ctx.analysis?.variables?.locals?.get(name)?.scope === "local") {
+          return `_ctx.locals.get('${sanitizeIdentifier(name)}')`;
+        }
         return sanitizeIdentifier(name);
     }
   }
@@ -1538,7 +1548,8 @@ var ExpressionCodegen = class {
         this.ctx.requireHelper("globals");
         return `_rt.globals.get('${varName}')`;
       case "element":
-        return `_ctx.me.${varName}`;
+        this.ctx.requireHelper("elementVars");
+        return `_rt.elementVars(_ctx.me).get('${varName}')`;
       default:
         return `_ctx.locals.get('${varName}')`;
     }
@@ -1551,19 +1562,40 @@ var ExpressionCodegen = class {
     const right = this.generate(node.right);
     const op = node.operator;
     switch (op) {
-      // Equality
+      // Equality, with core's phrase forms of each (`n is equal to 3`).
       case "is":
       case "==":
+      case "am":
+      case "equals":
+      case "is equal":
+      case "is equal to":
         return `(${left} === ${right})`;
       case "is not":
       case "!=":
+      case "is not equal":
+      case "is not equal to":
         return `(${left} !== ${right})`;
-      // Comparison
+      case "really equals":
+      case "is really":
+      case "is really equal to":
+        return `(${left} === ${right})`;
+      case "is not really":
+      case "is not really equal to":
+        return `(${left} !== ${right})`;
+      // Comparison. Left as is, `(n is greater than 2)` is not JavaScript.
       case "<":
       case ">":
       case "<=":
       case ">=":
         return `(${left} ${op} ${right})`;
+      case "is less than":
+        return `(${left} < ${right})`;
+      case "is greater than":
+        return `(${left} > ${right})`;
+      case "is less than or equal to":
+        return `(${left} <= ${right})`;
+      case "is greater than or equal to":
+        return `(${left} >= ${right})`;
       // Arithmetic
       case "+":
       case "-":
@@ -1571,6 +1603,9 @@ var ExpressionCodegen = class {
       case "/":
       case "%":
         return `(${left} ${op} ${right})`;
+      // Hyperscript's word for `%`; left as is, `(n mod 2)` is not JavaScript.
+      case "mod":
+        return `(${left} % ${right})`;
       // Logical
       case "and":
       case "&&":
@@ -1580,15 +1615,49 @@ var ExpressionCodegen = class {
         return `(${left} || ${right})`;
       // String/collection operators
       case "contains":
+      case "contain":
+      case "includes":
+      case "include":
         this.ctx.requireHelper("contains");
         return `_rt.contains(${left}, ${right})`;
+      case "does not contain":
+      case "do not contain":
+      case "does not contains":
+      case "does not include":
+        this.ctx.requireHelper("contains");
+        return `!_rt.contains(${left}, ${right})`;
+      // `matches` tests a selector, so a selector operand stays a string: the
+      // element it would query is not a selector (`_rt.matches(el, el)`).
       case "matches":
+      case "match":
+        this.ctx.requireHelper("matches");
+        return `_rt.matches(${left}, ${this.selectorText(node.right, right)})`;
+      case "does not match":
+      case "do not match":
         this.ctx.requireHelper("matches");
-        return `_rt.matches(${left}, ${right})`;
+        return `!_rt.matches(${left}, ${this.selectorText(node.right, right)})`;
+      // Membership, `n is in [1, 3]`: the right side contains the left.
+      case "is in":
+      case "am in":
+        this.ctx.requireHelper("contains");
+        return `_rt.contains(${right}, ${left})`;
+      case "is not in":
+      case "am not in":
+        this.ctx.requireHelper("contains");
+        return `!_rt.contains(${right}, ${left})`;
       case "starts with":
         return `${left}.startsWith(${right})`;
       case "ends with":
         return `${left}.endsWith(${right})`;
+      // A scoped query, `<li/> in #list`: the matches inside the scope, as
+      // both engines read it. JavaScript's `in` (the default below) tests a
+      // property KEY, so `(document.querySelector('li') in …)` matched nothing.
+      case "in":
+        if (node.left.type === "selector") {
+          const query = sanitizeSelector(node.left.value);
+          return `${right}.querySelectorAll('${query}')`;
+        }
+        return `(${left} ${op} ${right})`;
       // Class check
       case "has":
         if (node.right.type === "selector") {
@@ -1616,13 +1685,18 @@ var ExpressionCodegen = class {
         return `(${left} ${op} ${right})`;
     }
   }
+  /** A selector operand as its quoted text; any other operand as generated. */
+  selectorText(node, generated) {
+    return node.type === "selector" ? `'${sanitizeSelector(node.value)}'` : generated;
+  }
   // ===========================================================================
   // MEMBER EXPRESSIONS
   // ===========================================================================
   generateMember(node) {
     const object = this.generate(node.object);
-    if (typeof node.property === "string") {
-      const prop = node.property;
+    const property = node.property;
+    const prop = typeof property === "string" ? property : !node.computed && property.type === "identifier" ? property.value ?? property.name : void 0;
+    if (prop !== void 0) {
       if (prop.startsWith("*")) {
         const styleProp = prop.slice(1);
         return `${object}.style.${styleProp}`;
@@ -1804,6 +1878,12 @@ var ExpressionCodegen = class {
   // ===========================================================================
   // UNARY EXPRESSIONS
   // ===========================================================================
+  /** `x is a Number`, as both engines test it: see the runtime's `typeCheck`. */
+  generateTypeCheck(node) {
+    this.ctx.requireHelper("typeCheck");
+    const test = `_rt.typeCheck(${this.generate(node.value)}, ${JSON.stringify(node.typeName)}, ${node.nullOk})`;
+    return node.negated ? `!${test}` : test;
+  }
   generateUnary(node) {
     const operand = this.generate(node.operand);
     switch (node.operator) {
@@ -1816,6 +1896,22 @@ var ExpressionCodegen = class {
         return `+${operand}`;
       case "no":
         return `!${operand}`;
+      // Core's postfix tests. Left as is, `exists#d1` is not JavaScript.
+      case "exists":
+      case "some":
+        this.ctx.requireHelper("exists");
+        return `_rt.exists(${operand})`;
+      case "does not exist":
+        this.ctx.requireHelper("exists");
+        return `!_rt.exists(${operand})`;
+      case "is empty":
+        this.ctx.requireHelper("isEmpty");
+        return `_rt.isEmpty(${operand})`;
+      case "is not empty":
+        this.ctx.requireHelper("isEmpty");
+        return `!_rt.isEmpty(${operand})`;
+      case "beep!":
+        return `((v) => (console.log('%c[beep]', 'color: orange; font-weight: bold', v), v))(${operand})`;
       default:
         return `${node.operator}${operand}`;
     }
@@ -1834,6 +1930,30 @@ function generateExpression(node, ctx) {
   const codegen = new ExpressionCodegen(ctx);
   return codegen.generate(node);
 }
+var isNode = (value) => typeof value === "object" && value !== null && "type" in value;
+function commandTarget(node, ...slots) {
+  if (node.target) return node.target;
+  for (const slot of slots) {
+    const found = slot === "arg" ? node.args?.[0] : node.modifiers?.[slot];
+    if (isNode(found)) return found;
+  }
+  return void 0;
+}
+function isScopedQuery(node) {
+  const binary = node;
+  return binary?.type === "binary" && binary.operator === "in" && binary.left.type === "selector";
+}
+function allMatches(node, ctx) {
+  if (isScopedQuery(node)) return ctx.generateExpression(node);
+  if (node?.type !== "selector") return null;
+  const selector = node.value;
+  return /^#[\w-]+$/.test(selector) ? null : `document.querySelectorAll('${sanitizeSelector(selector)}')`;
+}
+function forEachTarget(node, ctx, op) {
+  const all = allMatches(node, ctx);
+  if (all) return `${all}.forEach(el => ${op("el")})`;
+  return op(node ? ctx.generateExpression(node) : "_ctx.me");
+}
 var ToggleCodegen = class {
   constructor() {
     this.command = "toggle";
@@ -1841,22 +1961,15 @@ var ToggleCodegen = class {
   generate(node, ctx) {
     const args = node.args ?? [];
     if (args.length === 0) return null;
-    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const targetNode = commandTarget(node, "on");
     const arg = args[0];
     if (arg.type === "selector") {
       const selector = arg.value;
       if (selector.startsWith(".")) {
         const className = sanitizeClassName(selector.slice(1));
         if (!className) return null;
-        if (target === "_ctx.me") {
-          return {
-            code: `_ctx.me.classList.toggle('${className}')`,
-            async: false,
-            sideEffects: true
-          };
-        }
         return {
-          code: `Array.from(document.querySelectorAll('${sanitizeSelector(selector.slice(1))}')).forEach(el => el.classList.toggle('${className}'))`,
+          code: forEachTarget(targetNode, ctx, (el) => `${el}.classList.toggle('${className}')`),
           async: false,
           sideEffects: true
         };
@@ -1868,7 +1981,11 @@ var ToggleCodegen = class {
         const attrName = value.slice(1);
         ctx.requireHelper("toggleAttr");
         return {
-          code: `_rt.toggleAttr(${target}, '${sanitizeSelector(attrName)}')`,
+          code: forEachTarget(
+            targetNode,
+            ctx,
+            (el) => `_rt.toggleAttr(${el}, '${sanitizeSelector(attrName)}')`
+          ),
           async: false,
           sideEffects: true
         };
@@ -1876,7 +1993,11 @@ var ToggleCodegen = class {
     }
     ctx.requireHelper("toggle");
     return {
-      code: `_rt.toggle(${ctx.generateExpression(arg)}, ${target})`,
+      code: forEachTarget(
+        targetNode,
+        ctx,
+        (el) => `_rt.toggle(${ctx.generateExpression(arg)}, ${el})`
+      ),
       async: false,
       sideEffects: true
     };
@@ -1897,15 +2018,8 @@ var AddCodegen = class {
       if (selector.startsWith(".")) {
         const className = sanitizeClassName(selector.slice(1));
         if (!className) return null;
-        if (target === "_ctx.me") {
-          return {
-            code: `_ctx.me.classList.add('${className}')`,
-            async: false,
-            sideEffects: true
-          };
-        }
         return {
-          code: `${target}.classList.add('${className}')`,
+          code: forEachTarget(targetSlot, ctx, (el) => `${el}.classList.add('${className}')`),
           async: false,
           sideEffects: true
         };
@@ -1928,7 +2042,11 @@ var AddCodegen = class {
     }
     ctx.requireHelper("addClass");
     return {
-      code: `_rt.addClass(${target}, ${ctx.generateExpression(arg)})`,
+      code: forEachTarget(
+        targetSlot,
+        ctx,
+        (el) => `_rt.addClass(${el}, ${ctx.generateExpression(arg)})`
+      ),
       async: false,
       sideEffects: true
     };
@@ -1942,23 +2060,29 @@ var RemoveCodegen = class {
     const args = node.args ?? [];
     if (args.length === 0) {
       const targetSlot2 = node.target ?? node.modifiers?.from;
-      const target2 = targetSlot2 ? ctx.generateExpression(targetSlot2) : "_ctx.me";
       return {
-        code: `${target2}.remove()`,
+        code: forEachTarget(targetSlot2, ctx, (el) => `${el}.remove()`),
         async: false,
         sideEffects: true
       };
     }
     const targetSlot = node.target ?? node.modifiers?.from;
-    const target = targetSlot ? ctx.generateExpression(targetSlot) : "_ctx.me";
     const arg = args[0];
+    const isElement = arg.type === "selector" ? !/^[.@]/.test(arg.value) : arg.type === "identifier" && !String(arg.value ?? "").startsWith("@") || arg.type === "variable" || isScopedQuery(arg);
+    if (!targetSlot && isElement) {
+      return {
+        code: forEachTarget(arg, ctx, (el) => `${el}.remove()`),
+        async: false,
+        sideEffects: true
+      };
+    }
     if (arg.type === "selector") {
       const selector = arg.value;
       if (selector.startsWith(".")) {
         const className = sanitizeClassName(selector.slice(1));
         if (!className) return null;
         return {
-          code: `${target}.classList.remove('${className}')`,
+          code: forEachTarget(targetSlot, ctx, (el) => `${el}.classList.remove('${className}')`),
           async: false,
           sideEffects: true
         };
@@ -1966,12 +2090,42 @@ var RemoveCodegen = class {
     }
     ctx.requireHelper("removeClass");
     return {
-      code: `_rt.removeClass(${target}, ${ctx.generateExpression(arg)})`,
+      code: forEachTarget(
+        targetSlot,
+        ctx,
+        (el) => `_rt.removeClass(${el}, ${ctx.generateExpression(arg)})`
+      ),
       async: false,
       sideEffects: true
     };
   }
 };
+function variableStore(node, ctx) {
+  let name;
+  let scope;
+  if (node.type === "variable") {
+    name = node.name;
+    scope = node.scope;
+  } else if (node.type === "identifier") {
+    name = node.value ?? node.name ?? "";
+    if (/^(\$|::)/.test(name)) scope = "global";
+    else if (/^[A-Za-z_]\w*$/.test(name)) scope = "local";
+    else return null;
+  } else {
+    return null;
+  }
+  const key = sanitizeIdentifier(name.replace(/^(\$|::|:)/, ""));
+  if (scope === "global") {
+    ctx.requireHelper("globals");
+    return { read: `_rt.globals.get('${key}')`, write: (v) => `_rt.globals.set('${key}', ${v})` };
+  }
+  if (scope === "element") {
+    ctx.requireHelper("elementVars");
+    const store = `_rt.elementVars(_ctx.me)`;
+    return { read: `${store}.get('${key}')`, write: (v) => `${store}.set('${key}', ${v})` };
+  }
+  return { read: `_ctx.locals.get('${key}')`, write: (v) => `_ctx.locals.set('${key}', ${v})` };
+}
 var SetCodegen = class {
   constructor() {
     this.command = "set";
@@ -1984,26 +2138,8 @@ var SetCodegen = class {
     const valueNode = roles?.patient ?? modifiers?.to ?? args[1];
     if (!targetNode || !valueNode) return null;
     const value = ctx.generateExpression(valueNode);
-    if (targetNode.type === "variable") {
-      const varNode = targetNode;
-      const name = varNode.name.startsWith(":") ? varNode.name.slice(1) : varNode.name;
-      const safeName = sanitizeIdentifier(name);
-      if (varNode.scope === "local") {
-        return {
-          code: `_ctx.locals.set('${safeName}', ${value})`,
-          async: false,
-          sideEffects: true
-        };
-      }
-      if (varNode.scope === "global") {
-        ctx.requireHelper("globals");
-        return {
-          code: `_rt.globals.set('${safeName}', ${value})`,
-          async: false,
-          sideEffects: true
-        };
-      }
-    }
+    const store = variableStore(targetNode, ctx);
+    if (store) return { code: store.write(value), async: false, sideEffects: true };
     if (targetNode.type === "possessive") {
       const possessive = targetNode;
       const obj = ctx.generateExpression(possessive.object);
@@ -2052,20 +2188,17 @@ var PutCodegen = class {
     const contentNode = roles?.patient ?? args[0];
     if (!contentNode) return null;
     const content = ctx.generateExpression(contentNode);
-    let target = "_ctx.me";
-    if (roles?.destination) {
-      target = ctx.generateExpression(roles.destination);
-    } else if (modifiers) {
+    let targetNode = roles?.destination;
+    if (!targetNode && modifiers) {
       for (const key of ["into", "before", "after"]) {
         if (modifiers[key] && typeof modifiers[key] === "object") {
-          target = ctx.generateExpression(modifiers[key]);
+          targetNode = modifiers[key];
           break;
         }
       }
     }
-    if (target === "_ctx.me" && node.target) {
-      target = ctx.generateExpression(node.target);
-    }
+    targetNode ?? (targetNode = node.target);
+    const into = (op) => forEachTarget(targetNode, ctx, op);
     let modifier = "into";
     if (roles?.method && roles.method.value) {
       modifier = String(roles.method.value);
@@ -2077,39 +2210,39 @@ var PutCodegen = class {
     switch (modifier) {
       case "into":
         return {
-          code: `${target}.innerHTML = ${content}`,
+          code: into((el) => `${el}.innerHTML = ${content}`),
           async: false,
           sideEffects: true
         };
       case "before":
         return {
-          code: `${target}.insertAdjacentHTML('beforebegin', ${content})`,
+          code: into((el) => `${el}.insertAdjacentHTML('beforebegin', ${content})`),
           async: false,
           sideEffects: true
         };
       case "after":
         return {
-          code: `${target}.insertAdjacentHTML('afterend', ${content})`,
+          code: into((el) => `${el}.insertAdjacentHTML('afterend', ${content})`),
           async: false,
           sideEffects: true
         };
       case "at start of":
       case "start":
         return {
-          code: `${target}.insertAdjacentHTML('afterbegin', ${content})`,
+          code: into((el) => `${el}.insertAdjacentHTML('afterbegin', ${content})`),
           async: false,
           sideEffects: true
         };
       case "at end of":
       case "end":
         return {
-          code: `${target}.insertAdjacentHTML('beforeend', ${content})`,
+          code: into((el) => `${el}.insertAdjacentHTML('beforeend', ${content})`),
           async: false,
           sideEffects: true
         };
       default:
         return {
-          code: `${target}.innerHTML = ${content}`,
+          code: into((el) => `${el}.innerHTML = ${content}`),
           async: false,
           sideEffects: true
         };
@@ -2121,9 +2254,9 @@ var ShowCodegen = class {
     this.command = "show";
   }
   generate(node, ctx) {
-    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const targetNode = commandTarget(node, "arg");
     return {
-      code: `${target}.style.display = ''`,
+      code: forEachTarget(targetNode, ctx, (el) => `${el}.style.display = ''`),
       async: false,
       sideEffects: true
     };
@@ -2134,9 +2267,22 @@ var HideCodegen = class {
     this.command = "hide";
   }
   generate(node, ctx) {
-    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const targetNode = commandTarget(node, "arg");
+    return {
+      code: forEachTarget(targetNode, ctx, (el) => `${el}.style.display = 'none'`),
+      async: false,
+      sideEffects: true
+    };
+  }
+};
+var EmptyCodegen = class {
+  constructor() {
+    this.command = "empty";
+  }
+  generate(node, ctx) {
+    const targetNode = commandTarget(node, "arg");
     return {
-      code: `${target}.style.display = 'none'`,
+      code: forEachTarget(targetNode, ctx, (el) => `${el}.replaceChildren()`),
       async: false,
       sideEffects: true
     };
@@ -2147,7 +2293,8 @@ var FocusCodegen = class {
     this.command = "focus";
   }
   generate(node, ctx) {
-    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const targetNode = commandTarget(node, "arg");
+    const target = targetNode ? ctx.generateExpression(targetNode) : "_ctx.me";
     return {
       code: `${target}.focus()`,
       async: false,
@@ -2160,7 +2307,8 @@ var BlurCodegen = class {
     this.command = "blur";
   }
   generate(node, ctx) {
-    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const targetNode = commandTarget(node, "arg");
+    const target = targetNode ? ctx.generateExpression(targetNode) : "_ctx.me";
     return {
       code: `${target}.blur()`,
       async: false,
@@ -2281,11 +2429,11 @@ var SendCodegen = class {
     const args = node.args ?? [];
     if (args.length === 0) return null;
     const eventName = ctx.generateExpression(args[0]);
-    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const targetNode = commandTarget(node, "on", "to");
     const detail = args.length > 1 ? ctx.generateExpression(args[1]) : "undefined";
     ctx.requireHelper("send");
     return {
-      code: `_rt.send(${target}, ${eventName}, ${detail})`,
+      code: forEachTarget(targetNode, ctx, (el) => `_rt.send(${el}, ${eventName}, ${detail})`),
       async: false,
       sideEffects: true
     };
@@ -2303,25 +2451,10 @@ var IncrementCodegen = class {
     if (!target) return null;
     const amountNode = roles?.quantity ?? modifiers?.by ?? args[1];
     const amount = amountNode ? ctx.generateExpression(amountNode) : "1";
-    if (target.type === "variable") {
-      const varNode = target;
-      const name = varNode.name.startsWith(":") ? varNode.name.slice(1) : varNode.name;
-      const safeName = sanitizeIdentifier(name);
-      if (varNode.scope === "local") {
-        return {
-          code: `_ctx.locals.set('${safeName}', (_ctx.locals.get('${safeName}') || 0) + ${amount})`,
-          async: false,
-          sideEffects: true
-        };
-      }
-      if (varNode.scope === "global") {
-        ctx.requireHelper("globals");
-        return {
-          code: `_rt.globals.set('${safeName}', (_rt.globals.get('${safeName}') || 0) + ${amount})`,
-          async: false,
-          sideEffects: true
-        };
-      }
+    const store = variableStore(target, ctx);
+    if (store) {
+      const code = store.write(`(Number(${store.read}) || 0) + ${amount}`);
+      return { code, async: false, sideEffects: true };
     }
     const targetCode = ctx.generateExpression(target);
     return {
@@ -2343,25 +2476,10 @@ var DecrementCodegen = class {
     if (!target) return null;
     const amountNode = roles?.quantity ?? modifiers?.by ?? args[1];
     const amount = amountNode ? ctx.generateExpression(amountNode) : "1";
-    if (target.type === "variable") {
-      const varNode = target;
-      const name = varNode.name.startsWith(":") ? varNode.name.slice(1) : varNode.name;
-      const safeName = sanitizeIdentifier(name);
-      if (varNode.scope === "local") {
-        return {
-          code: `_ctx.locals.set('${safeName}', (_ctx.locals.get('${safeName}') || 0) - ${amount})`,
-          async: false,
-          sideEffects: true
-        };
-      }
-      if (varNode.scope === "global") {
-        ctx.requireHelper("globals");
-        return {
-          code: `_rt.globals.set('${safeName}', (_rt.globals.get('${safeName}') || 0) - ${amount})`,
-          async: false,
-          sideEffects: true
-        };
-      }
+    const store = variableStore(target, ctx);
+    if (store) {
+      const code = store.write(`(Number(${store.read}) || 0) - ${amount}`);
+      return { code, async: false, sideEffects: true };
     }
     const targetCode = ctx.generateExpression(target);
     return {
@@ -2426,17 +2544,37 @@ var CallCodegen = class {
     };
   }
 };
+var SCROLL_BLOCK = {
+  top: "start",
+  middle: "center",
+  bottom: "end",
+  nearest: "nearest"
+};
+var SCROLL_INLINE = { left: "start", center: "center", right: "end" };
+function scrollOptions(modifiers) {
+  const word = (slot) => {
+    const value = modifiers?.[slot]?.value;
+    return typeof value === "string" ? value : void 0;
+  };
+  const position = word("position") ?? "";
+  const options = [];
+  if (SCROLL_BLOCK[position]) options.push(`block: '${SCROLL_BLOCK[position]}'`);
+  if (SCROLL_INLINE[position]) options.push(`inline: '${SCROLL_INLINE[position]}'`);
+  const behavior = modifiers?.smooth ? "smooth" : word("behavior");
+  options.push(
+    `behavior: '${behavior === "smooth" || behavior === "instant" ? behavior : "auto"}'`
+  );
+  return `{ ${options.join(", ")} }`;
+}
 var ScrollCodegen = class {
   constructor() {
     this.command = "scroll";
   }
   generate(node, ctx) {
-    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
-    const mods = node.modifiers;
-    const smooth = mods?.smooth || mods?.behavior?.value === "smooth";
-    const behavior = smooth ? "'smooth'" : "'auto'";
+    const targetNode = commandTarget(node, "arg", "of");
+    const target = targetNode ? ctx.generateExpression(targetNode) : "_ctx.me";
     return {
-      code: `${target}.scrollIntoView({ behavior: ${behavior} })`,
+      code: `${target}.scrollIntoView(${scrollOptions(node.modifiers)})`,
       async: false,
       sideEffects: true
     };
@@ -2446,7 +2584,7 @@ var TakeCodegen = class {
   constructor() {
     this.command = "take";
   }
-  generate(node, _ctx) {
+  generate(node, ctx) {
     const args = node.args ?? [];
     if (args.length === 0) return null;
     const arg = args[0];
@@ -2455,6 +2593,19 @@ var TakeCodegen = class {
     if (!selector.startsWith(".")) return null;
     const className = sanitizeClassName(selector.slice(1));
     if (!className) return null;
+    const source = commandTarget(node, "from");
+    if (source) {
+      let from = allMatches(source, ctx);
+      if (!from) {
+        ctx.requireHelper("toArray");
+        from = `_rt.toArray(${ctx.generateExpression(source)})`;
+      }
+      return {
+        code: `(() => { ${from}.forEach(el => el.classList.remove('${className}')); _ctx.me.classList.add('${className}'); })()`,
+        async: false,
+        sideEffects: true
+      };
+    }
     return {
       code: `(() => { const _me = _ctx.me; _me.parentElement?.querySelectorAll('.${className}').forEach(el => el.classList.remove('${className}')); _me.classList.add('${className}'); })()`,
       async: false,
@@ -2486,49 +2637,85 @@ ${elseBody}
   }
   return code;
 }
+function emitLoop(parts) {
+  const pass = [
+    ...parts.elseBody !== void 0 ? ["_ran = true;"] : [],
+    ...parts.enter ? [parts.enter] : [],
+    ...parts.indexName ? [`_ctx.locals.set('${sanitizeIdentifier(parts.indexName)}', _i);`] : [],
+    parts.body
+  ].join("\n");
+  const step = parts.step ? `_i++, ${parts.step}` : "_i++";
+  const loop = parts.bottomTested ? (
+    // A `continue` jumps straight to the test, so the counter moves there.
+    `let _i = 0;
+do {
+${pass}
+} while ((${step}, ${parts.test}));`
+  ) : `for (let _i = 0; ${parts.test}; ${step}) {
+${pass}
+}`;
+  if (parts.elseBody === void 0) return parts.bottomTested ? `{
+${loop}
+}` : loop;
+  return `{
+let _ran = false;
+${loop}
+if (!_ran) {
+${parts.elseBody}
+}
+}`;
+}
 function generateRepeat(node, ctx, generateBody) {
   const exprCodegen = new ExpressionCodegen(ctx);
-  const body = generateBody(node.body);
+  const shared = {
+    indexName: node.indexName,
+    body: generateBody(node.body),
+    elseBody: node.elseBody ? generateBody(node.elseBody) : void 0
+  };
   if (node.count !== void 0) {
     const count = typeof node.count === "number" ? String(node.count) : exprCodegen.generate(node.count);
-    return `for (let _i = 0; _i < ${count}; _i++) {
-  _ctx.locals.set('index', _i);
-${body}
-}`;
+    return emitLoop({ ...shared, test: `_i < ${count}`, indexName: node.indexName ?? "index" });
   }
   if (node.whileCondition) {
-    const condition = exprCodegen.generate(node.whileCondition);
-    return `while (${condition}) {
-${body}
-}`;
+    return emitLoop({ ...shared, test: exprCodegen.generate(node.whileCondition) });
   }
-  return `while (true) {
-${body}
+  if (node.untilEvent !== void 0) {
+    ctx.requireHelper("wait");
+    const target = node.untilEventTarget ? exprCodegen.generate(node.untilEventTarget) : "_ctx.me";
+    return `{
+let _fired = false;
+${target}.addEventListener(${JSON.stringify(node.untilEvent)}, () => { _fired = true; }, { once: true });
+${emitLoop({ ...shared, test: "!_fired", step: "await _rt.wait(0)" })}
 }`;
+  }
+  return emitLoop({ ...shared, test: "true" });
 }
 function generateForEach(node, ctx, generateBody) {
   const exprCodegen = new ExpressionCodegen(ctx);
-  const collection = exprCodegen.generate(node.collection);
+  const source = node.collection;
+  const collection = source.type === "selector" && !String(source.value).startsWith("#") ? `document.querySelectorAll('${sanitizeSelector(String(source.value))}')` : exprCodegen.generate(source);
   const itemName = sanitizeIdentifier(node.itemName);
-  const indexName = node.indexName ? sanitizeIdentifier(node.indexName) : "index";
-  const body = generateBody(node.body);
   return `{
   const _collection = ${collection};
-  const _arr = Array.isArray(_collection) ? _collection : Array.from(_collection);
-  for (let _i = 0; _i < _arr.length; _i++) {
-    _ctx.locals.set('${itemName}', _arr[_i]);
-    _ctx.locals.set('${indexName}', _i);
-${body}
-  }
+  const _arr = _collection == null ? [] : Array.isArray(_collection) ? _collection : Array.from(_collection);
+${emitLoop({
+    test: "_i < _arr.length",
+    enter: `_ctx.locals.set('${itemName}', _arr[_i]);`,
+    indexName: node.indexName ?? "index",
+    body: generateBody(node.body),
+    elseBody: node.elseBody ? generateBody(node.elseBody) : void 0
+  })}
 }`;
 }
 function generateWhile(node, ctx, generateBody) {
   const exprCodegen = new ExpressionCodegen(ctx);
-  const condition = exprCodegen.generate(node.condition);
-  const body = generateBody(node.body);
-  return `while (${condition}) {
-${body}
-}`;
+  return emitLoop({
+    test: exprCodegen.generate(node.condition),
+    bottomTested: node.bottomTested,
+    indexName: node.indexName,
+    body: generateBody(node.body),
+    elseBody: node.elseBody ? generateBody(node.elseBody) : void 0
+  });
 }
 var UnlessCodegen = class {
   constructor() {
@@ -2571,25 +2758,10 @@ var DefaultCodegen = class {
     const valueNode = roles?.patient ?? modifiers?.to ?? args[1];
     if (!targetNode || !valueNode) return null;
     const value = ctx.generateExpression(valueNode);
-    if (targetNode.type === "variable") {
-      const varNode = targetNode;
-      const name = varNode.name.startsWith(":") ? varNode.name.slice(1) : varNode.name;
-      const safeName = sanitizeIdentifier(name);
-      if (varNode.scope === "local") {
-        return {
-          code: `if (_ctx.locals.get('${safeName}') == null) _ctx.locals.set('${safeName}', ${value})`,
-          async: false,
-          sideEffects: true
-        };
-      }
-      if (varNode.scope === "global") {
-        ctx.requireHelper("globals");
-        return {
-          code: `if (_rt.globals.get('${safeName}') == null) _rt.globals.set('${safeName}', ${value})`,
-          async: false,
-          sideEffects: true
-        };
-      }
+    const store = variableStore(targetNode, ctx);
+    if (store) {
+      const code = `if (${store.read} == null) ${store.write(value)}`;
+      return { code, async: false, sideEffects: true };
     }
     return null;
   }
@@ -2605,6 +2777,15 @@ var GoCodegen = class {
     if (mods?.back) {
       return { code: "history.back()", async: false, sideEffects: true };
     }
+    if (mods?.position || mods?.behavior) {
+      const element = roles?.destination ?? args[0];
+      if (!element) return null;
+      return {
+        code: `${ctx.generateExpression(element)}.scrollIntoView(${scrollOptions(mods)})`,
+        async: false,
+        sideEffects: true
+      };
+    }
     const target = mods?.url ?? roles?.destination ?? args[0];
     if (!target) return null;
     if (target.type === "identifier") {
@@ -2616,9 +2797,10 @@ var GoCodegen = class {
         return { code: "history.forward()", async: false, sideEffects: true };
       }
     }
-    const url = ctx.generateExpression(target);
+    ctx.requireHelper("go");
+    const newWindow = mods?.in !== void 0 ? ", true" : "";
     return {
-      code: `window.location.href = ${url}`,
+      code: `_rt.go(${ctx.generateExpression(target)}${newWindow})`,
       async: false,
       sideEffects: true
     };
@@ -2634,7 +2816,8 @@ var AppendCodegen = class {
     const contentNode = roles?.patient ?? args[0];
     if (!contentNode) return null;
     const content = ctx.generateExpression(contentNode);
-    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const targetNode = commandTarget(node, "to");
+    const target = targetNode ? ctx.generateExpression(targetNode) : "_ctx.me";
     return {
       code: `${target}.insertAdjacentHTML('beforeend', ${content})`,
       async: false,
@@ -3013,7 +3196,8 @@ var SettleCodegen = class {
     this.command = "settle";
   }
   generate(node, ctx) {
-    const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+    const targetNode = commandTarget(node, "arg");
+    const target = targetNode ? ctx.generateExpression(targetNode) : "_ctx.me";
     const mods = node.modifiers;
     const timeoutNode = mods?.for;
     const timeout = timeoutNode ? ctx.generateExpression(timeoutNode) : "5000";
@@ -3133,6 +3317,7 @@ var commandCodegens = /* @__PURE__ */ new Map([
   ["put", new PutCodegen()],
   ["show", new ShowCodegen()],
   ["hide", new HideCodegen()],
+  ["empty", new EmptyCodegen()],
   ["focus", new FocusCodegen()],
   ["blur", new BlurCodegen()],
   ["log", new LogCodegen()],
@@ -3259,6 +3444,8 @@ var EventHandlerCodegen = class {
         return generateForEach(node, this.ctx, (nodes) => this.generateBody(nodes));
       case "while":
         return generateWhile(node, this.ctx, (nodes) => this.generateBody(nodes));
+      case "sequence":
+        return this.generateBody(node.commands);
       case "event": {
         const nested = node;
         return this.generateBody(nested.body ?? []);
@@ -4131,15 +4318,8 @@ var AOTCompiler = class {
    * Create a codegen context.
    */
   createCodegenContext(handlerId, analysis, options) {
-    const selectorCache = /* @__PURE__ */ new Map();
     const requiredHelpers = /* @__PURE__ */ new Set();
     let idCounter = 0;
-    for (const info of analysis.expressions.selectors) {
-      if (info.canCache && info.usages.length > 1) {
-        const cacheKey = "_sel_" + sanitizeIdentifier(info.selector).slice(0, 20) + "_" + idCounter++;
-        selectorCache.set(info.selector, cacheKey);
-      }
-    }
     const exprCodegenRef = { current: null };
     const ctx = {
       handlerId,
@@ -4152,8 +4332,12 @@ var AOTCompiler = class {
       },
       implicitTarget: "_ctx.me",
       localVarDeclarations: "",
-      canCacheSelector: (selector) => selectorCache.has(selector),
-      getCachedSelector: (selector) => selectorCache.get(selector) ?? `document.querySelector('${selector}')`,
+      // A selector is queried each time it is evaluated, as on both engines. The
+      // cache named a variable nothing declared (`_sel__d1_0`: a handler naming
+      // #d1 twice threw), and a declared one goes stale when the handler
+      // replaces the element.
+      canCacheSelector: () => false,
+      getCachedSelector: (selector) => `document.querySelector('${selector}')`,
       requireHelper: (name) => {
         requiredHelpers.add(name);
       },
@@ -4223,7 +4407,7 @@ async function compileHyperscript(code, options) {
 async function createMultilingualCompiler() {
   const compiler = new AOTCompiler();
   try {
-    const { createCoreParserAdapter: createCoreParserAdapter2 } = await import("./core-parser-adapter-W5UPZR4X-B6CKOVA3.js");
+    const { createCoreParserAdapter: createCoreParserAdapter2 } = await import("./core-parser-adapter-W5UPZR4X-QSTMJ42V.js");
     compiler.setParser(await createCoreParserAdapter2());
   } catch {
   }
@@ -4276,4 +4460,4 @@ export {
   sanitizeSelector,
   scanFiles
 };
-//# sourceMappingURL=dist-WWPF6XTQ.js.map
+//# sourceMappingURL=dist-6EMM5HXE.js.map