@holoviz/panel 0.14.4 → 1.0.0-a.2

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

@@ -1,134 +0,0 @@
-import { rgbToHSL } from "./color-converters.js";
-/**
- * The default configuration for palette extraction.
- * @public
- */
-export const defaultPaletteExtractionConfig = {
-    saturationWeight: 6,
-    luminosityWeight: 3,
-    populationWeight: 1,
-    volumeWeight: 0.1,
-    constraints: [
-        {
-            id: "Vibrant",
-            targetSaturation: 1,
-            minSaturation: 0.35,
-            maxSaturation: 1,
-            targetLuminosity: 0.5,
-            minLuminosity: 0.3,
-            maxLuminosity: 0.7,
-        },
-        {
-            id: "LightVibrant",
-            targetSaturation: 1,
-            minSaturation: 0.35,
-            maxSaturation: 1,
-            targetLuminosity: 0.74,
-            minLuminosity: 0.55,
-            maxLuminosity: 1,
-        },
-        {
-            id: "DarkVibrant",
-            targetSaturation: 1,
-            minSaturation: 0.35,
-            maxSaturation: 1,
-            targetLuminosity: 0.26,
-            minLuminosity: 0,
-            maxLuminosity: 0.45,
-        },
-        {
-            id: "Muted",
-            targetSaturation: 0.3,
-            minSaturation: 0,
-            maxSaturation: 0.4,
-            targetLuminosity: 0.5,
-            minLuminosity: 0.3,
-            maxLuminosity: 0.7,
-        },
-        {
-            id: "LightMuted",
-            targetSaturation: 0.3,
-            minSaturation: 0,
-            maxSaturation: 0.4,
-            targetLuminosity: 0.74,
-            minLuminosity: 0.55,
-            maxLuminosity: 1,
-        },
-        {
-            id: "DarkMuted",
-            targetSaturation: 0.3,
-            minSaturation: 0,
-            maxSaturation: 0.4,
-            targetLuminosity: 0.26,
-            minLuminosity: 0,
-            maxLuminosity: 0.45,
-        },
-    ],
-};
-/**
- * Extracts a palette.
- * @param colors - the quantized colors
- * @param config - the extraction config
- * @public
- */
-export function extractPalette(colors, config = defaultPaletteExtractionConfig) {
-    if (config.constraints.length === 0) {
-        return [];
-    }
-    let totalPixelCount = 0;
-    let totalVolume = 0;
-    for (let i = 0; i < colors.length; i++) {
-        totalPixelCount += colors[i].pixelCount;
-        totalVolume += colors[i].colorVolume;
-    }
-    const retVal = new Array(config.constraints.length);
-    const bestFitValues = new Array(config.constraints.length);
-    for (let i = 0; i < retVal.length; i++) {
-        bestFitValues[i] = 0;
-        retVal[i] = {
-            found: false,
-            constraint: config.constraints[i],
-        };
-    }
-    const totalWeight = config.saturationWeight +
-        config.luminosityWeight +
-        config.populationWeight +
-        config.volumeWeight;
-    for (let i = 0; i < colors.length; i++) {
-        const hsl = rgbToHSL(colors[i].color);
-        for (let j = 0; j < config.constraints.length; j++) {
-            // Check for min and max saturation / luminosity
-            if (hsl.s >= config.constraints[j].minSaturation &&
-                hsl.s <= config.constraints[j].maxSaturation &&
-                hsl.l >= config.constraints[j].minLuminosity &&
-                hsl.l <= config.constraints[j].maxLuminosity) {
-                const populationFactor = colors[i].pixelCount / totalPixelCount;
-                const volumeFactor = colors[i].colorVolume / totalVolume;
-                const saturationFactor = 1 - Math.abs(hsl.s - config.constraints[j].targetSaturation);
-                const luminosityFactor = 1 - Math.abs(hsl.l - config.constraints[j].targetLuminosity);
-                const fitValue = (populationFactor * config.populationWeight +
-                    volumeFactor * config.volumeWeight +
-                    saturationFactor * config.saturationWeight +
-                    luminosityFactor * config.luminosityWeight) /
-                    totalWeight;
-                if (fitValue > bestFitValues[j]) {
-                    // Check if this color is already in use
-                    let dupe = false;
-                    for (let k = 0; k < j; k++) {
-                        if (retVal[k].found &&
-                            retVal[k].color.color.equalValue(colors[i].color)) {
-                            dupe = true;
-                            break;
-                        }
-                    }
-                    if (!dupe) {
-                        bestFitValues[j] = fitValue;
-                        retVal[j].found = true;
-                        retVal[j].color = colors[i];
-                    }
-                }
-            }
-        }
-    }
-    return retVal;
-}

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

