@eightshift/ui-components 5.5.0 → 5.6.1

package/dist/utilities/general.js

@@ -1,4142 +1,10 @@
-var Lane = /* @__PURE__ */ ((Lane2) => {
-  Lane2[Lane2["ALPHA"] = 0] = "ALPHA";
-  Lane2[Lane2["BLUE"] = 1] = "BLUE";
-  Lane2[Lane2["GREEN"] = 2] = "GREEN";
-  Lane2[Lane2["RED"] = 3] = "RED";
-  return Lane2;
-})(Lane || {});
-const ROT_IDS = ["rotateCW", "rotate180", "rotateCCW"];
-const adaptiveCanvas2d = (width, height = width, parent, opts = {}) => {
-  const canvas = document.createElement("canvas");
-  adaptDPI(canvas, width, height, opts.dpr);
-  opts.pixelated && (canvas.style.imageRendering = "pixelated");
-  return {
-    canvas,
-    ctx: canvas.getContext("2d", opts.ctx)
-  };
-};
-const canvas2d = (width, height = width, parent, opts) => adaptiveCanvas2d(width, height, parent, { dpr: 1, ...opts });
-const adaptDPI = (canvas, width, height, dpr = window.devicePixelRatio || 1) => {
-  if (dpr !== 1) {
-    canvas.style.width = `${width}px`;
-    canvas.style.height = `${height}px`;
-  }
-  canvas.width = width * dpr;
-  canvas.height = height * dpr;
-  return dpr;
-};
-const isNumber = (x) => typeof x === "number";
-function canvasPixels(width, height, parent, opts) {
-  let canvas;
-  let ctx;
-  if (isNumber(width)) {
-    const c2 = canvas2d(width, height, parent, opts);
-    canvas = c2.canvas;
-    ctx = c2.ctx;
-  } else {
-    canvas = width;
-    ctx = canvas.getContext("2d");
-  }
-  const img = ctx.getImageData(0, 0, canvas.width, canvas.height);
-  const data = new Uint32Array(img.data.buffer);
-  return {
-    canvas,
-    ctx,
-    img,
-    data
-  };
-}
-const nomixin = (_, __, descriptor) => {
-  descriptor.configurable = false;
-};
-const mixin = (behaviour, sharedBehaviour = {}) => {
-  const instanceKeys = Reflect.ownKeys(behaviour);
-  const sharedKeys = Reflect.ownKeys(sharedBehaviour);
-  const typeTag = Symbol("isa");
-  function _mixin(clazz) {
-    for (let key of instanceKeys) {
-      const existing = Object.getOwnPropertyDescriptor(
-        clazz.prototype,
-        key
-      );
-      if (!existing || existing.configurable) {
-        Object.defineProperty(clazz.prototype, key, {
-          value: behaviour[key],
-          writable: true
-        });
-      }
-    }
-    Object.defineProperty(clazz.prototype, typeTag, { value: true });
-    return clazz;
-  }
-  for (let key of sharedKeys) {
-    Object.defineProperty(_mixin, key, {
-      value: sharedBehaviour[key],
-      enumerable: sharedBehaviour.propertyIsEnumerable(key)
-    });
-  }
-  Object.defineProperty(_mixin, Symbol.hasInstance, {
-    value: (x) => !!x[typeTag]
-  });
-  return _mixin;
-};
-mixin({
-  order() {
-    return [0];
-  },
-  includes(x) {
-    return x >= 0 && x < this.size[0];
-  },
-  indexAt(x) {
-    return this.includes(x) ? this.indexAtUnsafe(x) : -1;
-  },
-  indexAtUnsafe(x) {
-    return this.offset + (x | 0) * this.stride[0];
-  },
-  getAt(x) {
-    return this.includes(x) ? this.data[this.indexAtUnsafe(x)] : 0;
-  },
-  getAtUnsafe(x) {
-    return this.data[this.indexAtUnsafe(x)];
-  },
-  setAt(x, val) {
-    return this.includes(x) ? (this.data[this.indexAtUnsafe(x)] = val, true) : false;
-  },
-  setAtUnsafe(x, val) {
-    this.data[this.indexAtUnsafe(x)] = val;
-    return true;
-  }
-});
-const IGrid2DMixin = mixin({
-  order() {
-    return Math.abs(this.stride[1]) > Math.abs(this.stride[0]) ? [1, 0] : [0, 1];
-  },
-  includes(x, y) {
-    const size = this.size;
-    return x >= 0 && x < size[0] && y >= 0 && y < size[1];
-  },
-  indexAt(x, y) {
-    return this.includes(x, y) ? this.indexAtUnsafe(x, y) : -1;
-  },
-  indexAtUnsafe(x, y) {
-    return this.offset + (x | 0) * this.stride[0] + (y | 0) * this.stride[1];
-  },
-  getAt(x, y) {
-    return this.includes(x, y) ? this.data[this.indexAtUnsafe(x, y)] : 0;
-  },
-  getAtUnsafe(x, y) {
-    return this.data[this.indexAtUnsafe(x, y)];
-  },
-  setAt(x, y, val) {
-    return this.includes(x, y) ? (this.data[this.indexAtUnsafe(x, y)] = val, true) : false;
-  },
-  setAtUnsafe(x, y, val) {
-    this.data[this.indexAtUnsafe(x, y)] = val;
-    return true;
-  }
-});
-mixin({
-  order() {
-    return __strideOrder(this.stride);
-  },
-  includes(x, y, z) {
-    const size = this.size;
-    return x >= 0 && x < size[0] && y >= 0 && y < size[1] && z >= 0 && z < size[2];
-  },
-  indexAt(x, y, z) {
-    return this.includes(x, y, z) ? this.indexAtUnsafe(x, y, z) : -1;
-  },
-  indexAtUnsafe(x, y, z) {
-    const stride = this.stride;
-    return this.offset + (x | 0) * stride[0] + (y | 0) * stride[1] + (z | 0) * stride[2];
-  },
-  getAt(x, y, z) {
-    return this.includes(x, y, z) ? this.data[this.indexAtUnsafe(x, y, z)] : 0;
-  },
-  getAtUnsafe(x, y, z) {
-    return this.data[this.indexAtUnsafe(x, y, z)];
-  },
-  setAt(x, y, z, val) {
-    return this.includes(x, y, z) ? (this.data[this.indexAtUnsafe(x, y, z)] = val, true) : false;
-  },
-  setAtUnsafe(x, y, z, val) {
-    this.data[this.indexAtUnsafe(x, y, z)] = val;
-    return true;
-  }
-});
-mixin({
-  order() {
-    return __strideOrder(this.stride);
-  },
-  includes(x, y, z, w) {
-    const size = this.size;
-    return x >= 0 && x < size[0] && y >= 0 && y < size[1] && z >= 0 && z < size[2] && w >= 0 && w < size[3];
-  },
-  indexAt(x, y, z, w) {
-    return this.includes(x, y, z, w) ? this.indexAtUnsafe(x, y, z, w) : -1;
-  },
-  indexAtUnsafe(x, y, z, w) {
-    const stride = this.stride;
-    return this.offset + (x | 0) * stride[0] + (y | 0) * stride[1] + (z | 0) * stride[2] + (w | 0) * stride[3];
-  },
-  getAt(x, y, z, w) {
-    return this.includes(x, y, z, w) ? this.data[this.indexAtUnsafe(x, y, z, w)] : 0;
-  },
-  getAtUnsafe(x, y, z, w) {
-    return this.data[this.indexAtUnsafe(x, y, z, w)];
-  },
-  setAt(x, y, z, w, val) {
-    return this.includes(x, y, z, w) ? (this.data[this.indexAtUnsafe(x, y, z, w)] = val, true) : false;
-  },
-  setAtUnsafe(x, y, z, w, val) {
-    this.data[this.indexAtUnsafe(x, y, z, w)] = val;
-    return true;
-  }
-});
-const __strideOrder = (strides) => [...strides].map((x, i) => [x, i]).sort((a2, b2) => Math.abs(b2[0]) - Math.abs(a2[0])).map((x) => x[1]);
-const isString = (x) => typeof x === "string";
-const defError = (prefix, suffix = (msg) => msg !== void 0 ? ": " + msg : "") => class extends Error {
-  origMessage;
-  constructor(msg) {
-    super(prefix(msg) + suffix(msg));
-    this.origMessage = msg !== void 0 ? String(msg) : "";
-  }
-};
-const __vite_import_meta_env__ = {};
-const AssertionError = defError(() => "Assertion failed");
-const assert = (typeof process !== "undefined" && process.env !== void 0 ? process.env.NODE_ENV !== "production" || !!process.env.UMBRELLA_ASSERTS : __vite_import_meta_env__ ? false : true) ? (test, msg) => {
-  if (typeof test === "function" && !test() || !test) {
-    throw new AssertionError(
-      typeof msg === "function" ? msg() : msg
-    );
-  }
-} : () => {
-};
-const clamp$1 = (x, min2, max2) => x < min2 ? min2 : x > max2 ? max2 : x;
-const clamp01 = (x) => x < 0 ? 0 : x > 1 ? 1 : x;
-const setC4$1 = (out, a2, b2, c2, d2) => (out[0] = a2, out[1] = b2, out[2] = c2, out[3] = d2, out);
-const premultiply = (out, src) => {
-  const a2 = src[3];
-  return setC4$1(src, src[0] * a2, src[1] * a2, src[2] * a2, a2);
-};
-const premultiplyInt = (src) => {
-  const a2 = (src >>> 24) / 255;
-  return src & 4278190080 | (src >>> 16 & 255) * a2 << 16 | (src >>> 8 & 255) * a2 << 8 | (src & 255) * a2;
-};
-const postmultiply = (out, src) => {
-  const a2 = src[3];
-  return a2 > 0 ? setC4$1(src, src[0] / a2, src[1] / a2, src[2] / a2, a2) : src;
-};
-const postmultiplyInt = (src) => {
-  const a2 = (src >>> 24) / 255;
-  return a2 > 0 ? (src & 4278190080 | Math.min(255, (src >>> 16 & 255) / a2) << 16 | Math.min(255, (src >>> 8 & 255) / a2) << 8 | Math.min(255, (src & 255) / a2)) >>> 0 : src;
-};
-const isPremultiplied = (src) => {
-  const a2 = src[3];
-  return src[0] <= a2 && src[1] <= a2 || src[2] <= a2;
-};
-const isPremultipliedInt = (src) => {
-  const a2 = src >>> 24;
-  return (src >>> 16 & 255) <= a2 && (src >>> 8 & 255) <= a2 && (src & 255) <= a2;
-};
-const ensureSize = (data, width, height, stride = 1) => assert(data.length >= width * height * stride, "pixel buffer too small");
-const ensureImageData = (data, width, height) => data ? (ensureImageDataSize(data, width, height), data) : new ImageData(width, height);
-const ensureImageDataSize = (data, width, height) => assert(
-  data.width === width && data.height === height,
-  "imagedata has wrong dimensions"
-);
-const ensureChannel = (fmt, id) => {
-  const chan = fmt.channels[id];
-  assert(chan != null, `invalid channel ID: ${id}`);
-  return chan;
-};
-const ensureAlpha = (fmt) => assert(!!fmt.alpha, "missing alpha channel");
-const identity$1 = (x) => x;
-const __luminanceABGR = (c2) => ((c2 >>> 16 & 255) * 29 + (c2 >>> 8 & 255) * 150 + (c2 & 255) * 76) / 255;
-const __clampRegion = (sx, sy, w, h, maxw, maxh, dx = 0, dy = 0) => {
-  sx |= 0;
-  sy |= 0;
-  w |= 0;
-  h |= 0;
-  sx < 0 && (w += sx, dx -= sx, sx = 0);
-  sy < 0 && (h += sy, dy -= sy, sy = 0);
-  return [sx, sy, clamp$1(w, 0, maxw - sx), clamp$1(h, 0, maxh - sy), dx, dy];
-};
-const __prepRegions = (src, dest, opts = {}) => {
-  const sw = src.width;
-  const dw = dest.width;
-  let sx, sy;
-  let dx, dy;
-  let rw, rh;
-  [sx, sy, rw, rh] = __clampRegion(
-    opts.sx || 0,
-    opts.sy || 0,
-    opts.w || sw,
-    opts.h || src.height,
-    sw,
-    src.height
-  );
-  [dx, dy, rw, rh, sx, sy] = __clampRegion(
-    opts.dx || 0,
-    opts.dy || 0,
-    rw,
-    rh,
-    dw,
-    dest.height,
-    sx,
-    sy
-  );
-  return { sx, sy, dx, dy, rw, rh };
-};
-const __setChannelUni = (dbuf, src, set5) => {
-  for (let i = dbuf.length; i-- > 0; ) {
-    dbuf[i] = set5(dbuf[i], src);
-  }
-};
-const __setChannelSame = (dbuf, sbuf, get, set5) => {
-  for (let i = dbuf.length; i-- > 0; ) {
-    dbuf[i] = set5(dbuf[i], get(sbuf[i]));
-  }
-};
-const __setChannelConvert = (dbuf, sbuf, from, sto, mask) => {
-  const invMask = ~mask;
-  for (let i = dbuf.length; i-- > 0; ) {
-    dbuf[i] = dbuf[i] & invMask | from(sto(sbuf[i])) & mask;
-  }
-};
-const __transformABGR = (pix, format, fn) => {
-  const from = format.fromABGR;
-  const to = format.toABGR;
-  for (let i = pix.length; i-- > 0; ) {
-    pix[i] = from(fn(to(pix[i])));
-  }
-};
-const __blitCanvas = (buf, canvas, opts = {}) => (canvas instanceof HTMLCanvasElement || canvas instanceof OffscreenCanvas ? canvas.getContext("2d") : canvas).putImageData(buf.toImageData(opts.data), opts.x || 0, opts.y || 0);
-const defFloatFormat = (fmt) => {
-  const chan = fmt.channels;
-  const chanShift = chan.reduce(
-    (acc, ch) => (acc[ch] = 3 - ch << 3, acc),
-    {}
-  );
-  const res = {
-    ...fmt,
-    __float: true,
-    size: chan.length,
-    shift: chanShift,
-    range: [0, 1],
-    normalized: clamp01,
-    fromNormalized: identity$1
-  };
-  if (fmt.convert) {
-    Object.assign(res, fmt.convert);
-    return res;
-  }
-  const to = (col, i) => (clamp01(col[i]) * 255 + 0.5 | 0) << chanShift[chan[i]];
-  const from = (col, i) => (col >>> chanShift[chan[i]] & 255) / 255;
-  switch (chan.length) {
-    case 1:
-      fmt.gray ? __defConvert1Gray(res) : __defConvert1(res, from, to);
-      break;
-    case 2:
-      fmt.gray ? __defConvert2Gray(res, from) : __defConvert2(res, from, to);
-      break;
-    case 3:
-      __defConvert3(res, from, to);
-      break;
-    case 4:
-      __defConvert4(res, from, to);
-      break;
-  }
-  return res;
-};
-const __defConvert1 = (res, from, to) => {
-  res.toABGR = (col) => {
-    let out = res.alpha ? 0 : 4278190080;
-    out |= to(col, 0);
-    return out >>> 0;
-  };
-  res.fromABGR = (col, out = []) => {
-    out[0] = from(col, 0);
-    return out;
-  };
-};
-const __defConvert1Gray = (res) => {
-  res.toABGR = (col) => ((clamp01(col[0]) * 255 + 0.5 | 0) * 65793 | 4278190080) >>> 0;
-  res.fromABGR = (col, out = []) => (out[0] = __luminanceABGR(col) / 255, out);
-};
-const __defConvert2 = (res, from, to) => {
-  res.toABGR = (col) => {
-    let out = res.alpha ? 0 : 4278190080;
-    out |= to(col, 0);
-    out |= to(col, 1);
-    return out >>> 0;
-  };
-  res.fromABGR = (col, out = []) => {
-    out[0] = from(col, 0);
-    out[1] = from(col, 1);
-    return out;
-  };
-};
-const __defConvert2Gray = (res, from) => {
-  const gray = ~~(res.channels[0] === Lane.ALPHA);
-  const alpha = gray ^ 1;
-  res.toABGR = (col) => {
-    let out = (clamp01(col[gray]) * 255 + 0.5 | 0) * 65793;
-    out |= (col[alpha] * 255 + 0.5 | 0) << 24;
-    return out >>> 0;
-  };
-  res.fromABGR = (col, out = []) => {
-    out[gray] = __luminanceABGR(col) / 255;
-    out[alpha] = from(col, alpha);
-    return out;
-  };
-};
-const __defConvert3 = (res, from, to) => {
-  res.toABGR = (col) => {
-    let out = res.alpha ? 0 : 4278190080;
-    out |= to(col, 0);
-    out |= to(col, 1);
-    out |= to(col, 2);
-    return out >>> 0;
-  };
-  res.fromABGR = (col, out = []) => {
-    out[0] = from(col, 0);
-    out[1] = from(col, 1);
-    out[2] = from(col, 2);
-    return out;
-  };
-};
-const __defConvert4 = (res, from, to) => {
-  res.toABGR = (col) => {
-    let out = res.alpha ? 0 : 4278190080;
-    out |= to(col, 0);
-    out |= to(col, 1);
-    out |= to(col, 2);
-    out |= to(col, 3);
-    return out >>> 0;
-  };
-  res.fromABGR = (col, out = []) => {
-    out[0] = from(col, 0);
-    out[1] = from(col, 1);
-    out[2] = from(col, 2);
-    out[3] = from(col, 3);
-    return out;
-  };
-};
-const FLOAT_GRAY = defFloatFormat({
-  gray: true,
-  channels: [Lane.RED]
-});
-const GL2TYPE = {
-  [
-    5120
-    /* I8 */
-  ]: "i8",
-  [
-    5121
-    /* U8 */
-  ]: "u8",
-  [
-    5122
-    /* I16 */
-  ]: "i16",
-  [
-    5123
-    /* U16 */
-  ]: "u16",
-  [
-    5124
-    /* I32 */
-  ]: "i32",
-  [
-    5125
-    /* U32 */
-  ]: "u32",
-  [
-    5126
-    /* F32 */
-  ]: "f32"
-};
-const FLOAT_ARRAY_CTORS = {
-  f32: Float32Array,
-  f64: Float64Array
-};
-const INT_ARRAY_CTORS = {
-  i8: Int8Array,
-  i16: Int16Array,
-  i32: Int32Array
-};
-const UINT_ARRAY_CTORS = {
-  u8: Uint8Array,
-  u8c: Uint8ClampedArray,
-  u16: Uint16Array,
-  u32: Uint32Array
-};
-const BIGINT_ARRAY_CTORS = {
-  i64: BigInt64Array,
-  u64: BigUint64Array
-};
-const TYPEDARRAY_CTORS = {
-  ...FLOAT_ARRAY_CTORS,
-  ...INT_ARRAY_CTORS,
-  ...UINT_ARRAY_CTORS
-};
-const asNativeType = (type) => {
-  const t = GL2TYPE[type];
-  return t !== void 0 ? t : type;
-};
-function typedArray(type, ...args) {
-  const ctor = BIGINT_ARRAY_CTORS[type];
-  return new (ctor || TYPEDARRAY_CTORS[asNativeType(type)])(...args);
-}
-const uintTypeForBits = (x) => x > 16 ? "u32" : x > 8 ? "u16" : "u8";
-const __compileLShift = (x, shift) => shift > 0 ? `(${x} << ${shift})` : shift < 0 ? `(${x} >>> ${-shift})` : `${x}`;
-const __compileRShift = (x, shift) => __compileLShift(x, -shift);
-const __hex = (x) => `0x${x.toString(16)}`;
-const __compileGrayFromABGR = (size) => {
-  const shift = 8 - size;
-  const mask = (1 << size) - 1;
-  return new Function(
-    "luma",
-    `return (x) => ${__compileRShift("luma(x)", shift)} & ${mask};`
-  )(__luminanceABGR);
-};
-const __compileGrayToABGR = (size) => {
-  let body;
-  if (size !== 8) {
-    const mask = (1 << size) - 1;
-    const scale = 255 / mask;
-    body = `(((x & ${mask}) * ${scale}) | 0)`;
-  } else {
-    body = "x";
-  }
-  return new Function("x", `return 0xff000000 | (${body} * 0x010101);`);
-};
-const __compileFromABGR = (chans) => new Function(
-  "x",
-  "return (" + chans.map((ch) => {
-    const shift = ch.abgrShift + (8 - ch.size);
-    return `(${__compileRShift("x", shift)} & ${__hex(
-      ch.maskA
-    )})`;
-  }).join(" | ") + ") >>> 0;"
-);
-const __compileToABGR = (chans, hasAlpha) => {
-  const body = chans.map((ch) => {
-    if (ch.size !== 8) {
-      const mask = ch.mask0;
-      const scale = 255 / mask;
-      const inner = __compileRShift("x", ch.shift);
-      return __compileLShift(
-        `((${inner} & ${mask}) * ${scale})`,
-        24 - ch.lane * 8
-      );
-    } else {
-      return __compileLShift(
-        `(x & ${__hex(ch.maskA)})`,
-        ch.abgrShift
-      );
-    }
-  }).join(" | ");
-  const alpha = !hasAlpha ? `0xff000000 | ` : "";
-  return new Function("x", `return (${alpha}${body}) >>> 0;`);
-};
-const __defChannel = (ch, idx, shift) => {
-  const num = 1 << ch.size;
-  const mask0 = num - 1;
-  const maskA = mask0 << shift >>> 0;
-  const invMask = ~maskA >>> 0;
-  const lane = ch.lane != null ? ch.lane : idx;
-  const int = (x) => x >>> shift & mask0;
-  const setInt = (src, x) => src & invMask | (x & mask0) << shift;
-  return {
-    size: ch.size,
-    num,
-    abgrShift: 24 - lane * 8 - shift,
-    lane,
-    shift,
-    mask0,
-    maskA,
-    int,
-    setInt,
-    float: (x) => int(x) / mask0,
-    setFloat: (src, x) => setInt(src, clamp01(x) * mask0)
-  };
-};
-const defIntFormat = (fmt) => {
-  assert(fmt.channels.length > 0, "no channel specs given");
-  const channels = fmt.channels.reduce(
-    ([defs, shift], ch, i) => {
-      shift -= ch.size;
-      defs.push(__defChannel(ch, i, shift));
-      return [defs, shift];
-    },
-    [[], fmt.size]
-  )[0];
-  return {
-    __packed: true,
-    type: fmt.type,
-    size: fmt.size,
-    alpha: fmt.alpha || 0,
-    channels,
-    fromABGR: fmt.fromABGR || __compileFromABGR(channels),
-    toABGR: fmt.toABGR || __compileToABGR(channels, !!fmt.alpha)
-  };
-};
-const ABGR8888 = defIntFormat({
-  type: "u32",
-  size: 32,
-  alpha: 8,
-  channels: [
-    { size: 8, lane: Lane.ALPHA },
-    { size: 8, lane: Lane.BLUE },
-    { size: 8, lane: Lane.GREEN },
-    { size: 8, lane: Lane.RED }
-  ],
-  fromABGR: identity$1,
-  toABGR: identity$1
-});
-const PI = Math.PI;
-const TAU = PI * 2;
-const INV_TAU = 1 / TAU;
-let EPS = 1e-6;
-const mixBilinear = (a2, b2, c2, d2, u, v) => {
-  const iu = 1 - u;
-  const iv = 1 - v;
-  return a2 * iu * iv + b2 * u * iv + c2 * iu * v + d2 * u * v;
-};
-const mixCubicHermiteFromPoints = (a2, b2, c2, d2, t) => {
-  d2 *= 0.5;
-  const aa = -0.5 * a2 + 1.5 * b2 - 1.5 * c2 + d2;
-  const bb = a2 - 2.5 * b2 + 2 * c2 - d2;
-  const cc = -0.5 * a2 + 0.5 * c2;
-  const dd = b2;
-  const t2 = t * t;
-  return t * t2 * aa + t2 * bb + t * cc + dd;
-};
-const mixBicubic = (s00, s01, s02, s03, s10, s11, s12, s13, s20, s21, s22, s23, s30, s31, s32, s33, u, v) => mixCubicHermiteFromPoints(
-  mixCubicHermiteFromPoints(s00, s01, s02, s03, u),
-  mixCubicHermiteFromPoints(s10, s11, s12, s13, u),
-  mixCubicHermiteFromPoints(s20, s21, s22, s23, u),
-  mixCubicHermiteFromPoints(s30, s31, s32, s33, u),
-  v
-);
-const mod = (a2, b2) => a2 - b2 * Math.floor(a2 / b2);
-const fract = (x) => x - Math.floor(x);
-const roundTo = (x, prec = 1) => Math.round(x / prec) * prec;
-function defSampler(src, filter = "linear", wrap = "clamp") {
-  const isFloat = !!src.format.__float;
-  const suffix = src.format.channels.length === 1 ? "1" : "";
-  const id = `${filter[0]}${wrap[0]}${suffix}`;
-  const impl = (isFloat ? {
-    nc1: __sampleFNC,
-    nw1: __sampleFNW,
-    nr1: __sampleFNR,
-    nc: __sampleFNC,
-    nw: __sampleFNW,
-    nr: __sampleFNR,
-    lc1: (src2) => __bilinearGrayF(__sampleINC(src2)),
-    lw1: (src2) => __bilinearGrayF(__sampleINW(src2)),
-    lr1: (src2) => __bilinearGrayF(__sampleINR(src2)),
-    lc: (src2) => __bilinearFloat(src2, __sampleFNC(src2)),
-    lw: (src2) => __bilinearFloat(src2, __sampleFNW(src2)),
-    lr: (src2) => __bilinearFloat(src2, __sampleFNR(src2)),
-    cc1: (src2) => __bicubicGrayF(__sampleINC(src2)),
-    cw1: (src2) => __bicubicGrayF(__sampleINW(src2)),
-    cr1: (src2) => __bicubicGrayF(__sampleINR(src2)),
-    cc: (src2) => __bicubicFloat(src2, __sampleFNC(src2)),
-    cw: (src2) => __bicubicFloat(src2, __sampleFNW(src2)),
-    cr: (src2) => __bicubicFloat(src2, __sampleFNR(src2))
-  } : {
-    nc1: __sampleINC,
-    nw1: __sampleINW,
-    nr1: __sampleINR,
-    nc: __sampleINC,
-    nw: __sampleINW,
-    nr: __sampleINR,
-    lc1: (src2) => __bilinearGray(__sampleINC(src2)),
-    lw1: (src2) => __bilinearGray(__sampleINW(src2)),
-    lr1: (src2) => __bilinearGray(__sampleINR(src2)),
-    lc: (src2) => __bilinearABGR(src2, __sampleINC(src2)),
-    lw: (src2) => __bilinearABGR(src2, __sampleINW(src2)),
-    lr: (src2) => __bilinearABGR(src2, __sampleINR(src2)),
-    cc1: (src2) => __bicubicGrayI(src2, __sampleINC(src2)),
-    cw1: (src2) => __bicubicGrayI(src2, __sampleINW(src2)),
-    cr1: (src2) => __bicubicGrayI(src2, __sampleINR(src2)),
-    cc: (src2) => __bicubicABGR(src2, __sampleINC(src2)),
-    cw: (src2) => __bicubicABGR(src2, __sampleINW(src2)),
-    cr: (src2) => __bicubicABGR(src2, __sampleINR(src2))
-  })[id];
-  assert(!!impl, `missing impl for ${id}`);
-  return impl(src);
-}
-const __sampleINC = ({ data, width, height }) => (x, y) => x >= 0 && x < width && y >= 0 && y < height ? data[(y | 0) * width + (x | 0)] : 0;
-const __sampleINW = ({ data, width, height }) => (x, y) => data[mod(y | 0, height) * width + mod(x | 0, width)];
-const __sampleINR = ({ data, width, height }) => {
-  const w1 = width - 1;
-  const h1 = height - 1;
-  return (x, y) => data[clamp$1(y | 0, 0, h1) * width + clamp$1(x | 0, 0, w1)];
-};
-const __sampleFNC = ({
-  data,
-  width,
-  height,
-  stride: [stride, rowStride]
-}) => (x, y) => {
-  let i;
-  return x >= 0 && x < width && y >= 0 && y < height ? (i = (y | 0) * rowStride + (x | 0) * stride, data.slice(i, i + stride)) : [0];
-};
-const __sampleFNW = ({
-  data,
-  width,
-  height,
-  stride: [stride, rowStride]
-}) => (x, y) => {
-  let i = mod(y | 0, height) * rowStride + mod(x | 0, width) * stride;
-  return data.slice(i, i + stride);
-};
-const __sampleFNR = ({
-  data,
-  width,
-  height,
-  stride: [stride, rowStride]
-}) => {
-  const w1 = width - 1;
-  const h1 = height - 1;
-  return (x, y) => {
-    let i = clamp$1(y | 0, 0, h1) * rowStride + clamp$1(x | 0, 0, w1) * stride;
-    return data.slice(i, i + stride);
-  };
-};
-const __mixBilinearChan = (buf, u, v, i, s = 4) => mixBilinear(buf[i], buf[i + s], buf[i + 2 * s], buf[i + 3 * s], u, v);
-const __bilinearGray = (sample) => (x, y) => {
-  x -= 0.5;
-  y -= 0.5;
-  return mixBilinear(
-    sample(x, y),
-    sample(x + 1, y),
-    sample(x, y + 1),
-    sample(x + 1, y + 1),
-    fract(x),
-    fract(y)
-  );
-};
-const __bilinearGrayF = (sample) => {
-  sample = __bilinearGray(sample);
-  return (x, y) => [sample(x, y)];
-};
-const __bilinearABGR = (src, sample1) => {
-  const { fromABGR, toABGR } = src.format;
-  const u32 = new Uint32Array(4);
-  const u8 = new Uint8Array(u32.buffer);
-  return (x, y) => {
-    x -= 0.5;
-    y -= 0.5;
-    u32[0] = toABGR(sample1(x, y));
-    u32[1] = toABGR(sample1(x + 1, y));
-    u32[2] = toABGR(sample1(x, y + 1));
-    u32[3] = toABGR(sample1(x + 1, y + 1));
-    const u = fract(x);
-    const v = fract(y);
-    return fromABGR(
-      __mixBilinearChan(u8, u, v, 0) | __mixBilinearChan(u8, u, v, 1) << 8 | __mixBilinearChan(u8, u, v, 2) << 16 | __mixBilinearChan(u8, u, v, 3) << 24
-    ) >>> 0;
-  };
-};
-const __bilinearFloat = ({ stride: [stride] }, sample1) => {
-  const f32 = new Float32Array(stride * 4);
-  return (x, y) => {
-    x -= 0.5;
-    y -= 0.5;
-    f32.set(sample1(x, y), 0);
-    f32.set(sample1(x + 1, y), stride);
-    f32.set(sample1(x, y + 1), stride * 2);
-    f32.set(sample1(x + 1, y + 1), stride * 3);
-    const u = fract(x);
-    const v = fract(y);
-    let res = [];
-    for (let i = 0; i < stride; i++) {
-      res.push(__mixBilinearChan(f32, u, v, i, stride));
-    }
-    return res;
-  };
-};
-const __bicubicGray = (sample) => (x, y) => {
-  x -= 0.5;
-  y -= 0.5;
-  const x1 = x - 1;
-  const x2 = x + 1;
-  const x3 = x + 2;
-  const y1 = y - 1;
-  const y2 = y + 1;
-  const y3 = y + 2;
-  return mixBicubic(
-    sample(x1, y1),
-    sample(x, y1),
-    sample(x2, y1),
-    sample(x3, y1),
-    sample(x1, y),
-    sample(x, y),
-    sample(x2, y),
-    sample(x3, y),
-    sample(x1, y2),
-    sample(x, y2),
-    sample(x2, y2),
-    sample(x3, y2),
-    sample(x1, y3),
-    sample(x, y3),
-    sample(x2, y3),
-    sample(x3, y3),
-    fract(x),
-    fract(y)
-  );
-};
-const __bicubicGrayI = (src, sample) => {
-  const max2 = src.format.channels[0].mask0;
-  sample = __bicubicGray(sample);
-  return (x, y) => clamp$1(sample(x, y), 0, max2);
-};
-const __bicubicGrayF = (sample) => {
-  sample = __bicubicGray(sample);
-  return (x, y) => [sample(x, y)];
-};
-const __mixBicubicChan = (buf, u, v, i, s = 4) => mixBicubic(
-  buf[i],
-  buf[i + s],
-  buf[i + 2 * s],
-  buf[i + 3 * s],
-  buf[i + 4 * s],
-  buf[i + 5 * s],
-  buf[i + 6 * s],
-  buf[i + 7 * s],
-  buf[i + 8 * s],
-  buf[i + 9 * s],
-  buf[i + 10 * s],
-  buf[i + 11 * s],
-  buf[i + 12 * s],
-  buf[i + 13 * s],
-  buf[i + 14 * s],
-  buf[i + 15 * s],
-  u,
-  v
-);
-const __mixBicubicChanClamped = (buf, u, v, i, s = 4) => clamp$1(__mixBicubicChan(buf, u, v, i, s), 0, 255);
-const __bicubicABGR = (src, sample) => {
-  const { fromABGR, toABGR } = src.format;
-  const u32 = new Uint32Array(16);
-  const u8 = new Uint8Array(u32.buffer);
-  return (x, y) => {
-    x -= 0.5;
-    y -= 0.5;
-    const x1 = x - 1;
-    const x2 = x + 1;
-    const x3 = x + 2;
-    const y1 = y - 1;
-    const y2 = y + 1;
-    const y3 = y + 2;
-    const u = fract(x);
-    const v = fract(y);
-    u32[0] = toABGR(sample(x1, y1));
-    u32[1] = toABGR(sample(x, y1));
-    u32[2] = toABGR(sample(x2, y1));
-    u32[3] = toABGR(sample(x3, y1));
-    u32[4] = toABGR(sample(x1, y));
-    u32[5] = toABGR(sample(x, y));
-    u32[6] = toABGR(sample(x2, y));
-    u32[7] = toABGR(sample(x3, y));
-    u32[8] = toABGR(sample(x1, y2));
-    u32[9] = toABGR(sample(x, y2));
-    u32[10] = toABGR(sample(x2, y2));
-    u32[11] = toABGR(sample(x3, y2));
-    u32[12] = toABGR(sample(x1, y3));
-    u32[13] = toABGR(sample(x, y3));
-    u32[14] = toABGR(sample(x2, y3));
-    u32[15] = toABGR(sample(x3, y3));
-    return fromABGR(
-      __mixBicubicChanClamped(u8, u, v, 0) | __mixBicubicChanClamped(u8, u, v, 1) << 8 | __mixBicubicChanClamped(u8, u, v, 2) << 16 | __mixBicubicChanClamped(u8, u, v, 3) << 24
-    ) >>> 0;
-  };
-};
-const __bicubicFloat = ({ stride: [stride] }, sample) => {
-  const f32 = new Float32Array(stride * 16);
-  return (x, y) => {
-    x -= 0.5;
-    y -= 0.5;
-    const x1 = x - 1;
-    const x2 = x + 1;
-    const x3 = x + 2;
-    const y1 = y - 1;
-    const y2 = y + 1;
-    const y3 = y + 2;
-    const u = fract(x);
-    const v = fract(y);
-    f32.set(sample(x1, y1), 0);
-    f32.set(sample(x, y1), stride);
-    f32.set(sample(x2, y1), 2 * stride);
-    f32.set(sample(x3, y1), 3 * stride);
-    f32.set(sample(x1, y), 4 * stride);
-    f32.set(sample(x, y), 5 * stride);
-    f32.set(sample(x2, y), 6 * stride);
-    f32.set(sample(x3, y), 7 * stride);
-    f32.set(sample(x1, y2), 8 * stride);
-    f32.set(sample(x, y2), 9 * stride);
-    f32.set(sample(x2, y2), 10 * stride);
-    f32.set(sample(x3, y2), 11 * stride);
-    f32.set(sample(x1, y3), 12 * stride);
-    f32.set(sample(x, y3), 13 * stride);
-    f32.set(sample(x2, y3), 14 * stride);
-    f32.set(sample(x3, y3), 15 * stride);
-    let res = [];
-    for (let i = 0; i < stride; i++) {
-      res.push(__mixBicubicChan(f32, u, v, i, stride));
-    }
-    return res;
-  };
-};
-var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
-var __decorateClass$1 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = decorator(result) || result;
-  return result;
-};
-function intBuffer(...args) {
-  return args[0] instanceof IntBuffer ? args[0].as(args[1]) : (
-    // @ts-ignore
-    new IntBuffer(...args)
-  );
-}
-const intBufferFromCanvas = (canvas, fmt = ABGR8888) => {
-  const { data } = canvasPixels(canvas);
-  const w = canvas.width;
-  const h = canvas.height;
-  let dest;
-  if (fmt === ABGR8888) {
-    dest = data;
-  } else {
-    dest = typedArray(fmt.type, w * h);
-    const src = data;
-    const from = fmt.fromABGR;
-    for (let i = dest.length; i-- > 0; ) {
-      dest[i] = from(src[i]);
-    }
-  }
-  return new IntBuffer(w, h, fmt, dest);
-};
-let IntBuffer = class {
-  size;
-  stride;
-  format;
-  data;
-  constructor(w, h, fmt = ABGR8888, data) {
-    this.size = [w, h];
-    this.stride = [1, w];
-    this.format = fmt.__packed ? fmt : defIntFormat(fmt);
-    this.data = data || typedArray(fmt.type, w * h);
-  }
-  /** @deprecated use `.data` instead */
-  get pixels() {
-    return this.data;
-  }
-  get width() {
-    return this.size[0];
-  }
-  get height() {
-    return this.size[1];
-  }
-  // TODO support custom offsets (via ctor arg)
-  get offset() {
-    return 0;
-  }
-  get dim() {
-    return 2;
-  }
-  *[Symbol.iterator]() {
-    yield* this.data;
-  }
-  as(fmt) {
-    if (!fmt.__float)
-      return this.getRegion(
-        0,
-        0,
-        this.width,
-        this.height,
-        fmt
-      );
-    const dest = new FloatBuffer(this.width, this.height, fmt);
-    const {
-      data: dbuf,
-      format: dfmt,
-      stride: [stride]
-    } = dest;
-    const { data: sbuf, format: sfmt } = this;
-    for (let i = sbuf.length; i-- > 0; ) {
-      dbuf.set(dfmt.fromABGR(sfmt.toABGR(sbuf[i])), i * stride);
-    }
-    return dest;
-  }
-  copy() {
-    const dest = this.empty();
-    dest.data.set(this.data);
-    return dest;
-  }
-  empty() {
-    return new IntBuffer(this.width, this.height, this.format);
-  }
-  // @ts-ignore mixin
-  order() {
-  }
-  // @ts-ignore mixin
-  includes(x, y) {
-  }
-  // @ts-ignore mixin
-  indexAt(x, y) {
-  }
-  // @ts-ignore mixin
-  indexAtUnsafe(x, y) {
-  }
-  // @ts-ignore mixin
-  getAt(x, y) {
-  }
-  // @ts-ignore mixin
-  getAtUnsafe(x, y) {
-  }
-  // @ts-ignore mixin
-  setAt(x, y, col) {
-  }
-  // @ts-ignore mixin
-  setAtUnsafe(x, y, col) {
-  }
-  getChannelAt(x, y, id, normalized = false) {
-    const chan = ensureChannel(this.format, id);
-    const col = this.getAt(x, y);
-    return normalized ? chan.float(col) : chan.int(col);
-  }
-  setChannelAt(x, y, id, col, normalized = false) {
-    const chan = ensureChannel(this.format, id);
-    const src = this.getAt(x, y);
-    normalized ? chan.setFloat(src, col) : chan.setInt(src, col);
-    return this;
-  }
-  blend(op, dest, opts) {
-    let sw = this.width;
-    let dw = dest.width;
-    const { sx, sy, dx, dy, rw, rh } = __prepRegions(this, dest, opts);
-    if (rw < 1 || rh < 1) return dest;
-    const sbuf = this.data;
-    const dbuf = dest.data;
-    const sf = this.format.toABGR;
-    const df1 = dest.format.toABGR;
-    const df2 = dest.format.fromABGR;
-    for (let si = (sx | 0) + (sy | 0) * sw, di = (dx | 0) + (dy | 0) * dw, yy = 0; yy < rh; yy++, si += sw, di += dw) {
-      for (let xx = 0; xx < rw; xx++) {
-        dbuf[di + xx] = df2(op(sf(sbuf[si + xx]), df1(dbuf[di + xx])));
-      }
-    }
-    return dest;
-  }
-  blit(dest, opts) {
-    let sw = this.width;
-    let dw = dest.width;
-    const { sx, sy, dx, dy, rw, rh } = __prepRegions(this, dest, opts);
-    if (rw < 1 || rh < 1) return dest;
-    const sbuf = this.data;
-    const dbuf = dest.data;
-    const sf = this.format.toABGR;
-    const df = dest.format.fromABGR;
-    const blitRow = this.format !== dest.format ? (si, di) => {
-      for (let xx = 0; xx < rw; xx++) {
-        dbuf[di + xx] = df(sf(sbuf[si + xx]));
-      }
-    } : (si, di) => dbuf.set(sbuf.subarray(si, si + rw), di);
-    for (let si = (sx | 0) + (sy | 0) * sw, di = (dx | 0) + (dy | 0) * dw, yy = 0; yy < rh; yy++, si += sw, di += dw) {
-      blitRow(si, di);
-    }
-    return dest;
-  }
-  blitCanvas(canvas, opts = {}) {
-    __blitCanvas(this, canvas, opts);
-  }
-  setImageData(idata) {
-    ensureImageDataSize(idata, this.width, this.height);
-    const src = new Uint32Array(idata.data.buffer);
-    const dest = this.data;
-    const fmt = this.format.fromABGR;
-    for (let i = src.length; i-- > 0; ) {
-      dest[i] = fmt(src[i]);
-    }
-    return this;
-  }
-  toImageData(idata) {
-    idata = ensureImageData(idata, this.width, this.height);
-    const dest = new Uint32Array(idata.data.buffer);
-    const src = this.data;
-    const fmt = this.format.toABGR;
-    for (let i = dest.length; i-- > 0; ) {
-      dest[i] = fmt(src[i]);
-    }
-    return idata;
-  }
-  getRegion(x, y, width, height, fmt) {
-    const [sx, sy, w, h] = __clampRegion(
-      x,
-      y,
-      width,
-      height,
-      this.width,
-      this.height
-    );
-    if (w < 1 || h < 1) return;
-    return this.blit(new IntBuffer(w, h, fmt || this.format), {
-      sx,
-      sy,
-      w,
-      h
-    });
-  }
-  getChannel(id) {
-    const chan = ensureChannel(this.format, id);
-    const buf = new IntBuffer(this.width, this.height, {
-      type: uintTypeForBits(chan.size),
-      size: chan.size,
-      channels: [{ size: chan.size, lane: Lane.RED }],
-      fromABGR: __compileGrayFromABGR(chan.size),
-      toABGR: __compileGrayToABGR(chan.size)
-    });
-    const src = this.data;
-    const dest = buf.data;
-    const get = chan.int;
-    for (let i = src.length; i-- > 0; ) {
-      dest[i] = get(src[i]);
-    }
-    return buf;
-  }
-  setChannel(id, src) {
-    const chan = ensureChannel(this.format, id);
-    const dbuf = this.data;
-    const set5 = chan.setInt;
-    if (isNumber(src)) {
-      __setChannelUni(dbuf, src, set5);
-    } else {
-      const sbuf = src.data;
-      const schan = src.format.channels[0];
-      ensureSize(sbuf, this.width, this.height);
-      if (chan.size === schan.size) {
-        __setChannelSame(dbuf, sbuf, schan.int, set5);
-      } else {
-        __setChannelConvert(
-          dbuf,
-          sbuf,
-          this.format.fromABGR,
-          src.format.toABGR,
-          chan.maskA
-        );
-      }
-    }
-    return this;
-  }
-  invert() {
-    const { data, format } = this;
-    const mask = Math.pow(2, format.size - format.alpha) - 1;
-    for (let i = data.length; i-- > 0; ) {
-      data[i] ^= mask;
-    }
-    return this;
-  }
-  premultiply() {
-    ensureAlpha(this.format);
-    __transformABGR(this.data, this.format, premultiplyInt);
-    return this;
-  }
-  postmultiply() {
-    __transformABGR(this.data, this.format, postmultiplyInt);
-    return this;
-  }
-  isPremultiplied() {
-    const pix = this.data;
-    const to = this.format.toABGR;
-    for (let i = pix.length; i-- > 0; ) {
-      if (!isPremultipliedInt(to(pix[i]))) {
-        return false;
-      }
-    }
-    return true;
-  }
-  forEach(f) {
-    const pix = this.data;
-    for (let i = pix.length; i-- > 0; ) {
-      pix[i] = f(pix[i], i);
-    }
-    return this;
-  }
-  fill(x) {
-    this.data.fill(x);
-  }
-  /**
-   * Flips image horizontally.
-   */
-  flipX() {
-    const { data, width } = this;
-    for (let i = 0; i < data.length; i += width) {
-      data.subarray(i, i + width).reverse();
-    }
-    return this;
-  }
-  /**
-   * Flips image vertically.
-   */
-  flipY() {
-    const { data, width } = this;
-    const tmp = typedArray(this.format.type, width);
-    for (let i = 0, j = data.length - width; i < j; i += width, j -= width) {
-      tmp.set(data.subarray(i, i + width));
-      data.copyWithin(i, j, j + width);
-      data.set(tmp, j);
-    }
-    return this;
-  }
-  rotateByID(id) {
-    return id > 0 ? this[ROT_IDS[id - 1]]() : this;
-  }
-  rotateCW() {
-    const { width, height } = this;
-    const h1 = height - 1;
-    this._rotate((x, y) => x * height + h1 - y);
-    this.size[0] = height;
-    this.size[1] = width;
-    return this;
-  }
-  rotateCCW() {
-    const { width, height } = this;
-    const w1 = width - 1;
-    this._rotate((x, y) => (w1 - x) * height + y);
-    this.size[0] = height;
-    this.size[1] = width;
-    return this;
-  }
-  rotate180() {
-    const { width, height } = this;
-    const w1 = width - 1;
-    const h1 = height - 1;
-    this._rotate((x, y) => (h1 - y) * width + w1 - x);
-    return this;
-  }
-  /**
-   * Returns scaled version of this buffer using given sampler or filter
-   * (default: `"linear"`) for interpolation. Syntax sugar for
-   * {@link IntBuffer.resize}.
-   *
-   * @param scale -
-   */
-  scale(scale, sampler = "linear") {
-    assert(scale > 0, `scale must be > 0`);
-    return this.resize(this.width * scale, this.height * scale, sampler);
-  }
-  resize(w, h, sampler = "linear") {
-    w |= 0;
-    h |= 0;
-    assert(w > 0 && h > 0, `target width & height must be > 0`);
-    const dest = intBuffer(w, h, this.format);
-    const dpix = dest.data;
-    const scaleX = w > 0 ? this.width / w : 0;
-    const scaleY = h > 0 ? this.height / h : 0;
-    sampler = isString(sampler) ? defSampler(this, sampler, "repeat") : sampler;
-    for (let y = 0, i = 0; y < h; y++) {
-      const yy = y * scaleY;
-      for (let x = 0; x < w; x++, i++) {
-        dpix[i] = sampler(x * scaleX, yy);
-      }
-    }
-    return dest;
-  }
-  upsize() {
-    const { width, height, data } = this;
-    const dest = new IntBuffer(width * 2, height * 2, this.format);
-    const dpix = dest.data;
-    for (let y = 0, si = 0; y < height; y++) {
-      for (let x = 0, di = y * width * 4; x < width; x++, si++, di += 2) {
-        dpix[di] = data[si];
-      }
-    }
-    return dest;
-  }
-  _rotate(idxFn) {
-    const { data, format, width, height } = this;
-    const tmp = typedArray(format.type, width * height);
-    for (let y = 0; y < height; y++) {
-      for (let x = 0; x < width; x++) {
-        tmp[idxFn(x, y)] = data[y * width + x];
-      }
-    }
-    this.data = tmp;
-  }
-};
-IntBuffer = __decorateClass$1([
-  IGrid2DMixin
-], IntBuffer);
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-function floatBuffer(...args) {
-  return args[0] instanceof IntBuffer ? (
-    // @ts-ignore
-    floatBufferFromInt(...args)
-  ) : (
-    // @ts-ignore
-    new FloatBuffer(...args)
-  );
-}
-const floatBufferFromInt = (src, fmt) => {
-  const dest = new FloatBuffer(src.width, src.height, fmt);
-  const {
-    data: dbuf,
-    format: dfmt,
-    stride: [stride]
-  } = dest;
-  const { data: sbuf, format: sfmt } = src;
-  for (let i = sbuf.length; i-- > 0; ) {
-    dbuf.set(dfmt.fromABGR(sfmt.toABGR(sbuf[i])), i * stride);
-  }
-  return dest;
-};
-const floatBufferFromCanvas = (canvas, fmt = FLOAT_RGBA) => intBufferFromCanvas(canvas).as(fmt);
-let FloatBuffer = class {
-  size;
-  stride;
-  format;
-  data;
-  __empty;
-  constructor(w, h, fmt = FLOAT_RGBA, data) {
-    this.size = [w, h];
-    this.format = fmt.__float ? fmt : defFloatFormat(fmt);
-    const stride = this.format.channels.length;
-    this.stride = [stride, w * stride];
-    this.data = data || new Float32Array(w * h * stride);
-    this.__empty = Object.freeze(new Array(stride).fill(0));
-  }
-  /** @deprecated use `.data` instead */
-  get pixels() {
-    return this.data;
-  }
-  get width() {
-    return this.size[0];
-  }
-  get height() {
-    return this.size[1];
-  }
-  // TODO support custom offsets (via ctor arg)
-  get offset() {
-    return 0;
-  }
-  get dim() {
-    return 2;
-  }
-  *[Symbol.iterator]() {
-    const {
-      data,
-      stride: [stride]
-    } = this;
-    for (let i = 0, n = data.length; i < n; i += stride) {
-      yield data.subarray(i, i + stride);
-    }
-  }
-  as(fmt) {
-    const {
-      width,
-      height,
-      stride: [stride],
-      data,
-      format: { size, normalized: getNormalized, toABGR }
-    } = this;
-    let i = 0, j = 0, n = data.length;
-    if (fmt.__float) {
-      const $fmt = fmt;
-      const dest = new FloatBuffer(width, height, $fmt);
-      const {
-        data: dpixels,
-        stride: [dstride]
-      } = dest;
-      if (size === 1 && $fmt.channels.length === 1) {
-        const setNormalized = $fmt.fromNormalized;
-        for (; i < n; i += stride, j += dstride) {
-          dpixels[j] = setNormalized(getNormalized(data[i]));
-        }
-      } else {
-        for (; i < n; i += stride, j += dstride) {
-          dpixels.set(
-            $fmt.fromABGR(toABGR(data.subarray(i, i + stride))),
-            j
-          );
-        }
-      }
-      return dest;
-    } else {
-      const $fmt = fmt;
-      const dest = new IntBuffer(width, height, $fmt);
-      const dpixels = dest.data;
-      if (size === 1 && $fmt.channels.length === 1) {
-        const setFloat = $fmt.channels[0].setFloat;
-        for (; i < n; i += stride, j++) {
-          dpixels[j] = setFloat(0, getNormalized(data[i]));
-        }
-      } else {
-        for (; i < n; i += stride, j++) {
-          dpixels[j] = $fmt.fromABGR(
-            toABGR(data.subarray(i, i + stride))
-          );
-        }
-      }
-      return dest;
-    }
-  }
-  copy() {
-    const dest = this.empty();
-    dest.data.set(this.data);
-    return dest;
-  }
-  empty() {
-    return new FloatBuffer(this.width, this.height, this.format);
-  }
-  // @ts-ignore mixin
-  order() {
-  }
-  // @ts-ignore mixin
-  includes(x, y) {
-  }
-  // @ts-ignore mixin
-  indexAt(x, y) {
-  }
-  // @ts-ignore mixin
-  indexAtUnsafe(x, y) {
-  }
-  getAt(x, y) {
-    return this.includes(x, y) ? this.getAtUnsafe(x, y) : this.__empty;
-  }
-  getAtUnsafe(x, y) {
-    const idx = this.indexAtUnsafe(x, y);
-    return this.data.subarray(idx, idx + this.stride[0]);
-  }
-  setAt(x, y, col) {
-    return this.includes(x, y) ? (this.data.set(col, this.indexAtUnsafe(x, y)), true) : false;
-  }
-  setAtUnsafe(x, y, col) {
-    this.data.set(col, this.indexAtUnsafe(x, y));
-    return true;
-  }
-  getChannelAt(x, y, id) {
-    ensureChannel(this.format, id);
-    return this.includes(x, y) ? this.data[this.indexAtUnsafe(x, y) + id] : void 0;
-  }
-  setChannelAt(x, y, id, col) {
-    ensureChannel(this.format, id);
-    this.includes(x, y) && (this.data[this.indexAtUnsafe(x, y) + id] = col);
-    return this;
-  }
-  getChannel(id) {
-    ensureChannel(this.format, id);
-    const {
-      data,
-      stride: [stride]
-    } = this;
-    const [min2, max2] = this.format.range;
-    const dest = new Float32Array(this.width * this.height);
-    for (let i = id, j = 0, n = data.length; i < n; i += stride, j++) {
-      dest[j] = clamp$1(data[i], min2, max2);
-    }
-    return new FloatBuffer(this.width, this.height, FLOAT_GRAY, dest);
-  }
-  setChannel(id, src) {
-    ensureChannel(this.format, id);
-    const {
-      data: dest,
-      stride: [stride]
-    } = this;
-    if (isNumber(src)) {
-      for (let i = id, n = dest.length; i < n; i += stride) {
-        dest[i] = src;
-      }
-    } else {
-      const {
-        data: sbuf,
-        stride: [sstride]
-      } = src;
-      ensureSize(sbuf, this.width, this.height, sstride);
-      for (let i = id, j = 0, n = dest.length; i < n; i += stride, j += sstride) {
-        dest[i] = sbuf[j];
-      }
-    }
-    return this;
-  }
-  blend(op, dest, opts) {
-    this.ensureFormat(dest);
-    const { sx, sy, dx, dy, rw, rh } = __prepRegions(this, dest, opts);
-    if (rw < 1 || rh < 1) return dest;
-    const sbuf = this.data;
-    const dbuf = dest.data;
-    const [stride, sw] = this.stride;
-    const dw = dest.stride[1];
-    for (let si = (sx | 0) * stride + (sy | 0) * sw, di = (dx | 0) * stride + (dy | 0) * dw, yy = 0; yy < rh; yy++, si += sw, di += dw) {
-      for (let xx = rw, sii = si, dii = di; xx-- > 0; sii += stride, dii += stride) {
-        const out = dbuf.subarray(dii, dii + stride);
-        op(out, sbuf.subarray(sii, sii + stride), out);
-      }
-    }
-    return dest;
-  }
-  blit(dest, opts) {
-    this.ensureFormat(dest);
-    const { sx, sy, dx, dy, rw, rh } = __prepRegions(this, dest, opts);
-    if (rw < 1 || rh < 1) return dest;
-    const sbuf = this.data;
-    const dbuf = dest.data;
-    const [stride, sw] = this.stride;
-    const dw = dest.stride[1];
-    const rww = rw * stride;
-    for (let si = (sx | 0) * stride + (sy | 0) * sw, di = (dx | 0) * stride + (dy | 0) * dw, yy = 0; yy < rh; yy++, si += sw, di += dw) {
-      dbuf.set(sbuf.subarray(si, si + rww), di);
-    }
-    return dest;
-  }
-  blitCanvas(canvas, opts = {}) {
-    __blitCanvas(this, canvas, opts);
-  }
-  setImageData(idata) {
-    ensureImageDataSize(idata, this.width, this.height);
-    const src = new Uint32Array(idata.data.buffer);
-    const {
-      data: dest,
-      format: { fromABGR },
-      stride: [stride]
-    } = this;
-    const tmp = [];
-    for (let i = src.length; i-- > 0; ) {
-      dest.set(fromABGR(src[i], tmp), i * stride);
-    }
-    return this;
-  }
-  toImageData(idata) {
-    idata = ensureImageData(idata, this.width, this.height);
-    const dest = new Uint32Array(idata.data.buffer);
-    const {
-      stride: [stride],
-      data,
-      format
-    } = this;
-    for (let i = 0, j = 0, n = data.length; i < n; i += stride, j++) {
-      dest[j] = format.toABGR(data.subarray(i, i + stride));
-    }
-    return idata;
-  }
-  getRegion(x, y, width, height) {
-    const [sx, sy, w, h] = __clampRegion(
-      x,
-      y,
-      width,
-      height,
-      this.width,
-      this.height
-    );
-    if (w < 1 || h < 1) return;
-    return this.blit(new FloatBuffer(w, h, this.format), {
-      sx,
-      sy,
-      w,
-      h
-    });
-  }
-  forEach(f) {
-    const {
-      data,
-      stride: [stride]
-    } = this;
-    for (let i = 0, j = 0, n = data.length; i < n; i += stride, j++) {
-      data.set(f(data.subarray(i, i + stride), j), i);
-    }
-    return this;
-  }
-  fill(x) {
-    assert(
-      x.length <= this.format.channels.length,
-      `fill value has too many channels`
-    );
-    const {
-      data,
-      stride: [stride]
-    } = this;
-    for (let i = 0, n = data.length; i < n; i += stride) {
-      data.set(x, i);
-    }
-  }
-  premultiply() {
-    this.ensureRGBA();
-    const {
-      data,
-      stride: [stride]
-    } = this;
-    for (let i = 0, n = data.length; i < n; i += stride) {
-      premultiply(null, data.subarray(i, i + stride));
-    }
-    return this;
-  }
-  postmultiply() {
-    this.ensureRGBA();
-    const {
-      data,
-      stride: [stride]
-    } = this;
-    for (let i = 0, n = data.length; i < n; i += stride) {
-      postmultiply(null, data.subarray(i, i + stride));
-    }
-    return this;
-  }
-  isPremultiplied() {
-    this.ensureRGBA();
-    const {
-      data,
-      stride: [stride]
-    } = this;
-    for (let i = 0, n = data.length; i < n; i += stride) {
-      if (!isPremultiplied(data.subarray(i, i + stride))) {
-        return false;
-      }
-    }
-    return true;
-  }
-  clamp() {
-    const data = this.data;
-    const [min2, max2] = this.format.range;
-    for (let i = data.length; i-- > 0; ) {
-      data[i] = clamp$1(data[i], min2, max2);
-    }
-    return this;
-  }
-  clampChannel(id) {
-    ensureChannel(this.format, id);
-    const {
-      data,
-      stride: [stride]
-    } = this;
-    const [min2, max2] = this.format.range;
-    for (let i = id, n = data.length; i < n; i += stride) {
-      data[i] = clamp$1(data[i], min2, max2);
-    }
-  }
-  flipX() {
-    const {
-      data,
-      width,
-      height,
-      stride: [sx, sy]
-    } = this;
-    const tmp = new Float32Array(sx);
-    const w1 = width - 1;
-    const w2 = width >>> 1;
-    for (let y = 0; y < height; y++) {
-      for (let x = 0, i = y * sy, j = i + w1 * sx; x < w2; x++, i += sx, j -= sx) {
-        tmp.set(data.subarray(i, i + sx));
-        data.copyWithin(i, j, j + sx);
-        data.set(tmp, j);
-      }
-    }
-    return this;
-  }
-  /**
-   * Flips image vertically.
-   */
-  flipY() {
-    const data = this.data;
-    const rowStride = this.stride[1];
-    const tmp = new Float32Array(rowStride);
-    for (let i = 0, j = data.length - rowStride; i < j; i += rowStride, j -= rowStride) {
-      tmp.set(data.subarray(i, i + rowStride));
-      data.copyWithin(i, j, j + rowStride);
-      data.set(tmp, j);
-    }
-    return this;
-  }
-  rotateByID(id) {
-    return id > 0 ? this[ROT_IDS[id - 1]]() : this;
-  }
-  rotateCW() {
-    const { width, height } = this;
-    const h1 = height - 1;
-    this._rotate((x, y) => x * height + h1 - y);
-    this.size[0] = height;
-    this.size[1] = width;
-    return this;
-  }
-  rotateCCW() {
-    const { width, height } = this;
-    const w1 = width - 1;
-    this._rotate((x, y) => (w1 - x) * height + y);
-    this.size[0] = height;
-    this.size[1] = width;
-    return this;
-  }
-  rotate180() {
-    const { width, height } = this;
-    const w1 = width - 1;
-    const h1 = height - 1;
-    this._rotate((x, y) => (h1 - y) * width + w1 - x);
-    return this;
-  }
-  invert() {
-    const {
-      data,
-      format,
-      stride: [stride]
-    } = this;
-    for (let i = 0, n = data.length, m = format.alpha ? stride - 1 : stride; i < n; i += stride) {
-      for (let j = 0; j < m; j++) data[i + j] = 1 - data[i + j];
-    }
-    return this;
-  }
-  scale(scale, sampler) {
-    assert(scale > 0, `scale must be > 0`);
-    return this.resize(this.width * scale, this.height * scale, sampler);
-  }
-  resize(w, h, sampler = "linear") {
-    w |= 0;
-    h |= 0;
-    assert(w > 0 && h > 0, `target width & height must be > 0`);
-    const dest = floatBuffer(w, h, this.format);
-    const dpix = dest.data;
-    const scaleX = w > 0 ? this.width / w : 0;
-    const scaleY = h > 0 ? this.height / h : 0;
-    const stride = this.stride[0];
-    sampler = isString(sampler) ? defSampler(this, sampler, "repeat") : sampler;
-    for (let y = 0, i = 0; y < h; y++) {
-      const yy = y * scaleY;
-      for (let x = 0; x < w; x++, i += stride) {
-        dpix.set(sampler(x * scaleX, yy), i);
-      }
-    }
-    return dest;
-  }
-  upsize() {
-    const {
-      width,
-      height,
-      data,
-      stride: [stride, rowStride]
-    } = this;
-    const stride2x = stride * 2;
-    const dest = floatBuffer(width * 2, height * 2, this.format);
-    const dpix = dest.data;
-    for (let y = 0, si = 0; y < height; y++) {
-      for (let x = 0, di = y * rowStride * 4; x < width; x++, si += stride, di += stride2x) {
-        dpix.set(data.subarray(si, si + stride), di);
-      }
-    }
-    return dest;
-  }
-  _rotate(idxFn) {
-    const {
-      data,
-      width,
-      height,
-      stride: [stride]
-    } = this;
-    const tmp = new Float32Array(width * height * stride);
-    for (let y = 0, i = 0; y < height; y++) {
-      for (let x = 0; x < width; x++, i += stride) {
-        tmp.set(data.subarray(i, i + stride), idxFn(x, y) * stride);
-      }
-    }
-    this.data = tmp;
-  }
-  ensureFormat(dest) {
-    assert(
-      dest.format === this.format,
-      `dest buffer format must be same as src`
-    );
-  }
-  ensureRGBA() {
-    assert(this.format === FLOAT_RGBA, "require FLOAT_RGBA format");
-  }
-};
-__decorateClass([
-  nomixin
-], FloatBuffer.prototype, "getAt", 1);
-__decorateClass([
-  nomixin
-], FloatBuffer.prototype, "getAtUnsafe", 1);
-__decorateClass([
-  nomixin
-], FloatBuffer.prototype, "setAt", 1);
-__decorateClass([
-  nomixin
-], FloatBuffer.prototype, "setAtUnsafe", 1);
-FloatBuffer = __decorateClass([
-  IGrid2DMixin
-], FloatBuffer);
-const norm = (x, a2, b2) => (x - a2) / (b2 - a2);
-const fit = (x, a2, b2, c2, d2) => c2 + (d2 - c2) * norm(x, a2, b2);
-const abs$1 = Math.abs;
-const min = Math.min;
-const FLOAT_HSVA = defFloatFormat({
-  alpha: true,
-  channels: [Lane.RED, Lane.GREEN, Lane.BLUE, Lane.ALPHA],
-  convert: {
-    fromABGR: (x, out = []) => {
-      const a2 = (x >>> 24 & 255) / 255;
-      const b2 = (x >>> 16 & 255) / 255;
-      const g = (x >>> 8 & 255) / 255;
-      const r = (x & 255) / 255;
-      let p0, p1, p2, p3;
-      let q0, q1, q2, q3;
-      if (g < b2) {
-        p0 = b2;
-        p1 = g;
-        p2 = -1;
-        p3 = 2 / 3;
-      } else {
-        p0 = g;
-        p1 = b2;
-        p2 = 0;
-        p3 = -1 / 3;
-      }
-      if (r < p0) {
-        q0 = p0;
-        q1 = p1;
-        q2 = p3;
-        q3 = r;
-      } else {
-        q0 = r;
-        q1 = p1;
-        q2 = p2;
-        q3 = p0;
-      }
-      const c2 = q0 - min(q1, q3);
-      q0 = clamp01(q0);
-      out[0] = clamp01(abs$1((q3 - q1) / (6 * c2 + EPS) + q2));
-      out[1] = clamp01(c2 / (q0 + EPS));
-      out[2] = q0;
-      out[3] = a2;
-      return out;
-    },
-    toABGR: (x) => {
-      const h = x[0] * 6;
-      const s = x[1];
-      const v = x[2] * 255;
-      const a2 = x[3] * 255;
-      const r = ((clamp01(abs$1(h - 3) - 1) - 1) * s + 1) * v;
-      const g = ((clamp01(2 - abs$1(h - 2)) - 1) * s + 1) * v;
-      const b2 = ((clamp01(2 - abs$1(h - 4)) - 1) * s + 1) * v;
-      return (a2 << 24 | b2 << 16 | g << 8 | r) >>> 0;
-    }
-  }
-});
-const FLOAT_RGBA = defFloatFormat({
-  alpha: true,
-  channels: [Lane.RED, Lane.GREEN, Lane.BLUE, Lane.ALPHA]
-});
-const UnsupportedOperationError = defError(
-  () => "unsupported operation"
-);
-const unsupported = (msg) => {
-  throw new UnsupportedOperationError(msg);
-};
-const vop = (dispatch = 1, fallback, ...optimized) => {
-  const impls = [, ,].concat(optimized);
-  const fn = (...args) => {
-    const g = impls[args[dispatch].length] || fallback;
-    return g ? g(...args) : unsupported(`no impl for vec size ${args[dispatch].length}`);
-  };
-  fn.add = (dim, fn2) => impls[dim] = fn2;
-  fn.default = (fn2) => fallback = fn2;
-  fn.impl = (dim) => dim != null ? impls[dim] || fallback : fallback;
-  return fn;
-};
-const dot2 = (a2, b2) => a2[0] * b2[0] + a2[1] * b2[1];
-const dot3 = (a2, b2) => a2[0] * b2[0] + a2[1] * b2[1] + a2[2] * b2[2];
-const dot4 = (a2, b2) => a2[0] * b2[0] + a2[1] * b2[1] + a2[2] * b2[2] + a2[3] * b2[3];
-const dot = vop(
-  0,
-  (a2, b2) => {
-    let sum5 = 0;
-    for (let i = a2.length; i-- > 0; ) sum5 += a2[i] * b2[i];
-    return sum5;
-  },
-  dot2,
-  dot3,
-  dot4
-);
-function memoizeJ(fn, cache = /* @__PURE__ */ Object.create(null)) {
-  return (...args) => {
-    const key = JSON.stringify(args);
-    if (key !== void 0) {
-      return key in cache ? cache[key] : cache[key] = fn.apply(null, args);
-    }
-    return fn.apply(null, args);
-  };
-}
-function memoizeO(fn, cache = /* @__PURE__ */ Object.create(null)) {
-  return (...xs) => {
-    const key = xs.join("-");
-    return key in cache ? cache[key] : cache[key] = fn(...xs);
-  };
-}
-const repeat$1 = memoizeO((ch, n) => ch.repeat(n));
-const float = memoizeJ(
-  (prec, special = false) => special ? (x) => __nanOrInf(x) || x.toFixed(prec) : (x) => x.toFixed(prec)
-);
-const __nanOrInf = (x) => isNaN(x) ? "NaN" : x === Infinity ? "+∞" : x === -Infinity ? "-∞" : void 0;
-const percent = (prec = 0) => (x) => (x * 100).toFixed(prec) + "%";
-const RGB_LUMINANCE_REC601 = [0.299, 0.587, 0.114];
-const RGB_LUMINANCE_REC709 = [0.2126, 0.7152, 0.0722];
-const XYZ_RGB_D50 = [
-  3.1338561,
-  -0.9787684,
-  0.0719453,
-  -1.6168667,
-  1.9161415,
-  -0.2289914,
-  -0.4906146,
-  0.033454,
-  1.4052427
-];
-const XYZ_RGB_D65 = [
-  3.2404542,
-  -0.969266,
-  0.0556434,
-  -1.5371385,
-  1.8760108,
-  -0.2040259,
-  -0.4985314,
-  0.041556,
-  1.0572252
-];
-const D50 = [0.96422, 1, 0.82521];
-const D65 = [0.95047, 1, 1.08883];
-const OKLAB_M2 = [
-  0.2104542553,
-  1.9779984951,
-  0.0259040371,
-  0.793617785,
-  -2.428592205,
-  0.7827717662,
-  -0.0040720468,
-  0.4505937099,
-  -0.808675766
-];
-let FF = float(3);
-let PC = percent(3);
-const INV8BIT = 1 / 255;
-const luminanceRgb = (rgb2, weights = RGB_LUMINANCE_REC709) => dot3(rgb2, weights);
-const luminanceSrgb = (rgb2) => dot3(rgb2, RGB_LUMINANCE_REC601);
-const set2 = (o, a2) => {
-  !o && (o = []);
-  o[0] = a2[0];
-  o[1] = a2[1];
-  return o;
-};
-const set3 = (o, a2) => {
-  !o && (o = []);
-  o[0] = a2[0];
-  o[1] = a2[1];
-  o[2] = a2[2];
-  return o;
-};
-const set4 = (o, a2) => {
-  !o && (o = []);
-  o[0] = a2[0];
-  o[1] = a2[1];
-  o[2] = a2[2];
-  o[3] = a2[3];
-  return o;
-};
-const set = vop(
-  1,
-  (o, a2) => {
-    !o && (o = []);
-    for (let i = a2.length; i-- > 0; ) o[i] = a2[i];
-    return o;
-  },
-  set2,
-  set3,
-  set4
-);
-const implementsFunction = (x, fn) => typeof x?.[fn] === "function";
-const isArrayLike = (x) => x != null && typeof x !== "function" && x.length !== void 0;
-const IllegalArgumentError = defError(() => "illegal argument(s)");
-const illegalArgs = (msg) => {
-  throw new IllegalArgumentError(msg);
-};
-const vector = memoizeJ(
-  (size, prec = 3, d2 = ",", pre = "[", post = "]") => {
-    const f = typeof prec === "number" ? float(prec) : prec;
-    switch (size) {
-      case 1:
-        return (v) => `${pre}${f(v[0])}${post}`;
-      case 2:
-        return (v) => `${pre}${f(v[0])}${d2}${f(v[1])}${post}`;
-      case 3:
-        return (v) => `${pre}${f(v[0])}${d2}${f(v[1])}${d2}${f(v[2])}${post}`;
-      case 4:
-        return (v) => `${pre}${f(v[0])}${d2}${f(v[1])}${d2}${f(v[2])}${d2}${f(
-          v[3]
-        )}${post}`;
-      default:
-        return (v) => {
-          const res = [];
-          for (let i = 0; i < v.length; i++) {
-            res.push(f(v[i]));
-          }
-          return `${pre}${res.join(d2)}${post}`;
-        };
-    }
-  }
-);
-const mapStridedBuffer = (ctor, buf, num, start, cstride, estride) => {
-  const res = [];
-  while (num-- > 0) {
-    res.push(new ctor(buf, start, cstride));
-    start += estride;
-  }
-  return res;
-};
-const defOpVVV = (op, dispatch = 1, outA = true) => {
-  const a2 = outA ? (o, a22, b22, c22) => {
-    !o && (o = a22);
-    for (let i = a22.length; i-- > 0; ) o[i] = op(a22[i], b22[i], c22[i]);
-    return o;
-  } : (o, a22, b22, c22) => {
-    !o && (o = c22);
-    for (let i = a22.length; i-- > 0; ) o[i] = op(a22[i], b22[i], c22[i]);
-    return o;
-  };
-  const b2 = outA ? (o, a22, b22, c22) => {
-    !o && (o = a22);
-    o[0] = op(a22[0], b22[0], c22[0]);
-    o[1] = op(a22[1], b22[1], c22[1]);
-    return o;
-  } : (o, a22, b22, c22) => {
-    !o && (o = c22);
-    o[0] = op(a22[0], b22[0], c22[0]);
-    o[1] = op(a22[1], b22[1], c22[1]);
-    return o;
-  };
-  const c2 = outA ? (o, a22, b22, c22) => {
-    !o && (o = a22);
-    o[0] = op(a22[0], b22[0], c22[0]);
-    o[1] = op(a22[1], b22[1], c22[1]);
-    o[2] = op(a22[2], b22[2], c22[2]);
-    return o;
-  } : (o, a22, b22, c22) => {
-    !o && (o = c22);
-    o[0] = op(a22[0], b22[0], c22[0]);
-    o[1] = op(a22[1], b22[1], c22[1]);
-    o[2] = op(a22[2], b22[2], c22[2]);
-    return o;
-  };
-  const d2 = outA ? (o, a22, b22, c22) => {
-    !o && (o = a22);
-    o[0] = op(a22[0], b22[0], c22[0]);
-    o[1] = op(a22[1], b22[1], c22[1]);
-    o[2] = op(a22[2], b22[2], c22[2]);
-    o[3] = op(a22[3], b22[3], c22[3]);
-    return o;
-  } : (o, a22, b22, c22) => {
-    !o && (o = c22);
-    o[0] = op(a22[0], b22[0], c22[0]);
-    o[1] = op(a22[1], b22[1], c22[1]);
-    o[2] = op(a22[2], b22[2], c22[2]);
-    o[3] = op(a22[3], b22[3], c22[3]);
-    return o;
-  };
-  return [
-    vop(dispatch, a2, b2, c2, d2),
-    b2,
-    c2,
-    d2
-  ];
-};
-const [a$5, b$2, c$1, d] = defOpVVV(clamp$1);
-const clamp4 = d;
-const declareIndex = (proto, id, idx, strided = true, defNumeric = true) => {
-  const get = idx > 0 ? strided ? function() {
-    return this.buf[this.offset + idx * this.stride];
-  } : function() {
-    return this.buf[this.offset + idx];
-  } : function() {
-    return this.buf[this.offset];
-  };
-  const set5 = idx > 0 ? strided ? function(n) {
-    this.buf[this.offset + idx * this.stride] = n;
-  } : function(n) {
-    this.buf[this.offset + idx] = n;
-  } : function(n) {
-    this.buf[this.offset] = n;
-  };
-  defNumeric && Object.defineProperty(proto, idx, {
-    get,
-    set: set5,
-    enumerable: true
-  });
-  Object.defineProperty(proto, id, {
-    get,
-    set: set5,
-    enumerable: true
-  });
-};
-const declareIndices = (proto, props, strided, defNumeric) => props.forEach((id, i) => declareIndex(proto, id, i, strided, defNumeric));
-const abs = Math.abs;
-const eqDelta = (a2, b2, eps = EPS) => abs(a2 - b2) <= eps;
-const eqDelta2 = (a2, b2, eps = EPS) => {
-  return a2.length === b2.length && eqDelta(a2[0], b2[0], eps) && eqDelta(a2[1], b2[1], eps);
-};
-const eqDelta3 = (a2, b2, eps = EPS) => {
-  return a2.length === b2.length && eqDelta(a2[0], b2[0], eps) && eqDelta(a2[1], b2[1], eps) && eqDelta(a2[2], b2[2], eps);
-};
-const eqDelta4 = (a2, b2, eps = EPS) => {
-  return a2.length === b2.length && eqDelta(a2[0], b2[0], eps) && eqDelta(a2[1], b2[1], eps) && eqDelta(a2[2], b2[2], eps) && eqDelta(a2[3], b2[3], eps);
-};
-vop(
-  0,
-  (v1, v2, eps = EPS) => {
-    if (implementsFunction(v1, "eqDelta")) {
-      return v1.eqDelta(v2, eps);
-    }
-    if (implementsFunction(v2, "eqDelta")) {
-      return v2.eqDelta(v1, eps);
-    }
-    return eqDeltaS(v1, v2, v1.length, eps);
-  },
-  eqDelta2,
-  eqDelta3,
-  eqDelta4
-);
-const eqDeltaS = (a2, b2, n, eps = EPS, ia = 0, ib = 0, sa = 1, sb = 1) => {
-  for (; n > 0; n--, ia += sa, ib += sb) {
-    if (!eqDelta(a2[ia], b2[ib], eps)) {
-      return false;
-    }
-  }
-  return true;
-};
-function* stridedValues(buf, num, start, stride) {
-  while (num-- > 0) {
-    yield buf[start];
-    start += stride;
-  }
-}
-const INV_MAX = 1 / 2 ** 32;
-class ARandom {
-  float(norm2 = 1) {
-    return this.int() * INV_MAX * norm2;
-  }
-  probability(p) {
-    return this.float() < p;
-  }
-  norm(norm2 = 1) {
-    return (this.int() * INV_MAX - 0.5) * 2 * norm2;
-  }
-  normMinMax(min2, max2) {
-    const x = this.minmax(min2, max2);
-    return this.float() < 0.5 ? x : -x;
-  }
-  minmax(min2, max2) {
-    return this.float() * (max2 - min2) + min2;
-  }
-  minmaxInt(min2, max2) {
-    min2 |= 0;
-    const range = (max2 | 0) - min2;
-    return range ? min2 + this.int() % range : min2;
-  }
-  minmaxUint(min2, max2) {
-    min2 >>>= 0;
-    const range = (max2 >>> 0) - min2;
-    return range ? min2 + this.int() % range : min2;
-  }
-}
-class WrappedRandom extends ARandom {
-  constructor(rnd) {
-    super();
-    this.rnd = rnd;
-  }
-  float(norm2 = 1) {
-    return this.rnd() * norm2;
-  }
-  norm(norm2 = 1) {
-    return (this.rnd() - 0.5) * 2 * norm2;
-  }
-  int() {
-    return this.rnd() * 4294967296 >>> 0;
-  }
-}
-const SYSTEM = new WrappedRandom(Math.random);
-const weightedRandom = (choices, weights, rnd = SYSTEM) => {
-  const n = choices.length;
-  assert(n > 0, "no choices given");
-  const opts = weights ? choices.map((x, i) => [weights[i] || 0, x]).sort((a2, b2) => b2[0] - a2[0]) : choices.map((x) => [1, x]);
-  const total = opts.reduce((acc, o) => acc + o[0], 0);
-  total <= 0 && console.warn("total weights <= 0");
-  return () => {
-    const r = rnd.float(total);
-    let sum5 = total;
-    for (let i = 0; i < n; i++) {
-      sum5 -= opts[i][0];
-      if (sum5 <= r) {
-        return opts[i][1];
-      }
-    }
-    return void 0;
-  };
-};
-const randMinMax = vop(
-  1,
-  (o, a2, b2, rnd = SYSTEM) => {
-    !o && (o = a2);
-    for (let i = a2.length; i-- > 0; ) o[i] = rnd.minmax(a2[i], b2[i]);
-    return o;
-  }
-);
-const isArray = Array.isArray;
-const CONVERSIONS = {};
-const defConversions = (mode, spec) => {
-  for (let id in spec) {
-    const val = spec[id];
-    if (isArray(val)) {
-      const [a2, b2, c2, d2] = val;
-      spec[id] = val.length === 2 ? (out, src) => b2(out, a2(out, src)) : val.length === 3 ? (out, src) => c2(out, b2(out, a2(out, src))) : (out, src) => d2(out, c2(out, b2(out, a2(out, src))));
-    }
-  }
-  CONVERSIONS[mode] = { ...CONVERSIONS[mode], ...spec };
-};
-const convert = (res, src, destMode, srcMode) => {
-  const spec = CONVERSIONS[destMode];
-  assert(!!spec, `no conversions available for ${destMode}`);
-  let $convert = spec[srcMode];
-  return $convert ? $convert(res, src) : CONVERSIONS.rgb[srcMode] ? spec.rgb(res, CONVERSIONS.rgb[srcMode]([], src)) : unsupported(`can't convert: ${srcMode} -> ${destMode}`);
-};
-const rotateRight = (x, n) => (x >>> n | x << 32 - n) >>> 0;
-const interleave4_12_24 = (x) => (x & 3840) * 4352 | (x & 240) * 272 | (x & 15) * 17;
-const interleave4_16_32 = (x) => ((x & 61440) * 69632 | (x & 3840) * 4352 | (x & 240) * 272 | (x & 15) * 17) >>> 0;
-class ParsedColor {
-  constructor(mode, value) {
-    this.mode = mode;
-    this.value = value;
-  }
-  deref() {
-    return this.value;
-  }
-}
-const CSS_NAMES = {
-  aliceblue: "f0f8ff",
-  antiquewhite: "faebd7",
-  aqua: "0ff",
-  aquamarine: "7fffd4",
-  azure: "f0ffff",
-  beige: "f5f5dc",
-  bisque: "ffe4c4",
-  black: "000",
-  blanchedalmond: "ffebcd",
-  blue: "00f",
-  blueviolet: "8a2be2",
-  brown: "a52a2a",
-  burlywood: "deb887",
-  cadetblue: "5f9ea0",
-  chartreuse: "7fff00",
-  chocolate: "d2691e",
-  coral: "ff7f50",
-  cornflowerblue: "6495ed",
-  cornsilk: "fff8dc",
-  crimson: "dc143c",
-  cyan: "0ff",
-  darkblue: "00008b",
-  darkcyan: "008b8b",
-  darkgoldenrod: "b8860b",
-  darkgray: "a9a9a9",
-  darkgreen: "006400",
-  darkgrey: "a9a9a9",
-  darkkhaki: "bdb76b",
-  darkmagenta: "8b008b",
-  darkolivegreen: "556b2f",
-  darkorange: "ff8c00",
-  darkorchid: "9932cc",
-  darkred: "8b0000",
-  darksalmon: "e9967a",
-  darkseagreen: "8fbc8f",
-  darkslateblue: "483d8b",
-  darkslategray: "2f4f4f",
-  darkslategrey: "2f4f4f",
-  darkturquoise: "00ced1",
-  darkviolet: "9400d3",
-  deeppink: "ff1493",
-  deepskyblue: "00bfff",
-  dimgray: "696969",
-  dimgrey: "696969",
-  dodgerblue: "1e90ff",
-  firebrick: "b22222",
-  floralwhite: "fffaf0",
-  forestgreen: "228b22",
-  fuchsia: "f0f",
-  gainsboro: "dcdcdc",
-  ghostwhite: "f8f8ff",
-  gold: "ffd700",
-  goldenrod: "daa520",
-  gray: "808080",
-  grey: "808080",
-  green: "008000",
-  greenyellow: "adff2f",
-  honeydew: "f0fff0",
-  hotpink: "ff69b4",
-  indianred: "cd5c5c",
-  indigo: "4b0082",
-  ivory: "fffff0",
-  khaki: "f0e68c",
-  lavender: "e6e6fa",
-  lavenderblush: "fff0f5",
-  lawngreen: "7cfc00",
-  lemonchiffon: "fffacd",
-  lightblue: "add8e6",
-  lightcoral: "f08080",
-  lightcyan: "e0ffff",
-  lightgoldenrodyellow: "fafad2",
-  lightgray: "d3d3d3",
-  lightgreen: "90ee90",
-  lightgrey: "d3d3d3",
-  lightpink: "ffb6c1",
-  lightsalmon: "ffa07a",
-  lightseagreen: "20b2aa",
-  lightskyblue: "87cefa",
-  lightslategray: "789",
-  lightslategrey: "789",
-  lightsteelblue: "b0c4de",
-  lightyellow: "ffffe0",
-  lime: "0f0",
-  limegreen: "32cd32",
-  linen: "faf0e6",
-  magenta: "f0f",
-  maroon: "800000",
-  mediumaquamarine: "66cdaa",
-  mediumblue: "0000cd",
-  mediumorchid: "ba55d3",
-  mediumpurple: "9370db",
-  mediumseagreen: "3cb371",
-  mediumslateblue: "7b68ee",
-  mediumspringgreen: "00fa9a",
-  mediumturquoise: "48d1cc",
-  mediumvioletred: "c71585",
-  midnightblue: "191970",
-  mintcream: "f5fffa",
-  mistyrose: "ffe4e1",
-  moccasin: "ffe4b5",
-  navajowhite: "ffdead",
-  navy: "000080",
-  oldlace: "fdf5e6",
-  olive: "808000",
-  olivedrab: "6b8e23",
-  orange: "ffa500",
-  orangered: "ff4500",
-  orchid: "da70d6",
-  palegoldenrod: "eee8aa",
-  palegreen: "98fb98",
-  paleturquoise: "afeeee",
-  palevioletred: "db7093",
-  papayawhip: "ffefd5",
-  peachpuff: "ffdab9",
-  peru: "cd853f",
-  pink: "ffc0cb",
-  plum: "dda0dd",
-  powderblue: "b0e0e6",
-  purple: "800080",
-  red: "f00",
-  rosybrown: "bc8f8f",
-  royalblue: "4169e1",
-  saddlebrown: "8b4513",
-  salmon: "fa8072",
-  sandybrown: "f4a460",
-  seagreen: "2e8b57",
-  seashell: "fff5ee",
-  sienna: "a0522d",
-  silver: "c0c0c0",
-  skyblue: "87ceeb",
-  slateblue: "6a5acd",
-  slategray: "708090",
-  slategrey: "708090",
-  snow: "fffafa",
-  springgreen: "00ff7f",
-  steelblue: "4682b4",
-  tan: "d2b48c",
-  teal: "008080",
-  thistle: "d8bfd8",
-  tomato: "ff6347",
-  turquoise: "40e0d0",
-  violet: "ee82ee",
-  wheat: "f5deb3",
-  white: "fff",
-  whitesmoke: "f5f5f5",
-  yellow: "ff0",
-  yellowgreen: "9acd32",
-  // additions
-  transparent: "0000",
-  rebeccapurple: "639"
-};
-let CSS_SYSTEM_COLORS = {
-  canvas: "fff",
-  canvastext: "000",
-  linktext: "001ee4",
-  visitedtext: "4e2386",
-  activetext: "eb3323",
-  buttonface: "ddd",
-  buttontext: "000",
-  buttonborder: "000",
-  field: "fff",
-  fieldtext: "000",
-  highlight: "bbd5fb",
-  highlighttext: "000",
-  mark: "000",
-  marktext: "fff",
-  graytext: "808080"
-};
-const setC3 = (out, x, y, z) => {
-  !out && (out = []);
-  out[0] = x;
-  out[1] = y;
-  out[2] = z;
-  return out;
-};
-const setC4 = (out, x, y, z, w) => {
-  !out && (out = []);
-  out[0] = x;
-  out[1] = y;
-  out[2] = z;
-  out[3] = w;
-  return out;
-};
-const intArgb32Srgb = (out, src) => setC4(
-  out || [],
-  (src >>> 16 & 255) * INV8BIT,
-  (src >>> 8 & 255) * INV8BIT,
-  (src & 255) * INV8BIT,
-  (src >>> 24) * INV8BIT
-);
-const intAbgr32Srgb = (out, src) => setC4(
-  out || [],
-  (src & 255) * INV8BIT,
-  (src >>> 8 & 255) * INV8BIT,
-  (src >>> 16 & 255) * INV8BIT,
-  (src >>> 24) * INV8BIT
-);
-const parseCss = (src) => {
-  src = (isString(src) ? src : src.deref()).toLowerCase();
-  const named = CSS_NAMES[src] || CSS_SYSTEM_COLORS[src];
-  if (named || src[0] === "#")
-    return new ParsedColor(
-      "srgb",
-      intArgb32Srgb([], parseHex(named || src))
-    );
-  const parts = src.split(/[(),/ ]+/);
-  const [mode, a2, b2, c2, d2] = parts;
-  assert(parts.length === 5 || parts.length === 6, `invalid color: ${src}`);
-  switch (mode) {
-    case "rgb":
-    case "rgba":
-      return new ParsedColor("srgb", [
-        __numOrPercent(a2, 1, INV8BIT, true),
-        __numOrPercent(b2, 1, INV8BIT, true),
-        __numOrPercent(c2, 1, INV8BIT, true),
-        __alpha(d2)
-      ]);
-    case "hsl":
-    case "hsla":
-      return new ParsedColor("hsl", [
-        __hue(a2),
-        __percent(b2),
-        __percent(c2),
-        __alpha(d2)
-      ]);
-    case "lab":
-      return new ParsedColor("lab50", [
-        __numOrPercent(a2),
-        __numOrPercent(b2, 1.25),
-        __numOrPercent(c2, 1.25),
-        __alpha(d2)
-      ]);
-    case "lch":
-      return new ParsedColor(mode, [
-        __numOrPercent(a2),
-        __numOrPercent(b2, 1.5),
-        __hue(c2),
-        __alpha(d2)
-      ]);
-    case "oklab":
-      return new ParsedColor(mode, [
-        __numOrPercent(a2, 1, 1),
-        __numOrPercent(b2, 0.4, 1),
-        __numOrPercent(c2, 0.4, 1),
-        __alpha(d2)
-      ]);
-    case "oklch":
-      return new ParsedColor(mode, [
-        __numOrPercent(a2, 1, 1),
-        __numOrPercent(b2, 0.4, 1),
-        __hue(c2),
-        __alpha(d2)
-      ]);
-    default:
-      unsupported(`color mode: ${mode}`);
-  }
-};
-const HUE_NORMS = {
-  rad: TAU,
-  grad: 400,
-  turn: 1,
-  deg: 360
-};
-const __hue = (x) => {
-  const match = /^(-?[0-9.]+)(deg|rad|grad|turn)?$/.exec(x);
-  assert(!!match, `expected hue, got: ${x}`);
-  return fract(parseFloat(match[1]) / (HUE_NORMS[match[2]] || 360));
-};
-const __alpha = (x) => x ? __numOrPercent(x, 1, 1, true) : 1;
-const __percent = (x, clamp2 = true) => {
-  assert(/^([0-9.]+)%$/.test(x), `expected percentage, got: ${x}`);
-  const res = parseFloat(x) / 100;
-  return clamp2 ? clamp01(res) : res;
-};
-const __numOrPercent = (x, scalePerc = 1, scale = 0.01, clamp2 = false) => {
-  assert(/^-?[0-9.]+%?$/.test(x), `expected number or percentage, got: ${x}`);
-  const res = parseFloat(x) * (x.endsWith("%") ? 0.01 * scalePerc : scale);
-  return clamp2 ? clamp01(res) : res;
-};
-const parseHex = (src) => {
-  const match = /^#?([0-9a-f]{3,8})$/i.exec(src);
-  if (match) {
-    const hex = match[1];
-    const val = parseInt(hex, 16);
-    switch (hex.length) {
-      case 3:
-        return (interleave4_12_24(val) | 4278190080) >>> 0;
-      case 4:
-        return rotateRight(interleave4_16_32(val), 8);
-      case 6:
-        return (val | 4278190080) >>> 0;
-      case 8:
-        return rotateRight(val, 8);
-    }
-  }
-  return illegalArgs(`invalid hex color: "${src}"`);
-};
-const __ensureAlpha = (x, def = 1) => x != void 0 ? clamp01(x) : def;
-const __ensureArgs = (args) => {
-  if (typeof args[0] === "number") {
-    switch (args.length) {
-      case 1:
-        return args.push(0, 0, 1), [args];
-      case 2:
-        return args.push(0, 1), [args];
-      case 3:
-        return args.push(1), [args];
-      default:
-        return [args];
-    }
-  }
-  return args;
-};
-const defColor = (spec) => {
-  const channels = spec.channels || {};
-  const order = spec.order;
-  const numChannels = order.length;
-  order.reduce((acc, id) => {
-    acc[id] = {
-      range: [0, 1],
-      ...channels[id]
-    };
-    return acc;
-  }, channels);
-  const min2 = Object.freeze(order.map((id) => channels[id].range[0]));
-  const max2 = Object.freeze(order.map((id) => channels[id].range[1]));
-  const minR = set4([], min2);
-  const maxR = set4([], max2);
-  minR[numChannels - 1] = 1;
-  const hueChanID = order.findIndex((id) => !!channels[id].hue);
-  const $Color = class {
-    constructor(buf, offset = 0, stride = 1) {
-      this.offset = offset;
-      this.stride = stride;
-      this.buf = buf || [0, 0, 0, 0];
-      this.offset = offset;
-      this.stride = stride;
-    }
-    buf;
-    get mode() {
-      return spec.mode;
-    }
-    get length() {
-      return numChannels;
-    }
-    get range() {
-      return [min2, max2];
-    }
-    get [Symbol.toStringTag]() {
-      return spec.mode;
-    }
-    get xyz() {
-      return [this[0], this[1], this[2]];
-    }
-    [Symbol.iterator]() {
-      return stridedValues(
-        this.buf,
-        this.length,
-        this.offset,
-        this.stride
-      );
-    }
-    copy() {
-      return new $Color(this.deref());
-    }
-    copyView() {
-      return new $Color(this.buf, this.offset, this.stride);
-    }
-    empty() {
-      return new $Color();
-    }
-    deref() {
-      return [this[0], this[1], this[2], this[3]];
-    }
-    set(src) {
-      return set4(this, src);
-    }
-    clamp() {
-      hueChanID >= 0 && (this[hueChanID] = fract(this[hueChanID]));
-      clamp4(null, this, min2, max2);
-      return this;
-    }
-    eqDelta(o, eps = EPS) {
-      return eqDelta4(this, o, eps);
-    }
-    randomize(rnd) {
-      return randMinMax(this, minR, maxR, rnd);
-    }
-    toJSON() {
-      return this.deref();
-    }
-    toString() {
-      return vector(4, 4)(this);
-    }
-  };
-  declareIndices($Color.prototype, order);
-  defConversions(spec.mode, spec.from);
-  defConversions("rgb", { [spec.mode]: spec.toRgb });
-  const fromColor = (src, mode, args) => {
-    const res = new $Color(...args);
-    return mode !== spec.mode ? convert(res, src, spec.mode, mode) : res.set(src);
-  };
-  const factory = (src, ...args) => src == null ? new $Color() : isString(src) ? factory(parseCss(src), ...args) : isArrayLike(src) ? isString(src.mode) ? fromColor(src, src.mode, args) : new $Color(src, ...args) : implementsFunction(src, "deref") ? fromColor(src.deref(), src.mode, args) : isNumber(src) ? args.length && args.every(isNumber) ? new $Color(...__ensureArgs([src, ...args])) : fromColor(intArgb32Srgb([], src), "srgb", args) : illegalArgs(`can't create a ${spec.mode} color from: ${src}`);
-  factory.class = $Color;
-  factory.range = [min2, max2];
-  factory.random = (rnd, buf, idx, stride) => new $Color(buf, idx, stride).randomize(rnd);
-  factory.mapBuffer = (buf, num = buf.length / numChannels | 0, start = 0, cstride = 1, estride = numChannels) => mapStridedBuffer($Color, buf, num, start, cstride, estride);
-  return factory;
-};
-const hueRgb = (out, hue, alpha = 1) => {
-  hue = fract(hue) * 6;
-  return setC4(
-    out || [],
-    clamp01(Math.abs(hue - 3) - 1),
-    clamp01(2 - Math.abs(hue - 2)),
-    clamp01(2 - Math.abs(hue - 4)),
-    alpha
-  );
-};
-const hcyRgb = (out, src) => {
-  const h = src[0];
-  let c2 = src[1];
-  const y = src[2];
-  const rgb2 = hueRgb(out || src, h, __ensureAlpha(src[3]));
-  const lum = luminanceRgb(rgb2);
-  if (y < lum) {
-    c2 *= y / lum;
-  } else if (lum < 1) {
-    c2 *= (1 - y) / (1 - lum);
-  }
-  return setC3(
-    rgb2,
-    clamp01((rgb2[0] - lum) * c2 + y),
-    clamp01((rgb2[1] - lum) * c2 + y),
-    clamp01((rgb2[2] - lum) * c2 + y)
-  );
-};
-const clamp = (out, src, alpha = 1) => setC4(
-  out || src,
-  clamp01(src[0]),
-  clamp01(src[1]),
-  clamp01(src[2]),
-  __ensureAlpha(src[3], alpha)
-);
-const clampH = (out, src, alpha = 1) => setC4(
-  out || src,
-  fract(src[0]),
-  clamp01(src[1]),
-  clamp01(src[2]),
-  __ensureAlpha(src[3], alpha)
-);
-const hsiRgb = (out, src) => {
-  out = clampH(out || src, src);
-  const s = out[1];
-  const i = out[2];
-  if (s < 1e-6) {
-    return setC3(out, i, i, i);
-  }
-  const h = out[0] * 6 % 6;
-  const m = i * (1 - s);
-  const z = 1 - Math.abs(h % 2 - 1);
-  let c2 = 3 * i * s / (1 + z);
-  const x = c2 * z + m;
-  c2 += m;
-  switch (h | 0) {
-    case 0:
-      return setC3(out, c2, x, m);
-    case 1:
-      return setC3(out, x, c2, m);
-    case 2:
-      return setC3(out, m, c2, x);
-    case 3:
-      return setC3(out, m, x, c2);
-    case 4:
-      return setC3(out, x, m, c2);
-    case 5:
-      return setC3(out, c2, m, x);
-    default:
-      return setC3(out, m, m, m);
-  }
-};
-const hslRgb = (out, src) => {
-  const s = clamp01(src[1]);
-  const l = clamp01(src[2]);
-  out = hueRgb(out || src, src[0], __ensureAlpha(src[3]));
-  const c2 = (1 - Math.abs(2 * l - 1)) * s;
-  return setC3(
-    out,
-    (out[0] - 0.5) * c2 + l,
-    (out[1] - 0.5) * c2 + l,
-    (out[2] - 0.5) * c2 + l
-  );
-};
-const hsvRgb = (out, src) => {
-  out = clampH(out || src, src);
-  const s = out[1];
-  const v = out[2];
-  hueRgb(out, src[0], out[3]);
-  return setC3(
-    out,
-    ((out[0] - 1) * s + 1) * v,
-    ((out[1] - 1) * s + 1) * v,
-    ((out[2] - 1) * s + 1) * v
-  );
-};
-const linearSrgb = (x) => x <= 31308e-7 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055;
-const srgbLinear = (x) => x <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);
-const srgbRgb = (out, src) => setC4(
-  out || src,
-  srgbLinear(src[0]),
-  srgbLinear(src[1]),
-  srgbLinear(src[2]),
-  __ensureAlpha(src[3])
-);
-const intArgb32Rgb = (out, src) => srgbRgb(null, intArgb32Srgb(out, src));
-const intAbgr32Rgb = (out, src) => srgbRgb(null, intAbgr32Srgb(out, src));
-const cossin = (theta, n = 1) => [
-  Math.cos(theta) * n,
-  Math.sin(theta) * n
-];
-const absTheta = (theta) => (theta %= TAU, theta < 0 ? TAU + theta : theta);
-const atan2Abs = (y, x) => absTheta(Math.atan2(y, x));
-const lchLab = (out, src) => {
-  let { 1: c2, 2: h } = src;
-  h *= TAU;
-  const a2 = __ensureAlpha(src[3]);
-  return c2 > 0 ? setC4(out || src, src[0], Math.cos(h) * c2, Math.sin(h) * c2, a2) : setC4(out || src, src[0], 0, 0, a2);
-};
-const __transform = (x) => {
-  const y = x ** 3;
-  return y > 8856e-6 ? y : (x - 16 / 116) / 7.787;
-};
-const labXyz = (out, src, white = D50) => {
-  const y = (src[0] + 0.16) / 1.16;
-  return setC4(
-    out || src,
-    __transform(src[1] / 5 + y) * white[0],
-    __transform(y) * white[1],
-    __transform(y - src[2] / 2) * white[2],
-    __ensureAlpha(src[3])
-  );
-};
-const labXyzD65 = (out, src) => labXyz(out, src, D65);
-const dotS3 = (a2, b2, ia = 0, ib = 0, sa = 1, sb = 1) => a2[ia] * b2[ib] + a2[ia + sa] * b2[ib + sb] + a2[ia + 2 * sa] * b2[ib + 2 * sb];
-const __mulV33 = (out, mat, src, clampOut = false) => {
-  const x = dotS3(mat, src, 0, 0, 3);
-  const y = dotS3(mat, src, 1, 0, 3);
-  const z = dotS3(mat, src, 2, 0, 3);
-  const a2 = __ensureAlpha(src[3]);
-  return clampOut ? setC4(out || src, clamp01(x), clamp01(y), clamp01(z), a2) : setC4(out || src, x, y, z, a2);
-};
-const xyzRgb = (out, src, mat = XYZ_RGB_D50) => __mulV33(out, mat, src);
-const xyzRgbD65 = (out, src) => xyzRgb(out, src, XYZ_RGB_D65);
-const labRgb = (out, src) => xyzRgb(null, labXyz(out, src));
-const labRgbD65 = (out, src) => xyzRgbD65(null, labXyzD65(out, src));
-const LMS_CONE = [
-  4.0767416621,
-  -1.2684380046,
-  -0.0041960863,
-  -3.307711591,
-  2.6097574011,
-  -0.7034186147,
-  0.2309699292,
-  -0.3413193965,
-  1.707614701
-];
-const oklabRgb = (out, { 0: l, 1: a2, 2: b2, 3: alpha }) => __mulV33(out, LMS_CONE, [
-  (l + 0.3963377774 * a2 + 0.2158037573 * b2) ** 3,
-  (l - 0.1055613458 * a2 - 0.0638541728 * b2) ** 3,
-  (l - 0.0894841775 * a2 - 1.291485548 * b2) ** 3,
-  alpha
-]);
-const safeDiv = (a2, b2) => b2 !== 0 ? a2 / b2 : 0;
-const xyyXyz = (out, src) => {
-  const { 0: x, 1: y, 2: Y } = src;
-  return setC4(
-    out || src,
-    safeDiv(Y * x, y),
-    Y,
-    safeDiv(Y * (1 - x - y), y),
-    __ensureAlpha(src[3])
-  );
-};
-const yccRgb = (out, src, luma = RGB_LUMINANCE_REC709) => {
-  const y = src[0];
-  const bb = (2 - 2 * luma[2]) * src[1];
-  const rr = (2 - 2 * luma[0]) * src[2];
-  return setC4(
-    out || src,
-    y + rr,
-    y - luma[2] / luma[1] * bb - luma[0] / luma[1] * rr,
-    y + bb,
-    __ensureAlpha(src[3])
-  );
-};
-const rgb = defColor({
-  mode: "rgb",
-  order: ["r", "g", "b", "alpha"],
-  from: {
-    abgr32: (out, src) => intAbgr32Rgb(out, src[0]),
-    argb32: (out, src) => intArgb32Rgb(out, src[0]),
-    hcy: hcyRgb,
-    hsi: hsiRgb,
-    hsl: hslRgb,
-    hsv: hsvRgb,
-    lab50: labRgb,
-    lab65: labRgbD65,
-    lch: [lchLab, labRgb],
-    oklab: oklabRgb,
-    rgb: set4,
-    srgb: srgbRgb,
-    xyy: [xyyXyz, xyzRgbD65],
-    xyz50: xyzRgb,
-    xyz65: xyzRgbD65,
-    ycc: yccRgb
-  },
-  toRgb: set4
-});
-const contrast = (a2, b2) => {
-  const lumA = luminanceRgb(rgb(a2)) + 0.05;
-  const lumB = luminanceRgb(rgb(b2)) + 0.05;
-  return lumA > lumB ? lumA / lumB : lumB / lumA;
-};
-const hslCss = (src) => {
-  const h = FF(fract(src[0]) * 360);
-  const s = PC(clamp01(src[1]));
-  const l = PC(clamp01(src[2]));
-  const a2 = __ensureAlpha(src[3]);
-  return a2 < 1 ? `hsla(${h},${s},${l},${FF(a2)})` : `hsl(${h},${s},${l})`;
-};
-const hsvHsl = (out, src) => {
-  out = clampH(out || src, src);
-  const s = out[1];
-  const v = out[2];
-  const l = (2 - s) * v / 2;
-  out[2] = l;
-  out[1] = l && l < 1 ? s * v / (l < 0.5 ? l * 2 : 2 - l * 2) : s;
-  return out;
-};
-const hsvCss = (src) => hslCss(hsvHsl([], src));
-const HEX = "0123456789abcdef";
-const U8 = (x) => HEX[x >>> 4 & 15] + HEX[x & 15];
-const U16 = (x) => U8(x >>> 8) + U8(x & 255);
-const U24$1 = (x) => U8(x >>> 16) + U16(x);
-const radix = memoizeO(
-  (radix2, n, prefix = "") => {
-    const buf = repeat$1("0", n);
-    return (x) => {
-      x = (x >>> 0).toString(radix2);
-      return prefix + (x.length < n ? buf.substring(x.length) + x : x);
-    };
-  }
-);
-radix(2, 8);
-radix(2, 16);
-radix(2, 32);
-const U24 = U24$1;
-const intArgb32Css = (src) => {
-  const a2 = src >>> 24;
-  return a2 < 255 ? `rgba(${src >> 16 & 255},${src >> 8 & 255},${src & 255},${FF(
-    a2 * INV8BIT
-  )})` : `#${U24(src & 16777215)}`;
-};
-const swapLane13 = (x) => (x & 255) << 16 | x >> 16 & 255 | x & 4278255360;
-const intAbgr32Argb32 = swapLane13;
-const rgbSrgb = (out, src) => setC4(
-  out || src,
-  linearSrgb(src[0]),
-  linearSrgb(src[1]),
-  linearSrgb(src[2]),
-  __ensureAlpha(src[3])
-);
-const __scale8bit = (x, shift = 0) => (x < 0 ? 0 : x > 1 ? 1 : x) * 255 + 0.5 << shift;
-const srgbCss = (src) => {
-  const r = __scale8bit(src[0]);
-  const g = __scale8bit(src[1]);
-  const b2 = __scale8bit(src[2]);
-  const a2 = __ensureAlpha(src[3]);
-  return a2 < 1 ? `rgba(${r},${g},${b2},${FF(a2)})` : `#${U24(r << 16 | g << 8 | b2)}`;
-};
-const rgbCss = (src) => srgbCss(rgbSrgb([], src));
-const CSS_LEVEL3 = {
-  abgr32: (x) => intArgb32Css(intAbgr32Argb32(x[0])),
-  argb32: (x) => intArgb32Css(x[0]),
-  hsl: hslCss,
-  hsv: hsvCss,
-  lab50: (src) => srgbCss(rgbSrgb(null, labRgb([], src))),
-  lab65: (src) => srgbCss(rgbSrgb(null, labRgbD65([], src))),
-  lch: (src) => srgbCss(rgbSrgb(null, labRgb(null, lchLab([], src)))),
-  rgb: rgbCss,
-  srgb: srgbCss
-};
-({
-  ...CSS_LEVEL3
-});
-let CSS_DEFAULT = CSS_LEVEL3;
-const css = (src, cssTarget = CSS_DEFAULT) => {
-  let asCss;
-  return isString(src) ? src : isNumber(src) ? intArgb32Css(src) : src.mode ? (asCss = cssTarget[src.mode]) ? asCss(src) : cssTarget.rgb(
-    convert([], src, "rgb", src.mode)
-  ) : srgbCss(src);
-};
-const hslHsv = (out, src) => {
-  out = clampH(out || src, src);
-  const s = out[1];
-  const l = out[2];
-  const l2 = 2 * l;
-  const v = (l2 + s * (1 - Math.abs(l2 - 1))) * 0.5;
-  out[1] = 2 * (v - l) / v;
-  out[2] = v;
-  return out;
-};
-const rgbHcv = (out, src) => {
-  out = clamp(out || src, src);
-  const p = out[1] < out[2] ? [out[2], out[1], -1, 2 / 3] : [out[1], out[2], 0, -1 / 3];
-  const q = out[0] < p[0] ? [p[0], p[1], p[3], out[0]] : [out[0], p[1], p[2], p[0]];
-  const c2 = q[0] - Math.min(q[1], q[3]);
-  return setC3(
-    out,
-    clamp01(Math.abs((q[3] - q[1]) / (6 * c2 + EPS) + q[2])),
-    clamp01(c2),
-    clamp01(q[0])
-  );
-};
-const rgbHsv = (out, src) => {
-  out = rgbHcv(out, src);
-  out[1] /= out[2] + EPS;
-  return out;
-};
-const hsv = defColor({
-  mode: "hsv",
-  channels: { h: { hue: true } },
-  order: ["h", "s", "v", "alpha"],
-  from: {
-    rgb: rgbHsv,
-    srgb: rgbHsv,
-    hsl: hslHsv,
-    lch: [lchLab, labRgb, rgbSrgb, rgbHsv]
-  },
-  toRgb: hsvRgb
-});
-const defOpVN = (op, dispatch = 1) => {
-  const a2 = (o, a22, n) => {
-    !o && (o = a22);
-    for (let i = a22.length; i-- > 0; ) o[i] = op(a22[i], n);
-    return o;
-  };
-  const b2 = (o, a22, n) => {
-    !o && (o = a22);
-    o[0] = op(a22[0], n);
-    o[1] = op(a22[1], n);
-    return o;
-  };
-  const c2 = (o, a22, n) => {
-    !o && (o = a22);
-    o[0] = op(a22[0], n);
-    o[1] = op(a22[1], n);
-    o[2] = op(a22[2], n);
-    return o;
-  };
-  const d2 = (o, a22, n) => {
-    !o && (o = a22);
-    o[0] = op(a22[0], n);
-    o[1] = op(a22[1], n);
-    o[2] = op(a22[2], n);
-    o[3] = op(a22[3], n);
-    return o;
-  };
-  return [
-    vop(dispatch, a2, b2, c2, d2),
-    b2,
-    c2,
-    d2
-  ];
-};
-const [a$4, b$1, c] = defOpVN(Math.pow);
-const powN3 = c;
-const CONE_LMS = [
-  0.4122214708,
-  0.2119034982,
-  0.0883024619,
-  0.5363325363,
-  0.6806995451,
-  0.2817188376,
-  0.0514459929,
-  0.1073969566,
-  0.6299787005
-];
-const rgbOklab = (out, src) => __mulV33(null, OKLAB_M2, powN3(null, __mulV33(out, CONE_LMS, src), 1 / 3));
-const oklabOklch = (out, src) => setC4(
-  out || src,
-  src[0],
-  Math.hypot(src[1], src[2]),
-  atan2Abs(src[2], src[1]) * INV_TAU,
-  __ensureAlpha(src[3])
-);
-const oklchOklab = (out, src) => setC4(
-  out || src,
-  src[0],
-  ...cossin(src[2] * TAU, src[1]),
-  __ensureAlpha(src[3])
-);
-const oklch = defColor({
-  mode: "oklch",
-  channels: {
-    c: { range: [0, 0.3225] }
-  },
-  order: ["l", "c", "h", "alpha"],
-  from: {
-    oklab: oklabOklch,
-    rgb: (out, src) => oklabOklch(null, rgbOklab(out, src))
-  },
-  toRgb: [oklchOklab, oklabRgb]
-});
-const srgb = defColor({
-  mode: "srgb",
-  order: ["r", "g", "b", "alpha"],
-  from: {
-    abgr32: (out, src) => intAbgr32Srgb(out, src[0]),
-    argb32: (out, src) => intArgb32Srgb(out, src[0]),
-    hcy: hcyRgb,
-    hsi: hsiRgb,
-    hsl: hslRgb,
-    hsv: hsvRgb,
-    rgb: rgbSrgb
-  },
-  toRgb: srgbRgb
-});
-const compare = (a2, b2) => {
-  if (a2 === b2) {
-    return 0;
-  }
-  if (a2 == null) {
-    return b2 == null ? 0 : -1;
-  }
-  if (b2 == null) {
-    return a2 == null ? 0 : 1;
-  }
-  if (typeof a2.compare === "function") {
-    return a2.compare(b2);
-  }
-  if (typeof b2.compare === "function") {
-    return -b2.compare(a2);
-  }
-  return a2 < b2 ? -1 : a2 > b2 ? 1 : 0;
-};
-const __key = (k) => typeof k === "function" ? k : (x) => x[k];
-function compareByKey(key, cmp = compare) {
-  const kfn = __key(key);
-  return (x, y) => cmp(kfn(x), kfn(y));
-}
-const compareNumDesc = (a2, b2) => b2 - a2;
-const defOpVV = (op, dispatch = 1, outA = true) => {
-  const a2 = outA ? (o, a22, b22) => {
-    !o && (o = a22);
-    for (let i = a22.length; i-- > 0; ) o[i] = op(a22[i], b22[i]);
-    return o;
-  } : (o, a22, b22) => {
-    !o && (o = b22);
-    for (let i = a22.length; i-- > 0; ) o[i] = op(a22[i], b22[i]);
-    return o;
-  };
-  const b2 = outA ? (o, a22, b22) => {
-    !o && (o = a22);
-    o[0] = op(a22[0], b22[0]);
-    o[1] = op(a22[1], b22[1]);
-    return o;
-  } : (o, a22, b22) => {
-    !o && (o = b22);
-    o[0] = op(a22[0], b22[0]);
-    o[1] = op(a22[1], b22[1]);
-    return o;
-  };
-  const c2 = outA ? (o, a22, b22) => {
-    !o && (o = a22);
-    o[0] = op(a22[0], b22[0]);
-    o[1] = op(a22[1], b22[1]);
-    o[2] = op(a22[2], b22[2]);
-    return o;
-  } : (o, a22, b22) => {
-    !o && (o = b22);
-    o[0] = op(a22[0], b22[0]);
-    o[1] = op(a22[1], b22[1]);
-    o[2] = op(a22[2], b22[2]);
-    return o;
-  };
-  const d2 = outA ? (o, a22, b22) => {
-    !o && (o = a22);
-    o[0] = op(a22[0], b22[0]);
-    o[1] = op(a22[1], b22[1]);
-    o[2] = op(a22[2], b22[2]);
-    o[3] = op(a22[3], b22[3]);
-    return o;
-  } : (o, a22, b22) => {
-    !o && (o = b22);
-    o[0] = op(a22[0], b22[0]);
-    o[1] = op(a22[1], b22[1]);
-    o[2] = op(a22[2], b22[2]);
-    o[3] = op(a22[3], b22[3]);
-    return o;
-  };
-  return [
-    vop(dispatch, a2, b2, c2, d2),
-    b2,
-    c2,
-    d2
-  ];
-};
-const $add = (a2, b2) => a2 + b2;
-const $mul = (a2, b2) => a2 * b2;
-const $sub = (a2, b2) => a2 - b2;
-const [a$3, b] = defOpVV($add);
-const add = a$3;
-const add2 = b;
-const ZERO2 = Object.freeze([0, 0]);
-const ZERO3 = Object.freeze([0, 0, 0]);
-const cos = Math.cos;
-const sin = Math.sin;
-const cartesian = vop(1);
-cartesian.add(
-  2,
-  (out, v, offset = ZERO2) => add2(out || v, cossin(v[1], v[0]), offset)
-);
-cartesian.add(3, (out, v, offset = ZERO3) => {
-  const r = v[0];
-  const theta = v[1];
-  const phi = v[2];
-  const ct = cos(theta);
-  return setC3(
-    out || v,
-    r * ct * cos(phi) + offset[0],
-    r * ct * sin(phi) + offset[1],
-    r * sin(theta) + offset[2]
-  );
-});
-const cartesian2FromAngles = (angles, n) => {
-  const polar = [];
-  for (let x of angles) polar.push(cossin(x, n));
-  return polar;
-};
-const __ensureInputs = (src) => assert(src.length > 0, `no inputs given`);
-const [a$2] = defOpVN($mul);
-const mulN = a$2;
-const sum2 = (a2) => a2[0] + a2[1];
-const sum3 = (a2) => a2[0] + a2[1] + a2[2];
-const sum4 = (a2) => a2[0] + a2[1] + a2[2] + a2[3];
-const sum = vop(
-  0,
-  (v) => {
-    let res = 0;
-    for (let i = v.length; i-- > 0; ) res += v[i];
-    return res;
-  },
-  sum2,
-  sum3,
-  sum4
-);
-const mean = (out, src) => {
-  __ensureInputs(src);
-  out = set(out || [], src[0]);
-  for (let i = src.length; i-- > 1; ) {
-    add(out, out, src[i]);
-  }
-  return mulN(out, out, 1 / src.length);
-};
-const vmean = (a2) => a2.length > 0 ? sum(a2) / a2.length : 0;
-const [a$1] = defOpVN($sub);
-const subN = a$1;
-const center = (out, a2) => subN(out, a2, vmean(a2));
-const headingXY = (a2) => atan2Abs(a2[1], a2[0]);
-const magSq2 = (a2) => a2[0] * a2[0] + a2[1] * a2[1];
-const magSq3 = (a2) => a2[0] * a2[0] + a2[1] * a2[1] + a2[2] * a2[2];
-const magSq4 = (a2) => a2[0] * a2[0] + a2[1] * a2[1] + a2[2] * a2[2] + a2[3] * a2[3];
-const magSq = vop(
-  0,
-  (a2) => {
-    let sum5 = 0;
-    for (let i = a2.length; i-- > 0; ) sum5 += a2[i] * a2[i];
-    return sum5;
-  },
-  magSq2,
-  magSq3,
-  magSq4
-);
-const variance = (a2, isCentered = false, corrected = false) => {
-  const k = ~~corrected;
-  return a2.length > k ? magSq(isCentered ? a2 : center([], a2)) / (a2.length - k) : 0;
-};
-const sd = (a2, isCentered = false, corrected = false) => Math.sqrt(variance(a2, isCentered, corrected));
-const circularMean = (angles) => headingXY(mean([], cartesian2FromAngles(angles)));
-const centerCircular = (out, angles) => {
-  const mean2 = circularMean(angles);
-  !out && (out = []);
-  for (let i = 0, n = angles.length; i < n; i++) {
-    out[i] = (angles[i] - mean2 + PI) % TAU;
-  }
-  return center(null, out);
-};
-const circularSD = (angles, corrected) => sd(centerCircular([], angles), true, corrected);
-defOpVV(Math.max);
-const vmax = (v) => {
-  let max5 = -Infinity;
-  for (let i = v.length; i-- > 0; ) max5 = Math.max(max5, v[i]);
-  return max5;
-};
-const vmedian = (a2) => {
-  if (!a2.length) return 0;
-  const n = a2.length;
-  const m = n >> 1;
-  a2 = [...a2].sort((a22, b2) => a22 - b2);
-  return n & 1 ? a2[m] : (a2[m - 1] + a2[m]) * 0.5;
-};
-defOpVV(Math.min);
-const vmin = (v) => {
-  let min5 = Infinity;
-  for (let i = v.length; i-- > 0; ) min5 = Math.min(min5, v[i]);
-  return min5;
-};
-const defMetric = (values) => {
-  const [min2, max2] = valueRange(values);
-  return {
-    min: min2,
-    max: max2,
-    mean: vmean(values),
-    median: vmedian(values),
-    sd: sd(values)
-  };
-};
-const defWeightedMetric = (values, weights) => {
-  const [min2, max2] = valueRange(values);
-  return {
-    min: min2,
-    max: max2,
-    mean: vmean(values),
-    median: vmedian(values),
-    sd: sd(values),
-    weighted: dot(values, weights)
-  };
-};
-const defCircularMetric = (values) => {
-  const scaledValues = values.map((x) => x * TAU);
-  const mean2 = fract(circularMean(scaledValues) / TAU);
-  const [min2, max2] = circularRange(values, mean2);
-  return {
-    min: min2,
-    max: max2,
-    mean: mean2,
-    median: __circularMedian(values, min2, max2),
-    sd: circularSD(scaledValues) / TAU
-  };
-};
-const valueRange = (values) => [
-  vmin(values),
-  vmax(values)
-];
-const circularRange = (values, mean2) => {
-  const range = valueRange(values);
-  const [min2, max2] = range;
-  if (mean2 < min2 || mean2 > max2) {
-    return [
-      values.reduce(
-        (acc, x) => {
-          const d2 = fract(mean2 - x);
-          return d2 < 0.5 && d2 > acc[1] ? [x, d2] : acc;
-        },
-        [max2, fract(mean2 - max2)]
-      )[0],
-      values.reduce(
-        (acc, x) => {
-          const d2 = fract(x - mean2);
-          return d2 < 0.5 && d2 > acc[1] ? [x, d2] : acc;
-        },
-        [min2, fract(min2 - mean2)]
-      )[0]
-    ];
-  }
-  return range;
-};
-const __circularMedian = (values, min2, max2) => {
-  if (min2 <= max2) return vmedian(values);
-  const n = values.length;
-  const m = n >> 1;
-  const sorted = [...values].sort((a2, b2) => a2 - b2);
-  const split = sorted.findIndex((x) => x === min2);
-  const reordered = sorted.slice(split).concat(sorted.slice(0, split));
-  return n & 1 ? reordered[m] : (reordered[m - 1] + reordered[m]) * 0.5;
-};
-const isFunction = (x) => typeof x === "function";
-const distSq2 = (a2, b2) => {
-  const dx = a2[0] - b2[0];
-  const dy = a2[1] - b2[1];
-  return dx * dx + dy * dy;
-};
-const distSq3 = (a2, b2) => {
-  const dx = a2[0] - b2[0];
-  const dy = a2[1] - b2[1];
-  const dz = a2[2] - b2[2];
-  return dx * dx + dy * dy + dz * dz;
-};
-const distSq4 = (a2, b2) => {
-  const dx = a2[0] - b2[0];
-  const dy = a2[1] - b2[1];
-  const dz = a2[2] - b2[2];
-  const dw = a2[3] - b2[3];
-  return dx * dx + dy * dy + dz * dz + dw * dw;
-};
-const distSq = vop(
-  0,
-  (a2, b2) => {
-    let sum5 = 0;
-    for (let i = a2.length; i-- > 0; ) {
-      const d2 = a2[i] - b2[i];
-      sum5 += d2 * d2;
-    }
-    return sum5;
-  },
-  distSq2,
-  distSq3,
-  distSq4
-);
-class Squared {
-  constructor(metric) {
-    this.metric = metric;
-  }
-  to(x) {
-    return x * x;
-  }
-  from(x) {
-    return Math.sqrt(x);
-  }
-}
-const DIST_SQ = new Squared(distSq);
-const argmin = (p, samples, dist = DIST_SQ) => {
-  const distFn = isFunction(dist) ? dist : dist.metric;
-  let minD = Infinity;
-  let minArg = -1;
-  for (let i = 0, n = samples.length; i < n; i++) {
-    const d2 = distFn(p, samples[i]);
-    if (d2 < minD) {
-      minD = d2;
-      minArg = i;
-    }
-  }
-  return minArg;
-};
-const setN2 = (a2, n) => {
-  a2[0] = n;
-  a2[1] = n;
-  return a2;
-};
-const setN3 = (a2, n) => {
-  a2[0] = n;
-  a2[1] = n;
-  a2[2] = n;
-  return a2;
-};
-const setN4 = (a2, n) => {
-  a2[0] = n;
-  a2[1] = n;
-  a2[2] = n;
-  a2[3] = n;
-  return a2;
-};
-vop(
-  0,
-  (a2, n) => {
-    for (let i = a2.length; i-- > 0; ) a2[i] = n;
-    return a2;
-  },
-  setN2,
-  setN3,
-  setN4
-);
-const zeroes = (n) => Array(n).fill(0);
-const ones = (n) => Array(n).fill(1);
-const kmeans = (k, samples, opts = {}) => {
-  let {
-    dim = samples[0].length,
-    dist = DIST_SQ,
-    maxIter = 32,
-    strategy = means,
-    exponent,
-    initial,
-    rnd
-  } = opts;
-  const num = samples.length;
-  const centroids = Array.isArray(initial) ? initial : initial ? initial(k, samples, dist, rnd) : kmeansPlusPlus(k, samples, dist, rnd, exponent);
-  assert(centroids.length > 0, `missing initial centroids`);
-  k = centroids.length;
-  const clusters = new Uint32Array(num).fill(k);
-  let update = true;
-  while (update && maxIter-- > 0) {
-    update = __assign(samples, centroids, clusters, dist);
-    if (!update) break;
-    for (let i = 0; i < k; i++) {
-      const impl = strategy(dim);
-      for (let j = 0; j < num; j++) {
-        i === clusters[j] && impl.update(samples[j]);
-      }
-      const centroid = impl.finish();
-      if (centroid) centroids[i] = centroid;
-    }
-  }
-  return __buildClusters(centroids, clusters);
-};
-const kmeansPlusPlus = (k, samples, dist = DIST_SQ, rnd = SYSTEM, exponent = 2) => {
-  const num = samples.length;
-  assert(num > 0, `missing samples`);
-  k = Math.min(k, num);
-  const centroidIDs = [rnd.int() % num];
-  const centroids = [samples[centroidIDs[0]]];
-  const indices = new Array(num).fill(0).map((_, i) => i);
-  const metric = dist.metric;
-  while (centroidIDs.length < k) {
-    let psum = 0;
-    const probs = samples.map((p) => {
-      const d2 = dist.from(metric(p, centroids[argmin(p, centroids, dist)])) ** exponent;
-      psum += d2;
-      return d2;
-    });
-    if (!psum) break;
-    let id;
-    do {
-      id = weightedRandom(indices, probs, rnd)();
-    } while (centroidIDs.includes(id));
-    centroidIDs.push(id);
-    centroids.push(samples[id]);
-  }
-  return centroids;
-};
-const __assign = (samples, centroids, assignments, dist) => {
-  let update = false;
-  for (let i = samples.length; i-- > 0; ) {
-    const id = argmin(samples[i], centroids, dist);
-    if (id !== assignments[i]) {
-      assignments[i] = id;
-      update = true;
-    }
-  }
-  return update;
-};
-const __buildClusters = (centroids, assignments) => {
-  const clusters = [];
-  for (let i = 0, n = assignments.length; i < n; i++) {
-    const id = assignments[i];
-    (clusters[id] || (clusters[id] = {
-      id,
-      centroid: centroids[id],
-      items: []
-    })).items.push(i);
-  }
-  return clusters.filter((x) => !!x);
-};
-const means = (dim) => {
-  const acc = zeroes(dim);
-  let n = 0;
-  return {
-    update: (p) => {
-      add(acc, acc, p);
-      n++;
-    },
-    finish: () => n ? mulN(acc, acc, 1 / n) : void 0
-  };
-};
-const filterSamples = (pred, img) => {
-  const samples = [];
-  let i = 0;
-  for (let p of img) {
-    if (pred(p, i)) samples.push(p);
-    i++;
-  }
-  return samples;
-};
-const dominantColorsKmeans = (img, num, opts) => {
-  const samples = opts?.filter ? filterSamples(opts.filter, img) : Array.isArray(img) ? img : [...img];
-  return samples.length ? kmeans(Math.min(num, samples.length), samples, opts).sort((a2, b2) => b2.items.length - a2.items.length).map(
-    (c2) => ({
-      color: [...c2.centroid],
-      area: c2.items.length / samples.length,
-      ids: c2.items
-    })
-  ) : [];
-};
-const isIterable = (x) => typeof x?.[Symbol.iterator] === "function";
-const compR = (rfn, fn) => [rfn[0], rfn[1], fn];
-const SEMAPHORE = Symbol();
-const NO_OP = () => {
-};
-const ensureTransducer = (x) => implementsFunction(x, "xform") ? x.xform() : x;
-const IllegalArityError = defError(() => "illegal arity");
-const illegalArity = (n) => {
-  throw new IllegalArityError(n);
-};
-class Reduced {
-  value;
-  constructor(val) {
-    this.value = val;
-  }
-  deref() {
-    return this.value;
-  }
-}
-const isReduced = (x) => x instanceof Reduced;
-const ensureReduced = (x) => x instanceof Reduced ? x : new Reduced(x);
-const unreduced = (x) => x instanceof Reduced ? x.deref() : x;
-const __parseArgs = (args) => args.length === 2 ? [void 0, args[1]] : args.length === 3 ? [args[1], args[2]] : illegalArity(args.length);
-function reduce(...args) {
-  const rfn = args[0];
-  const init = rfn[0];
-  const complete = rfn[1];
-  const reduce2 = rfn[2];
-  args = __parseArgs(args);
-  const acc = args[0] == null ? init() : args[0];
-  const src = args[1];
-  return unreduced(
-    complete(
-      implementsFunction(src, "$reduce") ? src.$reduce(reduce2, acc) : isArrayLike(src) ? __reduceArray(reduce2, acc, src) : __reduceIterable(reduce2, acc, src)
-    )
-  );
-}
-const __reduceArray = (rfn, acc, src) => {
-  for (let i = 0, n = src.length; i < n; i++) {
-    acc = rfn(acc, src[i]);
-    if (isReduced(acc)) {
-      acc = acc.deref();
-      break;
-    }
-  }
-  return acc;
-};
-const __reduceIterable = (rfn, acc, src) => {
-  for (let x of src) {
-    acc = rfn(acc, x);
-    if (isReduced(acc)) {
-      acc = acc.deref();
-      break;
-    }
-  }
-  return acc;
-};
-const reducer = (init, rfn) => [init, identity$1, rfn];
-const $$reduce = (rfn, args) => {
-  const n = args.length - 1;
-  return isIterable(args[n]) ? args.length > 1 ? reduce(rfn.apply(null, args.slice(0, n)), args[n]) : reduce(rfn(), args[0]) : void 0;
-};
-function push(src) {
-  return src ? [...src] : reducer(
-    () => [],
-    (acc, x) => (acc.push(x), acc)
-  );
-}
-function* iterator(xform, src) {
-  const rfn = ensureTransducer(xform)(push());
-  const complete = rfn[1];
-  const reduce2 = rfn[2];
-  for (let x of src) {
-    const y = reduce2([], x);
-    if (isReduced(y)) {
-      yield* unreduced(complete(y.deref()));
-      return;
-    }
-    if (y.length) {
-      yield* y;
-    }
-  }
-  yield* unreduced(complete([]));
-}
-function* iterator1(xform, src) {
-  const reduce2 = ensureTransducer(xform)([NO_OP, NO_OP, (_, x) => x])[2];
-  for (let x of src) {
-    let y = reduce2(SEMAPHORE, x);
-    if (isReduced(y)) {
-      y = unreduced(y.deref());
-      if (y !== SEMAPHORE) {
-        yield y;
-      }
-      return;
-    }
-    if (y !== SEMAPHORE) {
-      yield y;
-    }
-  }
-}
-function map(fn, src) {
-  return isIterable(src) ? iterator1(map(fn), src) : (rfn) => {
-    const r = rfn[2];
-    return compR(rfn, (acc, x) => r(acc, fn(x)));
-  };
-}
-function max(src) {
-  return src ? reduce(max(), src) : reducer(
-    () => -Infinity,
-    (acc, x) => Math.max(acc, x)
-  );
-}
-const ensureIterable = (x) => {
-  (x == null || !x[Symbol.iterator]) && illegalArgs(`value is not iterable: ${x}`);
-  return x;
-};
-const ensureArray = (x) => isArray(x) ? x : [...ensureIterable(x)];
-const ensureArrayLike = (x) => isArrayLike(x) ? x : [...ensureIterable(x)];
-function* permutations(...src) {
-  const n = src.length - 1;
-  if (n < 0) {
-    return;
-  }
-  const step = new Array(n + 1).fill(0);
-  const realized = src.map(ensureArrayLike);
-  const total = realized.reduce((acc, x) => acc * x.length, 1);
-  for (let i = 0; i < total; i++) {
-    const tuple = [];
-    for (let j = n; j >= 0; j--) {
-      const r = realized[j];
-      let s = step[j];
-      if (s === r.length) {
-        step[j] = s = 0;
-        j > 0 && step[j - 1]++;
-      }
-      tuple[j] = r[s];
-    }
-    step[n]++;
-    yield tuple;
-  }
-}
-function transduce(...args) {
-  return $transduce(transduce, reduce, args);
-}
-const $transduce = (tfn, rfn, args) => {
-  let acc, src;
-  switch (args.length) {
-    case 4:
-      src = args[3];
-      acc = args[2];
-      break;
-    case 3:
-      src = args[2];
-      break;
-    case 2:
-      return map((x) => tfn(args[0], args[1], x));
-    default:
-      illegalArity(args.length);
-  }
-  return rfn(ensureTransducer(args[0])(args[1]), acc, src);
-};
-const [a] = defOpVN(roundTo);
-const roundN = a;
-const smoothStep = (edge, edge2, x) => smoothStep01(clamp01((x - edge) / (edge2 - edge)));
-const smoothStep01 = (x) => x * x * (3 - 2 * x);
-function comp$1(...fns) {
-  let [a2, b2, c2, d2, e, f, g, h, i, j] = fns;
-  switch (fns.length) {
-    case 0:
-      illegalArity(0);
-    case 1:
-      return a2;
-    case 2:
-      return (...args) => a2(b2(...args));
-    case 3:
-      return (...args) => a2(b2(c2(...args)));
-    case 4:
-      return (...args) => a2(b2(c2(d2(...args))));
-    case 5:
-      return (...args) => a2(b2(c2(d2(e(...args)))));
-    case 6:
-      return (...args) => a2(b2(c2(d2(e(f(...args))))));
-    case 7:
-      return (...args) => a2(b2(c2(d2(e(f(g(...args)))))));
-    case 8:
-      return (...args) => a2(b2(c2(d2(e(f(g(h(...args))))))));
-    case 9:
-      return (...args) => a2(b2(c2(d2(e(f(g(h(i(...args)))))))));
-    case 10:
-    default:
-      const fn = (...args) => a2(b2(c2(d2(e(f(g(h(i(j(...args))))))))));
-      return fns.length === 10 ? fn : comp$1(fn, ...fns.slice(10));
-  }
-}
-function comp(...fns) {
-  fns = fns.map(ensureTransducer);
-  return comp$1.apply(null, fns);
-}
-function count(...args) {
-  const res = $$reduce(count, args);
-  if (res !== void 0) {
-    return res;
-  }
-  const [offset = 0, step = 1] = args;
-  return reducer(
-    () => offset,
-    (acc, _) => acc + step
-  );
-}
-const identity = (x) => x;
-const __groupByOpts = (opts) => ({
-  key: (x) => x,
-  group: push(),
-  ...opts
-});
-function groupByMap(...args) {
-  const res = $$reduce(groupByMap, args);
-  if (res !== void 0) return res;
-  const opts = __groupByOpts(args[0]);
-  const [init, complete, reduce2] = opts.group;
-  return [
-    () => /* @__PURE__ */ new Map(),
-    (acc) => {
-      for (let k of acc.keys()) {
-        acc.set(k, complete(acc.get(k)));
-      }
-      return acc;
-    },
-    (acc, x) => {
-      const k = opts.key(x);
-      return acc.set(
-        k,
-        acc.has(k) ? reduce2(acc.get(k), x) : reduce2(init(), x)
-      );
-    }
-  ];
-}
-function frequencies(...args) {
-  return $$reduce(frequencies, args) || groupByMap({ key: args[0] || identity, group: count() });
-}
-function normFrequenciesAuto(...args) {
-  const res = $$reduce(normFrequenciesAuto, args);
-  if (res !== void 0) return res;
-  const [init, complete, reduce2] = frequencies(...args);
-  let norm2 = 0;
-  return [
-    init,
-    (acc) => {
-      acc = complete(acc);
-      for (let p of acc) {
-        acc.set(p[0], p[1] / norm2);
-      }
-      return acc;
-    },
-    (acc, x) => (norm2++, reduce2(acc, x))
-  ];
-}
-const cat = () => (rfn) => {
-  const r = rfn[2];
-  return compR(rfn, (acc, x) => {
-    if (x) {
-      for (let y of unreduced(x) || []) {
-        acc = r(acc, y);
-        if (isReduced(acc)) {
-          break;
-        }
-      }
-    }
-    return isReduced(x) ? ensureReduced(acc) : acc;
-  });
-};
-function mapcat(fn, src) {
-  return isIterable(src) ? iterator(mapcat(fn), src) : comp(map(fn), cat());
-}
-function* repeat(x, n = Infinity) {
-  while (n-- > 0) {
-    yield x;
-  }
-}
-const temperature = (colors, minSat = 0.2, coeffs) => {
-  const $colors = ensureArray(colors);
-  const filtered = $colors.filter((x) => x[1] >= minSat);
-  const area = filtered.length / $colors.length;
-  const hues = [
-    ...transduce(
-      map((x) => roundTo(x[0], 1 / 12) % 1),
-      normFrequenciesAuto(),
-      filtered
-    )
-  ].sort(compareByKey(0));
-  const angles = [
-    ...mapcat(([hue, num]) => {
-      num *= 50;
-      return num >= 1 ? repeat(hue * TAU, num) : null;
-    }, hues)
-  ];
-  if (!angles.length) {
-    return { hues, meanHue: 0, temp: 0, areaTemp: 0, area: 0 };
-  }
-  const meanHue = circularMean(angles) / TAU;
-  const temp = hueTemperature(meanHue, coeffs);
-  const areaTemp = temp * area;
-  return { hues, meanHue, temp, areaTemp, area };
-};
-const DEFAULT_TEMPERATURE_COEFFS = [
-  0.1,
-  0.6,
-  0.72,
-  0.92
-];
-const hueTemperature = (hue, [a2, b2, c2, d2] = DEFAULT_TEMPERATURE_COEFFS) => 2 * (hue < 2 / 3 ? smoothStep(b2, a2, hue) : smoothStep(c2, d2, hue)) - 1;
-const analyzeColors = (img, opts) => {
-  let $img = img.format !== FLOAT_RGBA ? img.as(FLOAT_RGBA) : img;
-  if (opts?.size) $img = __resize($img, opts.size);
-  const imgGray = $img.as(FLOAT_GRAY);
-  const imgHsv = $img.as(FLOAT_HSVA);
-  const colors = __dominantColors($img, opts);
-  const colorAreas = colors.map((x) => x.area);
-  const derived = deriveColorResults(
-    colors.map((x) => x.color),
-    colorAreas,
-    opts?.minSat,
-    opts?.tempCoeffs
-  );
-  const lumImg = defMetric(imgGray.data);
-  return {
-    ...derived,
-    img: $img,
-    imgGray,
-    imgHsv,
-    lumImg,
-    temperature: temperature(imgHsv, opts?.minSat, opts?.tempCoeffs),
-    contrastImg: lumImg.max - lumImg.min
-  };
-};
-const deriveColorResults = (colors, areas = ones(colors.length), minSat, tempCoeffs) => {
-  const dominantLuma = colors.map((x) => luminanceSrgb(x));
-  const dominantSrgb = colors.map((x) => srgb(x));
-  const dominantHsv = dominantSrgb.map((x) => hsv(x));
-  const dominantOklch = dominantSrgb.map((x) => oklch(x));
-  const dominantCss = dominantSrgb.map((x) => css(x));
-  const hues = dominantHsv.map((x) => x[0]);
-  const sats = dominantHsv.map((x) => x[1]);
-  const lum = defWeightedMetric(dominantLuma, areas);
-  return {
-    css: dominantCss,
-    srgb: dominantSrgb,
-    hsv: dominantHsv,
-    oklch: dominantOklch,
-    hue: defCircularMetric(hues),
-    sat: defWeightedMetric(sats, areas),
-    chroma: defWeightedMetric(
-      dominantOklch.map((x) => x[1]),
-      areas
-    ),
-    lum,
-    areas,
-    contrast: lum.max - lum.min,
-    colorContrast: fit(
-      transduce(
-        map((pair) => contrast(...pair)),
-        max(),
-        permutations(dominantSrgb, dominantSrgb)
-      ),
-      1,
-      21,
-      0,
-      1
-    ),
-    temperature: temperature(dominantHsv, minSat, tempCoeffs)
-  };
-};
-const __dominantColors = (img, {
-  dominantFn = dominantColorsKmeans,
-  numColors = 4,
-  prec = 1e-3
-} = {}) => dominantFn(img, numColors).sort(compareByKey("area", compareNumDesc)).map((x) => (roundN(null, x.color, prec), x));
-const __resize = ($img, size) => {
-  size = ~~size;
-  let w = $img.width;
-  let h = $img.height;
-  [w, h] = w > h ? [size, ~~Math.max(1, h / w * size)] : [~~Math.max(1, w / h * size), size];
-  return $img.resize(w, h);
-};
-/**
- * Options for extracting colors / evaluating lightness from an image.
- *
- * @typedef {Object} ImageAnalysisSettings
- * @property {number} [numColors=2] - Number of dominant colors to return.
- * @property {number} [lightnessThreshold=0.5] - Threshold (0.0 - 1.0) used to decide if a color is considered "light".
- * @property {number} [yFrom=0.0] - Minimum Y (luminance) value (0.0 - 1.0) to include when evaluating lightness.
- * @property {number} [yTo=1.0] - Maximum Y (luminance) value (0.0 - 1.0) to include when evaluating lightness.
- * @property {number} [maxSize=320] - Maximum width/height to scale down the image to before analysis, for performance.
- * @property {number} [alphaThreshold=30] - Threhold (0-255) below which a pixel is considered "transparent" for the purposes of analysis.
- *
- * @preserve
- */
-const defaultAnalysisSettings = {
-  numColors: 3,
-  lightnessThreshold: 0.5,
-  yFrom: 0,
-  yTo: 1,
-  maxSize: 320,
-  alphaThreshold: 30
-};
-/**
- * Analyze an image element to determine overall luminance, dominant colors and transparency.
- *
- * @param {string} url - URL of the image to check.
- * @param {ImageAnalysisSettings} [settings] - Optional settings to customize the analysis.
- *
- * @returns {{ isDark: boolean, dominantColors: Array<{ color: string, area: number, isDark: boolean }>, isTransparent: boolean } | false}
- *   Returns an object on success:
- *     - isDark: true if the computed mean image luminance is below 0.5.
- *     - dominantColors: an array of up to the requested number of dominant colors. Each entry contains:
- *         - color: CSS color string (as produced by the analyzer).
- *         - area: the relative area (weight) of that color.
- *         - isDark: boolean indicating whether the color's lightness (oklch.l) is < 0.5.
- *     - isTransparent: true if any inspected pixel has alpha < 255.
- *   Returns false if an error occurred during analysis.
- *
- * @preserve
- */
-const analyzeImage = (image, rawSettings) => {
-  const settings = { ...defaultAnalysisSettings, ...rawSettings };
-  const { numColors, lightnessThreshold, yFrom, yTo, maxSize } = settings;
-  try {
-    const fileExtension = getFileExtension(image.src);
-    let skipTransparencyCheck = false;
-    if (fileExtension) {
-      skipTransparencyCheck = !["png", "webp", "gif", "tiff", "svg", "avif"].includes(fileExtension);
-    }
-    const imageWidth = image.naturalWidth;
-    const imageHeight = image.naturalHeight;
-    if (!imageWidth || !imageHeight) {
-      return false;
-    }
-    let imageScale = 1;
-    if (imageWidth > maxSize || imageHeight > maxSize) {
-      imageScale = Math.min(maxSize / imageWidth, maxSize / imageHeight);
-    }
-    const imageWidthScaled = Math.floor(imageWidth * imageScale);
-    const imageHeightScaled = Math.floor(imageHeight * imageScale);
-    const srcX = 0;
-    const srcY = Math.floor(yFrom * imageHeight);
-    const srcW = Math.max(1, imageWidth);
-    const srcH = Math.max(1, Math.ceil((yTo - yFrom) * imageHeight));
-    const destW = Math.max(1, imageWidthScaled);
-    const destH = Math.max(1, Math.ceil((yTo - yFrom) * imageHeightScaled));
-    const colorCanvas = document.createElement("canvas");
-    colorCanvas.width = destW;
-    colorCanvas.height = destH;
-    const colorContext = colorCanvas.getContext("2d");
-    colorContext.drawImage(image, srcX, srcY, srcW, srcH, 0, 0, destW, destH);
-    const buffer = floatBufferFromCanvas(colorCanvas, FLOAT_RGBA);
-    const data = analyzeColors(buffer, {
-      numColors,
-      dominantFn: (pixels, num) => dominantColorsKmeans(pixels, num, {
-        filter: (p) => {
-          const { alpha } = srgb(p);
-          return alpha > 0;
-        }
-      }),
-      prec: 0.01
-    });
-    const { lumImg, srgb: srgbData, areas: colorAreas } = data;
-    let transparencyInfo = false;
-    if (!skipTransparencyCheck) {
-      const transparencyCanvas = document.createElement("canvas");
-      transparencyCanvas.width = imageWidthScaled;
-      transparencyCanvas.height = imageHeightScaled;
-      const transparencyContext = transparencyCanvas.getContext("2d", { willReadFrequently: true });
-      transparencyContext.drawImage(image, 0, 0, imageWidth, imageHeight, 0, 0, imageWidthScaled, imageHeightScaled);
-      const imageData = transparencyContext.getImageData(0, 0, imageWidthScaled, imageHeightScaled).data;
-      transparencyInfo = checkTransparency(imageData, imageWidthScaled, imageHeightScaled, settings);
-    }
-    return {
-      isDark: lumImg.mean < lightnessThreshold,
-      isTransparent: skipTransparencyCheck ? false : transparencyInfo?.any,
-      transparencyInfo: skipTransparencyCheck ? null : transparencyInfo,
-      dominantColors: srgbData.map(({ r, g, b: b2 }, index) => ({
-        color: css([r, g, b2]),
-        area: colorAreas?.[index],
-        isDark: isColorDark(r * 255, g * 255, b2 * 255, lightnessThreshold)
-      }))
-    };
-  } catch (error) {
-    console.error("Error analyzing image:", error);
-    return false;
-  }
-};
-/**
- * Check image transparency by analyzing pixel alpha values.
- *
- * @param {Uint8ClampedArray} imageData - The image data array containing RGBA values.
- * @param {number} w - The width of the image.
- * @param {number} h - The height of the image.
- * @param {ImageAnalysisSettings} [settings] - Optional settings to customize the transparency check.
- *
- * @return {{ any: boolean, left: boolean, right: boolean, top: boolean, bottom: boolean }} An object indicating transparency on different sides of the image.
- *
- * @preserve
- */
-const checkTransparency = (imageData, w, h, settings = {}) => {
-  const { alphaThreshold } = { ...defaultAnalysisSettings, ...settings };
-  const transparency = {
-    any: true,
-    left: true,
-    right: true,
-    top: true,
-    bottom: true
-  };
-  let counts = {
-    any: 0,
-    left: 0,
-    right: 0,
-    top: 0,
-    bottom: 0
-  };
-  const perimeterThresholdW = Math.floor(0.15 * w);
-  const perimeterThresholdH = Math.floor((h > 100 ? 0.05 : 0.5) * h);
-  const innerThreshold = Math.floor(w * h * 1e-3);
-  if (w > 0 && h > 0) {
-    for (let x = 0; x < w; x++) {
-      const idx = (0 * w + x) * 4 + 3;
-      if (imageData[idx] > alphaThreshold) {
-        counts.top++;
-        if (counts.top >= perimeterThresholdW) {
-          transparency.top = false;
-          break;
-        }
-      }
-    }
-    for (let x = 0; x < w; x++) {
-      const idx = ((h - 1) * w + x) * 4 + 3;
-      if (imageData[idx] > alphaThreshold) {
-        counts.bottom++;
-        if (counts.bottom >= perimeterThresholdW) {
-          transparency.bottom = false;
-          break;
-        }
-      }
-    }
-    for (let y = 0; y < h; y++) {
-      const idx = (y * w + 0) * 4 + 3;
-      if (imageData[idx] > alphaThreshold) {
-        counts.left++;
-        if (counts.left >= perimeterThresholdH) {
-          transparency.left = false;
-          break;
-        }
-      }
-    }
-    for (let y = 0; y < h; y++) {
-      const idx = (y * w + (w - 1)) * 4 + 3;
-      if (imageData[idx] > alphaThreshold) {
-        counts.right++;
-        if (counts.right >= perimeterThresholdH) {
-          transparency.right = false;
-          break;
-        }
-      }
-    }
-    if (!transparency.top && !transparency.bottom && !transparency.left && !transparency.right) {
-      for (let i = 3; i < imageData.length; i += 4) {
-        if (imageData[i] > alphaThreshold) {
-          counts.any++;
-          if (counts.any >= innerThreshold) {
-            transparency.any = false;
-            break;
-          }
-        }
-      }
-    } else {
-      transparency.any = true;
-    }
-  }
-  return transparency;
-};
-/**
- * Get file extension from a URL string.
- *
- * @param {string} input - The URL string to extract the file extension from.
- *
- * @returns {string|null} The file extension in lowercase, or null if not found.
- *
- * @example
- * getFileExtension('https://example.com/image.png'); // 'png'
- * getFileExtension('https://example.com/archive.tar.gz'); // 'gz'
- * getFileExtension('https://example.com/no-extension'); // null
- *
- * @preserve
- */
-const getFileExtension = (input) => {
-  const url = new URL(input);
-  const pathname = url.pathname;
-  const match = pathname.match(/\.([a-zA-Z0-9]+)(?:\?|#|$)/);
-  return match ? match[1].toLowerCase() : null;
-};
-/**
- * Determine if a color is considered "dark" based on its RGB values and a lightness threshold.
- *
- * @param {number} r - Red component (0-255).
- * @param {number} g - Green component (0-255).
- * @param {number} b - Blue component (0-255).
- * @param {number} [threshold=0.5] - Lightness threshold (0.0 - 1.0) below which the color is considered dark.
- *
- * @returns {boolean} True if the color is dark, false otherwise.
- *
- * @example
- * isColorDark(0, 0, 0); // true (black)
- * isColorDark(255, 255, 255); // false (white)
- * isColorDark(100, 100, 100, 0.4); // false (gray with higher threshold)
- *
- * @preserve
- */
-const isColorDark = (r, g, b2, threshold = 0.5) => {
-  const luminance = (0.299 * r + 0.587 * g + 0.114 * b2) / 255;
-  return luminance < threshold;
-};
+import "./hash.js";
+import { a, b, d, c, g, i } from "../general-Ck8IV7xJ.js";
 export {
-  analyzeImage,
-  checkTransparency,
-  getFileExtension,
-  isColorDark
+  a as analyzeImage,
+  b as analyzeImageAsync,
+  d as analyzeImageData,
+  c as checkTransparency,
+  g as getFileExtension,
+  i as isColorDark
 };