@bendyline/squisq 2.0.1 → 2.2.0

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

package/dist/{chunk-PXLVXTLW.js → chunk-RS5AP3J4.js}

@@ -2,22 +2,22 @@ import {
   extractContent,
   mapElementToBlock,
   stripMarkdown
-} from "./chunk-Q7LROV2H.js";
+} from "./chunk-NKNMGIIN.js";
 import {
   cloneAndFreezeData,
   isTemplateBlock
-} from "./chunk-5J4HKRJF.js";
+} from "./chunk-BAOV476U.js";
 import {
   extractPlainText,
   getChildren
-} from "./chunk-AMIR72JP.js";
+} from "./chunk-BCCXTMN5.js";
 import {
   estimateTimeFromText
-} from "./chunk-3E5F2XMR.js";
+} from "./chunk-67L6WRJN.js";
 import {
   SeededRandom,
   hashString
-} from "./chunk-FVTQSNR7.js";
+} from "./chunk-XRW6P7IF.js";
 
 // src/transform/styles/documentary.ts
 var documentaryStyle = {
@@ -32,7 +32,8 @@ var documentaryStyle = {
   interleaveImages: true,
   blocksPerSection: { max: 3 },
   transitionStyle: "fade",
-  suggestedThemeId: "documentary"
+  suggestedThemeId: "documentary",
+  page: { spacing: "generous", emphasisCurve: "front-loaded" }
 };
 
 // src/transform/styles/magazine.ts
@@ -49,7 +50,8 @@ var magazineStyle = {
   blocksPerSection: { max: 5 },
   transitionStyle: "dissolve",
   suggestedThemeId: "magazine",
-  templateMap: { quote: "pullQuote", impactLine: "fullBleedQuote" }
+  templateMap: { quote: "pullQuote", impactLine: "fullBleedQuote" },
+  page: { spacing: "comfortable", emphasisCurve: "front-loaded" }
 };
 
 // src/transform/styles/dataDriven.ts
@@ -65,7 +67,8 @@ var dataDrivenStyle = {
   interleaveImages: false,
   blocksPerSection: { max: 6 },
   transitionStyle: "cut",
-  suggestedThemeId: "tech-dark"
+  suggestedThemeId: "tech-dark",
+  page: { spacing: "compact", emphasisCurve: "even" }
 };
 
 // src/transform/styles/narrative.ts
@@ -82,7 +85,8 @@ var narrativeStyle = {
   blocksPerSection: { max: 4 },
   transitionStyle: "fade",
   suggestedThemeId: "cinematic",
-  pacing: { intro: true, outro: true }
+  pacing: { intro: true, outro: true },
+  page: { spacing: "comfortable", emphasisCurve: "even" }
 };
 
 // src/transform/styles/minimal.ts
@@ -98,7 +102,8 @@ var minimalStyle = {
   interleaveImages: false,
   blocksPerSection: { max: 2 },
   transitionStyle: "fade",
-  suggestedThemeId: "minimalist"
+  suggestedThemeId: "minimalist",
+  page: { spacing: "generous", emphasisCurve: "even" }
 };
 
 // src/transform/registry.ts
@@ -189,6 +194,19 @@ function validateTransformStyle(style) {
       fail("budget.slidesPerMinute must be a positive finite number");
     }
   }
+  const pageValue = candidate.page;
+  if (pageValue !== void 0) {
+    if (!pageValue || typeof pageValue !== "object" || Array.isArray(pageValue)) {
+      fail("page must be an object");
+    }
+    const page = pageValue;
+    if (page.spacing !== void 0 && !["compact", "comfortable", "generous"].includes(page.spacing)) {
+      fail("page.spacing must be compact, comfortable, or generous");
+    }
+    if (page.emphasisCurve !== void 0 && !["even", "front-loaded"].includes(page.emphasisCurve)) {
+      fail("page.emphasisCurve must be even or front-loaded");
+    }
+  }
 }
 function styleSnapshot(style) {
   validateTransformStyle(style);
@@ -576,10 +594,7 @@ function allocateRescaled(blocks, totalDuration) {
   });
   const rawTotal = durations.reduce((sum, d) => sum + d, 0);
   if (rawTotal > 0 && effectiveDuration > 0) {
-    const scale = effectiveDuration / rawTotal;
-    for (let i = 0; i < durations.length; i++) {
-      durations[i] = clampDuration(durations[i] * scale);
-    }
+    fitDurations(durations, effectiveDuration);
   }
   let currentTime = 0;
   const result = [];