@@ -1,219 +0,0 @@
-import { ColorRGBA64 } from "./color-rgba-64.js";
-import { normalize } from "./math-utilities.js";
-import { namedColorsConfigs } from "./named-colors.js";
-// Matches rgb(R, G, B) where R, G, and B are integers [0 - 255]
-const webRGBRegex = /^rgb\(\s*((?:(?:25[0-5]|2[0-4]\d|1\d\d|\d{1,2})\s*,\s*){2}(?:25[0-5]|2[0-4]\d|1\d\d|\d{1,2})\s*)\)$/i;
-// Matches rgb(R, G, B, A) where R, G, and B are integers [0 - 255] and A is [0-1] floating
-const webRGBARegex = /^rgba\(\s*((?:(?:25[0-5]|2[0-4]\d|1\d\d|\d{1,2})\s*,\s*){3}(?:0|1|0?\.\d*)\s*)\)$/i;
-// Matches #RGB and #RRGGBB, where R, G, and B are [0-9] or [A-F]
-const hexRGBRegex = /^#((?:[0-9a-f]{6}|[0-9a-f]{3}))$/i;
-// Matches #RGB and #RRGGBBAA, where R, G, B, and A are [0-9] or [A-F]
-const hexRGBARegex = /^#((?:[0-9a-f]{8}|[0-9a-f]{4}))$/i;
-/**
- * Test if a color matches #RRGGBB or #RGB
- * @public
- */
-export function isColorStringHexRGB(raw) {
-    return hexRGBRegex.test(raw);
-}
-/**
- * Test if a color matches #AARRGGBB or #ARGB
- * @public
- */
-export function isColorStringHexARGB(raw) {
-    return hexRGBARegex.test(raw);
-}
-/**
- * Test if a color matches #RRGGBBAA or #RGBA
- * @public
- */
-export function isColorStringHexRGBA(raw) {
-    return isColorStringHexARGB(raw); // No way to differentiate these two formats, so just use the same test
-}
-/**
- * Test if a color matches rgb(rr, gg, bb)
- * @public
- */
-export function isColorStringWebRGB(raw) {
-    return webRGBRegex.test(raw);
-}
-/**
- * Test if a color matches rgba(rr, gg, bb, aa)
- *
- * @public
- */
-export function isColorStringWebRGBA(raw) {
-    return webRGBARegex.test(raw);
-}
-/**
- * Tests whether a color is in {@link @microsoft/fast-colors#NamedColors}.
- * @param raw - the color name to test
- * @public
- */
-export function isColorNamed(raw) {
-    return namedColorsConfigs.hasOwnProperty(raw);
-}
-/**
- * Converts a hexadecimal color string to a {@link @microsoft/fast-colors#ColorRGBA64}.
- * @param raw - a color string in the form of "#RRGGBB" or "#RGB"
- * @example
- * ```ts
- * parseColorHexRGBA("#FF0000");
- * parseColorHexRGBA("#F00");
- * ```
- * @public
- */
-export function parseColorHexRGB(raw) {
-    const result = hexRGBRegex.exec(raw);
-    if (result === null) {
-        return null;
-    }
-    let digits = result[1];
-    if (digits.length === 3) {
-        const r = digits.charAt(0);
-        const g = digits.charAt(1);
-        const b = digits.charAt(2);
-        digits = r.concat(r, g, g, b, b);
-    }
-    const rawInt = parseInt(digits, 16);
-    if (isNaN(rawInt)) {
-        return null;
-    }
-    // Note the use of >>> rather than >> as we want JS to manipulate these as unsigned numbers
-    return new ColorRGBA64(normalize((rawInt & 0xff0000) >>> 16, 0, 255), normalize((rawInt & 0x00ff00) >>> 8, 0, 255), normalize(rawInt & 0x0000ff, 0, 255), 1);
-}
-/**
- * Converts a hexadecimal color string to a {@link @microsoft/fast-colors#ColorRGBA64}.
- * @param raw - a color string in the form of "#AARRGGBB" or "#ARGB"
- * @example
- * ```ts
- * parseColorHexRGBA("#AAFF0000");
- * parseColorHexRGBA("#AF00");
- * ```
- * @public
- */
-export function parseColorHexARGB(raw) {
-    const result = hexRGBARegex.exec(raw);
-    if (result === null) {
-        return null;
-    }
-    let digits = result[1];
-    if (digits.length === 4) {
-        const a = digits.charAt(0);
-        const r = digits.charAt(1);
-        const g = digits.charAt(2);
-        const b = digits.charAt(3);
-        digits = a.concat(a, r, r, g, g, b, b);
-    }
-    const rawInt = parseInt(digits, 16);
-    if (isNaN(rawInt)) {
-        return null;
-    }
-    // Note the use of >>> rather than >> as we want JS to manipulate these as unsigned numbers
-    return new ColorRGBA64(normalize((rawInt & 0x00ff0000) >>> 16, 0, 255), normalize((rawInt & 0x0000ff00) >>> 8, 0, 255), normalize(rawInt & 0x000000ff, 0, 255), normalize((rawInt & 0xff000000) >>> 24, 0, 255));
-}
-/**
- * Converts a hexadecimal color string to a {@link @microsoft/fast-colors#ColorRGBA64}.
- * @param raw - a color string in the form of "#RRGGBBAA" or "#RGBA"
- * @example
- * ```ts
- * parseColorHexRGBA("#FF0000AA");
- * parseColorHexRGBA("#F00A");
- * ```
- * @public
- */
-export function parseColorHexRGBA(raw) {
-    const result = hexRGBARegex.exec(raw);
-    if (result === null) {
-        return null;
-    }
-    let digits = result[1];
-    if (digits.length === 4) {
-        const r = digits.charAt(0);
-        const g = digits.charAt(1);
-        const b = digits.charAt(2);
-        const a = digits.charAt(3);
-        digits = r.concat(r, g, g, b, b, a, a);
-    }
-    const rawInt = parseInt(digits, 16);
-    if (isNaN(rawInt)) {
-        return null;
-    }
-    // Note the use of >>> rather than >> as we want JS to manipulate these as unsigned numbers
-    return new ColorRGBA64(normalize((rawInt & 0xff000000) >>> 24, 0, 255), normalize((rawInt & 0x00ff0000) >>> 16, 0, 255), normalize((rawInt & 0x0000ff00) >>> 8, 0, 255), normalize(rawInt & 0x000000ff, 0, 255));
-}
-/**
- * Converts a rgb color string to a {@link @microsoft/fast-colors#ColorRGBA64}.
- * @param raw - a color string format "rgba(RR,GG,BB)" where RR,GG,BB are [0,255]
- * @example
- * ```ts
- * parseColorWebRGB("rgba(255, 0, 0");
- * ```
- * @public
- */
-export function parseColorWebRGB(raw) {
-    const result = webRGBRegex.exec(raw);
-    if (result === null) {
-        return null;
-    }
-    const split = result[1].split(",");
-    return new ColorRGBA64(normalize(Number(split[0]), 0, 255), normalize(Number(split[1]), 0, 255), normalize(Number(split[2]), 0, 255), 1);
-}
-/**
- * Converts a rgba color string to a {@link @microsoft/fast-colors#ColorRGBA64}.
- * @param raw - a color string format "rgba(RR,GG,BB,a)" where RR,GG,BB are [0,255] and a is [0,1]
- * @example
- * ```ts
- * parseColorWebRGBA("rgba(255, 0, 0, 1");
- * ```
- * @public
- */
-export function parseColorWebRGBA(raw) {
-    const result = webRGBARegex.exec(raw);
-    if (result === null) {
-        return null;
-    }
-    const split = result[1].split(",");
-    if (split.length === 4) {
-        return new ColorRGBA64(normalize(Number(split[0]), 0, 255), normalize(Number(split[1]), 0, 255), normalize(Number(split[2]), 0, 255), Number(split[3]));
-    }
-    return null;
-}
-/**
- * Converts a named color to a {@link @microsoft/fast-colors#ColorRGBA64}.
- * @param raw - a {@link https://www.w3schools.com/colors/colors_names.asp | CSS color name}.
- * @example
- * ```ts
- * parseColorNamed("red");
- * ```
- * @public
- */
-export function parseColorNamed(raw) {
-    // const rawLower: typeof raw =  raw.toLowerCase() : raw.toString();
-    const config = namedColorsConfigs[raw.toLowerCase()];
-    return config
-        ? new ColorRGBA64(config.r, config.g, config.b, config.hasOwnProperty("a") ? config.a : void 0)
-        : null;
-}
-/**
- *
-  Expects any of the following and attempts to determine which is being used
- * #RRGGBB, #AARRGGBB, rgb(RR,GG,BB) rgba(RR,GG,BB,a),
- * or any of the {@link https://www.w3schools.com/colors/colors_names.asp | CSS color names}.
- * @param raw - the color string to parse
- * @public
- */
-export function parseColor(raw) {
-    const rawLower = raw.toLowerCase();
-    return isColorStringHexRGB(rawLower)
-        ? parseColorHexRGB(rawLower)
-        : isColorStringHexRGBA(rawLower)
-            ? parseColorHexARGB(rawLower)
-            : isColorStringWebRGB(rawLower)
-                ? parseColorWebRGB(rawLower)
-                : isColorStringWebRGBA(rawLower)
-                    ? parseColorWebRGBA(rawLower)
-                    : isColorNamed(rawLower)
-                        ? parseColorNamed(rawLower)
-                        : null;
-}

