@intentius/chant 0.101.0 → 0.104.0

package/src/discovery/specifier-resolve.ts

@@ -0,0 +1,344 @@
+/**
+ * chant#3090 — the file-system half of fold's import resolution: which file a
+ * relative specifier names, which file a package's `exports` map names for a
+ * subpath, and which file a tsconfig `paths` entry names.
+ *
+ * The rules follow TypeScript's `bundler` resolution with `noDtsResolution`,
+ * the resolver `tsc` and the editor use for these specifiers:
+ *
+ * - `./x.js` names `./x.ts` (or `./x.tsx`) when that file exists, and the
+ *   `.js` file only otherwise. `.mjs` maps to `.mts`, `.cjs` to `.cts` and
+ *   `.jsx` to `.tsx` the same way.
+ * - A package's `exports` map is read for the root and for subpaths, with
+ *   one `*` per pattern key, and its condition objects are read in key order
+ *   against the `import`, `node` and `default` conditions, as an ESM import
+ *   in Node reads them.
+ * - A `paths` entry from the nearest `tsconfig.json` resolves relative to
+ *   `baseUrl` when the config chain sets one and to the directory of the
+ *   config that declares `paths` otherwise.
+ *
+ * Nothing here calls Node's `Module._resolveFilename`: every answer comes from
+ * `statSync` and `readFileSync`, which is what keeps the cold-resolution cost
+ * of chant#1020 off this path.
+ */
+import * as ts from "typescript";
+import { readFileSync, statSync } from "node:fs";
+import { dirname, extname, isAbsolute, join, resolve as resolvePath } from "node:path";
+
+/** True when `path` is an existing regular file. */
+export function isFile(path: string): boolean {
+  try {
+    return statSync(path, { throwIfNoEntry: false })?.isFile() ?? false;
+  } catch {
+    return false;
+  }
+}
+
+/** True when `path` is an existing directory. */
+function isDirectory(path: string): boolean {
+  try {
+    return statSync(path, { throwIfNoEntry: false })?.isDirectory() ?? false;
+  } catch {
+    return false;
+  }
+}
+
+/** The TypeScript source extensions a JavaScript extension in a specifier stands for, in the order `tsc` tries them. */
+const TS_SOURCE_FOR_JS_EXTENSION: Readonly<Record<string, readonly string[]>> = {
+  ".js": [".ts", ".tsx"],
+  ".jsx": [".tsx"],
+  ".mjs": [".mts"],
+  ".cjs": [".cts"],
+};
+
+/**
+ * The file an absolute module base path names, or `undefined` when none of
+ * the probed files exists. A JavaScript extension is first swapped for its
+ * TypeScript source extension. Then the path itself, the path with `.ts`,
+ * `.tsx`, `.js` and `.mjs` appended, and `index.ts` and `index.js` under it
+ * are tried in that order.
+ */
+export function probeModuleFile(base: string): string | undefined {
+  const ext = extname(base);
+  const sourceExts = TS_SOURCE_FOR_JS_EXTENSION[ext];
+  if (sourceExts) {
+    const stem = base.slice(0, -ext.length);
+    for (const sourceExt of sourceExts) {
+      if (isFile(stem + sourceExt)) return stem + sourceExt;
+    }
+  }
+  const candidates = [
+    base,
+    `${base}.ts`,
+    `${base}.tsx`,
+    `${base}.js`,
+    `${base}.mjs`,
+    join(base, "index.ts"),
+    join(base, "index.js"),
+  ];
+  return candidates.find(isFile);
+}
+
+/** A bare specifier split into its package name and the subpath after it (`"."` for the root). */
+export function splitBareSpecifier(specifier: string): { name: string; subpath: string } | undefined {
+  const segments = specifier.split("/");
+  const nameLength = specifier.startsWith("@") ? 2 : 1;
+  if (segments.length < nameLength || segments.slice(0, nameLength).some((s) => s === "")) return undefined;
+  const name = segments.slice(0, nameLength).join("/");
+  const rest = segments.slice(nameLength).join("/");
+  return { name, subpath: rest === "" ? "." : `./${rest}` };
+}
+
+/** The conditions an ESM import in Node matches, which is what the run path does. */
+const EXPORT_CONDITIONS: ReadonlySet<string> = new Set(["import", "node", "default"]);
+
+/**
+ * The target an `exports` value selects, with `star` substituted for each `*`
+ * when it came from a pattern key. A string is the target; an array yields its
+ * first resolvable entry; a condition object is read in key order and the
+ * first matching condition that resolves wins. `null`, and a condition object
+ * with no matching condition, resolve to nothing.
+ */
+function exportsValueTarget(value: unknown, star: string | undefined): string | undefined {
+  if (typeof value === "string") return star === undefined ? value : value.split("*").join(star);
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const target = exportsValueTarget(entry, star);
+      if (target !== undefined) return target;
+    }
+    return undefined;
+  }
+  if (typeof value !== "object" || value === null) return undefined;
+  for (const [condition, conditional] of Object.entries(value)) {
+    if (!EXPORT_CONDITIONS.has(condition)) continue;
+    const target = exportsValueTarget(conditional, star);
+    if (target !== undefined) return target;
+  }
+  return undefined;
+}
+
+/**
+ * The target `exportsField` gives `subpath` (`"."` or `"./x"`), relative to
+ * the package directory, or `undefined` when the map does not export it. An
+ * exact key wins over a pattern; among patterns, the longest prefix before the
+ * `*` wins, as in Node's own resolver.
+ */
+export function packageExportsTarget(exportsField: unknown, subpath: string): string | undefined {
+  const isSubpathMap =
+    typeof exportsField === "object" &&
+    exportsField !== null &&
+    !Array.isArray(exportsField) &&
+    Object.keys(exportsField).some((k) => k.startsWith("."));
+  if (!isSubpathMap) return subpath === "." ? exportsValueTarget(exportsField, undefined) : undefined;
+
+  const map = exportsField as Record<string, unknown>;
+  if (Object.prototype.hasOwnProperty.call(map, subpath) && !subpath.includes("*")) return exportsValueTarget(map[subpath], undefined);
+
+  let bestKey: string | undefined;
+  let bestStar: string | undefined;
+  for (const key of Object.keys(map)) {
+    const starAt = key.indexOf("*");
+    if (starAt === -1 || key.indexOf("*", starAt + 1) !== -1) continue;
+    const prefix = key.slice(0, starAt);
+    const suffix = key.slice(starAt + 1);
+    if (!subpath.startsWith(prefix) || subpath === prefix) continue;
+    if (suffix !== "" && (!subpath.endsWith(suffix) || subpath.length < key.length)) continue;
+    if (bestKey === undefined || prefix.length > bestKey.indexOf("*") || (prefix.length === bestKey.indexOf("*") && key.length > bestKey.length)) {
+      bestKey = key;
+      bestStar = subpath.slice(prefix.length, subpath.length - suffix.length);
+    }
+  }
+  return bestKey === undefined ? undefined : exportsValueTarget(map[bestKey], bestStar);
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+// tsconfig `paths`
+// ─────────────────────────────────────────────────────────────────────────
+
+/** One `paths` key, split at its `*`. */
+interface PathsPattern {
+  key: string;
+  prefix: string;
+  /** `undefined` for a key with no `*`, which matches only itself. */
+  suffix: string | undefined;
+  substitutions: readonly string[];
+}
+
+/** The `paths` a config chain ends with, ready to match. */
+interface TsconfigPaths {
+  /** `baseUrl` when the chain sets one, else the directory of the config that declares `paths`. */
+  base: string;
+  patterns: readonly PathsPattern[];
+}
+
+/** A parsed config chain, with the files it was read from and their modification times. */
+interface CachedTsconfig {
+  stamps: ReadonlyArray<readonly [string, number]>;
+  paths: TsconfigPaths | undefined;
+}
+
+/** Nearest `tsconfig.json` for a directory (`null` when there is none). */
+const nearestTsconfigCache = new Map<string, string | null>();
+/** Parsed config chains by leaf config path, re-read when a file in the chain changes. */
+const tsconfigCache = new Map<string, CachedTsconfig>();
+
+function nearestTsconfig(dir: string): string | null {
+  const cached = nearestTsconfigCache.get(dir);
+  if (cached !== undefined) return cached;
+  const candidate = join(dir, "tsconfig.json");
+  let found: string | null;
+  if (isFile(candidate)) found = candidate;
+  else {
+    const parent = dirname(dir);
+    found = parent === dir ? null : nearestTsconfig(parent);
+  }
+  nearestTsconfigCache.set(dir, found);
+  return found;
+}
+
+function mtimeOf(path: string): number {
+  try {
+    return statSync(path, { throwIfNoEntry: false })?.mtimeMs ?? -1;
+  } catch {
+    return -1;
+  }
+}
+
+/** The config file an `extends` entry names, or `undefined` when it cannot be found. */
+function resolveExtends(entry: string, fromConfig: string): string | undefined {
+  const fromDir = dirname(fromConfig);
+  if (entry.startsWith(".") || isAbsolute(entry)) {
+    const path = resolvePath(fromDir, entry);
+    if (isFile(path)) return path;
+    if (!path.endsWith(".json") && isFile(`${path}.json`)) return `${path}.json`;
+    return undefined;
+  }
+  // A package's config, looked up in `node_modules` the way `tsc` does for
+  // the common shapes: the file itself, the file plus `.json`, or the
+  // package directory's `tsconfig.json`.
+  for (let dir = fromDir; ; ) {
+    const path = join(dir, "node_modules", entry);
+    if (isFile(path)) return path;
+    if (!path.endsWith(".json") && isFile(`${path}.json`)) return `${path}.json`;
+    if (isDirectory(path) && isFile(join(path, "tsconfig.json"))) return join(path, "tsconfig.json");
+    const parent = dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
+
+interface ChainOptions {
+  paths?: { value: Record<string, unknown>; declaredIn: string };
+  baseUrl?: string;
+}
+
+/** Read `configPath` and everything it extends, later configs overriding earlier ones. */
+function readConfigChain(configPath: string, files: string[], seen: Set<string>): ChainOptions {
+  if (seen.has(configPath)) return {};
+  seen.add(configPath);
+  files.push(configPath);
+  let text: string;
+  try {
+    text = readFileSync(configPath, "utf-8");
+  } catch {
+    return {};
+  }
+  const { config } = ts.parseConfigFileTextToJson(configPath, text);
+  if (typeof config !== "object" || config === null) return {};
+  const raw = config as { extends?: unknown; compilerOptions?: { paths?: unknown; baseUrl?: unknown } };
+
+  const merged: ChainOptions = {};
+  const parents = typeof raw.extends === "string" ? [raw.extends] : Array.isArray(raw.extends) ? raw.extends : [];
+  for (const parent of parents) {
+    if (typeof parent !== "string") continue;
+    const parentPath = resolveExtends(parent, configPath);
+    if (parentPath === undefined) continue;
+    const inherited = readConfigChain(parentPath, files, seen);
+    if (inherited.paths) merged.paths = inherited.paths;
+    if (inherited.baseUrl !== undefined) merged.baseUrl = inherited.baseUrl;
+  }
+
+  const options = raw.compilerOptions;
+  if (options && typeof options.paths === "object" && options.paths !== null && !Array.isArray(options.paths)) {
+    merged.paths = { value: options.paths as Record<string, unknown>, declaredIn: dirname(configPath) };
+  }
+  if (options && typeof options.baseUrl === "string") merged.baseUrl = resolvePath(dirname(configPath), options.baseUrl);
+  return merged;
+}
+
+function parsePaths(chain: ChainOptions): TsconfigPaths | undefined {
+  if (!chain.paths) return undefined;
+  const patterns: PathsPattern[] = [];
+  for (const [key, value] of Object.entries(chain.paths.value)) {
+    if (!Array.isArray(value)) continue;
+    const substitutions = value.filter((s): s is string => typeof s === "string");
+    const starAt = key.indexOf("*");
+    if (starAt !== -1 && key.indexOf("*", starAt + 1) !== -1) continue;
+    patterns.push(
+      starAt === -1
+        ? { key, prefix: key, suffix: undefined, substitutions }
+        : { key, prefix: key.slice(0, starAt), suffix: key.slice(starAt + 1), substitutions },
+    );
+  }
+  return { base: chain.baseUrl ?? chain.paths.declaredIn, patterns };
+}
+
+function tsconfigPathsFor(configPath: string): TsconfigPaths | undefined {
+  const cached = tsconfigCache.get(configPath);
+  if (cached && cached.stamps.every(([file, mtime]) => mtimeOf(file) === mtime)) return cached.paths;
+  const files: string[] = [];
+  const paths = parsePaths(readConfigChain(configPath, files, new Set()));
+  tsconfigCache.set(configPath, { stamps: files.map((f) => [f, mtimeOf(f)] as const), paths });
+  return paths;
+}
+
+/**
+ * The tsconfig `paths` entry that matches a bare `specifier` imported by
+ * `fromFile`, read from the nearest `tsconfig.json` above it, and the file it
+ * maps the specifier to (`target`, `undefined` when no substitution names an
+ * existing file). `undefined` when no entry matches. An exact key wins over a
+ * pattern, and among patterns the longest prefix wins, as in `tsc`.
+ * Substitutions are tried in order with {@link probeModuleFile}.
+ */
+export function tsconfigPathsMatch(
+  specifier: string,
+  fromFile: string,
+): { key: string; target: string | undefined } | undefined {
+  const configPath = nearestTsconfig(dirname(fromFile));
+  if (configPath === null) return undefined;
+  const paths = tsconfigPathsFor(configPath);
+  if (!paths) return undefined;
+
+  let best: PathsPattern | undefined;
+  for (const pattern of paths.patterns) {
+    if (pattern.suffix === undefined) {
+      if (pattern.key === specifier) {
+        best = pattern;
+        break;
+      }
+      continue;
+    }
+    if (
+      specifier.length >= pattern.prefix.length + pattern.suffix.length &&
+      specifier.startsWith(pattern.prefix) &&
+      specifier.endsWith(pattern.suffix) &&
+      (best === undefined || pattern.prefix.length > best.prefix.length)
+    ) {
+      best = pattern;
+    }
+  }
+  if (!best) return undefined;
+
+  const star =
+    best.suffix === undefined ? "" : specifier.slice(best.prefix.length, specifier.length - best.suffix.length);
+  for (const substitution of best.substitutions) {
+    const target = probeModuleFile(resolvePath(paths.base, substitution.split("*").join(star)));
+    if (target !== undefined) return { key: best.key, target };
+  }
+  return { key: best.key, target: undefined };
+}
+
+/** The file {@link tsconfigPathsMatch} maps `specifier` to, or `undefined`. */
+export function tsconfigPathsTarget(specifier: string, fromFile: string): string | undefined {
+  return tsconfigPathsMatch(specifier, fromFile)?.target;
+}

package/src/fold/fold.test.ts

@@ -492,6 +492,7 @@ describe("fold — intrinsic tagged templates", () => {
     expect(fold(expr, consts, [SUB])).toEqual({
       __intrinsic: "Sub",
       strings: ["", "-data"],
+      raw: ["", "-data"],
       values: ["prefix"],
     });
   });
@@ -504,6 +505,7 @@ describe("fold — intrinsic tagged templates", () => {
     expect(fold(expr, consts, [INTRINSIC])).toEqual({
       __intrinsic: "Intrinsic",
       strings: ["", "-data"],
+      raw: ["", "-data"],
       values: [{ __symbol: "Params.StackName" }],
     });
   });
@@ -519,6 +521,7 @@ describe("fold — intrinsic tagged templates", () => {
     expect(fold(expr, consts, [SUB])).toEqual({
       __intrinsic: "Sub",
       strings: ["", "/*"],
+      raw: ["", "/*"],
       values: [{ __attrRef: { entity: "bucket", attribute: "arn" } }],
     });
   });
@@ -527,7 +530,41 @@ describe("fold — intrinsic tagged templates", () => {
     const consts = parseConsts("const x = Sub`plain-value`;");
     const expr = consts.get("x");
     if (!expr) throw new Error("fixture error");
-    expect(fold(expr, consts, [SUB])).toEqual({ __intrinsic: "Sub", strings: ["plain-value"], values: [] });
+    expect(fold(expr, consts, [SUB])).toEqual({
+      __intrinsic: "Sub",
+      strings: ["plain-value"],
+      raw: ["plain-value"],
+      values: [],
+    });
+  });
+
+  // chant #3196 — the envelope carries the raw parts beside the cooked ones,
+  // exactly as the TemplateStringsArray running the tag would.
+  test("a backslash-bearing template carries both its cooked and raw parts", () => {
+    const consts = parseConsts("const x = Sub`DEFAULT '\\d+\\t' ${1} \\`q\\``;");
+    const expr = consts.get("x");
+    if (!expr) throw new Error("fixture error");
+    const run = ((s: TemplateStringsArray, ..._values: unknown[]) => ({ strings: [...s], raw: [...s.raw] }))`DEFAULT '\d+\t' ${1} \`q\``;
+    expect(fold(expr, consts, [SUB])).toEqual({ __intrinsic: "Sub", ...run, values: [1] });
+  });
+
+  test("raw parts normalize CRLF line endings the way the language does", () => {
+    const consts = parseConsts("const x = Sub`a\r\nb\rc${1}d`;");
+    const expr = consts.get("x");
+    if (!expr) throw new Error("fixture error");
+    expect(fold(expr, consts, [SUB])).toMatchObject({ strings: ["a\nb\nc", "d"], raw: ["a\nb\nc", "d"] });
+  });
+
+  test("a template whose escape has no cooked value is refused, not folded to a different string", () => {
+    for (const body of ["\\u{zz}", "\\xg1", "\\1", "\\01"]) {
+      const consts = parseConsts(`const x = Sub\`a\${1}${body}\`;`);
+      const expr = consts.get("x");
+      if (!expr) throw new Error("fixture error");
+      expect(() => fold(expr, consts, [SUB])).toThrow(/no cooked value/);
+    }
+    const ok = parseConsts("const x = Sub`\\0 \\x41 \\u0041 \\u{1F600} \\\\1`;").get("x");
+    if (!ok) throw new Error("fixture error");
+    expect(fold(ok, new Map(), [SUB])).toMatchObject({ strings: ["\0 A A \u{1F600} \\1"] });
   });
 
   test("an unregistered tagged template is rejected with a located FoldError", () => {
@@ -588,6 +625,7 @@ describe("fold — registered call-form intrinsics (#1044)", () => {
     expect(fold(expr, consts, [SUB, REF])).toEqual({
       __intrinsic: "Sub",
       strings: ["", "-fn"],
+      raw: ["", "-fn"],
       values: [{ __intrinsic: "Ref", args: ["prod"] }],
     });
   });

package/src/fold/fold.ts

@@ -198,7 +198,7 @@ export interface AttrRefValue {
 /**
  * The result of folding a registered lexicon intrinsic tagged template
  * (e.g. `Sub\`${AWS.StackName}-x\``) to its node form: tag name, cooked
- * template string parts, and folded interpolated values (in order).
+ * and raw template string parts, and folded interpolated values (in order).
  * Mirrors the runtime call shape `Tag(strings, ...values)` so a later
  * build path can replay it into the real intrinsic object (#1022).
  */
@@ -208,6 +208,8 @@ export type FoldedIntrinsic = FoldedIntrinsicTag | FoldedIntrinsicCall;
 export interface FoldedIntrinsicTag {
   __intrinsic: string;
   strings: string[];
+  /** The raw parts (`TemplateStringsArray.raw`), so the revived call sees what a real tagged call sees. */
+  raw: string[];
   values: FoldedValue[];
 }
 
@@ -1117,6 +1119,51 @@ function foldIntrinsicValue(
   return fold(node, consts, intrinsics, externals);
 }
 
+/**
+ * A template part's raw text, as `TemplateStringsArray.raw` holds it. The
+ * parser sets `rawText` on every literal it reads; the fallback takes the
+ * source between the delimiters for a node without one. Line terminators are
+ * normalized the way the language does for `raw` (`\r\n` and `\r` become
+ * `\n`), which TypeScript's `rawText` does not do.
+ */
+function rawTemplateText(
+  part: ts.NoSubstitutionTemplateLiteral | ts.TemplateHead | ts.TemplateMiddle | ts.TemplateTail,
+): string {
+  let raw = part.rawText;
+  if (raw === undefined) {
+    const text = part.getText();
+    const close = ts.isTemplateHead(part) || ts.isTemplateMiddle(part) ? 2 : 1;
+    raw = text.slice(1, text.length - close);
+  }
+  return raw.replace(/\r\n?/g, "\n");
+}
+
+/**
+ * True when a raw template part holds an escape a tagged template allows but
+ * cannot cook (`\u{zz}`, `\xg`, `\1`, `\01`). Its cooked string is
+ * `undefined` at run time, while TypeScript's `text` carries a string, so
+ * folding it would hand the tag something running never does.
+ */
+function hasInvalidTemplateEscape(raw: string): boolean {
+  for (let i = 0; i < raw.length; i++) {
+    if (raw[i] !== "\\") continue;
+    const rest = raw.slice(i + 1);
+    const c = rest[0];
+    if (c === "x") {
+      if (!/^x[0-9a-fA-F]{2}/.test(rest)) return true;
+    } else if (c === "u") {
+      const m = /^u(?:[0-9a-fA-F]{4}|\{([0-9a-fA-F]+)\})/.exec(rest);
+      if (!m || (m[1] !== undefined && parseInt(m[1], 16) > 0x10ffff)) return true;
+    } else if (c !== undefined && c >= "1" && c <= "9") {
+      return true;
+    } else if (c === "0" && rest[1] !== undefined && rest[1] >= "0" && rest[1] <= "9") {
+      return true;
+    }
+    i += 1;
+  }
+  return false;
+}
+
 /**
  * Fold a `TaggedTemplateExpression` whose tag is a registered, foldable
  * lexicon intrinsic ({@link intrinsicTagFolds}, `../lexicon.ts`) to its node
@@ -1126,6 +1173,11 @@ function foldIntrinsicValue(
  * Checks the TAG-form predicate specifically (chant #1044): an intrinsic
  * whose lexicon opted its plain-call form in is not thereby usable as a
  * tagged template, and `` Ref`...` `` stays a rejection.
+ *
+ * The envelope carries both the cooked parts and the raw ones (#3196), so the
+ * revived call receives the `TemplateStringsArray` a real tagged call does. A
+ * tag that reads `strings.raw` (a SQL tag keeping `'\d+'` as written) would
+ * otherwise build different text folded than run.
  */
 function foldTaggedTemplate(
   node: ts.TaggedTemplateExpression,
@@ -1140,15 +1192,21 @@ function foldTaggedTemplate(
   }
 
   const template = node.template;
-  if (ts.isNoSubstitutionTemplateLiteral(template)) {
-    return { __intrinsic: tagName, strings: [template.text], values: [] };
+  const parts = ts.isNoSubstitutionTemplateLiteral(template)
+    ? [template]
+    : [template.head, ...template.templateSpans.map((span) => span.literal)];
+  const raw = parts.map(rawTemplateText);
+  if (raw.some(hasInvalidTemplateEscape)) {
+    throw foldError(
+      node,
+      `${briefNodeText(node.tag)}\`...\` holds an escape sequence with no cooked value — not foldable, falls back to run`,
+    );
   }
-
-  const strings = [template.head.text, ...template.templateSpans.map((span) => span.literal.text)];
-  const values = template.templateSpans.map((span) =>
-    foldIntrinsicValue(span.expression, consts, intrinsics, externals),
-  );
-  return { __intrinsic: tagName, strings, values };
+  const strings = parts.map((part) => part.text);
+  const values = ts.isNoSubstitutionTemplateLiteral(template)
+    ? []
+    : template.templateSpans.map((span) => foldIntrinsicValue(span.expression, consts, intrinsics, externals));
+  return { __intrinsic: tagName, strings, raw, values };
 }
 
 /**
@@ -1336,6 +1394,22 @@ export function fold(
     // property-access branch below consults `consts` first, so a sibling
     // attribute reference is still the symbolic `{__attrRef}` the serializer
     // resolves by NAME. Nothing about the existing envelope changes.
+    //
+    // chant #3196 — the same holds for a same-file `const x = tag\`...\``
+    // whose tag returns an entity (a SQL `table`): re-folding the initializer
+    // would call the tag again and build a second entity discovery never
+    // registers. The caller pre-resolves those too; without it the
+    // initializer re-folds as before.
+    //
+    // chant#3325 — and a same-file `const x = Composite({...})` that a
+    // composite call's props name: the caller resolves it on the live spine
+    // and puts the instance here. Without it the call is refused below.
+    if (
+      (ts.isTaggedTemplateExpression(initializer) || ts.isCallExpression(initializer)) &&
+      externals?.has(node.text)
+    ) {
+      return externals.get(node.text) as FoldedValue;
+    }
     if (ts.isNewExpression(initializer)) {
       if (externals?.has(node.text)) return externals.get(node.text) as FoldedValue;
       throw foldError(