@holoviz/panel 0.14.4 → 1.0.0-a.2

package/dist/bundled/js/@microsoft/fast-colors@5.3.1/dist/color-interpolation.js

@@ -1,133 +0,0 @@
-import { hslToRGB, hsvToRGB, labToRGB, lchToRGB, rgbToHSL, rgbToHSV, rgbToLAB, rgbToLCH, rgbToXYZ, xyzToRGB, } from "./color-converters.js";
-import { ColorHSL } from "./color-hsl.js";
-import { ColorHSV } from "./color-hsv.js";
-import { ColorLAB } from "./color-lab.js";
-import { ColorLCH } from "./color-lch.js";
-import { ColorRGBA64 } from "./color-rgba-64.js";
-import { ColorXYZ } from "./color-xyz.js";
-import { lerp, lerpAnglesInDegrees } from "./math-utilities.js";
-/**
- * Interpolate by RGB color space
- *
- * @public
- */
-export function interpolateRGB(position, left, right) {
-    if (isNaN(position) || position <= 0) {
-        return left;
-    }
-    else if (position >= 1) {
-        return right;
-    }
-    return new ColorRGBA64(lerp(position, left.r, right.r), lerp(position, left.g, right.g), lerp(position, left.b, right.b), lerp(position, left.a, right.a));
-}
-/**
- * Interpolate by HSL color space
- *
- * @public
- */
-export function interpolateHSL(position, left, right) {
-    if (isNaN(position) || position <= 0) {
-        return left;
-    }
-    else if (position >= 1) {
-        return right;
-    }
-    return new ColorHSL(lerpAnglesInDegrees(position, left.h, right.h), lerp(position, left.s, right.s), lerp(position, left.l, right.l));
-}
-/**
- * Interpolate by HSV color space
- *
- * @public
- */
-export function interpolateHSV(position, left, right) {
-    if (isNaN(position) || position <= 0) {
-        return left;
-    }
-    else if (position >= 1) {
-        return right;
-    }
-    return new ColorHSV(lerpAnglesInDegrees(position, left.h, right.h), lerp(position, left.s, right.s), lerp(position, left.v, right.v));
-}
-/**
- * Interpolate by XYZ color space
- *
- * @public
- */
-export function interpolateXYZ(position, left, right) {
-    if (isNaN(position) || position <= 0) {
-        return left;
-    }
-    else if (position >= 1) {
-        return right;
-    }
-    return new ColorXYZ(lerp(position, left.x, right.x), lerp(position, left.y, right.y), lerp(position, left.z, right.z));
-}
-/**
- * Interpolate by LAB color space
- *
- * @public
- */
-export function interpolateLAB(position, left, right) {
-    if (isNaN(position) || position <= 0) {
-        return left;
-    }
-    else if (position >= 1) {
-        return right;
-    }
-    return new ColorLAB(lerp(position, left.l, right.l), lerp(position, left.a, right.a), lerp(position, left.b, right.b));
-}
-/**
- * Interpolate by LCH color space
- *
- * @public
- */
-export function interpolateLCH(position, left, right) {
-    if (isNaN(position) || position <= 0) {
-        return left;
-    }
-    else if (position >= 1) {
-        return right;
-    }
-    return new ColorLCH(lerp(position, left.l, right.l), lerp(position, left.c, right.c), lerpAnglesInDegrees(position, left.h, right.h));
-}
-/**
- * Color interpolation spaces
- *
- * @public
- */
-export var ColorInterpolationSpace;
-(function (ColorInterpolationSpace) {
-    ColorInterpolationSpace[ColorInterpolationSpace["RGB"] = 0] = "RGB";
-    ColorInterpolationSpace[ColorInterpolationSpace["HSL"] = 1] = "HSL";
-    ColorInterpolationSpace[ColorInterpolationSpace["HSV"] = 2] = "HSV";
-    ColorInterpolationSpace[ColorInterpolationSpace["XYZ"] = 3] = "XYZ";
-    ColorInterpolationSpace[ColorInterpolationSpace["LAB"] = 4] = "LAB";
-    ColorInterpolationSpace[ColorInterpolationSpace["LCH"] = 5] = "LCH";
-})(ColorInterpolationSpace || (ColorInterpolationSpace = {}));
-/**
- * Interpolate by color space
- *
- * @public
- */
-export function interpolateByColorSpace(position, space, left, right) {
-    if (isNaN(position) || position <= 0) {
-        return left;
-    }
-    else if (position >= 1) {
-        return right;
-    }
-    switch (space) {
-        case ColorInterpolationSpace.HSL:
-            return hslToRGB(interpolateHSL(position, rgbToHSL(left), rgbToHSL(right)));
-        case ColorInterpolationSpace.HSV:
-            return hsvToRGB(interpolateHSV(position, rgbToHSV(left), rgbToHSV(right)));
-        case ColorInterpolationSpace.XYZ:
-            return xyzToRGB(interpolateXYZ(position, rgbToXYZ(left), rgbToXYZ(right)));
-        case ColorInterpolationSpace.LAB:
-            return labToRGB(interpolateLAB(position, rgbToLAB(left), rgbToLAB(right)));
-        case ColorInterpolationSpace.LCH:
-            return lchToRGB(interpolateLCH(position, rgbToLCH(left), rgbToLCH(right)));
-        default:
-            return interpolateRGB(position, left, right);
-    }
-}

