@lokascript/compilation-service 2.9.1 → 2.9.3

package/dist/{chunk-54DRG7ML.js → chunk-DFBBRFZA.js}

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

package/dist/{chunk-TN7NTIUI.js → chunk-JTNX5Y3D.js}

@@ -2768,7 +2768,7 @@ var CompilationService = class _CompilationService {
     initValidation({
       validateSemanticResult: semantic.validateSemanticResult
     });
-    const aot = await import("./dist-3Y3WFOKC.js");
+    const aot = await import("./dist-2SCMFZ5O.js");
     const compiler = aot.createCompiler();
     initBridge(
       {
@@ -3326,4 +3326,4 @@ export {
   SvelteRenderer,
   CompilationService
 };
-//# sourceMappingURL=chunk-TN7NTIUI.js.map
+//# sourceMappingURL=chunk-JTNX5Y3D.js.map

package/dist/{core-parser-adapter-VCJB52SO-J6I45WLU.js → core-parser-adapter-VCJB52SO-EPO6NENW.js}

@@ -2,11 +2,11 @@ import {
   CoreParserAdapter,
   convertCoreASTToAOT,
   createCoreParserAdapter
-} from "./chunk-54DRG7ML.js";
+} from "./chunk-DFBBRFZA.js";
 import "./chunk-GBPMR66W.js";
 export {
   CoreParserAdapter,
   convertCoreASTToAOT,
   createCoreParserAdapter
 };
-//# sourceMappingURL=core-parser-adapter-VCJB52SO-J6I45WLU.js.map
+//# sourceMappingURL=core-parser-adapter-VCJB52SO-EPO6NENW.js.map

package/dist/{dist-3Y3WFOKC.js → dist-2SCMFZ5O.js}

@@ -1,7 +1,7 @@
 import {
   CoreParserAdapter,
   createCoreParserAdapter
-} from "./chunk-54DRG7ML.js";
+} from "./chunk-DFBBRFZA.js";
 import {
   SemanticParserAdapter,
   createSemanticAdapter
@@ -4217,7 +4217,7 @@ async function compileHyperscript(code, options) {
 async function createMultilingualCompiler() {
   const compiler = new AOTCompiler();
   try {
-    const { createCoreParserAdapter: createCoreParserAdapter2 } = await import("./core-parser-adapter-VCJB52SO-J6I45WLU.js");
+    const { createCoreParserAdapter: createCoreParserAdapter2 } = await import("./core-parser-adapter-VCJB52SO-EPO6NENW.js");
     compiler.setParser(await createCoreParserAdapter2());
   } catch {
   }
@@ -4270,4 +4270,4 @@ export {
   sanitizeSelector,
   scanFiles
 };
-//# sourceMappingURL=dist-3Y3WFOKC.js.map
+//# sourceMappingURL=dist-2SCMFZ5O.js.map

package/dist/{dist-MNOHSQR3.js → dist-RYFD45WA.js}

@@ -498,13 +498,13 @@ function tokenize$1(input) {
       continue;
     }
     if (char === "{") {
-      addToken(tokenizer, TokenKind.OPERATOR, "{");
       advance(tokenizer);
+      addToken(tokenizer, TokenKind.OPERATOR, "{");
       continue;
     }
     if (char === "}") {
-      addToken(tokenizer, TokenKind.OPERATOR, "}");
       advance(tokenizer);
+      addToken(tokenizer, TokenKind.OPERATOR, "}");
       continue;
     }
     if (char === "[") {
@@ -512,22 +512,22 @@ function tokenize$1(input) {
       const isEventCondition = prevToken && prevToken.kind === TokenKind.IDENTIFIER && DOM_EVENTS.has(prevToken.value) && tokenizer.tokens.length >= 2 && tokenizer.tokens[tokenizer.tokens.length - 2]?.value === "on";
       const isMemberAccess = prevToken && (prevToken.kind === TokenKind.IDENTIFIER || prevToken.value === ")" || prevToken.value === "]") && !isEventCondition;
       if (isMemberAccess) {
-        addToken(tokenizer, TokenKind.OPERATOR, "[");
         advance(tokenizer);
+        addToken(tokenizer, TokenKind.OPERATOR, "[");
       } else {
         if (isEventCondition) {
-          addToken(tokenizer, TokenKind.SYMBOL, "[");
           advance(tokenizer);
+          addToken(tokenizer, TokenKind.SYMBOL, "[");
         } else {
-          addToken(tokenizer, TokenKind.OPERATOR, "[");
           advance(tokenizer);
+          addToken(tokenizer, TokenKind.OPERATOR, "[");
         }
       }
       continue;
     }
     if (char === "]") {
-      addToken(tokenizer, TokenKind.OPERATOR, "]");
       advance(tokenizer);
+      addToken(tokenizer, TokenKind.OPERATOR, "]");
       continue;
     }
     if (char === "$") {
@@ -2825,7 +2825,6 @@ var MULTI_WORD_PATTERNS = [
     keywords: ["a", "an", "from", "called"],
     syntax: "make (a|an) <type> [from <args>] [called <name>]"
   },
-  { command: "send", keywords: ["to"], syntax: "send <event> to <target>" },
   { command: "throw", keywords: [], syntax: "throw <error>" }
 ];
 function getMultiWordPattern(commandName) {
@@ -3120,7 +3119,13 @@ function parseTriggerCommand(ctx, identifierNode) {
       finalArgs.push(ctx.createIdentifier(keyword));
       continue;
     }
-    finalArgs.push(ctx.parsePrimary());
+    const before = ctx.savePosition();
+    const expr = ctx.parsePrimary();
+    if (expr)
+      finalArgs.push(expr);
+    if (ctx.savePosition() === before) {
+      ctx.advance();
+    }
   }
   return CommandNodeBuilder.fromIdentifier(identifierNode).withArgs(...finalArgs).endingAt(ctx.getPosition()).build();
 }
@@ -3320,11 +3325,64 @@ function parseRepeatCommand(ctx, commandToken) {
   }
   return builder.endingAt(ctx.getPosition()).build();
 }
+function parseIfBranchCommands(ctx, stopAtElse) {
+  const commands = [];
+  const atTerminator = () => ctx.check(KEYWORDS$1.END) || stopAtElse && ctx.check(KEYWORDS$1.ELSE);
+  while (!ctx.isAtEnd() && !atTerminator()) {
+    if (isComment(ctx.peek())) {
+      ctx.advance();
+      continue;
+    }
+    if (!ctx.checkIsCommand() && !ctx.isCommand(ctx.peek().value))
+      break;
+    ctx.advance();
+    const cmd = ctx.parseCommand();
+    if (cmd) {
+      commands.push(cmd);
+    }
+    if (ctx.check(KEYWORDS$1.THEN) || ctx.check(KEYWORDS$1.AND) || ctx.check(",")) {
+      ctx.advance();
+    }
+  }
+  return commands;
+}
+var OPERAND_INTRODUCERS = /* @__PURE__ */ new Set([
+  "is",
+  "am",
+  "are",
+  "not",
+  "no",
+  "and",
+  "or",
+  "==",
+  "===",
+  "!=",
+  "!==",
+  "<",
+  ">",
+  "<=",
+  ">=",
+  "+",
+  "-",
+  "*",
+  "/",
+  "mod"
+]);
+function isBodyCommandStart(ctx, prevToken, token) {
+  if (prevToken === null) {
+    return false;
+  }
+  if (OPERAND_INTRODUCERS.has(prevToken.value?.toLowerCase?.() ?? "")) {
+    return false;
+  }
+  return ctx.checkIsCommand() || ctx.isCommand(token.value?.toLowerCase());
+}
 function parseIfCommand(ctx, commandToken) {
   const args = [];
   let hasThen = false;
   const savedPosForThen = ctx.savePosition();
   const maxThenLookahead = 500;
+  let prevForThen = null;
   for (let i = 0; i < maxThenLookahead && !ctx.isAtEnd(); i++) {
     const token = ctx.peek();
     if (token.value === KEYWORDS$1.THEN) {
@@ -3334,6 +3392,12 @@ function parseIfCommand(ctx, commandToken) {
     if (token.value === KEYWORDS$1.END || token.value === KEYWORDS$1.BEHAVIOR || token.value === KEYWORDS$1.DEF || token.value === KEYWORDS$1.ON) {
       break;
     }
+    if (token.line !== void 0 && token.line !== commandToken.line && isBodyCommandStart(ctx, prevForThen, token)) {
+      break;
+    }
+    if (!isComment(token)) {
+      prevForThen = token;
+    }
     ctx.advance();
   }
   ctx.restorePosition(savedPosForThen);
@@ -3342,9 +3406,14 @@ function parseIfCommand(ctx, commandToken) {
     const savedPosition = ctx.savePosition();
     const ifStatementLine = commandToken.line;
     const maxLookahead = 100;
+    let firstCommandOnIfLine = false;
+    let prevToken = null;
     while (!ctx.isAtEnd() && ctx.current - savedPosition < maxLookahead) {
       const token = ctx.peek();
       const tokenValue = token.value?.toLowerCase();
+      if (firstCommandOnIfLine && token.line !== void 0 && token.line !== ifStatementLine) {
+        break;
+      }
       if (tokenValue === KEYWORDS$1.BEHAVIOR || tokenValue === KEYWORDS$1.DEF || tokenValue === KEYWORDS$1.ON) {
         break;
       }
@@ -3354,11 +3423,15 @@ function parseIfCommand(ctx, commandToken) {
         }
         break;
       }
-      if (ctx.checkIsCommand() || ctx.isCommand(tokenValue)) {
+      if (isBodyCommandStart(ctx, prevToken, token)) {
         if (token.line !== void 0 && token.line !== ifStatementLine) {
           hasImplicitMultiLineEnd = true;
           break;
         }
+        firstCommandOnIfLine = true;
+      }
+      if (!isComment(token)) {
+        prevToken = token;
       }
       ctx.advance();
     }
@@ -3372,7 +3445,9 @@ function parseIfCommand(ctx, commandToken) {
     const conditionTokens = [];
     const maxIterations = 20;
     let iterations = 0;
-    while (!ctx.isAtEnd() && !ctx.checkIsCommand() && !ctx.isCommand(ctx.peek().value) && !ctx.check(KEYWORDS$1.THEN) && iterations < maxIterations) {
+    let firstConditionParse = true;
+    while (!ctx.isAtEnd() && !ctx.check(KEYWORDS$1.THEN) && (firstConditionParse || !ctx.checkIsCommand() && !ctx.isCommand(ctx.peek().value)) && iterations < maxIterations) {
+      firstConditionParse = false;
       const beforePos = ctx.savePosition();
       conditionTokens.push(ctx.parseLogicalAnd());
       if (ctx.savePosition() === beforePos) {
@@ -3397,21 +3472,8 @@ function parseIfCommand(ctx, commandToken) {
   }
   args.push(condition);
   if (isMultiLine) {
-    if (hasThen) {
-      ctx.advance();
-    }
-    const thenCommands = [];
-    while (!ctx.isAtEnd() && !ctx.check(KEYWORDS$1.ELSE) && !ctx.check(KEYWORDS$1.END)) {
-      if (ctx.checkIsCommand() || ctx.isCommand(ctx.peek().value)) {
-        ctx.advance();
-        const cmd = ctx.parseCommand();
-        if (cmd) {
-          thenCommands.push(cmd);
-        }
-      } else {
-        break;
-      }
-    }
+    consumeOptionalKeyword(ctx, KEYWORDS$1.THEN);
+    const thenCommands = parseIfBranchCommands(ctx, true);
     if (thenCommands.length === 0 && ctx.isAtEnd()) {
       throw new Error("Expected command after 'then' in if statement - incomplete conditional");
     }
@@ -3436,18 +3498,7 @@ function parseIfCommand(ctx, commandToken) {
         }));
         consumedElseIf = true;
       } else {
-        const elseCommands = [];
-        while (!ctx.isAtEnd() && !ctx.check(KEYWORDS$1.END)) {
-          if (ctx.checkIsCommand() || ctx.isCommand(ctx.peek().value)) {
-            ctx.advance();
-            const cmd = ctx.parseCommand();
-            if (cmd) {
-              elseCommands.push(cmd);
-            }
-          } else {
-            break;
-          }
-        }
+        const elseCommands = parseIfBranchCommands(ctx, false);
         args.push(createBlock(elseCommands, {
           start: commandToken.start,
           end: ctx.getPosition().end,
@@ -4177,21 +4228,6 @@ var GO_KEYWORDS = /* @__PURE__ */ new Set([
   "back",
   "forward"
 ]);
-var GO_URL_STOP = /* @__PURE__ */ new Set([
-  "in",
-  "then",
-  "and",
-  "else",
-  "end",
-  "otherwise",
-  "when",
-  "where",
-  "catch",
-  "finally"
-]);
-function isGoURLTerminator(ctx) {
-  return ctx.isAtEnd() || GO_URL_STOP.has(ctx.peek().value);
-}
 function stringNode(value, tok) {
   return {
     type: "string",
@@ -4213,7 +4249,7 @@ function parseGoCommand(ctx, identifierNode) {
       continue;
     }
     if (isNakedURLStart(ctx)) {
-      const url = parseBareURLPath(ctx, isGoURLTerminator);
+      const url = parseBareURLPath(ctx);
       if (url) {
         args.push(url);
         continue;
@@ -4336,12 +4372,6 @@ function parseMultiWordCommand(ctx, commandToken, commandName) {
   }
   return builder.build();
 }
-function isFetchURLTerminator(ctx) {
-  if (ctx.isAtEnd())
-    return true;
-  const val = ctx.peek().value;
-  return ["as", "with", "{", "then", "end", "else", "otherwise", ")"].includes(val) || isCommandBoundary(ctx);
-}
 function isNakedURLStart(ctx) {
   const tok = ctx.peek();
   if (tok.value === "/")
@@ -4352,23 +4382,50 @@ function isNakedURLStart(ctx) {
   }
   return false;
 }
-function parseBareURLPath(ctx, isTerminator = isFetchURLTerminator) {
+var URL_HARD_STOPS = /* @__PURE__ */ new Set(["{", ")"]);
+function parseBareURLPath(ctx) {
   const startPos = ctx.savePosition();
+  const firstTok = ctx.peek();
   let path = "";
-  while (!ctx.isAtEnd() && !isTerminator(ctx)) {
-    path += ctx.advance().value;
+  let prev = null;
+  while (!ctx.isAtEnd()) {
+    const tok = ctx.peek();
+    if (prev && tok.start !== prev.end)
+      break;
+    if (tok.value === "$" && ctx.peekAt(1)?.value === "{") {
+      ctx.advance();
+      let last = ctx.advance();
+      let depth = 1;
+      while (!ctx.isAtEnd() && depth > 0) {
+        last = ctx.advance();
+        if (last.value === "{")
+          depth++;
+        else if (last.value === "}")
+          depth--;
+      }
+      path += ctx.getInputSlice(tok.start, last.end);
+      prev = last;
+      continue;
+    }
+    if (URL_HARD_STOPS.has(tok.value))
+      break;
+    prev = ctx.advance();
+    path += prev.value;
   }
   if (!path || path === "/") {
     ctx.restorePosition(startPos);
     return null;
   }
-  return {
-    type: "literal",
-    value: path,
-    raw: path,
-    start: startPos,
-    end: ctx.savePosition()
+  const span = {
+    start: firstTok.start,
+    end: prev ? prev.end : firstTok.end,
+    line: firstTok.line,
+    column: firstTok.column
   };
+  if (path.includes("${")) {
+    return { type: "templateLiteral", value: path, ...span };
+  }
+  return { type: "literal", value: path, raw: path, ...span };
 }
 function parseFetchCommand(ctx, commandToken) {
   const modifiers = {};
@@ -4590,10 +4647,10 @@ function parseTellCommand(ctx, identifierNode) {
       } catch {
         break;
       }
-      if (ctx.match(KEYWORDS$1.AND)) {
+      if (ctx.match(KEYWORDS$1.AND) || ctx.match(KEYWORDS$1.THEN)) {
         continue;
       }
-      if (ctx.check(KEYWORDS$1.THEN) || ctx.check(KEYWORDS$1.ELSE) || ctx.check(KEYWORDS$1.END)) {
+      if (ctx.check(KEYWORDS$1.ELSE) || ctx.check(KEYWORDS$1.END)) {
         break;
       }
       if (ctx.checkIsCommand()) {
@@ -4768,6 +4825,7 @@ var Parser = class _Parser {
     const result = this.parseInternal();
     if (this.errors.length > 0) {
       result.errors = [...this.errors];
+      result.recovered = true;
     }
     return result;
   }
@@ -6611,6 +6669,9 @@ var Parser = class _Parser {
         this.advance();
         const cmd = this.parseCommand();
         commands.push(cmd);
+        if (this.match("then", "and", ",")) {
+          continue;
+        }
       } else {
         break;
       }
@@ -12251,6 +12312,25 @@ function isImplicitCommand(val) {
   return val !== null && typeof val === "object" && "command" in val && "selector" in val;
 }
 var eventRecursionDepth = /* @__PURE__ */ new WeakMap();
+function collectIdentifierNames(node, out = /* @__PURE__ */ new Set()) {
+  if (node === null || typeof node !== "object")
+    return out;
+  if (Array.isArray(node)) {
+    for (const item of node)
+      collectIdentifierNames(item, out);
+    return out;
+  }
+  const obj = node;
+  if (obj.type === "identifier" && typeof obj.name === "string") {
+    out.add(obj.name);
+  }
+  for (const key of Object.keys(obj)) {
+    if (key === "start" || key === "end" || key === "line" || key === "column")
+      continue;
+    collectIdentifierNames(obj[key], out);
+  }
+  return out;
+}
 var RuntimeBase = class _RuntimeBase {
   constructor(options) {
     this.autoCleanupObserver = null;
@@ -12440,6 +12520,9 @@ var RuntimeBase = class _RuntimeBase {
         case "behavior": {
           return await this.executeBehaviorDefinition(node, context);
         }
+        case "def": {
+          return this.installFunction(node, context);
+        }
         case "Program": {
           return await this.executeProgram(node, context);
         }
@@ -12649,22 +12732,69 @@ var RuntimeBase = class _RuntimeBase {
     };
     return this.processCommand(commandNode, context);
   }
+  installFunction(node, context) {
+    const runtime = this;
+    const params = node.params ?? [];
+    const body = node.body ?? [];
+    const errorHandler = node.errorHandler;
+    const finallyHandler = node.finallyHandler;
+    const errorSymbol = node.errorSymbol;
+    const fn = async (...args) => {
+      const fnContext = {
+        ...context,
+        locals: new Map(context.locals)
+      };
+      params.forEach((name, i) => {
+        if (name)
+          fnContext.locals.set(name, args[i]);
+      });
+      const run = async (commands) => {
+        const result = await runtime.executeCommandSequenceWithResult(commands, fnContext);
+        if (!isOk(result))
+          throw asControlFlowError(result.error);
+        return result.value;
+      };
+      if (!errorHandler && !finallyHandler) {
+        return await run(body);
+      }
+      try {
+        return await run(body);
+      } catch (e) {
+        if (!errorHandler || isControlFlowError(e))
+          throw e;
+        if (errorSymbol)
+          fnContext.locals.set(errorSymbol, e);
+        return await run(errorHandler);
+      } finally {
+        if (finallyHandler) {
+          await run(finallyHandler);
+        }
+      }
+    };
+    context.globals.set(node.name, fn);
+  }
   async executeProgram(node, context) {
     if (!node.statements || !Array.isArray(node.statements))
       return;
     let lastResult = void 0;
     const eventHandlers = [];
+    const defs = [];
     const initBlocks = [];
     const otherStatements = [];
     for (const statement of node.statements) {
       if (statement.type === "eventHandler") {
         eventHandlers.push(statement);
+      } else if (statement.type === "def") {
+        defs.push(statement);
       } else if (statement.type === "initBlock") {
         initBlocks.push(statement);
       } else {
         otherStatements.push(statement);
       }
     }
+    for (const def of defs) {
+      this.execute(def, context);
+    }
     for (const handler of eventHandlers) {
       try {
         await this.execute(handler, context);
@@ -12851,7 +12981,7 @@ var RuntimeBase = class _RuntimeBase {
     debug.runtime(`BEHAVIOR: Finished installing ${behaviorName}`);
   }
   async executeEventHandler(node, context) {
-    const { event, events, commands, target, args, selector, attributeName, watchTarget, modifiers, errorSymbol, errorHandler, finallyHandler } = node;
+    const { event, events, commands, target, args, selector, condition, attributeName, watchTarget, modifiers, errorSymbol, errorHandler, finallyHandler } = node;
     const eventNames = events && events.length > 0 ? events : [event];
     debug.runtime(`BEHAVIOR: executeEventHandler: event='${event}', target='${target}'`);
     let targets = [];
@@ -12925,7 +13055,8 @@ var RuntimeBase = class _RuntimeBase {
       }
       return;
     }
-    const baseEventHandler = _RuntimeBase.createEventHandler(this, commands, context, selector, args, { errorSymbol, errorHandler, finallyHandler });
+    const applicableCondition = eventNames.length === 1 ? condition : void 0;
+    const baseEventHandler = _RuntimeBase.createEventHandler(this, commands, context, selector, args, { errorSymbol, errorHandler, finallyHandler }, applicableCondition);
     let eventHandler;
     let debounceCleanup = null;
     if (modifiers) {
@@ -13023,7 +13154,7 @@ var RuntimeBase = class _RuntimeBase {
       }
     }
   }
-  static createEventHandler(runtime, commands, context, selector, args, errorBlocks) {
+  static createEventHandler(runtime, commands, context, selector, args, errorBlocks, condition) {
     return async (domEvent) => {
       const currentDepth = eventRecursionDepth.get(domEvent) ?? 0;
       if (currentDepth >= 100) {
@@ -13058,6 +13189,24 @@ var RuntimeBase = class _RuntimeBase {
           eventContext.locals.set(argName, value);
         }
       }
+      if (condition) {
+        const eventProps = domEvent;
+        for (const name of collectIdentifierNames(condition)) {
+          if (!eventContext.locals.has(name) && name in eventProps) {
+            eventContext.locals.set(name, eventProps[name]);
+          }
+        }
+        let filterResult;
+        try {
+          filterResult = await runtime.evaluateExpression(condition, eventContext);
+        } catch (e) {
+          debug.runtime(`Event filter threw; skipping handler body:`, e);
+          return;
+        }
+        if (!filterResult) {
+          return;
+        }
+      }
       const runCommands = async (toRun) => {
         for (const command2 of toRun) {
           try {
@@ -79084,9 +79233,11 @@ function compileSync(code, options) {
     const parseResult = parse$1(code, parserOptions);
     const timeMs = performance.now() - startTime;
     if (parseResult.success && parseResult.node) {
+      const recovered = parseResult.errors ?? [];
       const result = {
         ok: true,
         ast: parseResult.node,
+        ...recovered.length > 0 ? { errors: recovered.map(toCompileError) } : {},
         meta: {
           parser: usesSemanticParser ? "semantic" : "traditional",
           language: lang,
@@ -79205,9 +79356,10 @@ async function evalCode(code, context, options) {
 }
 async function validate(code, options) {
   const result = await compileAsync(code, options);
+  const errors = result.errors ?? [];
   return {
-    valid: result.ok,
-    errors: result.errors
+    valid: result.ok && errors.length === 0,
+    errors: errors.length > 0 ? errors : void 0
   };
 }
 function createContextWithParent(element, parent) {
@@ -86479,4 +86631,4 @@ export {
   toCoreAST,
   validatePartialContent
 };
-//# sourceMappingURL=dist-MNOHSQR3.js.map
+//# sourceMappingURL=dist-RYFD45WA.js.map