@pixerate/editor 0.123.0 → 0.124.0

package/dist/effects/index.js

@@ -0,0 +1,588 @@
+import {
+  EFFECT_KINDS,
+  EFFECT_USES,
+  createEffectToolProvider
+} from "../chunk-VFAKN46Z.js";
+import {
+  EFFECT_ERROR_CODES,
+  EffectControlError,
+  EffectDisposedError,
+  EffectError,
+  EffectUnsupportedError,
+  EffectsSlot,
+  NoEffectsProviderError,
+  UnknownEffectError,
+  applyEffectMask,
+  createEffectPixels,
+  effectValueErrors,
+  encodeEffectFloat,
+  isEffectError,
+  isEffectPixels,
+  linearToSrgb,
+  resolveEffectValues,
+  searchEffectSummaries,
+  srgbToLinear
+} from "../chunk-TGKT5QAB.js";
+import "../chunk-4FX5ACVG.js";
+
+// src/effects/conformance.ts
+var codeOf = (e) => isEffectError(e) ? e.code : e instanceof Error ? `untyped ${e.name}: ${e.message}` : String(e);
+async function rejectsWith(code, run) {
+  try {
+    await run();
+    return `did not fail (expected ${code})`;
+  } catch (e) {
+    const got = codeOf(e);
+    return got === code ? null : `failed with ${got} (expected ${code})`;
+  }
+}
+function checkSummary(e, issues) {
+  const at = (message) => issues.push({ effectId: e.id, message });
+  if (!e.id || typeof e.id !== "string") at("summary has no id");
+  if (!e.name) at("summary has no name");
+  if (!EFFECT_KINDS.includes(e.kind)) at(`kind "${e.kind}" is not one of ${EFFECT_KINDS.join(", ")}`);
+  if (!e.category) at("summary has no category");
+  if (!Array.isArray(e.uses) || !e.uses.length) at("summary has no uses");
+  for (const u of e.uses ?? []) if (!EFFECT_USES.includes(u)) at(`use "${u}" is not one of ${EFFECT_USES.join(", ")}`);
+  if (typeof e.transparent !== "boolean") at("transparent is not a boolean");
+  if (typeof e.loop !== "boolean") at("loop is not a boolean");
+  if (e.duration !== void 0 && !(e.duration > 0)) at("duration must be a positive number of ms when present");
+}
+function checkDescription(id, d, issues) {
+  const at = (message) => issues.push({ effectId: id, message });
+  if (d.id !== id) at(`describe("${id}") returned id "${d.id}"`);
+  const c = d.controls;
+  if (!c || c.type !== "object") at("controls is not an object schema");
+  if (c?.additionalProperties !== false) at("controls must set additionalProperties: false");
+  for (const [name, schema] of Object.entries(c?.properties ?? {})) {
+    if (!schema.description || !String(schema.description).trim()) at(`control "${name}" has no description`);
+    if (!(name in (d.defaults ?? {}))) at(`control "${name}" has no default`);
+  }
+  for (const name of Object.keys(d.defaults ?? {})) if (!(name in (c?.properties ?? {}))) at(`default "${name}" is not a control`);
+  for (const e of effectValueErrors(d, d.defaults)) at(`default ${e.path}: ${e.message}`);
+  for (const p of d.presets ?? []) for (const e of effectValueErrors(d, p.values)) at(`preset "${p.name}" ${e.path}: ${e.message}`);
+  for (const input2 of d.inputs ?? []) {
+    if (!input2.name || !input2.description) at("every input needs a name and a description");
+    if (input2.kind !== "image" && input2.kind !== "audio") at(`input "${input2.name}" has kind "${input2.kind}"`);
+  }
+  if (d.uses.includes("filter") && !d.inputs.some((i) => i.name === "source")) at('a filter must read an input named "source"');
+  if (d.uses.includes("transition") && !(d.inputs.some((i) => i.name === "from") && d.inputs.some((i) => i.name === "to"))) {
+    at('a transition must read inputs named "from" and "to"');
+  }
+}
+function grey(size) {
+  const p = createEffectPixels(size, size);
+  p.data.fill(128);
+  return p;
+}
+async function checkRender(provider, d, size, issues) {
+  const at = (message) => issues.push({ effectId: d.id, message });
+  const inputs = Object.fromEntries(d.inputs.filter((i) => i.kind === "image").map((i) => [i.name, grey(size)]));
+  let renderer;
+  try {
+    renderer = await provider.createRenderer(d.id, { width: size, height: size });
+  } catch (e) {
+    if (!(d.kind === "vector" && codeOf(e) === "unsupported")) at(`createRenderer failed: ${codeOf(e)}`);
+    return;
+  }
+  try {
+    const out = await renderer.render({ time: 0, inputs });
+    if (!isEffectPixels(out)) at("render did not return EffectPixels");
+    else if (out.width !== size || out.height !== size || out.data.length !== size * size * 4) at(`render returned ${out.width}\xD7${out.height}, not ${size}\xD7${size}`);
+  } catch (e) {
+    at(`render failed: ${codeOf(e)}`);
+  }
+  const bad = await rejectsWith("invalid_values", () => renderer.render({ time: 0, inputs, values: { __not_a_control__: 1 } }));
+  if (bad) at(`render with an unknown control ${bad}`);
+  renderer.dispose();
+  const after = await rejectsWith("disposed", () => renderer.render({ time: 0, inputs }));
+  if (after) at(`render after dispose ${after}`);
+}
+async function checkEffectProvider(provider, options = {}) {
+  const issues = [];
+  const top = (message) => issues.push({ message });
+  if (!provider.id) top("provider has no id");
+  const caps = provider.capabilities;
+  for (const k of ["supportsWorker", "supportsFloat", "supportsMask", "supportsHostImages", "supportsVector"]) {
+    if (typeof caps?.[k] !== "boolean") top(`capabilities.${k} is not a boolean`);
+  }
+  if (caps?.supportsVector && typeof provider.applyVectorEffect !== "function") top("supportsVector is set but applyVectorEffect is missing");
+  const list = await provider.list();
+  const ids = /* @__PURE__ */ new Set();
+  for (const e of list) {
+    if (ids.has(e.id)) top(`duplicate id "${e.id}"`);
+    ids.add(e.id);
+    checkSummary(e, issues);
+  }
+  const all = await provider.search("");
+  if (all.length !== list.length) top(`search("") returned ${all.length} effects, list() ${list.length}`);
+  const firstUse = list[0]?.uses[0];
+  if (firstUse) {
+    const filtered = await provider.search("", { use: firstUse });
+    if (filtered.some((e) => !e.uses.includes(firstUse))) top(`search("", { use: "${firstUse}" }) returned effects without that use`);
+  }
+  const unknown = await rejectsWith("unknown_effect", () => provider.describe("__no_such_effect__"));
+  if (unknown) top(`describe of an unknown id ${unknown}`);
+  const unknownRenderer = await rejectsWith("unknown_effect", () => provider.createRenderer("__no_such_effect__", { width: 4, height: 4 }));
+  if (unknownRenderer) top(`createRenderer of an unknown id ${unknownRenderer}`);
+  const size = options.size ?? 8;
+  for (const id of options.ids ?? [...ids]) {
+    let d;
+    try {
+      d = await provider.describe(id);
+    } catch (e) {
+      issues.push({ effectId: id, message: `describe failed: ${codeOf(e)}` });
+      continue;
+    }
+    checkDescription(id, d, issues);
+    if (options.render !== false && d.kind !== "motion") await checkRender(provider, d, size, issues);
+    if ((d.kind === "vector" || d.kind === "motion") && caps.supportsVector && provider.applyVectorEffect) {
+      try {
+        const m = await provider.applyVectorEffect(id, '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10"><rect id="r" width="10" height="10"/></svg>');
+        if (typeof m.svg !== "string" || !m.svg.includes("<svg")) issues.push({ effectId: id, message: "applyVectorEffect returned no SVG" });
+        if (!(m.duration >= 0)) issues.push({ effectId: id, message: "applyVectorEffect returned no duration" });
+      } catch (e) {
+        if (codeOf(e) !== "unsupported") issues.push({ effectId: id, message: `applyVectorEffect failed: ${codeOf(e)}` });
+      }
+      const bad = await rejectsWith("invalid_values", () => provider.applyVectorEffect(id, '<svg xmlns="http://www.w3.org/2000/svg"/>', { __not_a_control__: 1 }));
+      if (bad) issues.push({ effectId: id, message: `applyVectorEffect with an unknown control ${bad}` });
+    }
+  }
+  return issues;
+}
+
+// src/effects/fake.ts
+var HEX = "^#[0-9a-fA-F]{6}$";
+var colour = (description) => ({ type: "string", pattern: HEX, description });
+var amount = (description) => ({ type: "number", minimum: 0, maximum: 1, description });
+var DESCRIPTIONS = [
+  {
+    id: "fake.invert",
+    name: "Invert",
+    kind: "shader",
+    category: "image",
+    uses: ["filter"],
+    description: "Inverts the colours of the source.",
+    tags: ["negative", "colour"],
+    transparent: false,
+    loop: false,
+    controls: {
+      type: "object",
+      additionalProperties: false,
+      properties: { amount: amount("How far to invert, 0 (unchanged) to 1 (fully inverted). Default 1.") }
+    },
+    defaults: { amount: 1 },
+    presets: [{ name: "Half", values: { amount: 0.5 } }],
+    inputs: [{ name: "source", kind: "image", description: "The picture to invert.", required: true }]
+  },
+  {
+    id: "fake.tint",
+    name: "Tint",
+    kind: "shader",
+    category: "image",
+    uses: ["filter"],
+    description: "Mixes the source towards a colour.",
+    tags: ["colour", "wash"],
+    transparent: false,
+    loop: false,
+    controls: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        color: colour("Tint colour as #rrggbb. Default #ff8800."),
+        amount: amount("How far to mix towards the colour, 0\u20131. Default 0.5.")
+      }
+    },
+    defaults: { color: "#ff8800", amount: 0.5 },
+    presets: [
+      { name: "Sepia", values: { color: "#704214", amount: 0.4 } },
+      { name: "Cool", values: { color: "#2060ff", amount: 0.25 } }
+    ],
+    inputs: [{ name: "source", kind: "image", description: "The picture to tint.", required: true }]
+  },
+  {
+    id: "fake.gradient",
+    name: "Gradient",
+    kind: "shader",
+    category: "gradient",
+    uses: ["generator"],
+    description: "A linear gradient between two colours that can turn over time.",
+    tags: ["background"],
+    transparent: false,
+    loop: true,
+    duration: 4e3,
+    controls: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        from: colour("Start colour as #rrggbb. Default #1e3a8a."),
+        to: colour("End colour as #rrggbb. Default #f472b6."),
+        angle: { type: "number", minimum: 0, maximum: 360, description: "Direction in degrees, 0 = left to right, 90 = top to bottom. Default 90." },
+        spin: { type: "number", minimum: -360, maximum: 360, description: "Turn per loop (4 s) in degrees. Default 0." }
+      }
+    },
+    defaults: { from: "#1e3a8a", to: "#f472b6", angle: 90, spin: 0 },
+    presets: [{ name: "Sunset", values: { from: "#f97316", to: "#7c3aed" } }],
+    inputs: []
+  },
+  {
+    id: "fake.bar",
+    name: "Lower-third bar",
+    kind: "shader",
+    category: "broadcast",
+    uses: ["title", "overlay"],
+    description: "A coloured bar that slides in from the left in the lower third. Transparent elsewhere.",
+    tags: ["lower third", "title"],
+    transparent: true,
+    loop: false,
+    duration: 2e3,
+    controls: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        color: colour("Bar colour as #rrggbb. Default #0ea5e9."),
+        height: { type: "number", minimum: 0.02, maximum: 0.5, description: "Bar height as a fraction of the picture height. Default 0.12." },
+        slide: { type: "number", minimum: 0, maximum: 5e3, description: "Slide-in time (ms). Default 500." }
+      }
+    },
+    defaults: { color: "#0ea5e9", height: 0.12, slide: 500 },
+    presets: [],
+    inputs: []
+  },
+  {
+    id: "fake.crossfade",
+    name: "Crossfade",
+    kind: "shader",
+    category: "transition",
+    uses: ["transition"],
+    description: "Dissolves from one picture to the next.",
+    tags: ["dissolve", "mix"],
+    transparent: false,
+    loop: false,
+    duration: 1e3,
+    controls: {
+      type: "object",
+      additionalProperties: false,
+      properties: { curve: { type: "string", enum: ["linear", "smooth"], description: "Mix curve: linear, or smooth (ease in and out). Default smooth." } }
+    },
+    defaults: { curve: "smooth" },
+    presets: [],
+    inputs: [
+      { name: "from", kind: "image", description: "The outgoing picture.", required: true },
+      { name: "to", kind: "image", description: "The incoming picture.", required: true }
+    ]
+  },
+  {
+    id: "fake.fade-in",
+    name: "Fade in",
+    kind: "motion",
+    category: "morph",
+    uses: ["motion"],
+    description: "Fades vector elements in from transparent, one after another.",
+    tags: ["appear", "entrance"],
+    transparent: true,
+    loop: false,
+    duration: 600,
+    controls: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        ms: { type: "number", minimum: 0, maximum: 1e4, description: "Fade time per element (ms). Default 600." },
+        stagger: { type: "number", minimum: 0, maximum: 5e3, description: "Delay between elements (ms). Default 0." }
+      }
+    },
+    defaults: { ms: 600, stagger: 0 },
+    presets: [{ name: "Cascade", values: { ms: 400, stagger: 120 } }],
+    inputs: []
+  }
+];
+var summaryOf = ({ controls: _c, defaults: _d, presets: _p, inputs: _i, ...summary }) => summary;
+var hexToRgb = (hex) => [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16));
+var smooth = (t) => t * t * (3 - 2 * t);
+var clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function input(request, name, id, width, height) {
+  const src = request.inputs?.[name];
+  if (!src) throw new EffectUnsupportedError(`Effect "${id}" needs an input named "${name}".`, id);
+  if (!isEffectPixels(src)) throw new EffectUnsupportedError(`The fake provider only takes EffectPixels inputs ("${name}").`, id);
+  if (src.width !== width || src.height !== height) {
+    throw new EffectUnsupportedError(`Input "${name}" is ${src.width}\xD7${src.height}; the renderer is ${width}\xD7${height}.`, id);
+  }
+  return src;
+}
+function renderPixels(d, v, request, width, height) {
+  const out = createEffectPixels(width, height);
+  const o = out.data;
+  switch (d.id) {
+    case "fake.invert": {
+      const s = input(request, "source", d.id, width, height).data;
+      const k = v.amount;
+      for (let i = 0; i < o.length; i += 4) {
+        for (let c = 0; c < 3; c++) o[i + c] = s[i + c] + (255 - 2 * s[i + c]) * k;
+        o[i + 3] = s[i + 3];
+      }
+      break;
+    }
+    case "fake.tint": {
+      const s = input(request, "source", d.id, width, height).data;
+      const rgb = hexToRgb(v.color);
+      const k = v.amount;
+      for (let i = 0; i < o.length; i += 4) {
+        for (let c = 0; c < 3; c++) o[i + c] = s[i + c] + (rgb[c] - s[i + c]) * k;
+        o[i + 3] = s[i + 3];
+      }
+      break;
+    }
+    case "fake.gradient": {
+      const a = hexToRgb(v.from);
+      const b = hexToRgb(v.to);
+      const turn = request.time % (d.duration ?? 4e3) / (d.duration ?? 4e3) * v.spin;
+      const rad = (v.angle + turn) * Math.PI / 180;
+      const dx = Math.cos(rad);
+      const dy = Math.sin(rad);
+      const half = (Math.abs(dx) * width + Math.abs(dy) * height) / 2 || 1;
+      for (let y = 0, i = 0; y < height; y++) {
+        for (let x = 0; x < width; x++, i += 4) {
+          const t = clamp01(((x + 0.5 - width / 2) * dx + (y + 0.5 - height / 2) * dy) / (2 * half) + 0.5);
+          for (let c = 0; c < 3; c++) o[i + c] = a[c] + (b[c] - a[c]) * t;
+          o[i + 3] = 255;
+        }
+      }
+      break;
+    }
+    case "fake.bar": {
+      const rgb = hexToRgb(v.color);
+      const slide = v.slide;
+      const shown = slide > 0 ? smooth(clamp01(request.time / slide)) : 1;
+      const top = Math.round(height * (0.75 - v.height / 2));
+      const bottom = Math.round(height * (0.75 + v.height / 2));
+      const right = Math.round(width * 0.7 * shown);
+      for (let y = Math.max(0, top); y < Math.min(height, bottom); y++) {
+        for (let x = 0; x < right; x++) {
+          const i = (y * width + x) * 4;
+          o[i] = rgb[0];
+          o[i + 1] = rgb[1];
+          o[i + 2] = rgb[2];
+          o[i + 3] = 255;
+        }
+      }
+      break;
+    }
+    case "fake.crossfade": {
+      const from = input(request, "from", d.id, width, height).data;
+      const to = input(request, "to", d.id, width, height).data;
+      const p = clamp01(request.progress ?? request.time / (d.duration ?? 1e3));
+      const k = v.curve === "smooth" ? smooth(p) : p;
+      for (let i = 0; i < o.length; i++) o[i] = from[i] + (to[i] - from[i]) * k;
+      break;
+    }
+    default:
+      throw new EffectUnsupportedError(`"${d.id}" is a ${d.kind} effect; use applyVectorEffect.`, d.id);
+  }
+  return out;
+}
+function toFloat(p) {
+  const f = new Float32Array(p.data.length);
+  for (let i = 0; i < f.length; i += 4) {
+    f[i] = srgbToLinear(p.data[i] / 255);
+    f[i + 1] = srgbToLinear(p.data[i + 1] / 255);
+    f[i + 2] = srgbToLinear(p.data[i + 2] / 255);
+    f[i + 3] = p.data[i + 3] / 255;
+  }
+  return encodeEffectFloat({ ...p, float: f });
+}
+function maskResult(out, mask, source, id) {
+  if (!isEffectPixels(mask) || mask.width !== out.width || mask.height !== out.height) {
+    throw new EffectUnsupportedError("The mask must be EffectPixels the size of the renderer.", id);
+  }
+  const o = out.data;
+  for (let i = 0; i < o.length; i += 4) {
+    const k = mask.data[i + 3] / 255;
+    if (source) for (let c = 0; c < 4; c++) o[i + c] = source.data[i + c] + (o[i + c] - source.data[i + c]) * k;
+    else o[i + 3] *= k;
+  }
+}
+function createFakeEffectProvider(options = {}) {
+  const capabilities = {
+    supportsWorker: false,
+    supportsFloat: true,
+    supportsMask: true,
+    supportsHostImages: false,
+    supportsVector: true,
+    maxSize: 8192,
+    ...options.capabilities
+  };
+  const byId = new Map(DESCRIPTIONS.map((d) => [d.id, d]));
+  const get = (id) => {
+    const d = byId.get(id);
+    if (!d) throw new UnknownEffectError(id, "the fake provider");
+    return d;
+  };
+  const summaries = DESCRIPTIONS.map(summaryOf);
+  const provider = {
+    id: "fake",
+    name: "Fake effects",
+    version: "1",
+    capabilities,
+    list: (o) => searchEffectSummaries(summaries, "", o),
+    search: (q, o) => searchEffectSummaries(summaries, q, o),
+    describe: (id) => structuredClone(get(id)),
+    createRenderer(id, ro) {
+      const d = get(id);
+      if (d.kind === "motion") throw new EffectUnsupportedError(`"${id}" is a motion effect; use applyVectorEffect.`, id);
+      const { width, height } = ro;
+      const depth = ro.depth ?? 8;
+      if (!(width > 0 && height > 0) || width > capabilities.maxSize || height > capabilities.maxSize) {
+        throw new EffectUnsupportedError(`Renderer size ${width}\xD7${height} is outside 1\u2013${capabilities.maxSize}.`, id);
+      }
+      let disposed = false;
+      return {
+        effectId: id,
+        width,
+        height,
+        depth,
+        async render(request) {
+          if (disposed) throw new EffectDisposedError(id);
+          if (!Number.isFinite(request.time) || request.time < 0) {
+            throw new EffectUnsupportedError(`time must be a finite number of ms \u2265 0, got ${request.time}.`, id);
+          }
+          const values = resolveEffectValues(d, request.values);
+          options.onRender?.(id, request);
+          const out = renderPixels(d, values, request, width, height);
+          if (request.mask) {
+            if (!capabilities.supportsMask) throw new EffectUnsupportedError("This provider does not take masks.", id);
+            const source = d.uses.includes("filter") ? request.inputs?.source : void 0;
+            maskResult(out, request.mask, source, id);
+          }
+          return depth > 8 && capabilities.supportsFloat ? toFloat(out) : out;
+        },
+        dispose() {
+          disposed = true;
+        }
+      };
+    },
+    applyVectorEffect(id, target, values) {
+      const d = get(id);
+      if (d.kind !== "motion" && d.kind !== "vector") throw new EffectUnsupportedError(`"${id}" is a ${d.kind} effect, not a vector one.`, id);
+      const v = resolveEffectValues(d, values);
+      const svg = typeof target === "string" ? target : target.svg;
+      const ids = typeof target === "string" || !target.nodeIds ? [...svg.matchAll(/\sid="([^"]+)"/g)].map((m) => m[1]) : [...target.nodeIds];
+      const ms = v.ms;
+      const stagger = v.stagger;
+      return {
+        svg,
+        animate: ids.map((elementId, i) => ({ id: elementId, delay: i * stagger, ms, attrs: { opacity: [0, 1] } })),
+        duration: ms + Math.max(0, ids.length - 1) * stagger,
+        loop: false
+      };
+    }
+  };
+  return provider;
+}
+
+// src/effects/ui.ts
+var EFFECT_USE_LABELS = {
+  filter: "Filter",
+  transition: "Transition",
+  generator: "Generator",
+  overlay: "Overlay",
+  title: "Title",
+  motion: "Motion",
+  interactive: "Interactive"
+};
+var HEX2 = /^#[0-9a-f]{6}([0-9a-f]{2})?$/i;
+var typeOf = (s) => Array.isArray(s.type) ? s.type.find((t) => t !== "null") : s.type;
+function effectControlField(name, schema, fallback) {
+  const base = { id: name, ...schema.title ? { label: schema.title } : {}, ...schema.description ? { description: schema.description } : {} };
+  const def = schema.default ?? fallback;
+  const type = typeOf(schema);
+  if (Array.isArray(schema.enum) && schema.enum.length) {
+    const options = schema.enum.filter((v) => typeof v === "string" || typeof v === "number");
+    return { ...base, type: "choice", options, default: typeof def === "string" || typeof def === "number" ? def : options[0], control: options.length <= 4 ? "segmented" : "select" };
+  }
+  if (type === "number" || type === "integer") {
+    const min = schema.minimum ?? schema.exclusiveMinimum;
+    const max = schema.maximum ?? schema.exclusiveMaximum;
+    return { ...base, type: type === "integer" ? "int" : "number", default: typeof def === "number" ? def : min ?? 0, ...min !== void 0 ? { min } : {}, ...max !== void 0 ? { max } : {}, ...schema.multipleOf ? { step: schema.multipleOf } : {} };
+  }
+  if (type === "boolean") return { ...base, type: "boolean", default: def === true };
+  if (type === "string") {
+    if (typeof def === "string" && HEX2.test(def)) return { ...base, type: "color", alpha: def.length === 9, default: def };
+    return { ...base, type: "text", default: typeof def === "string" ? def : "", ...schema.maxLength ? { maxLength: schema.maxLength } : {} };
+  }
+  if (type === "array" && Array.isArray(def) && def.length >= 2 && def.length <= 4 && def.every((n) => typeof n === "number")) {
+    const items = schema.items ?? {};
+    return { ...base, type: "vector", size: def.length, default: [...def], ...items.minimum !== void 0 ? { min: items.minimum } : {}, ...items.maximum !== void 0 ? { max: items.maximum } : {} };
+  }
+  return null;
+}
+function effectParameterFields(description) {
+  return Object.entries(description.controls.properties).map(([name, schema]) => effectControlField(name, schema, description.defaults[name])).filter((f) => !!f);
+}
+var effectFieldValue = (field, value) => value === void 0 || value === null || typeof value === "object" && !Array.isArray(value) ? field.default : value;
+function effectSamplePicture(width, height, variant = 0) {
+  const p = createEffectPixels(width, height);
+  for (let y = 0, i = 0; y < height; y++) {
+    for (let x = 0; x < width; x++, i += 4) {
+      const u = x / Math.max(1, width - 1);
+      const v = y / Math.max(1, height - 1);
+      const check = (Math.floor(u * 4) + Math.floor(v * 4)) % 2;
+      if (variant === 0) p.data.set([Math.round(40 + 200 * u), Math.round(80 + 120 * v), Math.round(200 - 120 * u) + check * 30, 255], i);
+      else p.data.set([Math.round(230 - 60 * v), Math.round(190 - 100 * u), 60 + check * 40, 255], i);
+    }
+  }
+  return p;
+}
+async function renderEffectThumbnail(provider, effect, size = { width: 96, height: 54 }) {
+  const d = "inputs" in effect ? effect : await provider.describe(effect.id);
+  const renderer = await provider.createRenderer(d.id, size);
+  try {
+    const time = d.duration ? d.duration / 2 : 1e3;
+    const inputs = {};
+    for (const input2 of d.inputs) if (input2.kind === "image") inputs[input2.name] = effectSamplePicture(size.width, size.height, input2.name === "to" ? 1 : 0);
+    return await renderer.render({ time, inputs, ...d.uses.includes("transition") ? { progress: 0.5 } : {} });
+  } finally {
+    renderer.dispose();
+  }
+}
+function groupEffectsByCategory(effects) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const e of effects) {
+    const g = groups.get(e.category);
+    if (g) g.push(e);
+    else groups.set(e.category, [e]);
+  }
+  return [...groups].map(([category, list]) => ({ category, effects: list }));
+}
+export {
+  EFFECT_ERROR_CODES,
+  EFFECT_KINDS,
+  EFFECT_USES,
+  EFFECT_USE_LABELS,
+  EffectControlError,
+  EffectDisposedError,
+  EffectError,
+  EffectUnsupportedError,
+  EffectsSlot,
+  NoEffectsProviderError,
+  UnknownEffectError,
+  applyEffectMask,
+  checkEffectProvider,
+  createEffectPixels,
+  createEffectToolProvider,
+  createFakeEffectProvider,
+  effectControlField,
+  effectFieldValue,
+  effectParameterFields,
+  effectSamplePicture,
+  effectValueErrors,
+  encodeEffectFloat,
+  groupEffectsByCategory,
+  isEffectError,
+  isEffectPixels,
+  linearToSrgb,
+  renderEffectThumbnail,
+  resolveEffectValues,
+  searchEffectSummaries,
+  srgbToLinear
+};
+//# sourceMappingURL=index.js.map