@nice2dev/ui-graphics 1.1.0 → 1.1.1

package/dist/cjs/pixel/usePixelEditor.js

@@ -2,9 +2,9 @@
 
 var React = require('react');
 var asepriteFormat = require('./asepriteFormat.js');
-var pixelEditorUtils = require('./pixelEditorUtils.js');
-var pixelEditorTypes = require('./pixelEditorTypes.js');
 var pixelEditorExports = require('./pixelEditorExports.js');
+var pixelEditorTypes = require('./pixelEditorTypes.js');
+var pixelEditorUtils = require('./pixelEditorUtils.js');
 
 /**
  * usePixelEditor — custom hook encapsulating ALL state, refs, callbacks,
@@ -19,15 +19,22 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
     const [dw, setDw] = React.useState(initialWidth);
     const [dh, setDh] = React.useState(initialHeight);
     const [layers, setLayers] = React.useState(() => [
-        { id: pixelEditorTypes.lid(), name: "Background", visible: true, opacity: 255, locked: false, blendMode: "normal" },
+        {
+            id: pixelEditorTypes.lid(),
+            name: 'Background',
+            visible: true,
+            opacity: 255,
+            locked: false,
+            blendMode: 'normal',
+        },
     ]);
     const [aLi, setALi] = React.useState(0);
     const [fc, setFc] = React.useState(1);
     const [afi, setAfi] = React.useState(0);
     const [fDur, setFDur] = React.useState([100]);
-    const [tool, setTool] = React.useState("pencil");
-    const [col1, setCol1] = React.useState("#000000");
-    const [col2, setCol2] = React.useState("#ffffff");
+    const [tool, setTool] = React.useState('pencil');
+    const [col1, setCol1] = React.useState('#000000');
+    const [col2, setCol2] = React.useState('#ffffff');
     const [brush, setBrush] = React.useState({ ...pixelEditorUtils.DEFAULT_BRUSH });
     const [zoom, setZoom] = React.useState(8);
     const [px, setPx] = React.useState(0);
@@ -43,7 +50,7 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
     const [nh, setNh] = React.useState(64);
     const [sel, setSel] = React.useState(null);
     const [tick, setTick] = React.useState(0);
-    const [symmetry, setSymmetry] = React.useState("none");
+    const [symmetry, setSymmetry] = React.useState('none');
     const [shapeFilled, setShapeFilled] = React.useState(false);
     const [pressure, setPressure] = React.useState(0.5);
     const [showHSV, setShowHSV] = React.useState(false);
@@ -79,8 +86,9 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
     const scr2art = React.useCallback((cx, cy) => {
         var _a;
         const r = (_a = boxRef.current) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect();
-        if (!r)
+        if (!r) {
             return { x: 0, y: 0 };
+        }
         return {
             x: Math.floor((cx - r.left - px - r.width / 2) / zoom + dw / 2),
             y: Math.floor((cy - r.top - py - r.height / 2) / zoom + dh / 2),
@@ -97,8 +105,9 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
             layers: JSON.parse(JSON.stringify(layers)),
             frameCount: fc,
         });
-        if (hist.current.length > 50)
+        if (hist.current.length > 50) {
             hist.current.shift();
+        }
         hIdx.current = hist.current.length - 1;
     }, [layers, fc]);
     const restoreEntry = React.useCallback((e) => {
@@ -109,61 +118,66 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         setTick((t) => t + 1);
     }, []);
     const undo = React.useCallback(() => {
-        if (hIdx.current <= 0)
+        if (hIdx.current <= 0) {
             return;
+        }
         hIdx.current--;
         restoreEntry(hist.current[hIdx.current]);
     }, [restoreEntry]);
     const redo = React.useCallback(() => {
-        if (hIdx.current >= hist.current.length - 1)
+        if (hIdx.current >= hist.current.length - 1) {
             return;
+        }
         hIdx.current++;
         restoreEntry(hist.current[hIdx.current]);
     }, [restoreEntry]);
     /* Push initial snapshot so first undo works */
     React.useEffect(() => {
         if (hist.current.length === 0) {
-            snap("initial");
+            snap('initial');
         }
     }, [snap]);
     /* ── composite a frame ── */
     const compFrame = React.useCallback((fi) => {
         const cv = new OffscreenCanvas(dw, dh);
-        const ctx = cv.getContext("2d");
+        const ctx = cv.getContext('2d');
         for (let li = 0; li < layers.length; li++) {
-            if (!layers[li].visible)
+            if (!layers[li].visible) {
                 continue;
+            }
             const c = cels.current.get(pixelEditorTypes.celKey(fi, li));
-            if (!c)
+            if (!c) {
                 continue;
+            }
             const t = new OffscreenCanvas(dw, dh);
-            t.getContext("2d").putImageData(c, 0, 0);
+            t.getContext('2d').putImageData(c, 0, 0);
             ctx.globalAlpha = layers[li].opacity / 255;
             const bm = layers[li].blendMode;
-            if (bm !== "normal") {
+            if (bm !== 'normal') {
                 ctx.globalCompositeOperation = bm;
             }
             else {
-                ctx.globalCompositeOperation = "source-over";
+                ctx.globalCompositeOperation = 'source-over';
             }
             ctx.drawImage(t, 0, 0);
         }
-        ctx.globalCompositeOperation = "source-over";
+        ctx.globalCompositeOperation = 'source-over';
         return ctx.getImageData(0, 0, dw, dh);
     }, [dw, dh, layers]);
     /* ── rendering ── */
     const render = React.useCallback(() => {
         const canvas = cvRef.current;
         const box = boxRef.current;
-        if (!canvas || !box)
+        if (!canvas || !box) {
             return;
+        }
         const cw = box.clientWidth;
         const ch = box.clientHeight;
         if (canvas.width !== cw || canvas.height !== ch) {
             canvas.width = cw;
             canvas.height = ch;
         }
-        const ctx = canvas.getContext("2d");
+        const ctx = canvas.getContext('2d');
         ctx.clearRect(0, 0, cw, ch);
         ctx.imageSmoothingEnabled = false;
         ctx.save();
@@ -171,23 +185,26 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         ctx.scale(zoom, zoom);
         ctx.translate(-dw / 2, -dh / 2);
         // checkerboard
-        for (let y = 0; y < dh; y++)
+        for (let y = 0; y < dh; y++) {
             for (let x = 0; x < dw; x++) {
-                ctx.fillStyle = (x + y) % 2 === 0 ? "#3c3c3c" : "#2c2c2c";
+                ctx.fillStyle = (x + y) % 2 === 0 ? '#3c3c3c' : '#2c2c2c';
                 ctx.fillRect(x, y, 1, 1);
             }
+        }
         // onion skin (prev frame)
         if (onion && afi > 0) {
             const oc = new OffscreenCanvas(dw, dh);
-            const ox = oc.getContext("2d");
+            const ox = oc.getContext('2d');
             for (let li = 0; li < layers.length; li++) {
-                if (!layers[li].visible)
+                if (!layers[li].visible) {
                     continue;
+                }
                 const c = cels.current.get(pixelEditorTypes.celKey(afi - 1, li));
-                if (!c)
+                if (!c) {
                     continue;
+                }
                 const t = new OffscreenCanvas(dw, dh);
-                t.getContext("2d").putImageData(c, 0, 0);
+                t.getContext('2d').putImageData(c, 0, 0);
                 ox.globalAlpha = (layers[li].opacity / 255) * 0.25;
                 ox.drawImage(t, 0, 0);
             }
@@ -195,95 +212,105 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         }
         // current frame composite
         const comp = new OffscreenCanvas(dw, dh);
-        const cc = comp.getContext("2d");
+        const cc = comp.getContext('2d');
         for (let li = 0; li < layers.length; li++) {
-            if (!layers[li].visible)
+            if (!layers[li].visible) {
                 continue;
+            }
             const c = cels.current.get(pixelEditorTypes.celKey(afi, li));
-            if (!c)
+            if (!c) {
                 continue;
+            }
             const t = new OffscreenCanvas(dw, dh);
-            t.getContext("2d").putImageData(c, 0, 0);
+            t.getContext('2d').putImageData(c, 0, 0);
             cc.globalAlpha = layers[li].opacity / 255;
             const bm = layers[li].blendMode;
-            if (bm !== "normal") {
+            if (bm !== 'normal') {
                 cc.globalCompositeOperation = bm;
             }
             else {
-                cc.globalCompositeOperation = "source-over";
+                cc.globalCompositeOperation = 'source-over';
             }
             cc.drawImage(t, 0, 0);
         }
-        cc.globalCompositeOperation = "source-over";
+        cc.globalCompositeOperation = 'source-over';
         ctx.drawImage(comp, 0, 0);
         // tool preview (line / rect / ellipse while dragging)
         if (preview.current && drawing.current) {
             const pv = preview.current;
             const clr = btn.current === 2 ? pixelEditorTypes.hex2t(col2) : pixelEditorTypes.hex2t(col1);
             const pvData = pixelEditorUtils.cloneImageData(getCel(afi, aLi));
-            if (tool === "line") {
+            if (tool === 'line') {
                 pixelEditorUtils.bresenhamLine(pv.fr.x, pv.fr.y, pv.to.x, pv.to.y, (bx, by) => {
-                    if (pixelEditorTypes.inB(bx, by, dw, dh))
+                    if (pixelEditorTypes.inB(bx, by, dw, dh)) {
                         pixelEditorUtils.setPixel(pvData, bx, by, clr);
+                    }
                 });
             }
-            else if (tool === "rect") {
+            else if (tool === 'rect') {
                 const x1 = Math.min(pv.fr.x, pv.to.x), y1 = Math.min(pv.fr.y, pv.to.y);
                 const x2 = Math.max(pv.fr.x, pv.to.x), y2 = Math.max(pv.fr.y, pv.to.y);
                 if (shapeFilled) {
-                    for (let y = y1; y <= y2; y++)
-                        for (let x = x1; x <= x2; x++)
-                            if (pixelEditorTypes.inB(x, y, dw, dh))
+                    for (let y = y1; y <= y2; y++) {
+                        for (let x = x1; x <= x2; x++) {
+                            if (pixelEditorTypes.inB(x, y, dw, dh)) {
                                 pixelEditorUtils.setPixel(pvData, x, y, clr);
+                            }
+                        }
+                    }
                 }
                 else {
                     for (let x = x1; x <= x2; x++) {
-                        if (pixelEditorTypes.inB(x, y1, dw, dh))
+                        if (pixelEditorTypes.inB(x, y1, dw, dh)) {
                             pixelEditorUtils.setPixel(pvData, x, y1, clr);
-                        if (pixelEditorTypes.inB(x, y2, dw, dh))
+                        }
+                        if (pixelEditorTypes.inB(x, y2, dw, dh)) {
                             pixelEditorUtils.setPixel(pvData, x, y2, clr);
+                        }
                     }
                     for (let y = y1 + 1; y < y2; y++) {
-                        if (pixelEditorTypes.inB(x1, y, dw, dh))
+                        if (pixelEditorTypes.inB(x1, y, dw, dh)) {
                             pixelEditorUtils.setPixel(pvData, x1, y, clr);
-                        if (pixelEditorTypes.inB(x2, y, dw, dh))
+                        }
+                        if (pixelEditorTypes.inB(x2, y, dw, dh)) {
                             pixelEditorUtils.setPixel(pvData, x2, y, clr);
+                        }
                     }
                 }
             }
-            else if (tool === "ellipse") {
+            else if (tool === 'ellipse') {
                 const cx2 = (pv.fr.x + pv.to.x) / 2, cy2 = (pv.fr.y + pv.to.y) / 2;
                 const rx = Math.abs(pv.to.x - pv.fr.x) / 2, ry = Math.abs(pv.to.y - pv.fr.y) / 2;
                 pixelEditorTypes.plotEllipse(pvData, cx2, cy2, rx, ry, clr, dw, dh, shapeFilled);
             }
-            else if (tool === "gradient") {
+            else if (tool === 'gradient') {
                 const c2 = btn.current === 2 ? pixelEditorTypes.hex2t(col1) : pixelEditorTypes.hex2t(col2);
                 pixelEditorUtils.drawGradient(pvData, pv.fr.x, pv.fr.y, pv.to.x, pv.to.y, clr, c2, sel);
             }
             const pcv = new OffscreenCanvas(dw, dh);
-            pcv.getContext("2d").putImageData(pvData, 0, 0);
+            pcv.getContext('2d').putImageData(pvData, 0, 0);
             ctx.globalAlpha = layers[aLi].opacity / 255;
             ctx.drawImage(pcv, 0, 0);
             ctx.globalAlpha = 1;
         }
         // symmetry guides
-        if (symmetry !== "none") {
-            ctx.strokeStyle = "rgba(255,100,100,0.3)";
+        if (symmetry !== 'none') {
+            ctx.strokeStyle = 'rgba(255,100,100,0.3)';
             ctx.lineWidth = 1 / zoom;
             ctx.setLineDash([4 / zoom, 4 / zoom]);
-            if (symmetry === "h" || symmetry === "both") {
+            if (symmetry === 'h' || symmetry === 'both') {
                 ctx.beginPath();
                 ctx.moveTo(dw / 2, 0);
                 ctx.lineTo(dw / 2, dh);
                 ctx.stroke();
             }
-            if (symmetry === "v" || symmetry === "both") {
+            if (symmetry === 'v' || symmetry === 'both') {
                 ctx.beginPath();
                 ctx.moveTo(0, dh / 2);
                 ctx.lineTo(dw, dh / 2);
                 ctx.stroke();
             }
-            if (symmetry === "radial4") {
+            if (symmetry === 'radial4') {
                 ctx.beginPath();
                 ctx.moveTo(dw / 2, 0);
                 ctx.lineTo(dw / 2, dh);
@@ -295,7 +322,7 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         }
         // selection marching ants
         if (sel) {
-            ctx.strokeStyle = "rgba(255,255,255,0.8)";
+            ctx.strokeStyle = 'rgba(255,255,255,0.8)';
             ctx.lineWidth = 1 / zoom;
             ctx.setLineDash([4 / zoom, 4 / zoom]);
             ctx.strokeRect(sel.x, sel.y, sel.w, sel.h);
@@ -303,7 +330,7 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         }
         // grid
         if (grid && zoom >= 4) {
-            ctx.strokeStyle = "rgba(255,255,255,0.07)";
+            ctx.strokeStyle = 'rgba(255,255,255,0.07)';
             ctx.lineWidth = 1 / zoom;
             for (let x = 0; x <= dw; x++) {
                 ctx.beginPath();
@@ -319,16 +346,20 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
             }
         }
         // border
-        ctx.strokeStyle = "rgba(80,100,200,0.4)";
+        ctx.strokeStyle = 'rgba(80,100,200,0.4)';
         ctx.lineWidth = 1 / zoom;
         ctx.strokeRect(-0.5 / zoom, -0.5 / zoom, dw + 1 / zoom, dh + 1 / zoom);
         // brush cursor preview
-        if (cursor && pixelEditorTypes.inB(cursor.x, cursor.y, dw, dh) && (tool === "pencil" || tool === "eraser" || tool === "dither")) {
-            const sz = brush.pressureSize ? Math.max(1, Math.round(brush.size * curPressure.current)) : brush.size;
+        if (cursor &&
+            pixelEditorTypes.inB(cursor.x, cursor.y, dw, dh) &&
+            (tool === 'pencil' || tool === 'eraser' || tool === 'dither')) {
+            const sz = brush.pressureSize
+                ? Math.max(1, Math.round(brush.size * curPressure.current))
+                : brush.size;
             const half = Math.floor(sz / 2);
-            ctx.strokeStyle = "rgba(255,255,255,0.5)";
+            ctx.strokeStyle = 'rgba(255,255,255,0.5)';
             ctx.lineWidth = 1 / zoom;
-            if (brush.shape === "circle") {
+            if (brush.shape === 'circle') {
                 ctx.beginPath();
                 ctx.arc(cursor.x + 0.5, cursor.y + 0.5, half + 0.5, 0, Math.PI * 2);
                 ctx.stroke();
@@ -338,14 +369,34 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
             }
         }
         ctx.restore();
-    }, [dw, dh, zoom, px, py, layers, afi, aLi, grid, onion, tool, col1, col2, sel, getCel, symmetry, shapeFilled, brush, cursor]);
+    }, [
+        dw,
+        dh,
+        zoom,
+        px,
+        py,
+        layers,
+        afi,
+        aLi,
+        grid,
+        onion,
+        tool,
+        col1,
+        col2,
+        sel,
+        getCel,
+        symmetry,
+        shapeFilled,
+        brush,
+        cursor,
+    ]);
     /* ── brush drawing with symmetry ── */
     const applyBrushAt = React.useCallback((x, y, erase, pr) => {
         const cel = getCel(afi, aLi);
         const clr = erase ? [0, 0, 0, 0] : pixelEditorTypes.hex2t(btn.current === 2 ? col2 : col1);
         const pts = pixelEditorUtils.getSymmetryPoints(x, y, dw, dh, symmetry);
         for (const pt of pts) {
-            if (tool === "dither") {
+            if (tool === 'dither') {
                 pixelEditorUtils.applyDitherStamp(cel, pt.x, pt.y, clr, brush.size, pr);
             }
             else {
@@ -369,22 +420,23 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         }
         const p = scr2art(e.clientX, e.clientY);
         setCursor(p);
-        if ((_c = layers[aLi]) === null || _c === void 0 ? void 0 : _c.locked)
+        if ((_c = layers[aLi]) === null || _c === void 0 ? void 0 : _c.locked) {
             return;
+        }
         switch (tool) {
-            case "pencil":
-            case "eraser":
-            case "dither":
-                snap(tool === "pencil" ? "Draw" : tool === "eraser" ? "Erase" : "Dither");
+            case 'pencil':
+            case 'eraser':
+            case 'dither':
+                snap(tool === 'pencil' ? 'Draw' : tool === 'eraser' ? 'Erase' : 'Dither');
                 drawing.current = true;
                 lastPx.current = p;
                 brushDist.current = 0;
-                applyBrushAt(p.x, p.y, tool === "eraser", pr);
+                applyBrushAt(p.x, p.y, tool === 'eraser', pr);
                 setTick((t) => t + 1);
                 break;
-            case "fill":
+            case 'fill':
                 if (pixelEditorTypes.inB(p.x, p.y, dw, dh)) {
-                    snap("Fill");
+                    snap('Fill');
                     const clr = pixelEditorTypes.hex2t(e.button === 2 ? col2 : col1);
                     const pts = pixelEditorUtils.getSymmetryPoints(p.x, p.y, dw, dh, symmetry);
                     const cel = getCel(afi, aLi);
@@ -396,36 +448,54 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
                     setTick((t) => t + 1);
                 }
                 break;
-            case "eyedropper": {
+            case 'eyedropper': {
                 if (pixelEditorTypes.inB(p.x, p.y, dw, dh)) {
                     const c = pixelEditorUtils.getPixel(getCel(afi, aLi), p.x, p.y);
                     const hex = pixelEditorUtils.rgbaToHex(c);
-                    if (e.button === 2)
+                    if (e.button === 2) {
                         setCol2(hex);
-                    else
+                    }
+                    else {
                         setCol1(hex);
+                    }
                 }
                 break;
             }
-            case "line":
-            case "rect":
-            case "ellipse":
-            case "gradient":
+            case 'line':
+            case 'rect':
+            case 'ellipse':
+            case 'gradient':
                 snap(tool[0].toUpperCase() + tool.slice(1));
                 drawing.current = true;
                 tStart.current = p;
                 preview.current = { fr: p, to: p };
                 break;
-            case "select":
+            case 'select':
                 drawing.current = true;
                 tStart.current = p;
                 break;
-            case "move":
+            case 'move':
                 drawing.current = true;
                 lastPx.current = p;
                 break;
         }
-    }, [tool, aLi, layers, px, py, scr2art, snap, applyBrushAt, getCel, afi, col1, col2, dw, dh, symmetry]);
+    }, [
+        tool,
+        aLi,
+        layers,
+        px,
+        py,
+        scr2art,
+        snap,
+        applyBrushAt,
+        getCel,
+        afi,
+        col1,
+        col2,
+        dw,
+        dh,
+        symmetry,
+    ]);
     const onMove = React.useCallback((e) => {
         const pr = e.pressure > 0 ? e.pressure : 0.5;
         curPressure.current = pr;
@@ -437,30 +507,32 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         }
         const p = scr2art(e.clientX, e.clientY);
         setCursor(p);
-        if (!drawing.current)
+        if (!drawing.current) {
             return;
-        if (tool === "pencil" || tool === "eraser" || tool === "dither") {
+        }
+        if (tool === 'pencil' || tool === 'eraser' || tool === 'dither') {
             const last = lastPx.current || p;
             const spacing = Math.max(1, brush.size * (brush.spacing / 100));
             const ddx = p.x - last.x, ddy = p.y - last.y;
             const dist = Math.sqrt(ddx * ddx + ddy * ddy);
-            if (dist < 0.5)
+            if (dist < 0.5) {
                 return;
+            }
             brushDist.current += dist;
             if (brushDist.current >= spacing) {
                 pixelEditorUtils.bresenhamLine(last.x, last.y, p.x, p.y, (bx, by) => {
-                    applyBrushAt(bx, by, tool === "eraser", pr);
+                    applyBrushAt(bx, by, tool === 'eraser', pr);
                 });
                 brushDist.current = 0;
             }
             lastPx.current = p;
             setTick((t) => t + 1);
         }
-        else if (tool === "line" || tool === "rect" || tool === "ellipse" || tool === "gradient") {
+        else if (tool === 'line' || tool === 'rect' || tool === 'ellipse' || tool === 'gradient') {
             preview.current = { fr: tStart.current, to: p };
             setTick((t) => t + 1);
         }
-        else if (tool === "select") {
+        else if (tool === 'select') {
             const s = tStart.current;
             setSel({
                 x: Math.min(s.x, p.x),
@@ -469,7 +541,7 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
                 h: Math.abs(p.y - s.y) + 1,
             });
         }
-        else if (tool === "move" && sel) {
+        else if (tool === 'move' && sel) {
             const last2 = lastPx.current || p;
             const ddx = p.x - last2.x, ddy = p.y - last2.y;
             if (ddx !== 0 || ddy !== 0) {
@@ -483,18 +555,20 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
             panning.current = false;
             return;
         }
-        if (!drawing.current)
+        if (!drawing.current) {
             return;
+        }
         drawing.current = false;
         const p = scr2art(e.clientX, e.clientY);
         const clr = btn.current === 2 ? pixelEditorTypes.hex2t(col2) : pixelEditorTypes.hex2t(col1);
-        if (tool === "line" && tStart.current) {
+        if (tool === 'line' && tStart.current) {
             const cel = getCel(afi, aLi);
             pixelEditorUtils.getSymmetryPoints(0, 0, dw, dh, symmetry);
-            if (symmetry === "none") {
+            if (symmetry === 'none') {
                 pixelEditorUtils.bresenhamLine(tStart.current.x, tStart.current.y, p.x, p.y, (bx, by) => {
-                    if (pixelEditorTypes.inB(bx, by, dw, dh))
+                    if (pixelEditorTypes.inB(bx, by, dw, dh)) {
                         pixelEditorUtils.setPixel(cel, bx, by, clr);
+                    }
                 });
             }
             else {
@@ -502,42 +576,50 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
                 const toPts = pixelEditorUtils.getSymmetryPoints(p.x, p.y, dw, dh, symmetry);
                 for (let i = 0; i < fromPts.length; i++) {
                     pixelEditorUtils.bresenhamLine(fromPts[i].x, fromPts[i].y, toPts[i].x, toPts[i].y, (bx, by) => {
-                        if (pixelEditorTypes.inB(bx, by, dw, dh))
+                        if (pixelEditorTypes.inB(bx, by, dw, dh)) {
                             pixelEditorUtils.setPixel(cel, bx, by, clr);
+                        }
                     });
                 }
             }
             preview.current = null;
             setTick((t) => t + 1);
         }
-        else if (tool === "rect" && tStart.current) {
+        else if (tool === 'rect' && tStart.current) {
             const cel = getCel(afi, aLi);
             const x1 = Math.min(tStart.current.x, p.x), y1 = Math.min(tStart.current.y, p.y);
             const x2 = Math.max(tStart.current.x, p.x), y2 = Math.max(tStart.current.y, p.y);
             if (shapeFilled) {
-                for (let y = y1; y <= y2; y++)
-                    for (let x = x1; x <= x2; x++)
-                        if (pixelEditorTypes.inB(x, y, dw, dh))
+                for (let y = y1; y <= y2; y++) {
+                    for (let x = x1; x <= x2; x++) {
+                        if (pixelEditorTypes.inB(x, y, dw, dh)) {
                             pixelEditorUtils.setPixel(cel, x, y, clr);
+                        }
+                    }
+                }
             }
             else {
                 for (let x = x1; x <= x2; x++) {
-                    if (pixelEditorTypes.inB(x, y1, dw, dh))
+                    if (pixelEditorTypes.inB(x, y1, dw, dh)) {
                         pixelEditorUtils.setPixel(cel, x, y1, clr);
-                    if (pixelEditorTypes.inB(x, y2, dw, dh))
+                    }
+                    if (pixelEditorTypes.inB(x, y2, dw, dh)) {
                         pixelEditorUtils.setPixel(cel, x, y2, clr);
+                    }
                 }
                 for (let y = y1 + 1; y < y2; y++) {
-                    if (pixelEditorTypes.inB(x1, y, dw, dh))
+                    if (pixelEditorTypes.inB(x1, y, dw, dh)) {
                         pixelEditorUtils.setPixel(cel, x1, y, clr);
-                    if (pixelEditorTypes.inB(x2, y, dw, dh))
+                    }
+                    if (pixelEditorTypes.inB(x2, y, dw, dh)) {
                         pixelEditorUtils.setPixel(cel, x2, y, clr);
+                    }
                 }
             }
             preview.current = null;
             setTick((t) => t + 1);
         }
-        else if (tool === "ellipse" && tStart.current) {
+        else if (tool === 'ellipse' && tStart.current) {
             const cel = getCel(afi, aLi);
             const cx2 = (tStart.current.x + p.x) / 2;
             const cy2 = (tStart.current.y + p.y) / 2;
@@ -547,7 +629,7 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
             preview.current = null;
             setTick((t) => t + 1);
         }
-        else if (tool === "gradient" && tStart.current) {
+        else if (tool === 'gradient' && tStart.current) {
             const cel = getCel(afi, aLi);
             const c2 = btn.current === 2 ? pixelEditorTypes.hex2t(col1) : pixelEditorTypes.hex2t(col2);
             pixelEditorUtils.drawGradient(cel, tStart.current.x, tStart.current.y, p.x, p.y, clr, c2, sel);
@@ -558,22 +640,32 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         tStart.current = null;
     }, [tool, scr2art, getCel, afi, aLi, col1, col2, dw, dh, shapeFilled, symmetry, sel]);
     const onWheel = React.useCallback((e) => {
-        e.preventDefault();
         setZoom((z) => {
             const n = e.deltaY < 0 ? z * 1.2 : z / 1.2;
             return Math.max(0.5, Math.min(64, n));
         });
     }, []);
+    React.useEffect(() => {
+        const el = cvRef.current;
+        if (!el) {
+            return;
+        }
+        const handler = (e) => e.preventDefault();
+        el.addEventListener('wheel', handler, { passive: false });
+        return () => el.removeEventListener('wheel', handler);
+    }, []);
     /* ── clipboard operations ── */
     const doCopy = React.useCallback(() => {
-        if (!sel)
+        if (!sel) {
             return;
+        }
         clipboard.current = pixelEditorUtils.copySelection(getCel(afi, aLi), sel);
     }, [sel, getCel, afi, aLi]);
     const doCut = React.useCallback(() => {
-        if (!sel)
+        if (!sel) {
             return;
-        snap("Cut");
+        }
+        snap('Cut');
         const cel = getCel(afi, aLi);
         clipboard.current = pixelEditorUtils.copySelection(cel, sel);
         pixelEditorUtils.clearSelection(cel, sel);
@@ -581,17 +673,19 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
     }, [sel, getCel, afi, aLi, snap]);
     const doPaste = React.useCallback(() => {
         var _a, _b;
-        if (!clipboard.current)
+        if (!clipboard.current) {
             return;
-        snap("Paste");
+        }
+        snap('Paste');
         const cel = getCel(afi, aLi);
         pixelEditorUtils.pasteAt(cel, clipboard.current, (_a = sel === null || sel === void 0 ? void 0 : sel.x) !== null && _a !== void 0 ? _a : 0, (_b = sel === null || sel === void 0 ? void 0 : sel.y) !== null && _b !== void 0 ? _b : 0);
         setTick((t) => t + 1);
     }, [getCel, afi, aLi, snap, sel]);
     const doDeleteSel = React.useCallback(() => {
-        if (!sel)
+        if (!sel) {
             return;
-        snap("Delete Selection");
+        }
+        snap('Delete Selection');
         pixelEditorUtils.clearSelection(getCel(afi, aLi), sel);
         setTick((t) => t + 1);
     }, [sel, getCel, afi, aLi, snap]);
@@ -612,11 +706,20 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
             visible: l.visible,
             opacity: l.opacity,
             locked: false,
-            blendMode: "normal",
+            blendMode: 'normal',
         }));
         setLayers(lrs.length
             ? lrs
-            : [{ id: pixelEditorTypes.lid(), name: "Layer 1", visible: true, opacity: 255, locked: false, blendMode: "normal" }]);
+            : [
+                {
+                    id: pixelEditorTypes.lid(),
+                    name: 'Layer 1',
+                    visible: true,
+                    opacity: 255,
+                    locked: false,
+                    blendMode: 'normal',
+                },
+            ]);
         setALi(0);
         setFc(doc.frames.length || 1);
         setAfi(0);
@@ -625,22 +728,27 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
             frame.cels.forEach((cel) => {
                 const data = pixelEditorUtils.createBlankImageData(doc.width, doc.height);
                 if (cel.pixels && cel.width > 0 && cel.height > 0) {
-                    for (let y = 0; y < cel.height; y++)
+                    for (let y = 0; y < cel.height; y++) {
                         for (let x = 0; x < cel.width; x++) {
                             const dx = cel.x + x, dy = cel.y + y;
                             if (dx >= 0 && dy >= 0 && dx < doc.width && dy < doc.height) {
                                 const si = (y * cel.width + x) * 4;
                                 pixelEditorUtils.setPixel(data, dx, dy, [
-                                    cel.pixels[si], cel.pixels[si + 1], cel.pixels[si + 2], cel.pixels[si + 3],
+                                    cel.pixels[si],
+                                    cel.pixels[si + 1],
+                                    cel.pixels[si + 2],
+                                    cel.pixels[si + 3],
                                 ]);
                             }
                         }
+                    }
                 }
                 cels.current.set(pixelEditorTypes.celKey(fi, cel.layerIndex), data);
             });
         });
-        if (doc.palette.length)
+        if (doc.palette.length) {
             setPal(doc.palette.map(asepriteFormat.aseColorToHex));
+        }
         setZoom(Math.max(1, Math.floor(Math.min(512 / doc.width, 512 / doc.height))));
         setPx(0);
         setPy(0);
@@ -655,8 +763,8 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
                 loadAseDoc(doc);
             }
             catch (err) {
-                log.error("ASE parse error", err);
-                alert("Failed to parse Aseprite file.");
+                log.error('ASE parse error', err);
+                console.warn('[PixelEditor] Failed to parse Aseprite file.');
             }
         }
         else {
@@ -664,12 +772,21 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
             img.onload = () => {
                 const w2 = img.naturalWidth, h2 = img.naturalHeight;
                 const cv = new OffscreenCanvas(w2, h2);
-                cv.getContext("2d").drawImage(img, 0, 0);
-                const data = cv.getContext("2d").getImageData(0, 0, w2, h2);
+                cv.getContext('2d').drawImage(img, 0, 0);
+                const data = cv.getContext('2d').getImageData(0, 0, w2, h2);
                 setDw(w2);
                 setDh(h2);
                 cels.current = new Map([[pixelEditorTypes.celKey(0, 0), data]]);
-                setLayers([{ id: pixelEditorTypes.lid(), name: "Layer 1", visible: true, opacity: 255, locked: false, blendMode: "normal" }]);
+                setLayers([
+                    {
+                        id: pixelEditorTypes.lid(),
+                        name: 'Layer 1',
+                        visible: true,
+                        opacity: 255,
+                        locked: false,
+                        blendMode: 'normal',
+                    },
+                ]);
                 setALi(0);
                 setFc(1);
                 setAfi(0);
@@ -707,34 +824,44 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
     }, [dw, dh, fc, compFrame]);
     /* ── save to library ── */
     const saveToLibrary = React.useCallback(() => {
-        if (!onSaveToLibrary)
+        if (!onSaveToLibrary) {
             return;
+        }
         const data = compFrame(afi);
-        const cv = document.createElement("canvas");
+        const cv = document.createElement('canvas');
         cv.width = dw;
         cv.height = dh;
-        cv.getContext("2d").putImageData(data, 0, 0);
-        const dataUrl = cv.toDataURL("image/png");
+        cv.getContext('2d').putImageData(data, 0, 0);
+        const dataUrl = cv.toDataURL('image/png');
         const defaultName = `sprite-${dw}x${dh}.png`;
-        const name = window.prompt("Save to library as:", defaultName);
-        if (!name || !name.trim())
+        const name = window.prompt('Save to library as:', defaultName);
+        if (!name || !name.trim()) {
             return;
-        onSaveToLibrary(dataUrl, name.trim(), "image/png");
+        }
+        onSaveToLibrary(dataUrl, name.trim(), 'image/png');
     }, [onSaveToLibrary, afi, dw, dh, compFrame]);
     /* ── layer management ── */
     const addLayer = React.useCallback(() => {
-        snap("Add Layer");
+        snap('Add Layer');
         setLayers((ls) => [
             ...ls,
-            { id: pixelEditorTypes.lid(), name: `Layer ${ls.length + 1}`, visible: true, opacity: 255, locked: false, blendMode: "normal" },
+            {
+                id: pixelEditorTypes.lid(),
+                name: `Layer ${ls.length + 1}`,
+                visible: true,
+                opacity: 255,
+                locked: false,
+                blendMode: 'normal',
+            },
         ]);
         setALi(layers.length);
         setTick((t) => t + 1);
     }, [layers, snap]);
     const rmLayer = React.useCallback(() => {
-        if (layers.length <= 1)
+        if (layers.length <= 1) {
             return;
-        snap("Remove Layer");
+        }
+        snap('Remove Layer');
         const idx = aLi;
         for (let fi = 0; fi < fc; fi++) {
             cels.current.delete(pixelEditorTypes.celKey(fi, idx));
@@ -769,9 +896,10 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         setLayers((ls) => ls.map((l, j) => (j === i ? { ...l, name } : l)));
     }, []);
     const moveLayerUp = React.useCallback(() => {
-        if (aLi >= layers.length - 1)
+        if (aLi >= layers.length - 1) {
             return;
-        snap("Move Layer Up");
+        }
+        snap('Move Layer Up');
         setLayers((ls) => {
             const n = [...ls];
             [n[aLi], n[aLi + 1]] = [n[aLi + 1], n[aLi]];
@@ -780,22 +908,27 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         for (let fi = 0; fi < fc; fi++) {
             const a = cels.current.get(pixelEditorTypes.celKey(fi, aLi));
             const b = cels.current.get(pixelEditorTypes.celKey(fi, aLi + 1));
-            if (a)
+            if (a) {
                 cels.current.set(pixelEditorTypes.celKey(fi, aLi + 1), a);
-            else
+            }
+            else {
                 cels.current.delete(pixelEditorTypes.celKey(fi, aLi + 1));
-            if (b)
+            }
+            if (b) {
                 cels.current.set(pixelEditorTypes.celKey(fi, aLi), b);
-            else
+            }
+            else {
                 cels.current.delete(pixelEditorTypes.celKey(fi, aLi));
+            }
         }
         setALi(aLi + 1);
         setTick((t) => t + 1);
     }, [aLi, layers, fc, snap]);
     const moveLayerDown = React.useCallback(() => {
-        if (aLi <= 0)
+        if (aLi <= 0) {
             return;
-        snap("Move Layer Down");
+        }
+        snap('Move Layer Down');
         setLayers((ls) => {
             const n = [...ls];
             [n[aLi], n[aLi - 1]] = [n[aLi - 1], n[aLi]];
@@ -804,31 +937,36 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         for (let fi = 0; fi < fc; fi++) {
             const a = cels.current.get(pixelEditorTypes.celKey(fi, aLi));
             const b = cels.current.get(pixelEditorTypes.celKey(fi, aLi - 1));
-            if (a)
+            if (a) {
                 cels.current.set(pixelEditorTypes.celKey(fi, aLi - 1), a);
-            else
+            }
+            else {
                 cels.current.delete(pixelEditorTypes.celKey(fi, aLi - 1));
-            if (b)
+            }
+            if (b) {
                 cels.current.set(pixelEditorTypes.celKey(fi, aLi), b);
-            else
+            }
+            else {
                 cels.current.delete(pixelEditorTypes.celKey(fi, aLi));
+            }
         }
         setALi(aLi - 1);
         setTick((t) => t + 1);
     }, [aLi, fc, snap]);
     const mergeDown = React.useCallback(() => {
-        if (aLi <= 0)
+        if (aLi <= 0) {
             return;
-        snap("Merge Down");
+        }
+        snap('Merge Down');
         for (let fi = 0; fi < fc; fi++) {
             const top = cels.current.get(pixelEditorTypes.celKey(fi, aLi));
             const bot = getCel(fi, aLi - 1);
             if (top) {
                 const cv = new OffscreenCanvas(dw, dh);
-                const ctx = cv.getContext("2d");
+                const ctx = cv.getContext('2d');
                 ctx.putImageData(bot, 0, 0);
                 const t = new OffscreenCanvas(dw, dh);
-                t.getContext("2d").putImageData(top, 0, 0);
+                t.getContext('2d').putImageData(top, 0, 0);
                 ctx.globalAlpha = layers[aLi].opacity / 255;
                 ctx.drawImage(t, 0, 0);
                 cels.current.set(pixelEditorTypes.celKey(fi, aLi - 1), ctx.getImageData(0, 0, dw, dh));
@@ -849,8 +987,8 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         setTick((t) => t + 1);
     }, [aLi, fc, layers, getCel, dw, dh, snap]);
     const dupLayer = React.useCallback(() => {
-        snap("Duplicate Layer");
-        const newL = { ...layers[aLi], id: pixelEditorTypes.lid(), name: layers[aLi].name + " copy" };
+        snap('Duplicate Layer');
+        const newL = { ...layers[aLi], id: pixelEditorTypes.lid(), name: layers[aLi].name + ' copy' };
         setLayers((ls) => [...ls.slice(0, aLi + 1), newL, ...ls.slice(aLi + 1)]);
         for (let fi = 0; fi < fc; fi++) {
             for (let li = layers.length; li > aLi; li--) {
@@ -861,27 +999,29 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
                 }
             }
             const src = cels.current.get(pixelEditorTypes.celKey(fi, aLi));
-            if (src)
+            if (src) {
                 cels.current.set(pixelEditorTypes.celKey(fi, aLi + 1), pixelEditorUtils.cloneImageData(src));
+            }
         }
         setALi(aLi + 1);
         setTick((t) => t + 1);
     }, [aLi, layers, fc, snap]);
     /* ── frame management ── */
     const addFrame = React.useCallback(() => {
-        snap("Add Frame");
+        snap('Add Frame');
         setFc((n) => n + 1);
         setFDur((d) => [...d, 100]);
         setAfi(fc);
         setTick((t) => t + 1);
     }, [fc, snap]);
     const dupFrame = React.useCallback(() => {
-        snap("Dup Frame");
+        snap('Dup Frame');
         const ni = fc;
         for (let li = 0; li < layers.length; li++) {
             const c = cels.current.get(pixelEditorTypes.celKey(afi, li));
-            if (c)
+            if (c) {
                 cels.current.set(pixelEditorTypes.celKey(ni, li), pixelEditorUtils.cloneImageData(c));
+            }
         }
         setFc((n) => n + 1);
         setFDur((d) => [...d, fDur[afi] || 100]);
@@ -889,9 +1029,10 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         setTick((t) => t + 1);
     }, [fc, afi, layers, fDur, snap]);
     const rmFrame = React.useCallback(() => {
-        if (fc <= 1)
+        if (fc <= 1) {
             return;
-        snap("Remove Frame");
+        }
+        snap('Remove Frame');
         for (let li = 0; li < layers.length; li++) {
             cels.current.delete(pixelEditorTypes.celKey(afi, li));
             for (let f = afi + 1; f < fc; f++) {
@@ -909,12 +1050,12 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
     }, [fc, afi, layers, snap]);
     /* ── canvas ops ── */
     const flipCv = React.useCallback((dir) => {
-        snap(`Flip ${dir === "h" ? "H" : "V"}`);
-        cels.current.forEach((c, k) => cels.current.set(k, dir === "h" ? pixelEditorUtils.flipH(c) : pixelEditorUtils.flipV(c)));
+        snap(`Flip ${dir === 'h' ? 'H' : 'V'}`);
+        cels.current.forEach((c, k) => cels.current.set(k, dir === 'h' ? pixelEditorUtils.flipH(c) : pixelEditorUtils.flipV(c)));
         setTick((t) => t + 1);
     }, [snap]);
     const rotateCv = React.useCallback(() => {
-        snap("Rotate 90°");
+        snap('Rotate 90°');
         const n = new Map();
         cels.current.forEach((c, k) => n.set(k, pixelEditorUtils.rotateCW(c)));
         cels.current = n;
@@ -923,7 +1064,7 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         setTick((t) => t + 1);
     }, [dw, dh, snap]);
     const clearCv = React.useCallback(() => {
-        snap("Clear");
+        snap('Clear');
         cels.current.set(pixelEditorTypes.celKey(afi, aLi), pixelEditorUtils.createBlankImageData(dw, dh));
         setTick((t) => t + 1);
     }, [afi, aLi, dw, dh, snap]);
@@ -931,7 +1072,16 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
         setDw(w);
         setDh(h);
         cels.current = new Map();
-        setLayers([{ id: pixelEditorTypes.lid(), name: "Background", visible: true, opacity: 255, locked: false, blendMode: "normal" }]);
+        setLayers([
+            {
+                id: pixelEditorTypes.lid(),
+                name: 'Background',
+                visible: true,
+                opacity: 255,
+                locked: false,
+                blendMode: 'normal',
+            },
+        ]);
         setALi(0);
         setFc(1);
         setAfi(0);
@@ -953,49 +1103,60 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
     // keyboard shortcuts
     React.useEffect(() => {
         const h = (e) => {
-            if (dlgNew)
+            if (dlgNew) {
                 return;
+            }
             const tgt = e.target;
-            if (tgt.tagName === "INPUT" || tgt.tagName === "TEXTAREA" || tgt.tagName === "SELECT")
+            if (tgt.tagName === 'INPUT' || tgt.tagName === 'TEXTAREA' || tgt.tagName === 'SELECT') {
                 return;
-            if (e.ctrlKey && e.key === "z") {
+            }
+            if (e.ctrlKey && e.key === 'z') {
                 e.preventDefault();
                 undo();
                 return;
             }
-            if (e.ctrlKey && (e.key === "y" || (e.shiftKey && e.key === "Z"))) {
+            if (e.ctrlKey && (e.key === 'y' || (e.shiftKey && e.key === 'Z'))) {
                 e.preventDefault();
                 redo();
                 return;
             }
-            if (e.ctrlKey && e.key === "c") {
+            if (e.ctrlKey && e.key === 'c') {
                 e.preventDefault();
                 doCopy();
                 return;
             }
-            if (e.ctrlKey && e.key === "x") {
+            if (e.ctrlKey && e.key === 'x') {
                 e.preventDefault();
                 doCut();
                 return;
             }
-            if (e.ctrlKey && e.key === "v") {
+            if (e.ctrlKey && e.key === 'v') {
                 e.preventDefault();
                 doPaste();
                 return;
             }
-            if (e.ctrlKey && e.key === "a") {
+            if (e.ctrlKey && e.key === 'a') {
                 e.preventDefault();
                 doSelectAll();
                 return;
             }
-            if (e.ctrlKey && e.key === "d") {
+            if (e.ctrlKey && e.key === 'd') {
                 e.preventDefault();
                 doDeselectAll();
                 return;
             }
             const km = {
-                b: "pencil", e: "eraser", g: "fill", l: "line", u: "rect",
-                o: "ellipse", i: "eyedropper", m: "select", v: "move", h: "gradient", d: "dither",
+                b: 'pencil',
+                e: 'eraser',
+                g: 'fill',
+                l: 'line',
+                u: 'rect',
+                o: 'ellipse',
+                i: 'eyedropper',
+                m: 'select',
+                v: 'move',
+                h: 'gradient',
+                d: 'dither',
             };
             const k = e.key.toLowerCase();
             if (km[k]) {
@@ -1003,59 +1164,82 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
                 return;
             }
             switch (k) {
-                case "+":
-                case "=":
+                case '+':
+                case '=':
                     setZoom((z) => Math.min(64, z * 1.5));
                     break;
-                case "-":
+                case '-':
                     setZoom((z) => Math.max(0.5, z / 1.5));
                     break;
-                case "arrowleft":
+                case 'arrowleft':
                     setAfi((f) => Math.max(0, f - 1));
                     break;
-                case "arrowright":
+                case 'arrowright':
                     setAfi((f) => Math.min(fc - 1, f + 1));
                     break;
-                case "n":
-                    if (!e.ctrlKey)
+                case 'n':
+                    if (!e.ctrlKey) {
                         addFrame();
+                    }
                     break;
-                case "delete":
-                    if (sel)
+                case 'delete':
+                    if (sel) {
                         doDeleteSel();
-                    else
+                    }
+                    else {
                         clearCv();
+                    }
                     break;
-                case "x": {
-                    setCol1((c) => { setCol2(c); return col2; });
+                case 'x': {
+                    setCol1((c) => {
+                        setCol2(c);
+                        return col2;
+                    });
                     break;
                 }
-                case "[":
+                case '[':
                     setBrush((b) => ({ ...b, size: Math.max(1, b.size - 1) }));
                     break;
-                case "]":
+                case ']':
                     setBrush((b) => ({ ...b, size: Math.min(64, b.size + 1) }));
                     break;
-                case "f":
+                case 'f':
                     setShapeFilled((f) => !f);
                     break;
             }
         };
-        window.addEventListener("keydown", h);
-        return () => window.removeEventListener("keydown", h);
-    }, [dlgNew, undo, redo, fc, addFrame, clearCv, col2, doCopy, doCut, doPaste, doSelectAll, doDeselectAll, doDeleteSel, sel]);
+        window.addEventListener('keydown', h);
+        return () => window.removeEventListener('keydown', h);
+    }, [
+        dlgNew,
+        undo,
+        redo,
+        fc,
+        addFrame,
+        clearCv,
+        col2,
+        doCopy,
+        doCut,
+        doPaste,
+        doSelectAll,
+        doDeselectAll,
+        doDeleteSel,
+        sel,
+    ]);
     // animation playback
     React.useEffect(() => {
-        if (!playing)
+        if (!playing) {
             return;
+        }
         const iv = setInterval(() => setAfi((f) => (f + 1) % fc), 1000 / fps);
         return () => clearInterval(iv);
     }, [playing, fc, fps]);
     // resize observer
     React.useEffect(() => {
         const el = boxRef.current;
-        if (!el)
+        if (!el) {
             return;
+        }
         const obs = new ResizeObserver(() => setTick((t) => t + 1));
         obs.observe(el);
         return () => obs.disconnect();
@@ -1064,20 +1248,22 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
     const thumbs = React.useMemo(() => {
         const out = [];
         for (let fi = 0; fi < fc; fi++) {
-            const cv = document.createElement("canvas");
+            const cv = document.createElement('canvas');
             cv.width = dw;
             cv.height = dh;
-            const ctx = cv.getContext("2d");
+            const ctx = cv.getContext('2d');
             for (let li = 0; li < layers.length; li++) {
-                if (!layers[li].visible)
+                if (!layers[li].visible) {
                     continue;
+                }
                 const c = cels.current.get(pixelEditorTypes.celKey(fi, li));
-                if (!c)
+                if (!c) {
                     continue;
-                const t = document.createElement("canvas");
+                }
+                const t = document.createElement('canvas');
                 t.width = dw;
                 t.height = dh;
-                t.getContext("2d").putImageData(c, 0, 0);
+                t.getContext('2d').putImageData(c, 0, 0);
                 ctx.globalAlpha = layers[li].opacity / 255;
                 ctx.drawImage(t, 0, 0);
             }
@@ -1087,23 +1273,99 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
     }, [fc, dw, dh, layers, tick]);
     /* ── return API ── */
     return {
-        dw, dh, layers, aLi, setALi, fc, afi, setAfi, fDur,
-        tool, setTool, col1, setCol1, col2, setCol2,
-        brush, setBrush, zoom, setZoom, grid, setGrid, onion, setOnion,
-        fps, setFps, playing, setPlaying, pal, setPal,
-        cursor, setCursor, dlgNew, setDlgNew, nw, setNw, nh, setNh,
-        sel, setSel, symmetry, setSymmetry, shapeFilled, setShapeFilled,
-        pressure, showHSV, setShowHSV, editingLayerName, setEditingLayerName,
-        cvRef, boxRef, fInp, clipboard, drawing, panning,
-        undo, redo, openFile,
-        exportAse, exportPNG, exportJPG, exportWebP, exportBMP, exportSVG, exportSheet,
+        dw,
+        dh,
+        layers,
+        aLi,
+        setALi,
+        fc,
+        afi,
+        setAfi,
+        fDur,
+        tool,
+        setTool,
+        col1,
+        setCol1,
+        col2,
+        setCol2,
+        brush,
+        setBrush,
+        zoom,
+        setZoom,
+        grid,
+        setGrid,
+        onion,
+        setOnion,
+        fps,
+        setFps,
+        playing,
+        setPlaying,
+        pal,
+        setPal,
+        cursor,
+        setCursor,
+        dlgNew,
+        setDlgNew,
+        nw,
+        setNw,
+        nh,
+        setNh,
+        sel,
+        setSel,
+        symmetry,
+        setSymmetry,
+        shapeFilled,
+        setShapeFilled,
+        pressure,
+        showHSV,
+        setShowHSV,
+        editingLayerName,
+        setEditingLayerName,
+        cvRef,
+        boxRef,
+        fInp,
+        clipboard,
+        drawing,
+        panning,
+        undo,
+        redo,
+        openFile,
+        exportAse,
+        exportPNG,
+        exportJPG,
+        exportWebP,
+        exportBMP,
+        exportSVG,
+        exportSheet,
         saveToLibrary,
-        addLayer, rmLayer, toggleVis, toggleLock, setLayerOpacity, setLayerBlendMode,
-        renameLayer, moveLayerUp, moveLayerDown, mergeDown, dupLayer,
-        addFrame, dupFrame, rmFrame,
-        flipCv, rotateCv, clearCv, newDoc,
-        doCopy, doCut, doPaste, doDeleteSel, doSelectAll, doDeselectAll,
-        onDown, onMove, onUp, onWheel,
+        addLayer,
+        rmLayer,
+        toggleVis,
+        toggleLock,
+        setLayerOpacity,
+        setLayerBlendMode,
+        renameLayer,
+        moveLayerUp,
+        moveLayerDown,
+        mergeDown,
+        dupLayer,
+        addFrame,
+        dupFrame,
+        rmFrame,
+        flipCv,
+        rotateCv,
+        clearCv,
+        newDoc,
+        doCopy,
+        doCut,
+        doPaste,
+        doDeleteSel,
+        doSelectAll,
+        doDeselectAll,
+        onDown,
+        onMove,
+        onUp,
+        onWheel,
         thumbs,
         importImageData: React.useCallback((img) => {
             snap('import generator');
@@ -1119,7 +1381,7 @@ function usePixelEditor({ initialWidth = 64, initialHeight = 64, onSaveToLibrary
             ctx.drawImage(src, 0, 0);
             const merged = ctx.getImageData(0, 0, dw, dh);
             cel.data.set(merged.data);
-            setTick(t => t + 1);
+            setTick((t) => t + 1);
         }, [snap, getCel, afi, aLi, dw, dh]),
     };
 }