@poe-platform/safe-bash 0.1.813 → 0.1.815

package/dist/safe-bash/command-chunks/{chunk-JORIVUPM.js → chunk-YW2VYN4V.js}

@@ -1,3 +1,7 @@
+import {
+  materializeText,
+  textSize
+} from "./chunk-KHUT7BB5.js";
 import {
   decodeHeaderPath,
   isEpochHeader
@@ -18,27 +22,39 @@ function startIndex(start, count) {
 async function parseUnified(text, budget) {
   if (typeof text !== "string") {
     budget.countLines(text.length);
-    return parseUnifiedReader({ input: text, index: 0 }, budget, false);
+    return parseUnifiedReader({ input: text, index: 0 }, budget, false, bufferedLines);
   }
   if (text && !text.endsWith("\n")) throw new ToolError("patch is truncated: missing final LF");
   const lines = budget.split(text).map((line) => line.slice(0, -1));
   return parseUnifiedReader({ input: { length: lines.length, async read(index) {
     return lines[index];
-  } }, index: 0 }, budget, false);
+  } }, index: 0 }, budget, false, bufferedLines);
 }
 async function parseUnifiedSection(cursor, budget) {
-  if ("input" in cursor) return parseUnifiedReader(cursor, budget, true);
+  if ("input" in cursor) return parseUnifiedReader(cursor, budget, true, bufferedLines);
   const indexed = {
     index: cursor.index,
     input: { length: cursor.lines.length, async read(index) {
       return cursor.lines[index];
     } }
   };
-  const patches = await parseUnifiedReader(indexed, budget, true);
+  const patches = await parseUnifiedReader(indexed, budget, true, bufferedLines);
   cursor.index = indexed.index;
   return patches;
 }
