@pixerate/flair 0.0.0-stage → 0.1.0

package/dist/chunk-HKXOHRCD.js

@@ -0,0 +1,763 @@
+import {
+  controlValue
+} from "./chunk-J55UBNAT.js";
+
+// src/shader/textures.ts
+var ImageLoadError = class extends Error {
+  url;
+  constructor(url, cause) {
+    super(
+      `Could not load the image at ${shortUrl(url)}. If it is on another site, that site must allow cross-origin use (CORS).`,
+      { cause }
+    );
+    this.name = "ImageLoadError";
+    this.url = url;
+  }
+};
+function shortUrl(url) {
+  if (url.startsWith("data:")) return `${url.slice(0, Math.min(url.indexOf(",") + 1 || 40, 40))}\u2026`;
+  return url.length > 120 ? `${url.slice(0, 119)}\u2026` : url;
+}
+var SVG_EDGE = 2048;
+var SVG_TYPE = "image/svg+xml";
+function isSvgUrl(url) {
+  return /^data:image\/svg\+xml[;,]/i.test(url) || /^(?!data:)[^?#]*\.svg([?#]|$)/i.test(url);
+}
+function svgLength(value) {
+  const match = value?.trim().match(/^([\d.]+)(px)?$/);
+  const n = match ? Number(match[1]) : NaN;
+  return n > 0 ? n : void 0;
+}
+function sizeSvg(markup, edge) {
+  const doc = new DOMParser().parseFromString(markup, SVG_TYPE);
+  const svg = doc.documentElement;
+  if (svg.localName !== "svg" || doc.getElementsByTagName("parsererror").length) {
+    throw new Error("Not an SVG document.");
+  }
+  const box = (svg.getAttribute("viewBox") ?? "").trim().split(/[\s,]+/).map(Number);
+  const hasBox = box.length === 4 && box[2] > 0 && box[3] > 0;
+  const width = svgLength(svg.getAttribute("width")) ?? (hasBox ? box[2] : 300);
+  const height = svgLength(svg.getAttribute("height")) ?? (hasBox ? box[3] : 150);
+  if (!hasBox) svg.setAttribute("viewBox", `0 0 ${width} ${height}`);
+  const scale = edge / Math.max(width, height);
+  svg.setAttribute("width", String(Math.max(1, Math.round(width * scale))));
+  svg.setAttribute("height", String(Math.max(1, Math.round(height * scale))));
+  return new XMLSerializer().serializeToString(svg);
+}
+async function loadImage(url) {
+  if (isSvgUrl(url)) return loadSvg(url);
+  return decode(url, url, !/^(data|blob):/i.test(url));
+}
+async function loadSvg(url) {
+  let markup;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    markup = sizeSvg(await response.text(), SVG_EDGE);
+  } catch (e) {
+    throw new ImageLoadError(url, e);
+  }
+  const sized = URL.createObjectURL(new Blob([markup], { type: SVG_TYPE }));
+  try {
+    return await decode(sized, url, false);
+  } finally {
+    URL.revokeObjectURL(sized);
+  }
+}
+async function decode(src, url, cors) {
+  const image = new Image();
+  if (cors) image.crossOrigin = "anonymous";
+  image.src = src;
+  try {
+    await image.decode();
+  } catch (e) {
+    throw new ImageLoadError(url, e);
+  }
+  return image;
+}
+var preloaded = /* @__PURE__ */ new Map();
+var decoded = /* @__PURE__ */ new Map();
+async function preloadImages(urls) {
+  const loads = [...new Set(urls)].filter(Boolean).map((url) => {
+    let load = preloaded.get(url);
+    if (!load) {
+      load = loadImage(url).then(
+        (image) => {
+          if (preloaded.get(url) === load) decoded.set(url, image);
+          return image;
+        },
+        (e) => {
+          if (preloaded.get(url) === load) preloaded.delete(url);
+          throw e;
+        }
+      );
+      preloaded.set(url, load);
+    }
+    return load;
+  });
+  const results = await Promise.allSettled(loads);
+  const failed = results.find((r) => r.status === "rejected");
+  if (failed) throw failed.reason;
+}
+function releaseImages(urls) {
+  for (const url of urls ?? [...preloaded.keys()]) {
+    preloaded.delete(url);
+    decoded.delete(url);
+  }
+}
+var TextureCache = class {
+  gl;
+  entries = /* @__PURE__ */ new Map();
+  onLoad;
+  load;
+  placeholder = null;
+  disposed = false;
+  constructor(gl, onLoad = () => {
+  }, load = loadImage) {
+    this.gl = gl;
+    this.onLoad = onLoad;
+    this.load = load;
+  }
+  texture(url) {
+    return url && this.entry(url).texture || this.blank();
+  }
+  /** Starts loading `url` if it is new. */
+  request(url) {
+    if (url) this.entry(url);
+  }
+  entry(url) {
+    const existing = this.entries.get(url);
+    if (existing) return existing;
+    const created = { texture: null, loaded: Promise.resolve(), error: null };
+    const ready = decoded.get(url);
+    if (ready && !this.gl.isContextLost()) {
+      created.texture = this.upload(ready);
+      this.entries.set(url, created);
+      return created;
+    }
+    created.loaded = this.load(url).then(
+      (image) => {
+        if (this.entries.get(url) !== created || this.disposed || this.gl.isContextLost()) return;
+        created.texture = this.upload(image);
+        this.onLoad(url, null);
+      },
+      (e) => {
+        if (this.entries.get(url) !== created || this.disposed) return;
+        created.error = e instanceof ImageLoadError ? e : new ImageLoadError(url, e);
+        this.onLoad(url, created.error);
+      }
+    );
+    this.entries.set(url, created);
+    return created;
+  }
+  /** The error for `url`, if it failed to load. */
+  error(url) {
+    return this.entries.get(url)?.error ?? null;
+  }
+  /**
+   * Settles once every one of `urls` has loaded or failed (starting any that
+   * are new). Rejects with the first {@link ImageLoadError}.
+   */
+  async ready(urls) {
+    const entries = [...urls].filter(Boolean).map((url) => this.entry(url));
+    await Promise.all(entries.map((e) => e.loaded));
+    const failed = entries.find((e) => e.error);
+    if (failed) throw failed.error;
+  }
+  /** Deletes the textures of every URL not in `urls`; a later request loads them again. */
+  retain(urls) {
+    const keep = new Set(urls);
+    for (const [url, entry] of this.entries) {
+      if (keep.has(url)) continue;
+      if (entry.texture) this.gl.deleteTexture(entry.texture);
+      this.entries.delete(url);
+    }
+  }
+  /** Deletes every texture; loads still in flight are dropped. */
+  dispose() {
+    this.retain([]);
+    if (this.placeholder) this.gl.deleteTexture(this.placeholder);
+    this.placeholder = null;
+    this.disposed = true;
+  }
+  blank() {
+    if (this.placeholder) return this.placeholder;
+    const gl = this.gl;
+    this.placeholder = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, this.placeholder);
+    const black = new Uint8Array([0, 0, 0, 255]);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, black);
+    return this.placeholder;
+  }
+  upload(image) {
+    const gl = this.gl;
+    const texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
+    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+    gl.generateMipmap(gl.TEXTURE_2D);
+    return texture;
+  }
+};
+function applyTextureSettings(gl, settings) {
+  const min = { mipmap: gl.LINEAR_MIPMAP_LINEAR, linear: gl.LINEAR, nearest: gl.NEAREST }[settings.filter];
+  const wrap = { repeat: gl.REPEAT, clamp: gl.CLAMP_TO_EDGE, mirror: gl.MIRRORED_REPEAT }[settings.wrap];
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, min);
+  gl.texParameteri(
+    gl.TEXTURE_2D,
+    gl.TEXTURE_MAG_FILTER,
+    settings.filter === "nearest" ? gl.NEAREST : gl.LINEAR
+  );
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrap);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrap);
+}
+
+// src/shader/program.ts
+var BUILTIN_UNIFORMS = [
+  { name: "iResolution", type: "vec3", doc: "viewport size in pixels (z = 1)" },
+  { name: "iTime", type: "float", doc: "seconds since the shader started" },
+  { name: "iTimeDelta", type: "float", doc: "seconds since the previous frame" },
+  { name: "iFrame", type: "int", doc: "frame number" },
+  {
+    name: "iMouse",
+    type: "vec4",
+    doc: "xy = pointer while pressed (pixels), zw = press position (negative once released)"
+  }
+];
+var PRELUDE = `#version 300 es
+precision highp float;
+precision highp int;
+uniform vec3 iResolution;
+uniform float iTime;
+uniform float iTimeDelta;
+uniform int iFrame;
+uniform vec4 iMouse;
+out vec4 flair_FragColor;
+`;
+var EPILOGUE = `
+void main() {
+  vec4 flair_color = vec4(0.0, 0.0, 0.0, 1.0);
+  mainImage(flair_color, gl_FragCoord.xy);
+  flair_FragColor = vec4(flair_color.rgb, 1.0);
+}
+`;
+var VERTEX_SOURCE = `#version 300 es
+void main() {
+  vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));
+  gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
+}
+`;
+var ShaderCompileError = class extends Error {
+  errors;
+  constructor(errors) {
+    super(formatCompileError(errors));
+    this.name = "ShaderCompileError";
+    this.errors = errors;
+  }
+};
+function formatCompileError(errors) {
+  const first = errors[0];
+  return `The shader does not compile${first?.line ? ` (line ${first.line})` : ""}: ${first?.message ?? "unknown error"}`;
+}
+function wrapSource(source) {
+  return `${PRELUDE}#line 1
+${source.replace(/^\s*#version[^\n]*/m, "")}
+${EPILOGUE}`;
+}
+function parseCompileLog(log, lineCount) {
+  const errors = [];
+  for (const raw of log.split("\n")) {
+    const text = raw.trim();
+    if (!text) continue;
+    const m = /^(?:ERROR|WARNING):\s*\d+:(\d+):\s*(.*)$/.exec(text);
+    if (m) {
+      const line = Number(m[1]);
+      errors.push({ line: line >= 1 && line <= lineCount ? line : 0, message: m[2].trim() });
+    } else if (!/^\W*$/.test(text)) {
+      errors.push({ line: 0, message: text.replace(/^ERROR:\s*/, "") });
+    }
+  }
+  if (!errors.length) errors.push({ line: 0, message: "The shader did not compile." });
+  const seen = /* @__PURE__ */ new Set();
+  return errors.filter((e) => {
+    const key = `${e.line}:${e.message}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+var vertexCache = /* @__PURE__ */ new WeakMap();
+function vertexShader(gl) {
+  let vs = vertexCache.get(gl);
+  if (!vs) {
+    vs = gl.createShader(gl.VERTEX_SHADER);
+    gl.shaderSource(vs, VERTEX_SOURCE);
+    gl.compileShader(vs);
+    vertexCache.set(gl, vs);
+  }
+  return vs;
+}
+function resetGlCaches() {
+  vertexCache = /* @__PURE__ */ new WeakMap();
+}
+function compileShader(gl, source, controls) {
+  const lineCount = source.split("\n").length;
+  if (gl.isContextLost()) {
+    return {
+      ok: false,
+      errors: [
+        {
+          line: 0,
+          message: "The graphics context was lost; reload the page if the preview does not come back."
+        }
+      ]
+    };
+  }
+  if (!/\bmainImage\s*\(/.test(source)) {
+    return {
+      ok: false,
+      errors: [
+        { line: 0, message: "Define void mainImage(out vec4 fragColor, in vec2 fragCoord)." }
+      ]
+    };
+  }
+  const fs = gl.createShader(gl.FRAGMENT_SHADER);
+  if (!fs) {
+    return {
+      ok: false,
+      errors: [{ line: 0, message: "WebGL could not create a shader (the context may be lost)." }]
+    };
+  }
+  gl.shaderSource(fs, wrapSource(source));
+  gl.compileShader(fs);
+  if (!gl.getShaderParameter(fs, gl.COMPILE_STATUS)) {
+    const errors = parseCompileLog(gl.getShaderInfoLog(fs) ?? "", lineCount);
+    gl.deleteShader(fs);
+    return { ok: false, errors };
+  }
+  const program = gl.createProgram();
+  gl.attachShader(program, vertexShader(gl));
+  gl.attachShader(program, fs);
+  gl.linkProgram(program);
+  gl.deleteShader(fs);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    const errors = parseCompileLog(gl.getProgramInfoLog(program) ?? "", lineCount);
+    gl.deleteProgram(program);
+    return { ok: false, errors };
+  }
+  const builtins = {};
+  for (const u of BUILTIN_UNIFORMS) builtins[u.name] = gl.getUniformLocation(program, u.name);
+  const uniforms = new Map(
+    controls.map((c) => [c.name, gl.getUniformLocation(program, c.name)])
+  );
+  return { ok: true, shader: { program, builtins, uniforms } };
+}
+function drawFrame(gl, shader, controls, values, state, textures) {
+  gl.viewport(0, 0, state.width, state.height);
+  gl.useProgram(shader.program);
+  const b = shader.builtins;
+  if (b.iResolution) gl.uniform3f(b.iResolution, state.width, state.height, 1);
+  if (b.iTime) gl.uniform1f(b.iTime, state.time);
+  if (b.iTimeDelta) gl.uniform1f(b.iTimeDelta, state.delta);
+  if (b.iFrame) gl.uniform1i(b.iFrame, state.frame);
+  if (b.iMouse) gl.uniform4f(b.iMouse, ...state.mouse);
+  let unit = 0;
+  for (const control of controls) {
+    const loc = shader.uniforms.get(control.name);
+    if (!loc) continue;
+    const v = controlValue(control, values);
+    switch (control.type) {
+      case "float":
+        gl.uniform1f(loc, v);
+        break;
+      case "int":
+        gl.uniform1i(loc, Math.round(v));
+        break;
+      case "bool":
+        gl.uniform1i(loc, v ? 1 : 0);
+        break;
+      case "vec2":
+        gl.uniform2fv(loc, v);
+        break;
+      case "vec3":
+        gl.uniform3fv(loc, v);
+        break;
+      case "vec4":
+        gl.uniform4fv(loc, v);
+        break;
+      case "sampler2D": {
+        gl.activeTexture(gl.TEXTURE0 + unit);
+        const texture = textures?.texture(v) ?? null;
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        if (texture && control.texture) applyTextureSettings(gl, control.texture);
+        gl.uniform1i(loc, unit++);
+        break;
+      }
+    }
+  }
+  gl.drawArrays(gl.TRIANGLES, 0, 3);
+}
+function createContext(canvas, preserveDrawingBuffer = false) {
+  return canvas.getContext("webgl2", {
+    alpha: false,
+    antialias: false,
+    depth: false,
+    stencil: false,
+    premultipliedAlpha: false,
+    preserveDrawingBuffer,
+    powerPreference: "high-performance"
+  });
+}
+
+// src/shader/color.ts
+function srgbToLinear(c) {
+  const v = Math.max(0, c);
+  return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+}
+function linearToSrgb(c) {
+  const v = Math.max(0, c);
+  return v <= 31308e-7 ? v * 12.92 : 1.055 * Math.pow(v, 1 / 2.4) - 0.055;
+}
+function srgbToLinearRgb(rgb) {
+  return [srgbToLinear(rgb[0]), srgbToLinear(rgb[1]), srgbToLinear(rgb[2])];
+}
+function linearRgbToSrgb(rgb) {
+  return [linearToSrgb(rgb[0]), linearToSrgb(rgb[1]), linearToSrgb(rgb[2])];
+}
+function linearSrgbToOklab(rgb) {
+  const [r, g, b] = rgb;
+  const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+  const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+  const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+  const L = 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s;
+  const a = 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s;
+  const bVal = 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s;
+  return [L, a, bVal];
+}
+function oklabToLinearSrgb(lab) {
+  const [L, a, b] = lab;
+  const l_ = L + 0.3963377774 * a + 0.2158037573 * b;
+  const m_ = L - 0.1055613458 * a - 0.0638541728 * b;
+  const s_ = L - 0.0894841775 * a - 1.291485548 * b;
+  const l = l_ * l_ * l_;
+  const m = m_ * m_ * m_;
+  const s = s_ * s_ * s_;
+  const r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;
+  const g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;
+  const bVal = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;
+  return [r, g, bVal];
+}
+function srgbToOklab(rgb) {
+  return linearSrgbToOklab(srgbToLinearRgb(rgb));
+}
+function oklabToSrgb(lab) {
+  const linear = oklabToLinearSrgb(lab);
+  return linearRgbToSrgb(linear);
+}
+function oklabToOklch(lab) {
+  const [L, a, b] = lab;
+  const C = Math.sqrt(a * a + b * b);
+  let h = Math.atan2(b, a);
+  if (h < 0) h += 2 * Math.PI;
+  return [L, C, h];
+}
+function oklchToOklab(lch) {
+  const [L, C, h] = lch;
+  return [L, C * Math.cos(h), C * Math.sin(h)];
+}
+function interpolateOklab(c1, c2, t) {
+  const lab1 = srgbToOklab(c1);
+  const lab2 = srgbToOklab(c2);
+  const clampedT = Math.max(0, Math.min(1, t));
+  const lab = [
+    lab1[0] + (lab2[0] - lab1[0]) * clampedT,
+    lab1[1] + (lab2[1] - lab1[1]) * clampedT,
+    lab1[2] + (lab2[2] - lab1[2]) * clampedT
+  ];
+  const res = oklabToSrgb(lab);
+  return [
+    Math.max(0, Math.min(1, res[0])),
+    Math.max(0, Math.min(1, res[1])),
+    Math.max(0, Math.min(1, res[2]))
+  ];
+}
+function interpolateOklch(c1, c2, t) {
+  const lch1 = oklabToOklch(srgbToOklab(c1));
+  const lch2 = oklabToOklch(srgbToOklab(c2));
+  const clampedT = Math.max(0, Math.min(1, t));
+  const L = lch1[0] + (lch2[0] - lch1[0]) * clampedT;
+  const C = lch1[1] + (lch2[1] - lch1[1]) * clampedT;
+  let dHue = lch2[2] - lch1[2];
+  if (dHue > Math.PI) dHue -= 2 * Math.PI;
+  if (dHue < -Math.PI) dHue += 2 * Math.PI;
+  let h = lch1[2] + dHue * clampedT;
+  if (h < 0) h += 2 * Math.PI;
+  if (h >= 2 * Math.PI) h -= 2 * Math.PI;
+  const res = oklabToSrgb(oklchToOklab([L, C, h]));
+  return [
+    Math.max(0, Math.min(1, res[0])),
+    Math.max(0, Math.min(1, res[1])),
+    Math.max(0, Math.min(1, res[2]))
+  ];
+}
+function mulMat3(m, v) {
+  return [
+    m[0] * v[0] + m[1] * v[1] + m[2] * v[2],
+    m[3] * v[0] + m[4] * v[1] + m[5] * v[2],
+    m[6] * v[0] + m[7] * v[1] + m[8] * v[2]
+  ];
+}
+var MAT_LINEAR_SRGB_TO_P3 = [
+  0.822462,
+  0.177538,
+  0,
+  0.033194,
+  0.966806,
+  0,
+  0.017083,
+  0.072397,
+  0.91052
+];
+var MAT_P3_TO_LINEAR_SRGB = [
+  1.22494,
+  -0.22494,
+  0,
+  -0.042057,
+  1.042057,
+  0,
+  -0.019638,
+  -0.078636,
+  1.098274
+];
+var MAT_LINEAR_SRGB_TO_ACESCG = [
+  0.613097,
+  0.339523,
+  0.047379,
+  0.070194,
+  0.916354,
+  0.013452,
+  0.020616,
+  0.10957,
+  0.869815
+];
+var MAT_ACESCG_TO_LINEAR_SRGB = [
+  1.704859,
+  -0.621714,
+  -0.083299,
+  -0.130078,
+  1.140735,
+  -0.01056,
+  -0.023964,
+  -0.128975,
+  1.153014
+];
+function convertColorSpace(color, from, to) {
+  if (from === to) return [...color];
+  let lin;
+  switch (from) {
+    case "srgb":
+      lin = srgbToLinearRgb(color);
+      break;
+    case "linear-srgb":
+      lin = [...color];
+      break;
+    case "rec709":
+      lin = [
+        Math.pow(Math.max(0, color[0]), 2.4),
+        Math.pow(Math.max(0, color[1]), 2.4),
+        Math.pow(Math.max(0, color[2]), 2.4)
+      ];
+      break;
+    case "display-p3": {
+      const p3Lin = srgbToLinearRgb(color);
+      lin = mulMat3(MAT_P3_TO_LINEAR_SRGB, p3Lin);
+      break;
+    }
+    case "acescg":
+      lin = mulMat3(MAT_ACESCG_TO_LINEAR_SRGB, color);
+      break;
+  }
+  switch (to) {
+    case "linear-srgb":
+      return lin;
+    case "srgb":
+      return linearRgbToSrgb(lin);
+    case "rec709":
+      return [
+        Math.pow(Math.max(0, lin[0]), 1 / 2.4),
+        Math.pow(Math.max(0, lin[1]), 1 / 2.4),
+        Math.pow(Math.max(0, lin[2]), 1 / 2.4)
+      ];
+    case "display-p3": {
+      const p3Lin = mulMat3(MAT_LINEAR_SRGB_TO_P3, lin);
+      return linearRgbToSrgb(p3Lin);
+    }
+    case "acescg":
+      return mulMat3(MAT_LINEAR_SRGB_TO_ACESCG, lin);
+  }
+}
+function applyAscCdl(color, cdl) {
+  const slope = cdl.slope ?? [1, 1, 1];
+  const offset = cdl.offset ?? [0, 0, 0];
+  const power = cdl.power ?? [1, 1, 1];
+  const sat = cdl.saturation ?? 1;
+  let r = Math.pow(Math.max(0, color[0] * slope[0] + offset[0]), power[0]);
+  let g = Math.pow(Math.max(0, color[1] * slope[1] + offset[1]), power[1]);
+  let b = Math.pow(Math.max(0, color[2] * slope[2] + offset[2]), power[2]);
+  if (sat !== 1) {
+    const luma = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+    r = luma + sat * (r - luma);
+    g = luma + sat * (g - luma);
+    b = luma + sat * (b - luma);
+  }
+  return [Math.max(0, r), Math.max(0, g), Math.max(0, b)];
+}
+function applyLiftGammaGain(color, lgg) {
+  const lift = lgg.lift ?? [0, 0, 0];
+  const gamma = lgg.gamma ?? [1, 1, 1];
+  const gain = lgg.gain ?? [1, 1, 1];
+  const processChannel = (val, l, gm, gn) => {
+    const lifted = val + l * (1 - val);
+    const gained = Math.max(0, lifted * gn);
+    const safeGamma = Math.max(1e-4, gm);
+    return Math.pow(gained, 1 / safeGamma);
+  };
+  return [
+    processChannel(color[0], lift[0], gamma[0], gain[0]),
+    processChannel(color[1], lift[1], gamma[1], gain[1]),
+    processChannel(color[2], lift[2], gamma[2], gain[2])
+  ];
+}
+function applyVibrance(color, amount) {
+  if (Math.abs(amount) < 1e-4) return [...color];
+  const [r, g, b] = color;
+  const maxC = Math.max(r, g, b);
+  const minC = Math.min(r, g, b);
+  const sat = maxC > 1e-5 ? (maxC - minC) / maxC : 0;
+  let skinProtection = 1;
+  if (r > g && g > b) {
+    const skinFactor = (g - b) / (r - b + 1e-5);
+    skinProtection = Math.max(0.2, 1 - skinFactor * 0.5);
+  }
+  const boost = amount * (1 - sat) * skinProtection;
+  const luma = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+  const newR = Math.max(0, Math.min(1, luma + (1 + boost) * (r - luma)));
+  const newG = Math.max(0, Math.min(1, luma + (1 + boost) * (g - luma)));
+  const newB = Math.max(0, Math.min(1, luma + (1 + boost) * (b - luma)));
+  return [newR, newG, newB];
+}
+function getWhiteBalanceGains(kelvin, tint = 0) {
+  const k = Math.max(2e3, Math.min(12e3, kelvin)) / 100;
+  let r;
+  let g;
+  let b;
+  if (k <= 66) {
+    r = 255;
+    g = 99.4708025861 * Math.log(k) - 161.1195681661;
+    b = k <= 19 ? 0 : 138.5177312231 * Math.log(k - 10) - 305.0447927307;
+  } else {
+    r = 329.698727446 * Math.pow(k - 60, -0.1332047592);
+    g = 288.1221695283 * Math.pow(k - 60, -0.0755148492);
+    b = 255;
+  }
+  const d65R = 255;
+  const d65G = 250.7;
+  const d65B = 255;
+  let gainR = r / d65R;
+  let gainG = g / d65G;
+  let gainB = b / d65B;
+  const tintFactor = tint / 100;
+  gainG *= 1 - tintFactor * 0.15;
+  gainR *= 1 + tintFactor * 0.05;
+  gainB *= 1 + tintFactor * 0.05;
+  return [gainR, gainG, gainB];
+}
+function getOklabGLSL() {
+  return `
+// Oklab <-> Linear sRGB (Bj\xF6rn Ottosson)
+vec3 flair_linear_to_oklab(vec3 c) {
+  float l = pow(0.4122214708 * c.r + 0.5363325363 * c.g + 0.0514459929 * c.b, 1.0 / 3.0);
+  float m = pow(0.2119034982 * c.r + 0.6806995451 * c.g + 0.1073969566 * c.b, 1.0 / 3.0);
+  float s = pow(0.0883024619 * c.r + 0.2817188376 * c.g + 0.6299787005 * c.b, 1.0 / 3.0);
+  return vec3(
+    0.2104542553 * l + 0.7936177850 * m - 0.0040720468 * s,
+    1.9779984951 * l - 2.4285922050 * m + 0.4505937099 * s,
+    0.0259040371 * l + 0.7827717662 * m - 0.8086757660 * s
+  );
+}
+
+vec3 flair_oklab_to_linear(vec3 lab) {
+  float l_ = lab.x + 0.3963377774 * lab.y + 0.2158037573 * lab.z;
+  float m_ = lab.x - 0.1055613458 * lab.y - 0.0638541728 * lab.z;
+  float s_ = lab.x - 0.0894841775 * lab.y - 1.2914855480 * lab.z;
+  float l = l_ * l_ * l_;
+  float m = m_ * m_ * m_;
+  float s = s_ * s_ * s_;
+  return vec3(
+    +4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+    -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s
+  );
+}
+`.trim();
+}
+function getColorGradingGLSL() {
+  return `
+// ASC CDL Grading
+vec3 flair_cdl(vec3 color, vec3 slope, vec3 offset, vec3 power, float sat) {
+  vec3 c = pow(max(color * slope + offset, vec3(0.0)), power);
+  float luma = dot(c, vec3(0.2126, 0.7152, 0.0722));
+  return mix(vec3(luma), c, sat);
+}
+
+// 3-Way Lift / Gamma / Gain Grading
+vec3 flair_lift_gamma_gain(vec3 color, vec3 lift, vec3 gamma, vec3 gain) {
+  vec3 lifted = color + lift * (vec3(1.0) - color);
+  vec3 gained = max(lifted * gain, vec3(0.0));
+  return pow(gained, 1.0 / max(gamma, vec3(0.0001)));
+}
+`.trim();
+}
+
+export {
+  ImageLoadError,
+  SVG_EDGE,
+  isSvgUrl,
+  sizeSvg,
+  loadImage,
+  preloadImages,
+  releaseImages,
+  TextureCache,
+  applyTextureSettings,
+  BUILTIN_UNIFORMS,
+  VERTEX_SOURCE,
+  ShaderCompileError,
+  formatCompileError,
+  wrapSource,
+  parseCompileLog,
+  resetGlCaches,
+  compileShader,
+  drawFrame,
+  createContext,
+  srgbToLinear,
+  linearToSrgb,
+  srgbToLinearRgb,
+  linearRgbToSrgb,
+  linearSrgbToOklab,
+  oklabToLinearSrgb,
+  srgbToOklab,
+  oklabToSrgb,
+  oklabToOklch,
+  oklchToOklab,
+  interpolateOklab,
+  interpolateOklch,
+  convertColorSpace,
+  applyAscCdl,
+  applyLiftGammaGain,
+  applyVibrance,
+  getWhiteBalanceGains,
+  getOklabGLSL,
+  getColorGradingGLSL
+};
+//# sourceMappingURL=chunk-HKXOHRCD.js.map