@vltpkg/cli-js 1.3.7 → 1.4.0

package/{chunk-7BHHCB5C.js → chunk-OVPHE4O7.js}

@@ -13,7 +13,7 @@ import {
   AbortError,
   SecurityArchive,
   pRetry
-} from "./chunk-OWUICQFY.js";
+} from "./chunk-5TNXLRW2.js";
 import {
   Monorepo,
   PackageJson,
@@ -21,7 +21,7 @@ import {
   getUser,
   minimatch,
   platformCheck
-} from "./chunk-CB65DPZ2.js";
+} from "./chunk-I7UMHYZX.js";
 import {
   asDepID,
   baseDepID,
@@ -36,10 +36,10 @@ import {
   joinExtra,
   splitDepID,
   splitExtra
-} from "./chunk-SV4WK3KX.js";
+} from "./chunk-PLG3OYCX.js";
 import {
   Spec as Spec2
-} from "./chunk-GZ5MYMBT.js";
+} from "./chunk-5IJTPZXP.js";
 import {
   load,
   walkUp
@@ -47,7 +47,7 @@ import {
 import {
   userAgent,
   userAgentHeaders
-} from "./chunk-VBDNOU76.js";
+} from "./chunk-ZJMJ7MCT.js";
 import {
   graphStep,
   promiseSpawn
@@ -100,9 +100,10 @@ import {
   shortDependencyTypes,
   subset,
   tarballFormat
-} from "./chunk-IBGFQR23.js";
+} from "./chunk-FLH4YC6W.js";
 import {
   error,
+  syntaxError,
   typeError
 } from "./chunk-WZWDS3W4.js";
 import {
@@ -5542,11 +5543,11 @@ var exec = async (options) => {
     projectRoot,
     "script-shell": shell2 = false,
     color = false,
-    signal,
     ...spawnOptions
   } = options;
   const [spawnCmd, spawnArgs] = withShellArgs(shell2, arg0, args);
   const p = promiseSpawn(spawnCmd, spawnArgs, {
+    // `signal` kills it when aborted
     ...spawnOptions,
     shell: shell2,
     stdio: "pipe",
@@ -5565,6 +5566,10 @@ var exec = async (options) => {
     windowsHide: true
   });
   proxySignals(p.process);
+  p.process.on("error", () => {
+    p.process.stdout.destroy();
+    p.process.stderr.destroy();
+  });
   return await p;
 };
 var execFG = async (options) => {
@@ -5632,6 +5637,85 @@ var runExecFG = async (options) => runExecImpl(options, runFG, execFG);
 // ../../src/dss-parser/src/index.ts
 var import_postcss_selector_parser = __toESM(require_dist(), 1);
 
+// ../../src/dss-parser/src/grammar.ts
+var pseudoClassNames = [
+  "abandoned",
+  "attr",
+  "built",
+  "confused",
+  "cve",
+  "cwe",
+  "debug",
+  "deprecated",
+  "dev",
+  "diff",
+  "dist",
+  "dynamic",
+  "empty",
+  "entropic",
+  "env",
+  "eval",
+  "fs",
+  "has",
+  "host",
+  "hostname",
+  "is",
+  "license",
+  "link",
+  "malware",
+  "minified",
+  "missing",
+  "native",
+  "network",
+  "not",
+  "obfuscated",
+  "optional",
+  "outdated",
+  "overridden",
+  "path",
+  "peer",
+  "prerelease",
+  "private",
+  "prod",
+  "project",
+  "published",
+  "registry",
+  "root",
+  "scanned",
+  "scope",
+  "score",
+  "scripts",
+  "semver",
+  "sev",
+  "severity",
+  "shell",
+  "shrinkwrap",
+  "spec",
+  "squat",
+  "suspicious",
+  "tracker",
+  "trivial",
+  "type",
+  "undesirable",
+  "unknown",
+  "unmaintained",
+  "unpopular",
+  "unstable",
+  "v",
+  "vuln",
+  "vulnerable",
+  "workspace"
+];
+var combinatorNames = [">", "~", " "];
+var attributeOperatorNames = [
+  "=",
+  "^=",
+  "$=",
+  "~=",
+  "*=",
+  "|="
+];
+
 // ../../src/dss-parser/src/types.ts
 var isPostcssNodeWithChildren = (node) => "type" in node && "nodes" in node;
 var asPostcssNodeWithChildren = (node) => {
@@ -5758,7 +5842,68 @@ var pseudoCleanUpNeeded = /* @__PURE__ */ new Set([
   ":vulnerable"
 ]);
 var hasParamsToEscape = (node) => pseudoCleanUpNeeded.has(node.value);
-var parse2 = (query) => {
+var pseudoClasses = new Set(pseudoClassNames);
+var combinators = new Set(combinatorNames);
+var attributeOperators = new Set(attributeOperatorNames);
+var selectorPseudos = /* @__PURE__ */ new Set(["has", "is", "not"]);
+var invalid = (message, found) => syntaxError(message, { code: "EQUERY", found });
+var validate = (selector, query, forgiving = false) => {
+  const nodes = selector.nodes.filter((n) => n.type !== "comment");
+  if (!nodes.length && !forgiving) {
+    throw invalid("Empty selector", query);
+  }
+  nodes.forEach((node, i) => {
+    if (node.type === "id" && !node.value || node.type === "attribute" && !node.attribute) {
+      throw invalid(
+        "Unsupported selector",
+        node.type === "id" ? "#" : "[]"
+      );
+    }
+    if (isCombinatorNode(node)) {
+      if (forgiving) return;
+      if (!combinators.has(node.value)) {
+        throw syntaxError(`Unsupported combinator: ${node.value}`, {
+          code: "EQUERY",
+          found: node.value,
+          validOptions: combinatorNames
+        });
+      }
+      const next = nodes[i + 1];
+      if (!next || isCombinatorNode(next)) {
+        throw invalid("Dangling combinator", query);
+      }
+    } else if (isPseudoNode(node)) {
+      const name = node.value.slice(1);
+      if (!pseudoClasses.has(name)) {
+        if (forgiving) return;
+        throw invalid(
+          `Unsupported pseudo-class: ${node.value}`,
+          node.value
+        );
+      }
+      if (selectorPseudos.has(name)) {
+        for (const n of node.nodes) {
+          validate(
+            asSelectorNode(n),
+            query,
+            forgiving || name === "is"
+          );
+        }
+      }
+    } else if (isAttributeNode(node)) {
+      if (!forgiving && node.operator && !attributeOperators.has(node.operator)) {
+        throw invalid(
+          `Unsupported attribute operator: ${node.operator}`,
+          node.operator
+        );
+      }
+    } else if (isTagNode(node) && node.value !== "{" && node.value !== "}" || isStringNode(node)) {
+      throw invalid("Unsupported selector", node.value);
+    }
+  });
+};
+var parse2 = (query, { loose = false } = {}) => {
+  if (!loose && !query.trim()) throw invalid("Empty query", query);
   const escapedQuery = escapeDots(escapeScopedNamesSlashes(query));
   const transformAst = (root2) => {
     root2.walk((node) => {
@@ -5768,6 +5913,7 @@ var parse2 = (query) => {
       if (isPseudoNode(node) && hasParamsToEscape(node)) {
         for (const n of node.nodes) {
           const selector = asSelectorNode(n);
+          if (!selector.nodes.length) continue;
           selector.nodes.forEach((currentNode, index, arr) => {
             const nextNode = arr[index + 1];
             if (isCombinatorNode(currentNode) && isTagNode(nextNode)) {
@@ -5797,7 +5943,24 @@ var parse2 = (query) => {
       }
     });
   };
-  return (0, import_postcss_selector_parser.default)(transformAst).astSync(escapedQuery);
+  let ast;
+  try {
+    ast = (0, import_postcss_selector_parser.default)(transformAst).astSync(escapedQuery);
+  } catch (err) {
+    const reason = err instanceof TypeError ? "unexpected end of input" : err.message;
+    throw syntaxError(`Invalid query syntax: ${reason}`, {
+      code: "EQUERY",
+      found: query,
+      cause: err
+    });
+  }
+  if (!loose) {
+    if (/(^|[^\\])(\\\\)*,\s*$/.test(query)) {
+      throw invalid("Empty selector", query);
+    }
+    for (const s of ast.nodes) validate(s, query);
+  }
+  return ast;
 };
 
 // ../../src/query/src/error.ts
@@ -8951,7 +9114,7 @@ var Query = class {
         edges.add(edge);
       }
     }
-    const current = parse2(query);
+    const current = parse2(query, { loose: true });
     const loose = asPostcssNodeWithChildren(current).nodes.length > 1;
     const {
       collect,
@@ -9006,7 +9169,7 @@ var Query = class {
     const tokens = [];
     const ast = (q) => {
       try {
-        return parse2(q);
+        return parse2(q, { loose: true });
       } catch (_e) {
         return ast(q.slice(0, -1));
       }
@@ -9437,9 +9600,10 @@ var Graph = class {
   /**
    * Whether the lockfile on disk no longer matches this graph even
    * though no node changed, e.g. an importer edge spec was rewritten to
-   * the value saved to `package.json`, or the config options the graph
-   * was built with differ from the ones stored in the lockfile. Reify
-   * saves the lockfiles from its no-diff early return when set.
+   * the value saved to `package.json`, a node dev/optional flag was
+   * re-derived, or the config options the graph was built with differ
+   * from the ones stored in the lockfile. Reify saves the lockfiles
+   * from its no-diff early return when set.
    */
   lockfileStale = false;
   /**
@@ -9530,6 +9694,34 @@ var Graph = class {
   nextPeerContextIndex() {
     return ++this.currentPeerContextIndex;
   }
+  /**
+   * Re-derive node `dev`/`optional` flags: a node is dev/optional only
+   * when every importer path crosses a dev/optional edge. Placement only
+   * ever lowers these flags, so removed or retyped edges leave them
+   * stale. Sets `lockfileStale` when any flag changes.
+   */
+  recomputeFlags() {
+    const reach = (skip) => {
+      const seen = new Set(this.importers);
+      for (const node of seen) {
+        for (const edge of node.edgesOut.values()) {
+          if (edge.to && !skip(edge)) seen.add(edge.to);
+        }
+      }
+      return seen;
+    };
+    const nonDev = reach((edge) => edge.dev);
+    const nonOptional = reach((edge) => edge.optional);
+    for (const node of this.nodes.values()) {
+      const dev2 = !nonDev.has(node);
+      const optional2 = !nonOptional.has(node);
+      if (node.dev !== dev2 || node.optional !== optional2) {
+        node.dev = dev2;
+        node.optional = optional2;
+        this.lockfileStale = true;
+      }
+    }
+  }
   /**
    * Delete all nodes and edges that are unreachable from the importers.
    * The collection of deleted nodes is returned.
@@ -10459,6 +10651,9 @@ var parseDir = (options, scurry, packageJson, depsFound, graph, fromNode, currDi
         registry: fromNode.registry ?? options.registry
       });
       const { spec: modifiedSpec, queryModifier } = maybeApplyModifierToSpec(spec2, name, modifierRefs);
+      if (modifiedSpec !== spec2 && modifiedSpec.bareSpec === "-") {
+        continue;
+      }
       spec2 = modifiedSpec;
       graph.placePackage(
         fromNode,
@@ -11513,7 +11708,7 @@ var Breadcrumb = class {
   constructor(query) {
     this.#items = [];
     this.specificity = { idCounter: 0, commonCounter: 0 };
-    const ast = parse2(query);
+    const ast = parse2(query, { loose: true });
     let afterCombinator = true;
     for (const item of ast.first.nodes) {
       const pseudoNode = isPseudoNode(item);
@@ -11751,6 +11946,29 @@ var GraphModifier = class _GraphModifier {
     }
     return false;
   }
+  /**
+   * Selector of the modifier that wins the direct `importer -> spec.name`
+   * edge, if it removes it (value `-`). Same pick as tryNewDependency:
+   * complete entries whose qualifier accepts the spec, highest
+   * specificity, importer-anchored before lone on ties.
+   */
+  removesImporterEdge(importer, spec2) {
+    const anchored = [];
+    const lone = [];
+    for (const mod2 of this.#modifiers) {
+      const { last } = mod2.breadcrumb;
+      if (last.name !== spec2.name || !matchesQualifier(last, spec2))
+        continue;
+      const { prev } = last;
+      if (!prev) lone.push(mod2);
+      else if (!prev.prev && matchesImporter(prev, importer))
+        anchored.push(mod2);
+    }
+    const all = [...anchored, ...lone];
+    const [winner] = specificitySort(all.map((m) => m.breadcrumb));
+    const mod = all.find((m) => m.breadcrumb === winner);
+    return mod?.value === "-" ? mod.query : void 0;
+  }
   /**
    * Loads the modifiers defined in `vlt.json` into memory.
    */
@@ -12136,6 +12354,7 @@ var getImporterSpecs = (options) => {
   const { add, graph, remove } = options;
   const addResult = new AddImportersDependenciesMapImpl();
   const removeResult = new RemoveImportersDependenciesMapImpl();
+  const removedEdges = /* @__PURE__ */ new Set();
   for (const importer of graph.importers) {
     const addDeps = /* @__PURE__ */ new Map();
     const removeDeps = /* @__PURE__ */ new Set();
@@ -12162,6 +12381,10 @@ var getImporterSpecs = (options) => {
         continue;
       }
       const spec2 = Spec2.parse(depName, depSpec, options);
+      if (options.modifiers?.removesImporterEdge(importer, spec2)) {
+        if (edge) removedEdges.add(edge);
+        continue;
+      }
       if (spec2.type === "workspace" && !edge?.to) {
         const wsExists = [...graph.importers].some(
           (n) => n.name === depName
@@ -12267,6 +12490,7 @@ var getImporterSpecs = (options) => {
   return {
     add: addResult,
     remove: removeResult,
+    removedEdges,
     staleSpecs,
     transientAdd,
     transientRemove
@@ -13580,6 +13804,12 @@ var fetchManifestsForDeps = async (packageInfo, graph, fromNode, deps, scurry, o
     if (queryModifier && completeModifier && "spec" in activeModifier.modifier) {
       spec2 = activeModifier.modifier.spec;
       if (spec2.bareSpec === "-") {
+        if (isExplicit) {
+          throw error(
+            `Cannot add ${originalSpec.name}: it is removed by a graph modifier`,
+            { code: "ECONFIG", found: queryModifier }
+          );
+        }
         continue;
       }
     }
@@ -13692,6 +13922,8 @@ var fetchManifestsForDeps = async (packageInfo, graph, fromNode, deps, scurry, o
         throw er;
       })
     );
+    manifestPromise.catch(() => {
+    });
     const fetchTask = {
       spec: spec2,
       type: type2,
@@ -13706,6 +13938,7 @@ var fetchManifestsForDeps = async (packageInfo, graph, fromNode, deps, scurry, o
     };
     fetchTasks.push(fetchTask);
   }
+  await Promise.all(fetchTasks.map((t) => t.manifestPromise));
   for (const fetchTask of fetchTasks) {
     const manifest = await fetchTask.manifestPromise;
     placementTasks.push({
@@ -14105,7 +14338,11 @@ var refreshIdealGraph = async ({
       transientAdd,
       transientRemove,
       explicit
-    );
+    ).catch((er) => {
+      for (const p of extractPromises ?? []) p.catch(() => {
+      });
+      throw er;
+    });
   }
   graph.lockedResolutions = void 0;
   for (const importer of graph.importers) {
@@ -14163,6 +14400,12 @@ var buildIdealFromStartingGraph = async (options) => {
   if (importerSpecs.staleSpecs.size) {
     options.graph.lockfileStale = true;
   }
+  for (const edge of importerSpecs.removedEdges) {
+    edge.from.edgesOut.delete(edge.name);
+    edge.to?.edgesIn.delete(edge);
+    options.graph.edges.delete(edge);
+    options.graph.lockfileStale = true;
+  }
   await refreshIdealGraph({
     ...options,
     explicit,
@@ -14176,6 +14419,7 @@ var buildIdealFromStartingGraph = async (options) => {
       options
     );
   }
+  options.graph.recomputeFlags();
   return options.graph;
 };
 
@@ -14310,7 +14554,7 @@ import {
   stat as stat2,
   writeFile as writeFile3
 } from "node:fs/promises";
-import { dirname as dirname5, relative as relative2 } from "node:path";
+import { dirname as dirname5, isAbsolute, relative as relative2 } from "node:path";
 
 // ../../src/cmd-shim/src/to-batch-syntax.ts
 var convertToSetCommand = (key, value) => convertToSetCommand_(key.trim(), value.trim());
@@ -14411,6 +14655,18 @@ var cmdShimIfExists = async (from, to, remover) => {
   }
   await writeShim(from, to, remover);
 };
+var cmdShim = async (from, to, remover) => {
+  try {
+    await stat2(from);
+    await writeShim(from, to, remover);
+  } catch (er) {
+    throw error("Could not shim to executable file", {
+      path: from,
+      target: to,
+      cause: er
+    });
+  }
+};
 var writeShim = async (from, to, remover) => {
   await Promise.all([
     remover.rm(to),
@@ -14435,6 +14691,7 @@ var writeShim = async (from, to, remover) => {
 };
 var writeShim_ = async (from, to, prog, args, variables) => {
   let shTarget = relative2(dirname5(to), from);
+  const [dp0, basedir] = isAbsolute(shTarget) ? ["", ""] : ["%dp0%\\", "$basedir/"];
   let target = shTarget.split("/").join("\\");
   let longProg;
   let shProg = prog?.split("\\").join("/");
@@ -14445,8 +14702,8 @@ var writeShim_ = async (from, to, prog, args, variables) => {
   args = args || "";
   variables = variables || "";
   if (!prog) {
-    prog = `"%dp0%\\${target}"`;
-    shProg = `"$basedir/${shTarget}"`;
+    prog = `"${dp0}${target}"`;
+    shProg = `"${basedir}${shTarget}"`;
     pwshProg = shProg;
     args = "";
     target = "";
@@ -14455,8 +14712,8 @@ var writeShim_ = async (from, to, prog, args, variables) => {
     longProg = `"%dp0%\\${prog}.exe"`;
     shLongProg = `"$basedir/${prog}"`;
     pwshLongProg = `"$basedir/${prog}$exe"`;
-    target = `"%dp0%\\${target}"`;
-    shTarget = `"$basedir/${shTarget}"`;
+    target = `"${dp0}${target}"`;
+    shTarget = `"${basedir}${shTarget}"`;
   }
   const head = "@ECHO off\r\nGOTO start\r\n:find_dp0\r\nSET dp0=%~dp0\r\nEXIT /b\r\n:start\r\nSETLOCAL\r\nCALL :find_dp0\r\n";
   let cmd;
@@ -15056,7 +15313,7 @@ var reify = async (options) => {
   );
   const noModifiedDependencies = !options.add?.modifiedDependencies && !options.remove?.modifiedDependencies;
   const hasLockfiles = !!scurry.lstatSync("vlt-lock.json") && !!scurry.lstatSync("node_modules/.vlt-lock.json");
-  const skipOptionalOnly = noModifiedDependencies && diff2.optionalOnly;
+  const skipOptionalOnly = noModifiedDependencies && diff2.optionalOnly && !diff2.nodes.delete.size && !diff2.edges.delete.size;
   const skippable = skipOptionalOnly && !options.update && hasLockfiles;
   const res = { diff: diff2 };
   if (!diff2.hasChanges() || skippable) {
@@ -15174,19 +15431,26 @@ var uninstall = async (options, remove) => {
   const mainManifest = options.packageJson.read(options.projectRoot);
   const modifiers = GraphModifier.maybeLoad(options);
   const remover = new RollbackRemove();
+  const monorepo = Monorepo.maybeLoad(options.projectRoot, {
+    packageJson: options.packageJson,
+    scurry: options.scurry
+  });
   try {
     const act = load4({
       ...options,
+      monorepo,
       modifiers: void 0,
       mainManifest,
       loadManifests: true
     });
     const graph = await build3({
       ...options,
+      monorepo,
       actual: act,
       remove,
       mainManifest,
       loadManifests: true,
+      modifiers,
       remover
     });
     if (options.lockfileOnly) {
@@ -15209,6 +15473,7 @@ var uninstall = async (options, remove) => {
       actual: act,
       graph,
       loadManifests: true,
+      modifiers,
       remover
     });
     return { graph, diff: diff2 };
@@ -15232,6 +15497,30 @@ var uninstall = async (options, remove) => {
 // ../../src/graph/src/update.ts
 import { existsSync as existsSync5, rmSync as rmSync3 } from "node:fs";
 import { resolve as resolve12 } from "node:path";
+var startingGraph = (options, monorepo) => {
+  const fresh = () => new Graph({ ...options, monorepo });
+  if (!options.monorepo || !monorepo) return fresh();
+  const selected = new Set(
+    [...options.monorepo.values()].map((ws) => ws.id)
+  );
+  if (selected.size === monorepo.size) return fresh();
+  let graph;
+  try {
+    graph = load3({ ...options, monorepo });
+  } catch (err) {
+    if (isPathSecurityError(err)) throw err;
+    graph = load4({ ...options, monorepo, loadManifests: true });
+  }
+  for (const importer of graph.importers) {
+    if (!selected.has(importer.id)) continue;
+    for (const edge of importer.edgesOut.values()) {
+      edge.to?.edgesIn.delete(edge);
+    }
+    importer.edgesOut.clear();
+  }
+  graph.gc();
+  return graph;
+};
 var update = async (options) => {
   let mainManifest = void 0;
   try {
@@ -15248,6 +15537,10 @@ var update = async (options) => {
   }
   const modifiers = GraphModifier.maybeLoad(options);
   const remover = new RollbackRemove();
+  const monorepo = Monorepo.maybeLoad(options.projectRoot, {
+    packageJson: options.packageJson,
+    scurry: options.scurry
+  });
   try {
     const done = graphStep("build");
     const graph = await buildIdealFromStartingGraph({
@@ -15256,13 +15549,17 @@ var update = async (options) => {
       remove: Object.assign(/* @__PURE__ */ new Map(), {
         modifiedDependencies: false
       }),
-      graph: new Graph({ ...options, mainManifest }),
+      graph: startingGraph(
+        { ...options, mainManifest, modifiers },
+        monorepo
+      ),
       modifiers,
       remover
     });
     done();
     const act = load4({
       ...options,
+      monorepo,
       mainManifest,
       loadManifests: true
     });
@@ -15462,7 +15759,7 @@ var install = async (options, add) => {
         }
       }
     }
-    if (importerSpecs.add.modifiedDependencies || importerSpecs.remove.modifiedDependencies || specChanges.length > 0 || lockfileGraph.optionsChanged) {
+    if (importerSpecs.add.modifiedDependencies || importerSpecs.remove.modifiedDependencies || importerSpecs.removedEdges.size > 0 || specChanges.length > 0 || lockfileGraph.optionsChanged) {
       const details = [];
       if (lockfileGraph.optionsChanged) {
         details.push("  Configuration options have changed:");
@@ -15498,6 +15795,11 @@ var install = async (options, add) => {
           );
         }
       }
+      for (const edge of importerSpecs.removedEdges) {
+        details.push(
+          `  ${edge.from.location}: ${edge.name} is removed by a graph modifier`
+        );
+      }
       const lockfilePath = resolve13(
         options.projectRoot,
         "vlt-lock.json"
@@ -15510,6 +15812,27 @@ var install = async (options, add) => {
       );
     }
   }
+  if (modifiers && add?.modifiedDependencies) {
+    const wsIds = new Set(
+      [...fullMonorepo?.values() ?? []].map((ws) => ws.id)
+    );
+    for (const [id2, deps] of add) {
+      const mainImporter = id2 === joinDepIDTuple(["file", "."]);
+      if (!mainImporter && !wsIds.has(id2)) continue;
+      for (const { spec: spec2 } of deps.values()) {
+        const found = modifiers.removesImporterEdge(
+          { importer: true, mainImporter },
+          spec2
+        );
+        if (found) {
+          throw error(
+            `Cannot add ${spec2.name}: it is removed by a graph modifier`,
+            { code: "ECONFIG", found }
+          );
+        }
+      }
+    }
+  }
   const remover = new RollbackRemove();
   if (options.cleanInstall) {
     const nodeModulesPath = resolve13(
@@ -15612,6 +15935,7 @@ export {
   humanReadableOutput,
   mermaidOutput,
   findCmdShimIfExists,
+  cmdShim,
   RollbackRemove,
   GraphModifier,
   init,

package/{chunk-KOFQTETH.js → chunk-PHJJPY5G.js}

@@ -11,13 +11,13 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   openUrl
-} from "./chunk-OWMR2EDW.js";
+} from "./chunk-TPRK6IDA.js";
 import {
   stderr
-} from "./chunk-XDSZO74H.js";
+} from "./chunk-FZUYGJZU.js";
 import {
   mermaidOutput
-} from "./chunk-7BHHCB5C.js";
+} from "./chunk-OVPHE4O7.js";
 import {
   ViewClass
 } from "./chunk-4KCU2KZL.js";