@ai-game-assets/dev 0.8.3 → 0.9.0

package/dist/provider-image-processing.js

@@ -1,48 +1,5 @@
 import { PNG } from "pngjs";
 import sharp from "sharp";
-const DEFAULT_CHROMA_KEY = { red: 255, green: 0, blue: 255 };
-const CHROMA_KEY_CANDIDATES = [
-    DEFAULT_CHROMA_KEY,
-    { red: 0, green: 255, blue: 0 },
-    { red: 0, green: 255, blue: 255 },
-    { red: 255, green: 255, blue: 0 },
-    { red: 0, green: 0, blue: 255 }
-];
-const CHROMA_MATCH_TOLERANCE = 120;
-const CHROMA_EDGE_TOLERANCE = 170;
-const CHROMA_EDGE_FILL_TOLERANCE = 150;
-const STRICT_CHROMA_MATCH_TOLERANCE = 90;
-const COHERENT_EDGE_MATTE_TOLERANCE = 96;
-const COHERENT_EDGE_MATTE_MIN_COVERAGE = 0.55;
-const OPAQUE_EDGE_ALPHA_THRESHOLD = 224;
-export function selectChromaKey(request) {
-    const samples = [...(request.references ?? []), ...(request.styleReferences ?? [])]
-        .flatMap((reference) => referenceColorSamples(reference));
-    const prompt = [
-        request.prompt,
-        request.asset.prompt,
-        request.stylePrompt,
-        ...(request.asset.tileset?.tiles?.map((tile) => tile.prompt) ?? [])
-    ].filter(Boolean).join(" ").toLowerCase();
-    if (!samples.length) {
-        return CHROMA_KEY_CANDIDATES.find((candidate) => !promptMentionsChromaFamily(prompt, candidate)) ??
-            DEFAULT_CHROMA_KEY;
-    }
-    return CHROMA_KEY_CANDIDATES
-        .filter((candidate) => !promptMentionsChromaFamily(prompt, candidate))
-        .map((candidate) => ({
-        candidate,
-        score: Math.min(...samples.map((sample) => colorDistance(candidate, sample)))
-    }))
-        .sort((left, right) => right.score - left.score)[0]?.candidate ??
-        CHROMA_KEY_CANDIDATES
-            .map((candidate) => ({
-            candidate,
-            score: Math.min(...samples.map((sample) => colorDistance(candidate, sample)))
-        }))
-            .sort((left, right) => right.score - left.score)[0]?.candidate ??
-        DEFAULT_CHROMA_KEY;
-}
 export function referenceLockPromptLines(references) {
     const analyses = references
         .map((reference) => analyzeReferenceImage(reference))
@@ -70,28 +27,6 @@ export function referenceLockPromptLines(references) {
         return lines;
     });
 }
