@pixerate/editor 0.116.0 → 0.117.0

package/dist/{chunk-SEBYNBHW.js → chunk-R2JE6SA7.js}

@@ -28,17 +28,13 @@ import {
   newEffectId,
   normalizeLayerEffects,
   parseEffectColor,
-  readDeepRegion,
   reduceSurface,
   scaleLayerEffect,
-  surfaceDepth,
-  surfaceFromDeepPixels,
   transformSurface,
   validateEffectGradient,
   validateLayerEffects,
-  warpSurface,
-  writeDeepRegion
-} from "./chunk-D53KSJUV.js";
+  warpSurface
+} from "./chunk-VD2UDVF7.js";
 import {
   affineFromHomography,
   applyHomography,
@@ -65,13 +61,17 @@ import {
   isBlendMode,
   mixPigmentRgb,
   normalizeBlendMode,
+  readDeepRegion,
   readRegion,
   setLum,
+  surfaceDepth,
+  surfaceFromDeepPixels,
   surfaceFromPixels,
   tileKey,
   tilesInRect,
-  translateSurface
-} from "./chunk-XK5LZKBD.js";
+  translateSurface,
+  writeDeepRegion
+} from "./chunk-HKDTM6VC.js";
 import {
   Transform,
   builtinProfile,
@@ -11735,4 +11735,4 @@ export {
   smartContentsFile,
   exportPsd
 };
-//# sourceMappingURL=chunk-SEBYNBHW.js.map
+//# sourceMappingURL=chunk-R2JE6SA7.js.map

package/dist/{chunk-D53KSJUV.js → chunk-VD2UDVF7.js}

@@ -14,263 +14,27 @@ import {
   blendChannel,
   blendRgb,
   contentBounds,
+  deepTile,
   emptySurface,
   finishTile,
   isBlendMode,
   isSeparableBlendMode,
   mixPigment8,
   mixPigmentRgb,
+  readDeepRegion,
   readRegion,
+  srgbDecode,
+  srgbEncode,
+  surfaceDepth,
   surfaceFromPixels,
   tileKey,
+  tileSamples,
   tilesInRect,
+  to32From8,
   translateSurface,
+  writeDeepRegion,
   writeRegion
-} from "./chunk-XK5LZKBD.js";
-
-// src/raster/deep.ts
-var BIT_DEPTHS = [8, 16, 32];
-var isBitDepth = (v) => v === 8 || v === 16 || v === 32;
-var TILE_PIXELS = TILE * TILE;
-function srgbDecode(v) {
-  return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
-}
-function srgbEncode(v) {
-  if (!(v > 0)) return 0;
-  return v <= 31308e-7 ? v * 12.92 : 1.055 * Math.pow(v, 1 / 2.4) - 0.055;
-}
-var LIN8 = null;
-var LIN16 = null;
-function lin8() {
-  if (!LIN8) {
-    LIN8 = new Float32Array(256);
-    for (let i = 0; i < 256; i++) LIN8[i] = srgbDecode(i / 255);
-  }
-  return LIN8;
-}
-function lin16() {
-  if (!LIN16) {
-    LIN16 = new Float32Array(65536);
-    for (let i = 0; i < 65536; i++) LIN16[i] = srgbDecode(i / 65535);
-  }
-  return LIN16;
-}
-function encode16(v) {
-  if (!(v > 0)) return 0;
-  if (v >= 1) return 65535;
-  return Math.round(srgbEncode(v) * 65535);
-}
-var ENC8 = null;
-function encode8(v) {
-  if (!(v > 0)) return 0;
-  if (v >= 1) return 255;
-  if (!ENC8) {
-    ENC8 = new Uint8Array(65536);
-    for (let i = 0; i < 65536; i++) ENC8[i] = Math.round(srgbEncode(i / 65535) * 255);
-  }
-  return ENC8[Math.round(v * 65535)];
-}
-function to16From8(data, out = new Uint16Array(data.length)) {
-  for (let i = 0; i < data.length; i++) out[i] = data[i] * 257;
-  return out;
-}
-function to32From8(data, channels, out = new Float32Array(data.length)) {
-  if (channels === 1) {
-    for (let i = 0; i < data.length; i++) out[i] = data[i] / 255;
-    return out;
-  }
-  const t = lin8();
-  for (let i = 0; i < data.length; i += 4) {
-    out[i] = t[data[i]];
-    out[i + 1] = t[data[i + 1]];
-    out[i + 2] = t[data[i + 2]];
-    out[i + 3] = data[i + 3] / 255;
-  }
-  return out;
-}
-function to32From16(data, channels, out = new Float32Array(data.length)) {
-  if (channels === 1) {
-    for (let i = 0; i < data.length; i++) out[i] = data[i] / 65535;
-    return out;
-  }
-  const t = lin16();
-  for (let i = 0; i < data.length; i += 4) {
-    out[i] = t[data[i]];
-    out[i + 1] = t[data[i + 1]];
-    out[i + 2] = t[data[i + 2]];
-    out[i + 3] = data[i + 3] / 65535;
-  }
-  return out;
-}
-function to16From32(data, channels, out = new Uint16Array(data.length)) {
-  const unit = (v) => v > 0 ? v < 1 ? Math.round(v * 65535) : 65535 : 0;
-  if (channels === 1) {
-    for (let i = 0; i < data.length; i++) out[i] = unit(data[i]);
-    return out;
-  }
-  for (let i = 0; i < data.length; i += 4) {
-    out[i] = encode16(data[i]);
-    out[i + 1] = encode16(data[i + 1]);
-    out[i + 2] = encode16(data[i + 2]);
-    out[i + 3] = unit(data[i + 3]);
-  }
-  return out;
-}
-function to8From16(data, out = new Uint8ClampedArray(data.length)) {
-  for (let i = 0; i < data.length; i++) out[i] = Math.round(data[i] / 257);
-  return out;
-}
-function to8From32(data, channels, out = new Uint8ClampedArray(data.length)) {
-  if (channels === 1) {
-    for (let i = 0; i < data.length; i++) out[i] = Math.round(data[i] * 255);
-    return out;
-  }
-  for (let i = 0; i < data.length; i += 4) {
-    out[i] = encode8(data[i]);
-    out[i + 1] = encode8(data[i + 1]);
-    out[i + 2] = encode8(data[i + 2]);
-    out[i + 3] = Math.round(Math.min(1, Math.max(0, data[i + 3])) * 255);
-  }
-  return out;
-}
-function proxyOf(deep, channels, out) {
-  return deep instanceof Uint16Array ? to8From16(deep, out) : to8From32(deep, channels, out);
-}
-var depthOf = (deep) => deep instanceof Uint16Array ? 16 : 32;
-function deepTile(deep, channels, defaultValue = 0) {
-  const data = proxyOf(deep, channels);
-  if (deep instanceof Uint16Array) {
-    let exact = true;
-    for (let i = 0; i < deep.length; i++) {
-      if (deep[i] % 257 !== 0) {
-        exact = false;
-        break;
-      }
-    }
-    if (exact) return finishTile(data, channels, defaultValue);
-  } else if (channels === 4 && defaultValue === 0) {
-    let empty = true;
-    for (let i = 3; i < deep.length; i += 4) {
-      if (deep[i] !== 0) {
-        empty = false;
-        break;
-      }
-    }
-    if (empty) return null;
-  }
-  return { data, uniform: null, deep };
-}
-function tileSamples16(tile, channels, defaultValue = 0) {
-  const deep = tile?.deep;
-  if (deep instanceof Uint16Array) return deep;
-  if (deep instanceof Float32Array) return to16From32(deep, channels);
-  if (tile) return to16From8(tile.data);
-  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_PIXELS * channels);
-  if (defaultValue) {
-    if (channels === 1) out.fill(defaultValue / 255);
-    else to32From8(new Uint8ClampedArray(TILE_PIXELS * 4).fill(defaultValue), 4, out);
-  }
-  return out;
-}
-function tileSamples(tile, channels, depth, defaultValue = 0) {
-  return depth === 16 ? tileSamples16(tile, channels, defaultValue) : tileSamples32(tile, channels, defaultValue);
-}
-function surfaceDepth(surface) {
-  let d = 8;
-  for (const t of surface.tiles.values()) {
-    if (t.deep instanceof Float32Array) return 32;
-    if (t.deep) d = 16;
-  }
-  return d;
-}
-function readDeepRegion(surface, rect, depth) {
-  const ch = surface.channels;
-  const w = rect.width;
-  const h = rect.height;
-  const out = depth === 16 ? new Uint16Array(w * h * ch) : new Float32Array(w * h * ch);
-  const fill2 = tileSamples(void 0, ch, depth, surface.defaultValue);
-  if (surface.defaultValue) for (let i = 0; i < out.length; i += ch) for (let c = 0; c < ch; c++) out[i + c] = fill2[c];
-  for (const { tx, ty } of tilesInRect(rect)) {
-    const tile = surface.tiles.get(tileKey(tx, ty));
-    if (!tile) continue;
-    const src = tileSamples(tile, ch, depth, surface.defaultValue);
-    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;
-      out.set(src.subarray(s, s + span), d);
-    }
-  }
-  return out;
-}
-function writeDeepRegion(surface, rect, samples) {
-  const ch = surface.channels;
-  const w = rect.width;
-  const h = rect.height;
-  if (w <= 0 || h <= 0) return surface;
-  if (samples.length < w * h * ch) throw new Error(`writeDeepRegion: expected ${w * h * ch} samples, got ${samples.length}`);
-  const depth = depthOf(samples);
-  const tiles = new Map(surface.tiles);
-  for (const { tx, ty } of tilesInRect(rect)) {
-    const key = tileKey(tx, ty);
-    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 base = full ? null : tileSamples(surface.tiles.get(key), ch, depth, surface.defaultValue);
-    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;
-      const d = ((yy - oy) * TILE + (x0 - ox)) * ch;
-      t.set(samples.subarray(s, s + span), d);
-    }
-    const tile = deepTile(t, ch, surface.defaultValue);
-    if (tile) tiles.set(key, tile);
-    else tiles.delete(key);
-  }
-  return new TiledSurface(ch, tiles, surface.defaultValue);
-}
-function surfaceFromDeepPixels(pixels, channels = 4, x = 0, y = 0, defaultValue = 0) {
-  return writeDeepRegion(emptySurface(channels, defaultValue), { x, y, width: pixels.width, height: pixels.height }, pixels.data);
-}
-function convertSurfaceDepth(surface, depth) {
-  let changed = false;
-  const tiles = new Map(surface.tiles);
-  const ch = surface.channels;
-  for (const [key, tile] of surface.tiles) {
-    const deep = tile.deep;
-    if (!deep || depthOf(deep) === depth) continue;
-    changed = true;
-    let next;
-    if (depth === 8) next = finishTile(tile.data, ch, surface.defaultValue);
-    else next = deepTile(depth === 16 ? to16From32(deep, ch) : to32From16(deep, ch), ch, surface.defaultValue);
-    if (next) tiles.set(key, next);
-    else tiles.delete(key);
-  }
-  return changed ? new TiledSurface(ch, tiles, surface.defaultValue) : surface;
-}
-function deepBytes(surface) {
-  let n = 0;
-  for (const t of surface.tiles.values()) if (t.deep) n += t.deep.byteLength;
-  return n;
-}
+} from "./chunk-HKDTM6VC.js";
 
 // src/raster/effects/model.ts
 var DEFAULT_GLOBAL_LIGHT = { angle: 120, altitude: 30 };
