@pixerate/editor 0.207.0 → 0.208.0

package/dist/{chunk-H367YTXI.js → chunk-42TWUPNJ.js}

@@ -1,3 +1,11 @@
+import {
+  TILE,
+  TiledSurface,
+  emptySurface,
+  finishTile,
+  tileKey,
+  tilesInRect
+} from "./chunk-HVVR5PZW.js";
 import {
   deflate,
   inflate
@@ -708,369 +716,10 @@ function blendImageData(backdrop, source, mode, alpha = 1) {
   }
 }
 
-// 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/deep.ts
 var BIT_DEPTHS = [8, 16, 32];
 var isBitDepth = (v) => v === 8 || v === 16 || v === 32;
-var TILE_PIXELS2 = TILE * TILE;
+var TILE_PIXELS = TILE * TILE;
 function srgbDecode(v) {
   return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
 }
@@ -1204,17 +853,17 @@ function tileSamples16(tile, channels, defaultValue = 0) {
   if (deep instanceof Uint16Array) return deep;
   if (deep instanceof Float32Array) return to16From32(deep, channels);
   if (tile) return to16From8(tile.data);
-  return new Uint16Array(TILE_PIXELS2 * channels).fill(defaultValue * 257);
+  return new Uint16Array(TILE_PIXELS * channels).fill(defaultValue * 257);
 }
 function tileSamples32(tile, channels, defaultValue = 0) {
   const deep = tile?.deep;
   if (deep instanceof Float32Array) return deep;
   if (deep instanceof Uint16Array) return to32From16(deep, channels);
   if (tile) return to32From8(tile.data, channels);
-  const out = new Float32Array(TILE_PIXELS2 * channels);
+  const out = new Float32Array(TILE_PIXELS * channels);
   if (defaultValue) {
     if (channels === 1) out.fill(defaultValue / 255);
-    else to32From8(new Uint8ClampedArray(TILE_PIXELS2 * 4).fill(defaultValue), 4, out);
+    else to32From8(new Uint8ClampedArray(TILE_PIXELS * 4).fill(defaultValue), 4, out);
   }
   return out;
 }
@@ -1273,7 +922,7 @@ function writeDeepRegion(surface, rect, samples) {
     const y1 = Math.min(rect.y + h, oy + TILE);
     const full = x0 === ox && y0 === oy && x1 === ox + TILE && y1 === oy + TILE;
     const base = full ? null : tileSamples(surface.tiles.get(key), ch, depth, surface.defaultValue);
-    const t = base ? base.slice() : depth === 16 ? new Uint16Array(TILE_PIXELS2 * ch) : new Float32Array(TILE_PIXELS2 * ch);
+    const t = base ? base.slice() : depth === 16 ? new Uint16Array(TILE_PIXELS * ch) : new Float32Array(TILE_PIXELS * ch);
     const span = (x1 - x0) * ch;
     for (let yy = y0; yy < y1; yy++) {
       const s = ((yy - rect.y) * w + (x0 - rect.x)) * ch;
@@ -1679,29 +1328,6 @@ export {
   mixPigment8,
   blendPixel,
   blendImageData,
-  TILE,
-  TILE_SHIFT,
-  tileKey,
-  tileCoord,
-  tileRect,
-  TiledSurface,
-  uniformTile,
-  packRgba,
-  finishTile,
-  emptySurface,
-  solidSurface,
-  surfaceFromPixels,
-  tilesInRect,
-  readRegion,
-  readPixel,
-  contentBounds,
-  SurfaceDraft,
-  writeRegion,
-  fillRect,
-  translateSurface,
-  surfaceBytes,
-  collectTiles,
-  surfacesEqual,
   BIT_DEPTHS,
   isBitDepth,
   srgbDecode,