-export function referenceColorSamples(reference) {
-    if (reference.mimeType !== "image/png")
-        return [];
-    let png;
-    try {
-        png = PNG.sync.read(Buffer.from(reference.image));
-    }
-    catch {
-        return [];
-    }
-    const bins = new Map();
-    for (let offset = 0; offset < png.data.length; offset += 4) {
-        const alpha = png.data[offset + 3] ?? 255;
-        if (alpha < 64)
-            continue;
-        const red = png.data[offset] ?? 0;
-        const green = png.data[offset + 1] ?? 0;
-        const blue = png.data[offset + 2] ?? 0;
-        addColorBin(bins, red, green, blue);
-    }
-    return topColorBinValues(bins, 8);
-}
 export function analyzeReferenceImage(reference) {
     if (reference.mimeType !== "image/png")
         return undefined;
@@ -116,8 +51,6 @@ export function analyzeReferenceImage(reference) {
         const red = png.data[offset] ?? 0;
         const green = png.data[offset + 1] ?? 0;
         const blue = png.data[offset + 2] ?? 0;
-        if (isChromaRgb(red, green, blue))
-            continue;
         visiblePixels += 1;
         const max = Math.max(red, green, blue);
         const min = Math.min(red, green, blue);
@@ -181,9 +114,6 @@ export function topColorBinValues(bins, count) {
 export function quantizeColor(value) {
     return Math.round(value / 32) * 32;
 }
-export function isChromaRgb(red, green, blue) {
-    return CHROMA_KEY_CANDIDATES.some((chromaKey) => (colorDistance({ red, green, blue }, chromaKey) < 90));
-}
 export function isBrightSaturatedColor(red, green, blue) {
     const max = Math.max(red, green, blue);
     const min = Math.min(red, green, blue);
@@ -210,16 +140,6 @@ export function colorName(red, green, blue) {
         return blue - red > 40 ? "blue" : "purple";
     return "color";
 }
-export function colorDistance(left, right) {
-    const redDelta = left.red - right.red;
-    const greenDelta = left.green - right.green;
-    const blueDelta = left.blue - right.blue;
-    return Math.sqrt(redDelta * redDelta + greenDelta * greenDelta + blueDelta * blueDelta);
-}
-export function hexColor(color) {
-    const channel = (value) => value.toString(16).padStart(2, "0");
-    return `#${channel(color.red)}${channel(color.green)}${channel(color.blue)}`;
-}
 export function rgbColor(color) {
     return `rgb(${color.red}, ${color.green}, ${color.blue})`;
 }
@@ -232,8 +152,8 @@ export function variationDirectionPromptLine(index) {
     ];
     return variants[index % variants.length];
 }
-export function shouldRequestRgbaPng(request, context) {
-    if (!context.model.startsWith("gpt-image-2") || context.outputFormat !== "png") {
+export function shouldRequestTransparency(request, context) {
+    if (context.outputFormat === "jpeg") {
         return false;
     }
     if (context.requestedBackground === "opaque") {
@@ -254,270 +174,6 @@ export function resolveRequestedBackground(request, options) {
     }
     return options.background ?? "transparent";
 }
-export function shouldPostprocessTransparency(request, context) {
-    return shouldRequestRgbaPng(request, context);
-}
-export function removeChromaBackground(image, chromaKey) {
-    const png = PNG.sync.read(Buffer.from(image));
-    const backgroundRemoval = detectBackgroundRemoval(png, chromaKey);
-    if (!backgroundRemoval) {
-        return Buffer.from(image);
-    }
-    removeDetectedBackground(png, backgroundRemoval);
-    return PNG.sync.write(png);
-}
-export function removeTilesetChromaBackground(image, tileset, chromaKey) {
-    const png = PNG.sync.read(Buffer.from(image));
-    const tileCapacity = tileset.columns * tileset.rows;
-    const tileCount = Math.min(tileset.tileCount ?? tileCapacity, tileCapacity);
-    const cellPixels = new Uint8Array(png.width * png.height);
-    for (let index = 0; index < tileCapacity; index += 1) {
-        const bounds = scaledTilesetCellBounds(png, tileset, index);
-        if (!bounds)
-            continue;
-        markPngRect(cellPixels, png.width, bounds.x, bounds.y, bounds.width, bounds.height);
-        if (index >= tileCount) {
-            clearPngRect(png, bounds.x, bounds.y, bounds.width, bounds.height);
-            continue;
-        }
-        const cell = copyPngRect(png, bounds.x, bounds.y, bounds.width, bounds.height);
-        if (removeKnownChromaPixels(cell, chromaKey)) {
-            pastePngRect(png, cell, bounds.x, bounds.y);
-        }
-    }
-    clearUnmarkedPngPixels(png, cellPixels);
-    return PNG.sync.write(png);
-}
-function markPngRect(pixels, imageWidth, x, y, width, height) {
-    for (let localY = 0; localY < height; localY += 1) {
-        const start = (y + localY) * imageWidth + x;
-        pixels.fill(1, start, start + width);
-    }
-}
-function clearUnmarkedPngPixels(png, markedPixels) {
-    for (let index = 0; index < markedPixels.length; index += 1) {
-        if (markedPixels[index])
-            continue;
-        const offset = index * 4;
-        png.data[offset] = 0;
-        png.data[offset + 1] = 0;
-        png.data[offset + 2] = 0;
-        png.data[offset + 3] = 0;
-    }
-}
-function removeDetectedBackground(png, backgroundRemoval) {
-    const width = png.width;
-    const height = png.height;
-    const visited = new Uint8Array(width * height);
-    const transparent = new Uint8Array(width * height);
-    const queue = [];
-    let queueCursor = 0;
-    const enqueue = (x, y) => {
-        if (x < 0 || y < 0 || x >= width || y >= height)
-            return;
-        const index = y * width + x;
-        if (visited[index])
-            return;
-        visited[index] = 1;
-        if (isRemovableEdgeBackgroundPixel(png, index, backgroundRemoval)) {
-            queue.push(index);
-        }
-    };
-    for (let x = 0; x < width; x += 1) {
-        enqueue(x, 0);
-        enqueue(x, height - 1);
-    }
-    for (let y = 1; y < height - 1; y += 1) {
-        enqueue(0, y);
-        enqueue(width - 1, y);
-    }
-    while (queueCursor < queue.length) {
-        const index = queue[queueCursor];
-        queueCursor += 1;
-        transparent[index] = 1;
-        const x = index % width;
-        const y = Math.floor(index / width);
-        enqueue(x + 1, y);
-        enqueue(x - 1, y);
-        enqueue(x, y + 1);
-        enqueue(x, y - 1);
-    }
-    for (let index = 0; index < transparent.length; index += 1) {
-        if (transparent[index] ||
-            (backgroundRemoval.kind === "chroma" &&
-                backgroundRemoval.removeDisconnected &&
-                isHighConfidenceChromaPixel(png, index, backgroundRemoval.chromaKey))) {
-            transparent[index] = 1;
-            setAlpha(png, index, 0);
-        }
-    }
-    featherBackgroundEdges(png, transparent, backgroundRemoval);
-}
-function removeKnownChromaPixels(png, chromaKey) {
-    const transparent = new Uint8Array(png.width * png.height);
-    let found = false;
-    for (let index = 0; index < transparent.length; index += 1) {
-        if (isChromaPixel(png, index, CHROMA_MATCH_TOLERANCE, chromaKey) ||
-            isKeyTintedPixel(rgbAt(png, index), chromaKey, 0.86)) {
-            transparent[index] = 1;
-            setAlpha(png, index, 0);
-            found = true;
-        }
-    }
-    if (found) {
-        featherBackgroundEdges(png, transparent, {
-            kind: "chroma",
-            chromaKey,
-            removeDisconnected: true
-        });
-    }
-    return found;
-}
-function scaledTilesetCellBounds(png, tileset, index) {
-    const margin = tileset.margin ?? 0;
-    const spacing = tileset.spacing ?? 0;
-    const sheetWidth = margin * 2 + tileset.columns * tileset.tileWidth +
-        Math.max(0, tileset.columns - 1) * spacing;
-    const sheetHeight = margin * 2 + tileset.rows * tileset.tileHeight +
-        Math.max(0, tileset.rows - 1) * spacing;
-    if (sheetWidth <= 0 || sheetHeight <= 0 || index < 0 || index >= tileset.columns * tileset.rows) {
-        return undefined;
-    }
-    const column = index % tileset.columns;
-    const row = Math.floor(index / tileset.columns);
-    const sourceX = margin + column * (tileset.tileWidth + spacing);
-    const sourceY = margin + row * (tileset.tileHeight + spacing);
-    const x = Math.round((sourceX / sheetWidth) * png.width);
-    const y = Math.round((sourceY / sheetHeight) * png.height);
-    const right = Math.round(((sourceX + tileset.tileWidth) / sheetWidth) * png.width);
-    const bottom = Math.round(((sourceY + tileset.tileHeight) / sheetHeight) * png.height);
-    return {
-        x,
-        y,
-        width: Math.max(1, right - x),
-        height: Math.max(1, bottom - y)
-    };
-}
-function copyPngRect(png, x, y, width, height) {
-    const target = new PNG({ width, height });
-    PNG.bitblt(png, target, x, y, width, height, 0, 0);
-    return target;
-}
-function pastePngRect(png, source, x, y) {
-    PNG.bitblt(source, png, 0, 0, source.width, source.height, x, y);
-}
-export function detectBackgroundRemoval(png, chromaKey) {
-    if (hasRequestedChromaKey(png, chromaKey)) {
-        return {
-            kind: "chroma",
-            chromaKey,
-            removeDisconnected: hasRequestedChromaKeyOnEdges(png, chromaKey)
-        };
-    }
-    const matteColor = detectNeutralEdgeMatte(png);
-    if (matteColor) {
-        return { kind: "edge-matte", matteColor };
-    }
-    const coherentMatteColor = detectCoherentEdgeMatte(png);
-    return coherentMatteColor
-        ? { kind: "coherent-edge-matte", matteColor: coherentMatteColor }
-        : undefined;
-}
-export function hasRequestedChromaKey(png, chromaKey) {
-    if (hasRequestedChromaKeyOnEdges(png, chromaKey))
-        return true;
-    let matches = 0;
-    const threshold = Math.max(256, Math.floor(png.width * png.height * 0.005));
-    for (let index = 0; index < png.width * png.height; index += 1) {
-        if (isChromaPixel(png, index, STRICT_CHROMA_MATCH_TOLERANCE, chromaKey) ||
-            isKeyTintedPixel(rgbAt(png, index), chromaKey, 0.8)) {
-            matches += 1;
-            if (matches >= threshold)
-                return true;
-        }
-    }
-    return false;
-}
-export function hasRequestedChromaKeyOnEdges(png, chromaKey) {
-    const edgeStats = sampleImageEdges(png, (index) => (isChromaPixel(png, index, STRICT_CHROMA_MATCH_TOLERANCE, chromaKey) ||
-        isKeyTintedPixel(rgbAt(png, index), chromaKey, 0.8)));
-    return edgeStats.matches / edgeStats.total >= 0.18;
-}
-export function detectNeutralEdgeMatte(png) {
-    let edgePixelCount = 0;
-    let neutralEdgePixelCount = 0;
-    let redTotal = 0;
-    let greenTotal = 0;
-    let blueTotal = 0;
-    sampleImageEdges(png, (index) => {
-        const color = rgbAt(png, index);
-        edgePixelCount += 1;
-        if (isNeutralMatteCandidate(color)) {
-            neutralEdgePixelCount += 1;
-            redTotal += color.red;
-            greenTotal += color.green;
-            blueTotal += color.blue;
-        }
-        return false;
-    });
-    if (neutralEdgePixelCount === 0 ||
-        neutralEdgePixelCount / edgePixelCount < 0.65 ||
-        neutralCornerCount(png) < 3) {
-        return undefined;
-    }
-    const matteColor = {
-        red: Math.round(redTotal / neutralEdgePixelCount),
-        green: Math.round(greenTotal / neutralEdgePixelCount),
-        blue: Math.round(blueTotal / neutralEdgePixelCount)
-    };
-    const matteStats = sampleImageEdges(png, (index) => (isNeutralMattePixel(rgbAt(png, index), matteColor)));
-    return matteStats.matches / matteStats.total >= 0.55 ? matteColor : undefined;
-}
-export function detectCoherentEdgeMatte(png) {
-    const corners = [
-        { x: 0, y: 0 },
-        { x: png.width - 1, y: 0 },
-        { x: 0, y: png.height - 1 },
-        { x: png.width - 1, y: png.height - 1 }
-    ].map(({ x, y }) => y * png.width + x)
-        .filter((index) => alphaAt(png, index) >= OPAQUE_EDGE_ALPHA_THRESHOLD)
-        .map((index) => rgbAt(png, index));
-    if (corners.length < 3)
-        return undefined;
-    const cornerCluster = corners
-        .map((seed) => corners.filter((color) => (colorDistance(color, seed) <= COHERENT_EDGE_MATTE_TOLERANCE)))
-        .sort((left, right) => right.length - left.length)[0];
-    if (!cornerCluster || cornerCluster.length < 3)
-        return undefined;
-    const cornerColor = averageColors(cornerCluster);
-    const matchingEdgeColors = [];
-    const edgeStats = sampleImageEdges(png, (index) => {
-        if (alphaAt(png, index) < OPAQUE_EDGE_ALPHA_THRESHOLD)
-            return false;
-        const color = rgbAt(png, index);
-        const matches = colorDistance(color, cornerColor) <= COHERENT_EDGE_MATTE_TOLERANCE;
-        if (matches)
-            matchingEdgeColors.push(color);
-        return matches;
-    });
-    if (matchingEdgeColors.length === 0 ||
-        edgeStats.matches / edgeStats.total < COHERENT_EDGE_MATTE_MIN_COVERAGE) {
-        return undefined;
-    }
-    const matteColor = averageColors(matchingEdgeColors);
-    const refinedStats = sampleImageEdges(png, (index) => (alphaAt(png, index) >= OPAQUE_EDGE_ALPHA_THRESHOLD &&
-        colorDistance(rgbAt(png, index), matteColor) <= COHERENT_EDGE_MATTE_TOLERANCE));
-    return refinedStats.matches / refinedStats.total >= COHERENT_EDGE_MATTE_MIN_COVERAGE
-        ? matteColor
-        : undefined;
-}
-function averageColors(colors) {
-    return {
-        red: Math.round(colors.reduce((sum, color) => sum + color.red, 0) / colors.length),
-        green: Math.round(colors.reduce((sum, color) => sum + color.green, 0) / colors.length),
-        blue: Math.round(colors.reduce((sum, color) => sum + color.blue, 0) / colors.length)
-    };
-}
 export function resizePngToDimensions(image, dimensions) {
     const source = PNG.sync.read(Buffer.from(image));
     if (source.width === dimensions.width && source.height === dimensions.height) {
@@ -541,6 +197,42 @@ export function resizePngToDimensions(image, dimensions) {
     }
     return PNG.sync.write(target);
 }
+export async function composeSpriteSheetFrames(frameImages, dimensions, frameGrid) {
+    const margin = frameGrid.margin ?? 0;
+    const spacing = frameGrid.spacing ?? 0;
+    const frameCount = Math.min(frameGrid.frameCount ?? frameGrid.columns * frameGrid.rows, frameGrid.columns * frameGrid.rows);
+    if (frameImages.length !== frameCount) {
+        throw new Error(`Expected ${frameCount} generated sprite frames, received ${frameImages.length}.`);
+    }
+    const normalizedFrames = await Promise.all(frameImages.map((image) => (sharp(Buffer.from(image), { failOn: "error" })
+        .resize(frameGrid.frameWidth, frameGrid.frameHeight, {
+        fit: "fill",
+        kernel: sharp.kernel.nearest
+    })
+        .png()
+        .toBuffer())));
+    const composites = normalizedFrames.map((input, index) => {
+        const column = index % frameGrid.columns;
+        const row = Math.floor(index / frameGrid.columns);
+        const left = margin + column * (frameGrid.frameWidth + spacing);
+        const top = margin + row * (frameGrid.frameHeight + spacing);
+        if (left < 0 ||
+            top < 0 ||
+            left + frameGrid.frameWidth > dimensions.width ||
+            top + frameGrid.frameHeight > dimensions.height) {
+            throw new Error(`Sprite frame ${index + 1} lies outside the ${dimensions.width}x${dimensions.height} sheet.`);
+        }
+        return { input, left, top };
+    });
+    return sharp({
+        create: {
+            width: dimensions.width,
+            height: dimensions.height,
+            channels: 4,
+            background: { r: 0, g: 0, b: 0, alpha: 0 }
+        }
+    }).composite(composites).png().toBuffer();
+}
 export async function resizeRasterToDimensions(image, dimensions, outputFormat) {
     const sourceImage = Buffer.from(image);
     const metadata = await sharp(sourceImage, {
@@ -557,6 +249,8 @@ export async function resizeRasterToDimensions(image, dimensions, outputFormat)
         fit: "fill",
         kernel: sharp.kernel.nearest
     });
+    if (outputFormat === "png")
+        return resized.png().toBuffer();
     return outputFormat === "webp"
         ? resized.webp({ quality: 100 }).toBuffer()
         : resized.jpeg({ quality: 95 }).toBuffer();
@@ -708,143 +402,4 @@ function copyShiftedPngRect(png, source, options) {
         }
     }
 }
-export function featherBackgroundEdges(png, transparent, backgroundRemoval) {
-    const width = png.width;
-    const height = png.height;
-    for (let y = 0; y < height; y += 1) {
-        for (let x = 0; x < width; x += 1) {
-            const index = y * width + x;
-            if (transparent[index] || !touchesTransparentNeighbor(transparent, width, height, x, y)) {
-                continue;
-            }
-            const distance = backgroundDistance(png, index, backgroundRemoval);
-            if (distance > CHROMA_EDGE_TOLERANCE) {
-                continue;
-            }
-            const alpha = Math.max(0, Math.min(255, Math.round((distance / CHROMA_EDGE_TOLERANCE) * 255)));
-            setAlpha(png, index, Math.min(alphaAt(png, index), alpha));
-        }
-    }
-}
-export function touchesTransparentNeighbor(transparent, width, height, x, y) {
-    return ((x > 0 && transparent[y * width + x - 1] === 1) ||
-        (x < width - 1 && transparent[y * width + x + 1] === 1) ||
-        (y > 0 && transparent[(y - 1) * width + x] === 1) ||
-        (y < height - 1 && transparent[(y + 1) * width + x] === 1));
-}
-export function isChromaPixel(png, index, tolerance, chromaKey) {
-    return chromaDistance(png, index, chromaKey) <= tolerance;
-}
-export function isRemovableEdgeBackgroundPixel(png, index, backgroundRemoval) {
-    if (backgroundRemoval.kind === "chroma") {
-        return (isChromaPixel(png, index, CHROMA_EDGE_FILL_TOLERANCE, backgroundRemoval.chromaKey) ||
-            isKeyTintedPixel(rgbAt(png, index), backgroundRemoval.chromaKey, 0.86));
-    }
-    if (backgroundRemoval.kind === "coherent-edge-matte") {
-        return colorDistance(rgbAt(png, index), backgroundRemoval.matteColor) <=
-            COHERENT_EDGE_MATTE_TOLERANCE;
-    }
-    return isNeutralMattePixel(rgbAt(png, index), backgroundRemoval.matteColor);
-}
-export function isHighConfidenceChromaPixel(png, index, chromaKey) {
-    return (isChromaPixel(png, index, STRICT_CHROMA_MATCH_TOLERANCE, chromaKey) ||
-        isKeyTintedPixel(rgbAt(png, index), chromaKey, 0.86));
-}
-export function isKeyTintedPixel(color, chromaKey, strength) {
-    const keyChannels = [
-        { color: color.red, key: chromaKey.red },
-        { color: color.green, key: chromaKey.green },
-        { color: color.blue, key: chromaKey.blue }
-    ];
-    const activeChannels = keyChannels.filter((channel) => channel.key > 128);
-    const inactiveChannels = keyChannels.filter((channel) => channel.key <= 128);
-    return (activeChannels.every((channel) => channel.color >= 150 * strength) &&
-        inactiveChannels.every((channel) => channel.color <= 190 * (1.1 - strength)));
-}
-export function promptMentionsChromaFamily(prompt, chromaKey) {
-    if (chromaKey.red === 255 && chromaKey.green === 0 && chromaKey.blue === 255) {
-        return /\b(red|pink|purple|magenta|violet|crimson|fuchsia)\b/.test(prompt);
-    }
-    if (chromaKey.red === 0 && chromaKey.green === 255 && chromaKey.blue === 0) {
-        return /\b(green|lime|emerald|neon green|chartreuse)\b/.test(prompt);
-    }
-    if (chromaKey.red === 0 && chromaKey.green === 255 && chromaKey.blue === 255) {
-        return /\b(cyan|aqua|teal|turquoise|blue)\b/.test(prompt);
-    }
-    if (chromaKey.red === 255 && chromaKey.green === 255 && chromaKey.blue === 0) {
-        return /\b(yellow|gold|golden|amber)\b/.test(prompt);
-    }
-    if (chromaKey.red === 0 && chromaKey.green === 0 && chromaKey.blue === 255) {
-        return /\b(blue|navy|cobalt|azure|indigo|cyan)\b/.test(prompt);
-    }
-    return false;
-}
-export function chromaDistance(png, index, chromaKey) {
-    return colorDistance(rgbAt(png, index), chromaKey);
-}
-export function backgroundDistance(png, index, backgroundRemoval) {
-    if (backgroundRemoval.kind === "chroma") {
-        return chromaDistance(png, index, backgroundRemoval.chromaKey);
-    }
-    return colorDistance(rgbAt(png, index), backgroundRemoval.matteColor);
-}
-export function isNeutralMattePixel(color, matteColor) {
-    const max = Math.max(color.red, color.green, color.blue);
-    const min = Math.min(color.red, color.green, color.blue);
-    const saturation = max === 0 ? 0 : (max - min) / max;
-    const luminance = relativeLuminance(color.red, color.green, color.blue);
-    const matteLuminance = relativeLuminance(matteColor.red, matteColor.green, matteColor.blue);
-    return (saturation <= 0.22 &&
-        luminance >= 80 &&
-        Math.abs(luminance - matteLuminance) <= 70 &&
-        colorDistance(color, matteColor) <= 92);
-}
-export function isNeutralMatteCandidate(color) {
-    const max = Math.max(color.red, color.green, color.blue);
-    const min = Math.min(color.red, color.green, color.blue);
-    const saturation = max === 0 ? 0 : (max - min) / max;
-    const luminance = relativeLuminance(color.red, color.green, color.blue);
-    return saturation <= 0.22 && luminance >= 75;
-}
-export function neutralCornerCount(png) {
-    return [
-        { x: 0, y: 0 },
-        { x: png.width - 1, y: 0 },
-        { x: 0, y: png.height - 1 },
-        { x: png.width - 1, y: png.height - 1 }
-    ].filter(({ x, y }) => isNeutralMatteCandidate(rgbAt(png, y * png.width + x))).length;
-}
-export function sampleImageEdges(png, predicate) {
-    let total = 0;
-    let matches = 0;
-    const sample = (x, y) => {
-        total += 1;
-        if (predicate(y * png.width + x)) {
-            matches += 1;
-        }
-    };
-    for (let x = 0; x < png.width; x += 1) {
-        sample(x, 0);
-        sample(x, png.height - 1);
-    }
-    for (let y = 1; y < png.height - 1; y += 1) {
-        sample(0, y);
-        sample(png.width - 1, y);
-    }
-    return { total, matches };
-}
-export function rgbAt(png, index) {
-    const offset = index * 4;
-    return {
-        red: png.data[offset] ?? 0,
-        green: png.data[offset + 1] ?? 0,
-        blue: png.data[offset + 2] ?? 0
-    };
-}
-export function alphaAt(png, index) {
-    return png.data[index * 4 + 3] ?? 255;
-}
-export function setAlpha(png, index, alpha) {
-    png.data[index * 4 + 3] = alpha;
-}
 //# sourceMappingURL=provider-image-processing.js.map