@@ -2580,8 +2344,8 @@ function renderLayerEffects(effects, layer, backdrop, canvas, ctx) {
 }
 
 // src/raster/compositor.ts
-var TILE_PIXELS2 = TILE * TILE;
-var TILE_BYTES = TILE_PIXELS2 * 4;
+var TILE_PIXELS = TILE * TILE;
+var TILE_BYTES = TILE_PIXELS * 4;
 function sameSig(a, b) {
   if (!a || a.key !== b.key || a.refs.length !== b.refs.length) return false;
   for (let i = 0; i < a.refs.length; i++) if (a.refs[i] !== b.refs[i]) return false;
@@ -3601,13 +3365,13 @@ function hasTilesIn(src, r) {
   for (const { tx, ty } of tilesInRect(r)) if (src.getTile(tx, ty)) return true;
   return false;
 }
-function readWindow(src, srcRect, rect) {
+function readWindow(src, srcRect, rect, depth = null) {
   const n = src.channels === 4 ? 4 : 2;
   const data = new Float32Array(rect.width * rect.height * n);
   const win = { x: rect.x, y: rect.y, w: rect.width, h: rect.height, n, data };
   const r = intersect(rect, srcRect);
   if (!r) return win;
-  const px = readRegion(src, r);
+  const px = depth ? readScaled(src, r, depth) : readRegion(src, r);
   for (let y = 0; y < r.height; y++) {
     let s = y * r.width * src.channels;
     let d = ((r.y - rect.y + y) * rect.width + (r.x - rect.x)) * n;
@@ -3741,7 +3505,44 @@ function store(out, o, acc, ch, def) {
   out[o] = acc[0] + def * (1 - inside);
   return true;
 }
-function boxReduce(src, srcRect, kx, ky) {
+function resampleDepth(src, step) {
+  if (src.channels !== 4 || src.defaultValue !== 0 || step !== 1) return null;
+  const d = surfaceDepth(src);
+  return d === 8 ? null : d;
+}
+function readScaled(src, rect, depth) {
+  const d = readDeepRegion(src, rect, depth);
+  const out = new Float32Array(d.length);
+  const k = depth === 16 ? 1 / 257 : 255;
+  for (let i = 0; i < d.length; i++) out[i] = d[i] * k;
+  return out;
+}
+function fromScaled(v, depth) {
+  if (depth === 16) {
+    const out2 = new Uint16Array(v.length);
+    for (let i = 0; i < v.length; i++) {
+      const x = Math.round(v[i] * 257);
+      out2[i] = x <= 0 ? 0 : x >= 65535 ? 65535 : x;
+    }
+    return out2;
+  }
+  const out = new Float32Array(v.length);
+  for (let i = 0; i < v.length; i++) {
+    const x = v[i] / 255;
+    out[i] = (i & 3) === 3 ? x <= 0 ? 0 : x >= 1 ? 1 : x : x;
+  }
+  return out;
+}
+function storeScaled(out, o, acc) {
+  const al = acc[3] > 1 ? 1 : acc[3];
+  if (!(al > 1e-6)) return false;
+  out[o] = acc[0] / al;
+  out[o + 1] = acc[1] / al;
+  out[o + 2] = acc[2] / al;
+  out[o + 3] = al * 255;
+  return true;
+}
+function boxReduce(src, srcRect, kx, ky, depth = null) {
   const ch = src.channels;
   const rx0 = Math.floor(srcRect.x / kx);
   const ry0 = Math.floor(srcRect.y / ky);
@@ -3755,8 +3556,8 @@ function boxReduce(src, srcRect, kx, ky) {
   for (let ry = ry0; ry < ry1; ry += rowsPer) {
     const rows = Math.min(rowsPer, ry1 - ry);
     const strip = { x: rx0 * kx, y: ry * ky, width: rw * kx, height: rows * ky };
-    const px = readRegion(src, strip);
-    const red = new Uint8ClampedArray(rw * rows * ch);
+    const px = depth ? readScaled(src, strip, depth) : readRegion(src, strip);
+    const red = depth ? new Float32Array(rw * rows * ch) : new Uint8ClampedArray(rw * rows * ch);
     for (let j = 0; j < rows; j++) {
       for (let i = 0; i < rw; i++) {
         if (ch === 4) {
@@ -3791,7 +3592,8 @@ function boxReduce(src, srcRect, kx, ky) {
         }
       }
     }
-    out = writeRegion(out, { x: rx0, y: ry, width: rw, height: rows }, red);
+    const region = { x: rx0, y: ry, width: rw, height: rows };
+    out = depth ? writeDeepRegion(out, region, fromScaled(red, depth)) : writeRegion(out, region, red);
   }
   return { surface: out, rect };
 }
@@ -3840,11 +3642,18 @@ function transformSurface(src, h, options = {}) {
   const empty = emptySurface(ch, def);
   const given = options.source;
   const step = normalizeStep(options.step);
+  const depth = resampleDepth(src, step);
   if (isIdentityHomography(h, 1e-12) && !given && !options.clip) return src;
   const dx = h[2] / h[8];
   const dy = h[5] / h[8];
   if (!given && !options.clip && isIdentityHomography([h[0], h[1], 0, h[3], h[4], 0, h[6], h[7], h[8]], 1e-12) && Math.abs(dx - Math.round(dx)) < 1e-9 && Math.abs(dy - Math.round(dy)) < 1e-9) {
-    return translateSurface(src, Math.round(dx), Math.round(dy));
+    const mx = Math.round(dx);
+    const my = Math.round(dy);
+    const b = src.bounds;
+    if (depth && b && (mx % TILE !== 0 || my % TILE !== 0)) {
+      return writeDeepRegion(emptySurface(ch, def), { ...b, x: b.x + mx, y: b.y + my }, readDeepRegion(src, b, depth));
+    }
+    return translateSurface(src, mx, my);
   }
   let srcRect = given ? intersect(given, given) : contentBounds(src);
   if (!srcRect) return empty;
@@ -3858,7 +3667,7 @@ function transformSurface(src, h, options = {}) {
       const kx = reduction(su);
       const ky = reduction(sv);
       if (kx > 1 || ky > 1) {
-        const red = boxReduce(src, srcRect, kx, ky);
+        const red = boxReduce(src, srcRect, kx, ky, depth);
         S = red.surface;
         srcRect = red.rect;
         H = multiplyHomographies([kx, 0, 0, 0, ky, 0, 0, 0, 1], H);
@@ -3942,9 +3751,10 @@ function transformSurface(src, h, options = {}) {
     if (!foot) continue;
     const readable = intersect(foot, sr);
     if (!readable || !hasTilesIn(S, readable)) continue;
-    const win = readWindow(S, sr, foot);
+    const win = readWindow(S, sr, foot, depth);
     const out = new Uint8ClampedArray(TILE * TILE * ch);
     if (def) out.fill(def);
+    const deepOut = depth ? new Float32Array(TILE * TILE * 4) : null;
     let any = false;
     const ox = tx * TILE;
     const oy = ty * TILE;
@@ -3973,6 +3783,10 @@ function transformSurface(src, h, options = {}) {
           sv = widen(s[1]);
         }
         sample(win, interp, u, v, su, sv, acc);
+        if (deepOut) {
+          if (storeScaled(deepOut, ((y - oy) * TILE + (x - ox)) * 4, acc)) any = true;
+          continue;
+        }
         if (!store(scratch, 0, acc, ch, def)) continue;
         rowSet[bi] = 1;
         rowVals[bi] = ch === 4 ? scratchWord[0] : scratch[0];
@@ -3995,7 +3809,7 @@ function transformSurface(src, h, options = {}) {
       }
     }
     if (!any) continue;
-    const tile = finishTile(out, ch, def);
+    const tile = deepOut ? deepTile(fromScaled(deepOut, depth), 4, def) : finishTile(out, ch, def);
     if (tile) tiles.set(tileKey(tx, ty), tile);
   }
   return assemble(src, tiles);
@@ -4011,6 +3825,7 @@ function warpSurface(src, f, options = {}) {
   const sr = options.source ? intersect(options.source, options.source) : contentBounds(src);
   if (!sr) return empty;
   const step = normalizeStep(options.step);
+  const depth = resampleDepth(src, step);
   const nx = Math.min(MAX_CELLS, Math.max(1, Math.ceil(sr.width / CELL)));
   const ny = Math.min(MAX_CELLS, Math.max(1, Math.ceil(sr.height / CELL)));
   const w1 = nx + 1;
@@ -4178,9 +3993,10 @@ function warpSurface(src, f, options = {}) {
       if (fx0 > fx1) continue;
       const foot = intersect({ x: Math.floor(fx0) - 3, y: Math.floor(fy0) - 3, width: Math.ceil(fx1) - Math.floor(fx0) + 6, height: Math.ceil(fy1) - Math.floor(fy0) + 6 }, sr);
       if (!foot || !hasTilesIn(src, foot)) continue;
-      const win = readWindow(src, sr, foot);
+      const win = readWindow(src, sr, foot, depth);
       const out = new Uint8ClampedArray(TILE * TILE * ch);
       if (def) out.fill(def);
+      const deepOut = depth ? new Float32Array(TILE * TILE * 4) : null;
       let any = false;
       const ox = ttx * TILE;
       const oy = tty * TILE;
@@ -4214,7 +4030,8 @@ function warpSurface(src, f, options = {}) {
           pointAt(o, acc);
           const x = t.x + o % tw;
           const y = t.y + Math.floor(o / tw);
-          if (store(out, ((y - oy) * TILE + (x - ox)) * ch, acc, ch, def)) any = true;
+          const o4 = ((y - oy) * TILE + (x - ox)) * ch;
+          if (deepOut ? storeScaled(deepOut, o4, acc) : store(out, o4, acc, ch, def)) any = true;
         }
       } else {
         for (let by = 0; by < th; by += step) {
@@ -4233,7 +4050,7 @@ function warpSurface(src, f, options = {}) {
         }
       }
       if (!any) continue;
-      const tile = finishTile(out, ch, def);
+      const tile = deepOut ? deepTile(fromScaled(deepOut, depth), 4, def) : finishTile(out, ch, def);
       if (tile) tiles.set(tileKey(ttx, tty), tile);
     }
   }
@@ -4244,12 +4061,34 @@ function compositeSurfaceOver(base, top) {
   if (!top.tiles.size) return base;
   const ch = base.channels;
   const tiles = new Map(base.tiles);
+  const bd = ch === 4 && base.defaultValue === 0 ? Math.max(surfaceDepth(base), surfaceDepth(top)) : 8;
+  const depth = bd === 8 ? null : bd;
   for (const [key, t] of top.tiles) {
     const under = base.tiles.get(key);
     if (!under && ch === 4) {
       tiles.set(key, t);
       continue;
     }
+    if (depth) {
+      const k = depth === 16 ? 65535 : 1;
+      const d2 = tileSamples(under, 4, depth, 0).slice();
+      const sd = tileSamples(t, 4, depth, 0);
+      for (let i = 0; i < d2.length; i += 4) {
+        const ta = Math.min(1, sd[i + 3] / k);
+        if (ta <= 0) continue;
+        const da = d2[i + 3] / k;
+        const oa = ta + da * (1 - ta);
+        for (let c = 0; c < 3; c++) {
+          const v = (sd[i + c] * ta + d2[i + c] * da * (1 - ta)) / oa;
+          d2[i + c] = depth === 16 ? Math.round(v) : v;
+        }
+        d2[i + 3] = depth === 16 ? Math.round(oa * k) : oa;
+      }
+      const tile2 = deepTile(d2, 4, 0);
+      if (tile2) tiles.set(key, tile2);
+      else tiles.delete(key);
+      continue;
+    }
     const d = new Uint8ClampedArray(TILE * TILE * ch);
     if (under) d.set(under.data);
     else if (base.defaultValue) d.fill(base.defaultValue);
@@ -4284,28 +4123,6 @@ function compositeSurfaceOver(base, top) {
 }
 
 export {
-  BIT_DEPTHS,
-  isBitDepth,
-  srgbDecode,
-  srgbEncode,
-  to16From8,
-  to32From8,
-  to32From16,
-  to16From32,
-  to8From16,
-  to8From32,
-  proxyOf,
-  depthOf,
-  deepTile,
-  tileSamples16,
-  tileSamples32,
-  tileSamples,
-  surfaceDepth,
-  readDeepRegion,
-  writeDeepRegion,
-  surfaceFromDeepPixels,
-  convertSurfaceDepth,
-  deepBytes,
   DEFAULT_GLOBAL_LIGHT,
   LAYER_EFFECT_KINDS,
   layerEffectLabel,
@@ -4369,4 +4186,4 @@ export {
   warpSurface,
   compositeSurfaceOver
 };
-//# sourceMappingURL=chunk-D53KSJUV.js.map
+//# sourceMappingURL=chunk-VD2UDVF7.js.map