package/dist/bundled/js/@microsoft/fast-colors@5.3.1/dist/color-lab.js

@@ -1,47 +0,0 @@
-import { roundToPrecisionSmall } from "./math-utilities.js";
-/**
- * {@link https://en.wikipedia.org/wiki/CIELAB_color_space | CIELAB color space}
- * This implementation uses the D65 constants for 2 degrees. That determines the constants used for the pure white point of the XYZ space of 0.95047, 1.0, 1.08883.
- * {@link https://en.wikipedia.org/wiki/Illuminant_D65}
- * These constants determine how the XYZ, LCH and LAB colors convert to/from RGB.
- *
- * @public
- */
-export class ColorLAB {
-    constructor(l, a, b) {
-        this.l = l;
-        this.a = a;
-        this.b = b;
-    }
-    /**
-     * Construct a {@link ColorLAB} from a config object.
-     */
-    static fromObject(data) {
-        if (data && !isNaN(data.l) && !isNaN(data.a) && !isNaN(data.b)) {
-            return new ColorLAB(data.l, data.a, data.b);
-        }
-        return null;
-    }
-    /**
-     * Determines if a color is equal to another
-     * @param rhs - the value to compare
-     */
-    equalValue(rhs) {
-        return this.l === rhs.l && this.a === rhs.a && this.b === rhs.b;
-    }
-    /**
-     * Returns a new {@link ColorLAB} rounded to the provided precision
-     * @param precision - the precision to round to
-     */
-    roundToPrecision(precision) {
-        return new ColorLAB(roundToPrecisionSmall(this.l, precision), roundToPrecisionSmall(this.a, precision), roundToPrecisionSmall(this.b, precision));
-    }
-    /**
-     * Returns the {@link ColorLAB} formatted as an object.
-     */
-    toObject() {
-        return { l: this.l, a: this.a, b: this.b };
-    }
-}
-ColorLAB.epsilon = 216 / 24389;
-ColorLAB.kappa = 24389 / 27;

package/dist/bundled/js/@microsoft/fast-colors@5.3.1/dist/color-lch.js

