@defold-typescript/transpiler 0.24.0 → 0.26.0

package/dist/index.js

@@ -1,3 +1,257 @@
+// src/config-key-index.ts
+function sectionNameOf(line) {
+  const match = line.trim().match(/^\[(.+)\]$/);
+  return match?.[1];
+}
+function buildConfigKeyIndex(gameProjectText) {
+  const keys = new Set;
+  let section;
+  for (const line of gameProjectText.split(`
+`)) {
+    const header = sectionNameOf(line);
+    if (header !== undefined) {
+      section = header;
+      continue;
+    }
+    if (section === undefined)
+      continue;
+    const separator = line.indexOf("=");
+    if (separator === -1)
+      continue;
+    const key = line.slice(0, separator).trim();
+    if (key === "")
+      continue;
+    keys.add(`${section}.${key}`);
+  }
+  return keys;
+}
+// src/scene-text-format.ts
+class SceneTextFormatError extends Error {
+  line;
+  constructor(message, line) {
+    super(`${message} (line ${line})`);
+    this.name = "SceneTextFormatError";
+    this.line = line;
+  }
+}
+var IDENTIFIER_PART = /[A-Za-z0-9_]/;
+function append(target, key, value) {
+  const existing = target.get(key);
+  if (existing === undefined) {
+    target.set(key, [value]);
+    return;
+  }
+  existing.push(value);
+}
+function parseSceneTextFormat(text) {
+  let pos = 0;
+  let line = 1;
+  function fail(message, at) {
+    throw new SceneTextFormatError(message, at);
+  }
+  function advance() {
+    const ch = text.charAt(pos);
+    pos += 1;
+    if (ch === `
+`)
+      line += 1;
+    return ch;
+  }
+  function skipWhitespace() {
+    while (pos < text.length) {
+      const ch = text.charAt(pos);
+      if (ch !== " " && ch !== "\t" && ch !== "\r" && ch !== `
+`)
+        return;
+      advance();
+    }
+  }
+  function skipInlineWhitespace() {
+    while (pos < text.length) {
+      const ch = text.charAt(pos);
+      if (ch !== " " && ch !== "\t")
+        return;
+      pos += 1;
+    }
+  }
+  function readIdentifier(at) {
+    const start = pos;
+    while (pos < text.length && IDENTIFIER_PART.test(text.charAt(pos))) {
+      pos += 1;
+    }
+    if (pos === start) {
+      fail(`unexpected \`${text.charAt(start)}\``, at);
+    }
+    return text.slice(start, pos);
+  }
+  function readQuotedScalar() {
+    let value = "";
+    for (;; ) {
+      const openedAt = line;
+      advance();
+      let closed = false;
+      while (pos < text.length) {
+        const ch = advance();
+        if (ch === "\\") {
+          if (pos >= text.length)
+            break;
+          const escaped = advance();
+          if (escaped === '"')
+            value += '"';
+          else if (escaped === "\\")
+            value += "\\";
+          else if (escaped === "n")
+            value += `
+`;
+          else if (escaped === "r")
+            value += "\r";
+          else if (escaped === "t")
+            value += "\t";
+          else
+            value += `\\${escaped}`;
+          continue;
+        }
+        if (ch === '"') {
+          closed = true;
+          break;
+        }
+        if (ch === `
+`)
+          break;
+        value += ch;
+      }
+      if (!closed) {
+        fail("unterminated string literal", openedAt);
+      }
+      const resumePos = pos;
+      const resumeLine = line;
+      skipWhitespace();
+      if (text.charAt(pos) === '"') {
+        continue;
+      }
+      pos = resumePos;
+      line = resumeLine;
+      return value;
+    }
+  }
+  function readUnquotedScalar() {
+    const newline = text.indexOf(`
+`, pos);
+    const end = newline === -1 ? text.length : newline;
+    const raw = text.slice(pos, end);
+    pos = end;
+    return raw.trim();
+  }
+  function parseBody(nested, openedAt) {
+    const fields = new Map;
+    const messages = new Map;
+    for (;; ) {
+      skipWhitespace();
+      if (pos >= text.length) {
+        if (nested) {
+          fail("unclosed `{`", openedAt);
+        }
+        break;
+      }
+      if (text.charAt(pos) === "}") {
+        if (!nested) {
+          fail("unexpected `}`", line);
+        }
+        advance();
+        break;
+      }
+      const keyLine = line;
+      const key = readIdentifier(keyLine);
+      skipInlineWhitespace();
+      const delimiter = text.charAt(pos);
+      if (delimiter === "{") {
+        const braceLine = line;
+        advance();
+        append(messages, key, parseBody(true, braceLine));
+        continue;
+      }
+      if (delimiter === ":") {
+        advance();
+        skipInlineWhitespace();
+        append(fields, key, text.charAt(pos) === '"' ? readQuotedScalar() : readUnquotedScalar());
+        continue;
+      }
+      fail(`expected \`:\` or \`{\` after \`${key}\``, keyLine);
+    }
+    return { fields, messages };
+  }
+  return parseBody(false, 1);
+}
+
+// src/gui-node-index.ts
+var SCRIPT_SUFFIX = ".gui_script";
+function scriptKeyOf(script) {
+  if (!script.endsWith(SCRIPT_SUFFIX))
+    return;
+  const key = script.startsWith("/") ? script.slice(1) : script;
+  return key === SCRIPT_SUFFIX ? undefined : key;
+}
+function buildGuiNodeIndex(documents) {
+  const byScriptResource = new Map;
+  const claimedBy = new Map;
+  const unresolved = [];
+  for (const [displayPath, text] of documents) {
+    let document;
+    try {
+      document = parseSceneTextFormat(text);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
+      continue;
+    }
+    const [script] = document.fields.get("script") ?? [];
+    if (script === undefined)
+      continue;
+    const key = scriptKeyOf(script);
+    if (key === undefined)
+      continue;
+    const owner = claimedBy.get(key);
+    if (owner !== undefined) {
+      byScriptResource.delete(key);
+      unresolved.push(`${key}: claimed by both ${owner} and ${displayPath}, so its node ids are ambiguous`);
+      continue;
+    }
+    claimedBy.set(key, displayPath);
+    const ids = new Set;
+    for (const message of document.messages.get("nodes") ?? []) {
+      for (const id of message.fields.get("id") ?? []) {
+        if (id !== "")
+          ids.add(id);
+      }
+    }
+    byScriptResource.set(key, ids);
+  }
+  return { byScriptResource, unresolved };
+}
+// src/input-action-index.ts
+function buildInputActionIndex(documents) {
+  const actions = new Set;
+  for (const text of documents.values()) {
+    let document;
+    try {
+      document = parseSceneTextFormat(text);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      continue;
+    }
+    for (const triggers of document.messages.values()) {
+      for (const trigger of triggers) {
+        for (const action of trigger.fields.get("action") ?? []) {
+          if (action !== "")
+            actions.add(action);
+        }
+      }
+    }
+  }
+  return actions;
+}
 // src/main-entry-factory-imports.ts
 import * as ts3 from "typescript";
 