package/dist/bundled/js/@microsoft/fast-colors@5.3.1/dist/pixel-blob.js

@@ -1,72 +0,0 @@
-import { ColorRGBA64 } from "./color-rgba-64.js";
-/**
- * Creates an HTMLImageElement and loads the source argument as its src. Then an HTMLCanvasElement is created and the image is copied into the canvas. The pixel data is then returned from the CanvasRenderingContext2D for that canvas.
- *
- * @public
- */
-export function loadImageData(source) {
-    return new Promise((resolve, reject) => {
-        const image = new Image();
-        if (!image) {
-            reject("Unable to create image");
-            return;
-        }
-        /* eslint-disable-next-line */
-        image.onload = (e) => {
-            const canvas = document.createElement("canvas");
-            if (!canvas) {
-                reject("Unable to create canvas");
-                return;
-            }
-            canvas.width = image.naturalWidth;
-            canvas.height = image.naturalHeight;
-            const context = canvas.getContext("2d");
-            if (!context) {
-                reject("Unable to create context");
-                return;
-            }
-            context.drawImage(image, 0, 0, canvas.width, canvas.height);
-            const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
-            resolve(imageData);
-        };
-        image.onerror = (e) => {
-            reject(e);
-        };
-        image.onabort = (e) => {
-            reject(e);
-        };
-        image.src = source;
-    });
-}
-/**
- * A {@link PixelBlob} implementation from an {@link https://developer.mozilla.org/en-US/docs/Web/API/ImageData | ImageData} object.
- * @public
- * @privateRemarks
- * Note that this class and the function loadImageData are not covered by unit tests
- * due to not being able to create a valid canvas rendering context or ImageData object
- * in the unit test framework. ArrayPixelBlob is used instead in tests needing a PixelBlob.
- */
-export class ImageDataPixelBlob {
-    constructor(image) {
-        this.getPixel = (x, y) => {
-            const rgba = this.getPixelRGBA(x, y);
-            return new ColorRGBA64(rgba[0] / 255, rgba[1] / 255, rgba[2] / 255, rgba[3] / 255);
-        };
-        this.getPixelRGBA = (x, y) => {
-            if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
-                throw new Error("Requested pixel is outside of the image bounds");
-            }
-            const offset = (y * this.width + x) * 4;
-            return [
-                this.image.data[offset],
-                this.image.data[offset + 1],
-                this.image.data[offset + 2],
-                this.image.data[offset + 3],
-            ];
-        };
-        this.image = image;
-        this.width = image.width;
-        this.height = image.height;
-        this.totalPixels = this.width * this.height;
-    }
-}

