oasis-editor 0.0.84 → 0.0.85

package/dist/core/endnotes.d.ts

@@ -1,10 +1,5 @@
 import { EditorBlockNode, EditorDocument, EditorEndnote, EditorEndnotes, EditorParagraphNode, EditorTextRun } from './model.js';
 
-/**
- * Iterate every paragraph in document order (endnote bodies excluded), yielding
- * each endnote reference run with its owning paragraph. Order matches reading
- * order, which is what numbering depends on.
- */
 export declare function iterateEndnoteReferenceRuns(document: EditorDocument): Generator<{
     paragraph: EditorParagraphNode;
     run: EditorTextRun;

package/dist/core/footnotes.d.ts

@@ -1,10 +1,5 @@
 import { EditorBlockNode, EditorDocument, EditorFootnote, EditorFootnoteNumberFormat, EditorFootnotes, EditorParagraphNode, EditorTextRun } from './model.js';
 
-/**
- * Iterate every paragraph in document order (sections + footnotes excluded),
- * yielding each footnote reference run along with the owning paragraph. Order
- * matches reading order, which is what numbering depends on.
- */
 export declare function iterateFootnoteReferenceRuns(document: EditorDocument): Generator<{
     paragraph: EditorParagraphNode;
     run: EditorTextRun;

package/dist/core/noteTraversal.d.ts

@@ -0,0 +1,77 @@
+import { EditorBlockNode, EditorDocument, EditorFootnoteNumberFormat, EditorParagraphNode, EditorSection, EditorTextRun } from './model.js';
+
+/** Discriminant of a note reference run. */
+export type NoteReferenceRunKind = "footnoteReference" | "endnoteReference";
+/** Neutral view of a note reference run's data (id + optional custom mark). */
+export interface NoteRef {
+    id: string;
+    customMark?: string;
+}
+/** Minimal shape of a note body shared by footnotes and endnotes. */
+interface NoteBody {
+    blocks: EditorBlockNode[];
+}
+/** Minimal shape of a note collection (footnotes/endnotes registry). */
+interface NoteCollection<TNote extends NoteBody> {
+    items: Record<string, TNote>;
+    settings?: {
+        numberFormat?: EditorFootnoteNumberFormat;
+        startAt?: number;
+    };
+}
+/**
+ * Describes one note family so the shared algorithm can operate on either.
+ */
+export interface NoteTraversal {
+    /** Reference run discriminant for this family. */
+    runKind: NoteReferenceRunKind;
+    /** Read neutral reference data from a run, or undefined if not this kind. */
+    getRef(run: EditorTextRun): NoteRef | undefined;
+    /** Map a one-based index + format to display marker text. */
+    formatMarker(oneBasedIndex: number, format: EditorFootnoteNumberFormat): string;
+}
+/**
+ * Iterate every paragraph in document order (note bodies excluded), yielding
+ * each reference run of `runKind` with its owning paragraph. Order matches
+ * reading order, which is what numbering depends on.
+ */
+export declare function iterateNoteReferenceRuns(document: EditorDocument, runKind: NoteReferenceRunKind): Generator<{
+    paragraph: EditorParagraphNode;
+    run: EditorTextRun;
+}, void, void>;
+export declare function collectNoteReferences(document: EditorDocument, runKind: NoteReferenceRunKind): Array<{
+    paragraph: EditorParagraphNode;
+    run: EditorTextRun;
+}>;
+/** Find the note body that contains the given paragraph id (neutral id). */
+export declare function findNoteBodyByParagraphId<TNote extends NoteBody>(items: Record<string, TNote> | undefined, paragraphId: string): {
+    id: string;
+    body: TNote;
+} | null;
+/** Find the first reference run for a given note id. */
+export declare function findNoteReference(document: EditorDocument, traversal: NoteTraversal, noteId: string): {
+    paragraph: EditorParagraphNode;
+    run: EditorTextRun;
+} | null;
+/** Neutral per-reference info (id + custom mark + computed reading-order index). */
+export interface NoteReferenceInfo {
+    id: string;
+    customMark?: string;
+    index: number;
+}
+export declare function listReferencedNotes(document: EditorDocument, traversal: NoteTraversal): NoteReferenceInfo[];
+/** Result of {@link computeNoteRenumber}: rewritten sections + pruned items. */
+export interface NoteRenumberResult<TNote extends NoteBody> {
+    sections: EditorSection[];
+    sectionsChanged: boolean;
+    nextItems: Record<string, TNote>;
+    itemsChanged: boolean;
+}
+/**
+ * Compute the renumbering of a note family: assign a marker per referenced note
+ * in reading order, rewrite reference run text where it differs, and prune note
+ * bodies that are no longer referenced. Pure — the caller assembles the new
+ * document with the correct collection field.
+ */
+export declare function computeNoteRenumber<TNote extends NoteBody>(document: EditorDocument, collection: NoteCollection<TNote>, traversal: NoteTraversal): NoteRenumberResult<TNote>;
+export {};

package/dist/{index-9_ibx79n.js → index-CHcJlpsx.js}

@@ -2483,7 +2483,7 @@ function OasisEditorAppLazy(props = {}) {
     onCleanup(() => {
       cancelled = true;
     });
-    import("./OasisEditorApp-lNYRC99y.js").then((m) => {
+    import("./OasisEditorApp-D_hjBUA1.js").then((m) => {
       cancelled = true;
       setProgress(1);
       setTimeout(() => setApp(() => m.OasisEditorApp), 180);
@@ -14000,7 +14000,7 @@ function projectDocumentSections(context2, reservedHeightByPageIndex) {
     )
   };
 }
-function* iterateFootnoteReferenceRuns(document2) {
+function* iterateNoteReferenceRuns(document2, runKind) {
   const sections = getDocumentSectionsCanonical(document2);
   for (const section of sections) {
     const zones = [
@@ -14016,7 +14016,7 @@ function* iterateFootnoteReferenceRuns(document2) {
       for (const block of blocks) {
         for (const paragraph of getBlockParagraphs(block)) {
           for (const run of paragraph.runs) {
-            if (run.kind === "footnoteReference") {
+            if (run.kind === runKind) {
               yield { paragraph, run };
             }
           }
@@ -14025,103 +14025,56 @@ function* iterateFootnoteReferenceRuns(document2) {
     }
   }
 }
-const LOWER_LETTERS = "abcdefghijklmnopqrstuvwxyz";
-const ROMAN_NUMERALS = [
-  [1e3, "m"],
-  [900, "cm"],
-  [500, "d"],
-  [400, "cd"],
-  [100, "c"],
-  [90, "xc"],
-  [50, "l"],
-  [40, "xl"],
-  [10, "x"],
-  [9, "ix"],
-  [5, "v"],
-  [4, "iv"],
-  [1, "i"]
-];
-function toRoman(value) {
-  if (value <= 0) return String(value);
-  let remaining = value;
-  let result = "";
-  for (const [size, glyph] of ROMAN_NUMERALS) {
-    while (remaining >= size) {
-      result += glyph;
-      remaining -= size;
-    }
-  }
-  return result;
-}
-function toLetters(value) {
-  if (value <= 0) return String(value);
-  let remaining = value;
-  let result = "";
-  while (remaining > 0) {
-    const digit = (remaining - 1) % 26;
-    result = LOWER_LETTERS[digit] + result;
-    remaining = Math.floor((remaining - 1) / 26);
-  }
-  return result;
-}
-const SYMBOL_MARKS = ["*", "†", "‡", "§", "¶", "#"];
-function getFootnoteDisplayMarker(oneBasedIndex, format = "decimal") {
-  switch (format) {
-    case "lowerRoman":
-      return toRoman(oneBasedIndex);
-    case "upperRoman":
-      return toRoman(oneBasedIndex).toUpperCase();
-    case "lowerLetter":
-      return toLetters(oneBasedIndex);
-    case "upperLetter":
-      return toLetters(oneBasedIndex).toUpperCase();
-    case "symbol": {
-      const slot = (oneBasedIndex - 1) % SYMBOL_MARKS.length;
-      const cycles = Math.floor((oneBasedIndex - 1) / SYMBOL_MARKS.length) + 1;
-      return SYMBOL_MARKS[slot].repeat(cycles);
-    }
-    case "decimal":
-    default:
-      return String(oneBasedIndex);
-  }
-}
-function findFootnoteReference(document2, footnoteId) {
+function findNoteReference(document2, traversal, noteId) {
   var _a;
-  for (const entry of iterateFootnoteReferenceRuns(document2)) {
-    if (((_a = getRunFootnoteReference(entry.run)) == null ? void 0 : _a.footnoteId) === footnoteId) {
+  for (const entry of iterateNoteReferenceRuns(document2, traversal.runKind)) {
+    if (((_a = traversal.getRef(entry.run)) == null ? void 0 : _a.id) === noteId) {
       return entry;
     }
   }
   return null;
 }
-function renumberFootnotes(document2) {
-  var _a, _b;
-  const footnotes = document2.footnotes;
-  if (!footnotes || Object.keys(footnotes.items).length === 0) {
-    return document2;
+function listReferencedNotes(document2, traversal) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  let counter2 = 0;
+  for (const { run } of iterateNoteReferenceRuns(document2, traversal.runKind)) {
+    const ref = traversal.getRef(run);
+    if (!ref) continue;
+    if (seen.has(ref.id)) continue;
+    seen.add(ref.id);
+    if (!ref.customMark) {
+      counter2 += 1;
+    }
+    result.push({
+      id: ref.id,
+      customMark: ref.customMark,
+      index: ref.customMark ? 0 : counter2
+    });
   }
-  const format = ((_a = footnotes.settings) == null ? void 0 : _a.numberFormat) ?? "decimal";
-  const startAt = ((_b = footnotes.settings) == null ? void 0 : _b.startAt) ?? 1;
+  return result;
+}
+function computeNoteRenumber(document2, collection, traversal) {
+  var _a, _b;
+  const format = ((_a = collection.settings) == null ? void 0 : _a.numberFormat) ?? "decimal";
+  const startAt = ((_b = collection.settings) == null ? void 0 : _b.startAt) ?? 1;
   const referenced = /* @__PURE__ */ new Set();
-  const markerByFootnoteId = /* @__PURE__ */ new Map();
+  const markerById = /* @__PURE__ */ new Map();
   let autoCounter = startAt - 1;
-  for (const { run } of iterateFootnoteReferenceRuns(document2)) {
-    const ref = getRunFootnoteReference(run);
+  for (const { run } of iterateNoteReferenceRuns(document2, traversal.runKind)) {
+    const ref = traversal.getRef(run);
     if (!ref) continue;
-    referenced.add(ref.footnoteId);
+    referenced.add(ref.id);
     if (ref.customMark) {
-      markerByFootnoteId.set(ref.footnoteId, ref.customMark);
+      markerById.set(ref.id, ref.customMark);
       continue;
     }
-    if (!markerByFootnoteId.has(ref.footnoteId)) {
+    if (!markerById.has(ref.id)) {
       autoCounter += 1;
-      markerByFootnoteId.set(
-        ref.footnoteId,
-        getFootnoteDisplayMarker(autoCounter, format)
-      );
+      markerById.set(ref.id, traversal.formatMarker(autoCounter, format));
     }
   }
-  let mutatedSections = false;
+  let sectionsChanged = false;
   const sections = getDocumentSectionsCanonical(document2).map((section) => {
     const rewriteBlocks = (blocks) => {
       if (!blocks) return blocks;
@@ -14129,7 +14082,11 @@ function renumberFootnotes(document2) {
       const nextBlocks = blocks.map((block) => {
         switch (block.type) {
           case "paragraph": {
-            const updated = rewriteParagraphMarkers$1(block, markerByFootnoteId);
+            const updated = rewriteParagraphMarkers(
+              block,
+              traversal,
+              markerById
+            );
             if (updated !== block) blockChanged = true;
             return updated;
           }
@@ -14140,9 +14097,10 @@ function renumberFootnotes(document2) {
               const nextCells = row.cells.map((cell) => {
                 let cellChanged = false;
                 const nextCellBlocks = cell.blocks.map((p) => {
-                  const updated = rewriteParagraphMarkers$1(
+                  const updated = rewriteParagraphMarkers(
                     p,
-                    markerByFootnoteId
+                    traversal,
+                    markerById
                   );
                   if (updated !== p) cellChanged = true;
                   return updated;
@@ -14164,7 +14122,7 @@ function renumberFootnotes(document2) {
         }
       });
       if (!blockChanged) return blocks;
-      mutatedSections = true;
+      sectionsChanged = true;
       return nextBlocks;
     };
     return {
@@ -14180,31 +14138,21 @@ function renumberFootnotes(document2) {
   });
   const nextItems = {};
   let itemsChanged = false;
-  for (const [id, footnote] of Object.entries(footnotes.items)) {
+  for (const [id, body] of Object.entries(collection.items)) {
     if (referenced.has(id)) {
-      nextItems[id] = footnote;
+      nextItems[id] = body;
     } else {
       itemsChanged = true;
     }
   }
-  if (!mutatedSections && !itemsChanged) {
-    return document2;
-  }
-  return {
-    ...document2,
-    sections: mutatedSections ? sections : document2.sections,
-    footnotes: {
-      ...footnotes,
-      items: itemsChanged ? nextItems : footnotes.items
-    }
-  };
+  return { sections, sectionsChanged, nextItems, itemsChanged };
 }
-function rewriteParagraphMarkers$1(paragraph, markerByFootnoteId) {
+function rewriteParagraphMarkers(paragraph, traversal, markerById) {
   let runChanged = false;
   const nextRuns = paragraph.runs.map((run) => {
-    const ref = getRunFootnoteReference(run);
+    const ref = traversal.getRef(run);
     if (!ref) return run;
-    const desired = markerByFootnoteId.get(ref.footnoteId);
+    const desired = markerById.get(ref.id);
     if (desired === void 0) return run;
     if (run.text === desired) return run;
     runChanged = true;
@@ -14213,167 +14161,134 @@ function rewriteParagraphMarkers$1(paragraph, markerByFootnoteId) {
   if (!runChanged) return paragraph;
   return { ...paragraph, runs: nextRuns };
 }
-function* iterateEndnoteReferenceRuns(document2) {
-  const sections = getDocumentSectionsCanonical(document2);
-  for (const section of sections) {
-    const zones = [
-      section.header ?? [],
-      section.firstPageHeader ?? [],
-      section.evenPageHeader ?? [],
-      section.blocks,
-      section.footer ?? [],
-      section.firstPageFooter ?? [],
-      section.evenPageFooter ?? []
-    ];
-    for (const blocks of zones) {
-      for (const block of blocks) {
-        for (const paragraph of getBlockParagraphs(block)) {
-          for (const run of paragraph.runs) {
-            if (run.kind === "endnoteReference") {
-              yield { paragraph, run };
-            }
-          }
-        }
-      }
+function iterateFootnoteReferenceRuns(document2) {
+  return iterateNoteReferenceRuns(document2, "footnoteReference");
+}
+const LOWER_LETTERS = "abcdefghijklmnopqrstuvwxyz";
+const ROMAN_NUMERALS = [
+  [1e3, "m"],
+  [900, "cm"],
+  [500, "d"],
+  [400, "cd"],
+  [100, "c"],
+  [90, "xc"],
+  [50, "l"],
+  [40, "xl"],
+  [10, "x"],
+  [9, "ix"],
+  [5, "v"],
+  [4, "iv"],
+  [1, "i"]
+];
+function toRoman(value) {
+  if (value <= 0) return String(value);
+  let remaining = value;
+  let result = "";
+  for (const [size, glyph] of ROMAN_NUMERALS) {
+    while (remaining >= size) {
+      result += glyph;
+      remaining -= size;
     }
   }
+  return result;
 }
-function listReferencedEndnotes(document2) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  let counter2 = 0;
-  for (const { run } of iterateEndnoteReferenceRuns(document2)) {
-    const ref = getRunEndnoteReference(run);
-    if (!ref) continue;
-    if (seen.has(ref.endnoteId)) continue;
-    seen.add(ref.endnoteId);
-    if (!ref.customMark) {
-      counter2 += 1;
-    }
-    result.push({
-      endnoteId: ref.endnoteId,
-      customMark: ref.customMark,
-      index: ref.customMark ? 0 : counter2
-    });
+function toLetters(value) {
+  if (value <= 0) return String(value);
+  let remaining = value;
+  let result = "";
+  while (remaining > 0) {
+    const digit = (remaining - 1) % 26;
+    result = LOWER_LETTERS[digit] + result;
+    remaining = Math.floor((remaining - 1) / 26);
   }
   return result;
 }
-function renumberEndnotes(document2) {
-  var _a, _b;
-  const endnotes = document2.endnotes;
-  if (!endnotes || Object.keys(endnotes.items).length === 0) {
+const SYMBOL_MARKS = ["*", "†", "‡", "§", "¶", "#"];
+function getFootnoteDisplayMarker(oneBasedIndex, format = "decimal") {
+  switch (format) {
+    case "lowerRoman":
+      return toRoman(oneBasedIndex);
+    case "upperRoman":
+      return toRoman(oneBasedIndex).toUpperCase();
+    case "lowerLetter":
+      return toLetters(oneBasedIndex);
+    case "upperLetter":
+      return toLetters(oneBasedIndex).toUpperCase();
+    case "symbol": {
+      const slot = (oneBasedIndex - 1) % SYMBOL_MARKS.length;
+      const cycles = Math.floor((oneBasedIndex - 1) / SYMBOL_MARKS.length) + 1;
+      return SYMBOL_MARKS[slot].repeat(cycles);
+    }
+    case "decimal":
+    default:
+      return String(oneBasedIndex);
+  }
+}
+const footnoteTraversal = {
+  runKind: "footnoteReference",
+  getRef: (run) => {
+    const ref = getRunFootnoteReference(run);
+    return ref ? { id: ref.footnoteId, customMark: ref.customMark } : void 0;
+  },
+  formatMarker: getFootnoteDisplayMarker
+};
+function findFootnoteReference(document2, footnoteId) {
+  return findNoteReference(document2, footnoteTraversal, footnoteId);
+}
+function renumberFootnotes(document2) {
+  const footnotes = document2.footnotes;
+  if (!footnotes || Object.keys(footnotes.items).length === 0) {
     return document2;
   }
-  const format = ((_a = endnotes.settings) == null ? void 0 : _a.numberFormat) ?? "decimal";
-  const startAt = ((_b = endnotes.settings) == null ? void 0 : _b.startAt) ?? 1;
-  const referenced = /* @__PURE__ */ new Set();
-  const markerByEndnoteId = /* @__PURE__ */ new Map();
-  let autoCounter = startAt - 1;
-  for (const { run } of iterateEndnoteReferenceRuns(document2)) {
-    const ref = getRunEndnoteReference(run);
-    if (!ref) continue;
-    referenced.add(ref.endnoteId);
-    if (ref.customMark) {
-      markerByEndnoteId.set(ref.endnoteId, ref.customMark);
-      continue;
-    }
-    if (!markerByEndnoteId.has(ref.endnoteId)) {
-      autoCounter += 1;
-      markerByEndnoteId.set(
-        ref.endnoteId,
-        getFootnoteDisplayMarker(autoCounter, format)
-      );
-    }
+  const { sections, sectionsChanged, nextItems, itemsChanged } = computeNoteRenumber(document2, footnotes, footnoteTraversal);
+  if (!sectionsChanged && !itemsChanged) {
+    return document2;
   }
-  let mutatedSections = false;
-  const sections = getDocumentSectionsCanonical(document2).map((section) => {
-    const rewriteBlocks = (blocks) => {
-      if (!blocks) return blocks;
-      let blockChanged = false;
-      const nextBlocks = blocks.map((block) => {
-        switch (block.type) {
-          case "paragraph": {
-            const updated = rewriteParagraphMarkers(block, markerByEndnoteId);
-            if (updated !== block) blockChanged = true;
-            return updated;
-          }
-          case "table": {
-            let tableChanged = false;
-            const nextRows = block.rows.map((row) => {
-              let rowChanged = false;
-              const nextCells = row.cells.map((cell) => {
-                let cellChanged = false;
-                const nextCellBlocks = cell.blocks.map((p) => {
-                  const updated = rewriteParagraphMarkers(p, markerByEndnoteId);
-                  if (updated !== p) cellChanged = true;
-                  return updated;
-                });
-                if (!cellChanged) return cell;
-                rowChanged = true;
-                return { ...cell, blocks: nextCellBlocks };
-              });
-              if (!rowChanged) return row;
-              tableChanged = true;
-              return { ...row, cells: nextCells };
-            });
-            if (!tableChanged) return block;
-            blockChanged = true;
-            return { ...block, rows: nextRows };
-          }
-          default:
-            return assertNever(block, "block");
-        }
-      });
-      if (!blockChanged) return blocks;
-      mutatedSections = true;
-      return nextBlocks;
-    };
-    return {
-      ...section,
-      blocks: rewriteBlocks(section.blocks) ?? section.blocks,
-      header: rewriteBlocks(section.header),
-      firstPageHeader: rewriteBlocks(section.firstPageHeader),
-      evenPageHeader: rewriteBlocks(section.evenPageHeader),
-      footer: rewriteBlocks(section.footer),
-      firstPageFooter: rewriteBlocks(section.firstPageFooter),
-      evenPageFooter: rewriteBlocks(section.evenPageFooter)
-    };
-  });
-  const nextItems = {};
-  let itemsChanged = false;
-  for (const [id, endnote] of Object.entries(endnotes.items)) {
-    if (referenced.has(id)) {
-      nextItems[id] = endnote;
-    } else {
-      itemsChanged = true;
+  return {
+    ...document2,
+    sections: sectionsChanged ? sections : document2.sections,
+    footnotes: {
+      ...footnotes,
+      items: itemsChanged ? nextItems : footnotes.items
     }
+  };
+}
+const endnoteTraversal = {
+  runKind: "endnoteReference",
+  getRef: (run) => {
+    const ref = getRunEndnoteReference(run);
+    return ref ? { id: ref.endnoteId, customMark: ref.customMark } : void 0;
+  },
+  formatMarker: getFootnoteDisplayMarker
+};
+function iterateEndnoteReferenceRuns(document2) {
+  return iterateNoteReferenceRuns(document2, "endnoteReference");
+}
+function listReferencedEndnotes(document2) {
+  return listReferencedNotes(document2, endnoteTraversal).map((info) => ({
+    endnoteId: info.id,
+    customMark: info.customMark,
+    index: info.index
+  }));
+}
+function renumberEndnotes(document2) {
+  const endnotes = document2.endnotes;
+  if (!endnotes || Object.keys(endnotes.items).length === 0) {
+    return document2;
   }
-  if (!mutatedSections && !itemsChanged) {
+  const { sections, sectionsChanged, nextItems, itemsChanged } = computeNoteRenumber(document2, endnotes, endnoteTraversal);
+  if (!sectionsChanged && !itemsChanged) {
     return document2;
   }
   return {
     ...document2,
-    sections: mutatedSections ? sections : document2.sections,
+    sections: sectionsChanged ? sections : document2.sections,
     endnotes: {
       ...endnotes,
       items: itemsChanged ? nextItems : endnotes.items
     }
   };
 }
-function rewriteParagraphMarkers(paragraph, markerByEndnoteId) {
-  let runChanged = false;
-  const nextRuns = paragraph.runs.map((run) => {
-    const ref = getRunEndnoteReference(run);
-    if (!ref) return run;
-    const desired = markerByEndnoteId.get(ref.endnoteId);
-    if (desired === void 0) return run;
-    if (run.text === desired) return run;
-    runChanged = true;
-    return { ...run, text: desired };
-  });
-  if (!runChanged) return paragraph;
-  return { ...paragraph, runs: nextRuns };
-}
 const FLOW_ID_PREFIX = "endnote-flow";
 function makeMarkerRun(endnoteId, marker) {
   return {
@@ -35709,7 +35624,7 @@ function importDocxInWorker(buffer, options = {}) {
     const worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "" + new URL("assets/importDocxWorker-8fivvDCX.js", import.meta.url).href,
+        "" + new URL("assets/importDocxWorker-C94l6-O5.js", import.meta.url).href,
         import.meta.url
       ),
       {

package/dist/oasis-editor.js

@@ -1,4 +1,4 @@
-import { O, c2, c3, c4, c5, c6, a8, c7, Q, bN, c8, c9, ca, N, cb, bL, cc, cd, ce, cf, cg, bZ, ch, ci, cj, ck, cl, cm, cn, co, cp, cq, cr, ad, cs, bY, ct, c4 as c42, c9 as c92, cb as cb2, ck as ck2, cm as cm2, cr as cr2, cu, bP, bK, cv, cw, cx, bM, cy, cz, bO } from "./index-9_ibx79n.js";
+import { O, c2, c3, c4, c5, c6, a8, c7, Q, bN, c8, c9, ca, N, cb, bL, cc, cd, ce, cf, cg, bZ, ch, ci, cj, ck, cl, cm, cn, co, cp, cq, cr, ad, cs, bY, ct, c4 as c42, c9 as c92, cb as cb2, ck as ck2, cm as cm2, cr as cr2, cu, bP, bK, cv, cw, cx, bM, cy, cz, bO } from "./index-CHcJlpsx.js";
 export {
   O as BalloonShell,
   c2 as Button,