@pixerate/editor 0.87.0 → 0.89.0

package/dist/chunk-D4ZCU72J.js

@@ -0,0 +1,604 @@
+// src/raster/surface.ts
+var TILE = 256;
+var TILE_SHIFT = 8;
+var TILE_PIXELS = TILE * TILE;
+var KEY_OFFSET = 1 << 15;
+var KEY_SPAN = 1 << 16;
+function tileKey(tx, ty) {
+  return (ty + KEY_OFFSET) * KEY_SPAN + (tx + KEY_OFFSET);
+}
+function tileCoord(key) {
+  return { tx: key % KEY_SPAN - KEY_OFFSET, ty: Math.floor(key / KEY_SPAN) - KEY_OFFSET };
+}
+function tileRect(tx, ty) {
+  return { x: tx * TILE, y: ty * TILE, width: TILE, height: TILE };
+}
+var nextSurfaceId = 1;
+var TiledSurface = class {
+  constructor(channels, tiles, defaultValue = 0) {
+    this.channels = channels;
+    this.tiles = tiles;
+    this.defaultValue = defaultValue;
+  }
+  channels;
+  tiles;
+  defaultValue;
+  /** Unique per instance: a cache key that changes whenever the pixels can have changed. */
+  id = nextSurfaceId++;
+  boundsCache;
+  /** Bounds of the stored (non-default) tiles, tile-aligned; `null` when there are none. */
+  get bounds() {
+    if (this.boundsCache === void 0) this.boundsCache = tileUnion(this.tiles.keys());
+    return this.boundsCache;
+  }
+  get tileCount() {
+    return this.tiles.size;
+  }
+  getTile(tx, ty) {
+    return this.tiles.get(tileKey(tx, ty));
+  }
+};
+function tileUnion(keys) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const key of keys) {
+    const { tx, ty } = tileCoord(key);
+    if (tx < x0) x0 = tx;
+    if (ty < y0) y0 = ty;
+    if (tx > x1) x1 = tx;
+    if (ty > y1) y1 = ty;
+  }
+  if (x0 === Infinity) return null;
+  return { x: x0 * TILE, y: y0 * TILE, width: (x1 - x0 + 1) * TILE, height: (y1 - y0 + 1) * TILE };
+}
+var uniformTiles = /* @__PURE__ */ new Map();
+var UNIFORM_LIMIT = 64;
+function packPixel(data, offset, channels) {
+  return channels === 1 ? data[offset] : (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+}
+function uniformTile(channels, value) {
+  const key = `${channels}:${value}`;
+  let tile = uniformTiles.get(key);
+  if (tile) return tile;
+  const data = new Uint8ClampedArray(TILE_PIXELS * channels);
+  if (channels === 1) data.fill(value);
+  else if (value !== 0) {
+    const r = value >>> 24;
+    const g = value >>> 16 & 255;
+    const b = value >>> 8 & 255;
+    const a = value & 255;
+    for (let i = 0; i < data.length; i += 4) {
+      data[i] = r;
+      data[i + 1] = g;
+      data[i + 2] = b;
+      data[i + 3] = a;
+    }
+  }
+  tile = { data, uniform: value };
+  if (uniformTiles.size >= UNIFORM_LIMIT) uniformTiles.delete(uniformTiles.keys().next().value);
+  uniformTiles.set(key, tile);
+  return tile;
+}
+function packRgba(r, g, b, a) {
+  return (r << 24 | g << 16 | b << 8 | a) >>> 0;
+}
+function defaultPacked(channels, defaultValue) {
+  return channels === 1 ? defaultValue : packRgba(defaultValue, defaultValue, defaultValue, defaultValue);
+}
+function uniformValue(data, channels) {
+  if (channels === 1) {
+    const v = data[0];
+    for (let i = 1; i < data.length; i++) if (data[i] !== v) return null;
+    return v;
+  }
+  const words = new Uint32Array(data.buffer, data.byteOffset, data.length >> 2);
+  const w = words[0];
+  for (let i = 1; i < words.length; i++) if (words[i] !== w) return null;
+  return packPixel(data, 0, 4);
+}
+function finishTile(data, channels, defaultValue) {
+  const u = uniformValue(data, channels);
+  if (u === null) return { data, uniform: null };
+  if (u === defaultPacked(channels, defaultValue)) return null;
+  return uniformTile(channels, u);
+}
+function emptySurface(channels = 4, defaultValue = 0) {
+  return new TiledSurface(channels, /* @__PURE__ */ new Map(), defaultValue);
+}
+function solidSurface(channels, rect, value, defaultValue = 0) {
+  const bytes = new Uint8ClampedArray(channels);
+  if (channels === 1) bytes[0] = value;
+  else {
+    bytes[0] = value >>> 24;
+    bytes[1] = value >>> 16 & 255;
+    bytes[2] = value >>> 8 & 255;
+    bytes[3] = value & 255;
+  }
+  return fillRect(emptySurface(channels, defaultValue), rect, bytes);
+}
+function surfaceFromPixels(pixels, channels = 4, x = 0, y = 0, defaultValue = 0) {
+  return writeRegion(emptySurface(channels, defaultValue), { x, y, width: pixels.width, height: pixels.height }, pixels.data);
+}
+function tilesInRect(rect) {
+  const out = [];
+  if (rect.width <= 0 || rect.height <= 0) return out;
+  const tx0 = Math.floor(rect.x / TILE);
+  const ty0 = Math.floor(rect.y / TILE);
+  const tx1 = Math.floor((rect.x + rect.width - 1) / TILE);
+  const ty1 = Math.floor((rect.y + rect.height - 1) / TILE);
+  for (let ty = ty0; ty <= ty1; ty++) for (let tx = tx0; tx <= tx1; tx++) out.push({ tx, ty });
+  return out;
+}
+function readRegion(surface, rect, out) {
+  const ch = surface.channels;
+  const w = rect.width;
+  const h = rect.height;
+  const dst = out ?? new Uint8ClampedArray(w * h * ch);
+  if (surface.defaultValue !== 0) dst.fill(surface.defaultValue);
+  else if (out) dst.fill(0);
+  for (const { tx, ty } of tilesInRect(rect)) {
+    const tile = surface.getTile(tx, ty);
+    if (!tile) continue;
+    const ox = tx * TILE;
+    const oy = ty * TILE;
+    const x0 = Math.max(rect.x, ox);
+    const y0 = Math.max(rect.y, oy);
+    const x1 = Math.min(rect.x + w, ox + TILE);
+    const y1 = Math.min(rect.y + h, oy + TILE);
+    const span = (x1 - x0) * ch;
+    for (let yy = y0; yy < y1; yy++) {
+      const s = ((yy - oy) * TILE + (x0 - ox)) * ch;
+      const d = ((yy - rect.y) * w + (x0 - rect.x)) * ch;
+      dst.set(tile.data.subarray(s, s + span), d);
+    }
+  }
+  return dst;
+}
+function readPixel(surface, x, y) {
+  const tile = surface.getTile(Math.floor(x / TILE), Math.floor(y / TILE));
+  const ch = surface.channels;
+  if (!tile) return new Array(ch).fill(surface.defaultValue);
+  const i = ((y & TILE - 1) * TILE + (x & TILE - 1)) * ch;
+  return Array.from(tile.data.subarray(i, i + ch));
+}
+function contentBounds(surface) {
+  const ch = surface.channels;
+  const def = surface.defaultValue;
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const [key, tile] of surface.tiles) {
+    const { tx, ty } = tileCoord(key);
+    const ox = tx * TILE;
+    const oy = ty * TILE;
+    if (tile.uniform !== null) {
+      if (ox < x0) x0 = ox;
+      if (oy < y0) y0 = oy;
+      if (ox + TILE - 1 > x1) x1 = ox + TILE - 1;
+      if (oy + TILE - 1 > y1) y1 = oy + TILE - 1;
+      continue;
+    }
+    const d = tile.data;
+    for (let y = 0; y < TILE; y++) {
+      let first = -1;
+      let last = -1;
+      const row = y * TILE * ch;
+      for (let x = 0; x < TILE; x++) {
+        const i = row + x * ch;
+        let differs = false;
+        for (let c = 0; c < ch; c++) if (d[i + c] !== def) differs = true;
+        if (differs) {
+          if (first < 0) first = x;
+          last = x;
+        }
+      }
+      if (first < 0) continue;
+      if (ox + first < x0) x0 = ox + first;
+      if (ox + last > x1) x1 = ox + last;
+      if (oy + y < y0) y0 = oy + y;
+      if (oy + y > y1) y1 = oy + y;
+    }
+  }
+  if (x0 === Infinity) return null;
+  return { x: x0, y: y0, width: x1 - x0 + 1, height: y1 - y0 + 1 };
+}
+var SurfaceDraft = class {
+  constructor(base) {
+    this.base = base;
+  }
+  base;
+  copies = /* @__PURE__ */ new Map();
+  get channels() {
+    return this.base.channels;
+  }
+  /** The writable data of tile (tx, ty), copied from the base on first use. */
+  tile(tx, ty) {
+    const key = tileKey(tx, ty);
+    let data = this.copies.get(key);
+    if (data) return data;
+    const src = this.base.tiles.get(key);
+    if (src) data = new Uint8ClampedArray(src.data);
+    else {
+      data = new Uint8ClampedArray(TILE_PIXELS * this.base.channels);
+      if (this.base.defaultValue !== 0) data.fill(this.base.defaultValue);
+    }
+    this.copies.set(key, data);
+    return data;
+  }
+  /** Replaces a whole tile with `data` (owned by the draft from now on). */
+  replace(tx, ty, data) {
+    this.copies.set(tileKey(tx, ty), data);
+  }
+  /** The current data of a tile without copying it (base tile, draft copy or `null` for default). */
+  peek(tx, ty) {
+    const key = tileKey(tx, ty);
+    return this.copies.get(key) ?? this.base.tiles.get(key)?.data ?? null;
+  }
+  /** Keys of the tiles changed so far. */
+  get touched() {
+    return [...this.copies.keys()];
+  }
+  /** A new surface with the draft's tiles; the draft must not be used afterwards. */
+  commit() {
+    if (!this.copies.size) return this.base;
+    const tiles = new Map(this.base.tiles);
+    const { channels, defaultValue } = this.base;
+    for (const [key, data] of this.copies) {
+      const tile = finishTile(data, channels, defaultValue);
+      if (tile) tiles.set(key, tile);
+      else tiles.delete(key);
+    }
+    return new TiledSurface(channels, tiles, defaultValue);
+  }
+};
+function writeRegion(surface, rect, data) {
+  const ch = surface.channels;
+  const w = rect.width;
+  const h = rect.height;
+  if (w <= 0 || h <= 0) return surface;
+  if (data.length < w * h * ch) throw new Error(`writeRegion: expected ${w * h * ch} bytes, got ${data.length}`);
+  const draft = new SurfaceDraft(surface);
+  const src = data;
+  const canSubarray = typeof src.subarray === "function";
+  for (const { tx, ty } of tilesInRect(rect)) {
+    const ox = tx * TILE;
+    const oy = ty * TILE;
+    const x0 = Math.max(rect.x, ox);
+    const y0 = Math.max(rect.y, oy);
+    const x1 = Math.min(rect.x + w, ox + TILE);
+    const y1 = Math.min(rect.y + h, oy + TILE);
+    const full = x0 === ox && y0 === oy && x1 === ox + TILE && y1 === oy + TILE;
+    const t = full ? new Uint8ClampedArray(TILE_PIXELS * ch) : draft.tile(tx, ty);
+    const span = (x1 - x0) * ch;
+    for (let yy = y0; yy < y1; yy++) {
+      const s = ((yy - rect.y) * w + (x0 - rect.x)) * ch;
+      const d = ((yy - oy) * TILE + (x0 - ox)) * ch;
+      if (canSubarray) t.set(src.subarray(s, s + span), d);
+      else for (let k = 0; k < span; k++) t[d + k] = src[s + k];
+    }
+    if (full) draft.replace(tx, ty, t);
+  }
+  return draft.commit();
+}
+function fillRect(surface, rect, bytes) {
+  const ch = surface.channels;
+  if (rect.width <= 0 || rect.height <= 0) return surface;
+  const tiles = new Map(surface.tiles);
+  const draft = new SurfaceDraft(surface);
+  const value = packPixel(bytes, 0, ch);
+  const isDefault = value === defaultPacked(ch, surface.defaultValue);
+  for (const { tx, ty } of tilesInRect(rect)) {
+    const ox = tx * TILE;
+    const oy = ty * TILE;
+    const x0 = Math.max(rect.x, ox);
+    const y0 = Math.max(rect.y, oy);
+    const x1 = Math.min(rect.x + rect.width, ox + TILE);
+    const y1 = Math.min(rect.y + rect.height, oy + TILE);
+    const key = tileKey(tx, ty);
+    if (x0 === ox && y0 === oy && x1 === ox + TILE && y1 === oy + TILE) {
+      if (isDefault) tiles.delete(key);
+      else tiles.set(key, uniformTile(ch, value));
+      continue;
+    }
+    const t = draft.tile(tx, ty);
+    for (let yy = y0; yy < y1; yy++) {
+      let d = ((yy - oy) * TILE + (x0 - ox)) * ch;
+      for (let xx = x0; xx < x1; xx++, d += ch) for (let c = 0; c < ch; c++) t[d + c] = bytes[c];
+    }
+    const tile = finishTile(t, ch, surface.defaultValue);
+    if (tile) tiles.set(key, tile);
+    else tiles.delete(key);
+  }
+  return new TiledSurface(ch, tiles, surface.defaultValue);
+}
+function translateSurface(surface, dx, dy) {
+  dx = Math.round(dx);
+  dy = Math.round(dy);
+  if (!dx && !dy) return surface;
+  if (dx % TILE === 0 && dy % TILE === 0) {
+    const tiles = /* @__PURE__ */ new Map();
+    for (const [key, tile] of surface.tiles) {
+      const { tx, ty } = tileCoord(key);
+      tiles.set(tileKey(tx + dx / TILE, ty + dy / TILE), tile);
+    }
+    return new TiledSurface(surface.channels, tiles, surface.defaultValue);
+  }
+  const b = surface.bounds;
+  if (!b) return surface;
+  const data = readRegion(surface, b);
+  return writeRegion(emptySurface(surface.channels, surface.defaultValue), { ...b, x: b.x + dx, y: b.y + dy }, data);
+}
+function surfaceBytes(surface) {
+  let n = 0;
+  for (const tile of surface.tiles.values()) if (tile.uniform === null) n += tile.data.byteLength;
+  return n;
+}
+function collectTiles(surface, into) {
+  for (const tile of surface.tiles.values()) if (tile.uniform === null) into.add(tile);
+}
+function surfacesEqual(a, b) {
+  if (a === b) return true;
+  if (a.channels !== b.channels || a.defaultValue !== b.defaultValue || a.tiles.size !== b.tiles.size) return false;
+  for (const [key, ta] of a.tiles) {
+    const tb = b.tiles.get(key);
+    if (!tb) return false;
+    if (ta === tb) continue;
+    if (ta.uniform !== null || tb.uniform !== null) {
+      if (ta.uniform !== tb.uniform) return false;
+      continue;
+    }
+    const x = ta.data;
+    const y = tb.data;
+    for (let i = 0; i < x.length; i++) if (x[i] !== y[i]) return false;
+  }
+  return true;
+}
+
+// src/raster/blend.ts
+var BLEND_MODES = [
+  { id: "normal", label: "Normal", canvas: "source-over" },
+  { id: "darken", label: "Darken", canvas: "darken" },
+  { id: "multiply", label: "Multiply", canvas: "multiply" },
+  { id: "color-burn", label: "Color Burn", canvas: "color-burn" },
+  { id: "linear-burn", label: "Linear Burn", canvas: null },
+  { id: "darker-color", label: "Darker Color", canvas: null },
+  { id: "lighten", label: "Lighten", canvas: "lighten" },
+  { id: "screen", label: "Screen", canvas: "screen" },
+  { id: "color-dodge", label: "Color Dodge", canvas: "color-dodge" },
+  { id: "linear-dodge", label: "Linear Dodge (Add)", canvas: null },
+  { id: "lighter-color", label: "Lighter Color", canvas: null },
+  { id: "overlay", label: "Overlay", canvas: "overlay" },
+  // Canvas soft-light is the W3C formula, not Photoshop's: use the scalar path.
+  { id: "soft-light", label: "Soft Light", canvas: null },
+  { id: "hard-light", label: "Hard Light", canvas: "hard-light" },
+  { id: "vivid-light", label: "Vivid Light", canvas: null },
+  { id: "linear-light", label: "Linear Light", canvas: null },
+  { id: "pin-light", label: "Pin Light", canvas: null },
+  { id: "hard-mix", label: "Hard Mix", canvas: null },
+  { id: "difference", label: "Difference", canvas: "difference" },
+  { id: "exclusion", label: "Exclusion", canvas: "exclusion" },
+  { id: "subtract", label: "Subtract", canvas: null },
+  { id: "divide", label: "Divide", canvas: null },
+  { id: "hue", label: "Hue", canvas: "hue" },
+  { id: "saturation", label: "Saturation", canvas: "saturation" },
+  { id: "color", label: "Color", canvas: "color" },
+  { id: "luminosity", label: "Luminosity", canvas: "luminosity" }
+];
+var BLEND_INFO = new Map(BLEND_MODES.map((m) => [m.id, m]));
+function isBlendMode(value) {
+  return typeof value === "string" && BLEND_INFO.has(value);
+}
+function normalizeBlendMode(value) {
+  return isBlendMode(value) ? value : "normal";
+}
+function canvasCompositeOperation(mode) {
+  return BLEND_INFO.get(mode ?? "normal")?.canvas ?? null;
+}
+function isSeparableBlendMode(mode) {
+  return !(mode === "hue" || mode === "saturation" || mode === "color" || mode === "luminosity" || mode === "darker-color" || mode === "lighter-color");
+}
+function colorBurn(cb, cs) {
+  if (cb >= 1) return 1;
+  if (cs <= 0) return 0;
+  return 1 - Math.min(1, (1 - cb) / cs);
+}
+function colorDodge(cb, cs) {
+  if (cb <= 0) return 0;
+  if (cs >= 1) return 1;
+  return Math.min(1, cb / (1 - cs));
+}
+function hardLight(cb, cs) {
+  if (cs <= 0.5) return cb * 2 * cs;
+  const s = 2 * cs - 1;
+  return cb + s - cb * s;
+}
+function softLight(cb, cs) {
+  return cs <= 0.5 ? 2 * cb * cs + cb * cb * (1 - 2 * cs) : 2 * cb * (1 - cs) + Math.sqrt(Math.max(0, cb)) * (2 * cs - 1);
+}
+function vividLightHardMix(cb, cs) {
+  const EDGE = 1e-4;
+  if (cs <= 0.5) {
+    if (cb >= 1 - EDGE) return 1;
+    if (cs <= 0) return 0;
+    return 1 - Math.min(1, (1 - cb) / (2 * cs));
+  }
+  if (cb <= EDGE) return 0;
+  if (cs >= 1) return 1;
+  return Math.min(1, cb / (2 * (1 - cs)));
+}
+function blendChannel(mode, cb, cs) {
+  switch (mode) {
+    case "normal":
+      return cs;
+    case "darken":
+      return Math.min(cb, cs);
+    case "multiply":
+      return cb * cs;
+    case "color-burn":
+      return colorBurn(cb, cs);
+    case "linear-burn":
+      return Math.max(0, cb + cs - 1);
+    case "lighten":
+      return Math.max(cb, cs);
+    case "screen":
+      return cb + cs - cb * cs;
+    case "color-dodge":
+      return colorDodge(cb, cs);
+    case "linear-dodge":
+      return Math.min(1, cb + cs);
+    case "overlay":
+      return hardLight(cs, cb);
+    case "soft-light":
+      return softLight(cb, cs);
+    case "hard-light":
+      return hardLight(cb, cs);
+    case "vivid-light":
+      if (cs <= 0) return 0;
+      if (cs >= 1) return 1;
+      return cs <= 0.5 ? colorBurn(cb, 2 * cs) : colorDodge(cb, 2 * (cs - 0.5));
+    case "linear-light":
+      return Math.min(1, Math.max(0, cb + 2 * cs - 1));
+    case "pin-light":
+      return cs <= 0.5 ? Math.min(cb, 2 * cs) : Math.max(cb, 2 * cs - 1);
+    case "hard-mix":
+      return vividLightHardMix(cb, cs) >= 0.5 - 1e-6 ? 1 : 0;
+    case "difference":
+      return Math.abs(cb - cs);
+    case "exclusion":
+      return cb + cs - 2 * cb * cs;
+    case "subtract":
+      return Math.max(0, cb - cs);
+    case "divide":
+      if (cs <= 0) return cb <= 0 ? 0 : 1;
+      return Math.min(1, cb / cs);
+    default:
+      return cs;
+  }
+}
+function blendLum(c) {
+  return 0.3 * c[0] + 0.59 * c[1] + 0.11 * c[2];
+}
+function clipColor(c) {
+  const l = blendLum(c);
+  const n = Math.min(c[0], c[1], c[2]);
+  const x = Math.max(c[0], c[1], c[2]);
+  let out = [c[0], c[1], c[2]];
+  if (n < 0) {
+    const d = l - n;
+    out = out.map((v) => l > 0 && d > 0 ? l + (v - l) * l / d : l);
+  }
+  if (x > 1) {
+    const d = x - l;
+    out = out.map((v) => l < 1 && d > 0 ? l + (v - l) * (1 - l) / d : l);
+  }
+  return out;
+}
+function setLum(c, l) {
+  const d = l - blendLum(c);
+  return clipColor([c[0] + d, c[1] + d, c[2] + d]);
+}
+function sat(c) {
+  return Math.max(c[0], c[1], c[2]) - Math.min(c[0], c[1], c[2]);
+}
+function setSat(c, s) {
+  const idx = [0, 1, 2].sort((a, b) => c[a] - c[b]);
+  const [imin, imid, imax] = idx;
+  const out = [0, 0, 0];
+  if (c[imax] > c[imin]) {
+    out[imid] = (c[imid] - c[imin]) * s / (c[imax] - c[imin]);
+    out[imax] = s;
+  }
+  out[imin] = 0;
+  return out;
+}
+function blendRgb(mode, cb, cs) {
+  switch (mode) {
+    case "hue":
+      return setLum(setSat(cs, sat(cb)), blendLum(cb));
+    case "saturation":
+      return setLum(setSat(cb, sat(cs)), blendLum(cb));
+    case "color":
+      return setLum(cs, blendLum(cb));
+    case "luminosity":
+      return setLum(cb, blendLum(cs));
+    case "darker-color":
+      return blendLum(cs) < blendLum(cb) ? [cs[0], cs[1], cs[2]] : [cb[0], cb[1], cb[2]];
+    case "lighter-color":
+      return blendLum(cs) > blendLum(cb) ? [cs[0], cs[1], cs[2]] : [cb[0], cb[1], cb[2]];
+    default:
+      return [blendChannel(mode, cb[0], cs[0]), blendChannel(mode, cb[1], cs[1]), blendChannel(mode, cb[2], cs[2])];
+  }
+}
+function blendPixel(mode, backdrop, source, alpha = 1) {
+  const ab = backdrop[3] ?? 1;
+  const as = (source[3] ?? 1) * alpha;
+  if (!(as > 0)) return [backdrop[0], backdrop[1], backdrop[2], ab];
+  const b = blendRgb(mode, backdrop, source);
+  const ao = as + ab * (1 - as);
+  if (ao <= 0) return [0, 0, 0, 0];
+  const out = [0, 0, 0, ao];
+  for (let i = 0; i < 3; i++) {
+    out[i] = ((1 - as) * ab * backdrop[i] + (1 - ab) * as * source[i] + as * ab * b[i]) / ao;
+  }
+  return out;
+}
+function blendImageData(backdrop, source, mode, alpha = 1) {
+  const d = backdrop.data;
+  const s = source.data;
+  const len = Math.min(d.length, s.length);
+  const cb = [0, 0, 0, 0];
+  const cs = [0, 0, 0, 0];
+  for (let i = 0; i < len; i += 4) {
+    if (s[i + 3] === 0) continue;
+    for (let k = 0; k < 4; k++) {
+      cb[k] = d[i + k] / 255;
+      cs[k] = s[i + k] / 255;
+    }
+    const o = blendPixel(mode, cb, cs, alpha);
+    d[i] = Math.round(o[0] * 255);
+    d[i + 1] = Math.round(o[1] * 255);
+    d[i + 2] = Math.round(o[2] * 255);
+    d[i + 3] = Math.round(o[3] * 255);
+  }
+}
+
+export {
+  TILE,
+  TILE_SHIFT,
+  tileKey,
+  tileCoord,
+  tileRect,
+  TiledSurface,
+  uniformTile,
+  packRgba,
+  finishTile,
+  emptySurface,
+  solidSurface,
+  surfaceFromPixels,
+  tilesInRect,
+  readRegion,
+  readPixel,
+  contentBounds,
+  SurfaceDraft,
+  writeRegion,
+  fillRect,
+  translateSurface,
+  surfaceBytes,
+  collectTiles,
+  surfacesEqual,
+  BLEND_MODES,
+  isBlendMode,
+  normalizeBlendMode,
+  canvasCompositeOperation,
+  isSeparableBlendMode,
+  blendChannel,
+  blendLum,
+  setLum,
+  blendRgb,
+  blendPixel,
+  blendImageData
+};
+//# sourceMappingURL=chunk-D4ZCU72J.js.map