@lango-project/lango-js 0.1.1 → 0.1.3

package/src/compiler.mjs

@@ -32,7 +32,8 @@ export function formatDiagnostics(error) {
 
 export async function buildFile(inputPath, outputPath, seen = new Set(), includeTests = false, profile = {}) {
   const decimalProfile = validateDecimalProfile(profile);
-  if (seen.size === 0)
+  const isEntryPoint = seen.size === 0;
+  if (isEntryPoint)
     await validateModuleInitializerCycles(inputPath, outputPath);
   if (seen.has(inputPath)) return;
   seen.add(inputPath);
@@ -86,10 +87,19 @@ export async function buildFile(inputPath, outputPath, seen = new Set(), include
   }
 
   const compiled = compile(source, inputPath, imports, includeTests, decimalProfile);
-  const output = compiled.javascript.replace(
+  let output = compiled.javascript.replace(
     "//# sourceMappingURL=main.mjs.map",
     `//# sourceMappingURL=${path.basename(outputPath)}.map`,
   );
+  if (isEntryPoint && profile.executable) {
+    const main = compiled.program.functions.find((item) => item.name === "main" && item.exported);
+    if (!main)
+      throw new LangoError("LNG1265", 1, "an executable build requires export main(args)", inputPath);
+    output = output.replace(
+      `//# sourceMappingURL=${path.basename(outputPath)}.map`,
+      `const { configure } = await import("./.lango/runtime.mjs");\nconfigure({ output: (value) => console.log(value) });\nawait main(process.argv.slice(2));\n//# sourceMappingURL=${path.basename(outputPath)}.map`,
+    );
+  }
   const directory = path.dirname(outputPath);
 
   await mkdir(path.join(directory, ".lango"), { recursive: true });
@@ -111,6 +121,19 @@ export async function buildFile(inputPath, outputPath, seen = new Set(), include
     await readFile(new URL("./vendor/bignumber.mjs", import.meta.url), "utf8"),
     "utf8",
   );
+  const xmlVendor = new URL("./vendor/xmldom/", import.meta.url);
+  await mkdir(path.join(directory, ".lango/xmldom"), { recursive: true });
+  for (const name of ["conventions.js", "dom-parser.js", "dom.js", "entities.js", "errors.js", "grammar.js", "index.js", "sax.js"])
+    await writeFile(
+      path.join(directory, ".lango/xmldom", name),
+      await readFile(new URL(name, xmlVendor), "utf8"),
+      "utf8",
+    );
+  await writeFile(
+    path.join(directory, ".lango/xmldom.LICENSE.md"),
+    await readFile(new URL("./vendor/xmldom.LICENSE.md", import.meta.url), "utf8"),
+    "utf8",
+  );
 }
 
 export function compile(source, sourceName = "<source>", imports = [], includeTests = false, profile = {}) {
@@ -231,7 +254,7 @@ function formatLine(line) {
 
 class Parser {
   constructor(source, name) {
-    this.lines = source.split(/\r?\n/).map((line) => stripComment(line).trimEnd());
+    this.lines = normalizeKebabIdentifiers(source).split(/\r?\n/).map((line) => stripComment(line).trimEnd());
     this.name = name;
     this.i = 0;
   }
@@ -243,7 +266,6 @@ class Parser {
     const tests = [];
     const jsImports = [];
     let declarationSeen = false;
-    let exportedClassSeen = false;
     this.blank();
     while (this.i < this.lines.length) {
       const line = this.line();
@@ -293,9 +315,6 @@ class Parser {
         );
       if (classHeader) {
         declarationSeen = true;
-        if (classHeader[1] && exportedClassSeen)
-          this.fail(line, "LNG1114", "a file may export one class");
-        exportedClassSeen ||= Boolean(classHeader[1]);
         const classNode = {
           name: classHeader[2],
           ancestor: classHeader[3] ?? null,
@@ -518,7 +537,16 @@ class Parser {
           `expected ${indent} spaces`,
         );
       const line = this.line();
-      const text = line.text.slice(indent);
+      const initialText = line.text.slice(indent);
+      const text = /^([A-Za-z_]\w*) = \{$/.test(initialText)
+        ? initialText
+        : this.continuedStatement(initialText, line, indent);
+      if (text === "else")
+        this.fail(
+          line,
+          "LNG1259",
+          "else must be indented 2 spaces more than its if",
+        );
       if (text.startsWith("assert ")) {
         body.push({
           type: "assert",
@@ -540,7 +568,16 @@ class Parser {
         this.blank();
         let elseBody = null;
         if (this.peek() === `${" ".repeat(indent + 2)}else`) {
+          const elseLine = { text: this.peek(), number: this.i + 1 };
           this.i += 1;
+          this.blank();
+          const elseStart = this.peek();
+          if (!elseStart || spaces(elseStart) !== indent + 6)
+            this.fail(
+              elseStart ? { text: elseStart, number: this.i + 1 } : elseLine,
+              "LNG1260",
+              "else body must be indented 4 spaces more than else",
+            );
           elseBody = this.block(indent + 6);
         }
         body.push({
@@ -739,7 +776,80 @@ class Parser {
         });
       else if (/^[A-Za-z_]\w*\+\+$/.test(text))
         body.push({ type: "increment", name: text.slice(0, -2) });
-      else if (/^(.+)\.([A-Za-z_]\w*)\(\(([^)]*)\)$/.test(text)) {
+      else if (/^(\$?[A-Za-z_]\w*) = new ([A-Za-z_]\w*(?:[./][A-Za-z_]\w*)*)\(\(([^)]*)\)$/.test(text)) {
+        const [, name, constructor, parameters] =
+          /^(\$?[A-Za-z_]\w*) = new ([A-Za-z_]\w*(?:[./][A-Za-z_]\w*)*)\(\(([^)]*)\)$/.exec(text);
+        const closure = {
+          type: "closure",
+          parameters: this.parameters(parameters, line),
+          captures: this.captures(),
+          line: line.number,
+          body: this.block(indent + 4),
+        };
+        this.blank();
+        if (this.peek() !== `${" ".repeat(indent)})`)
+          this.fail(line, "LNG1263", "constructor callback requires a closing parenthesis");
+        this.i += 1;
+        body.push({
+          type: "assign",
+          name,
+          value: { type: "new", name: constructor, arguments: [closure], line: line.number },
+        });
+      }
+      else if (!text.includes(" = ") && /^(.+)\.([A-Za-z_]\w*)\((.*), \(([^)]*)\)$/.test(text)) {
+        const [, receiver, name, argumentsText, parameters] =
+          /^(.+)\.([A-Za-z_]\w*)\((.*), \(([^)]*)\)$/.exec(text);
+        const closure = {
+          type: "closure",
+          parameters: this.parameters(parameters, line),
+          captures: this.captures(),
+          line: line.number,
+          body: this.block(indent + 4),
+        };
+        this.blank();
+        if (this.peek() !== `${" ".repeat(indent)})`)
+          this.fail(line, "LNG1264", "method callback requires a closing parenthesis");
+        this.i += 1;
+        body.push({
+          type: "expression",
+          value: {
+            type: "methodCall",
+            receiver,
+            optional: false,
+            name,
+            arguments: [...splitTopLevel(argumentsText).map((item) => expr(item, line, this)), closure],
+            line: line.number,
+          },
+        });
+      }
+      else if (/^(\$?[A-Za-z_]\w*) = (.+)\.([A-Za-z_]\w*)\((?:(.*), )?\(([^)]*)\)$/.test(text)) {
+        const [, name, receiver, method, argumentsText, parameters] =
+          /^(\$?[A-Za-z_]\w*) = (.+)\.([A-Za-z_]\w*)\((?:(.*), )?\(([^)]*)\)$/.exec(text);
+        const closure = {
+          type: "closure",
+          parameters: this.parameters(parameters, line),
+          captures: this.captures(),
+          line: line.number,
+          body: this.block(indent + 4),
+        };
+        this.blank();
+        if (this.peek() !== `${" ".repeat(indent)})`)
+          this.fail(line, "LNG1266", "assigned method callback requires a closing parenthesis");
+        this.i += 1;
+        body.push({
+          type: "assign",
+          name,
+          value: {
+            type: "methodCall",
+            receiver,
+            optional: false,
+            name: method,
+            arguments: [...(argumentsText ? splitTopLevel(argumentsText).map((item) => expr(item, line, this)) : []), closure],
+            line: line.number,
+          },
+        });
+      }
+      else if (!text.includes(" = ") && /^(.+)\.([A-Za-z_]\w*)\(\(([^)]*)\)$/.test(text)) {
         const [, first, name, parameters] = /^(.+)\.([A-Za-z_]\w*)\(\(([^)]*)\)$/.exec(text);
         const steps = [];
         let step = { name, parameters: this.parameters(parameters, line), captures: this.captures(), line: line.number, body: this.block(indent + 4) };
@@ -895,7 +1005,7 @@ class Parser {
           operator: suffix === "++" ? "+" : "-",
         });
       } else {
-        const assignment = /^(\$[A-Za-z_]\w*|@{0,2}\$?[A-Za-z_]\w*|[A-Za-z_]\w*\.\$?[A-Za-z_]\w*) = (.+)$/.exec(text);
+        const assignment = /^(\$[A-Za-z_]\w*|@{0,2}\$?[A-Za-z_]\w*|[A-Za-z_]\w*(?:\.\$?[A-Za-z_]\w*)+) = (.+)$/.exec(text);
         if (!assignment)
           this.fail(line, "LNG1106", `unsupported Faz 2 statement: ${text}`);
         body.push({
@@ -937,6 +1047,17 @@ class Parser {
       xml += `\n${this.lines[this.i++]}`;
     }
   }
+  continuedStatement(source, line, indent) {
+    let depth = curlyDelimiterDepth(source);
+    while (depth > 0) {
+      const next = this.peek();
+      if (next === undefined || spaces(next) < indent)
+        this.fail(line, "LNG1262", "unterminated multi-line expression");
+      source += ` ${this.line().text.trim()}`;
+      depth = curlyDelimiterDepth(source);
+    }
+    return source;
+  }
   captures() {
     if (!(this.peek() ?? "").trimStart().startsWith("capture ")) return [];
     const line = this.line();
@@ -1072,6 +1193,66 @@ function topLevelBinary(text, operators, rightAssociative = false) {
   return match;
 }
 
+function curlyDelimiterDepth(text) {
+  let quote = null;
+  let depth = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    if (quote !== null) {
+      if (character === "\\") { index += 1; continue; }
+      if (character === quote) quote = null;
+      continue;
+    }
+    if (character === "'" || character === '"') { quote = character; continue; }
+    if (character === "{") depth += 1;
+    if (character === "}") depth -= 1;
+  }
+  return depth;
+}
+
+const KEBAB_MARKER = "__lango_dash__";
+
+function normalizeKebabIdentifiers(source) {
+  let result = "";
+  let quote = null;
+  for (let index = 0; index < source.length; index += 1) {
+    const character = source[index];
+    if (quote !== null) {
+      result += character;
+      if (character === "\\") result += source[++index] ?? "";
+      else if (character === quote) quote = null;
+      continue;
+    }
+    if (character === "'" || character === '"') { quote = character; result += character; continue; }
+    const match = /^[A-Za-z_]\w*(?:-[A-Za-z_]\w*)+/.exec(source.slice(index));
+    if (match) {
+      result += match[0].replaceAll("-", KEBAB_MARKER);
+      index += match[0].length - 1;
+      continue;
+    }
+    result += character;
+  }
+  return result;
+}
+
+function kebabName(name) {
+  return name.replaceAll(KEBAB_MARKER, "-");
+}
+
+function emitKebabMember(receiver, operator, name) {
+  return name.includes(KEBAB_MARKER)
+    ? `${receiver}${operator === "?." ? "?." : ""}[${JSON.stringify(kebabName(name))}]`
+    : `${receiver}${operator}${name}`;
+}
+
+function emitKebabPath(value) {
+  return value.replace(/(\?\.|\.)([A-Za-z_]\w*)/g, (all, operator, name) =>
+    name.includes(KEBAB_MARKER)
+      ? emitKebabMember("", operator, name)
+      : all,
+  );
+}
+
 function splitTopLevel(text, separator = ", ") {
   const parts = [];
   let start = 0;
@@ -1153,10 +1334,18 @@ function expr(source, line, parser) {
       }),
     };
   }
+  if (text.startsWith("not "))
+    return {
+      type: "unary",
+      operator: "not",
+      value: expr(text.slice(4), line, parser),
+    };
   for (const operators of [
     ["??"],
-    ["or", "||"],
-    ["and", "&&"],
+    ["or"],
+    ["and"],
+    ["||"],
+    ["&&"],
     ["==", "!="],
     [">=", "<=", ">", "<", "not in", "in"],
     ["+", "-"],
@@ -1179,12 +1368,6 @@ function expr(source, line, parser) {
       left: expr(text.slice(0, exponent.index), line, parser),
       right: expr(text.slice(exponent.index + exponent.operator.length + 2), line, parser),
     };
-  if (text.startsWith("not "))
-    return {
-      type: "unary",
-      operator: "not",
-      value: expr(text.slice(4), line, parser),
-    };
   if (/^-[^\s]/.test(text))
     return {
       type: "unary",
@@ -1200,6 +1383,13 @@ function expr(source, line, parser) {
   const localize = /^_\((.*)\)$/.exec(text);
   if (localize)
     return { type: "translate", literal: literal(localize[1], line, parser) };
+  const decimal = /^\$\((.*)\)$/.exec(text);
+  if (decimal) {
+    const arguments_ = decimal[1] === "" ? [] : splitTopLevel(decimal[1]);
+    if (arguments_.length !== 1)
+      parser.fail(line, "LNG1261", "$() requires exactly one value");
+    return { type: "decimal", value: expr(arguments_[0], line, parser) };
+  }
   const construct =
     /^new ([A-Za-z_]\w*(?:[./][A-Za-z_]\w*)*)\((.*)\)$/.exec(text);
   if (construct)
@@ -1313,6 +1503,17 @@ function expr(source, line, parser) {
         : [],
       line: line.number,
     };
+  const indexedCall = /^(.+)\[(.+)\]\((.*)\)$/.exec(text);
+  if (indexedCall)
+    return {
+      type: "indexedCall",
+      receiver: expr(indexedCall[1], line, parser),
+      index: expr(indexedCall[2], line, parser),
+      arguments: indexedCall[3]
+        ? splitTopLevel(indexedCall[3]).map((item) => expr(item, line, parser))
+        : [],
+      line: line.number,
+    };
   const methodCall =
     /^([A-Za-z_]\w*(?:(?:\.|\?\.)[A-Za-z_]\w*)*?)(\?\.|\.)([A-Za-z_]\w*)\((.*)\)$/.exec(
       text,
@@ -1618,12 +1819,15 @@ function validate(program, imports = []) {
     ["is_array", 1],
     ["range", [1, 2, 3]],
     ["to_js_number", 1],
+    ["import_module", 1],
+    ["xml2obj", 1],
     ["start_trans", 0], ["commit_trans", 0], ["rollback_trans", 0], ["trans_state", 0],
   ]);
   const hostFunctions = new Set(["fetch"]);
   const isDecimalValue = (value) =>
     value &&
-    ((value.type === "raw" && (value.value.startsWith("$") || value.value.includes(".$"))) ||
+    (value.type === "decimal" ||
+      (value.type === "raw" && (value.value.startsWith("$") || value.value.includes(".$"))) ||
       (value.type === "unary" &&
         value.operator === "negate" &&
         isDecimalValue(value.value)) ||
@@ -1635,6 +1839,21 @@ function validate(program, imports = []) {
         ((value.left.type === "raw" && value.left.value === "null" && isDecimalValue(value.right)) ||
           (value.right.type === "raw" && value.right.value === "null" && isDecimalValue(value.left)) ||
           (isDecimalValue(value.left) && isDecimalValue(value.right)))));
+  const decimalParameters = (fn) => {
+    const parameterNames = new Set(fn.parameters.map((parameter) => parameter.name));
+    const accepted = new Set();
+    const visit = (node) => {
+      if (!node || typeof node !== "object") return;
+      if (node.type === "decimal" && node.value?.type === "raw" && parameterNames.has(node.value.value))
+        accepted.add(node.value.value);
+      Object.values(node).forEach((child) => {
+        if (Array.isArray(child)) child.forEach(visit);
+        else visit(child);
+      });
+    };
+    visit(fn.body);
+    return accepted;
+  };
   const returns = (body, result = []) => {
     for (const node of body) {
       if (node.type === "return") result.push(node.value);
@@ -2057,11 +2276,13 @@ function validate(program, imports = []) {
         );
       if (target) {
         validateRequiredArguments(target, value, value.name);
+        const decimalArguments = decimalParameters(target);
         value.arguments.forEach((argument, index) => {
           const parameter = target.parameters[index];
           if (
             parameter &&
             !parameter.name.startsWith("$") &&
+            !decimalArguments.has(parameter.name) &&
             isDecimalValue(argument)
           )
             throw new LangoError(
@@ -2348,6 +2569,15 @@ function validate(program, imports = []) {
     return names;
   };
 
+  const contextBindings = (body, names = new Set()) => {
+    for (const node of body) {
+      if (node.type === "contextDeclare" || node.type === "contextSet") names.add(node.name);
+      if (node.type !== "closureAssign")
+        nestedBodies(node).forEach((child) => contextBindings(child, names));
+    }
+    return names;
+  };
+
   const globalDeclarations = (body, names = new Set()) => {
     for (const node of body) {
       if (node.type === "globalDeclare") names.add(node.name);
@@ -2403,9 +2633,14 @@ function validate(program, imports = []) {
     outerBindings,
     classScope = null,
     inheritedExpiredCatchBindings = new Set(),
+    outerContextBindings = new Set(),
   ) => {
     const available = new Set(outerBindings);
     const expiredCatchBindings = new Set(inheritedExpiredCatchBindings);
+    const availableContexts = new Set([
+      ...outerContextBindings,
+      ...contextBindings(body),
+    ]);
     for (const node of body) {
       const references = new Set();
       [node.value, node.condition, node.collection, node.arguments, node.tests].forEach((value) => {
@@ -2425,6 +2660,7 @@ function validate(program, imports = []) {
           new Set(available),
           classScope,
           expiredCatchBindings,
+          availableContexts,
         );
         const right = node.elseBody
           ? validateClosures(
@@ -2432,6 +2668,7 @@ function validate(program, imports = []) {
               new Set(available),
               classScope,
               expiredCatchBindings,
+              availableContexts,
             )
           : available;
         const exits = [];
@@ -2450,6 +2687,7 @@ function validate(program, imports = []) {
             new Set(available),
             classScope,
             expiredCatchBindings,
+            availableContexts,
             ),
           );
         if (!node.elseBody || reachesEnd(node.elseBody))
@@ -2460,6 +2698,7 @@ function validate(program, imports = []) {
                 new Set(available),
                 classScope,
                 expiredCatchBindings,
+                availableContexts,
                 )
               : new Set(available),
           );
@@ -2475,6 +2714,7 @@ function validate(program, imports = []) {
           new Set(available),
           classScope,
           expiredCatchBindings,
+          availableContexts,
         );
         if (reachesEnd(node.tryBody)) exits.push(tryExit);
         if (node.catchBody) {
@@ -2485,6 +2725,7 @@ function validate(program, imports = []) {
               new Set(
                 [...expiredCatchBindings].filter((name) => name !== node.catchName),
               ),
+              availableContexts,
           );
           if (reachesEnd(node.catchBody)) exits.push(catchExit);
         }
@@ -2498,6 +2739,7 @@ function validate(program, imports = []) {
               certain,
               classScope,
               new Set([...expiredCatchBindings, node.catchName].filter(Boolean)),
+              availableContexts,
             )
           : certain;
         if (!node.finallyBody || reachesEnd(node.finallyBody))
@@ -2511,6 +2753,7 @@ function validate(program, imports = []) {
           new Set([...available, node.item]),
           classScope,
           expiredCatchBindings,
+          availableContexts,
         );
         continue;
       }
@@ -2520,6 +2763,7 @@ function validate(program, imports = []) {
           new Set([...available, node.key, node.value]),
           classScope,
           expiredCatchBindings,
+          availableContexts,
         );
         continue;
       }
@@ -2535,6 +2779,7 @@ function validate(program, imports = []) {
             new Set(available),
             classScope,
             expiredCatchBindings,
+            availableContexts,
           );
         continue;
       }
@@ -2543,6 +2788,10 @@ function validate(program, imports = []) {
           ? node
           : node.type === "return" && node.value?.type === "closure"
             ? node.value
+            : node.type === "assign" && node.value?.type === "new" && node.value.arguments.length === 1 && node.value.arguments[0].type === "closure"
+              ? node.value.arguments[0]
+              : node.type === "expression" && node.value?.type === "methodCall" && node.value.arguments.at(-1)?.type === "closure"
+                ? node.value.arguments.at(-1)
             : null;
       if (closure) {
         const localBindings = new Set([
@@ -2562,9 +2811,14 @@ function validate(program, imports = []) {
           (name) =>
             !localBindings.has(name) &&
             !contextNames.has(name) &&
-            !globalNames.has(name),
+            !globalNames.has(name) &&
+            !standardFunctions.has(name) &&
+            !hostFunctions.has(name),
         );
         const captures = new Set(closure.captures);
+        const contextCaptures = new Set(
+          closure.captures.filter((name) => availableContexts.has(name)),
+        );
         for (const name of needed)
           if (!captures.has(name))
             throw new LangoError(
@@ -2573,7 +2827,7 @@ function validate(program, imports = []) {
               `MissingCapture: ${name}; add capture ${name}`,
             );
         for (const name of captures) {
-          if (!needed.includes(name))
+          if (!needed.includes(name) && !contextCaptures.has(name))
             throw new LangoError(
               "LNG1211",
               closure.line,
@@ -2581,7 +2835,7 @@ function validate(program, imports = []) {
             );
           const protectedMember = Boolean(classScope && name.startsWith("_"));
           const propertyCapture = name.startsWith("@") || protectedMember;
-          if (!propertyCapture && !available.has(name))
+          if (!propertyCapture && !contextCaptures.has(name) && !available.has(name))
             throw new LangoError(
               "LNG1212",
               closure.line,
@@ -2614,8 +2868,9 @@ function validate(program, imports = []) {
           new Set([...available, ...localBindings]),
           classScope,
           expiredCatchBindings,
+          new Set([...availableContexts, ...contextCaptures]),
         );
-      if (node.type === "closureAssign") available.add(node.name);
+      if (node.type === "closureAssign" || node.type === "assign") available.add(node.name);
         continue;
       }
       if (node.type === "assign" && !node.name.startsWith("@"))
@@ -3163,6 +3418,7 @@ function emit(program, moduleImports = [], includeTests = false) {
     flags.print && "println as __println",
     flags.translate && "translate as __translate",
     flags.xml && "xmlEscape as __xmlEscape",
+    flags.xmlObject && "xml2obj as __xml2obj",
     flags.context && "contextGet as __contextGet",
     flags.context && "contextSet as __contextSet",
     flags.context && "contextRestore as __contextRestore",
@@ -3192,6 +3448,7 @@ function emit(program, moduleImports = [], includeTests = false) {
     flags.finite && "finite as __finite",
     flags.number && "requireNumber as __requireNumber",
     flags.call && "call as __call",
+    flags.callMethod && "callMethod as __callMethod",
     flags.boundary && "boundary as __boundary",
     flags.database && "startTrans as __startTrans",
     flags.database && "commitTrans as __commitTrans",
@@ -3442,6 +3699,7 @@ function collectEmitLocals(body, names = new Set(), nested = false) {
 }
 function emitDecimalExpression(node, flags) {
   const operand = (value) => {
+    if (value.type === "decimal") return emitExpr(value, flags);
     if (value.type === "binary" && ["+", "-", "*", "/", "%", "**"].includes(value.operator))
       return emitDecimalExpression(value, flags);
     if (value.type === "raw" && /^\d+(?:\.\d+)?$/.test(value.value)) {
@@ -3497,7 +3755,7 @@ function emitStatement(node, depth, declared, flags) {
   if (node.type === "assign") {
     const decimalBinding = node.name.startsWith("$") || /^@{1,2}\$/.test(node.name);
     const property = node.name.slice(node.name.startsWith("@@") ? 2 : 1);
-    const target = /^[A-Za-z_]\w*\.\$?[A-Za-z_]\w*$/.test(node.name)
+    const target = /^[A-Za-z_]\w*(?:\.\$?[A-Za-z_]\w*)+$/.test(node.name)
       ? node.name
       : node.name.startsWith("@@")
       ? `${flags.className}.${property}`
@@ -3509,7 +3767,7 @@ function emitStatement(node, depth, declared, flags) {
           ? `this.${node.name}`
           : node.name;
     const prefix =
-      /^[A-Za-z_]\w*\.\$?[A-Za-z_]\w*$/.test(node.name)
+      /^[A-Za-z_]\w*(?:\.\$?[A-Za-z_]\w*)+$/.test(node.name)
         ? ""
         : node.name.startsWith("@") ||
       (flags.className && node.name.startsWith("_")) ||
@@ -3643,7 +3901,11 @@ function emitClosure(node, depth, flags) {
   const priorContextNames = flags.contextNames;
   const priorGlobalNames = flags.globalNames;
   const priorArrayBindings = flags.arrayBindings;
-  const contextNames = collectContextNames(node.body);
+  const contextCaptures = node.captures.filter((name) => priorContextNames?.has(name));
+  const contextNames = new Set([
+    ...collectContextNames(node.body),
+    ...contextCaptures,
+  ]);
   flags.contextNames = contextNames;
   flags.globalNames = collectGlobalNames(node.body);
   flags.arrayBindings = new Set();
@@ -3671,7 +3933,16 @@ function emitClosure(node, depth, flags) {
   if (!contextNames.size)
     return wrap(`(${parameters}) => {\n${boundary}${body}${pad}    return null;\n${pad}}`);
   flags.context = true;
-  return wrap(`(${parameters}) => {\n${pad}    const __contextScope = [];\n${pad}    try {\n${boundary}${body}${pad}        return null;\n${pad}    } finally {\n${pad}        __contextRestore(__contextScope);\n${pad}    }\n${pad}}`);
+  const capturedParameters = contextCaptures.map((_, index) => `__capturedContext${index}`);
+  const capturedValues = contextCaptures.map((name) => `__contextGet(${JSON.stringify(name)})`);
+  const capturedSetup = contextCaptures
+    .map((name, index) => `${pad}        __contextScope.push(__contextSet(${JSON.stringify(name)}, __capturedContext${index}));\n`)
+    .join("");
+  const callback = `(${parameters}) => {\n${pad}    const __contextScope = [];\n${pad}    try {\n${capturedSetup}${boundary}${body}${pad}        return null;\n${pad}    } finally {\n${pad}        __contextRestore(__contextScope);\n${pad}    }\n${pad}}`;
+  const wrappedCallback = contextCaptures.length
+    ? `((${capturedParameters.join(", ")}) => ${callback})(${capturedValues.join(", ")})`
+    : callback;
+  return wrap(wrappedCallback);
 }
 function emitArityGuard(parameters, actual, name, depth, flags) {
   const positions = parameters
@@ -3695,11 +3966,18 @@ function emitBoundaryChecks(parameters, depth, flags) {
     })
     .join("");
 }
+function emitReceiverName(name, flags) {
+  if (!flags.contextNames?.has(name)) return name;
+  flags.context = true;
+  return `__contextGet(${JSON.stringify(name)})`;
+}
+
 function emitExpr(node, flags) {
   const decimalRaw = (value) =>
     value?.type === "raw" &&
     (value.value.startsWith("$") || value.value.includes(".$"));
   const decimalValue = (value) =>
+    value?.type === "decimal" ||
     decimalRaw(value) ||
     (value?.type === "binary" && (decimalValue(value.left) || decimalValue(value.right))) ||
     (value?.type === "unary" && decimalValue(value.value));
@@ -3731,9 +4009,13 @@ function emitExpr(node, flags) {
           : normalize(`this.#${node.value.slice(1)}`)
         : flags.className && node.value.startsWith("_")
           ? normalize(`this.${node.value}`)
-          : (node.value.includes("?.") || /^(?:[A-Za-z_]\w*\.[A-Za-z_]\w*|[A-Za-z_]\w*\[(?:\d+|[A-Za-z_]\w*|['"][^'"]*['"])\])$/.test(node.value))
-            ? normalize(node.value)
-            : node.value;
+          : (node.value.includes("?.") || node.value.includes(KEBAB_MARKER) || /^(?:[A-Za-z_]\w*\.[A-Za-z_]\w*|[A-Za-z_]\w*\[(?:\d+|[A-Za-z_]\w*|['"][^'"]*['"])\])$/.test(node.value))
+            ? normalize(emitKebabPath(node.value))
+            : emitKebabPath(node.value);
+  if (node.type === "decimal") {
+    flags.decimal = true;
+    return `__decimal(${emitExpr(node.value, flags)})`;
+  }
   if (node.type === "sql") {
     flags.sql = true;
     const text = node.parts
@@ -3758,23 +4040,25 @@ function emitExpr(node, flags) {
     return `__finite(-${numericLiteral ? emitExpr(node.value, flags) : `__requireNumber(${emitExpr(node.value, flags)})`})`;
   }
   if (node.type === "new")
-    return `new ${node.name.replaceAll("/", ".")}(${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
+    return `new ${node.name.replaceAll("/", ".")}(${node.arguments.map((item) =>
+      item.type === "closure" ? emitClosure(item, 0, flags) : emitExpr(item, flags),
+    ).join(", ")})`;
   if (node.type === "superMethodCall")
     return `super.${node.name}(${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
   if (node.type === "index")
     return normalize(
-      `${typeof node.receiver === "string" ? node.receiver : emitExpr(node.receiver, flags)}${node.optional ? "?." : ""}[${emitExpr(node.index, flags)}]`,
+      `${typeof node.receiver === "string" ? emitReceiverName(node.receiver, flags) : emitExpr(node.receiver, flags)}${node.optional ? "?." : ""}[${emitExpr(node.index, flags)}]`,
     );
   if (node.type === "property")
     return normalize(
-      `${emitExpr(node.receiver, flags)}${node.optional ? "?." : "."}${node.name}`,
+      emitKebabMember(emitExpr(node.receiver, flags), node.optional ? "?." : ".", node.name),
     );
   if (node.type === "methodCall" || node.type === "namespaceMethodCall") {
     const namespace = node.type === "namespaceMethodCall";
     const sourceReceiver = namespace
       ? node.receiver.replaceAll("/", ".")
       : typeof node.receiver === "string"
-        ? node.receiver
+        ? emitReceiverName(node.receiver, flags)
         : emitExpr(node.receiver, flags);
     const type =
       sourceReceiver === flags.className ||
@@ -3793,7 +4077,9 @@ function emitExpr(node, flags) {
       flags.arrayBindings?.has(node.receiver)
         ? "push"
         : node.name;
-    const arguments_ = node.arguments.map((item) => emitExpr(item, flags)).join(", ");
+    const arguments_ = node.arguments.map((item) =>
+      item.type === "closure" ? emitClosure(item, 0, flags) : emitExpr(item, flags),
+    ).join(", ");
     const helperCall = (helper) => {
       const call = `${helper}(${receiver}${arguments_ ? `, ${arguments_}` : ""})`;
       if (!node.optional) return call;
@@ -3824,7 +4110,9 @@ function emitExpr(node, flags) {
       flags.insertAt = true;
       return helperCall("__insertAt");
     }
-    const call = `${receiver}${visibility === false ? ".#" : node.optional ? "?." : "."}${method}(${arguments_})`;
+    const call = visibility === false
+      ? `${receiver}.#${method}(${arguments_})`
+      : emitKebabMember(receiver, node.optional ? "?." : ".", method) + `(${arguments_})`;
     if (node.optional) return normalize(call);
     if (
       visibility === undefined &&
@@ -3840,7 +4128,8 @@ function emitExpr(node, flags) {
   if (node.type === "object")
     return `{ ${node.fields.map((item) => {
       const value = emitExpr(item.value, flags);
-      if (!item.key.startsWith("$")) return `${item.key}: ${value}`;
+      if (!item.key.startsWith("$"))
+        return `${item.key.includes(KEBAB_MARKER) ? JSON.stringify(kebabName(item.key)) : item.key}: ${value}`;
       flags.decimal = true;
       return `${JSON.stringify(item.key)}: __decimal(${item.value.type === "raw" ? JSON.stringify(item.value.value) : value})`;
     }).join(", ")} }`;
@@ -3912,6 +4201,14 @@ function emitExpr(node, flags) {
       flags.toJsNumber = true;
       return `__toJsNumber(${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
     }
+  if (node.type === "call")
+    if (node.name === "import_module")
+      return `import(${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
+  if (node.type === "call")
+    if (node.name === "xml2obj") {
+      flags.xmlObject = true;
+      return `__xml2obj(${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
+    }
   if (node.type === "call")
     if (node.name === "from_json" || node.name === "to_json") {
       flags.json = true;
@@ -3951,6 +4248,10 @@ function emitExpr(node, flags) {
       return `__call(${node.name}, ${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
     } else
       return `${node.name}(${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
+  if (node.type === "indexedCall") {
+    flags.callMethod = true;
+    return `__callMethod(${emitExpr(node.receiver, flags)}, ${emitExpr(node.index, flags)}, ${node.arguments.map((item) => emitExpr(item, flags)).join(", ")})`;
+  }
   if (node.type === "string") return emitString(node.literal, flags);
   if (node.type === "xml") {
     flags.xml = true;