@@ -361,6 +615,46 @@ function findMainEntryFactoryImports(fileName, source) {
   }
   return factories;
 }
+// src/output-paths.ts
+import * as path from "node:path";
+var DEFAULT_INCLUDE = ["src/**/*.ts"];
+var SCRIPT_SUFFIX_BY_KIND = {
+  script: ".ts.script",
+  "gui-script": ".ts.gui_script",
+  "render-script": ".ts.render_script",
+  "editor-script": ".ts.editor_script"
+};
+function parseBuildConfig(raw) {
+  const tsconfig = JSON.parse(raw);
+  const outDir = tsconfig.compilerOptions?.outDir;
+  const include = tsconfig.include?.length ? tsconfig.include : DEFAULT_INCLUDE;
+  return { outDir, include };
+}
+function stripIncludeBase(pattern) {
+  const firstWildcard = pattern.search(/[*?[]/);
+  if (firstWildcard === -1) {
+    return pattern.endsWith("/") ? pattern : `${path.posix.dirname(pattern)}/`;
+  }
+  const upToWildcard = pattern.slice(0, firstWildcard);
+  const lastSlash = upToWildcard.lastIndexOf("/");
+  return lastSlash === -1 ? "" : upToWildcard.slice(0, lastSlash + 1);
+}
+function relUnderOutDir(rel, config) {
+  const { outDir, include } = config;
+  if (outDir === undefined || outDir === "" || outDir === ".") {
+    return rel;
+  }
+  const includeBase = include.map(stripIncludeBase).filter((base) => rel.startsWith(base)).sort((a, b) => b.length - a.length)[0] ?? "";
+  const relUnderBase = rel.slice(includeBase.length);
+  return path.posix.join(outDir, relUnderBase);
+}
+function computeOutputRel(rel, config, kind) {
+  const baseRel = relUnderOutDir(rel, config);
+  if (kind === "module") {
+    return baseRel.replace(/\.ts$/, ".lua");
+  }
+  return baseRel.replace(/\.ts$/, SCRIPT_SUFFIX_BY_KIND[kind]);
+}
 // src/program-diagnostics.ts
 import * as ts7 from "typescript";
 import * as tstl from "typescript-to-lua";
@@ -532,10 +826,155 @@ function getProgramDiagnostics(program, sourceFile) {
   });
   return diagnostics.filter((d) => d.file !== undefined && !isAmbient(d.file.fileName));
 }