@@ -1,50 +0,0 @@
-import { roundToPrecisionSmall } from "./math-utilities.js";
-/**
- *
- * {@link https://en.wikipedia.org/wiki/CIELAB_color_space | CIELCH color space}
- *
- * This is a cylindrical representation of the CIELAB space useful for saturation operations
- * This uses Hue values in "degree" format. So expect a range of [0,360]. Some other implementations instead uses radians or a normalized Hue with range [0,1]. Be aware of this when checking values or using other libraries.
- * This implementation uses the D65 constants for 2 degrees. That determines the constants used for the pure white point of the XYZ space of 0.95047, 1.0, 1.08883.
- * {@link https://en.wikipedia.org/wiki/Illuminant_D65}
- * These constants determine how the XYZ, LCH and LAB colors convert to/from RGB.
- *
- * @public
- */
-export class ColorLCH {
-    constructor(l, c, h) {
-        this.l = l;
-        this.c = c;
-        this.h = h;
-    }
-    /**
-     * Construct a {@link ColorLCH} from a config object.
-     * @param data - the config object
-     */
-    static fromObject(data) {
-        if (data && !isNaN(data.l) && !isNaN(data.c) && !isNaN(data.h)) {
-            return new ColorLCH(data.l, data.c, data.h);
-        }
-        return null;
-    }
-    /**
-     * Determines if one color is equal to another.
-     * @param rhs - the color to compare
-     */
-    equalValue(rhs) {
-        return this.l === rhs.l && this.c === rhs.c && this.h === rhs.h;
-    }
-    /**
-     * Returns a new {@link ColorLCH} rounded to the provided precision
-     * @param precision - the precision to round to
-     */
-    roundToPrecision(precision) {
-        return new ColorLCH(roundToPrecisionSmall(this.l, precision), roundToPrecisionSmall(this.c, precision), roundToPrecisionSmall(this.h, precision));
-    }
-    /**
-     * Converts the {@link ColorLCH} to a config object.
-     */
-    toObject() {
-        return { l: this.l, c: this.c, h: this.h };
-    }
-}

package/dist/bundled/js/@microsoft/fast-colors@5.3.1/dist/color-palette.js

