@bendyline/squisq 2.1.0 → 2.3.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