supervision 0.0.9000 → 0.1.0

package/dist/mask-preparation.worker.js

@@ -0,0 +1,823 @@
+(function () {
+    'use strict';
+
+    /** COCO-compatible keypoint visibility values. */
+    var KeypointVisibility;
+    (function (KeypointVisibility) {
+        KeypointVisibility[KeypointVisibility["NotLabeled"] = 0] = "NotLabeled";
+        KeypointVisibility[KeypointVisibility["Occluded"] = 1] = "Occluded";
+        KeypointVisibility[KeypointVisibility["Visible"] = 2] = "Visible";
+    })(KeypointVisibility || (KeypointVisibility = {}));
+    var DetectionMaskEncoding;
+    (function (DetectionMaskEncoding) {
+        DetectionMaskEncoding["CompressedRle"] = "compressedRle";
+    })(DetectionMaskEncoding || (DetectionMaskEncoding = {}));
+
+    var DetectionBufferStatus;
+    (function (DetectionBufferStatus) {
+        DetectionBufferStatus["Idle"] = "idle";
+        DetectionBufferStatus["Loading"] = "loading";
+        DetectionBufferStatus["Ready"] = "ready";
+        DetectionBufferStatus["Error"] = "error";
+        DetectionBufferStatus["Destroyed"] = "destroyed";
+    })(DetectionBufferStatus || (DetectionBufferStatus = {}));
+    /**
+     * How the renderer selects the active detection frame for a media timestamp.
+     */
+    var DetectionFrameSelectionMode;
+    (function (DetectionFrameSelectionMode) {
+        /**
+         * Select the frame whose `[mediaTime, endTime)` interval contains the media
+         * time. This is the default for interval annotations and timestamped sources.
+         */
+        DetectionFrameSelectionMode["Interval"] = "interval";
+        /**
+         * Select from a known inference frame grid using `frameIndex`, `frameRate`,
+         * and optional `frameIndexOriginTime`. This is useful when inference was run
+         * on normalized frames and playback should snap detections to that grid.
+         */
+        DetectionFrameSelectionMode["NearestFrameIndex"] = "nearestFrameIndex";
+    })(DetectionFrameSelectionMode || (DetectionFrameSelectionMode = {}));
+    var DetectionFrameRetentionMode;
+    (function (DetectionFrameRetentionMode) {
+        /**
+         * Keep writable detections only in an in-memory store. Useful for ephemeral
+         * live streams where old predictions should disappear when evicted.
+         */
+        DetectionFrameRetentionMode["MemoryOnly"] = "memoryOnly";
+        /**
+         * Persist every written detection frame. Useful for finite media where seek
+         * and replay should not require recomputing detections.
+         */
+        DetectionFrameRetentionMode["PersistAll"] = "persistAll";
+        /**
+         * Persist only the most recent retention window. Useful for long-running
+         * streams where replay is bounded to a recent time horizon.
+         */
+        DetectionFrameRetentionMode["PersistWindow"] = "persistWindow";
+    })(DetectionFrameRetentionMode || (DetectionFrameRetentionMode = {}));
+    function decodeCompressedRleMask(mask) {
+        if (mask.encoding !== DetectionMaskEncoding.CompressedRle) {
+            throw new Error(`Unsupported detection mask encoding: ${mask.encoding}`);
+        }
+        const data = new Uint8Array(mask.width * mask.height);
+        const counts = decodeCompressedRleCounts(mask.counts);
+        let offset = 0;
+        for (let index = 0; index < counts.length; index += 1) {
+            const runLength = counts[index] ?? 0;
+            const isForeground = index % 2 === 1;
+            if (isForeground) {
+                for (let runOffset = 0; runOffset < runLength; runOffset += 1) {
+                    const maskOffset = offset + runOffset;
+                    const x = Math.floor(maskOffset / mask.height);
+                    const y = maskOffset % mask.height;
+                    const rowMajorOffset = y * mask.width + x;
+                    if (rowMajorOffset < data.length) {
+                        data[rowMajorOffset] = 1;
+                    }
+                }
+            }
+            offset += runLength;
+        }
+        return {
+            data,
+            height: mask.height,
+            width: mask.width,
+        };
+    }
+    function decodeCompressedRleCounts(counts) {
+        const decoded = [];
+        let index = 0;
+        while (index < counts.length) {
+            let value = 0;
+            let shift = 0;
+            let charCode;
+            do {
+                charCode = counts.charCodeAt(index) - 48;
+                index += 1;
+                value |= (charCode & 0x1f) << shift;
+                shift += 5;
+            } while (charCode & 0x20);
+            if (charCode & 0x10) {
+                value |= -1 << shift;
+            }
+            if (decoded.length > 2) {
+                value += decoded[decoded.length - 2] ?? 0;
+            }
+            decoded.push(value);
+        }
+        return decoded;
+    }
+    function encodeCompressedRleCounts(counts) {
+        return counts
+            .map((count, index) => {
+            let value = index > 2 ? count - counts[index - 2] : count;
+            let encoded = "";
+            let more = true;
+            while (more) {
+                let charCode = value & 0x1f;
+                value >>= 5;
+                more = !((value === 0 && (charCode & 0x10) === 0) ||
+                    (value === -1 && (charCode & 0x10) !== 0));
+                if (more) {
+                    charCode |= 0x20;
+                }
+                encoded += String.fromCharCode(charCode + 48);
+            }
+            return encoded;
+        })
+            .join("");
+    }
+
+    var AnnotationFrameMutationKind;
+    (function (AnnotationFrameMutationKind) {
+        AnnotationFrameMutationKind["Add"] = "add";
+        AnnotationFrameMutationKind["Remove"] = "remove";
+        AnnotationFrameMutationKind["Replace"] = "replace";
+        AnnotationFrameMutationKind["Transact"] = "transact";
+        AnnotationFrameMutationKind["Update"] = "update";
+    })(AnnotationFrameMutationKind || (AnnotationFrameMutationKind = {}));
+
+    var DetectionPickTarget;
+    (function (DetectionPickTarget) {
+        DetectionPickTarget["Box"] = "box";
+        DetectionPickTarget["Edge"] = "edge";
+        DetectionPickTarget["Keypoint"] = "keypoint";
+        DetectionPickTarget["Label"] = "label";
+        DetectionPickTarget["Mask"] = "mask";
+        DetectionPickTarget["Polygon"] = "polygon";
+        DetectionPickTarget["Polyline"] = "polyline";
+    })(DetectionPickTarget || (DetectionPickTarget = {}));
+    var MediaInteractionMode;
+    (function (MediaInteractionMode) {
+        MediaInteractionMode["Always"] = "always";
+        MediaInteractionMode["Disabled"] = "disabled";
+        MediaInteractionMode["PausedOnly"] = "pausedOnly";
+    })(MediaInteractionMode || (MediaInteractionMode = {}));
+
+    function centerRectToTopLeftRect(rect) {
+        return {
+            height: rect.height,
+            width: rect.width,
+            x: rect.x - rect.width / 2,
+            y: rect.y - rect.height / 2,
+        };
+    }
+    function getPointsRect(points) {
+        if (points.length === 0) {
+            return undefined;
+        }
+        let minX = Number.POSITIVE_INFINITY;
+        let minY = Number.POSITIVE_INFINITY;
+        let maxX = Number.NEGATIVE_INFINITY;
+        let maxY = Number.NEGATIVE_INFINITY;
+        for (const point of points) {
+            minX = Math.min(minX, point.x);
+            minY = Math.min(minY, point.y);
+            maxX = Math.max(maxX, point.x);
+            maxY = Math.max(maxY, point.y);
+        }
+        return {
+            height: maxY - minY,
+            width: maxX - minX,
+            x: (minX + maxX) / 2,
+            y: (minY + maxY) / 2,
+        };
+    }
+
+    var AnnotationGeometryKind;
+    (function (AnnotationGeometryKind) {
+        AnnotationGeometryKind["Box"] = "box";
+        AnnotationGeometryKind["Polygon"] = "polygon";
+        AnnotationGeometryKind["Polyline"] = "polyline";
+        AnnotationGeometryKind["Keypoints"] = "keypoints";
+        AnnotationGeometryKind["Mask"] = "mask";
+    })(AnnotationGeometryKind || (AnnotationGeometryKind = {}));
+    var AnnotationGestureStateKind;
+    (function (AnnotationGestureStateKind) {
+        AnnotationGestureStateKind["Idle"] = "idle";
+        AnnotationGestureStateKind["Creating"] = "creating";
+        AnnotationGestureStateKind["Moving"] = "moving";
+        AnnotationGestureStateKind["Resizing"] = "resizing";
+        AnnotationGestureStateKind["DragSelecting"] = "dragSelecting";
+    })(AnnotationGestureStateKind || (AnnotationGestureStateKind = {}));
+    var AnnotationHandleKind;
+    (function (AnnotationHandleKind) {
+        AnnotationHandleKind["Resize"] = "resize";
+        AnnotationHandleKind["Vertex"] = "vertex";
+        AnnotationHandleKind["AddVertex"] = "addVertex";
+        AnnotationHandleKind["Keypoint"] = "keypoint";
+    })(AnnotationHandleKind || (AnnotationHandleKind = {}));
+
+    var BoxShape;
+    (function (BoxShape) {
+        BoxShape["Rect"] = "rect";
+        BoxShape["RoundedRect"] = "roundedRect";
+    })(BoxShape || (BoxShape = {}));
+    var BoxStrokeAlignment;
+    (function (BoxStrokeAlignment) {
+        BoxStrokeAlignment["Inside"] = "inside";
+        BoxStrokeAlignment["Center"] = "center";
+        BoxStrokeAlignment["Outside"] = "outside";
+    })(BoxStrokeAlignment || (BoxStrokeAlignment = {}));
+
+    var FocusTargetMode;
+    (function (FocusTargetMode) {
+        FocusTargetMode["Hovered"] = "hovered";
+        FocusTargetMode["Selected"] = "selected";
+        FocusTargetMode["HoveredAndSelected"] = "hoveredAndSelected";
+        FocusTargetMode["Ambient"] = "ambient";
+    })(FocusTargetMode || (FocusTargetMode = {}));
+
+    var DetectionInteractionState;
+    (function (DetectionInteractionState) {
+        DetectionInteractionState["Hovered"] = "hovered";
+        DetectionInteractionState["Selected"] = "selected";
+    })(DetectionInteractionState || (DetectionInteractionState = {}));
+
+    var LabelPlacement;
+    (function (LabelPlacement) {
+        LabelPlacement["Top"] = "top";
+        LabelPlacement["Bottom"] = "bottom";
+        LabelPlacement["InsideTop"] = "insideTop";
+        LabelPlacement["InsideBottom"] = "insideBottom";
+        LabelPlacement["Center"] = "center";
+    })(LabelPlacement || (LabelPlacement = {}));
+    var LabelVisibilityMode;
+    (function (LabelVisibilityMode) {
+        LabelVisibilityMode["Always"] = "always";
+        LabelVisibilityMode["HoveredOnly"] = "hoveredOnly";
+    })(LabelVisibilityMode || (LabelVisibilityMode = {}));
+
+    var MaskRenderMode;
+    (function (MaskRenderMode) {
+        MaskRenderMode["FillAndStroke"] = "fillAndStroke";
+        MaskRenderMode["FillOnly"] = "fillOnly";
+        MaskRenderMode["StrokeOnly"] = "strokeOnly";
+    })(MaskRenderMode || (MaskRenderMode = {}));
+
+    var KeypointMarkerShape;
+    (function (KeypointMarkerShape) {
+        KeypointMarkerShape["Circle"] = "circle";
+        KeypointMarkerShape["Cross"] = "cross";
+    })(KeypointMarkerShape || (KeypointMarkerShape = {}));
+
+    var DetectionMaskPayloadFormat;
+    (function (DetectionMaskPayloadFormat) {
+        DetectionMaskPayloadFormat["RawCocoRle"] = "rawCocoRle";
+        DetectionMaskPayloadFormat["DeflatedBase64"] = "deflatedBase64";
+    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));
+    function encodeBinaryMask(data, width, height) {
+        assertMaskDimensions(data, width, height);
+        const runs = [];
+        let currentValue = 0;
+        let runLength = 0;
+        for (let x = 0; x < width; x += 1) {
+            for (let y = 0; y < height; y += 1) {
+                const value = data[y * width + x] ? 1 : 0;
+                if (value === currentValue) {
+                    runLength += 1;
+                }
+                else {
+                    runs.push(runLength);
+                    currentValue = value;
+                    runLength = 1;
+                }
+            }
+        }
+        runs.push(runLength);
+        return {
+            counts: encodeCompressedRleCounts(runs),
+            encoding: DetectionMaskEncoding.CompressedRle,
+            height,
+            width,
+        };
+    }
+    function assertMaskDimensions(data, width, height) {
+        if (!Number.isInteger(width) || width <= 0) {
+            throw new Error("Mask width must be a positive integer.");
+        }
+        if (!Number.isInteger(height) || height <= 0) {
+            throw new Error("Mask height must be a positive integer.");
+        }
+        if (data.length !== width * height) {
+            throw new Error("Mask data length must equal width * height.");
+        }
+    }
+    function rasterizePolygonToMask(points, dimensions) {
+        const data = createEmptyMask(dimensions);
+        if (points.length < 3) {
+            return data;
+        }
+        const bounds = centerRectToTopLeftRect(getPointsRect(points));
+        const startY = Math.max(0, Math.floor(bounds.y));
+        const endY = Math.min(dimensions.height - 1, Math.ceil(bounds.y + bounds.height));
+        for (let y = startY; y <= endY; y += 1) {
+            const scanY = y + 0.5;
+            const intersections = [];
+            for (let index = 0; index < points.length; index += 1) {
+                const current = points[index];
+                const next = points[(index + 1) % points.length];
+                if ((current.y <= scanY && next.y > scanY) ||
+                    (next.y <= scanY && current.y > scanY)) {
+                    const ratio = (scanY - current.y) / (next.y - current.y);
+                    intersections.push(current.x + ratio * (next.x - current.x));
+                }
+            }
+            intersections.sort((left, right) => left - right);
+            for (let index = 0; index < intersections.length - 1; index += 2) {
+                const left = Math.max(0, Math.ceil(intersections[index]));
+                const right = Math.min(dimensions.width - 1, Math.floor(intersections[index + 1]));
+                for (let x = left; x <= right; x += 1) {
+                    data[y * dimensions.width + x] = 1;
+                }
+            }
+        }
+        return data;
+    }
+    function createEmptyMask(dimensions) {
+        if (!Number.isInteger(dimensions.width) ||
+            dimensions.width <= 0 ||
+            !Number.isInteger(dimensions.height) ||
+            dimensions.height <= 0) {
+            throw new Error("Media dimensions must be positive integers.");
+        }
+        return new Uint8Array(dimensions.width * dimensions.height);
+    }
+
+    const MAX_ID_MASK_PALETTE_ENTRIES = 64;
+    const MAX_ID_MASK_STROKE_WIDTH = 16;
+    function createIdMaskFrame(instructions) {
+        if (instructions.length === 0) {
+            return undefined;
+        }
+        const width = Math.max(...instructions.map(({ mask }) => mask.width));
+        const height = Math.max(...instructions.map(({ mask }) => mask.height));
+        const data = new Uint8Array(new ArrayBuffer(width * height));
+        const fillPalette = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4 * 4));
+        const strokePalette = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4 * 4));
+        const strokeWidths = new Float32Array(new ArrayBuffer(MAX_ID_MASK_PALETTE_ENTRIES * 4));
+        let hasStroke = false;
+        let maxStrokeWidth = 0;
+        for (const instruction of instructions) {
+            const detectionMaskId = instruction.detectionIndex + 1;
+            if (detectionMaskId <= 0 ||
+                detectionMaskId >= MAX_ID_MASK_PALETTE_ENTRIES) {
+                return undefined;
+            }
+            writePaletteEntry(fillPalette, detectionMaskId, instruction.color, instruction.alpha);
+            if (instruction.stroke && instruction.stroke.width > 0) {
+                const strokeWidth = Math.min(Math.max(0, instruction.stroke.width), MAX_ID_MASK_STROKE_WIDTH);
+                hasStroke = true;
+                strokeWidths[detectionMaskId] = strokeWidth;
+                maxStrokeWidth = Math.max(maxStrokeWidth, strokeWidth);
+                writePaletteEntry(strokePalette, detectionMaskId, instruction.stroke.color, instruction.stroke.alpha);
+            }
+            const decodedMask = decodeCompressedRleMask(instruction.mask);
+            for (let y = 0; y < decodedMask.height; y += 1) {
+                for (let x = 0; x < decodedMask.width; x += 1) {
+                    const maskOffset = y * decodedMask.width + x;
+                    if (decodedMask.data[maskOffset]) {
+                        data[y * width + x] = detectionMaskId;
+                    }
+                }
+            }
+        }
+        return {
+            data,
+            fillPalette,
+            hasStroke,
+            height,
+            maxStrokeWidth,
+            strokePalette,
+            strokeWidths,
+            width,
+        };
+    }
+    function writePaletteEntry(palette, id, color, alpha) {
+        const offset = id * 4;
+        palette[offset] = ((color >> 16) & 0xff) / 255;
+        palette[offset + 1] = ((color >> 8) & 0xff) / 255;
+        palette[offset + 2] = (color & 0xff) / 255;
+        palette[offset + 3] = Math.max(0, Math.min(alpha, 1));
+    }
+
+    var MediaRendererFit;
+    (function (MediaRendererFit) {
+        /**
+         * Preserve media aspect ratio and fit the full frame inside the canvas.
+         */
+        MediaRendererFit["Contain"] = "contain";
+        /**
+         * Preserve media aspect ratio and fill the canvas, cropping if necessary.
+         */
+        MediaRendererFit["Cover"] = "cover";
+    })(MediaRendererFit || (MediaRendererFit = {}));
+    /**
+     * Playback lifecycle state reported by a platform renderer.
+     */
+    var MediaRendererPlaybackState;
+    (function (MediaRendererPlaybackState) {
+        MediaRendererPlaybackState["Loading"] = "loading";
+        MediaRendererPlaybackState["Ready"] = "ready";
+        MediaRendererPlaybackState["Playing"] = "playing";
+        MediaRendererPlaybackState["Buffering"] = "buffering";
+        MediaRendererPlaybackState["Paused"] = "paused";
+        MediaRendererPlaybackState["Error"] = "error";
+        MediaRendererPlaybackState["Destroyed"] = "destroyed";
+    })(MediaRendererPlaybackState || (MediaRendererPlaybackState = {}));
+    /**
+     * Lower-level media source readiness.
+     */
+    var MediaSourceStatus;
+    (function (MediaSourceStatus) {
+        MediaSourceStatus["Loading"] = "loading";
+        MediaSourceStatus["Ready"] = "ready";
+        MediaSourceStatus["Error"] = "error";
+        MediaSourceStatus["Destroyed"] = "destroyed";
+    })(MediaSourceStatus || (MediaSourceStatus = {}));
+
+    /**
+     * Media-session operating mode.
+     *
+     * Core owns the names because file-like and stream-like lifecycle choices are
+     * platform-neutral. Platform packages decide how these modes tune media,
+     * storage, and renderer defaults.
+     */
+    var MediaSessionMode;
+    (function (MediaSessionMode) {
+        /**
+         * Finite media. Defaults usually favor seek/replay and persistent detection
+         * storage.
+         */
+        MediaSessionMode["File"] = "file";
+        /**
+         * Live or append-only media. Defaults usually favor rolling windows and
+         * bounded retention.
+         */
+        MediaSessionMode["Stream"] = "stream";
+    })(MediaSessionMode || (MediaSessionMode = {}));
+    /**
+     * Aggregate lifecycle state for a media session.
+     */
+    var MediaSessionStatus;
+    (function (MediaSessionStatus) {
+        MediaSessionStatus["Buffering"] = "buffering";
+        MediaSessionStatus["Destroyed"] = "destroyed";
+        MediaSessionStatus["Error"] = "error";
+        MediaSessionStatus["Loading"] = "loading";
+        MediaSessionStatus["Paused"] = "paused";
+        MediaSessionStatus["Playing"] = "playing";
+        MediaSessionStatus["Processing"] = "processing";
+        MediaSessionStatus["Ready"] = "ready";
+    })(MediaSessionStatus || (MediaSessionStatus = {}));
+    /**
+     * Subsystem currently affecting session readiness or presentation.
+     */
+    var MediaSessionActivityKind;
+    (function (MediaSessionActivityKind) {
+        MediaSessionActivityKind["DetectionsBuffering"] = "detectionsBuffering";
+        MediaSessionActivityKind["DetectionsLoading"] = "detectionsLoading";
+        MediaSessionActivityKind["Error"] = "error";
+        MediaSessionActivityKind["MediaNormalizing"] = "mediaNormalizing";
+        MediaSessionActivityKind["MediaOpening"] = "mediaOpening";
+        MediaSessionActivityKind["PlaybackBuffering"] = "playbackBuffering";
+        MediaSessionActivityKind["RenderPreparing"] = "renderPreparing";
+    })(MediaSessionActivityKind || (MediaSessionActivityKind = {}));
+    /**
+     * State of one session activity.
+     */
+    var MediaSessionActivityStatus;
+    (function (MediaSessionActivityStatus) {
+        MediaSessionActivityStatus["Error"] = "error";
+        MediaSessionActivityStatus["Running"] = "running";
+        MediaSessionActivityStatus["Waiting"] = "waiting";
+    })(MediaSessionActivityStatus || (MediaSessionActivityStatus = {}));
+
+    const PNG_SIGNATURE = new Uint8Array([
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+    ]);
+    function compositeMaskFrame(instructions) {
+        const maskInstructions = materializeMaskInstructions(instructions);
+        if (maskInstructions.length === 0) {
+            return undefined;
+        }
+        const width = Math.max(...maskInstructions.map(({ mask }) => mask.width));
+        const height = Math.max(...maskInstructions.map(({ mask }) => mask.height));
+        const data = new Uint8ClampedArray(new ArrayBuffer(width * height * 4));
+        for (const instruction of maskInstructions) {
+            compositeInstruction(data, width, instruction);
+        }
+        return { data, height, width };
+    }
+    async function createPngIdMaskFrame(instructions) {
+        const frame = createIdMaskFrame(materializeMaskInstructions(instructions));
+        if (!frame) {
+            return undefined;
+        }
+        return {
+            ...frame,
+            png: await encodeGrayscalePng({
+                height: frame.height,
+                pixels: frame.data,
+                width: frame.width,
+            }),
+        };
+    }
+    function compositeInstruction(rgba, canvasWidth, instruction) {
+        const decodedMask = decodeCompressedRleMask(instruction.mask);
+        const fill = resolveRgbaColor(instruction.color, instruction.alpha);
+        compositeMaskFill(rgba, canvasWidth, decodedMask, fill);
+        if (instruction.stroke) {
+            compositeMaskStroke(rgba, canvasWidth, decodedMask, instruction.stroke);
+        }
+    }
+    function materializeMaskInstructions(instructions) {
+        return instructions.map((instruction) => {
+            if (instruction.mask) {
+                return instruction;
+            }
+            const { height, points, width } = instruction.polygon;
+            return {
+                alpha: instruction.alpha,
+                color: instruction.color,
+                detectionIndex: instruction.detectionIndex,
+                mask: encodeBinaryMask(rasterizePolygonToMask(points, { height, width }), width, height),
+                stroke: instruction.stroke,
+            };
+        });
+    }
+    function compositeMaskFill(rgba, canvasWidth, decodedMask, fill) {
+        for (let y = 0; y < decodedMask.height; y += 1) {
+            for (let x = 0; x < decodedMask.width; x += 1) {
+                const maskOffset = y * decodedMask.width + x;
+                if (!decodedMask.data[maskOffset]) {
+                    continue;
+                }
+                writePixel(rgba, canvasWidth, x, y, fill);
+            }
+        }
+    }
+    function compositeMaskStroke(rgba, canvasWidth, decodedMask, stroke) {
+        const width = Math.round(stroke.width);
+        if (width <= 0) {
+            return;
+        }
+        const strokeColor = resolveRgbaColor(stroke.color, stroke.alpha);
+        for (let y = 0; y < decodedMask.height; y += 1) {
+            for (let x = 0; x < decodedMask.width; x += 1) {
+                if (!isMaskPixel(decodedMask, x, y) ||
+                    !isBoundaryPixel(decodedMask, x, y)) {
+                    continue;
+                }
+                for (let offsetY = -width; offsetY <= width; offsetY += 1) {
+                    for (let offsetX = -width; offsetX <= width; offsetX += 1) {
+                        const strokeX = x + offsetX;
+                        const strokeY = y + offsetY;
+                        if (isOutsideMaskBounds(decodedMask, strokeX, strokeY) ||
+                            isMaskPixel(decodedMask, strokeX, strokeY)) {
+                            continue;
+                        }
+                        writePixel(rgba, canvasWidth, strokeX, strokeY, strokeColor);
+                    }
+                }
+            }
+        }
+    }
+    function isBoundaryPixel(mask, x, y) {
+        for (let offsetY = -1; offsetY <= 1; offsetY += 1) {
+            for (let offsetX = -1; offsetX <= 1; offsetX += 1) {
+                if (offsetX === 0 && offsetY === 0) {
+                    continue;
+                }
+                const neighborX = x + offsetX;
+                const neighborY = y + offsetY;
+                if (isOutsideMaskBounds(mask, neighborX, neighborY) ||
+                    !isMaskPixel(mask, neighborX, neighborY)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    function isMaskPixel(mask, x, y) {
+        return mask.data[y * mask.width + x] === 1;
+    }
+    function isOutsideMaskBounds(mask, x, y) {
+        return x < 0 || y < 0 || x >= mask.width || y >= mask.height;
+    }
+    function resolveRgbaColor(color, alpha) {
+        return {
+            alpha: Math.round(Math.max(0, Math.min(alpha, 1)) * 255),
+            blue: color & 0xff,
+            green: (color >> 8) & 0xff,
+            red: (color >> 16) & 0xff,
+        };
+    }
+    function writePixel(rgba, canvasWidth, x, y, color) {
+        const rgbaOffset = (y * canvasWidth + x) * 4;
+        rgba[rgbaOffset] = color.red;
+        rgba[rgbaOffset + 1] = color.green;
+        rgba[rgbaOffset + 2] = color.blue;
+        rgba[rgbaOffset + 3] = color.alpha;
+    }
+    async function encodeGrayscalePng(options) {
+        if (typeof CompressionStream === "undefined") {
+            throw new Error("CompressionStream is required to encode PNG ID masks.");
+        }
+        const rawScanlines = createFilterlessPngScanlines(options);
+        const ihdr = new Uint8Array(13);
+        const ihdrView = new DataView(ihdr.buffer);
+        ihdrView.setUint32(0, options.width);
+        ihdrView.setUint32(4, options.height);
+        ihdr[8] = 8;
+        ihdr[9] = 0;
+        ihdr[10] = 0;
+        ihdr[11] = 0;
+        ihdr[12] = 0;
+        const compressed = new Uint8Array(await new Response(new Blob([rawScanlines])
+            .stream()
+            .pipeThrough(new CompressionStream("deflate"))).arrayBuffer());
+        return concatUint8Arrays([
+            PNG_SIGNATURE,
+            createPngChunk("IHDR", ihdr),
+            createPngChunk("IDAT", compressed),
+            createPngChunk("IEND", new Uint8Array(0)),
+        ]);
+    }
+    function createFilterlessPngScanlines(options) {
+        const rowStride = options.width + 1;
+        const scanlines = new Uint8Array(rowStride * options.height);
+        for (let y = 0; y < options.height; y += 1) {
+            const sourceOffset = y * options.width;
+            const targetOffset = y * rowStride;
+            scanlines[targetOffset] = 0;
+            scanlines.set(options.pixels.subarray(sourceOffset, sourceOffset + options.width), targetOffset + 1);
+        }
+        return scanlines;
+    }
+    function createPngChunk(type, data) {
+        const typeBytes = new TextEncoder().encode(type);
+        const chunk = new Uint8Array(12 + data.length);
+        const view = new DataView(chunk.buffer);
+        view.setUint32(0, data.length);
+        chunk.set(typeBytes, 4);
+        chunk.set(data, 8);
+        view.setUint32(8 + data.length, crc32(concatUint8Arrays([typeBytes, data])));
+        return chunk;
+    }
+    const crc32Table = createCrc32Table();
+    function createCrc32Table() {
+        const table = new Uint32Array(256);
+        for (let index = 0; index < table.length; index += 1) {
+            let value = index;
+            for (let bit = 0; bit < 8; bit += 1) {
+                value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+            }
+            table[index] = value >>> 0;
+        }
+        return table;
+    }
+    function crc32(bytes) {
+        let crc = 0xffffffff;
+        for (const byte of bytes) {
+            crc = crc32Table[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+        }
+        return (crc ^ 0xffffffff) >>> 0;
+    }
+    function concatUint8Arrays(chunks) {
+        const totalLength = chunks.reduce((total, chunk) => total + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return result;
+    }
+
+    var PreparedMaskFrameKind;
+    (function (PreparedMaskFrameKind) {
+        PreparedMaskFrameKind["PngIdMask"] = "pngIdMask";
+        PreparedMaskFrameKind["RgbaImage"] = "rgbaImage";
+    })(PreparedMaskFrameKind || (PreparedMaskFrameKind = {}));
+
+    var MaskPreparationWorkerMessageType;
+    (function (MaskPreparationWorkerMessageType) {
+        MaskPreparationWorkerMessageType["Complete"] = "complete";
+        MaskPreparationWorkerMessageType["Empty"] = "empty";
+        MaskPreparationWorkerMessageType["Error"] = "error";
+        MaskPreparationWorkerMessageType["Prepare"] = "prepare";
+    })(MaskPreparationWorkerMessageType || (MaskPreparationWorkerMessageType = {}));
+
+    const workerScope = globalThis;
+    workerScope.addEventListener("message", (event) => {
+        const message = event.data;
+        if (message.type !== MaskPreparationWorkerMessageType.Prepare) {
+            return;
+        }
+        void prepareMaskFrame(message);
+    });
+    async function prepareMaskFrame(message) {
+        try {
+            const pngIdMaskFrame = await createPngIdMaskWorkerResponse(message);
+            if (pngIdMaskFrame) {
+                workerScope.postMessage(pngIdMaskFrame, [
+                    pngIdMaskFrame.imageBitmap,
+                    pngIdMaskFrame.png.buffer,
+                    pngIdMaskFrame.fillPalette.buffer,
+                    pngIdMaskFrame.strokePalette.buffer,
+                    pngIdMaskFrame.strokeWidths.buffer,
+                ]);
+                return;
+            }
+            const compositedFrame = compositeMaskFrame(message.job.instructions);
+            if (!compositedFrame) {
+                workerScope.postMessage({
+                    key: message.job.key,
+                    requestId: message.requestId,
+                    type: MaskPreparationWorkerMessageType.Empty,
+                });
+                return;
+            }
+            const imageData = new ImageData(compositedFrame.data, compositedFrame.width, compositedFrame.height);
+            const imageBitmap = createImageBitmapFromImageData(imageData);
+            if (imageBitmap) {
+                workerScope.postMessage({
+                    imageBitmap,
+                    key: message.job.key,
+                    requestId: message.requestId,
+                    type: MaskPreparationWorkerMessageType.Complete,
+                }, [imageBitmap]);
+                return;
+            }
+            workerScope.postMessage({
+                imageData,
+                key: message.job.key,
+                requestId: message.requestId,
+                type: MaskPreparationWorkerMessageType.Complete,
+            }, [imageData.data.buffer]);
+        }
+        catch (error) {
+            workerScope.postMessage({
+                error: error instanceof Error
+                    ? error.message
+                    : "Unable to prepare mask frame.",
+                key: message.job.key,
+                requestId: message.requestId,
+                type: MaskPreparationWorkerMessageType.Error,
+            });
+        }
+    }
+    async function createPngIdMaskWorkerResponse(message) {
+        if (typeof Blob === "undefined" ||
+            typeof createImageBitmap === "undefined" ||
+            typeof CompressionStream === "undefined") {
+            return undefined;
+        }
+        let frame;
+        try {
+            frame = await createPngIdMaskFrame(message.job.instructions);
+        }
+        catch {
+            return undefined;
+        }
+        if (!frame) {
+            return undefined;
+        }
+        let imageBitmap;
+        try {
+            imageBitmap = await createImageBitmap(new Blob([frame.png], { type: "image/png" }));
+        }
+        catch {
+            return undefined;
+        }
+        return {
+            artifactKind: PreparedMaskFrameKind.PngIdMask,
+            fillPalette: frame.fillPalette,
+            hasStroke: frame.hasStroke,
+            imageBitmap,
+            key: message.job.key,
+            maxStrokeWidth: frame.maxStrokeWidth,
+            png: frame.png,
+            requestId: message.requestId,
+            strokePalette: frame.strokePalette,
+            strokeWidths: frame.strokeWidths,
+            type: MaskPreparationWorkerMessageType.Complete,
+        };
+    }
+    function createImageBitmapFromImageData(imageData) {
+        if (typeof OffscreenCanvas === "undefined") {
+            return null;
+        }
+        const canvas = new OffscreenCanvas(imageData.width, imageData.height);
+        const context = canvas.getContext("2d");
+        if (!context) {
+            return null;
+        }
+        context.putImageData(imageData, 0, 0);
+        return canvas.transferToImageBitmap();
+    }
+
+})();
+//# sourceMappingURL=mask-preparation.worker.js.map