@bendyline/squisq 2.11.6 → 2.11.8

package/dist/{chunk-J2IPSQKP.js → chunk-KFZOCWPK.js}

@@ -5,14 +5,14 @@ import {
 } from "./chunk-SVN7T6BK.js";
 import {
   markdownToDoc
-} from "./chunk-WAGJK36Q.js";
+} from "./chunk-RMCUZDW5.js";
 import {
   cloneAndFreezeData,
   isTemplateBlock
 } from "./chunk-Y4D6TDZT.js";
 import {
   parseMarkdown
-} from "./chunk-CW24CH7I.js";
+} from "./chunk-HUXK7EOT.js";
 import {
   extractPlainText,
   getChildren
@@ -512,7 +512,7 @@ function buildBlockSequence(analyzed, selected, config, images, rng) {
       elementsSinceImage++;
       if (config.interleaveImages && imageIndex < images.length && elementsSinceImage >= imageInterval) {
         const img = images[imageIndex];
-        const imageBlock = {
+        const imageBlock2 = {
           template: "imageWithCaption",
           id: `transform-img-${blockIdCounter++}`,
           duration: 4,
@@ -522,7 +522,7 @@ function buildBlockSequence(analyzed, selected, config, images, rng) {
           ambientMotion: rng.pick(AMBIENT_MOTIONS) ?? "zoomIn",
           sourceBlockId: ab.block.id
         };
-        blocks.push(imageBlock);
+        blocks.push(imageBlock2);
         imageIndex++;
         insertedCount++;
         elementsSinceImage = 0;
@@ -846,12 +846,37 @@ function firstTitle(doc) {
 }
 
 // src/transform/narratedSegment.ts
+var DEFAULT_SLIDES_PER_MINUTE = 5;
+var DEFAULT_MAX_SLIDE_DURATION = 15;
+var DEFAULT_MIN_SLIDE_DURATION = 6;
+var DEFAULT_MAX_VIDEOS = 2;
+var AMBIENT_MOTIONS2 = [
+  "zoomIn",
+  "zoomOut",
+  "panLeft",
+  "panRight"
+];
 function transformNarratedSegment(input, options = {}) {
   const seed = options.seed ?? hashString(`${input.articleId}-${input.segmentId}`);
   const heading = input.title.replace(/[\r\n]+/g, " ").trim() || input.segmentId;
-  const source = markdownToDoc(parseMarkdown(`# ${heading}
+  const pacing = {
+    slidesPerMinute: options.slidesPerMinute ?? DEFAULT_SLIDES_PER_MINUTE,
+    maxSlideDuration: options.maxSlideDuration ?? DEFAULT_MAX_SLIDE_DURATION,
+    minSlideDuration: options.minSlideDuration ?? DEFAULT_MIN_SLIDE_DURATION,
+    maxVideos: options.maxVideos ?? DEFAULT_MAX_VIDEOS
+  };
+  const images = uniqueImages(input.images ?? []);
+  const videos = input.videos ?? [];
+  const contentTarget = contentSlotCount(
+    input.duration,
+    pacing,
+    images.length + Math.min(videos.length, pacing.maxVideos),
+    !!input.includeTitleBlock
+  );
+  const markdown = chunkNarration(input.text, contentTarget).map((chunk) => `# ${heading}
 
-${input.text}`), {
+${chunk}`).join("\n\n");
+  const source = markdownToDoc(parseMarkdown(markdown), {
     articleId: `${input.articleId}:${input.segmentId}`,
     defaultDuration: Math.max(3, input.duration)
   });
@@ -876,23 +901,41 @@ ${input.text}`), {
     themeId: options.themeId,
     registry: options.registry,
     overrides: {
+      // The style's transformRatio is a share of source blocks, and a
+      // narrated segment is one block — so it would always cap promotion at
+      // a single extraction. Size the cap by content slots instead; the
+      // slides-per-minute budget and blocksPerSection still apply.
+      transformRatio: (contentTarget + 0.5) / Math.max(1, source.blocks.length),
       ...options.minConfidence === void 0 ? {} : { minConfidence: options.minConfidence },
       ...options.slidesPerMinute === void 0 ? {} : { budget: { slidesPerMinute: options.slidesPerMinute } }
     }
   });
-  let blocks = transformed.doc.blocks;
-  if (input.includeTitleBlock) {
-    const title = {
-      template: "title",
-      id: `${input.segmentId}-title`,
-      duration: 4,
-      audioSegment: 0,
-      title: input.title
-    };
-    blocks = [title, ...blocks];
-  }
-  blocks = interleaveVideoBlocks(blocks, input.videos ?? [], input.segmentId);
-  const timedBlocks = allocateTiming(blocks, input.duration).map((block) => ({
+  const title = input.includeTitleBlock ? {
+    template: "title",
+    id: `${input.segmentId}-title`,
+    duration: 4,
+    audioSegment: 0,
+    title: input.title
+  } : void 0;
+  const transformedBlocks = transformed.doc.blocks;
+  const sourceIds = new Set(source.blocks.map((block) => block.id));
+  const promoted = transformedBlocks.filter((block) => !sourceIds.has(block.id));
+  const kept = promoted.length > 0 ? promoted : transformedBlocks.slice(0, 1);
+  const content = kept.map((block) => ({
+    ...block,
+    id: namespacedId(block.id, input.segmentId)
+  }));
+  const paced = paceSegment({
+    segmentId: input.segmentId,
+    duration: input.duration,
+    title,
+    content,
+    videos,
+    images,
+    pacing,
+    rng: new SeededRandom(seed ^ 1540483477)
+  });
+  const timedBlocks = allocateTiming(paced, input.duration).map((block) => ({
     ...block,
     audioSegment: 0
   }));
@@ -908,33 +951,202 @@ ${input.text}`), {
     }
   };
 }
-function interleaveVideoBlocks(blocks, videos, segmentId) {
-  if (videos.length === 0) return blocks;
-  const result = [...blocks];
+function paceTarget(duration, pacing) {
+  return Math.max(
+    1,
+    Math.round(duration / 60 * pacing.slidesPerMinute),
+    Math.ceil(duration / pacing.maxSlideDuration)
+  );
+}
+function contentSlotCount(duration, pacing, visualCount, hasTitle) {
+  const target = paceTarget(duration, pacing);
+  const share = visualCount >= 3 ? 0.2 : 0.4;
+  return Math.max(1, Math.round(target * share), target - (hasTitle ? 1 : 0) - visualCount);
+}
+function paceSegment(args) {
+  const { segmentId, duration, title, content, pacing, rng } = args;
+  const fixedCount = (title ? 1 : 0) + content.length;
+  const maxCount = Math.max(1, Math.floor(duration / pacing.minSlideDuration));
+  const target = paceTarget(duration, pacing);
+  const videoCount = args.videos.length === 0 ? 0 : Math.min(
+    args.videos.length,
+    pacing.maxVideos,
+    Math.max(1, Math.floor(target * 0.3)),
+    Math.max(0, maxCount - fixedCount)
+  );
+  const videos = pickVideos(args.videos, videoCount);
+  const pool = standaloneImagePool(args.images, content);
+  let count = Math.max(target, fixedCount + videos.length);
+  let imageCount = 0;
+  for (; ; ) {
+    imageCount = Math.min(pool.length, Math.max(0, count - fixedCount - videos.length));
+    const longest = longestFittedSlide(duration, count, title, content, videos, imageCount, pacing);
+    if (longest <= pacing.maxSlideDuration || imageCount >= pool.length || count >= maxCount) {
+      break;
+    }
+    count++;
+  }
+  const slot = duration / Math.max(1, count);
+  const items = [];
+  if (title) {
+    items.push({
+      block: { ...title, duration: Math.min(slot, pacing.minSlideDuration) },
+      at: -1,
+      rank: 0
+    });
+  }
+  content.forEach((block, index) => {
+    const anchor = typeof block.sourceStartTime === "number" ? block.sourceStartTime : (index + 0.5) / content.length * duration;
+    items.push({ block: { ...unanchored(block), duration: slot }, at: anchor, rank: 1 });
+  });
   videos.forEach((video, index) => {
-    const block = {
-      template: "videoWithCaption",
-      id: `${segmentId}-video-${index}`,
-      duration: Math.max(3, video.clipEnd - video.clipStart),
-      audioSegment: 0,
-      videoSrc: video.src,
-      posterSrc: video.posterSrc,
-      videoAlt: video.alt ?? "",
-      clipStart: video.clipStart,
-      clipEnd: video.clipEnd,
-      sourceDuration: video.sourceDuration,
-      caption: video.alt,
-      captionPosition: "bottom",
-      videoCredit: video.credit,
-      videoLicense: video.license
-    };
-    const insertion = Math.min(
-      result.length,
-      Math.round((index + 1) * result.length / (videos.length + 1))
-    );
-    result.splice(insertion + index, 0, block);
+    items.push({
+      block: videoBlock(video, index, segmentId, videoNominal(video, slot, pacing)),
+      at: videoPosition(index, videos.length) * duration,
+      rank: 2
+    });
   });
-  return result;
+  for (let index = 0; index < imageCount; index++) {
+    items.push({
+      block: imageBlock(pool[index], index, segmentId, slot, rng),
+      at: (index + 0.5) / imageCount * duration,
+      rank: 3
+    });
+  }
+  return items.map((item, order) => ({ ...item, order })).sort((a, b) => a.at - b.at || a.rank - b.rank || a.order - b.order).map((item) => item.block);
+}
+function longestFittedSlide(duration, count, title, content, videos, imageCount, pacing) {
+  const slot = duration / Math.max(1, count);
+  const nominal = [
+    ...title ? [Math.min(slot, pacing.minSlideDuration)] : [],
+    ...content.map(() => slot),
+    ...videos.map((video) => videoNominal(video, slot, pacing)),
+    ...Array.from({ length: imageCount }, () => slot)
+  ];
+  const total = nominal.reduce((sum, d) => sum + d, 0);
+  return total > 0 ? Math.max(...nominal) * (duration / total) : duration;
+}
+function videoNominal(video, slot, pacing) {
+  return Math.min(slot, Math.max(pacing.minSlideDuration, video.clipEnd - video.clipStart));
+}
+function videoPosition(index, count) {
+  if (count === 1) return 0.4;
+  if (count === 2) return index === 0 ? 0.3 : 0.7;
+  return (index + 1) / (count + 1);
+}
+function pickVideos(videos, count) {
+  const picked = [];
+  const seenSources = /* @__PURE__ */ new Set();
+  for (const video of videos) {
+    if (picked.length >= count) break;
+    if (seenSources.has(video.src)) continue;
+    seenSources.add(video.src);
+    picked.push(video);
+  }
+  for (const video of videos) {
+    if (picked.length >= count) break;
+    if (!picked.includes(video)) picked.push(video);
+  }
+  return picked;
+}
+function standaloneImagePool(images, content) {
+  const shown = /* @__PURE__ */ new Set();
+  const accents = /* @__PURE__ */ new Set();
+  for (const block of content) {
+    const media = block;
+    if (block.template === "imageWithCaption" && media.imageSrc) shown.add(media.imageSrc);
+    if (media.accentImage?.src) accents.add(media.accentImage.src);
+    if (media.backgroundImage?.src) accents.add(media.backgroundImage.src);
+  }
+  const available = images.filter((image) => !shown.has(image.src));
+  return [
+    ...available.filter((image) => !accents.has(image.src)),
+    ...available.filter((image) => accents.has(image.src))
+  ];
+}
+function chunkNarration(text, count) {
+  if (count <= 1) return [text];
+  const sentences = [];
+  const boundary = /[.!?]["'’”)\]]*\s+/g;
+  let start = 0;
+  let match;
+  while ((match = boundary.exec(text)) !== null) {
+    const end = match.index + match[0].length;
+    const sentence = text.slice(start, end).trim();
+    if (sentence) sentences.push(sentence);
+    start = end;
+  }
+  const tail = text.slice(start).trim();
+  if (tail) sentences.push(tail);
+  if (sentences.length < 2) return [text];
+  const chunkCount = Math.min(count, sentences.length);
+  const words = sentences.map((sentence) => sentence.split(/\s+/).length);
+  const totalWords = words.reduce((sum, n) => sum + n, 0);
+  const chunks = [];
+  let current = [];
+  let seenWords = 0;
+  sentences.forEach((sentence, index) => {
+    current.push(sentence);
+    seenWords += words[index];
+    const due = totalWords * (chunks.length + 1) / chunkCount;
+    if (seenWords >= due && chunks.length < chunkCount - 1) {
+      chunks.push(current);
+      current = [];
+    }
+  });
+  if (current.length > 0) chunks.push(current);
+  return chunks.map((chunk) => chunk.join(" "));
+}
+function uniqueImages(images) {
+  const seen = /* @__PURE__ */ new Set();
+  return images.filter((image) => {
+    if (!image.src || seen.has(image.src)) return false;
+    seen.add(image.src);
+    return true;
+  });
+}
+function namespacedId(id, segmentId) {
+  return id.startsWith(`${segmentId}-`) ? id : `${segmentId}-${id}`;
+}
+function unanchored(block) {
+  const { sourceStartTime: _start, sourceDuration: _duration, ...rest } = block;
+  return rest;
+}
+function imageBlock(image, index, segmentId, duration, rng) {
+  const caption = image.alt && !/\.(jpe?g|png|gif|svg|webp)/i.test(image.alt) ? image.alt : "";
+  return {
+    template: "imageWithCaption",
+    id: `${segmentId}-image-${index}`,
+    duration,
+    audioSegment: 0,
+    imageSrc: image.src,
+    imageAlt: image.alt ?? "",
+    caption,
+    captionPosition: "bottom",
+    ambientMotion: rng.pick(AMBIENT_MOTIONS2) ?? "zoomIn",
+    imageCredit: image.credit,
+    imageLicense: image.license
+  };
+}
+function videoBlock(video, index, segmentId, duration) {
+  return {
+    template: "videoWithCaption",
+    id: `${segmentId}-video-${index}`,
+    duration,
+    audioSegment: 0,
+    videoSrc: video.src,
+    posterSrc: video.posterSrc,
+    videoAlt: video.alt ?? "",
+    clipStart: video.clipStart,
+    clipEnd: video.clipEnd,
+    // The clip's source file length (VideoWithCaptionInput's meaning), not a
+    // narration timing hint.
+    sourceDuration: video.sourceDuration,
+    caption: video.alt,
+    captionPosition: "bottom",
+    videoCredit: video.credit,
+    videoLicense: video.license
+  };
 }
 
 export {

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
+};