@wular/coder 0.3.18 → 0.4.1

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/chunk-NQE46AZN.js

@@ -0,0 +1,647 @@
+import { createRequire as __coderRequire } from "node:module";
+const __pnextRoot = __coderRequire(import.meta.url).resolve("@wular/pnext").replace(/\/src\/index\.ts$/, "");
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire(("file://" + __pnextRoot + "/package.json"));
+import {
+  isCommonJsModuleSource
+} from "./chunk-4P5CMIYT.js";
+import {
+  __require,
+  loadNative
+} from "./chunk-3UPROT2C.js";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/client/reference.ts
+import { createHash } from "node:crypto";
+import path from "node:path";
+var compiledClientReferences = /* @__PURE__ */ new Set();
+function noteCompiledClientReference(file) {
+  compiledClientReferences.add(path.resolve(file));
+}
+var clientReferenceSymbol = Symbol.for("pnext.clientReference");
+function clientReferenceId(file, exportName) {
+  return createHash("sha256").update(file).update("\0").update(exportName).digest("hex").slice(0, 10);
+}
+function ssrClientReference(reference) {
+  if (reference.sideEffect) return false;
+  if (reference.dynamic?.ssr === false) return false;
+  if (reference.dynamic?.load === "visible" && reference.dynamic.ssr !== true) return false;
+  return true;
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/runtime/module-transform.ts
+var transformSync = (...args) => (
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  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 void 0;
+}
+function transformServerModule(source, file, define) {
+  const options = {
+    lang: langForFile(file),
+    jsx: { runtime: "automatic", importSource: "preact" },
+    // No `target`: these modules are loaded by Bun, so syntax lowering buys nothing and oxc's
+    // lowering plugins are expensive on the transform line.
+    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 === void 0) 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 !== void 0) {
+      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("\n") ? 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("\n"));
+  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 = /* @__PURE__ */ 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;
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/resolve/scan-facts.ts
+var parseSync = (...args) => (
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  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: [],
+  unreliable: false
+};
+var memo = /* @__PURE__ */ 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}\0${source.length}\0${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 !== void 0) 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 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = [];
+  for (const entry of result.module.dynamicImports) {
+    const raw = source.slice(entry.moduleRequest.start, entry.moduleRequest.end);
+    const specifier = literalSpecifier(raw);
+    if (specifier === void 0) 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"),
+      // `result.program` deserializes the whole AST: walk it only for sources
+      // that can bind `dynamic()` at all (same cheap gate as resolve/dynamic.ts).
+      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 })),
+      unreliable: result.errors.length > 0
+    }
+  };
+}
+function moduleDirective(source, result, directive) {
+  const sniffed = sniffDirective(source, directive);
+  if (sniffed !== void 0) 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 void 0;
+    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 void 0;
+      if (char === quote) break;
+      end += 1;
+    }
+    if (end >= source.length) return void 0;
+    const raw = source.slice(index + 1, end);
+    const after = skipTrivia(source, end + 1);
+    if (after < 0) return void 0;
+    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 void 0;
+    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] || void 0;
+}
+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 : void 0;
+}
+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 void 0;
+  const args = call.arguments;
+  if (!Array.isArray(args) || !isNode(args[0])) return void 0;
+  const loader = args[0];
+  let target;
+  let literal;
+  if (stringValue(loader) !== void 0) {
+    target = { specifier: loader, exportName: "default" };
+    literal = true;
+  } else if (loader.type === "ArrowFunctionExpression" || loader.type === "FunctionExpression") {
+    target = loaderImportTarget(loader) ?? firstImportTarget(loader);
+  }
+  if (!target) return void 0;
+  const specifier = stringValue(target.specifier);
+  if (specifier === void 0) return void 0;
+  const options = isNode(args[1]) ? args[1] : void 0;
+  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 void 0;
+  if (node.type !== "Literal" && node.type !== "StringLiteral") return void 0;
+  return typeof node.value === "string" ? node.value : void 0;
+}
+function unwrapExpression(node) {
+  let current = node;
+  for (; ; ) {
+    if (!current) return void 0;
+    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 void 0;
+  if (body.type !== "BlockStatement" && body.type !== "FunctionBody") return unwrapExpression(body);
+  const statements = body.body;
+  if (!Array.isArray(statements)) return void 0;
+  for (const statement of statements) {
+    if (isNode(statement) && statement.type === "ReturnStatement") {
+      return unwrapExpression(child(statement, "argument"));
+    }
+  }
+  return void 0;
+}
+function importSource(node) {
+  if (node?.type !== "ImportExpression") return void 0;
+  const source = child(node, "source");
+  return source && stringValue(source) !== void 0 ? source : void 0;
+}
+function loaderImportTarget(fn) {
+  const result = loaderResult(fn);
+  if (!result) return void 0;
+  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 void 0;
+  const callee = child(result, "callee");
+  if (callee?.type !== "MemberExpression" || callee.computed === true) return void 0;
+  if (child(callee, "property")?.name !== "then") return void 0;
+  const source = importSource(unwrapExpression(child(callee, "object")));
+  if (!source) return void 0;
+  return { specifier: source, exportName: thenArmExport(result) ?? "default" };
+}
+function thenArmExport(thenCall) {
+  const args = thenCall.arguments;
+  if (!Array.isArray(args) || !isNode(args[0])) return void 0;
+  const arm = args[0];
+  if (arm.type !== "ArrowFunctionExpression" && arm.type !== "FunctionExpression") return void 0;
+  const params = arm.params;
+  const param = Array.isArray(params) && isNode(params[0]) ? params[0] : void 0;
+  if (param?.type !== "Identifier") return void 0;
+  const result = loaderResult(arm);
+  if (result?.type !== "MemberExpression" || result.computed === true) return void 0;
+  const object = unwrapExpression(child(result, "object"));
+  if (object?.type !== "Identifier" || object.name !== param.name) return void 0;
+  const property = child(result, "property");
+  return property?.type === "Identifier" ? property.name : void 0;
+}
+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" } : void 0;
+}
+function langForFile2(file) {
+  return /\.[mc]?ts$/.test(file) ? "ts" : "tsx";
+}
+
+export {
+  noteCompiledClientReference,
+  clientReferenceSymbol,
+  clientReferenceId,
+  ssrClientReference,
+  transformBailReason,
+  transformServerModule,
+  outputSpecifiers,
+  spliceSource,
+  scanFacts,
+  importSpecifiers,
+  moduleExportNames,
+  moduleExportStars,
+  dynamicCallFacts,
+  rewriteFacts,
+  moduleSpecifierEdges,
+  rewriteSpecifierLiterals
+};