@bendyline/squisq 2.11.7 → 2.11.8

package/dist/chunk-L7QZORLB.js

@@ -0,0 +1,230 @@
+// src/mediaEdit/recipe.ts
+var MEDIA_FX_ORDER = ["highpass", "denoise", "debreath", "loudness"];
+var MEDIA_FX_SPECS = Object.freeze({
+  highpass: { defaultValue: 80, min: 20, max: 300 },
+  denoise: { defaultValue: 0.8, min: 0, max: 1 },
+  debreath: { defaultValue: -15, min: -40, max: 0 },
+  loudness: { defaultValue: -16, min: -31, max: -5 }
+});
+var MEDIA_EDIT_PARAMS = [
+  { key: "fx", htmlSuffix: "fx" },
+  { key: "cuts", htmlSuffix: "cuts" },
+  { key: "gain", htmlSuffix: "gain" },
+  { key: "fadeIn", htmlSuffix: "fade-in" },
+  { key: "fadeOut", htmlSuffix: "fade-out" },
+  { key: "crop", htmlSuffix: "crop" },
+  { key: "group", htmlSuffix: "group" }
+];
+function mediaEditHtmlAttribute(kind, key) {
+  const param = MEDIA_EDIT_PARAMS.find((p) => p.key === key);
+  return `data-squisq-${kind}-${param?.htmlSuffix ?? key}`;
+}
+function formatMediaNumber(value, digits = 3) {
+  const rounded = Number(value.toFixed(digits));
+  return Object.is(rounded, -0) ? "0" : String(rounded);
+}
+function finiteNumber(raw) {
+  if (raw == null) return null;
+  const trimmed = raw.trim();
+  if (!/^[-+]?(\d+(\.\d*)?|\.\d+)$/.test(trimmed)) return null;
+  const n = Number(trimmed);
+  return Number.isFinite(n) ? n : null;
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function parseSeconds(raw) {
+  const trimmed = raw.trim();
+  const bare = finiteNumber(trimmed);
+  if (bare != null) return bare >= 0 ? bare : null;
+  const ms = trimmed.match(/^(\d+(?:\.\d+)?)ms$/i);
+  if (ms) return Number(ms[1]) / 1e3;
+  const mmss = trimmed.match(/^(\d+):([0-5]?\d)(?:\.(\d+))?$/);
+  if (mmss) return Number(mmss[1]) * 60 + Number(mmss[2]) + Number(`0.${mmss[3] ?? "0"}`);
+  return null;
+}
+function isFxOpId(name) {
+  return MEDIA_FX_ORDER.includes(name);
+}
+function parseMediaFx(raw) {
+  if (raw == null) return null;
+  const tokens = raw.split(/[\s,]+/).filter(Boolean);
+  if (tokens.length === 0) return null;
+  const byId = /* @__PURE__ */ new Map();
+  const unknown = [];
+  for (const token of tokens) {
+    const colon = token.indexOf(":");
+    const name = (colon === -1 ? token : token.slice(0, colon)).toLowerCase();
+    if (!isFxOpId(name)) {
+      unknown.push(token);
+      continue;
+    }
+    const spec = MEDIA_FX_SPECS[name];
+    let value = spec.defaultValue;
+    if (colon !== -1) {
+      value = finiteNumber(token.slice(colon + 1));
+      if (value != null && name === "debreath") value = -Math.abs(value);
+    }
+    if (value == null) {
+      unknown.push(token);
+      continue;
+    }
+    byId.set(name, clamp(value, spec.min, spec.max));
+  }
+  const ops = MEDIA_FX_ORDER.filter((id) => byId.has(id)).map((id) => ({
+    id,
+    value: byId.get(id)
+  }));
+  return { ops, unknown };
+}
+function serializeMediaFx(chain) {
+  return [
+    ...chain.ops.map((op) => `${op.id}:${formatMediaNumber(op.value)}`),
+    ...chain.unknown
+  ].join(" ");
+}
+function hasRenderableFx(chain) {
+  return chain != null && chain.ops.length > 0;
+}
+var CUT_EPSILON = 1e-3;
+function normalizeMediaCuts(cuts, windowStart = 0, windowEnd = Number.POSITIVE_INFINITY) {
+  const clamped = cuts.filter((c) => Number.isFinite(c.start) && Number.isFinite(c.end)).map((c) => ({
+    start: Math.max(windowStart, Math.min(c.start, c.end)),
+    end: Math.min(windowEnd, Math.max(c.start, c.end))
+  })).filter((c) => c.end - c.start >= CUT_EPSILON).sort((a, b) => a.start - b.start);
+  const merged = [];
+  for (const cut of clamped) {
+    const last = merged[merged.length - 1];
+    if (last && cut.start <= last.end + CUT_EPSILON) {
+      last.end = Math.max(last.end, cut.end);
+    } else {
+      merged.push({ ...cut });
+    }
+  }
+  return merged;
+}
+function parseMediaCuts(raw) {
+  if (raw == null) return null;
+  const cuts = [];
+  for (const token of raw.split(/[\s,]+/).filter(Boolean)) {
+    const dash = token.indexOf("-", 1);
+    if (dash === -1) continue;
+    const start = parseSeconds(token.slice(0, dash));
+    const end = parseSeconds(token.slice(dash + 1));
+    if (start == null || end == null || end <= start) continue;
+    cuts.push({ start, end });
+  }
+  const normalized = normalizeMediaCuts(cuts);
+  return normalized.length > 0 ? normalized : null;
+}
+function serializeMediaCuts(cuts) {
+  return normalizeMediaCuts(cuts).map((c) => `${formatMediaNumber(c.start)}-${formatMediaNumber(c.end)}`).join(" ");
+}
+var MIN_CROP_EDGE = 0.02;
+function parseMediaCrop(raw) {
+  if (raw == null) return null;
+  const parts = raw.split(/[\s,]+/).filter(Boolean).map((p) => finiteNumber(p));
+  if (parts.length !== 4 || parts.some((p) => p == null)) return null;
+  return normalizeMediaCrop({
+    x: parts[0],
+    y: parts[1],
+    w: parts[2],
+    h: parts[3]
+  });
+}
+function normalizeMediaCrop(crop) {
+  const x = clamp(crop.x, 0, 1 - MIN_CROP_EDGE);
+  const y = clamp(crop.y, 0, 1 - MIN_CROP_EDGE);
+  const w = clamp(crop.w, MIN_CROP_EDGE, 1 - x);
+  const h = clamp(crop.h, MIN_CROP_EDGE, 1 - y);
+  const full = x < 1e-4 && y < 1e-4 && w > 1 - 1e-4 && h > 1 - 1e-4;
+  return full ? null : { x, y, w, h };
+}
+function serializeMediaCrop(crop) {
+  return [crop.x, crop.y, crop.w, crop.h].map((n) => formatMediaNumber(n, 4)).join(" ");
+}
+var GAIN_RANGE = { min: -60, max: 24 };
+var GROUP_RE = /^[A-Za-z0-9_-]{1,64}$/;
+function parseMediaEdits(values) {
+  const edits = {};
+  const fx = parseMediaFx(values.fx);
+  if (fx && (fx.ops.length > 0 || fx.unknown.length > 0)) edits.fx = fx;
+  const cuts = parseMediaCuts(values.cuts);
+  if (cuts) edits.cuts = cuts;
+  const gain = finiteNumber(values.gain);
+  if (gain != null && gain !== 0) edits.gain = clamp(gain, GAIN_RANGE.min, GAIN_RANGE.max);
+  const fadeIn = values.fadeIn == null ? null : parseSeconds(values.fadeIn);
+  if (fadeIn != null && fadeIn > 0) edits.fadeIn = fadeIn;
+  const fadeOut = values.fadeOut == null ? null : parseSeconds(values.fadeOut);
+  if (fadeOut != null && fadeOut > 0) edits.fadeOut = fadeOut;
+  const crop = parseMediaCrop(values.crop);
+  if (crop) edits.crop = crop;
+  const group = values.group?.trim();
+  if (group && GROUP_RE.test(group)) edits.group = group;
+  return Object.keys(edits).length > 0 ? edits : void 0;
+}
+function serializeMediaEdits(edits) {
+  const fx = edits?.fx && (edits.fx.ops.length > 0 || edits.fx.unknown.length > 0);
+  return {
+    fx: fx && edits?.fx ? serializeMediaFx(edits.fx) : null,
+    cuts: edits?.cuts && edits.cuts.length > 0 ? serializeMediaCuts(edits.cuts) : null,
+    gain: edits?.gain ? formatMediaNumber(edits.gain, 2) : null,
+    fadeIn: edits?.fadeIn ? formatMediaNumber(edits.fadeIn) : null,
+    fadeOut: edits?.fadeOut ? formatMediaNumber(edits.fadeOut) : null,
+    crop: edits?.crop ? serializeMediaCrop(edits.crop) : null,
+    group: edits?.group ?? null
+  };
+}
+function mediaEditValuesFromParams(params) {
+  const out = {};
+  for (const { key } of MEDIA_EDIT_PARAMS) {
+    if (params[key] != null) out[key] = params[key];
+  }
+  return out;
+}
+function mediaEditValuesFromAttributes(kind, attributes) {
+  const out = {};
+  for (const { key } of MEDIA_EDIT_PARAMS) {
+    const value = attributes[mediaEditHtmlAttribute(kind, key)];
+    if (value != null) out[key] = value;
+  }
+  return out;
+}
+function fnv1a64Hex(text) {
+  let h1 = 2166136261;
+  let h2 = 16777619 ^ 1540483477;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    h1 = Math.imul(h1 ^ c, 16777619);
+    h2 = Math.imul(h2 ^ c, 1540483477);
+    h2 ^= h2 >>> 15;
+  }
+  return (h1 >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
+}
+function mediaRenderKey(src, fx) {
+  const canonical = fx.ops.map((op) => `${op.id}:${formatMediaNumber(op.value)}`).join(" ");
+  return fnv1a64Hex(`${src}
+${canonical}`).slice(0, 12);
+}
+
+export {
+  MEDIA_FX_ORDER,
+  MEDIA_FX_SPECS,
+  MEDIA_EDIT_PARAMS,
+  mediaEditHtmlAttribute,
+  formatMediaNumber,
+  parseMediaFx,
+  serializeMediaFx,
+  hasRenderableFx,
+  normalizeMediaCuts,
+  parseMediaCuts,
+  serializeMediaCuts,
+  parseMediaCrop,
+  normalizeMediaCrop,
+  serializeMediaCrop,
+  parseMediaEdits,
+  serializeMediaEdits,
+  mediaEditValuesFromParams,
+  mediaEditValuesFromAttributes,
+  mediaRenderKey
+};

package/dist/chunk-NEWNNLWN.js

@@ -0,0 +1,64 @@
+// src/mediaEdit/dsp/biquad.ts
+var BUTTERWORTH_Q = Math.SQRT1_2;
+function createBiquadState() {
+  return { x1: 0, x2: 0, y1: 0, y2: 0 };
+}
+function omega(sampleRate, freqHz) {
+  const w0 = 2 * Math.PI * freqHz / sampleRate;
+  return { cosW0: Math.cos(w0), sinW0: Math.sin(w0) };
+}
+function highpassCoeffs(sampleRate, freqHz, q = BUTTERWORTH_Q) {
+  const { cosW0, sinW0 } = omega(sampleRate, freqHz);
+  const alpha = sinW0 / (2 * q);
+  const a0 = 1 + alpha;
+  return {
+    b0: (1 + cosW0) / 2 / a0,
+    b1: -(1 + cosW0) / a0,
+    b2: (1 + cosW0) / 2 / a0,
+    a1: -2 * cosW0 / a0,
+    a2: (1 - alpha) / a0
+  };
+}
+function lowpassCoeffs(sampleRate, freqHz, q = BUTTERWORTH_Q) {
+  const { cosW0, sinW0 } = omega(sampleRate, freqHz);
+  const alpha = sinW0 / (2 * q);
+  const a0 = 1 + alpha;
+  return {
+    b0: (1 - cosW0) / 2 / a0,
+    b1: (1 - cosW0) / a0,
+    b2: (1 - cosW0) / 2 / a0,
+    a1: -2 * cosW0 / a0,
+    a2: (1 - alpha) / a0
+  };
+}
+function biquadRun(coeffs, state, input, output) {
+  let { x1, x2, y1, y2 } = state;
+  const { b0, b1, b2, a1, a2 } = coeffs;
+  for (let i = 0; i < input.length; i++) {
+    const x0 = input[i];
+    const y0 = b0 * x0 + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2;
+    output[i] = y0;
+    x2 = x1;
+    x1 = x0;
+    y2 = y1;
+    y1 = y0;
+  }
+  return { x1, x2, y1, y2 };
+}
+function createBiquadCascade(stages) {
+  const states = stages.map(() => createBiquadState());
+  return {
+    process(block) {
+      for (let s = 0; s < stages.length; s++) {
+        states[s] = biquadRun(stages[s], states[s], block, block);
+      }
+    }
+  };
+}
+
+export {
+  highpassCoeffs,
+  lowpassCoeffs,
+  biquadRun,
+  createBiquadCascade
+};

package/dist/{chunk-6ECMNUIP.js → chunk-OU5FYBOB.js}

@@ -216,11 +216,11 @@ async function revertToImageEditVersion(container, version, options = {}) {
   if (options.snapshotCurrent !== false) {
     const saveOptions = { stateFilename: options.stateFilename };
     if (options.doc !== void 0) saveOptions.doc = options.doc;
-    const result = await saveImageEditVersion(container, saveOptions);
-    if (!result.saved && result.reason !== "unchanged") {
+    const result2 = await saveImageEditVersion(container, saveOptions);
+    if (!result2.saved && result2.reason !== "unchanged") {
       return { reverted: false, snapshotted: null, reason: "snapshot-failed" };
     }
-    snapshotted = result.version;
+    snapshotted = result2.version;
   }
   await writeImageEditDoc(container, doc, options.stateFilename);
   return { reverted: true, snapshotted };
@@ -482,6 +482,170 @@ function escapeText(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 
+// src/imageEdit/animatedImage.ts
+var MIN_FRAME_DELAY_MS = 10;
+var CLAMPED_DELAY_MS = 100;
+function inspectAnimatedImage(input) {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  return inspectGif(bytes) ?? inspectPng(bytes) ?? inspectWebp(bytes);
+}
+var ANIMATABLE_EXTENSIONS = /* @__PURE__ */ new Set(["gif", "webp", "apng"]);
+var ANIMATABLE_MIME = /^image\/(?:gif|webp|apng)(?=$|[;,\s])/i;
+function mayBeAnimatedImage(srcOrMime) {
+  const value = srcOrMime.trim();
+  if (!value) return false;
+  if (/^data:/i.test(value)) return ANIMATABLE_MIME.test(value.slice(5));
+  if (ANIMATABLE_MIME.test(value)) return true;
+  const path = value.split(/[?#]/, 1)[0] ?? "";
+  const dot = path.lastIndexOf(".");
+  if (dot < 0 || dot < path.lastIndexOf("/")) return false;
+  return ANIMATABLE_EXTENSIONS.has(path.slice(dot + 1).toLowerCase());
+}
+function inspectGif(b) {
+  if (b.length < 13) return null;
+  if (b[0] !== 71 || b[1] !== 73 || b[2] !== 70 || b[3] !== 56) return null;
+  if (b[4] !== 55 && b[4] !== 57 || b[5] !== 97) return null;
+  let pos = 13 + colorTableSize(b[10]);
+  let frames = 0;
+  let duration = 0;
+  let pendingDelayMs = 0;
+  let playCount = 1;
+  while (pos < b.length) {
+    const marker = b[pos++];
+    if (marker === 59) break;
+    if (marker === 33) {
+      if (pos >= b.length) break;
+      const label = b[pos++];
+      if (label === 249 && pos + 3 < b.length && b[pos] >= 4) {
+        pendingDelayMs = (b[pos + 2] | b[pos + 3] << 8) * 10;
+      } else if (label === 255 && b[pos] === 11 && pos + 12 <= b.length) {
+        const id = ascii(b, pos + 1, 11);
+        const sub = pos + 12;
+        if ((id === "NETSCAPE2.0" || id === "ANIMEXTS1.0") && sub + 3 < b.length && b[sub] >= 3 && b[sub + 1] === 1) {
+          const loops = b[sub + 2] | b[sub + 3] << 8;
+          playCount = loops === 0 ? 0 : loops + 1;
+        }
+      }
+      pos = skipSubBlocks(b, pos);
+      if (pos < 0) break;
+      continue;
+    }
+    if (marker === 44) {
+      if (pos + 9 > b.length) break;
+      const packed = b[pos + 8];
+      pos += 9 + colorTableSize(packed);
+      pos += 1;
+      frames++;
+      duration += playedDelay(pendingDelayMs);
+      pendingDelayMs = 0;
+      pos = skipSubBlocks(b, pos);
+      if (pos < 0) break;
+      continue;
+    }
+    break;
+  }
+  return result("gif", frames, duration, playCount);
+}
+function colorTableSize(packed) {
+  return packed & 128 ? 3 * (1 << (packed & 7) + 1) : 0;
+}
+function skipSubBlocks(b, start) {
+  let pos = start;
+  while (pos < b.length) {
+    const size = b[pos];
+    pos += 1;
+    if (size === 0) return pos;
+    pos += size;
+  }
+  return -1;
+}
+var PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+function inspectPng(b) {
+  if (b.length < PNG_SIGNATURE.length) return null;
+  for (let i = 0; i < PNG_SIGNATURE.length; i++) {
+    if (b[i] !== PNG_SIGNATURE[i]) return null;
+  }
+  let pos = PNG_SIGNATURE.length;
+  let hasAnimationControl = false;
+  let frames = 1;
+  let playCount = 1;
+  let duration = 0;
+  while (pos + 8 <= b.length) {
+    const length = readU32BE(b, pos);
+    const type = ascii(b, pos + 4, 4);
+    const data = pos + 8;
+    if (type === "acTL" && length >= 8 && data + 8 <= b.length) {
+      hasAnimationControl = true;
+      frames = readU32BE(b, data);
+      playCount = readU32BE(b, data + 4);
+    } else if (type === "fcTL" && length >= 26 && data + 26 <= b.length) {
+      const num = readU16BE(b, data + 20);
+      const den = readU16BE(b, data + 22) || 100;
+      duration += playedDelay(num * 1e3 / den);
+    } else if (type === "IDAT" && !hasAnimationControl) {
+      break;
+    } else if (type === "IEND") {
+      break;
+    }
+    pos = data + length + 4;
+  }
+  return result("png", hasAnimationControl ? frames : 1, duration, playCount);
+}
+function inspectWebp(b) {
+  if (b.length < 12 || ascii(b, 0, 4) !== "RIFF" || ascii(b, 8, 4) !== "WEBP") return null;
+  let pos = 12;
+  let animationFlag = false;
+  let frames = 0;
+  let duration = 0;
+  let loopCount = null;
+  while (pos + 8 <= b.length) {
+    const type = ascii(b, pos, 4);
+    const size = readU32LE(b, pos + 4);
+    const data = pos + 8;
+    if (type === "VP8X" && size >= 10 && data < b.length) {
+      animationFlag = (b[data] & 2) !== 0;
+      if (!animationFlag) break;
+    } else if (type === "ANIM" && size >= 6 && data + 6 <= b.length) {
+      loopCount = b[data + 4] | b[data + 5] << 8;
+    } else if (type === "ANMF" && size >= 16 && data + 15 <= b.length) {
+      frames++;
+      duration += playedDelay(b[data + 12] | b[data + 13] << 8 | b[data + 14] << 16);
+    } else if ((type === "VP8 " || type === "VP8L") && !animationFlag) {
+      break;
+    }
+    pos = data + size + (size & 1);
+  }
+  const frameCount = animationFlag ? frames : 1;
+  return result("webp", frameCount, duration, loopCount ?? 0);
+}
+function result(format, frameCount, durationMs, playCount) {
+  const animated = frameCount > 1;
+  return {
+    format,
+    animated,
+    frameCount: Math.max(frameCount, 1),
+    durationMs: animated ? Math.round(durationMs) : 0,
+    playCount: animated ? playCount : 1
+  };
+}
+function playedDelay(ms) {
+  return ms <= MIN_FRAME_DELAY_MS ? CLAMPED_DELAY_MS : ms;
+}
+function ascii(b, start, length) {
+  let out = "";
+  for (let i = start; i < start + length && i < b.length; i++) out += String.fromCharCode(b[i]);
+  return out;
+}
+function readU16BE(b, pos) {
+  return b[pos] << 8 | b[pos + 1];
+}
+function readU32BE(b, pos) {
+  return (b[pos] << 24 | b[pos + 1] << 16 | b[pos + 2] << 8 | b[pos + 3]) >>> 0;
+}
+function readU32LE(b, pos) {
+  return (b[pos] | b[pos + 1] << 8 | b[pos + 2] << 16 | b[pos + 3] << 24) >>> 0;
+}
+
 export {
   IMAGE_EDIT_STATE_FILENAME,
   IMAGE_EDIT_ASSETS_PREFIX,
@@ -507,5 +671,7 @@ export {
   coalesceImageEditVersions,
   ImageEditVersionManager,
   exportImageEditDoc,
-  buildSvgString
+  buildSvgString,
+  inspectAnimatedImage,
+  mayBeAnimatedImage
 };

package/dist/{chunk-3YNFMFNK.js → chunk-RMCUZDW5.js}

@@ -1,11 +1,3 @@
-import {
-  anchorPoint,
-  base64ToUtf8,
-  connectorPath,
-  lineStyleDasharray,
-  shapePath,
-  snapEndpoints
-} from "./chunk-PUS54YU6.js";
 import {
   detectAsciiDiagram,
   detectAsciiTimeline,
@@ -22,6 +14,14 @@ import {
   pickAutoTemplate,
   profileBlockContents
 } from "./chunk-C3NAY5YP.js";
+import {
+  anchorPoint,
+  base64ToUtf8,
+  connectorPath,
+  lineStyleDasharray,
+  shapePath,
+  snapEndpoints
+} from "./chunk-PUS54YU6.js";
 import {
   DEFAULT_THEME,
   FRONTMATTER_CUSTOM_TEMPLATES_KEY,
@@ -42,6 +42,11 @@ import {
   validateTheme,
   withAlpha
 } from "./chunk-Y4D6TDZT.js";
+import {
+  mediaEditValuesFromAttributes,
+  mediaEditValuesFromParams,
+  parseMediaEdits
+} from "./chunk-L7QZORLB.js";
 import {
   KNOWN_BLOCK_META_KEYS,
   TABLE_FED_TEMPLATES,
@@ -11133,6 +11138,8 @@ function toMediaClip(parsed, id) {
   if (clipEnd != null) clip.clipEnd = clipEnd;
   if (clip.lockToBlock === true) delete clip.clipEnd;
   if (params.spillover === "true" || params.spillover === "") clip.spillover = true;
+  const edits = parseMediaEdits(mediaEditValuesFromParams(params));
+  if (edits) clip.edits = edits;
   return clip;
 }
 function firstVideoElement(children) {
@@ -11195,6 +11202,8 @@ function htmlVideoClip(node, id) {
   const clipEnd = time(element.attributes["data-squisq-video-clip-end"]);
   if (clipStart != null) clip.clipStart = clipStart;
   if (!locked && clipEnd != null) clip.clipEnd = clipEnd;
+  const edits = parseMediaEdits(mediaEditValuesFromAttributes("video", element.attributes));
+  if (edits) clip.edits = edits;
   return clip;
 }
 function extractMediaFromContents(contents, makeId, blockId) {

package/dist/{chunk-XJXBI3N5.js → chunk-XZVBR5BP.js}

@@ -2,7 +2,7 @@ import {
   assertMarkdownDocumentWithinLimits,
   parseMarkdown,
   toMdast
-} from "./chunk-CW24CH7I.js";
+} from "./chunk-HUXK7EOT.js";
 import {
   formatFrontmatterYaml,
   getChildren,