@@ -1,285 +0,0 @@
-import { blendMultiply, blendOverlay, saturateViaLCH } from "./color-blending.js";
-import { rgbToHSL } from "./color-converters.js";
-import { ColorInterpolationSpace, interpolateByColorSpace, } from "./color-interpolation.js";
-import { ColorRGBA64 } from "./color-rgba-64.js";
-import { ColorScale } from "./color-scale.js";
-import { parseColorHexRGB } from "./parse-color.js";
-/**
- * Generates a color palette
- * @public
- */
-export class ColorPalette {
-    constructor(config) {
-        this.config = Object.assign({}, ColorPalette.defaultPaletteConfig, config);
-        this.palette = [];
-        this.updatePaletteColors();
-    }
-    updatePaletteGenerationValues(newConfig) {
-        let changed = false;
-        for (const key in newConfig) {
-            if (this.config[key]) {
-                if (this.config[key].equalValue) {
-                    if (!this.config[key].equalValue(newConfig[key])) {
-                        this.config[key] = newConfig[key];
-                        changed = true;
-                    }
-                }
-                else {
-                    if (newConfig[key] !== this.config[key]) {
-                        this.config[key] = newConfig[key];
-                        changed = true;
-                    }
-                }
-            }
-        }
-        if (changed) {
-            this.updatePaletteColors();
-        }
-        return changed;
-    }
-    updatePaletteColors() {
-        const scale = this.generatePaletteColorScale();
-        for (let i = 0; i < this.config.steps; i++) {
-            this.palette[i] = scale.getColor(i / (this.config.steps - 1), this.config.interpolationMode);
-        }
-    }
-    generatePaletteColorScale() {
-        // Even when config.baseScalePosition is specified, using 0.5 for the baseColor
-        // in the baseScale gives better results. Otherwise very off-center palettes
-        // tend to go completely grey at the end furthest from the specified base color.
-        const baseColorHSL = rgbToHSL(this.config.baseColor);
-        const baseScale = new ColorScale([
-            { position: 0, color: this.config.scaleColorLight },
-            { position: 0.5, color: this.config.baseColor },
-            { position: 1, color: this.config.scaleColorDark },
-        ]);
-        const trimmedScale = baseScale.trim(this.config.clipLight, 1 - this.config.clipDark);
-        const trimmedLight = trimmedScale.getColor(0);
-        const trimmedDark = trimmedScale.getColor(1);
-        let adjustedLight = trimmedLight;
-        let adjustedDark = trimmedDark;
-        if (baseColorHSL.s >= this.config.saturationAdjustmentCutoff) {
-            adjustedLight = saturateViaLCH(adjustedLight, this.config.saturationLight);
-            adjustedDark = saturateViaLCH(adjustedDark, this.config.saturationDark);
-        }
-        if (this.config.multiplyLight !== 0) {
-            const multiply = blendMultiply(this.config.baseColor, adjustedLight);
-            adjustedLight = interpolateByColorSpace(this.config.multiplyLight, this.config.interpolationMode, adjustedLight, multiply);
-        }
-        if (this.config.multiplyDark !== 0) {
-            const multiply = blendMultiply(this.config.baseColor, adjustedDark);
-            adjustedDark = interpolateByColorSpace(this.config.multiplyDark, this.config.interpolationMode, adjustedDark, multiply);
-        }
-        if (this.config.overlayLight !== 0) {
-            const overlay = blendOverlay(this.config.baseColor, adjustedLight);
-            adjustedLight = interpolateByColorSpace(this.config.overlayLight, this.config.interpolationMode, adjustedLight, overlay);
-        }
-        if (this.config.overlayDark !== 0) {
-            const overlay = blendOverlay(this.config.baseColor, adjustedDark);
-            adjustedDark = interpolateByColorSpace(this.config.overlayDark, this.config.interpolationMode, adjustedDark, overlay);
-        }
-        if (this.config.baseScalePosition) {
-            if (this.config.baseScalePosition <= 0) {
-                return new ColorScale([
-                    { position: 0, color: this.config.baseColor },
-                    { position: 1, color: adjustedDark.clamp() },
-                ]);
-            }
-            else if (this.config.baseScalePosition >= 1) {
-                return new ColorScale([
-                    { position: 0, color: adjustedLight.clamp() },
-                    { position: 1, color: this.config.baseColor },
-                ]);
-            }
-            return new ColorScale([
-                { position: 0, color: adjustedLight.clamp() },
-                {
-                    position: this.config.baseScalePosition,
-                    color: this.config.baseColor,
-                },
-                { position: 1, color: adjustedDark.clamp() },
-            ]);
-        }
-        return new ColorScale([
-            { position: 0, color: adjustedLight.clamp() },
-            { position: 0.5, color: this.config.baseColor },
-            { position: 1, color: adjustedDark.clamp() },
-        ]);
-    }
-}
-ColorPalette.defaultPaletteConfig = {
-    baseColor: parseColorHexRGB("#808080"),
-    steps: 11,
-    interpolationMode: ColorInterpolationSpace.RGB,
-    scaleColorLight: new ColorRGBA64(1, 1, 1, 1),
-    scaleColorDark: new ColorRGBA64(0, 0, 0, 1),
-    clipLight: 0.185,
-    clipDark: 0.16,
-    saturationAdjustmentCutoff: 0.05,
-    saturationLight: 0.35,
-    saturationDark: 1.25,
-    overlayLight: 0,
-    overlayDark: 0.25,
-    multiplyLight: 0,
-    multiplyDark: 0,
-    baseScalePosition: 0.5,
-};
-ColorPalette.greyscalePaletteConfig = {
-    baseColor: parseColorHexRGB("#808080"),
-    steps: 11,
-    interpolationMode: ColorInterpolationSpace.RGB,
-    scaleColorLight: new ColorRGBA64(1, 1, 1, 1),
-    scaleColorDark: new ColorRGBA64(0, 0, 0, 1),
-    clipLight: 0,
-    clipDark: 0,
-    saturationAdjustmentCutoff: 0,
-    saturationLight: 0,
-    saturationDark: 0,
-    overlayLight: 0,
-    overlayDark: 0,
-    multiplyLight: 0,
-    multiplyDark: 0,
-    baseScalePosition: 0.5,
-};
-/**
- * Takes the input color and compares it to each color in the reference array to find the index with the closest Lightness value in HSL color space
- * @public
- */
-export function matchLightnessIndex(input, reference) {
-    const hsl = rgbToHSL(input);
-    let bestFitValue = Number.MAX_VALUE;
-    let bestFitIndex = 0;
-    for (let i = 0; i < reference.length; i++) {
-        const ihsl = rgbToHSL(reference[i]);
-        const fitValue = Math.abs(ihsl.l - hsl.l);
-        if (fitValue < bestFitValue) {
-            bestFitValue = fitValue;
-            bestFitIndex = i;
-        }
-    }
-    return bestFitIndex;
-}
-/**
- * Generates a greyscale palette using greyscaleConfig. The Lightness (in HSL) of the input color is then compared to the greyscale palette to determine how far off center the input color should be placed. The output palette is then generated with outputSteps number of steps using colorConfig.
- * @public
- */
-export function generateOffCenterPalette(input, outputSteps, greyscaleConfig = ColorPalette.greyscalePaletteConfig, colorConfig = ColorPalette.defaultPaletteConfig) {
-    const greyscale = new ColorPalette(Object.assign(Object.assign({}, greyscaleConfig), { steps: outputSteps }));
-    const scaleIndex = matchLightnessIndex(input, greyscale.palette);
-    return new ColorPalette(Object.assign(Object.assign({}, colorConfig), { steps: outputSteps, baseColor: input, baseScalePosition: scaleIndex / (outputSteps - 1) }));
-}
-/**
- * Take the input array of colors and extrapolates them to a larger palette of size targetSize. If preserveInputColors is false the input colors are evenly distributed into the output. Otherwise, the positions of the input colors are adjusted from a perfectly even distribution in order to ensure that the exact color values appearing in the input array also appear in the output array. The larger targetSize is compared to input.length the smaller those adjustments will be.
- *
- * @public
- */
-export function rescale(input, targetSize, preserveInputColors) {
-    if (input.length <= 1 || targetSize <= 1) {
-        throw new Error("The input array and targetSize must both be greater than 1");
-    }
-    if (preserveInputColors && targetSize <= input.length) {
-        throw new Error("If preserveInputColors is true then targetSize must be greater than the length of the input array");
-    }
-    const stops = new Array(input.length);
-    if (preserveInputColors) {
-        for (let i = 0; i < input.length; i++) {
-            const p = i / (input.length - 1);
-            let bestFitValue = 2;
-            let bestFitIndex = 0;
-            for (let j = 0; j < targetSize; j++) {
-                const fitValue = Math.abs(j / (targetSize - 1) - p);
-                if (fitValue < bestFitValue) {
-                    bestFitValue = fitValue;
-                    bestFitIndex = j;
-                }
-                if (fitValue === 0) {
-                    break;
-                }
-            }
-            stops[i] = {
-                color: input[i],
-                position: bestFitIndex / (targetSize - 1),
-            };
-        }
-    }
-    else {
-        for (let i = 0; i < stops.length; i++) {
-            stops[i] = { color: input[i], position: i / (input.length - 1) };
-        }
-    }
-    const scale = new ColorScale(stops);
-    const retVal = new Array(targetSize);
-    for (let i = 0; i < targetSize; i++) {
-        retVal[i] = scale.getColor(i / (targetSize - 1));
-    }
-    return retVal;
-}
-/**
- * @public
- */
-export const defaultCenteredRescaleConfig = {
-    targetSize: 63,
-    spacing: 4,
-    scaleColorLight: ColorPalette.defaultPaletteConfig.scaleColorLight,
-    scaleColorDark: ColorPalette.defaultPaletteConfig.scaleColorDark,
-};
-/**
- * Takes an input array of colors and extrapolates them to a larger palette. The mapping first takes the input array and extrapolates between each color so that they are separated by spacing-1 slots. Then it adds to either end enough new colors to make up the desired targetSize. All output color slots between the defined stops are interpolated.
- * @example
- * For an input array with length 5, a targetSize of 17 and spacing of 3 the output would be:
- *  0: scaleColorLight
- *  1:
- *  2: input 0
- *  3:
- *  4:
- *  5: input 1
- *  6:
- *  7:
- *  8: input 2
- *  9:
- * 10:
- * 11: input 3
- * 12:
- * 13:
- * 14: input 4
- * 15:
- * 16: scaleColorDark
- *
- * @public
- */
-export function centeredRescale(input, config = defaultCenteredRescaleConfig) {
-    if (input.length === 0) {
-        return [];
-    }
-    const offset = Math.floor((config.targetSize - ((input.length - 1) * config.spacing + 1)) / 2);
-    if (offset < 0) {
-        throw new Error("(targetSize - ((input.length - 1) * spacing + 1)) / 2 must be >= 0");
-    }
-    const stops = new Array(input.length + 2);
-    stops[0] = { position: 0, color: config.scaleColorLight };
-    stops[stops.length - 1] = {
-        position: 1,
-        color: config.scaleColorDark,
-    };
-    for (let i = 0; i < input.length; i++) {
-        stops[i + 1] = {
-            color: input[i],
-            position: (i * config.spacing + offset) / (config.targetSize - 1),
-        };
-    }
-    const scale = new ColorScale(stops);
-    const retVal = new Array(config.targetSize);
-    for (let i = 0; i < config.targetSize; i++) {
-        retVal[i] = scale.getColor(i / (config.targetSize - 1));
-    }
-    return retVal;
-}
-/**
- * Generates two palettes of length shortPaletteLength and longPaletteLength from a base color. The base color is compared to the default greyscale palette to determine where it should be placed. The short palette is then fed into centeredRescale to create the long palette. The colors in the short palette are always contained within the long.
- * @public
- */
-export function generateScaledPalettes(input, shortPaletteLength = 11, config = defaultCenteredRescaleConfig) {
-    const shortPalette = generateOffCenterPalette(input, shortPaletteLength);
-    const longPalette = centeredRescale(shortPalette.palette, config);
-    return { short: shortPalette.palette, long: longPalette };
-}