-async function parseUnifiedReader(cursor, budget, single) {
+function bufferedLines() {
+  const lines = [];
+  return { lines, async append(line) {
+    lines.push({ kind: line.kind, text: await materializeText(line.text) });
+  } };
+}
+function bufferedHunks() {
+  const hunks = [];
+  return { hunks, append(hunk) {
+    hunks.push(hunk);
+  } };
+}
+async function parseUnifiedReader(cursor, budget, single, createLines, createHunks = bufferedHunks) {
   const physical = cursor.input;
   const patches = [];
   let index = cursor.index;
@@ -67,7 +83,8 @@ async function parseUnifiedReader(cursor, budget, single) {
     const newEpoch = isEpochHeader(await physical.read(index));
     index++;
     budget.file();
-    const hunks = [];
+    const hunkBuilder = createHunks();
+    const hunks = hunkBuilder.hunks;
     let oldEnded = false;
     let newEnded = false;
     while (index < physical.length && (await physical.read(index)).startsWith("@@")) {
@@ -85,7 +102,7 @@ async function parseUnifiedReader(cursor, budget, single) {
       if (oldEnded && oldCount || newEnded && newCount) throw new ToolError("hunk follows an incomplete final line");
       let oldRead = 0;
       let newRead = 0;
-      const lines = [];
+      const bodyLines = createLines();
       let changed = false;
       while (oldRead < oldCount || newRead < newCount) {
         budget.step();
@@ -93,27 +110,28 @@ async function parseUnifiedReader(cursor, budget, single) {
           const c = budget.checkpoint();
           if (c) await c;
         }
-        const body = await physical.read(index++);
+        const bodyIndex = index++;
+        const body = await physical.read(bodyIndex, physical.body ? 1 : void 0);
         const kind = body === "" ? " " : body?.[0];
         if (body === void 0 || kind !== " " && kind !== "+" && kind !== "-") throw new ToolError("truncated or malformed hunk body");
         if (kind !== "+" && oldEnded || kind !== "-" && newEnded) throw new ToolError("content follows an incomplete final line");
         if (kind !== "+") oldRead++;
         if (kind !== "-") newRead++;
         if (oldRead > oldCount || newRead > newCount) throw new ToolError("hunk line counts do not match header");
-        const entry = { kind, text: `${body.slice(1)}
-` };
-        lines.push(entry);
+        const incomplete = physical.matches ? await physical.matches(index, "\") : await physical.read(index) === "\";
+        const text = physical.body ? await physical.body(bodyIndex, 1, incomplete) : `${body.slice(1)}${incomplete ? "" : "\n"}`;
+        const entry = { kind, text };
         changed ||= kind !== " ";
-        if (await physical.read(index) === "\") {
-          if (entry.text === "\n") throw new ToolError("empty incomplete line is not a valid text line");
+        if (incomplete) {
+          if (textSize(text) === 0) throw new ToolError("empty incomplete line is not a valid text line");
           index++;
-          entry.text = entry.text.slice(0, -1);
           if (kind !== "+") oldEnded = true;
           if (kind !== "-") newEnded = true;
         }
+        await bodyLines.append(entry);
       }
       if (!changed) throw new ToolError("hunk has no changes");
-      hunks.push({ oldStart, oldCount, newStart, newCount, lines, section: match[5] ?? "" });
+      await hunkBuilder.append({ oldStart, oldCount, newStart, newCount, lines: bodyLines.lines, section: match[5] ?? "" });
     }
     if (!hunks.length) throw new ToolError("file patch has no hunks");
     patches.push({ oldPath, newPath, oldEpoch, newEpoch, oldHeader, newHeader, hunks });
@@ -354,6 +372,7 @@ export {
   startIndex,
   parseUnified,
   parseUnifiedSection,
+  parseUnifiedReader,
   reversePatch,
   applyHunks
 };

package/dist/safe-bash/command-chunks/{chunk-NMPED6L5.js → chunk-Z2WNYEPD.js}

@@ -1,10 +1,10 @@
 import {
   themeColorSlots,
   validateColor
-} from "./chunk-5KGEZ3RW.js";
+} from "./chunk-CCMAHM3I.js";
 import {
   readXmlPercentage
-} from "./chunk-EZ4NQIPL.js";
+} from "./chunk-TJLXSENN.js";
 import {
   callableConstructor
 } from "./chunk-HR2Y6YEP.js";
@@ -13,10 +13,10 @@ import {
   PropertyAccessError,
   TypeError,
   ValueError
-} from "./chunk-D55REQA3.js";
+} from "./chunk-JUHOL5KB.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/enum-definition.ts
 function defineEnum(values) {

package/dist/safe-bash/command-chunks/{chunk-7PZHWMK6.js → chunk-Z7QOSXQC.js}

@@ -1,26 +1,26 @@
 import {
   readPackage
-} from "./chunk-PVGZMLC6.js";
+} from "./chunk-IWHNRYER.js";
 import {
   binarySource,
   readBinary
-} from "./chunk-LD7BONZY.js";
+} from "./chunk-NFII726L.js";
 import {
   parseXmlPart
-} from "./chunk-7PRL6RJ6.js";
+} from "./chunk-DBLQUZGN.js";
 import {
   parseContentTypes
-} from "./chunk-VQOINPVF.js";
+} from "./chunk-ZQM37BGE.js";
 import {
   readRelationshipGraph
-} from "./chunk-TODWFDYB.js";
+} from "./chunk-LNTEV56A.js";
 import {
   asciiKey
-} from "./chunk-U5TWQFZY.js";
+} from "./chunk-WTVJLHMG.js";
 import {
   OfficeError,
   resolveOfficeResources
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/slide-transfer-budget.ts
 var SlideTransferBudget = class {

package/dist/safe-bash/command-chunks/{chunk-7UC2Q6Z6.js → chunk-ZIGENXGC.js}

@@ -1,3 +1,8 @@
+import {
+  openRetainedPresentationIndex,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-4EHY6J2Z.js";
 import {
   attr,
   child,
@@ -7,22 +12,257 @@ import {
   nextRel,
   relPart,
   required
-} from "./chunk-2Z3WRRFT.js";
+} from "./chunk-ADHFF2IM.js";
 import {
   SelectionError
-} from "./chunk-O675URF4.js";
+} from "./chunk-W3ZSWK76.js";
+import {
+  openRetainedPresentationValidation
+} from "./chunk-3GRMU7TM.js";
+import {
+  dialects
+} from "./chunk-AWPI4DZR.js";
 import {
   parseXmlPart
-} from "./chunk-7PRL6RJ6.js";
+} from "./chunk-DBLQUZGN.js";
 import {
   relativePartReference
-} from "./chunk-U5TWQFZY.js";
+} from "./chunk-WTVJLHMG.js";
 import {
-  OfficeError
-} from "./chunk-X6RHJ6YN.js";
+  OfficeError,
+  RetainedValues,
+  equal,
+  folded,
+  literal,
+  openRetainedXmlDocument,
+  resolveOfficeResources
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/notes.ts
 import { SaxesParser } from "saxes";
