@thigasdevelopment/luam 0.2.0 → 0.2.1

package/luam.mjs

@@ -212,7 +212,7 @@ var EXIT_DIAGNOSTICS = 1;
 var EXIT_USAGE = 2;
 
 // src/cli/usage.ts
-var VERSION = true ? "0.2.0" : "0.0.0-dev";
+var VERSION = true ? "0.2.1" : "0.0.0-dev";
 var USAGE = [
   "luam \u2014 the Luam compiler for Multi Theft Auto resources.",
   "",
@@ -279,7 +279,7 @@ function classify(raw) {
   return { value, kind: value.length > 0 && Number.isFinite(Number(value)) ? "number" : "string" };
 }
 function parseEnvFile(source) {
-  const entries = [];
+  const entries2 = [];
   const errors = [];
   source.split(/\r?\n/).forEach((raw, index) => {
     const trimmed = raw.trim();
@@ -293,9 +293,9 @@ function parseEnvFile(source) {
       return;
     }
     const { value, kind } = classify(match[2]);
-    entries.push({ key: match[1], value, kind, line: line2 });
+    entries2.push({ key: match[1], value, kind, line: line2 });
   });
-  return { entries, errors };
+  return { entries: entries2, errors };
 }
 function isSensitiveKey(key) {
   return SENSITIVE.test(key);
@@ -759,27 +759,27 @@ var PROCESS_GLOBAL = "process";
 var PROCESS_ENV = "process.env";
 var ENV_GLOBAL = "env";
 var VALUE_TYPES = { boolean: BOOLEAN, number: NUMBER, string: STRING };
-function envMembers(entries) {
+function envMembers(entries2) {
   const members = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
+  for (const entry of entries2) {
     members.set(entry.key, { name: entry.key, type: VALUE_TYPES[entry.kind] });
   }
   return [...members.values()].sort((left, right) => left.name.localeCompare(right.name));
 }
-function environmentDeclaration(entries, origin) {
-  const env = record(PROCESS_ENV, envMembers(entries), origin);
+function environmentDeclaration(entries2, origin) {
+  const env = record(PROCESS_ENV, envMembers(entries2), origin);
   const process2 = record(PROCESS_GLOBAL, [{ name: ENV_GLOBAL, type: env }], origin);
   return { name: PROCESS_GLOBAL, environment: "server", source: "project", type: process2 };
 }
-function envDeclaration(entries, origin) {
-  const env = record(ENV_GLOBAL, envMembers(entries), origin);
+function envDeclaration(entries2, origin) {
+  const env = record(ENV_GLOBAL, envMembers(entries2), origin);
   return { name: ENV_GLOBAL, environment: "server", source: "project", type: env };
 }
-function projectDeclarations(entries, origin) {
-  if (entries === null) {
+function projectDeclarations(entries2, origin) {
+  if (entries2 === null) {
     return EMPTY_PROJECT_DECLARATIONS;
   }
-  return { globals: [environmentDeclaration(entries, origin), envDeclaration(entries, origin)] };
+  return { globals: [environmentDeclaration(entries2, origin), envDeclaration(entries2, origin)] };
 }
 
 // ../compiler/src/checker/ambient.ts
@@ -792,9 +792,9 @@ function ambientFromRegistry(registry) {
     globals: registry.allGlobals()
   };
 }
-function withoutNames(entries, excluded) {
+function withoutNames(entries2, excluded) {
   const names = new Set(excluded.map((entry) => entry.name));
-  return entries.filter((entry) => !names.has(entry.name));
+  return entries2.filter((entry) => !names.has(entry.name));
 }
 function ownDeclarations(registry, ambient) {
   const all = ambientFromRegistry(registry);
@@ -6988,22 +6988,22 @@ function emitMethod(state, className, member) {
   return withSymbol(state, `${className}:${member.name}`, () => emitFunctionBody(state, [self, ...member.parameters], member.body, `${member.name} = function`));
 }
 function emitMembers(state, statement) {
-  const entries = [];
+  const entries2 = [];
   state.indent += 1;
   for (const member of statement.members) {
     if (member.kind === "class-method") {
-      entries.push(indentLine(state, `${markSource(state, member.position.line, `${statement.name}:${member.name}`)}${emitMethod(state, statement.name, member)}`));
+      entries2.push(indentLine(state, `${markSource(state, member.position.line, `${statement.name}:${member.name}`)}${emitMethod(state, statement.name, member)}`));
       continue;
     }
     if (member.value !== null) {
-      entries.push(indentLine(state, `${markSource(state, member.position.line, statement.name)}${member.name} = ${emitExpression(state, member.value)}`));
+      entries2.push(indentLine(state, `${markSource(state, member.position.line, statement.name)}${member.name} = ${emitExpression(state, member.value)}`));
     }
   }
   for (const generated of state.generatedMembers.get(statement) ?? []) {
-    entries.push(indentLine(state, `${markSource(state, generated.position.line, `${statement.name}:${generated.name}`)}${emitMethod(state, statement.name, generated)}`));
+    entries2.push(indentLine(state, `${markSource(state, generated.position.line, `${statement.name}:${generated.name}`)}${emitMethod(state, statement.name, generated)}`));
   }
   state.indent -= 1;
-  return entries;
+  return entries2;
 }
 function emitClassHeader(statement) {
   const name = emitString(statement.name);
@@ -7012,11 +7012,11 @@ function emitClassHeader(statement) {
 function emitClassDeclaration(state, statement) {
   requireHelper(state, "class");
   const header = emitClassHeader(statement);
-  const entries = emitMembers(state, statement);
-  if (entries.length === 0) {
+  const entries2 = emitMembers(state, statement);
+  if (entries2.length === 0) {
     return `${header} {}`;
   }
-  return [`${header} {`, entries.join(",\n"), indentLine(state, "}")].join("\n");
+  return [`${header} {`, entries2.join(",\n"), indentLine(state, "}")].join("\n");
 }
 function emitEnumDeclaration(state, statement) {
   if (!state.references.has(statement.name)) {
@@ -8809,8 +8809,8 @@ function attribute(name, value) {
 function textElement(name, value) {
   return `${INDENT2}<${name}>${escapeXml(value)}</${name}>`;
 }
-function section(text, entries) {
-  return entries.length === 0 ? [] : [`${INDENT2}<!-- ${text} -->`, ...entries];
+function section(text, entries2) {
+  return entries2.length === 0 ? [] : [`${INDENT2}<!-- ${text} -->`, ...entries2];
 }
 function infoElement(info) {
   const attributes = info.author === void 0 ? [] : [attribute("author", info.author)];
@@ -8949,16 +8949,16 @@ function createAmbientResolver(collected) {
   const visible = /* @__PURE__ */ new Map();
   const merged = /* @__PURE__ */ new Map();
   for (const environment of ALL_ENVIRONMENTS) {
-    const entries = collected.filter((entry) => canReference(environment, entry.environment) && !declaresNothing(entry.declarations));
-    visible.set(environment, entries);
-    merged.set(environment, mergeAmbient(entries.map((entry) => entry.declarations)));
+    const entries2 = collected.filter((entry) => canReference(environment, entry.environment) && !declaresNothing(entry.declarations));
+    visible.set(environment, entries2);
+    merged.set(environment, mergeAmbient(entries2.map((entry) => entry.declarations)));
   }
   return (entry) => {
     if (declaresNothing(entry.declarations)) {
       return merged.get(entry.environment) ?? EMPTY_AMBIENT;
     }
-    const entries = visible.get(entry.environment) ?? [];
-    return mergeAmbient(entries.filter((candidate) => candidate.path !== entry.path).map((candidate) => candidate.declarations));
+    const entries2 = visible.get(entry.environment) ?? [];
+    return mergeAmbient(entries2.filter((candidate) => candidate.path !== entry.path).map((candidate) => candidate.declarations));
   };
 }
 function compileModule(file, ambient, context) {
@@ -9245,12 +9245,12 @@ var MISSING_LOAD_ORDER = 'is listed in "loadOrder" but no source file or asset m
 function missingEntry(entry) {
   return { path: entry, diagnostic: createDiagnostic("project", "project-load-order-missing", `"${entry}" ${MISSING_LOAD_ORDER}`, FILE_START) };
 }
-function resolveLoadOrder(entries, scripts, assets) {
+function resolveLoadOrder(entries2, scripts, assets) {
   const byScript = new Map(scripts.map((script) => [normalizePath(script.source), script]));
   const byAsset = new Map(assets.map((asset) => [normalizePath(asset.source), asset]));
   const resolved = { scripts: [], assets: [], diagnostics: [] };
   const seen = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
+  for (const entry of entries2) {
     const path = normalizePath(entry).replace(/^\.\//, "");
     const script = byScript.get(path);
     const asset = byAsset.get(path);
@@ -9482,8 +9482,8 @@ function materialize(build, resource, includeMap) {
   const bundled = materializeBundles(resource, build.bundles, helperContent);
   return { ...build, scripts: bundled.scripts, map: includeMap ? bundled.map : null };
 }
-function diagnosticSources(files, entries) {
-  const paths = new Set(entries.map((entry) => entry.path));
+function diagnosticSources(files, entries2) {
+  const paths = new Set(entries2.map((entry) => entry.path));
   return new Map(files.filter((file) => paths.has(file.path)).map((file) => [file.path, file.source]));
 }
 function runCompile(root, config, options = {}) {
@@ -9644,13 +9644,13 @@ function isSearchable(name) {
   return !name.startsWith(".") && !SKIPPED_DIRECTORIES.has(name);
 }
 function collectResourceMaps(directory, found) {
-  let entries;
+  let entries2;
   try {
-    entries = readdirSync3(directory, { withFileTypes: true });
+    entries2 = readdirSync3(directory, { withFileTypes: true });
   } catch {
     return;
   }
-  for (const entry of entries) {
+  for (const entry of entries2) {
     const absolute = join3(directory, entry.name);
     if (entry.isDirectory()) {
       if (isSearchable(entry.name)) {
@@ -9995,9 +9995,9 @@ function pluralize(count, singular, plural = `${singular}s`) {
 var MAX_ENTRIES_PER_FILE = 10;
 var MAX_FILES = 10;
 var GUTTER_WIDTH = 6;
-function groupByFile(entries) {
+function groupByFile(entries2) {
   const groups = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
+  for (const entry of entries2) {
     const group = groups.get(entry.path);
     if (group === void 0) {
       groups.set(entry.path, [entry]);
@@ -10044,19 +10044,19 @@ function emit2(reporter, entry, block) {
   }
   reporter.rawWarn(block);
 }
-function reportGroup(reporter, path, entries, options) {
+function reportGroup(reporter, path, entries2, options) {
   const limit = options.maxPerFile ?? MAX_ENTRIES_PER_FILE;
   const source = options.sources.get(path);
   reporter.raw(reporter.style.paint("strong", path));
-  for (const entry of entries.slice(0, limit)) {
+  for (const entry of entries2.slice(0, limit)) {
     emit2(reporter, entry, entryBlock(reporter, entry, source));
   }
-  if (entries.length > limit) {
-    reporter.detail(`  ... and ${pluralize(entries.length - limit, "more diagnostic")} in this file.`);
+  if (entries2.length > limit) {
+    reporter.detail(`  ... and ${pluralize(entries2.length - limit, "more diagnostic")} in this file.`);
   }
 }
-function reportGroupedDiagnostics(reporter, entries, options) {
-  const groups = [...groupByFile(entries)];
+function reportGroupedDiagnostics(reporter, entries2, options) {
+  const groups = [...groupByFile(entries2)];
   const limit = options.maxFiles ?? MAX_FILES;
   for (const [path, group] of groups.slice(0, limit)) {
     reportGroup(reporter, path, group, options);
@@ -10072,9 +10072,9 @@ function formatFileDiagnostic(entry) {
   const location = `${path}:${diagnostic.position.line}:${diagnostic.position.column}`;
   return `${location} ${diagnostic.severity} ${diagnostic.code}: ${diagnostic.message}`;
 }
-function countFileDiagnostics(entries) {
-  const errors = entries.filter((entry) => entry.diagnostic.severity === "error").length;
-  return { errors, warnings: entries.length - errors };
+function countFileDiagnostics(entries2) {
+  const errors = entries2.filter((entry) => entry.diagnostic.severity === "error").length;
+  return { errors, warnings: entries2.length - errors };
 }
 function countCliDiagnostics(diagnostics) {
   const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
@@ -10090,8 +10090,8 @@ function reportCliDiagnostics(reporter, diagnostics) {
     reporter.warn(line2);
   }
 }
-function reportPlainFileDiagnostics(reporter, entries) {
-  for (const entry of entries) {
+function reportPlainFileDiagnostics(reporter, entries2) {
+  for (const entry of entries2) {
     const line2 = formatFileDiagnostic(entry);
     if (entry.diagnostic.severity === "error") {
       reporter.rawError(line2);
@@ -10100,12 +10100,12 @@ function reportPlainFileDiagnostics(reporter, entries) {
     reporter.rawWarn(line2);
   }
 }
-function reportFileDiagnostics(reporter, entries, sources) {
+function reportFileDiagnostics(reporter, entries2, sources) {
   if (!reporter.capability.interactive) {
-    reportPlainFileDiagnostics(reporter, entries);
+    reportPlainFileDiagnostics(reporter, entries2);
     return;
   }
-  reportGroupedDiagnostics(reporter, entries, { sources });
+  reportGroupedDiagnostics(reporter, entries2, { sources });
 }
 function formatCounts(counts) {
   return `${pluralize(counts.errors, "error")}, ${pluralize(counts.warnings, "warning")}`;
@@ -11002,11 +11002,11 @@ function readStringArray(source, field, diagnostics, scope = "") {
   if (!Array.isArray(value) || value.length === 0) {
     return report2(diagnostics, `${scope}${field}`, "a non-empty array of strings", value);
   }
-  const entries = value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
-  if (entries.length !== value.length) {
+  const entries2 = value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+  if (entries2.length !== value.length) {
     return report2(diagnostics, `${scope}${field}`, "a non-empty array of strings", value);
   }
-  return entries.map((entry) => entry.trim());
+  return entries2.map((entry) => entry.trim());
 }
 function readObject(source, field, diagnostics, scope = "") {
   const value = source[field];
@@ -11376,10 +11376,70 @@ function runTraceCommand(root, reporter, options) {
 }
 
 // src/editor/editor-service.ts
-import { spawnSync } from "node:child_process";
 import { mkdtempSync, rmSync, writeFileSync as writeFileSync5 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
+
+// src/editor/editor-command.ts
+import { spawnSync } from "node:child_process";
+import { statSync as statSync4 } from "node:fs";
+import { extname, isAbsolute as isAbsolute7, join as join5 } from "node:path";
+var WINDOWS_SEPARATOR = ";";
+var DEFAULT_EXTENSIONS = ".COM;.EXE;.BAT;.CMD";
+var SHELL_EXTENSIONS = /* @__PURE__ */ new Set([".bat", ".cmd"]);
+var SPAWN_OPTIONS = { encoding: "utf8", shell: false, windowsHide: true, maxBuffer: 1024 * 1024 };
+function entries(value) {
+  return value.split(WINDOWS_SEPARATOR).map((entry) => entry.trim().replace(/^"|"$/gu, "")).filter((entry) => entry.length > 0);
+}
+function present(path) {
+  try {
+    return statSync4(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function failure(error) {
+  return { pid: 0, output: [null, "", ""], stdout: "", stderr: "", status: null, signal: null, error };
+}
+function resolveWindowsCommand(command) {
+  const extensions = entries(process.env.PATHEXT ?? DEFAULT_EXTENSIONS);
+  const named2 = extname(command).toLowerCase();
+  const suffixes = named2 !== "" && extensions.some((entry) => entry.toLowerCase() === named2) ? [""] : extensions;
+  const rooted = isAbsolute7(command) || command.includes("/") || command.includes("\\");
+  const directories = rooted ? [""] : entries(process.env.PATH ?? process.env.Path ?? "");
+  for (const directory of directories) {
+    for (const suffix of suffixes) {
+      const path = directory === "" ? `${command}${suffix}` : join5(directory, `${command}${suffix}`);
+      if (present(path)) {
+        return path;
+      }
+    }
+  }
+  return null;
+}
+function buildInvocation(executable, args) {
+  if (!SHELL_EXTENSIONS.has(extname(executable).toLowerCase())) {
+    return { file: executable, args: [...args], verbatim: false };
+  }
+  const line2 = [executable, ...args].map((token) => `"${token}"`).join(" ");
+  return { file: process.env.COMSPEC ?? "cmd.exe", args: ["/d", "/s", "/c", `"${line2}"`], verbatim: true };
+}
+function runEditorCommand(command, args) {
+  if (process.platform !== "win32") {
+    return spawnSync(command, [...args], SPAWN_OPTIONS);
+  }
+  const executable = resolveWindowsCommand(command);
+  if (executable === null) {
+    return failure(new Error(`The command ${command} was not found on PATH.`));
+  }
+  if ([executable, ...args].some((token) => token.includes('"'))) {
+    return failure(new Error(`The command ${command} received an argument that cannot be quoted safely.`));
+  }
+  const invocation = buildInvocation(executable, args);
+  return spawnSync(invocation.file, invocation.args, { ...SPAWN_OPTIONS, windowsVerbatimArguments: invocation.verbatim });
+}
+
+// src/editor/editor-service.ts
 var EXTENSION_ID = "thigasdevelopment.luam";
 var SUPPORTED_EDITORS = [
   { id: "vscode", name: "Visual Studio Code", command: "code" },
@@ -11390,11 +11450,8 @@ var SUPPORTED_EDITORS = [
 ];
 var MAX_VSIX_BYTES = 50 * 1024 * 1024;
 var RELEASE_URL = `https://github.com/ThigasDevelopment/luam/releases/download/v${VERSION}/luam-${VERSION}.vsix`;
-function run(command, args) {
-  return spawnSync(command, [...args], { encoding: "utf8", shell: false, windowsHide: true, maxBuffer: 1024 * 1024 });
-}
 function succeeded(result) {
-  return result.error === void 0 && result.status === 0;
+  return (result.error === void 0 || result.error === null) && result.status === 0;
 }
 function trustedReleaseHost(url) {
   const host = new URL(url).hostname.toLowerCase();
@@ -11419,11 +11476,11 @@ async function downloadRelease() {
   return bytes;
 }
 function installVsix(editor, bytes) {
-  const directory = mkdtempSync(join5(tmpdir(), "luam-"));
-  const path = join5(directory, `luam-${VERSION}.vsix`);
+  const directory = mkdtempSync(join6(tmpdir(), "luam-"));
+  const path = join6(directory, `luam-${VERSION}.vsix`);
   try {
     writeFileSync5(path, bytes, { flag: "wx" });
-    const result = run(editor.command, ["--install-extension", path, "--force"]);
+    const result = runEditorCommand(editor.command, ["--install-extension", path, "--force"]);
     return succeeded(result) ? { source: "release", error: null } : { source: null, error: "The editor rejected the release VSIX." };
   } finally {
     rmSync(directory, { recursive: true, force: true });
@@ -11432,13 +11489,13 @@ function installVsix(editor, bytes) {
 function createEditorService() {
   let release = null;
   return {
-    detect: () => SUPPORTED_EDITORS.filter((editor) => succeeded(run(editor.command, ["--version"]))),
+    detect: () => SUPPORTED_EDITORS.filter((editor) => succeeded(runEditorCommand(editor.command, ["--version"]))),
     hasExtension: (editor) => {
-      const result = run(editor.command, ["--list-extensions"]);
+      const result = runEditorCommand(editor.command, ["--list-extensions"]);
       return succeeded(result) && result.stdout.split(/\r?\n/u).some((entry) => entry.trim().toLowerCase() === EXTENSION_ID);
     },
     install: async (editor) => {
-      const marketplace = run(editor.command, ["--install-extension", EXTENSION_ID, "--force"]);
+      const marketplace = runEditorCommand(editor.command, ["--install-extension", EXTENSION_ID, "--force"]);
       if (succeeded(marketplace)) {
         return { source: "marketplace", error: null };
       }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@thigasdevelopment/luam",
-    "version": "0.2.0",
+    "version": "0.2.1",
     "description": "The Luam compiler for Multi Theft Auto resources.",
     "keywords": [
         "mta",