package/dist/bundled/js/@microsoft/fast-colors@5.3.1/dist/color-quantization.js

@@ -1,135 +0,0 @@
-import { Histogram } from "./histogram.js";
-import { insertIntoSortedList, PixelBox } from "./pixel-box.js";
-function countValidBoxes(queue, isBoxValid) {
-    if (isBoxValid === null) {
-        return queue.length;
-    }
-    let retVal = 0;
-    for (let i = 0; i < queue.length; i++) {
-        if (isBoxValid(queue[i])) {
-            retVal++;
-        }
-    }
-    return retVal;
-}
-/**
- * The default quantize configuration.
- * @public
- */
-export const defaultQuantizeConfig = {
-    significantBits: 5,
-    pixelSkipping: 5,
-    targetPaletteSize: 64,
-    fractionByPopulation: 0.85,
-    isBoxValid: (box) => {
-        if (box.pixelCount < 5) {
-            // Screen out outlier results that aren't present in the original image
-            return false;
-        }
-        return true;
-    },
-    isHistogramPixelValid: (pixel) => {
-        if (pixel[3] < 128) {
-            // Ignore pixels that are too transparent
-            return false;
-        }
-        return true;
-    },
-    maxIterations: 1000,
-};
-/**
- * The data in the color histogram is reduced down to a small set of colors.
- * It can be useful to create the Histogram manually in cases where one wants to remove or alter the colors in it
- * or to re-use it in order to quantize multiple times with different config settings.
- * Based on the Modified Median Cut Quantization implementation from https://github.com/DanBloomberg/leptonica/blob/master/src/colorquant2.c
- *
- * @public
- */
-export function quantizeHistogram(histogram, config = defaultQuantizeConfig) {
-    const initialBox = new PixelBox(histogram, histogram.minRed, histogram.maxRed, histogram.minGreen, histogram.maxGreen, histogram.minBlue, histogram.maxBlue);
-    const queue = [initialBox];
-    let count = countValidBoxes(queue, config.isBoxValid);
-    // For a final palette of size targetPaletteSize, we determine the first fractionByPopulation*targetPaletteSize
-    // using population as the only factor when determening sort order. For the rest of the colors the
-    // sort order is population * colorVolume. This helps highly contrasting colors in a small area to show
-    // up in some of the final output.
-    const colorsByPopulation = Math.floor(config.targetPaletteSize * config.fractionByPopulation);
-    const popSort = (box) => {
-        return box.pixelCount;
-    };
-    let iterationCount = 0;
-    while (iterationCount <= config.maxIterations) {
-        if (queue.length > 0) {
-            const currentBox = queue.shift();
-            const cutBoxes = currentBox.modifiedMedianCut();
-            if (cutBoxes[0] !== null) {
-                insertIntoSortedList(queue, cutBoxes[0], popSort);
-            }
-            if (cutBoxes[1] !== null) {
-                insertIntoSortedList(queue, cutBoxes[1], popSort);
-            }
-        }
-        count = countValidBoxes(queue, config.isBoxValid);
-        if (count >= colorsByPopulation || queue.length <= 1) {
-            break;
-        }
-        iterationCount++;
-    }
-    if (count < config.targetPaletteSize) {
-        const popAndVolumeSort = (box) => {
-            return box.pixelCount * box.colorVolume;
-        };
-        queue.sort((a, b) => {
-            const aSort = popAndVolumeSort(a);
-            const bSort = popAndVolumeSort(b);
-            if (aSort === bSort) {
-                return 0;
-            }
-            else if (aSort > bSort) {
-                return -1;
-            }
-            return 1;
-        });
-        iterationCount = 0;
-        while (iterationCount <= config.maxIterations) {
-            if (queue.length > 0) {
-                const currentBox = queue.shift();
-                const cutBoxes = currentBox.modifiedMedianCut();
-                if (cutBoxes[0] !== null) {
-                    insertIntoSortedList(queue, cutBoxes[0], popAndVolumeSort);
-                }
-                if (cutBoxes[1] !== null) {
-                    insertIntoSortedList(queue, cutBoxes[1], popAndVolumeSort);
-                }
-            }
-            count = countValidBoxes(queue, config.isBoxValid);
-            if (count >= config.targetPaletteSize || queue.length <= 1) {
-                break;
-            }
-            iterationCount++;
-        }
-    }
-    const retVal = new Array(count);
-    let index = 0;
-    for (let i = 0; i < queue.length; i++) {
-        if (!config.isBoxValid || config.isBoxValid(queue[i])) {
-            retVal[index] = {
-                color: queue[i].averageColor,
-                pixelCount: queue[i].pixelCount,
-                colorVolume: queue[i].colorVolume,
-            };
-            index++;
-        }
-    }
-    return retVal;
-}
-/**
- * The image stored in the source PixelBlob is reduced down to a small set of colors.
- * Based on the Modified Median Cut Quantization implementation from https://github.com/DanBloomberg/leptonica/blob/master/src/colorquant2.c
- *
- * @public
- */
-export function quantize(source, config = defaultQuantizeConfig) {
-    const histogram = new Histogram(source, config.significantBits, config.pixelSkipping, config.isHistogramPixelValid);
-    return quantizeHistogram(histogram, config);
-}