+
+// packages/safe-bash-presentation-engine/src/retained-notes.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+async function openRetainedNotes(archive, fingerprint, options, settings, selectBeforeValidation = false) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some((key) => key !== "selection"))
+    throw new OfficeError("invalid-value", "Invalid notes query.", "usage");
+  if (options.selection !== void 0 && (!options.selection || typeof options.selection !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options.selection))))
+    throw new SelectionError("invalid-selection");
+  const selection = options.selection === void 0 ? void 0 : { ...options.selection, kind: options.selection.kind ?? "slide", ...options.selection.position ? { position: { ...options.selection.position } } : {} };
+  const context = resolveOfficeResources(settings), working = { ...settings.workingStorage }, signal = context.signal ?? new AbortController().signal;
+  const index = await openRetainedPresentationIndex(archive, fingerprint, { ...context, workingStorage: working });
+  const pages = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, (working.cacheBytes ?? 1024 * 1024) / 16384);
+  let closed = false, closing, first = 0, last = 0, count = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Notes are closed.", "select");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "select");
+  };
+  const failure = (error) => error instanceof OfficeError ? error : new OfficeError(signal.aborted ? "cancelled" : "io-failure", "Notes storage operation failed.", "select");
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const outcomes = await Promise.allSettled([index.close(), pages.close()]);
+      for (const outcome of outcomes) if (outcome.status === "rejected") throw outcome.reason;
+    })();
+  };
+  const values = new RetainedValues(pages, check, signal);
+  const range = (row2, field) => ({ start: row2[field], length: row2[field + 1] });
+  async function row(pointer) {
+    check();
+    const bytes = await pages.read(pointer, 11 /* Count */ * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length: 11 /* Count */ }, (_, n) => view.getFloat64(n * 8, true));
+  }
+  async function write(pointer, numbers) {
+    check();
+    const bytes = new Uint8Array(numbers.length * 8), view = new DataView(bytes.buffer);
+    numbers.forEach((number, n) => view.setFloat64(n * 8, number, true));
+    await pages.write(pointer, bytes);
+  }
+  async function metadata(value) {
+    const decoder = new TextDecoder();
+    let result = "";
+    for await (const bytes of values.read(value)) result += decoder.decode(bytes, { stream: true });
+    return result + decoder.decode();
+  }
+  try {
+    if (selectBeforeValidation && selection) for await (const record of index.records.select(selection)) {
+      void record;
+      check();
+    }
+    const validation = await openRetainedPresentationValidation(archive, { ...context, workingStorage: working }, {
+      ...context.xmlLimits,
+      ...context.relationshipLimits,
+      maxBytes: Math.min(context.xmlLimits.maxBytes, context.relationshipLimits.maxBytes),
+      maxEntries: context.archiveLimits.maxMembers
+    });
+    const valid = validation.valid;
+    try {
+      await validation.close();
+    } catch (error) {
+      if (valid) await Promise.reject(error);
+    }
+    if (!valid) throw new OfficeError("invalid-opc", "Invalid presentation graph.", "validate-intent");
+    for await (const part of archive.parts()) {
+      const key = await values.store(folded(literal(part))), value = await values.store(literal(part));
+      await values.insert("parts", key, value);
+    }
+    const main = await openRetainedXmlDocument(archive.read(index.records.main), { ...context, workingStorage: working });
+    let dialect = dialects[0], mainFailed = false;
+    try {
+      for (const candidate of dialects) if (await equal(main.namespace(main.root), literal(candidate.p))) dialect = candidate;
+    } catch (error) {
+      mainFailed = true;
+      throw error;
+    } finally {
+      try {
+        await main.close();
+      } catch (error) {
+        if (!mainFailed) await Promise.reject(error);
+      }
+    }
+    async function target(owner, kind, internal) {
+      for await (const edge of index.graph.outgoing(owner)) if ((!internal || !edge.external) && await equal(edge.type(), literal(`${dialect.r}/${kind}`))) {
+        if (!edge.targetPart) return void 0;
+        const original = await values.find("parts", () => folded(edge.targetPart()));
+        if (!original) throw new OfficeError("missing-binding", "Package member is absent.", "index");
+        return { name: await metadata(original), reference: await values.store(edge.targetPart()) };
+      }
+      return void 0;
+    }
+    if (selection) {
+      for await (const slide of index.records.select(selection)) if (slide.kind !== "slide") throw new SelectionError("invalid-selection");
+    }
+    for await (const slide of selection ? index.records.select(selection) : index.records.records("slide")) {
+      const part = await target(slide.part, "notesSlide", true);
+      if (!part) continue;
+      const document = await openRetainedXmlDocument(archive.read(part.name), { ...context, workingStorage: working });
+      let failed = false;
+      try {
+        async function is(node, local, namespace) {
+          return node.kind === "element" && await equal(document.raw(node.localName), literal(local)) && await equal(document.namespace(node), namespace);
+        }
+        async function child2(node, local) {
+          if (!node) return void 0;
+          let found;
+          for await (const candidate of document.children(node)) if (await is(candidate, local, document.namespace(node))) {
+            if (found) throw new OfficeError("invalid-value", "Ambiguous shared structure.", "usage");
+            found = candidate;
+          }
+          return found;
+        }
+        async function required2(node, local) {
+          const found = await child2(node, local);
+          if (!found) throw new OfficeError("unsupported-edit", "Unsupported shared structure.", "validate-intent");
+          return found;
+        }
+        async function attribute(node, local) {
+          if (node) {
+            for await (const candidate of document.attributes(node)) if (await equal(document.raw(candidate.localName), literal(local)) && await equal(document.namespace(candidate), literal(""))) return candidate;
+          }
+          return void 0;
+        }
+        const tree = await required2(await required2(document.root, "cSld"), "spTree");
+        let body2;
+        for await (const node of document.children(tree)) if (await is(node, "sp", document.namespace(document.root))) {
+          const placeholder2 = await child2(await child2(await child2(node, "nvSpPr"), "nvPr"), "ph"), type = await attribute(placeholder2, "type");
+          if (type && await equal(document.text(type), literal("body"))) {
+            if (body2) throw new OfficeError("ambiguous-selection", "Notes have multiple speaker bodies.", "select");
+            body2 = node;
+          }
+        }
+        const id = await attribute(await child2(await child2(body2, "nvSpPr"), "cNvPr"), "id"), textBody = await child2(body2, "txBody");
+        const idRange = id ? await values.store(document.text(id)) : { start: -1, length: 0 };
+        let drawing = dialects[0].a;
+        for (const candidate of dialects) if (await equal(document.namespace(document.root), literal(candidate.p))) drawing = candidate.a;
+        async function* speakerText2() {
+          let separator = false;
+          if (textBody) {
+            for await (const paragraph of document.children(textBody)) if (await is(paragraph, "p", literal(drawing))) {
+              if (separator) yield* literal("\n");
+              separator = true;
+              for await (const inline of document.children(paragraph)) {
+                if (await is(inline, "br", literal(drawing))) yield* literal("\v");
+                else if (await is(inline, "r", literal(drawing)) || await is(inline, "fld", literal(drawing))) {
+                  for await (const text2 of document.children(inline)) if (await is(text2, "t", literal(drawing))) yield* document.text(text2);
+                }
+              }
+            }
+          }
+        }
+        const text = textBody ? await values.store(speakerText2()) : { start: -1, length: 0 }, master = await target(part.name, "notesMaster", false);
+        if (!master) throw new OfficeError("invalid-opc", "Missing notes master.", "index");
+        const descriptor = await values.store(literal(JSON.stringify({ selector: slide.token, location: slide.location, slide: slide.position })));
+        const pointer = pages.allocate(11 /* Count */ * 8);
+        await write(pointer, [0, descriptor.start, descriptor.length, part.reference.start, part.reference.length, master.reference.start, master.reference.length, text.start, text.length, idRange.start, idRange.length]);
+        if (last) await write(last, [pointer]);
+        else first = pointer;
+        last = pointer;
+        count++;
+      } catch (error) {
+        failed = true;
+        throw error;
+      } finally {
+        try {
+          await document.close();
+        } catch (error) {
+          if (!failed) await Promise.reject(error);
+        }
+      }
+    }
+    await index.close();
+    check();
+    async function* records() {
+      try {
+        for (let pointer = first; pointer; ) {
+          const entry = await row(pointer), descriptor = JSON.parse(await metadata(range(entry, 1 /* Metadata */)));
+          yield {
+            ...descriptor,
+            part: () => values.read(range(entry, 3 /* Part */)),
+            master: () => values.read(range(entry, 5 /* Master */)),
+            text: entry[7 /* Text */] === -1 ? null : () => values.read(range(entry, 7 /* Text */)),
+            bodyShapeId: entry[9 /* Id */] === -1 ? null : () => values.read(range(entry, 9 /* Id */))
+          };
+          pointer = entry[0 /* Next */];
+        }
+        check();
+      } catch (error) {
+        throw failure(error);
+      }
+    }
+    return Object.freeze({ records, close, count });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw failure(error);
+  }
+}
+async function stageRetainedNotes(archive, fingerprint, options, settings, output) {
+  const format = { ...output }, notes = await openRetainedNotes(archive, fingerprint, options, settings, format.operation === "notes.get");
+  let staged;
+  async function* locations() {
+    for await (const note of notes.records()) yield note.location;
+  }
+  async function* render() {
+    if (format.json) {
+      yield* streamJson({ version: 1, operation: format.operation, ok: true, data: format.operation === "notes.get" && !notes.count ? null : { notes: notes.records() }, affected: 0, warnings: [], errors: [], locations: locations() });
+      yield* literal("\n");
+    } else for await (const note of notes.records()) {
+      yield* literal(`${note.slide}: `);
+      if (note.text) yield* note.text();
+      yield* literal("\n");
+    }
+  }
+  try {
+    staged = await stageRetainedOutput(render(), settings, format.maxOutputBytes);
+    await notes.close();
+    return staged;
+  } catch (error) {
+    await Promise.allSettled([notes.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/notes.ts
 var relns = "http://schemas.openxmlformats.org/package/2006/relationships";
 function notesPart(s, slide) {
   return s.index.inventory.relationships.find(
@@ -366,6 +606,8 @@ async function mutateNotes(input, action, options, context) {
 }
 
 export {
+  openRetainedNotes,
+  stageRetainedNotes,
   readNotes,
   validateNotesOptions,
   mutateNotes

package/dist/safe-bash/command-chunks/{chunk-VQOINPVF.js → chunk-ZQM37BGE.js}

@@ -1,10 +1,10 @@
 import {
   asciiKey,
   partName
-} from "./chunk-U5TWQFZY.js";
+} from "./chunk-WTVJLHMG.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/content-types.ts
 import { SaxesParser } from "saxes";

package/dist/safe-bash/command-chunks/{chunk-W3HV45CI.js → chunk-ZSQZHFWS.js}

@@ -1,27 +1,27 @@
 import {
   openDocumentLocations,
   resolveDocxSelection
-} from "./chunk-UZL7G57V.js";
+} from "./chunk-CKEMZUE3.js";
 import {
   DocumentArchiveEditor
-} from "./chunk-QDVI2YB6.js";
+} from "./chunk-VUWXLH3E.js";
+import {
+  paragraphTextRun
+} from "./chunk-BLIFGBIO.js";
 import {
   measurePackageResourceSerialization
-} from "./chunk-LLU2IQEJ.js";
+} from "./chunk-2BNGPR6Z.js";
 import {
   validateDocxInvocation
-} from "./chunk-GXLXWZWH.js";
-import {
-  paragraphTextRun
-} from "./chunk-CU4DLVME.js";
+} from "./chunk-DZH54L3F.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-PZMU3Z4L.js";
+} from "./chunk-EVYKV3QI.js";
 import {
   UnsupportedEditError,
   runElementOpen
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   dialectForNamespace,
   documentDialects

package/dist/safe-bash/command-chunks/{chunk-IDJQP3A6.js → chunk-ZTMZO4IT.js}

@@ -1,7 +1,7 @@
 import {
   SinkError,
   writeDocumentArchive
-} from "./chunk-PPO7YUZF.js";
+} from "./chunk-JGKSWDGP.js";
 import {
   asPermissionError
 } from "./chunk-JGGRMERW.js";

package/dist/safe-bash/command-chunks/{chunk-V6XBEYPC.js → chunk-ZU2KJMXO.js}

@@ -1,31 +1,31 @@
 import {
   admitImage
-} from "./chunk-ET2VPDUA.js";
+} from "./chunk-7KZ5LWV2.js";
 import {
   readTable
-} from "./chunk-3TYDSGAH.js";
+} from "./chunk-RQYPFLZJ.js";
 import {
   nodeFor
-} from "./chunk-EJTNVXWF.js";
+} from "./chunk-MVLVIMJ6.js";
 import {
   readTextBodies
-} from "./chunk-C5KLFZGT.js";
+} from "./chunk-KSBNZTAZ.js";
 import {
   child,
   escape,
   loadShared,
   nextRel,
   relPart
-} from "./chunk-2Z3WRRFT.js";
+} from "./chunk-ADHFF2IM.js";
 import {
   protectedEquationNodes
-} from "./chunk-Z5BIM5B7.js";
+} from "./chunk-XTEIT5CI.js";
 import {
   relativePartReference
-} from "./chunk-U5TWQFZY.js";
+} from "./chunk-WTVJLHMG.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/template-bindings.ts
 function invalid() {

package/dist/safe-bash/command-chunks/{chunk-YXKNJ6EM.js → chunk-ZXELXF2H.js}

@@ -2,15 +2,15 @@ import {
   matchesModelVfs,
   modelContext
 } from "./chunk-DMAOMHJQ.js";
-import {
-  characterizeRasterHeader
-} from "./chunk-4Y6O2K35.js";
 import {
   DocumentIo
-} from "./chunk-IDJQP3A6.js";
+} from "./chunk-ZTMZO4IT.js";
+import {
+  characterizeRasterHeader
+} from "./chunk-GLAF45M7.js";
 import {
   UnsupportedEditError
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   Emu,
   Inches,

package/dist/safe-bash/command-chunks/{clipboard-BBDK33GP-VB22F7GI.js → clipboard-BBDK33GP-QZ4ERNQX.js}

@@ -4,9 +4,9 @@ import {
   Vr,
   Yn,
   gn
-} from "./chunk-4YSBUQPV.js";
-import "./chunk-YXIB6JV5.js";
+} from "./chunk-W2FKFEVY.js";
 import "./chunk-5V3TE7XU.js";
+import "./chunk-YXIB6JV5.js";
 import "./chunk-VO6Q3KKZ.js";
 import "./chunk-Z7ESJVFP.js";
 import "./chunk-2BKOSQD3.js";