@lokascript/compilation-service 2.2.1 → 2.3.1

package/dist/http.cjs

@@ -171,7 +171,7 @@ function tokenize$1(input) {
       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 === ";";
       const isAdjacentToPrev = prevToken && prevToken.end === tokenizer.position;
-      if (isCSSSelectorContext && !isAdjacentToPrev && isAlpha(peek(tokenizer))) {
+      if (isCSSSelectorContext && !isAdjacentToPrev && (isAlpha(peek(tokenizer)) || peek(tokenizer) === "{")) {
         tokenizeCSSSelector(tokenizer);
         continue;
       }
@@ -387,6 +387,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 === ":") {
@@ -1263,31 +1274,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) {
@@ -1915,8 +1909,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();
   }
@@ -2084,43 +2079,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;
@@ -2444,6 +2420,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("(")) {
@@ -2456,11 +2494,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();
@@ -25443,7 +25482,7 @@ var init_dist = __esm({
                 }
               } 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;
@@ -26553,9 +26592,7 @@ var init_dist = __esm({
         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();
@@ -28398,6 +28435,8 @@ var init_dist = __esm({
             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}`);
         }
@@ -28673,6 +28712,14 @@ var init_dist = __esm({
         }
         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());
       }
@@ -33172,6 +33219,8 @@ var init_dist = __esm({
         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);
           }
@@ -33635,9 +33684,14 @@ var init_dist = __esm({
       }
       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);
@@ -34762,11 +34816,28 @@ var init_dist = __esm({
               const obj = targetArg.object, prop = targetArg.property;
               if (obj?.type === "selector")
                 targetSelector = obj.value;
-              else if (obj?.type === "identifier")
-                targetSelector = obj.name;
+              else if (obj?.type === "identifier") {
+                const objName = obj.name;
+                if (objName === "my" || objName === "me" || objName === "I") {
+                  if (context.me && prop?.name) {
+                    return {
+                      value,
+                      targets: [context.me],
+                      position: "replace",
+                      memberPath: prop.name
+                    };
+                  }
+                } else if (objName === "its" || objName === "it") {
+                  const ev = await evaluator.evaluate(targetArg, context);
+                  if (typeof ev === "string")
+                    targetSelector = ev;
+                } else {
+                  targetSelector = objName;
+                }
+              }
               if (targetSelector && prop?.name)
                 memberPath = prop.name;
-              else {
+              else if (!targetSelector && !memberPath) {
                 const ev = await evaluator.evaluate(targetArg, context);
                 if (typeof ev === "string")
                   targetSelector = ev;
@@ -36485,7 +36556,9 @@ var init_dist = __esm({
             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 };
@@ -39250,12 +39323,18 @@ var init_dist = __esm({
         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;