@wular/pnext 0.1.6 → 0.1.8

package/dist/server/_chunks/index-x9c55pzy.js

@@ -0,0 +1,871 @@
+// @bun
+import {
+  isCommonJsModuleSource
+} from "./index-d1jsmhhk.js";
+import {
+  loadNative
+} from "./index-7wc9n8be.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/runtime/module-transform.ts
+var transformSync = (...args) => loadNative(() => __require("oxc-transform")).transformSync(...args);
+var NON_LITERAL_DYNAMIC_IMPORT = /\bimport\s*\(\s*(?!['"])[^)]/;
+var REQUIRE_CALL = /\brequire\s*\(/;
+var COMMONJS_EXPORTS = /\bmodule\.exports\b|\bexports\s*\.\s*[A-Za-z_$]/;
+var ENUM_DECLARATION = /(?:^|[^.\w$])enum\s+[A-Za-z_$]/;
+function transformBailReason(source, file) {
+  if (REQUIRE_CALL.test(source) || COMMONJS_EXPORTS.test(source) || isCommonJsModuleSource(source, file)) {
+    return "commonjs";
+  }
+  if (NON_LITERAL_DYNAMIC_IMPORT.test(source))
+    return "glob-import";
+  if (ENUM_DECLARATION.test(source))
+    return "enum";
+  return;
+}
+function transformServerModule(source, file, define) {
+  const options = {
+    lang: langForFile(file),
+    jsx: { runtime: "automatic", importSource: "preact" },
+    sourcemap: false,
+    ...define ? { define } : {}
+  };
+  const result = transformSync(file, source, options);
+  if (result.errors.length > 0)
+    return { bail: "parse-error" };
+  if (Object.keys(result.helpersUsed).length > 0)
+    return { bail: "helpers" };
+  return { code: dropUnreferencedImports(result.code) };
+}
+function langForFile(file) {
+  if (/\.[mc]?ts$/.test(file))
+    return "ts";
+  if (file.endsWith(".tsx"))
+    return "tsx";
+  return "jsx";
+}
+var SPECIFIER_RE = /(?:^|[\n;{}])\s*(?:import|export)\b[^;'"]*?\bfrom\s*("[^"]*"|'[^']*')|(?:^|[\n;{}])\s*import\s*("[^"]*"|'[^']*')|\bimport\s*\(\s*("[^"]*"|'[^']*')\s*\)/g;
+function outputSpecifiers(code) {
+  const found = [];
+  SPECIFIER_RE.lastIndex = 0;
+  let match;
+  while (match = SPECIFIER_RE.exec(code)) {
+    for (let group = 1;group <= 3; group += 1) {
+      const literal = match[group];
+      if (literal === undefined)
+        continue;
+      const start = match.index + match[0].lastIndexOf(literal);
+      found.push({
+        start,
+        end: start + literal.length,
+        value: literal.slice(1, -1),
+        kind: group === 3 ? "dynamic-import" : "import-statement"
+      });
+    }
+  }
+  return found;
+}
+function spliceSource(code, edits) {
+  let next = code;
+  for (const edit of [...edits].sort((a, b) => b.start - a.start)) {
+    next = `${next.slice(0, edit.start)}${edit.value}${next.slice(edit.end)}`;
+  }
+  return next;
+}
+var IMPORT_STATEMENT_RE = /(?:^|\n)[ \t]*import\s+([A-Za-z_$][\w$]*\s*,\s*)?(?:\*\s*as\s+([A-Za-z_$][\w$]*)|\{([^}]*)\}|([A-Za-z_$][\w$]*))\s+from\s*(?:"[^"]*"|'[^']*')\s*;?/g;
+function dropUnreferencedImports(code) {
+  const statements = [];
+  IMPORT_STATEMENT_RE.lastIndex = 0;
+  let match;
+  while (match = IMPORT_STATEMENT_RE.exec(code)) {
+    const [text, defaultWithNamed, namespace, named, defaultOnly] = match;
+    const names = [];
+    if (defaultWithNamed)
+      names.push(defaultWithNamed.replace(/\s*,\s*$/, "").trim());
+    if (namespace)
+      names.push(namespace);
+    if (defaultOnly)
+      names.push(defaultOnly);
+    if (named !== undefined) {
+      for (const part of named.split(",")) {
+        const local = part.split(/\bas\b/).pop()?.trim();
+        if (!local)
+          continue;
+        if (!/^[A-Za-z_$][\w$]*$/.test(local))
+          return code;
+        names.push(local);
+      }
+    }
+    if (names.length === 0)
+      continue;
+    const leading = text.startsWith(`
+`) ? 1 : 0;
+    statements.push({ start: match.index + leading, end: match.index + text.length, names });
+  }
+  if (statements.length === 0)
+    return code;
+  const gaps = [];
+  let cursor = 0;
+  for (const statement of statements) {
+    gaps.push(code.slice(cursor, statement.start));
+    cursor = statement.end;
+  }
+  gaps.push(code.slice(cursor));
+  const used = referencedNames(gaps.join(`
+`));
+  const unused = statements.filter((statement) => statement.names.every((name) => !used.has(name)));
+  if (unused.length === 0)
+    return code;
+  return spliceSource(code, unused.map(({ start, end }) => ({ start, end, value: "" })));
+}
+var IDENTIFIER_RE = /[A-Za-z_$][\w$]*/g;
+function referencedNames(body) {
+  const names = new Set;
+  IDENTIFIER_RE.lastIndex = 0;
+  let match;
+  while (match = IDENTIFIER_RE.exec(body)) {
+    if (body[match.index - 1] === "." && body[match.index - 2] !== ".")
+      continue;
+    names.add(match[0]);
+  }
+  return names;
+}
+
+// src/resolve/scan-facts.ts
+var parseSync = (...args) => loadNative(() => __require("oxc-parser")).parseSync(...args);
+var { Bun: bun } = globalThis;
+var stylesheetOrData = /\.(?:css|scss|sass|less|styl|json)$/;
+var emptyFacts = {
+  imports: [],
+  dynamicImports: [],
+  requires: [],
+  exportNames: [],
+  exportStars: [],
+  useClient: false,
+  useServer: false,
+  dynamicCalls: []
+};
+var emptyRewriteFacts = {
+  edges: [],
+  imports: [],
+  importMetas: [],
+  computedImports: [],
+  unreliable: false
+};
+var memo = new Map;
+var hits = 0;
+var misses = 0;
+function scanFacts(file, source) {
+  if (stylesheetOrData.test(file))
+    return emptyFacts;
+  return parsed(file, source).scan;
+}
+function importSpecifiers(source, sourcefile = "source") {
+  const facts = scanFacts(sourcefile, source);
+  return [
+    ...facts.imports.map((edge) => edge.specifier),
+    ...facts.dynamicImports.map((entry) => entry.specifier),
+    ...facts.requires.map((entry) => entry.specifier)
+  ];
+}
+function moduleExportNames(source, sourcefile = "source.tsx") {
+  return scanFacts(sourcefile, source).exportNames;
+}
+function moduleExportStars(source, sourcefile = "source.tsx") {
+  return scanFacts(sourcefile, source).exportStars;
+}
+function dynamicCallFacts(source, file = "module.tsx") {
+  if (stylesheetOrData.test(file))
+    return [];
+  return parsed(file, source).scan.dynamicCalls;
+}
+function rewriteFacts(file, source) {
+  if (stylesheetOrData.test(file))
+    return emptyRewriteFacts;
+  return parsed(file, source).rewrite;
+}
+function moduleSpecifierEdges(source, file = "source") {
+  const facts = rewriteFacts(file, source);
+  return facts.unreliable ? textualEdges(source) : facts.edges;
+}
+function parsed(file, source, lang = langForFile2(file)) {
+  const key = `${lang}\x00${source.length}\x00${bun.hash(source).toString()}`;
+  const cached = memo.get(key);
+  if (cached) {
+    hits += 1;
+    return cached;
+  }
+  misses += 1;
+  const facts = parseFacts(file, source, lang);
+  memo.set(key, facts);
+  return facts;
+}
+function rewriteSpecifierLiterals(source, file, replace) {
+  const edges = moduleSpecifierEdges(source, file);
+  const edits = [];
+  for (const edge of edges) {
+    const value = replace(edge.specifier, edge.kind);
+    if (value !== undefined)
+      edits.push({ start: edge.start, end: edge.end, value });
+  }
+  return edits.length > 0 ? spliceSource(source, edits) : source;
+}
+var textualSpecifier = /(\bfrom\s*|\b(?:import|require)\s*\(\s*)(['"])([^'"]+)\2/g;
+function textualEdges(source) {
+  const edges = [];
+  textualSpecifier.lastIndex = 0;
+  let match;
+  while (match = textualSpecifier.exec(source)) {
+    const start = match.index + match[1].length;
+    edges.push({
+      specifier: match[3],
+      start,
+      end: start + match[3].length + 2,
+      kind: match[1].includes("require") ? "require" : match[1].includes("import") ? "dynamic" : "import"
+    });
+  }
+  return edges;
+}
+function scanFactsStats() {
+  return { hits, misses, sources: memo.size };
+}
+function parseFacts(file, source, lang) {
+  const result = parseSync(file, source, { lang });
+  const imports = [];
+  const exportNames = [];
+  const exportStars = [];
+  const edges = [];
+  const importStatements = [];
+  for (const statement of result.module.staticImports) {
+    const names = [];
+    const bindings = [];
+    let bindsValue = statement.entries.length === 0;
+    for (const entry of statement.entries) {
+      const kind = entry.importName.kind;
+      bindings.push({
+        imported: kind === "Default" ? "default" : kind === "NamespaceObject" ? "*" : entry.importName.name ?? "",
+        local: entry.localName.value ?? "",
+        type: entry.isType
+      });
+      if (entry.isType)
+        continue;
+      bindsValue = true;
+      if (kind === "Default")
+        names.push("default");
+      else if (kind === "NamespaceObject")
+        names.push("*");
+      else if (entry.importName.name)
+        names.push(entry.importName.name);
+    }
+    importStatements.push({
+      specifier: statement.moduleRequest.value,
+      start: statement.start,
+      end: statement.end,
+      specifierStart: statement.moduleRequest.start,
+      specifierEnd: statement.moduleRequest.end,
+      bindings
+    });
+    edges.push({
+      specifier: statement.moduleRequest.value,
+      start: statement.moduleRequest.start,
+      end: statement.moduleRequest.end,
+      kind: statement.entries.length === 0 ? "side-effect" : "import"
+    });
+    if (!bindsValue)
+      continue;
+    imports.push({
+      specifier: statement.moduleRequest.value,
+      exports: names,
+      index: statement.start
+    });
+  }
+  const seenExportRequests = new Set;
+  for (const statement of result.module.staticExports) {
+    for (const entry of statement.entries) {
+      const request = entry.moduleRequest;
+      if (!request || seenExportRequests.has(request.start))
+        continue;
+      seenExportRequests.add(request.start);
+      edges.push({
+        specifier: request.value,
+        start: request.start,
+        end: request.end,
+        kind: "export"
+      });
+    }
+  }
+  for (const statement of result.module.staticExports) {
+    const edges2 = new Map;
+    for (const entry of statement.entries) {
+      if (entry.isType)
+        continue;
+      const exportKind = entry.exportName.kind;
+      if (exportKind === "Default")
+        exportNames.push("default");
+      else if (entry.exportName.name)
+        exportNames.push(entry.exportName.name);
+      const specifier = entry.moduleRequest?.value;
+      if (!specifier)
+        continue;
+      const importKind = entry.importName.kind;
+      const star = importKind === "AllButDefault";
+      if (star)
+        exportStars.push(specifier);
+      let edge = edges2.get(specifier);
+      if (!edge) {
+        edge = {
+          specifier,
+          exports: [],
+          index: statement.start,
+          reexport: true,
+          exportMap: {}
+        };
+        edges2.set(specifier, edge);
+        imports.push(edge);
+      }
+      if (star)
+        edge.star = true;
+      else if (importKind === "All")
+        edge.exports.push("*");
+      else {
+        const imported = importKind === "Default" ? "default" : entry.importName.name;
+        if (!imported)
+          continue;
+        edge.exports.push(imported);
+        const exported = exportKind === "Default" ? "default" : entry.exportName.name;
+        if (exported)
+          edge.exportMap[exported] = imported;
+      }
+    }
+  }
+  imports.sort((a, b) => a.index - b.index);
+  const dynamicImports = [];
+  const computedImports = [];
+  for (const entry of result.module.dynamicImports) {
+    const raw = source.slice(entry.moduleRequest.start, entry.moduleRequest.end);
+    const specifier = literalSpecifier(raw);
+    if (specifier === undefined) {
+      computedImports.push({ start: entry.start, end: entry.end });
+      continue;
+    }
+    dynamicImports.push({ specifier, index: entry.start });
+    const lead = raw.length - raw.trimStart().length;
+    edges.push({
+      specifier,
+      start: entry.moduleRequest.start + lead,
+      end: entry.moduleRequest.start + lead + specifier.length + 2,
+      kind: "dynamic"
+    });
+  }
+  const requires = requireCalls(source, result.comments);
+  for (const call of requires) {
+    edges.push({
+      specifier: call.specifier,
+      start: call.specifierStart,
+      end: call.specifierStart + call.specifier.length + 2,
+      kind: "require"
+    });
+  }
+  edges.sort((a, b) => a.start - b.start);
+  return {
+    scan: {
+      imports,
+      dynamicImports,
+      requires,
+      exportNames,
+      exportStars,
+      useClient: moduleDirective(source, result, "use client"),
+      useServer: moduleDirective(source, result, "use server"),
+      dynamicCalls: source.includes("@wular/pnext") || source.includes("next/dynamic") ? collectDynamicCalls(result.program) : []
+    },
+    rewrite: {
+      edges,
+      imports: importStatements,
+      importMetas: result.module.importMetas.map((meta) => ({ start: meta.start, end: meta.end })),
+      computedImports,
+      unreliable: result.errors.length > 0
+    }
+  };
+}
+function moduleDirective(source, result, directive) {
+  const sniffed = sniffDirective(source, directive);
+  if (sniffed !== undefined)
+    return sniffed;
+  if (!source.includes(directive))
+    return false;
+  return hasDirective(result.program.body, directive);
+}
+var continuesExpression = /[+\-*/%.,?:=<>!&|^~([`)\]}]/;
+var wordContinuation = /^(?:in|instanceof)\b/;
+var lineTerminator = /[\n\r\u2028\u2029]/;
+function sniffDirective(source, directive) {
+  let index = 0;
+  if (source.startsWith("#!")) {
+    const nl = source.search(lineTerminator);
+    if (nl < 0)
+      return false;
+    index = nl + 1;
+  }
+  for (;; ) {
+    index = skipTrivia(source, index);
+    if (index < 0)
+      return;
+    const quote = source[index];
+    if (quote !== '"' && quote !== "'")
+      return false;
+    let end = index + 1;
+    while (end < source.length) {
+      const char = source[end];
+      if (char === "\\" || lineTerminator.test(char))
+        return;
+      if (char === quote)
+        break;
+      end += 1;
+    }
+    if (end >= source.length)
+      return;
+    const raw = source.slice(index + 1, end);
+    const after = skipTrivia(source, end + 1);
+    if (after < 0)
+      return;
+    const next = source[after];
+    let terminated = after >= source.length || next === ";";
+    if (!terminated && lineTerminator.test(source.slice(end + 1, after))) {
+      terminated = !continuesExpression.test(next) && !wordContinuation.test(source.slice(after, after + 11));
+    }
+    if (!terminated)
+      return;
+    if (raw === directive)
+      return true;
+    index = next === ";" ? after + 1 : after;
+    if (index >= source.length)
+      return false;
+  }
+}
+function skipTrivia(source, index) {
+  for (;; ) {
+    while (index < source.length && /\s/.test(source[index]))
+      index += 1;
+    if (source[index] !== "/")
+      return index;
+    if (source[index + 1] === "/") {
+      let end = index + 2;
+      while (end < source.length && !lineTerminator.test(source[end]))
+        end += 1;
+      index = end;
+      continue;
+    }
+    if (source[index + 1] === "*") {
+      const end = source.indexOf("*/", index + 2);
+      if (end < 0)
+        return -1;
+      index = end + 2;
+      continue;
+    }
+    return index;
+  }
+}
+function hasDirective(body, directive) {
+  for (const statement of body) {
+    if (statement.type !== "ExpressionStatement" || typeof statement.directive !== "string")
+      return false;
+    if (statement.directive === directive)
+      return true;
+  }
+  return false;
+}
+var requirePattern = /\brequire\s*\(\s*(['"])([^'"]+)\1\s*\)/g;
+function requireCalls(source, comments) {
+  const calls = [];
+  if (!source.includes("require"))
+    return calls;
+  requirePattern.lastIndex = 0;
+  let match;
+  let cursor = 0;
+  while (match = requirePattern.exec(source)) {
+    const index = match.index;
+    while (cursor < comments.length && comments[cursor].end <= index)
+      cursor += 1;
+    if (cursor < comments.length && index >= comments[cursor].start)
+      continue;
+    calls.push({
+      specifier: match[2],
+      index,
+      specifierStart: index + match[0].indexOf(match[1])
+    });
+  }
+  return calls;
+}
+function literalSpecifier(raw) {
+  return /^\s*(['"])([^'"]*)\1\s*$/.exec(raw)?.[2] || undefined;
+}
+function isNode(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function child(node, key) {
+  const value = node?.[key];
+  return isNode(value) ? value : undefined;
+}
+var noMetaRefs = {
+  urls: [],
+  resolves: [],
+  readsLocation: false,
+  computedImports: [],
+  unreliable: false
+};
+var metaRefMemo = new Map;
+var locationMembers = new Set(["url", "dirname", "filename", "resolve"]);
+function importMetaRefs(file, source) {
+  if (stylesheetOrData.test(file))
+    return noMetaRefs;
+  if (!source.includes("import.meta") && !source.includes("import("))
+    return noMetaRefs;
+  const record = rewriteFacts(file, source);
+  if (record.importMetas.length === 0)
+    return { ...noMetaRefs, computedImports: record.computedImports, unreliable: record.unreliable };
+  const lang = langForFile2(file);
+  const key = `${lang}\x00${source.length}\x00${bun.hash(source).toString()}`;
+  const cached = metaRefMemo.get(key);
+  if (cached)
+    return cached;
+  const result = parseSync(file, source, { lang });
+  const refs = {
+    ...noMetaRefs,
+    urls: [],
+    resolves: [],
+    computedImports: record.computedImports
+  };
+  refs.unreliable = result.errors.length > 0;
+  const isImportMeta = (node) => node?.type === "MetaProperty" && child(node, "meta")?.name === "import" && child(node, "property")?.name === "meta";
+  const memberName = (node) => node.computed ? stringValue(child(node, "property")) : child(node, "property")?.name;
+  const literal = (node) => {
+    if (!node)
+      return;
+    const value = stringValue(node) ?? (node.type === "TemplateLiteral" && node.expressions.length === 0 ? node.quasis[0]?.value?.cooked : undefined);
+    return value === undefined ? undefined : { specifier: value, start: node.start, end: node.end };
+  };
+  const visit = (value, parent) => {
+    if (Array.isArray(value)) {
+      for (const item of value)
+        visit(item, parent);
+      return;
+    }
+    if (!isNode(value))
+      return;
+    if (isImportMeta(value)) {
+      const member = parent?.type === "MemberExpression" && parent.object === value;
+      if (!member || locationMembers.has(memberName(parent) ?? ""))
+        refs.readsLocation = true;
+    } else if (value.type === "NewExpression" && child(value, "callee")?.name === "URL") {
+      const [target, base] = value.arguments;
+      const span = literal(target);
+      if (span && base?.type === "MemberExpression" && isImportMeta(child(base, "object"))) {
+        if (memberName(base) === "url")
+          refs.urls.push(span);
+      }
+    } else if (value.type === "CallExpression") {
+      const callee = child(value, "callee");
+      if (callee?.type === "MemberExpression" && isImportMeta(child(callee, "object"))) {
+        const span = literal(value.arguments[0]);
+        if (span && memberName(callee) === "resolve")
+          refs.resolves.push(span);
+      }
+    }
+    for (const key2 in value) {
+      if (key2 !== "start" && key2 !== "end" && key2 !== "type")
+        visit(value[key2], value);
+    }
+  };
+  visit(result.program, undefined);
+  metaRefMemo.set(key, refs);
+  return refs;
+}
+function hasModuleState(file, source) {
+  const result = parseSync(file, source, { lang: langForFile2(file) });
+  const pureEnds = new Set(result.comments.filter((comment) => /^\s*[#@]__PURE__\s*$/.test(comment.value)).map((comment) => comment.end));
+  const annotatedPure = (node) => {
+    for (let index = node.start - 1;index >= 0; index -= 1) {
+      if (pureEnds.has(index + 1))
+        return true;
+      if (!/\s/.test(source[index]))
+        return false;
+    }
+    return false;
+  };
+  const plainCallee = (node) => node?.type === "Identifier" || node?.type === "MemberExpression" && !node.computed && plainCallee(child(node, "object"));
+  const declarations = result.program.body.flatMap((statement) => {
+    const declaration = statement.type === "ExportNamedDeclaration" ? child(statement, "declaration") : statement;
+    return declaration?.type === "VariableDeclaration" ? declaration.declarations : [];
+  });
+  return declarations.some((declarator) => {
+    const init = unwrapExpression(child(declarator, "init"));
+    if (init?.type === "NewExpression")
+      return true;
+    if (init?.type !== "CallExpression")
+      return false;
+    const callee = child(init, "callee");
+    return plainCallee(callee) && callee?.name !== "require" && !annotatedPure(init);
+  });
+}
+function absolutePathLiterals(file, source) {
+  const result = parseSync(file, source, { lang: langForFile2(file) });
+  if (result.errors.length > 0)
+    return;
+  const found = [];
+  const visit = (value, parent) => {
+    if (Array.isArray(value)) {
+      for (const item of value)
+        visit(item, parent);
+      return;
+    }
+    if (!isNode(value))
+      return;
+    const literal = stringValue(value);
+    if (literal !== undefined && (literal.startsWith("/") || literal.startsWith("file:///"))) {
+      const key = parent?.type === "Property" && parent.key === value && !parent.computed;
+      found.push({ value: literal, start: value.start, end: value.end, key });
+    }
+    for (const key in value) {
+      if (key !== "start" && key !== "end" && key !== "type")
+        visit(value[key], value);
+    }
+  };
+  visit(result.program, undefined);
+  return found;
+}
+function lineComments(file, source) {
+  const result = parseSync(file, source, { lang: langForFile2(file) });
+  if (result.errors.length > 0)
+    return;
+  return result.comments.filter((comment) => comment.type === "Line").map((comment) => ({ value: comment.value, start: comment.start, end: comment.end }));
+}
+function stripJsonImportAttributes(source, file, compiled) {
+  const result = parseSync(file, source, { lang: "js", sourceType: "module" });
+  if (result.errors.length > 0)
+    return source;
+  const edits = [];
+  const visit = (node) => {
+    const target = child(node, "source");
+    const specifier = stringValue(target);
+    if (target && specifier !== undefined && compiled(specifier)) {
+      const attributes = node.attributes;
+      const options = child(node, "options");
+      if (attributes?.length && attributes.every(jsonTypeAttribute)) {
+        const end = source.indexOf("}", attributes.at(-1).end) + 1;
+        edits.push({ start: target.end, end, value: "" });
+      } else if (node.type === "ImportExpression" && options && jsonImportOptions(options)) {
+        edits.push({ start: target.end, end: options.end, value: "" });
+      }
+    }
+    for (const value of Object.values(node)) {
+      if (isNode(value))
+        visit(value);
+      else if (Array.isArray(value)) {
+        for (const item of value)
+          if (isNode(item))
+            visit(item);
+      }
+    }
+  };
+  visit(result.program);
+  return edits.length > 0 ? spliceSource(source, edits) : source;
+}
+function propertyName(node) {
+  if (!node)
+    return;
+  return node.type === "Identifier" ? node.name : stringValue(node);
+}
+function jsonTypeAttribute(node) {
+  return !node.computed && propertyName(child(node, "key")) === "type" && stringValue(child(node, "value")) === "json";
+}
+function jsonImportOptions(options) {
+  const [property, ...rest] = options.properties ?? [];
+  const attributes = child(property, "value");
+  const entries = attributes?.properties;
+  return options.type === "ObjectExpression" && !!property && rest.length === 0 && property.type === "Property" && !property.computed && ["with", "assert"].includes(propertyName(child(property, "key")) ?? "") && attributes?.type === "ObjectExpression" && !!entries?.length && entries.every((entry) => entry.type === "Property" && jsonTypeAttribute(entry));
+}
+function collectDynamicCalls(program) {
+  const calls = [];
+  const visit = (value) => {
+    if (Array.isArray(value)) {
+      for (const item of value)
+        visit(item);
+      return;
+    }
+    if (!isNode(value))
+      return;
+    if (value.type === "CallExpression") {
+      const fact = dynamicCallFact(value);
+      if (fact)
+        calls.push(fact);
+    }
+    for (const key in value) {
+      if (key === "type" || key === "loc" || key === "range")
+        continue;
+      const entry = value[key];
+      if (entry && typeof entry === "object")
+        visit(entry);
+    }
+  };
+  visit(program.body);
+  return calls.sort((a, b) => a.start - b.start);
+}
+function dynamicCallFact(call) {
+  const callee = child(call, "callee");
+  if (callee?.type !== "Identifier")
+    return;
+  const args = call.arguments;
+  if (!Array.isArray(args) || !isNode(args[0]))
+    return;
+  const loader = args[0];
+  let target;
+  let literal;
+  if (stringValue(loader) !== undefined) {
+    target = { specifier: loader, exportName: "default" };
+    literal = true;
+  } else if (loader.type === "ArrowFunctionExpression" || loader.type === "FunctionExpression") {
+    target = loaderImportTarget(loader) ?? firstImportTarget(loader);
+  }
+  if (!target)
+    return;
+  const specifier = stringValue(target.specifier);
+  if (specifier === undefined)
+    return;
+  const options = isNode(args[1]) ? args[1] : undefined;
+  return {
+    name: callee.name,
+    start: callee.start,
+    end: call.end,
+    specifier,
+    specifierStart: target.specifier.start,
+    specifierEnd: target.specifier.end,
+    exportName: target.exportName,
+    ...literal ? { literal } : {},
+    loaderEnd: loader.end,
+    ...options ? { optionsStart: options.start, optionsEnd: options.end } : {}
+  };
+}
+function stringValue(node) {
+  if (!node)
+    return;
+  if (node.type !== "Literal" && node.type !== "StringLiteral")
+    return;
+  return typeof node.value === "string" ? node.value : undefined;
+}
+function unwrapExpression(node) {
+  let current = node;
+  for (;; ) {
+    if (!current)
+      return;
+    if (current.type === "ParenthesizedExpression" || current.type === "ChainExpression") {
+      current = child(current, "expression");
+    } else if (current.type === "AwaitExpression") {
+      current = child(current, "argument");
+    } else if (current.type === "TSAsExpression" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression") {
+      current = child(current, "expression");
+    } else {
+      return current;
+    }
+  }
+}
+function loaderResult(fn) {
+  const body = child(fn, "body");
+  if (!body)
+    return;
+  if (body.type !== "BlockStatement" && body.type !== "FunctionBody")
+    return unwrapExpression(body);
+  const statements = body.body;
+  if (!Array.isArray(statements))
+    return;
+  for (const statement of statements) {
+    if (isNode(statement) && statement.type === "ReturnStatement") {
+      return unwrapExpression(child(statement, "argument"));
+    }
+  }
+  return;
+}
+function importSource(node) {
+  if (node?.type !== "ImportExpression")
+    return;
+  const source = child(node, "source");
+  return source && stringValue(source) !== undefined ? source : undefined;
+}
+function loaderImportTarget(fn) {
+  const result = loaderResult(fn);
+  if (!result)
+    return;
+  const direct = importSource(result);
+  if (direct)
+    return { specifier: direct, exportName: "default" };
+  if (result.type === "MemberExpression" && result.computed !== true) {
+    const source2 = importSource(unwrapExpression(child(result, "object")));
+    const property = child(result, "property");
+    if (source2 && property?.type === "Identifier") {
+      return { specifier: source2, exportName: property.name };
+    }
+  }
+  if (result.type !== "CallExpression")
+    return;
+  const callee = child(result, "callee");
+  if (callee?.type !== "MemberExpression" || callee.computed === true)
+    return;
+  if (child(callee, "property")?.name !== "then")
+    return;
+  const source = importSource(unwrapExpression(child(callee, "object")));
+  if (!source)
+    return;
+  return { specifier: source, exportName: thenArmExport(result) ?? "default" };
+}
+function thenArmExport(thenCall) {
+  const args = thenCall.arguments;
+  if (!Array.isArray(args) || !isNode(args[0]))
+    return;
+  const arm = args[0];
+  if (arm.type !== "ArrowFunctionExpression" && arm.type !== "FunctionExpression")
+    return;
+  const params = arm.params;
+  const param = Array.isArray(params) && isNode(params[0]) ? params[0] : undefined;
+  if (param?.type !== "Identifier")
+    return;
+  const result = loaderResult(arm);
+  if (result?.type !== "MemberExpression" || result.computed === true)
+    return;
+  const object = unwrapExpression(child(result, "object"));
+  if (object?.type !== "Identifier" || object.name !== param.name)
+    return;
+  const property = child(result, "property");
+  return property?.type === "Identifier" ? property.name : undefined;
+}
+function firstImportTarget(fn) {
+  let found;
+  const visit = (value) => {
+    if (found)
+      return;
+    if (Array.isArray(value)) {
+      for (const item of value)
+        visit(item);
+      return;
+    }
+    if (!isNode(value))
+      return;
+    const source = importSource(value);
+    if (source) {
+      found = source;
+      return;
+    }
+    for (const key in value) {
+      const entry = value[key];
+      if (entry && typeof entry === "object")
+        visit(entry);
+    }
+  };
+  visit(fn.body);
+  return found ? { specifier: found, exportName: "default" } : undefined;
+}
+function langForFile2(file) {
+  return /\.[mc]?ts$/.test(file) ? "ts" : "tsx";
+}
+
+export { transformBailReason, transformServerModule, outputSpecifiers, spliceSource, scanFacts, importSpecifiers, moduleExportNames, moduleExportStars, dynamicCallFacts, rewriteFacts, moduleSpecifierEdges, rewriteSpecifierLiterals, scanFactsStats, importMetaRefs, hasModuleState, absolutePathLiterals, lineComments, stripJsonImportAttributes };