@lokascript/compilation-service 2.2.0 → 2.3.0

package/dist/{chunk-PVQF6QYP.js → chunk-BHZMWRBA.js}

@@ -2768,7 +2768,7 @@ var CompilationService = class _CompilationService {
     initValidation({
       validateSemanticResult: semantic.validateSemanticResult
     });
-    const aot = await import("./dist-A6VWPCPB.js");
+    const aot = await import("./dist-CXRMMXI7.js");
     const compiler = aot.createCompiler();
     initBridge(
       {
@@ -3206,4 +3206,4 @@ export {
   SvelteRenderer,
   CompilationService
 };
-//# sourceMappingURL=chunk-PVQF6QYP.js.map
+//# sourceMappingURL=chunk-BHZMWRBA.js.map

package/dist/{chunk-ZQ3GX55O.js → chunk-BW34XOBT.js}

@@ -24,7 +24,7 @@ function convertCoreASTToAOT(node) {
   return node;
 }
 async function createCoreParserAdapter() {
-  const core = await import("./dist-CYO3JGTJ.js");
+  const core = await import("./dist-5S22WYM3.js");
   const api = core.hyperscript ?? core.default ?? core;
   if (!api?.compileSync) {
     throw new Error(
@@ -46,4 +46,4 @@ export {
   convertCoreASTToAOT,
   createCoreParserAdapter
 };
-//# sourceMappingURL=chunk-ZQ3GX55O.js.map
+//# sourceMappingURL=chunk-BW34XOBT.js.map

package/dist/{core-parser-adapter-VCJB52SO-7T2PARW4.js → core-parser-adapter-VCJB52SO-I5AIPWJQ.js}

@@ -2,11 +2,11 @@ import {
   CoreParserAdapter,
   convertCoreASTToAOT,
   createCoreParserAdapter
-} from "./chunk-ZQ3GX55O.js";
+} from "./chunk-BW34XOBT.js";
 import "./chunk-GBPMR66W.js";
 export {
   CoreParserAdapter,
   convertCoreASTToAOT,
   createCoreParserAdapter
 };
-//# sourceMappingURL=core-parser-adapter-VCJB52SO-7T2PARW4.js.map
+//# sourceMappingURL=core-parser-adapter-VCJB52SO-I5AIPWJQ.js.map

package/dist/{dist-CYO3JGTJ.js → dist-5S22WYM3.js}

@@ -440,7 +440,8 @@ function tokenize$1(input) {
       const isCommandContext = prevToken && prevToken.kind === TokenKind.IDENTIFIER && COMMANDS.has(prevToken.value.toLowerCase());
       const isKeywordContext = prevToken && prevToken.kind === TokenKind.IDENTIFIER && SELECTOR_CONTEXT_KEYWORDS.has(prevToken.value.toLowerCase());
       const isCSSSelectorContext = !prevToken || prevToken.kind === TokenKind.OPERATOR && prevToken.value !== ")" && prevToken.value !== "]" || isCommandContext || isKeywordContext || prevToken.value === "(" || prevToken.value === "[" || prevToken.value === "{" || prevToken.value === "," || prevToken.value === ";";
-      if (isCSSSelectorContext && isAlpha(peek(tokenizer))) {
+      const isAdjacentToPrev = prevToken && prevToken.end === tokenizer.position;
+      if (isCSSSelectorContext && !isAdjacentToPrev && (isAlpha(peek(tokenizer)) || peek(tokenizer) === "{")) {
         tokenizeCSSSelector(tokenizer);
         continue;
       }
@@ -656,6 +657,17 @@ function tokenizeCSSSelector(tokenizer) {
   const start = tokenizer.position;
   const prefix2 = advance(tokenizer);
   let value = prefix2;
+  if (tokenizer.position < tokenizer.input.length && tokenizer.input[tokenizer.position] === "{") {
+    value += advance(tokenizer);
+    while (tokenizer.position < tokenizer.input.length) {
+      const ch = tokenizer.input[tokenizer.position];
+      value += advance(tokenizer);
+      if (ch === "}")
+        break;
+    }
+    addToken(tokenizer, TokenKind.SELECTOR, value, start);
+    return;
+  }
   while (tokenizer.position < tokenizer.input.length) {
     const char = tokenizer.input[tokenizer.position];
     if (isAlphaNumeric(char) || char === "-" || char === "_" || char === ":") {
@@ -2238,31 +2250,14 @@ function parseTriggerCommand(ctx, identifierNode) {
       });
     }
   }
-  while (!isCommandBoundary(ctx)) {
-    allArgs.push(ctx.parsePrimary());
-  }
-  let operationIndex = -1;
-  let operationKeyword = "on";
-  for (let i = 0; i < allArgs.length; i++) {
-    const arg = allArgs[i];
-    const argRecord = arg;
-    const argValue = argRecord.name || argRecord.value;
-    if ((arg.type === "identifier" || arg.type === "literal" || arg.type === "keyword") && (argValue === "on" || argValue === "to")) {
-      operationIndex = i;
-      operationKeyword = argValue;
-      break;
+  const finalArgs = [...allArgs];
+  if (ctx.check("on") || ctx.check("to")) {
+    const keyword = ctx.advance().value;
+    finalArgs.push(ctx.createIdentifier(keyword));
+    while (!isCommandBoundary(ctx)) {
+      finalArgs.push(ctx.parsePrimary());
     }
   }
-  const finalArgs = [];
-  if (operationIndex === -1) {
-    finalArgs.push(...allArgs);
-  } else {
-    const eventArgs = allArgs.slice(0, operationIndex);
-    const targetArgs = allArgs.slice(operationIndex + 1);
-    finalArgs.push(...eventArgs);
-    finalArgs.push(ctx.createIdentifier(operationKeyword));
-    finalArgs.push(...targetArgs);
-  }
   return CommandNodeBuilder.fromIdentifier(identifierNode).withArgs(...finalArgs).endingAt(ctx.getPosition()).build();
 }
 function parseHaltCommand(ctx, identifierNode) {
@@ -2899,8 +2894,9 @@ function parseSwapCommand(ctx, identifierNode) {
 }
 function parseWaitCommand(ctx, commandToken) {
   const args = [];
-  if (ctx.checkTimeExpression() || ctx.checkLiteral()) {
-    const timeExpr = ctx.parsePrimary();
+  const isExpressionStart = ctx.checkTimeExpression() || ctx.checkLiteral() || ctx.checkContextVar() || ctx.check("(") || ctx.checkIdentifierLike() && !ctx.check("for") && !isCommandBoundary(ctx);
+  if (isExpressionStart) {
+    const timeExpr = ctx.parseExpression();
     args.push(timeExpr);
     return CommandNodeBuilder.from(commandToken).withArgs(...args).blocking().endingAt(ctx.getPosition()).build();
   }
@@ -3068,43 +3064,24 @@ function parsePropertyOfTarget(ctx, startPosition) {
     return null;
   const thePosition = ctx.savePosition();
   ctx.advance();
-  const nextToken = ctx.peek();
-  const tokenAfterNext = ctx.peekAt(1);
-  if (nextToken && tokenAfterNext && tokenAfterNext.value === KEYWORDS$1.OF) {
-    const propertyToken = ctx.advance();
-    if (ctx.check(KEYWORDS$1.OF)) {
-      ctx.advance();
-      const targetToken = ctx.advance();
-      const isIdSelector2 = targetToken.value.startsWith("#");
-      return {
-        type: "propertyOfExpression",
-        property: {
-          type: "identifier",
-          name: propertyToken.value,
-          start: propertyToken.start,
-          end: propertyToken.end
-        },
-        target: {
-          type: isIdSelector2 ? "idSelector" : "cssSelector",
-          value: targetToken.value,
-          start: targetToken.start,
-          end: targetToken.end
-        },
-        start: startPosition,
-        end: ctx.savePosition()
-      };
-    }
-    ctx.restorePosition(startPosition);
+  const propertyExpr = ctx.parseExpression();
+  if (!propertyExpr) {
+    ctx.restorePosition(thePosition);
     return null;
   }
-  if (nextToken && tokenAfterNext && tokenAfterNext.value === KEYWORDS$1.TO) {
-    const variableToken = ctx.advance();
-    return {
-      type: "identifier",
-      name: variableToken.value,
-      start: variableToken.start,
-      end: variableToken.end
-    };
+  const exprAny = propertyExpr;
+  if (exprAny.type === "binaryExpression" && exprAny.operator === KEYWORDS$1.OF) {
+    const property = exprAny.left;
+    const target = exprAny.right;
+    return createPropertyOfExpression(property, target, {
+      start: property.start ?? 0,
+      end: target.end ?? 0,
+      line: property.line ?? 1,
+      column: property.column ?? 1
+    });
+  }
+  if (ctx.check(KEYWORDS$1.TO)) {
+    return propertyExpr;
   }
   ctx.restorePosition(thePosition);
   return null;
@@ -3428,6 +3405,68 @@ function parseFetchNakedNamedArgs(ctx) {
     column: startPos.column
   };
 }
+function findJsEndBoundary(ctx, startPos) {
+  const input = ctx.getInputSlice(startPos);
+  if (!input) {
+    return startPos;
+  }
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i];
+    if (ch === "'" || ch === "\u2019" || ch === "\u2018") {
+      i++;
+      while (i < input.length && input[i] !== ch) {
+        if (input[i] === "\\")
+          i++;
+        i++;
+      }
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      i++;
+      while (i < input.length && input[i] !== '"') {
+        if (input[i] === "\\")
+          i++;
+        i++;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "`") {
+      i++;
+      while (i < input.length && input[i] !== "`") {
+        if (input[i] === "\\")
+          i++;
+        i++;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "/" && i + 1 < input.length && input[i + 1] === "/") {
+      i += 2;
+      while (i < input.length && input[i] !== "\n")
+        i++;
+      continue;
+    }
+    if (ch === "/" && i + 1 < input.length && input[i + 1] === "*") {
+      i += 2;
+      while (i < input.length && !(input[i] === "*" && i + 1 < input.length && input[i + 1] === "/"))
+        i++;
+      i += 2;
+      continue;
+    }
+    if ((ch === "e" || ch === "E") && i + 3 <= input.length && input.slice(i, i + 3).toLowerCase() === "end") {
+      const before = i === 0 || !/[a-zA-Z0-9_]/.test(input[i - 1]);
+      const after = i + 3 >= input.length || !/[a-zA-Z0-9_]/.test(input[i + 3]);
+      if (before && after) {
+        return startPos + i;
+      }
+    }
+    i++;
+  }
+  return startPos + input.length;
+}
 function parseJsCommand(ctx, identifierNode) {
   const parameters = [];
   if (ctx.match("(")) {
@@ -3440,11 +3479,12 @@ function parseJsCommand(ctx, identifierNode) {
     ctx.consume(")", "Expected ) after js parameters");
   }
   const jsCodeStart = ctx.peek().start;
-  while (!ctx.check(KEYWORDS$1.END) && !ctx.isAtEnd()) {
+  const jsCodeEnd = findJsEndBoundary(ctx, jsCodeStart);
+  while (!ctx.isAtEnd() && !ctx.check(KEYWORDS$1.END)) {
+    if (ctx.peek().start >= jsCodeEnd)
+      break;
     ctx.advance();
   }
-  const endToken = ctx.peek();
-  const jsCodeEnd = endToken.start;
   ctx.consume(KEYWORDS$1.END, "Expected end after js code body");
   const rawSlice = ctx.getInputSlice(jsCodeStart, jsCodeEnd);
   const code = rawSlice.trim();
@@ -4288,7 +4328,7 @@ var Parser = class _Parser {
             }
           } else {
             const commandName = expr.name.toLowerCase();
-            if (commandName === "wait" && this.checkTimeExpression()) {
+            if (commandName === "wait" && (this.checkTimeExpression() || this.checkNumber() || this.checkIdentifier() || this.checkContextVar() || this.check("("))) {
               const command2 = this.createCommandFromIdentifier(expr);
               if (command2) {
                 expr = command2;
@@ -5398,9 +5438,7 @@ var Parser = class _Parser {
     while (!this.isAtEnd() && !this.check("end")) {
       if (this.match("on")) {
         const handlerPos = this.getPosition();
-        const eventToken = this.peek();
-        const eventName = eventToken.value;
-        this.advance();
+        const eventName = this.parseEventNameWithNamespace("Expected event name after 'on'");
         const eventArgs = [];
         if (this.check("(")) {
           this.advance();
@@ -8092,6 +8130,8 @@ var BaseExpressionEvaluator = class {
         return this.evaluateIdSelector(node, context);
       case "attributeAccess":
         return this.evaluateAttributeAccess(node, context);
+      case "asExpression":
+        return this.evaluateAsExpression(node, context);
       default:
         throw new Error(`Unsupported AST node type for evaluation: ${node.type}`);
     }
@@ -8367,6 +8407,14 @@ var BaseExpressionEvaluator = class {
     }
     return `@${node.attributeName}`;
   }
+  async evaluateAsExpression(node, context) {
+    const value = await this.evaluate(node.expression, context);
+    const asExpr = this.expressionRegistry.get("as");
+    if (asExpr) {
+      return asExpr.evaluate(context, value, node.targetType);
+    }
+    throw new Error(`Conversion type 'as' not registered`);
+  }
   getAvailableExpressions() {
     return Array.from(this.expressionRegistry.keys());
   }
@@ -13744,6 +13792,8 @@ var RuntimeBase = class _RuntimeBase {
     this.behaviorAPI = {
       has: (name) => this.behaviorRegistry.has(name),
       get: (name) => this.behaviorRegistry.get(name),
+      set: (name, definition) => this.behaviorRegistry.set(name, definition),
+      resolve: null,
       install: async (behaviorName, element, parameters) => {
         return await this.installBehaviorOnElement(behaviorName, element, parameters);
       }
@@ -14207,9 +14257,14 @@ var RuntimeBase = class _RuntimeBase {
   }
   async installBehaviorOnElement(behaviorName, element, parameters) {
     debug.runtime(`BEHAVIOR: installBehaviorOnElement called: ${behaviorName}`);
-    const behavior = this.behaviorRegistry.get(behaviorName);
-    if (!behavior)
-      throw new Error(`Behavior "${behaviorName}" not found`);
+    let behavior = this.behaviorRegistry.get(behaviorName);
+    if (!behavior) {
+      if (this.behaviorAPI.resolve && this.behaviorAPI.resolve(behaviorName)) {
+        behavior = this.behaviorRegistry.get(behaviorName);
+      }
+      if (!behavior)
+        throw new Error(`Behavior "${behaviorName}" not found`);
+    }
     if (behavior.type === "imperative" && typeof behavior.install === "function") {
       debug.runtime(`BEHAVIOR: Installing imperative behavior '${behaviorName}'`);
       behavior.install(element, parameters);
@@ -19287,7 +19342,9 @@ var SetCommand = (() => {
         return { type: "property", element: firstValue[0], property: "textContent", value: value2 };
       }
       if (typeof firstValue !== "string") {
-        throw new Error("set command target must be a string or object literal");
+        const isMember = firstArg?.type === "memberExpression" || firstArg?.type === "propertyAccess";
+        const hint = isMember ? ` (a property chain evaluated to ${firstValue === null ? "null" : typeof firstValue} \u2014 check that all intermediate objects exist)` : "";
+        throw new Error(`set command target must be a string or object literal${hint}`);
       }
       const value = await this.extractValue(raw, evaluator, context);
       return { type: "variable", name: firstValue, value };
@@ -22342,12 +22399,18 @@ var InstallCommand = class _InstallCommand {
     const behaviorRegistry = context.locals.get("_behaviors");
     if (behaviorRegistry && typeof behaviorRegistry === "object") {
       const registry = behaviorRegistry;
-      return registry.has(behaviorName);
+      if (registry.has(behaviorName))
+        return true;
+      if (registry.resolve && registry.resolve(behaviorName))
+        return true;
     }
     if (typeof globalThis !== "undefined") {
       const hyperscriptGlobal = globalThis._hyperscript;
       if (hyperscriptGlobal?.behaviors) {
-        return hyperscriptGlobal.behaviors.has(behaviorName);
+        if (hyperscriptGlobal.behaviors.has(behaviorName))
+          return true;
+        if (hyperscriptGlobal.behaviors.resolve && hyperscriptGlobal.behaviors.resolve(behaviorName))
+          return true;
       }
     }
     return false;
@@ -74673,4 +74736,4 @@ export {
   toCoreAST,
   validatePartialContent
 };
-//# sourceMappingURL=dist-CYO3JGTJ.js.map
+//# sourceMappingURL=dist-5S22WYM3.js.map