@bendyline/squisq 2.1.0 → 2.2.0

package/dist/{chunk-OTKVFVL6.js → chunk-I2O6W7DX.js}

@@ -24,24 +24,27 @@ import {
   templateRegistry,
   writeCustomTemplatesToFrontmatter,
   writeCustomThemesToFrontmatter
-} from "./chunk-JI77MGAK.js";
+} from "./chunk-7ARJZYQY.js";
 import {
   ASCII_TREE_VOCAB,
   ASCII_VOCAB,
+  MAX_BRIDGE_GAP,
   UNICODE_TREE_VOCAB,
   UNICODE_VOCAB,
   arrowDirection,
+  cellWidth,
   detectAsciiDiagram,
   isHoriz,
   isJunction,
   isVert,
+  toCells,
   toGrid,
   traceBoxes
-} from "./chunk-5UYI3RJB.js";
+} from "./chunk-FDYDYL77.js";
 import {
   defaultPageStyle,
   resolveMediaSchedule
-} from "./chunk-VWCJ2WXC.js";
+} from "./chunk-2ZWIXGAC.js";
 import {
   DEFAULT_THEME,
   FRONTMATTER_CUSTOM_TEMPLATES_KEY,
@@ -49,27 +52,27 @@ import {
   hexHueDegrees,
   resolveFontFamily,
   resolveTheme
-} from "./chunk-JHZWYRSW.js";
+} from "./chunk-C33GTPUZ.js";
 import {
   VIEWPORT_PRESETS,
   isTemplateBlock
-} from "./chunk-5J4HKRJF.js";
+} from "./chunk-BAOV476U.js";
 import {
   parseMarkdown
-} from "./chunk-66QO7XFB.js";
+} from "./chunk-ACZOVWX3.js";
 import {
   KNOWN_BLOCK_META_KEYS,
   coerceAnnotationValues,
   serializeAnnotation
-} from "./chunk-R2YZTCLO.js";
+} from "./chunk-ZQKZSJAX.js";
 import {
   extractPlainText,
   getChildren,
   readFrontmatterThemeId
-} from "./chunk-AMIR72JP.js";
+} from "./chunk-BCCXTMN5.js";
 import {
   estimateTimeFromText
-} from "./chunk-3E5F2XMR.js";
+} from "./chunk-67L6WRJN.js";
 
 // src/doc/utils/animationUtils.ts
 function getAnimationStyle(animation, _currentTime = 0) {
@@ -330,7 +333,9 @@ function cssFilterForTreatment(treatment, blur) {
 
 // src/doc/docToMarkdown.ts
 var TRANSITION_PARAM_KEYS = ["transition", "transitionDuration", "transitionDirection"];
-function docToMarkdown(doc) {
+var DEFAULT_TEMPLATE = "sectionHeader";
+function docToMarkdown(doc, options = {}) {
+  const defaultTemplate = resolveTemplateName(options.defaultTemplate ?? DEFAULT_TEMPLATE);
   const children = [];
   const blockIds = new Set(flattenBlocks(doc.blocks).map((b) => b.id));
   const docMediaByBlock = /* @__PURE__ */ new Map();
@@ -349,7 +354,7 @@ function docToMarkdown(doc) {
   }
   function emitBlock(block) {
     if (block.sourceHeading) {
-      const heading = ensureAnnotation(block, block.sourceHeading);
+      const heading = ensureAnnotation(block, block.sourceHeading, defaultTemplate);
       children.push(heading);
     } else if (block.standaloneAnnotation) {
       children.push(synthesizeAnnotationParagraph(block));
@@ -423,15 +428,16 @@ function synthesizeMediaParagraph(clip) {
     children: [{ type: "text", value: serializeAnnotation(clip.kind, params) }]
   };
 }
-function ensureAnnotation(block, heading) {
+function ensureAnnotation(block, heading, defaultTemplate) {
   const { attributes, transitionParams } = ensureTransitionMetadata(block, heading);
-  const hasExplicitTemplate = block.template && block.template !== "sectionHeader" && block.autoTemplate !== true;
-  const hasOverrides = block.templateOverrides && Object.keys(block.templateOverrides).length > 0;
-  let templateAnnotation = heading.templateAnnotation;
-  if (!templateAnnotation && (hasExplicitTemplate || hasOverrides || transitionParams)) {
+  const existing = heading.templateAnnotation;
+  const template = resolveAnnotationTemplate(block, existing, defaultTemplate);
+  const overrides = block.templateOverrides && Object.keys(block.templateOverrides).length > 0 ? block.templateOverrides : void 0;
+  let templateAnnotation;
+  if (template !== void 0 || overrides !== void 0) {
     templateAnnotation = {
-      ...hasExplicitTemplate ? { template: block.template ?? "sectionHeader" } : {},
-      ...hasOverrides ? { params: block.templateOverrides } : {}
+      ...template !== void 0 ? { template } : {},
+      ...overrides ? { params: overrides } : {}
     };
   }
   if (transitionParams) {
@@ -443,11 +449,33 @@ function ensureAnnotation(block, heading) {
       }
     };
   }
+  if (annotationsEqual(existing, templateAnnotation)) templateAnnotation = existing;
   if (attributes === heading.attributes && templateAnnotation === heading.templateAnnotation) {
     return heading;
   }
   return { ...heading, children: [...heading.children], attributes, templateAnnotation };
 }
+function resolveAnnotationTemplate(block, existing, defaultTemplate) {
+  if (!block.template || block.autoTemplate === true) return existing?.template;
+  const template = resolveTemplateName(block.template);
+  if (existing?.template && resolveTemplateName(existing.template) === template) {
+    return existing.template;
+  }
+  if (template === defaultTemplate) return void 0;
+  return block.template;
+}
+function annotationsEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return a.template === b.template && paramsEqual(a.params, b.params);
+}
+function paramsEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  const keys = Object.keys(a);
+  if (keys.length !== Object.keys(b).length) return false;
+  return keys.every((key) => Object.prototype.hasOwnProperty.call(b, key) && a[key] === b[key]);
+}
 function ensureTransitionMetadata(block, heading) {
   const transition = block.transition;
   if (!transition) {
@@ -2068,10 +2096,11 @@ async function discoverNarrationAudio(container) {
     let timing = null;
     if (consolidatedSections) {
       const audioBase = stripAudioExtension(filename);
+      let matchedName = "";
       for (const [sectionName, sectionTiming] of Object.entries(consolidatedSections)) {
-        if (audioBase.endsWith(`-${sectionName}`)) {
+        if (audioBase.endsWith(`-${sectionName}`) && sectionName.length > matchedName.length) {
+          matchedName = sectionName;
           timing = sectionTiming;
-          break;
         }
       }
     }
@@ -2508,6 +2537,17 @@ function truncate(text, max = 40) {
 }
 
 // src/doc/asciiDiagram/render.ts
+function normalizeLabelLines(label) {
+  return label.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function normalizeEdgeLabel(label) {
+  if (label === void 0) return void 0;
+  const collapsed = label.replace(/\s+/gu, " ").trim();
+  return collapsed.length > 0 ? collapsed : void 0;
+}
+function edgeLabelFitsBridge(text) {
+  return text.length <= MAX_BRIDGE_GAP;
+}
 var SIDE_MARGIN = 1;
 function renderAsciiDiagram(diagram2, options = {}) {
   const vocab = (options.style ?? diagram2.style) === "ascii" ? ASCII_VOCAB : UNICODE_VOCAB;
@@ -2591,10 +2631,10 @@ function layoutNodes(nodes, edges) {
   };
   const layoutSubtree = (id, depth) => {
     const node = byId.get(id);
-    const labelLines = node.label.length > 0 ? node.label.split("\n") : [];
+    const labelLines = normalizeLabelLines(node.label);
     const children = childIds.get(id) ?? [];
     if (children.length === 0) {
-      const innerW = labelLines.reduce((w, l) => Math.max(w, l.length), 0);
+      const innerW = labelLines.reduce((w, l) => Math.max(w, cellWidth(l)), 0);
       const deg = sideDeg.get(id) ?? { top: 0, bottom: 0, left: 0, right: 0 };
       const horizDeg = Math.max(deg.top, deg.bottom);
       const vertDeg = Math.max(deg.left, deg.right);
@@ -2617,14 +2657,15 @@ function layoutNodes(nodes, edges) {
     const childRects = placeSiblings(children, (childId) => layoutSubtree(childId, depth + 1));
     const bbox = unionRects(childRects);
     const extraRows = Math.max(0, labelLines.length - 1);
-    const titleLen = (labelLines[0] ?? "").length;
+    const titleLen = cellWidth(labelLines[0] ?? "");
     const rect = {
       r0: bbox.r0 - 2 - extraRows,
       c0: bbox.c0 - 2,
       r1: bbox.r1 + 2,
       c1: bbox.c1 + 2
     };
-    const minW = titleLen > 0 ? titleLen + 6 : 3;
+    const innerLinesW = labelLines.slice(1).reduce((w, l) => Math.max(w, cellWidth(l)), 0);
+    const minW = Math.max(titleLen > 0 ? titleLen + 6 : 3, innerLinesW > 0 ? innerLinesW + 4 : 3);
     if (rect.c1 - rect.c0 + 1 < minW) rect.c1 = rect.c0 + minW - 1;
     if (rect.c1 - rect.c0 + 1 < node.wCols) rect.c1 = rect.c0 + node.wCols - 1;
     placed.set(id, { node, rect, labelLines, isContainer: true, depth });
@@ -2718,7 +2759,7 @@ function drawBox(canvas, p, vocab) {
   const innerW = rect.c1 - rect.c0 - 1;
   canvas.set(rect.r0, rect.c0, vocab.tl, "border");
   canvas.set(rect.r0, rect.c1, vocab.tr, "border");
-  const title2 = isContainer && labelLines.length > 0 ? ` ${labelLines[0]} ` : null;
+  const title2 = isContainer && labelLines.length > 0 ? toCells(` ${labelLines[0]} `) : null;
   if (title2 && title2.length <= innerW - 2) {
     const left = Math.floor((innerW - title2.length) / 2);
     for (let i = 0; i < innerW; i++) {
@@ -2741,9 +2782,10 @@ function drawBox(canvas, p, vocab) {
     const innerH = rect.r1 - rect.r0 - 1;
     const startRow = isContainer ? rect.r0 + 1 : rect.r0 + 1 + Math.max(0, Math.floor((innerH - interiorLines.length) / 2));
     interiorLines.forEach((line, i) => {
-      const pad = Math.max(0, Math.floor((innerW - line.length) / 2));
-      for (let j = 0; j < line.length && pad + j < innerW; j++) {
-        canvas.set(startRow + i, rect.c0 + 1 + pad + j, line[j], "label");
+      const cells = toCells(line);
+      const pad = Math.max(0, Math.floor((innerW - cells.length) / 2));
+      for (let j = 0; j < cells.length && pad + j < innerW; j++) {
+        canvas.set(startRow + i, rect.c0 + 1 + pad + j, cells[j], "label");
       }
     });
   }
@@ -2795,24 +2837,25 @@ function drawEdges(canvas, edges, placed, vocab) {
     )
   );
   for (const req of sideLabelRequests) {
+    const cells = toCells(req.label);
     let done = false;
     for (const side of ["right", "left"]) {
       if (done) break;
       for (const { row, col } of req.candidates) {
         if (canvas.kindAt(row, col) !== "line-v") continue;
-        const startCol = side === "right" ? col + 2 : col - 1 - req.label.length;
+        const startCol = side === "right" ? col + 2 : col - 1 - cells.length;
         if (startCol < 0) continue;
         const gapCol = side === "right" ? col + 1 : col - 1;
         let free = canvas.kindAt(row, gapCol) === "empty";
-        for (let i = 0; free && i < req.label.length; i++) {
+        for (let i = 0; free && i < cells.length; i++) {
           if (canvas.kindAt(row, startCol + i) !== "empty") free = false;
         }
         if (free && side === "left" && startCol > 0) {
           free = canvas.kindAt(row, startCol - 1) === "empty";
         }
         if (!free) continue;
-        for (let i = 0; i < req.label.length; i++) {
-          canvas.set(row, startCol + i, req.label[i], "label");
+        for (let i = 0; i < cells.length; i++) {
+          canvas.set(row, startCol + i, cells[i], "label");
         }
         done = true;
         break;
@@ -2891,7 +2934,7 @@ function routeEdge(canvas, plan, planIdx, placed, attachment, vocab, deferSideLa
     canvas,
     directed: plan.edge.directed,
     biDir: plan.biDir,
-    label: plan.edge.label,
+    label: normalizeEdgeLabel(plan.edge.label),
     vocab,
     junction,
     stagger,
@@ -2989,8 +3032,8 @@ function drawVertical(args, s, t, exitCol, enterCol, dir) {
     const hi = Math.max(exitCol, enterCol);
     let segment = [];
     for (let c = lo + 1; c <= hi - 1; c++) segment.push(vocab.h);
-    if (label && segment.length >= label.length + 4) {
-      const text = ` ${label} `;
+    const text = label ? toCells(` ${label} `) : null;
+    if (text && edgeLabelFitsBridge(text) && segment.length >= text.length + 2) {
       const left = Math.floor((segment.length - text.length) / 2);
       segment = segment.map((ch, i) => i >= left && i < left + text.length ? text[i - left] : ch);
       labelEmbedded = true;
@@ -3045,15 +3088,22 @@ function drawHorizontal(args, s, t, exitRow, enterRow, dir) {
   const firstFree = exitCol + dir;
   const lastFree = enterCol - dir;
   const gap = (lastFree - firstFree) * dir + 1;
-  const drawH = (row, cA, cB, hostLabel) => {
+  const drawH = (row, cA, cB, hostLabel, reserveLo = 0, reserveHi = 0) => {
     const lo = Math.min(cA, cB);
     const hi = Math.max(cA, cB);
     let segment = [];
     for (let c = lo; c <= hi; c++) segment.push(vocab.h);
-    if (hostLabel && label && segment.length >= label.length + 4) {
-      const text = ` ${label} `;
-      const left = Math.floor((segment.length - text.length) / 2);
-      segment = segment.map((ch, i) => i >= left && i < left + text.length ? text[i - left] : ch);
+    const text = hostLabel && label ? toCells(` ${label} `) : null;
+    if (text && edgeLabelFitsBridge(text)) {
+      const from = reserveLo;
+      const to = segment.length - 1 - reserveHi;
+      const room = to - from + 1;
+      if (room >= text.length + 2) {
+        const left = from + Math.floor((room - text.length) / 2);
+        segment = segment.map(
+          (ch, i) => i >= left && i < left + text.length ? text[i - left] : ch
+        );
+      }
     }
     segment.forEach((ch, i) => {
       canvas.drawEdgeCell(row, lo + i, ch, ch === vocab.h ? "line-h" : "label", vocab);
@@ -3066,7 +3116,14 @@ function drawHorizontal(args, s, t, exitRow, enterRow, dir) {
     junction(sRow, exitCol, dir === 1 ? "right" : "left");
     junction(tRow, enterCol, dir === 1 ? "left" : "right");
     if (sRow === tRow && gap >= 1) {
-      drawH(sRow, firstFree, lastFree, true);
+      drawH(
+        sRow,
+        firstFree,
+        lastFree,
+        true,
+        (dir === 1 ? biDir : directed) ? 1 : 0,
+        (dir === 1 ? directed : biDir) ? 1 : 0
+      );
       if (directed) {
         canvas.drawEdgeCell(
           sRow,
@@ -3095,7 +3152,16 @@ function drawHorizontal(args, s, t, exitRow, enterRow, dir) {
   );
   junction(exitRow, exitCol, dir === 1 ? "right" : "left");
   junction(enterRow, enterCol, dir === 1 ? "left" : "right");
-  if (Math.abs(midCol - exitCol) >= 2) drawH(exitRow, firstFree, midCol - dir, true);
+  if (Math.abs(midCol - exitCol) >= 2) {
+    drawH(
+      exitRow,
+      firstFree,
+      midCol - dir,
+      true,
+      dir === 1 && biDir ? 1 : 0,
+      dir === -1 && biDir ? 1 : 0
+    );
+  }
   if (Math.abs(enterCol - midCol) >= 2) drawH(enterRow, midCol + dir, lastFree, false);
   if (exitRow === enterRow) {
     canvas.drawEdgeCell(exitRow, midCol, vocab.h, "line-h", vocab);
@@ -3670,10 +3736,17 @@ function formatCoordinate(value) {
 }
 
 // src/doc/treeview/render.ts
+function normalizeText(text) {
+  return text.replace(/\s+/gu, " ").trim();
+}
 function renderTree(tree2, options = {}) {
   const vocab = (options.style ?? tree2.style) === "ascii" ? ASCII_TREE_VOCAB : UNICODE_TREE_VOCAB;
   const lines = [];
-  const label = (node) => node.comment ? `${node.label}  # ${node.comment}` : node.label;
+  const label = (node) => {
+    const text = normalizeText(node.label);
+    const comment = node.comment ? normalizeText(node.comment) : "";
+    return comment ? `${text}  # ${comment}` : text;
+  };
   const walk = (nodes, prefix) => {
     nodes.forEach((node, i) => {
       const last = i === nodes.length - 1;
@@ -3717,4 +3790,3 @@ export {
   renderAsciiTimeline,
   renderTree
 };
-//# sourceMappingURL=chunk-OTKVFVL6.js.map

package/dist/{chunk-Q7LROV2H.js → chunk-NKNMGIIN.js}

@@ -720,4 +720,3 @@ export {
   stripMarkdown,
   mapElementToBlock
 };
-//# sourceMappingURL=chunk-Q7LROV2H.js.map

package/dist/chunk-OPO5K4DZ.js

@@ -0,0 +1,241 @@
+// src/versions/timestamp.ts
+var TIMESTAMP_RE = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})Z$/;
+function pad2(n) {
+  return n < 10 ? `0${n}` : String(n);
+}
+function formatVersionTimestamp(date) {
+  return String(date.getUTCFullYear()).padStart(4, "0") + pad2(date.getUTCMonth() + 1) + pad2(date.getUTCDate()) + "T" + pad2(date.getUTCHours()) + pad2(date.getUTCMinutes()) + pad2(date.getUTCSeconds()) + "Z";
+}
+function parseVersionTimestamp(stamp) {
+  const m = TIMESTAMP_RE.exec(stamp);
+  if (!m) return null;
+  const [, y, mo, d, h, mi, s] = m;
+  const ms = Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), Number(s));
+  if (Number.isNaN(ms)) return null;
+  return new Date(ms);
+}
+var VERSION_TIMESTAMP_PATTERN = TIMESTAMP_RE;
+
+// src/versions/gitignore.ts
+var decoder = new TextDecoder();
+var encoder = new TextEncoder();
+var GITIGNORE_PATH = ".gitignore";
+var VERSIONS_IGNORE_RULE = ".versions/";
+var EQUIVALENT_VERSIONS_RULE = /^(!?)\/?\.versions\/?$/;
+async function ensureVersionsGitIgnored(container) {
+  const data = await container.readFile(GITIGNORE_PATH);
+  const existing = data ? decoder.decode(data) : "";
+  for (const line of existing.split(/\r?\n/)) {
+    if (EQUIVALENT_VERSIONS_RULE.test(line.trim())) return;
+  }
+  const newline = existing.includes("\r\n") ? "\r\n" : "\n";
+  const separator = existing.length > 0 && !existing.endsWith("\n") ? newline : "";
+  const next = `${existing}${separator}${VERSIONS_IGNORE_RULE}${newline}`;
+  await container.writeFile(GITIGNORE_PATH, encoder.encode(next), "text/plain");
+}
+
+// src/versions/snapshotStore.ts
+var decoder2 = new TextDecoder();
+var encoder2 = new TextEncoder();
+var INVALID_BASENAME_CHARS = /[<>:"/\\|?*]/;
+var WINDOWS_DEVICE_NAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i;
+var mutationQueues = /* @__PURE__ */ new WeakMap();
+function assertSafeBasename(basename) {
+  if (basename.length === 0 || basename.length > 200 || basename === "." || basename === ".." || basename.endsWith(".") || basename.endsWith(" ") || INVALID_BASENAME_CHARS.test(basename) || [...basename].some((char) => {
+    const code = char.codePointAt(0);
+    return code < 32 || code === 127;
+  }) || WINDOWS_DEVICE_NAME.test(basename)) {
+    throw new TypeError(`Invalid snapshot basename: ${JSON.stringify(basename)}`);
+  }
+}
+function buildSnapshotPath(strategy, basename, date, collision = 0) {
+  assertSafeBasename(basename);
+  if (!Number.isFinite(date.getTime())) throw new TypeError("Snapshot date must be valid");
+  if (!Number.isInteger(collision) || collision < 0) {
+    throw new RangeError("Snapshot collision must be a non-negative integer");
+  }
+  const stamp = formatVersionTimestamp(date);
+  const suffix = collision > 0 ? `-${collision + 1}` : "";
+  return `${strategy.prefix}${basename}.${stamp}${suffix}.${strategy.extension}`;
+}
+function parseSnapshotPath(strategy, path) {
+  if (!path.startsWith(strategy.prefix)) return null;
+  const extension = `.${strategy.extension}`;
+  const rest = path.slice(strategy.prefix.length);
+  if (!rest.endsWith(extension)) return null;
+  const stem = rest.slice(0, -extension.length);
+  const lastDot = stem.lastIndexOf(".");
+  if (lastDot <= 0) return null;
+  const basename = stem.slice(0, lastDot);
+  const tail = stem.slice(lastDot + 1);
+  const dash = tail.indexOf("-");
+  let stamp = tail;
+  let collision = 0;
+  if (dash >= 0) {
+    stamp = tail.slice(0, dash);
+    const suffix = Number(tail.slice(dash + 1));
+    if (!Number.isInteger(suffix) || suffix < 2) return null;
+    collision = suffix - 1;
+  }
+  const timestamp = parseVersionTimestamp(stamp);
+  return timestamp ? { basename, timestamp, collision } : null;
+}
+async function listSnapshots(container, strategy, basename) {
+  const entries = await container.listFiles(strategy.prefix);
+  const versions = [];
+  for (const entry of entries) {
+    const parsed = parseSnapshotPath(strategy, entry.path);
+    if (!parsed || basename !== void 0 && parsed.basename !== basename) continue;
+    versions.push({
+      path: entry.path,
+      basename: parsed.basename,
+      timestamp: parsed.timestamp,
+      size: entry.size,
+      collision: parsed.collision
+    });
+  }
+  versions.sort((a, b) => {
+    const timestampDelta = b.timestamp.getTime() - a.timestamp.getTime();
+    return timestampDelta || b.collision - a.collision;
+  });
+  return versions;
+}
+async function readTextSnapshot(container, version) {
+  const path = typeof version === "string" ? version : version.path;
+  const data = await container.readFile(path);
+  return data ? decoder2.decode(data) : null;
+}
+async function saveTextSnapshot(container, strategy, options) {
+  return withContainerMutationLock(container, async () => {
+    const versions = await listSnapshots(container, strategy, options.basename);
+    if (!options.force && versions.length > 0) {
+      const existing = await readTextSnapshot(container, versions[0]);
+      if (existing === options.content) {
+        await ensureVersionsGitIgnored(container);
+        return { saved: false, version: null, reason: "unchanged" };
+      }
+    }
+    const now = options.now ?? /* @__PURE__ */ new Date();
+    const data = encoder2.encode(options.content);
+    await ensureVersionsGitIgnored(container);
+    let collision = 0;
+    let path = buildSnapshotPath(strategy, options.basename, now, collision);
+    if (container.writeFileExclusive) {
+      while (!await container.writeFileExclusive(path, data, options.mimeType)) {
+        collision += 1;
+        path = buildSnapshotPath(strategy, options.basename, now, collision);
+      }
+    } else {
+      while (await container.exists(path)) {
+        collision += 1;
+        path = buildSnapshotPath(strategy, options.basename, now, collision);
+      }
+      await container.writeFile(path, data, options.mimeType);
+    }
+    return {
+      saved: true,
+      version: {
+        path,
+        basename: options.basename,
+        timestamp: now,
+        size: data.byteLength,
+        collision
+      },
+      reason: "saved"
+    };
+  });
+}
+async function withContainerMutationLock(container, operation) {
+  const key = container.mutationLock ?? container;
+  const previous = mutationQueues.get(key) ?? Promise.resolve();
+  let release;
+  const gate = new Promise((resolve) => {
+    release = resolve;
+  });
+  const queued = previous.catch(() => void 0).then(() => gate);
+  mutationQueues.set(key, queued);
+  await previous.catch(() => void 0);
+  try {
+    return await operation();
+  } finally {
+    release();
+    if (mutationQueues.get(key) === queued) mutationQueues.delete(key);
+  }
+}
+function groupByBasename(versions) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const version of versions) {
+    const group = groups.get(version.basename);
+    if (group) group.push(version);
+    else groups.set(version.basename, [version]);
+  }
+  return groups;
+}
+function inListOrder(versions, toDelete) {
+  return versions.filter((version) => toDelete.has(version));
+}
+async function pruneSnapshots(container, strategy, policy, basename) {
+  if (policy.type === "keep-last-n" && (!Number.isSafeInteger(policy.n) || policy.n < 0)) {
+    throw new RangeError("keep-last-n requires a non-negative safe integer");
+  }
+  if (policy.type === "older-than" && !Number.isFinite(policy.date.getTime())) {
+    throw new TypeError("older-than requires a valid date");
+  }
+  const versions = await listSnapshots(container, strategy, basename);
+  const toDelete = /* @__PURE__ */ new Set();
+  for (const group of groupByBasename(versions).values()) {
+    if (policy.type === "keep-last-n") {
+      for (const version of group.slice(policy.n)) toDelete.add(version);
+    } else if (policy.type === "older-than") {
+      const cutoff = policy.date.getTime();
+      for (const version of group) {
+        if (version.timestamp.getTime() < cutoff) toDelete.add(version);
+      }
+    } else {
+      for (const version of group) {
+        if (!policy.keep(version, group)) toDelete.add(version);
+      }
+    }
+  }
+  const deleted = inListOrder(versions, toDelete);
+  await removeSnapshots(container, deleted);
+  return deleted;
+}
+async function coalesceSnapshots(container, strategy, options = {}, basename) {
+  const windowMs = options.windowMs ?? 6e4;
+  if (!Number.isFinite(windowMs) || windowMs < 0) {
+    throw new RangeError("windowMs must be a non-negative finite number");
+  }
+  const versions = await listSnapshots(container, strategy, basename);
+  const toDelete = /* @__PURE__ */ new Set();
+  for (const group of groupByBasename(versions).values()) {
+    let anchor = group[0];
+    for (let index = 1; index < group.length; index++) {
+      const candidate = group[index];
+      if (anchor.timestamp.getTime() - candidate.timestamp.getTime() <= windowMs) {
+        toDelete.add(candidate);
+      } else {
+        anchor = candidate;
+      }
+    }
+  }
+  const deleted = inListOrder(versions, toDelete);
+  await removeSnapshots(container, deleted);
+  return deleted;
+}
+async function removeSnapshots(container, versions) {
+  for (const version of versions) await container.removeFile(version.path);
+}
+
+export {
+  formatVersionTimestamp,
+  parseVersionTimestamp,
+  VERSION_TIMESTAMP_PATTERN,
+  buildSnapshotPath,
+  parseSnapshotPath,
+  listSnapshots,
+  readTextSnapshot,
+  saveTextSnapshot,
+  pruneSnapshots,
+  coalesceSnapshots
+};

package/dist/{chunk-TUWMK62B.js → chunk-PUS54YU6.js}

@@ -435,6 +435,48 @@ function lineStyleDasharray(style) {
   }
 }
 
+// src/base64.ts
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function bytesToBase64(bytes) {
+  let output = "";
+  for (let index = 0; index < bytes.length; index += 3) {
+    const first = bytes[index];
+    const hasSecond = index + 1 < bytes.length;
+    const hasThird = index + 2 < bytes.length;
+    const second = hasSecond ? bytes[index + 1] : 0;
+    const third = hasThird ? bytes[index + 2] : 0;
+    const value = first << 16 | second << 8 | third;
+    output += ALPHABET[value >>> 18 & 63];
+    output += ALPHABET[value >>> 12 & 63];
+    output += hasSecond ? ALPHABET[value >>> 6 & 63] : "=";
+    output += hasThird ? ALPHABET[value & 63] : "=";
+  }
+  return output;
+}
+function base64ToBytes(value) {
+  const normalized = value.replace(/[\t\n\r ]/g, "");
+  if (normalized.length % 4 !== 0 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(normalized)) {
+    throw new TypeError("Invalid base64 data");
+  }
+  const padding = normalized.endsWith("==") ? 2 : normalized.endsWith("=") ? 1 : 0;
+  const output = new Uint8Array(normalized.length / 4 * 3 - padding);
+  let outputIndex = 0;
+  for (let index = 0; index < normalized.length; index += 4) {
+    const a = ALPHABET.indexOf(normalized[index]);
+    const b = ALPHABET.indexOf(normalized[index + 1]);
+    const c = normalized[index + 2] === "=" ? 0 : ALPHABET.indexOf(normalized[index + 2]);
+    const d = normalized[index + 3] === "=" ? 0 : ALPHABET.indexOf(normalized[index + 3]);
+    const packed = a << 18 | b << 12 | c << 6 | d;
+    if (outputIndex < output.length) output[outputIndex++] = packed >>> 16 & 255;
+    if (outputIndex < output.length) output[outputIndex++] = packed >>> 8 & 255;
+    if (outputIndex < output.length) output[outputIndex++] = packed & 255;
+  }
+  return output;
+}
+function base64ToUtf8(value) {
+  return new TextDecoder().decode(base64ToBytes(value));
+}
+
 export {
   PATH_SHAPE_KINDS,
   shapePath,
@@ -446,6 +488,7 @@ export {
   nearestSnapPoint,
   snapEndpoints,
   connectorPath,
-  lineStyleDasharray
+  lineStyleDasharray,
+  bytesToBase64,
+  base64ToUtf8
 };
-//# sourceMappingURL=chunk-TUWMK62B.js.map

package/dist/{chunk-GZY66SDN.js → chunk-R3KTTOMS.js}

@@ -121,4 +121,3 @@ export {
   getGeohashPath,
   geohashOverlapsBounds
 };
-//# sourceMappingURL=chunk-GZY66SDN.js.map