+// src/project-resources.ts
+var SCAFFOLDED_DEFIGNORE_LINES = ["/node_modules", "/.defold-types", "/.vscode"];
+function isDefignoredPath(displayPath) {
+  const rooted = `/${displayPath.replace(/^\/+/, "")}`;
+  return SCAFFOLDED_DEFIGNORE_LINES.some((line) => rooted === line || rooted.startsWith(`${line}/`));
+}
+// src/scene-component-index.ts
+var COMPONENT_BLOCKS = new Set(["components", "embedded_components"]);
+var EMBEDDING_BLOCKS = new Set(["embedded_instances", "embedded_components"]);
+function collect(message, blockName, depth, displayPath, ids, incomplete) {
+  if (COMPONENT_BLOCKS.has(blockName)) {
+    for (const id of message.fields.get("id") ?? []) {
+      ids.add(id);
+    }
+  }
+  if (EMBEDDING_BLOCKS.has(blockName)) {
+    for (const payload of message.fields.get("data") ?? []) {
+      try {
+        collect(parseSceneTextFormat(payload), "", depth + 1, displayPath, ids, incomplete);
+      } catch (error) {
+        if (!(error instanceof SceneTextFormatError))
+          throw error;
+        incomplete.push(`${displayPath}: embedded payload at depth ${depth + 1} could not be parsed (${error.message})`);
+      }
+    }
+  }
+  for (const [name, nested] of message.messages) {
+    for (const child of nested) {
+      collect(child, name, depth, displayPath, ids, incomplete);
+    }
+  }
+}
+function buildSceneComponentIndex(documents) {
+  const ids = new Set;
+  const incomplete = [];
+  if (documents.size === 0) {
+    incomplete.push("no scene sources were read, so no component id can be proven absent");
+    return { ids, incomplete };
+  }
+  for (const [displayPath, text] of documents) {
+    try {
+      collect(parseSceneTextFormat(text), "", 0, displayPath, ids, incomplete);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      incomplete.push(`${displayPath}: could not be parsed (${error.message})`);
+    }
+  }
+  return { ids, incomplete };
+}
+// src/scene-object-path-index.ts
+var LEAF_BLOCKS = ["instances", "embedded_instances"];
+function resourceKey(resource) {
+  return resource.startsWith("/") ? resource.slice(1) : resource;
+}
+function firstField(message, name) {
+  return (message.fields.get(name) ?? [])[0];
+}
+function childrenOf(message, name) {
+  return message.messages.get(name) ?? [];
+}
+function buildSceneObjectPathIndex(documents) {
+  const incomplete = [];
+  if (documents.size === 0) {
+    incomplete.push("no scene sources were read, so no game-object path can be proven absent");
+    return { paths: new Set, declaredIn: new Map, incomplete };
+  }
+  const parsed = new Map;
+  for (const [displayPath, text] of documents) {
+    try {
+      parsed.set(displayPath, parseSceneTextFormat(text));
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      incomplete.push(`${displayPath}: could not be parsed (${error.message})`);
+    }
+  }
+  const instanced = new Set;
+  for (const document of parsed.values()) {
+    for (const block of childrenOf(document, "collection_instances")) {
+      const collection = firstField(block, "collection");
+      if (collection !== undefined)
+        instanced.add(resourceKey(collection));
+    }
+  }
+  const composed = new Map;
+  const inProgress = new Set;
+  function pathsOf(displayPath) {
+    const done = composed.get(displayPath);
+    if (done !== undefined)
+      return done;
+    if (inProgress.has(displayPath)) {
+      incomplete.push(`${displayPath}: is instanced inside itself through a cycle of collection references, so its paths cannot be composed`);
+      return new Map;
+    }
+    const document = parsed.get(displayPath);
+    if (document === undefined)
+      return new Map;
+    inProgress.add(displayPath);
+    const paths2 = new Map;
+    for (const blockName of LEAF_BLOCKS) {
+      for (const block of childrenOf(document, blockName)) {
+        const id = firstField(block, "id");
+        if (id !== undefined && id !== "")
+          paths2.set(`/${id}`, displayPath);
+      }
+    }
+    for (const block of childrenOf(document, "collection_instances")) {
+      const id = firstField(block, "id");
+      const collection = firstField(block, "collection");
+      if (id === undefined || id === "" || collection === undefined)
+        continue;
+      const key = resourceKey(collection);
+      if (!parsed.has(key)) {
+        incomplete.push(`${displayPath}: the collection instance "${id}" names ${collection}, which is not among the project's readable scene documents`);
+        continue;
+      }
+      for (const [nested, declarer] of pathsOf(key)) {
+        paths2.set(`/${id}${nested}`, declarer);
+      }
+    }
+    inProgress.delete(displayPath);
+    composed.set(displayPath, paths2);
+    return paths2;
+  }
+  const paths = new Set;
+  const declaredIn = new Map;
+  for (const displayPath of parsed.keys()) {
+    const own = pathsOf(displayPath);
+    if (instanced.has(displayPath))
+      continue;
+    for (const [path2, declarer] of own) {
+      paths.add(path2);
+      const declarers = declaredIn.get(path2);
+      if (declarers === undefined) {
+        declaredIn.set(path2, [declarer]);
+      } else if (!declarers.includes(declarer)) {
+        declarers.push(declarer);
+      }
+    }
+  }
+  for (const declarers of declaredIn.values())
+    declarers.sort();
+  return { paths, declaredIn, incomplete };
+}
 // src/session.ts
 import { readFileSync as readFileSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 import * as ts10 from "typescript";
 import * as tstl3 from "typescript-to-lua";
 
@@ -545,30 +984,39 @@ import {
   createReturnStatement as createReturnStatement2
 } from "typescript-to-lua";
 var EDITOR_FACTORY_MODULE = "@defold-typescript/types";
-var EDITOR_FACTORY_NAME = "defineEditorScript";
-var EDITOR_FACTORY_SPECIFIERS = new Set([EDITOR_FACTORY_MODULE]);
-function resolvesToEditorFactoryExport(callee, checker) {
+var EDITOR_SCRIPT_FACTORY_NAME = "defineEditorScript";
+var EDITOR_COMMAND_FACTORY_NAME = "defineEditorCommand";
+var EDITOR_FACTORY_NAMES = new Set([
+  EDITOR_SCRIPT_FACTORY_NAME,
+  EDITOR_COMMAND_FACTORY_NAME
+]);
+var EDITOR_FACTORY_SPECIFIERS = new Set([
+  EDITOR_FACTORY_MODULE,
+  `${EDITOR_FACTORY_MODULE}/editor-script`
+]);
+function resolveEditorFactoryExport(callee, checker) {
   let symbol = checker.getSymbolAtLocation(callee);
   if (symbol === undefined) {
-    return false;
+    return;
   }
   if (symbol.flags & ts8.SymbolFlags.Alias) {
     symbol = checker.getAliasedSymbol(symbol);
   }
-  if (symbol.getName() !== EDITOR_FACTORY_NAME) {
-    return false;
+  const name = symbol.getName();
+  if (!EDITOR_FACTORY_NAMES.has(name)) {
+    return;
   }
   const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
   if (declaration === undefined) {
-    return false;
+    return;
   }
-  return declaration.getSourceFile().fileName.includes(EDITOR_FACTORY_MODULE);
+  return declaration.getSourceFile().fileName.includes(EDITOR_FACTORY_MODULE) ? name : undefined;
 }
 function lowerEditorFactoryCall(expression, context) {
   if (!ts8.isCallExpression(expression)) {
     return;
   }
-  if (!resolvesToEditorFactoryExport(expression.expression, context.checker)) {
+  if (resolveEditorFactoryExport(expression.expression, context.checker) !== EDITOR_SCRIPT_FACTORY_NAME) {
     return;
   }
   const module = expression.arguments[0];
@@ -596,7 +1044,7 @@ function isEditorFactoryOnlyImport(node) {
   if (runtime.length === 0) {
     return false;
   }
-  return runtime.every((element) => (element.propertyName ?? element.name).text === EDITOR_FACTORY_NAME);
+  return runtime.every((element) => EDITOR_FACTORY_NAMES.has((element.propertyName ?? element.name).text));
 }
 var editorScriptErasurePlugin = {
   visitors: {
@@ -609,6 +1057,13 @@ var editorScriptErasurePlugin = {
       }
       return context.superTransformStatements(node);
     },
+    [ts8.SyntaxKind.CallExpression]: (node, context) => {
+      const command = node.arguments[0];
+      if (command !== undefined && resolveEditorFactoryExport(node.expression, context.checker) === EDITOR_COMMAND_FACTORY_NAME) {
+        return context.transformExpression(command);
+      }
+      return context.superTransformExpression(node);
+    },
     [ts8.SyntaxKind.ImportDeclaration]: (node, context) => isEditorFactoryOnlyImport(node) ? [] : context.superTransformStatements(node)
   }
 };
@@ -616,7 +1071,7 @@ var editorScriptErasurePlugin = {
 // src/transpile.ts
 import { readdirSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import * as path from "node:path";
+import * as path2 from "node:path";
 import * as tstl2 from "typescript-to-lua";
 
 // src/go-property-direct-call.ts
@@ -642,12 +1097,12 @@ function flattenDiagnosticMessage(text) {
   return flattenDiagnosticMessage(text.messageText);
 }
 var requireFromHere = createRequire(import.meta.url);
-var TYPES_PKG_ROOT = path.dirname(requireFromHere.resolve("@defold-typescript/types/package.json"));
-var TSTL_LANG_EXT_ROOT = path.dirname(requireFromHere.resolve("@typescript-to-lua/language-extensions/package.json"));
+var TYPES_PKG_ROOT = path2.dirname(requireFromHere.resolve("@defold-typescript/types/package.json"));
+var TSTL_LANG_EXT_ROOT = path2.dirname(requireFromHere.resolve("@typescript-to-lua/language-extensions/package.json"));
 function readAmbient(rel) {
-  return readFileSync(path.join(TYPES_PKG_ROOT, rel), "utf8");
+  return readFileSync(path2.join(TYPES_PKG_ROOT, rel), "utf8");
 }
-var LUA_TYPES_ROOT = path.dirname(createRequire(path.join(TYPES_PKG_ROOT, "package.json")).resolve("lua-types/package.json"));
+var LUA_TYPES_ROOT = path2.dirname(createRequire(path2.join(TYPES_PKG_ROOT, "package.json")).resolve("lua-types/package.json"));
 var LUA_TYPES_ENTRY_FILES = ["5.1.d.ts", "special/jit-only.d.ts"];
 var REFERENCE_PATH_RE = /\/\/\/\s*<reference\s+path="([^"]+)"\s*\/>/g;
 function collectLuaTypesClosure() {
@@ -656,14 +1111,14 @@ function collectLuaTypesClosure() {
     const key = `node_modules/lua-types/${rel}`;
     if (key in files)
       return;
-    const source = readFileSync(path.join(LUA_TYPES_ROOT, rel), "utf8");
+    const source = readFileSync(path2.join(LUA_TYPES_ROOT, rel), "utf8");
     files[key] = source;
-    const dir = path.posix.dirname(rel);
+    const dir = path2.posix.dirname(rel);
     for (const match of source.matchAll(REFERENCE_PATH_RE)) {
       const ref = match[1];
       if (!ref)
         continue;
-      visit(path.posix.normalize(path.posix.join(dir, ref)));
+      visit(path2.posix.normalize(path2.posix.join(dir, ref)));
     }
   };
   for (const entry of LUA_TYPES_ENTRY_FILES)
@@ -672,7 +1127,7 @@ function collectLuaTypesClosure() {
 }
 function buildAmbientFiles() {
   const files = {
-    "node_modules/@typescript-to-lua/language-extensions/index.d.ts": readFileSync(path.join(TSTL_LANG_EXT_ROOT, "index.d.ts"), "utf8"),
+    "node_modules/@typescript-to-lua/language-extensions/index.d.ts": readFileSync(path2.join(TSTL_LANG_EXT_ROOT, "index.d.ts"), "utf8"),
     "node_modules/@defold-typescript/types/src/core-types.ts": readAmbient("src/core-types.ts"),
     "node_modules/@defold-typescript/types/src/engine-globals.d.ts": readAmbient("src/engine-globals.d.ts"),
     "node_modules/@defold-typescript/types/src/go-overloads.d.ts": readAmbient("src/go-overloads.d.ts"),
@@ -700,15 +1155,21 @@ export type { ScriptProperties, ScriptProperty } from "./src/lifecycle.js";
 `,
     "node_modules/@defold-typescript/types/render-script.d.ts": `export { defineRenderScript } from "./src/lifecycle.js";
 export type { ScriptProperties, ScriptProperty } from "./src/lifecycle.js";
-`
+`,
+    "node_modules/@defold-typescript/types/editor-script.d.ts": [
+      'export { defineEditorCommand, defineEditorScript } from "./src/editor.js";',
+      'export type { EditorCommandQuery, EditorNode } from "./src/editor.js";',
+      ""
+    ].join(`
+`)
   };
   Object.assign(files, collectLuaTypesClosure());
-  for (const entry of readdirSync(path.join(TYPES_PKG_ROOT, "generated"))) {
+  for (const entry of readdirSync(path2.join(TYPES_PKG_ROOT, "generated"))) {
     if (entry.endsWith(".d.ts")) {
       files[`node_modules/@defold-typescript/types/generated/${entry}`] = readAmbient(`generated/${entry}`);
     }
   }
-  for (const entry of readdirSync(path.join(TYPES_PKG_ROOT, "src"))) {
+  for (const entry of readdirSync(path2.join(TYPES_PKG_ROOT, "src"))) {
     if (entry.endsWith(".d.ts")) {
       files[`node_modules/@defold-typescript/types/src/${entry}`] = readAmbient(`src/${entry}`);
     }
@@ -868,12 +1329,12 @@ function createTranspileSession() {
     }
     let filePath;
     if (fileName.startsWith("lib.")) {
-      const typeScriptDir = path2.dirname(requireFromHere2.resolve("typescript"));
-      filePath = path2.join(typeScriptDir, fileName);
+      const typeScriptDir = path3.dirname(requireFromHere2.resolve("typescript"));
+      filePath = path3.join(typeScriptDir, fileName);
     }
     if (fileName.includes("language-extensions")) {
       const dtsName = fileName.replace(/(\.d)?(\.ts)$/, ".d.ts");
-      filePath = path2.resolve(dtsName);
+      filePath = path3.resolve(dtsName);
     }
     if (filePath !== undefined) {
       const cached = libCache.get(fileName);
@@ -935,10 +1396,437 @@ function createTranspileSession() {
     getProgram: () => program
   };
 }
+// src/sprite-animation-index.ts
+function resourceKey2(resource) {
+  return resource.startsWith("/") ? resource.slice(1) : resource;
+}
+function normalizeDocumentKey(path4) {
+  return path4.replaceAll("\\", "/");
+}
+var SCRIPT_SUFFIX2 = ".script";
+var SPRITE_SUFFIX = ".sprite";
+function firstField2(message, name) {
+  return (message.fields.get(name) ?? [])[0];
+}
+function childrenOf2(message, name) {
+  return message.messages.get(name) ?? [];
+}
+function declaredAnimations(document) {
+  const ids = new Set;
+  for (const animation of childrenOf2(document, "animations")) {
+    for (const id of animation.fields.get("id") ?? []) {
+      if (id !== "")
+        ids.add(id);
+    }
+  }
+  return ids;
+}
+function readAssets(assets, unresolved) {
+  const animationsByTileSet = new Map;
+  const tileSetBySprite = new Map;
+  for (const [path4, text] of assets) {
+    const displayPath = normalizeDocumentKey(path4);
+    let document;
+    try {
+      document = parseSceneTextFormat(text);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
+      continue;
+    }
+    if (displayPath.endsWith(SPRITE_SUFFIX)) {
+      const tileSet = firstField2(document, "tile_set");
+      if (tileSet !== undefined)
+        tileSetBySprite.set(displayPath, resourceKey2(tileSet));
+      continue;
+    }
+    animationsByTileSet.set(displayPath, declaredAnimations(document));
+  }
+  return { animationsByTileSet, tileSetBySprite };
+}
+function spriteTileSets(object, displayPath, assets, unresolved) {
+  const tileSets = new Map;
+  for (const embedded of childrenOf2(object, "embedded_components")) {
+    if (firstField2(embedded, "type") !== "sprite")
+      continue;
+    const id = firstField2(embedded, "id");
+    const payload = firstField2(embedded, "data");
+    if (id === undefined || payload === undefined)
+      continue;
+    try {
+      const tileSet = firstField2(parseSceneTextFormat(payload), "tile_set");
+      if (tileSet !== undefined)
+        tileSets.set(id, resourceKey2(tileSet));
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      unresolved.push(`${displayPath}: the embedded sprite "${id}" could not be read (${error.message})`);
+    }
+  }
+  for (const referenced of childrenOf2(object, "components")) {
+    const component = firstField2(referenced, "component");
+    const id = firstField2(referenced, "id");
+    if (id === undefined || component === undefined || !component.endsWith(SPRITE_SUFFIX))
+      continue;
+    const tileSet = assets.tileSetBySprite.get(resourceKey2(component));
+    if (tileSet === undefined) {
+      unresolved.push(`${displayPath}: the sprite component "${id}" names ${component}, which is not among the project's sprite documents`);
+      continue;
+    }
+    tileSets.set(id, tileSet);
+  }
+  return tileSets;
+}
+function scriptResourcesOf(object) {
+  const resources = [];
+  for (const component of childrenOf2(object, "components")) {
+    const resource = firstField2(component, "component");
+    if (resource === undefined || !resource.endsWith(SCRIPT_SUFFIX2))
+      continue;
+    const key = resourceKey2(resource);
+    if (key !== SCRIPT_SUFFIX2.slice(1))
+      resources.push(key);
+  }
+  return resources;
+}
+function isGameObject(message) {
+  return message.messages.has("components") || message.messages.has("embedded_components");
+}
+function buildSpriteAnimationIndex(input) {
+  const unresolved = [];
+  const assets = readAssets(input.assets, unresolved);
+  const byScriptResource = new Map;
+  const tileSetByScriptResource = new Map;
+  const claimedBy = new Map;
+  function walk(message, blockName, displayPath) {
+    if (isGameObject(message)) {
+      claim(message, displayPath);
+    }
+    if (blockName === "embedded_instances") {
+      for (const payload of message.fields.get("data") ?? []) {
+        try {
+          walk(parseSceneTextFormat(payload), "", displayPath);
+        } catch (error) {
+          if (!(error instanceof SceneTextFormatError))
+            throw error;
+          unresolved.push(`${displayPath}: an embedded game object could not be read (${error.message})`);
+        }
+      }
+    }
+    for (const [name, nested] of message.messages) {
+      for (const child of nested) {
+        walk(child, name, displayPath);
+      }
+    }
+  }
+  function claim(object, displayPath) {
+    const scripts = scriptResourcesOf(object);
+    if (scripts.length === 0)
+      return;
+    const tileSets = spriteTileSets(object, displayPath, assets, unresolved);
+    const animations = new Map;
+    const declaringTileSets = new Map;
+    for (const [id, tileSet] of tileSets) {
+      const declared = assets.animationsByTileSet.get(tileSet);
+      if (declared === undefined) {
+        unresolved.push(`${displayPath}: the sprite component "${id}" names the tile source /${tileSet}, which is not among the project's asset documents`);
+        continue;
+      }
+      animations.set(id, declared);
+      declaringTileSets.set(id, tileSet);
+    }
+    for (const key of scripts) {
+      const owner = claimedBy.get(key);
+      if (owner !== undefined) {
+        byScriptResource.delete(key);
+        tileSetByScriptResource.delete(key);
+        unresolved.push(`${key}: claimed by both ${owner} and ${displayPath}, so its sprite animations are ambiguous`);
+        continue;
+      }
+      claimedBy.set(key, displayPath);
+      byScriptResource.set(key, animations);
+      tileSetByScriptResource.set(key, declaringTileSets);
+    }
+  }
+  for (const [path4, text] of input.scenes) {
+    const displayPath = normalizeDocumentKey(path4);
+    try {
+      walk(parseSceneTextFormat(text), "", displayPath);
+    } catch (error) {
+      if (!(error instanceof SceneTextFormatError))
+        throw error;
+      unresolved.push(`${displayPath}: could not be parsed (${error.message})`);
+    }
+  }
+  return { byScriptResource, tileSetByScriptResource, unresolved };
+}
+function componentIdOfSameObjectAddress(address) {
+  if (!address.startsWith("#"))
+    return;
+  const id = address.slice(1);
+  if (id === "" || id.includes("/") || id.includes("#"))
+    return;
+  return id;
+}
+// src/url-address-slots.ts
+import * as ts11 from "typescript";
+var ADDRESS_CLASSES = {
+  "game-object": true,
+  component: true,
+  either: true,
+  "gui-node": false,
+  animation: false,
+  "resource-path": false,
+  "config-key": false,
+  "action-id": false,
+  none: false
+};
+function isAddressClass(parameterClass) {
+  return ADDRESS_CLASSES[parameterClass];
+}
+function isFragmentCaret(slot, position) {
+  return slot.fragmentStart !== -1 && position >= slot.fragmentStart;
+}
+function tableKey(checker, callee) {
+  const symbol = checker.getSymbolAtLocation(ts11.isIdentifier(callee) ? callee : callee.name);
+  if (!symbol)
+    return;
+  const fqn = checker.getFullyQualifiedName(symbol);
+  return fqn.startsWith("global.") ? fqn.slice("global.".length) : undefined;
+}
+function parameterName(checker, call, index) {
+  const declaration = checker.getResolvedSignature(call)?.declaration;
+  if (!declaration || !ts11.isFunctionLike(declaration))
+    return;
+  const parameter = declaration.parameters[index];
+  if (!parameter || parameter.dotDotDotToken || !ts11.isIdentifier(parameter.name))
+    return;
+  return parameter.name.text;
+}
+var EQUALITY_OPERATORS = new Set([
+  ts11.SyntaxKind.EqualsEqualsEqualsToken,
+  ts11.SyntaxKind.ExclamationEqualsEqualsToken,
+  ts11.SyntaxKind.EqualsEqualsToken,
+  ts11.SyntaxKind.ExclamationEqualsToken
+]);
+function comparisonSatisfied(checker, entry, call) {
+  if (entry.comparedParameter === undefined)
+    return true;
+  let node = call;
+  while (ts11.isParenthesizedExpression(node.parent))
+    node = node.parent;
+  const comparison = node.parent;
+  if (!ts11.isBinaryExpression(comparison))
+    return false;
+  if (!EQUALITY_OPERATORS.has(comparison.operatorToken.kind))
+    return false;
+  const other = comparison.left === node ? comparison.right : comparison.left;
+  const symbol = checker.getSymbolAtLocation(other);
+  return (symbol?.declarations ?? []).some((declaration) => ts11.isParameter(declaration) && ts11.isIdentifier(declaration.name) && declaration.name.text === entry.comparedParameter);
+}
+function classifiedEntryOfArgument(checker, table, argument) {
+  const call = argument.parent;
+  if (!ts11.isCallExpression(call))
+    return;
+  const argumentIndex = call.arguments.indexOf(argument);
+  if (argumentIndex === -1)
+    return;
+  const callee = call.expression;
+  if (!ts11.isPropertyAccessExpression(callee) && !ts11.isIdentifier(callee))
+    return;
+  const fqn = tableKey(checker, callee);
+  if (fqn === undefined)
+    return;
+  const parameter = parameterName(checker, call, argumentIndex);
+  if (parameter === undefined)
+    return;
+  for (const entry of table) {
+    if (entry.fqn !== fqn || entry.parameter !== parameter)
+      continue;
+    return comparisonSatisfied(checker, entry, call) ? { entry, call } : undefined;
+  }
+  return;
+}
+function slotThroughHashedCall(checker, table, literal) {
+  const call = literal.parent;
+  if (!ts11.isCallExpression(call))
+    return;
+  const callee = call.expression;
+  if (!ts11.isPropertyAccessExpression(callee) && !ts11.isIdentifier(callee))
+    return;
+  if (tableKey(checker, callee) !== "hash")
+    return;
+  const ascended = classifiedEntryOfArgument(checker, table, call);
+  return ascended?.entry.fqn === "hash" ? undefined : ascended;
+}
+function addressClassOfArgument(checker, table, argument) {
+  return classifiedEntryOfArgument(checker, table, argument)?.entry.class ?? "none";
+}
+function addressTextOf(checker, entry, call) {
+  if (entry.addressParameter === undefined)
+    return;
+  const declaration = checker.getResolvedSignature(call)?.declaration;
+  if (!declaration || !ts11.isFunctionLike(declaration))
+    return;
+  const index = declaration.parameters.findIndex((parameter) => !parameter.dotDotDotToken && ts11.isIdentifier(parameter.name) && parameter.name.text === entry.addressParameter);
+  if (index === -1)
+    return;
+  const argument = call.arguments[index];
+  return argument && ts11.isStringLiteralLike(argument) ? argument.text : undefined;
+}
+function innermostLiteralAt(sourceFile, position) {
+  let found;
+  const visit = (node) => {
+    if (position < node.getStart(sourceFile) || position > node.getEnd())
+      return;
+    if (ts11.isStringLiteralLike(node))
+      found = node;
+    ts11.forEachChild(node, visit);
+  };
+  ts11.forEachChild(sourceFile, visit);
+  return found;
+}
+function resolveClassifiedSlotAtPosition(input) {
+  const { program, table, fileName, position } = input;
+  const sourceFile = program.getSourceFile(fileName);
+  if (!sourceFile)
+    return;
+  const literal = innermostLiteralAt(sourceFile, position);
+  if (!literal)
+    return;
+  if (literal.getWidth(sourceFile) !== literal.text.length + 2)
+    return;
+  const textStart = literal.getStart(sourceFile) + 1;
+  if (position < textStart || position > textStart + literal.text.length)
+    return;
+  const checker = program.getTypeChecker();
+  const own = classifiedEntryOfArgument(checker, table, literal);
+  const classified = own && own.entry.class !== "none" ? own : slotThroughHashedCall(checker, table, literal);
+  if (!classified || classified.entry.class === "none")
+    return;
+  const hash = literal.text.lastIndexOf("#");
+  const addressText = addressTextOf(checker, classified.entry, classified.call);
+  return {
+    class: classified.entry.class,
+    text: literal.text,
+    textStart,
+    fragmentStart: hash === -1 ? -1 : textStart + hash + 1,
+    ...addressText === undefined ? {} : { addressText },
+    ...classified.entry.resourceExtensions === undefined ? {} : { resourceExtensions: classified.entry.resourceExtensions }
+  };
+}
+// src/url-fragment-reachability.ts
+import * as ts12 from "typescript";
+function isAmbient2(fileName) {
+  return /[\\/]node_modules[\\/]/.test(fileName) || /(^|[\\/])lib\.[^\\/]*\.d\.ts$/.test(fileName);
+}
+function referenceTargetSymbol(type) {
+  if ((type.flags & ts12.TypeFlags.Object) === 0)
+    return;
+  if ((type.objectFlags & ts12.ObjectFlags.Reference) === 0)
+    return;
+  return type.target.symbol;
+}
+function ambientHashAliasTargets(checker, anchor) {
+  const targets = new Set;
+  for (const symbol of checker.getSymbolsInScope(anchor, ts12.SymbolFlags.Type)) {
+    if (symbol.name !== "Hash")
+      continue;
+    const target = referenceTargetSymbol(checker.getDeclaredTypeOfSymbol(symbol));
+    if (target)
+      targets.add(target);
+  }
+  return targets;
+}
+function canonicalHashSymbols(checker, program) {
+  const files = program.getSourceFiles();
+  const anchor = files.find((file) => isAmbient2(file.fileName)) ?? files[0];
+  const canonical = new Set;
+  if (!anchor)
+    return canonical;
+  const aliased = ambientHashAliasTargets(checker, anchor);
+  for (const symbol of checker.getSymbolsInScope(anchor, ts12.SymbolFlags.Function)) {
+    if (symbol.name !== "hash")
+      continue;
+    const declaration = symbol.declarations?.[0];
+    if (!declaration)
+      continue;
+    for (const signature of checker.getTypeOfSymbolAtLocation(symbol, declaration).getCallSignatures()) {
+      const target = referenceTargetSymbol(signature.getReturnType());
+      if (target && aliased.has(target))
+        canonical.add(target);
+    }
+  }
+  return canonical;
+}
+function hashedSourceOfType(checker, type, canonical) {
+  const target = referenceTargetSymbol(type);
+  if (!target || !canonical.has(target))
+    return;
+  const [source] = checker.getTypeArguments(type);
+  return source?.isStringLiteral() ? source.value : undefined;
+}
+function checkUrlFragmentReachability(input) {
+  const { program, table, index, sourceFiles } = input;
+  if (index.incomplete.length > 0) {
+    return { kind: "suppressed", reasons: index.incomplete };
+  }
+  const checker = program.getTypeChecker();
+  const canonical = canonicalHashSymbols(checker, program);
+  const findings = [];
+  const targets = sourceFiles ?? program.getSourceFiles();
+  for (const sourceFile of targets) {
+    if (isAmbient2(sourceFile.fileName))
+      continue;
+    const visit = (node) => {
+      if (ts12.isExpression(node) && isAddressClass(addressClassOfArgument(checker, table, node))) {
+        const text = ts12.isStringLiteralLike(node) ? node.text : hashedSourceOfType(checker, checker.getTypeAtLocation(node), canonical);
+        if (text !== undefined) {
+          const hash = text.indexOf("#");
+          const fragment = hash === -1 ? "" : text.slice(hash + 1);
+          if (fragment !== "" && !index.ids.has(fragment)) {
+            findings.push({
+              fileName: sourceFile.fileName,
+              start: node.getStart(sourceFile),
+              length: node.getWidth(sourceFile),
+              fragment,
+              message: `no \`.go\` or \`.collection\` in this project declares a component with the id ` + `"${fragment}", so this address cannot resolve at runtime`
+            });
+          }
+        }
+      }
+      ts12.forEachChild(node, visit);
+    };
+    ts12.forEachChild(sourceFile, visit);
+  }
+  return { kind: "checked", findings };
+}
 export {
   transpileProject,
   transpile,
+  stripIncludeBase,
+  resolveClassifiedSlotAtPosition,
+  parseSceneTextFormat,
+  parseBuildConfig,
+  isFragmentCaret,
+  isDefignoredPath,
+  isAddressClass,
   getProgramDiagnostics,
   findMainEntryFactoryImports,
-  createTranspileSession
+  createTranspileSession,
+  computeOutputRel,
+  componentIdOfSameObjectAddress,
+  checkUrlFragmentReachability,
+  buildSpriteAnimationIndex,
+  buildSceneObjectPathIndex,
+  buildSceneComponentIndex,
+  buildInputActionIndex,
+  buildGuiNodeIndex,
+  buildConfigKeyIndex,
+  addressClassOfArgument,
+  SceneTextFormatError,
+  SCRIPT_SUFFIX_BY_KIND,
+  SCAFFOLDED_DEFIGNORE_LINES,
+  DEFAULT_INCLUDE
 };