@@ -683,6 +698,49 @@ function toOutputBlock(block, startTime, duration) {
 function clampDuration(d) {
   return Math.max(MIN_BLOCK_DURATION, Math.min(MAX_BLOCK_DURATION, d));
 }
+var SCALE_SEARCH_ITERATIONS = 60;
+function totalAtScale(durations, scale) {
+  let sum = 0;
+  for (const d of durations) sum += clampDuration(d * scale);
+  return sum;
+}
+function fitDurations(durations, target) {
+  const rawTotal = durations.reduce((sum, d) => sum + d, 0);
+  if (rawTotal <= 0) return;
+  const plain = target / rawTotal;
+  const clampsNothing = durations.every((d) => {
+    const scaled = d * plain;
+    return scaled >= MIN_BLOCK_DURATION && scaled <= MAX_BLOCK_DURATION;
+  });
+  if (clampsNothing) {
+    for (let i = 0; i < durations.length; i++) durations[i] *= plain;
+    return;
+  }
+  let lo = 0;
+  let hi = 1;
+  for (let i = 0; i < SCALE_SEARCH_ITERATIONS && totalAtScale(durations, hi) < target; i++) {
+    hi *= 2;
+  }
+  for (let i = 0; i < SCALE_SEARCH_ITERATIONS; i++) {
+    const mid = (lo + hi) / 2;
+    if (totalAtScale(durations, mid) < target) lo = mid;
+    else hi = mid;
+  }
+  const scale = (lo + hi) / 2;
+  let clampedTotal = 0;
+  let freeRaw = 0;
+  for (const d of durations) {
+    const scaled = d * scale;
+    if (scaled < MIN_BLOCK_DURATION) clampedTotal += MIN_BLOCK_DURATION;
+    else if (scaled > MAX_BLOCK_DURATION) clampedTotal += MAX_BLOCK_DURATION;
+    else freeRaw += d;
+  }
+  const exact = freeRaw > 0 ? (target - clampedTotal) / freeRaw : scale;
+  const finalScale = Number.isFinite(exact) && exact > 0 ? exact : scale;
+  for (let i = 0; i < durations.length; i++) {
+    durations[i] = clampDuration(durations[i] * finalScale);
+  }
+}
 function estimateDefaultDuration(blocks) {
   let totalSeconds = 0;
   for (const block of blocks) {
@@ -791,4 +849,3 @@ export {
   analyzeBlocks,
   applyTransform
 };
-//# sourceMappingURL=chunk-PXLVXTLW.js.map

package/dist/{chunk-4X3JQXNM.js → chunk-XOFT65EX.js}

@@ -1,7 +1,7 @@
 import {
   DEFAULT_WORDS_PER_SECOND,
   countSpokenWords
-} from "./chunk-3E5F2XMR.js";
+} from "./chunk-67L6WRJN.js";
 
 // src/timing/readingTime.ts
 var DEFAULT_READING_WPM = 200;
@@ -32,4 +32,3 @@ export {
   estimateReadingTime,
   estimateNarrationTime
 };
-//# sourceMappingURL=chunk-4X3JQXNM.js.map

package/dist/{chunk-FVTQSNR7.js → chunk-XRW6P7IF.js}

@@ -6,9 +6,18 @@ var SeededRandom = class _SeededRandom {
       this.state = 3735928559;
     }
   }
-  /** Random float in [0, 1). */
+  /**
+   * Random float in [0, 1).
+   *
+   * The state increment wraps to 32 bits, as Mulberry32 specifies. Leaving it
+   * unwrapped (the shape of the widely-copied reference snippet) keeps the
+   * state as an ever-growing float: the bitwise ops below still coerce it
+   * mod 2^32, so the OUTPUT is identical — until the state passes 2^53 and
+   * `+= 0x6d2b79f5` stops being exact. From that point the low bits rot and
+   * the sequence silently drifts from Mulberry32 (measured: draw 4,917,758).
+   */
   next() {
-    let t = this.state += 1831565813;
+    let t = this.state = this.state + 1831565813 >>> 0;
     t = Math.imul(t ^ t >>> 15, t | 1);
     t ^= t + Math.imul(t ^ t >>> 7, t | 61);
     return ((t ^ t >>> 14) >>> 0) / 4294967296;
@@ -75,9 +84,9 @@ var SeededRandom = class _SeededRandom {
     }
     return items[items.length - 1]?.item;
   }
-  /** Current internal state (for debugging / serialization). */
+  /** Current internal state as a uint32 (for debugging / serialization). */
   getState() {
-    return this.state;
+    return this.state >>> 0;
   }
   /** Create an independent sub-stream keyed by a modifier. */
   derive(modifier) {
@@ -97,4 +106,3 @@ export {
   SeededRandom,
   hashString
 };
-//# sourceMappingURL=chunk-FVTQSNR7.js.map

package/dist/{chunk-R2YZTCLO.js → chunk-ZQKZSJAX.js}

@@ -3,7 +3,7 @@ import {
   TRANSITION_TYPES,
   normalizeTransitionDirection,
   normalizeTransitionType
-} from "./chunk-QE7TWGVT.js";
+} from "./chunk-4VOD55SX.js";
 
 // src/markdown/annotationCoercion.ts
 var KNOWN_BLOCK_META_KEYS = {
@@ -289,4 +289,3 @@ export {
   quoteAttrValue,
   serializeAnnotation
 };
-//# sourceMappingURL=chunk-R2YZTCLO.js.map