package/dist/bundled/js/@microsoft/fast-colors@5.3.1/dist/pixel-box.js

@@ -1,249 +0,0 @@
-import { ColorRGBA64 } from "./color-rgba-64.js";
-/**
- * Adds a newItem to an already sorted list without needing to do a full re-sort.
- * Higher sort priority puts the newItem closer to the start (index 0) of the list.
- *
- * @public
- */
-export function insertIntoSortedList(list, newItem, sortPriority) {
-    if (list.length === 0) {
-        list.push(newItem);
-        return;
-    }
-    const newItemPriority = sortPriority(newItem);
-    // The new item being either first or last happens often enough that it is worth special casing
-    // In cases of a tie the new item should be inserted after existing items of the same priority
-    if (newItemPriority > sortPriority(list[0])) {
-        list.unshift(newItem);
-        return;
-    }
-    if (newItemPriority <= sortPriority(list[list.length - 1])) {
-        list.push(newItem);
-        return;
-    }
-    let newIndex = 0;
-    for (let i = 0; i < list.length; i++) {
-        if (newItemPriority > sortPriority(list[i])) {
-            newIndex = i;
-            break;
-        }
-    }
-    list.splice(newIndex, 0, newItem);
-}
-/**
- * Represents a range of colors in RGB color space.
- *
- * @public
- */
-export class PixelBox {
-    constructor(globalHistogram, minRed, maxRed, minGreen, maxGreen, minBlue, maxBlue) {
-        /**
-         * Attempts to divide the range of colors represented by this PixelBox into two smaller PixelBox objects.
-         * This does not actually cut directly at the median, rather it finds the median then cuts halfway through the larger box on either side of that median. The result is that small areas of color are better represented in the final output.
-         * Based on the Modified Median Cut Quantization implementation from https://github.com/DanBloomberg/leptonica/blob/master/src/colorquant2.c
-         */
-        this.modifiedMedianCut = () => {
-            if (this.rangeRed === 1 && this.rangeGreen === 1 && this.rangeBlue === 1) {
-                // This box is already sliced as finely as possible
-                return [this, null];
-            }
-            let CutAxis;
-            (function (CutAxis) {
-                CutAxis[CutAxis["Red"] = 0] = "Red";
-                CutAxis[CutAxis["Green"] = 1] = "Green";
-                CutAxis[CutAxis["Blue"] = 2] = "Blue";
-            })(CutAxis || (CutAxis = {}));
-            let axis;
-            let axisRange;
-            if (this.rangeRed >= this.rangeGreen && this.rangeRed >= this.rangeBlue) {
-                axis = CutAxis.Red;
-                axisRange = this.rangeRed;
-            }
-            else if (this.rangeGreen >= this.rangeRed &&
-                this.rangeGreen >= this.rangeBlue) {
-                axis = CutAxis.Green;
-                axisRange = this.rangeGreen;
-            }
-            else {
-                axis = CutAxis.Blue;
-                axisRange = this.rangeBlue;
-            }
-            const partialSum = new Array(axisRange);
-            const lookAheadSum = new Array(axisRange);
-            let retLeft = null;
-            let retRight = null;
-            let axisTotal = 0;
-            // This does not actually cut directly at the median, rather it finds the median then
-            // cuts halfway through the larger box on either side of that median
-            // The result is that small areas of color are better represented in the final output
-            if (axis === CutAxis.Red) {
-                // Calculate partial sums
-                for (let r = this.minRed; r <= this.maxRed; r++) {
-                    let sum = 0;
-                    for (let g = this.minGreen; g <= this.maxGreen; g++) {
-                        for (let b = this.minBlue; b <= this.maxBlue; b++) {
-                            sum += this.globalHistogram.getHistogramValue(r, g, b);
-                        }
-                    }
-                    axisTotal += sum;
-                    partialSum[r - this.minRed] = axisTotal;
-                }
-                for (let i = 0; i < partialSum.length; i++) {
-                    lookAheadSum[i] = axisTotal - partialSum[i];
-                }
-                // Find the cut point based on partial sums vs total
-                for (let r = this.minRed; r <= this.maxRed; r++) {
-                    if (partialSum[r - this.minRed] >= axisTotal / 2) {
-                        const left = r - this.minRed;
-                        const right = this.maxRed - r;
-                        let cut;
-                        if (left <= right) {
-                            cut = Math.min(this.maxRed - 1, Math.floor(r + right / 2));
-                        }
-                        else {
-                            cut = Math.max(this.minRed, Math.floor(r - 1 - left / 2));
-                        }
-                        // Adjust the cut point if either side has 0 pixelCount
-                        while (partialSum[cut - this.minRed] <= 0 && cut < this.maxRed - 1) {
-                            cut++;
-                        }
-                        let lookAhead = lookAheadSum[cut - this.minRed];
-                        while (lookAhead === 0 &&
-                            cut > this.minRed &&
-                            partialSum[cut - this.minRed - 1] !== 0) {
-                            cut--;
-                            lookAhead = lookAheadSum[cut - this.minRed];
-                        }
-                        retLeft = new PixelBox(this.globalHistogram, this.minRed, cut, this.minGreen, this.maxGreen, this.minBlue, this.maxBlue);
-                        retRight = new PixelBox(this.globalHistogram, cut + 1, this.maxRed, this.minGreen, this.maxGreen, this.minBlue, this.maxBlue);
-                        break;
-                    }
-                }
-            }
-            else if (axis === CutAxis.Green) {
-                // Calculate partial sums
-                for (let g = this.minGreen; g <= this.maxGreen; g++) {
-                    let sum = 0;
-                    for (let r = this.minRed; r <= this.maxRed; r++) {
-                        for (let b = this.minBlue; b <= this.maxBlue; b++) {
-                            sum += this.globalHistogram.getHistogramValue(r, g, b);
-                        }
-                    }
-                    axisTotal += sum;
-                    partialSum[g - this.minGreen] = axisTotal;
-                }
-                for (let i = 0; i < partialSum.length; i++) {
-                    lookAheadSum[i] = axisTotal - partialSum[i];
-                }
-                // Find the cut point based on partial sums vs total
-                for (let g = this.minGreen; g <= this.maxGreen; g++) {
-                    if (partialSum[g - this.minGreen] >= axisTotal / 2) {
-                        const left = g - this.minGreen;
-                        const right = this.maxGreen - g;
-                        let cut;
-                        if (left <= right) {
-                            cut = Math.min(this.maxGreen - 1, Math.floor(g + right / 2));
-                        }
-                        else {
-                            cut = Math.max(this.minGreen, Math.floor(g - 1 - left / 2));
-                        }
-                        // Adjust the cut point if either side has 0 pixelCount
-                        while (partialSum[cut - this.minGreen] <= 0 &&
-                            cut < this.maxGreen - 1) {
-                            cut++;
-                        }
-                        let lookAhead = lookAheadSum[cut - this.minGreen];
-                        while (lookAhead === 0 &&
-                            cut > this.minGreen &&
-                            partialSum[cut - this.minGreen - 1] !== 0) {
-                            cut--;
-                            lookAhead = lookAheadSum[cut - this.minGreen];
-                        }
-                        retLeft = new PixelBox(this.globalHistogram, this.minRed, this.maxRed, this.minGreen, cut, this.minBlue, this.maxBlue);
-                        retRight = new PixelBox(this.globalHistogram, this.minRed, this.maxRed, cut + 1, this.maxGreen, this.minBlue, this.maxBlue);
-                        break;
-                    }
-                }
-            }
-            else {
-                // Calculate partial sums
-                for (let b = this.minBlue; b <= this.maxBlue; b++) {
-                    let sum = 0;
-                    for (let r = this.minRed; r <= this.maxRed; r++) {
-                        for (let g = this.minGreen; g <= this.maxGreen; g++) {
-                            sum += this.globalHistogram.getHistogramValue(r, g, b);
-                        }
-                    }
-                    axisTotal += sum;
-                    partialSum[b - this.minBlue] = axisTotal;
-                }
-                for (let i = 0; i < partialSum.length; i++) {
-                    lookAheadSum[i] = axisTotal - partialSum[i];
-                }
-                // Find the cut point based on partial sums vs total
-                for (let b = this.minBlue; b <= this.maxBlue; b++) {
-                    if (partialSum[b - this.minBlue] >= axisTotal / 2) {
-                        const left = b - this.minBlue;
-                        const right = this.maxBlue - b;
-                        let cut;
-                        if (left <= right) {
-                            cut = Math.min(this.maxBlue - 1, Math.floor(b + right / 2));
-                        }
-                        else {
-                            cut = Math.max(this.minBlue, Math.floor(b - 1 - left / 2));
-                        }
-                        // Adjust the cut point if either side has 0 pixelCount
-                        while (partialSum[cut - this.minBlue] <= 0 &&
-                            cut < this.maxBlue - 1) {
-                            cut++;
-                        }
-                        let lookAhead = lookAheadSum[cut - this.minBlue];
-                        while (lookAhead === 0 &&
-                            cut > this.minBlue &&
-                            partialSum[cut - this.minBlue - 1] !== 0) {
-                            cut--;
-                            lookAhead = lookAheadSum[cut - this.minBlue];
-                        }
-                        retLeft = new PixelBox(this.globalHistogram, this.minRed, this.maxRed, this.minGreen, this.maxGreen, this.minBlue, cut);
-                        retRight = new PixelBox(this.globalHistogram, this.minRed, this.maxRed, this.minGreen, this.maxGreen, cut + 1, this.maxBlue);
-                        break;
-                    }
-                }
-            }
-            return [retLeft, retRight];
-        };
-        this.pixelCount = 0;
-        this.globalHistogram = globalHistogram;
-        this.minRed = minRed;
-        this.maxRed = maxRed;
-        this.minGreen = minGreen;
-        this.maxGreen = maxGreen;
-        this.minBlue = minBlue;
-        this.maxBlue = maxBlue;
-        this.rangeRed = this.maxRed - this.minRed + 1;
-        this.rangeGreen = this.maxGreen - this.minGreen + 1;
-        this.rangeBlue = this.maxBlue - this.minBlue + 1;
-        this.colorVolume = this.rangeRed * this.rangeGreen * this.rangeBlue;
-        let redSum = 0;
-        let greenSum = 0;
-        let blueSum = 0;
-        const factor = 1 << (8 - this.globalHistogram.significantBits);
-        for (let r = minRed; r <= maxRed; r++) {
-            for (let g = minGreen; g <= maxGreen; g++) {
-                for (let b = minBlue; b <= maxBlue; b++) {
-                    const histoValue = this.globalHistogram.getHistogramValue(r, g, b);
-                    this.pixelCount += histoValue;
-                    redSum += histoValue * (r + 0.5) * factor;
-                    greenSum += histoValue * (g + 0.5) * factor;
-                    blueSum += histoValue * (b + 0.5) * factor;
-                }
-            }
-        }
-        if (this.pixelCount === 0) {
-            this.averageColor = new ColorRGBA64((factor * ((minRed + maxRed + 1) / 2)) / 255, (factor * ((minGreen + maxGreen + 1) / 2)) / 255, (factor * ((minBlue + maxBlue + 1) / 2)) / 255, 1);
-        }
-        else {
-            this.averageColor = new ColorRGBA64(redSum / this.pixelCount / 255, greenSum / this.pixelCount / 255, blueSum / this.pixelCount / 255, 1);
-        }
-    }
-}