@holoviz/panel 0.14.3 → 1.0.0-a.1

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

@@ -1,95 +0,0 @@
-import { clamp, denormalize, getHexStringForByte, roundToPrecisionSmall, } from "./math-utilities.js";
-/**
- * A RGBA color with 64 bit channels.
- *
- * @example
- * ```ts
- * new ColorRGBA64(1, 0, 0, 1) // red
- * ```
- * @public
- */
-export class ColorRGBA64 {
-    /**
-     *
-     * @param red - the red value
-     * @param green - the green value
-     * @param blue - the blue value
-     * @param alpha - the alpha value
-     */
-    constructor(red, green, blue, alpha) {
-        this.r = red;
-        this.g = green;
-        this.b = blue;
-        this.a = typeof alpha === "number" && !isNaN(alpha) ? alpha : 1;
-    }
-    /**
-     * Construct a {@link ColorRGBA64} from a {@link ColorRGBA64Config}
-     * @param data - the config object
-     */
-    static fromObject(data) {
-        return data && !isNaN(data.r) && !isNaN(data.g) && !isNaN(data.b)
-            ? new ColorRGBA64(data.r, data.g, data.b, data.a)
-            : null;
-    }
-    /**
-     * Determines if one color is equal to another.
-     * @param rhs - the color to compare
-     */
-    equalValue(rhs) {
-        return (this.r === rhs.r && this.g === rhs.g && this.b === rhs.b && this.a === rhs.a);
-    }
-    /**
-     * Returns the color formatted as a string; #RRGGBB
-     */
-    toStringHexRGB() {
-        return "#" + [this.r, this.g, this.b].map(this.formatHexValue).join("");
-    }
-    /**
-     * Returns the color formatted as a string; #RRGGBBAA
-     */
-    toStringHexRGBA() {
-        return this.toStringHexRGB() + this.formatHexValue(this.a);
-    }
-    /**
-     * Returns the color formatted as a string; #AARRGGBB
-     */
-    toStringHexARGB() {
-        return "#" + [this.a, this.r, this.g, this.b].map(this.formatHexValue).join("");
-    }
-    /**
-     * Returns the color formatted as a string; "rgb(0xRR, 0xGG, 0xBB)"
-     */
-    toStringWebRGB() {
-        return `rgb(${Math.round(denormalize(this.r, 0.0, 255.0))},${Math.round(denormalize(this.g, 0.0, 255.0))},${Math.round(denormalize(this.b, 0.0, 255.0))})`;
-    }
-    /**
-     * Returns the color formatted as a string; "rgba(0xRR, 0xGG, 0xBB, a)"
-     * @remarks
-     * Note that this follows the convention of putting alpha in the range [0.0,1.0] while the other three channels are [0,255]
-     */
-    toStringWebRGBA() {
-        return `rgba(${Math.round(denormalize(this.r, 0.0, 255.0))},${Math.round(denormalize(this.g, 0.0, 255.0))},${Math.round(denormalize(this.b, 0.0, 255.0))},${clamp(this.a, 0, 1)})`;
-    }
-    /**
-     * Returns a new {@link ColorRGBA64} rounded to the provided precision
-     * @param precision - the precision to round to
-     */
-    roundToPrecision(precision) {
-        return new ColorRGBA64(roundToPrecisionSmall(this.r, precision), roundToPrecisionSmall(this.g, precision), roundToPrecisionSmall(this.b, precision), roundToPrecisionSmall(this.a, precision));
-    }
-    /**
-     * Returns a new {@link ColorRGBA64} with channel values clamped between 0 and 1.
-     */
-    clamp() {
-        return new ColorRGBA64(clamp(this.r, 0, 1), clamp(this.g, 0, 1), clamp(this.b, 0, 1), clamp(this.a, 0, 1));
-    }
-    /**
-     * Converts the {@link ColorRGBA64} to a {@link ColorRGBA64Config}.
-     */
-    toObject() {
-        return { r: this.r, g: this.g, b: this.b, a: this.a };
-    }
-    formatHexValue(value) {
-        return getHexStringForByte(denormalize(value, 0.0, 255.0));
-    }
-}

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

@@ -1,176 +0,0 @@
-import { contrastRatio } from "./color-converters.js";
-import { ColorInterpolationSpace, interpolateByColorSpace, } from "./color-interpolation.js";
-/**
- * A color scale created from linear stops
- * @public
- */
-export class ColorScale {
-    constructor(stops) {
-        if (stops == null || stops.length === 0) {
-            throw new Error("The stops argument must be non-empty");
-        }
-        else {
-            this.stops = this.sortColorScaleStops(stops);
-        }
-    }
-    static createBalancedColorScale(colors) {
-        if (colors == null || colors.length === 0) {
-            throw new Error("The colors argument must be non-empty");
-        }
-        const stops = new Array(colors.length);
-        for (let i = 0; i < colors.length; i++) {
-            // Special case first and last in order to avoid floating point jaggies
-            if (i === 0) {
-                stops[i] = { color: colors[i], position: 0 };
-            }
-            else if (i === colors.length - 1) {
-                stops[i] = { color: colors[i], position: 1 };
-            }
-            else {
-                stops[i] = {
-                    color: colors[i],
-                    position: i * (1 / (colors.length - 1)),
-                };
-            }
-        }
-        return new ColorScale(stops);
-    }
-    getColor(position, interpolationMode = ColorInterpolationSpace.RGB) {
-        if (this.stops.length === 1) {
-            return this.stops[0].color;
-        }
-        else if (position <= 0) {
-            return this.stops[0].color;
-        }
-        else if (position >= 1) {
-            return this.stops[this.stops.length - 1].color;
-        }
-        let lowerIndex = 0;
-        for (let i = 0; i < this.stops.length; i++) {
-            if (this.stops[i].position <= position) {
-                lowerIndex = i;
-            }
-        }
-        let upperIndex = lowerIndex + 1;
-        if (upperIndex >= this.stops.length) {
-            upperIndex = this.stops.length - 1;
-        }
-        const scalePosition = (position - this.stops[lowerIndex].position) *
-            (1.0 / (this.stops[upperIndex].position - this.stops[lowerIndex].position));
-        return interpolateByColorSpace(scalePosition, interpolationMode, this.stops[lowerIndex].color, this.stops[upperIndex].color);
-    }
-    trim(lowerBound, upperBound, interpolationMode = ColorInterpolationSpace.RGB) {
-        if (lowerBound < 0 || upperBound > 1 || upperBound < lowerBound) {
-            throw new Error("Invalid bounds");
-        }
-        if (lowerBound === upperBound) {
-            return new ColorScale([
-                { color: this.getColor(lowerBound, interpolationMode), position: 0 },
-            ]);
-        }
-        const containedStops = [];
-        for (let i = 0; i < this.stops.length; i++) {
-            if (this.stops[i].position >= lowerBound &&
-                this.stops[i].position <= upperBound) {
-                containedStops.push(this.stops[i]);
-            }
-        }
-        if (containedStops.length === 0) {
-            return new ColorScale([
-                { color: this.getColor(lowerBound), position: lowerBound },
-                { color: this.getColor(upperBound), position: upperBound },
-            ]);
-        }
-        if (containedStops[0].position !== lowerBound) {
-            containedStops.unshift({
-                color: this.getColor(lowerBound),
-                position: lowerBound,
-            });
-        }
-        if (containedStops[containedStops.length - 1].position !== upperBound) {
-            containedStops.push({
-                color: this.getColor(upperBound),
-                position: upperBound,
-            });
-        }
-        const range = upperBound - lowerBound;
-        const finalStops = new Array(containedStops.length);
-        for (let i = 0; i < containedStops.length; i++) {
-            finalStops[i] = {
-                color: containedStops[i].color,
-                position: (containedStops[i].position - lowerBound) / range,
-            };
-        }
-        return new ColorScale(finalStops);
-    }
-    findNextColor(position, contrast, searchDown = false, interpolationMode = ColorInterpolationSpace.RGB, contrastErrorMargin = 0.005, maxSearchIterations = 32) {
-        if (isNaN(position) || position <= 0) {
-            position = 0;
-        }
-        else if (position >= 1) {
-            position = 1;
-        }
-        const startingColor = this.getColor(position, interpolationMode);
-        const finalPosition = searchDown ? 0 : 1;
-        const finalColor = this.getColor(finalPosition, interpolationMode);
-        const finalContrast = contrastRatio(startingColor, finalColor);
-        if (finalContrast <= contrast) {
-            return finalPosition;
-        }
-        let testRangeMin = searchDown ? 0 : position;
-        let testRangeMax = searchDown ? position : 0;
-        let mid = finalPosition;
-        let iterations = 0;
-        while (iterations <= maxSearchIterations) {
-            mid = Math.abs(testRangeMax - testRangeMin) / 2 + testRangeMin;
-            const midColor = this.getColor(mid, interpolationMode);
-            const midContrast = contrastRatio(startingColor, midColor);
-            if (Math.abs(midContrast - contrast) <= contrastErrorMargin) {
-                return mid;
-            }
-            else if (midContrast > contrast) {
-                if (searchDown) {
-                    testRangeMin = mid;
-                }
-                else {
-                    testRangeMax = mid;
-                }
-            }
-            else {
-                if (searchDown) {
-                    testRangeMax = mid;
-                }
-                else {
-                    testRangeMin = mid;
-                }
-            }
-            iterations++;
-        }
-        return mid;
-    }
-    clone() {
-        const newStops = new Array(this.stops.length);
-        for (let i = 0; i < newStops.length; i++) {
-            newStops[i] = {
-                color: this.stops[i].color,
-                position: this.stops[i].position,
-            };
-        }
-        return new ColorScale(newStops);
-    }
-    sortColorScaleStops(stops) {
-        return stops.sort((a, b) => {
-            const A = a.position;
-            const B = b.position;
-            if (A < B) {
-                return -1;
-            }
-            else if (A > B) {
-                return 1;
-            }
-            else {
-                return 0;
-            }
-        });
-    }
-}

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

@@ -1,50 +0,0 @@
-import { roundToPrecisionSmall } from "./math-utilities.js";
-/**
- * {@link https://en.wikipedia.org/wiki/CIE_1931_color_space | XYZ 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 ColorXYZ {
-    constructor(x, y, z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-    /**
-     * Construct a {@link ColorXYZ} from a config object.
-     */
-    static fromObject(data) {
-        if (data && !isNaN(data.x) && !isNaN(data.y) && !isNaN(data.z)) {
-            return new ColorXYZ(data.x, data.y, data.z);
-        }
-        return null;
-    }
-    /**
-     * Determines if a color is equal to another
-     * @param rhs - the value to compare
-     */
-    equalValue(rhs) {
-        return this.x === rhs.x && this.y === rhs.y && this.z === rhs.z;
-    }
-    /**
-     * Returns a new {@link ColorXYZ} rounded to the provided precision
-     * @param precision - the precision to round to
-     */
-    roundToPrecision(precision) {
-        return new ColorXYZ(roundToPrecisionSmall(this.x, precision), roundToPrecisionSmall(this.y, precision), roundToPrecisionSmall(this.z, precision));
-    }
-    /**
-     * Returns the {@link ColorXYZ} formatted as an object.
-     */
-    toObject() {
-        return { x: this.x, y: this.y, z: this.z };
-    }
-}
-/**
- * D65 2 degree white point
- */
-ColorXYZ.whitePoint = new ColorXYZ(0.95047, 1.0, 1.08883);

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

@@ -1,113 +0,0 @@
-import { ColorRGBA64 } from "./color-rgba-64.js";
-import { ColorPalette } from "./color-palette.js";
-import { hslToRGB, rgbToHSL, rgbToLinearLuminance } from "./color-converters.js";
-import { ColorScale } from "./color-scale.js";
-import { ColorHSL } from "./color-hsl.js";
-import { ColorInterpolationSpace } from "./color-interpolation.js";
-import { parseColorHexRGB } from "./parse-color.js";
-/**
- * Creates a color palette for UI components
- * @public
- */
-export class ComponentStateColorPalette {
-    constructor(config) {
-        this.palette = [];
-        this.config = Object.assign({}, ComponentStateColorPalette.defaultPaletteConfig, config);
-        this.regenPalettes();
-    }
-    regenPalettes() {
-        let steps = this.config.steps;
-        if (isNaN(steps) || steps < 3) {
-            steps = 3;
-        }
-        // This palette is tuned to go as dark as differences between the levels can be perceived according to tests
-        // on numerous monitors in different conditions. Stay linear from white until this first cutoff.
-        const darkLum = 0.14;
-        // In the dark compression, this is the last luminance value before full black.
-        const darkestLum = 0.06;
-        // The Color for the luminance value above, placed on the ramp at it's normal position, so darker colors after
-        // it can be compressed.
-        const darkLumColor = new ColorRGBA64(darkLum, darkLum, darkLum, 1);
-        // The number of steps in the ramp that has been tuned for default use. This coincides with the size of the
-        // default ramp, but the palette could be generated with fewer steps to increase final contrast. This number
-        // should however stay the same.
-        const stepsForLuminanceRamp = 94;
-        // Create the reference, dark-compressed, grey palette, like:
-        // F------------------------------------------------------------------------------------[dark]------[darkest]0
-        //                                                                                      |--compressed area--|
-        const r = new ColorPalette(Object.assign(Object.assign({}, ColorPalette.greyscalePaletteConfig), { baseColor: darkLumColor, baseScalePosition: ((1 - darkLum) * 100) / stepsForLuminanceRamp, steps }));
-        const referencePalette = r.palette;
-        // Find the requested base color on the adjusted luminance reference ramp.
-        // There is no _right_ way to desaturate a color, and both methods we've tested have value, so average them out.
-        const baseColorLum1 = rgbToLinearLuminance(this.config.baseColor);
-        const baseColorLum2 = rgbToHSL(this.config.baseColor).l;
-        const baseColorLum = (baseColorLum1 + baseColorLum2) / 2;
-        const baseColorRefIndex = this.matchRelativeLuminanceIndex(baseColorLum, referencePalette);
-        const baseColorPercent = baseColorRefIndex / (steps - 1);
-        // Find the luminance location for the dark cutoff.
-        const darkRefIndex = this.matchRelativeLuminanceIndex(darkLum, referencePalette);
-        const darkPercent = darkRefIndex / (steps - 1);
-        // Issue https://github.com/microsoft/fast/issues/1904
-        // Creating a color from H, S, and a known L value is not the inverse of getting the relative
-        // luminace as above. Need to derive a relative luminance version of the color to better match on the dark end.
-        // Find the dark cutoff and darkest variations of the requested base color.
-        const baseColorHSL = rgbToHSL(this.config.baseColor);
-        const darkBaseColor = hslToRGB(ColorHSL.fromObject({
-            h: baseColorHSL.h,
-            s: baseColorHSL.s,
-            l: darkLum,
-        }));
-        const darkestBaseColor = hslToRGB(ColorHSL.fromObject({
-            h: baseColorHSL.h,
-            s: baseColorHSL.s,
-            l: darkestLum,
-        }));
-        // Create the gradient stops, including the base color and anchor colors for the dark end compression.
-        const fullColorScaleStops = new Array(5);
-        fullColorScaleStops[0] = {
-            position: 0,
-            color: new ColorRGBA64(1, 1, 1, 1),
-        };
-        fullColorScaleStops[1] = {
-            position: baseColorPercent,
-            color: this.config.baseColor,
-        };
-        fullColorScaleStops[2] = {
-            position: darkPercent,
-            color: darkBaseColor,
-        };
-        fullColorScaleStops[3] = {
-            position: 0.99,
-            color: darkestBaseColor,
-        };
-        fullColorScaleStops[4] = {
-            position: 1,
-            color: new ColorRGBA64(0, 0, 0, 1),
-        };
-        const scale = new ColorScale(fullColorScaleStops);
-        // Create the palette.
-        this.palette = new Array(steps);
-        for (let i = 0; i < steps; i++) {
-            const c = scale.getColor(i / (steps - 1), ColorInterpolationSpace.RGB);
-            this.palette[i] = c;
-        }
-    }
-    matchRelativeLuminanceIndex(input, reference) {
-        let bestFitValue = Number.MAX_VALUE;
-        let bestFitIndex = 0;
-        let i = 0;
-        const referenceLength = reference.length;
-        for (; i < referenceLength; i++) {
-            const fitValue = Math.abs(rgbToLinearLuminance(reference[i]) - input);
-            if (fitValue < bestFitValue) {
-                bestFitValue = fitValue;
-                bestFitIndex = i;
-            }
-        }
-        return bestFitIndex;
-    }
-}
-ComponentStateColorPalette.defaultPaletteConfig = {
-    baseColor: parseColorHexRGB("#808080"),
-    steps: 94,
-};

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

@@ -1,76 +0,0 @@
-/**
- * For each possible color, this counts how many pixels in the source image match that color.
- * If signifigantBits is less than 8, each channel (eg: red, green, blue) in each color is reduced to fit in significantBits. So for the default value of 5 significantBits colors are reduced from 8 bits per channel (0-255) to 5 (0-31). Colors that were previously distinct get combined together.
- * If the image source has more than 2^32 pixels (eg: a square image 65536x65536 in size) of the same color this code will break.
- *
- * @public
- */
-export class Histogram {
-    /**
-     * @param source - the source pixel data.
-     * @param significantBits - The memory needed for the histogram increases dramatically if significantBits is increased. It needs a buffer which is 4*2^(3*significantBits) in size. EG: for 5 significant bits the histogram is 128K while for 8 it is 64 megs.
-     * @param pixelSkipping - CPU time increases linearly as pixelSkipping is reduced.
-     * @param isHistogramPixelValid - isHistogramPixelValid is an optional predicate which can screen out unwanted pixels from the source data. EG: ignoring transparent pixels.
-     */
-    constructor(source, significantBits = 5, pixelSkipping = 5, isHistogramPixelValid = null) {
-        this.getHistogramIndex = (r, g, b) => {
-            const index = (r << (2 * this.significantBits)) + (g << this.significantBits) + b;
-            if (index >= this.data.length) {
-                throw new Error("RGB value is outside the bounds of the histogram");
-            }
-            return index;
-        };
-        this.getHistogramValue = (r, g, b) => {
-            return this.data[this.getHistogramIndex(r, g, b)];
-        };
-        this.setHistogramValue = (value, r, g, b) => {
-            this.data[this.getHistogramIndex(r, g, b)] = value;
-        };
-        if (significantBits < 1 || significantBits > 8) {
-            throw new Error("significantBits must be in the range [1,8]");
-        }
-        if (pixelSkipping < 0) {
-            throw new Error("pixelSkipping must be >= 0");
-        }
-        this.significantBits = significantBits;
-        const sigShift = 8 - this.significantBits;
-        this.minRed = 255 >>> sigShift;
-        this.maxRed = 0;
-        this.minGreen = 255 >>> sigShift;
-        this.maxGreen = 0;
-        this.minBlue = 255 >>> sigShift;
-        this.maxBlue = 0;
-        const histoSize = 1 << (significantBits * 3);
-        this.data = new Uint32Array(histoSize);
-        this.data.fill(0);
-        this.total = 0;
-        let pixelIndex = 0;
-        for (let y = 0; y < source.height; y++) {
-            for (let x = 0; x < source.width; x++) {
-                if (pixelSkipping > 0 && pixelIndex++ % pixelSkipping !== 0) {
-                    continue;
-                }
-                const rgba = source.getPixelRGBA(x, y);
-                if (isHistogramPixelValid !== null) {
-                    if (!isHistogramPixelValid(rgba)) {
-                        continue;
-                    }
-                }
-                // Shift the pixel data into the range determined by significantBits
-                // after checking minAlpha the alpha data is no longer needed
-                rgba[0] = rgba[0] >>> sigShift;
-                rgba[1] = rgba[1] >>> sigShift;
-                rgba[2] = rgba[2] >>> sigShift;
-                this.minRed = Math.min(rgba[0], this.minRed);
-                this.maxRed = Math.max(rgba[0], this.maxRed);
-                this.minGreen = Math.min(rgba[1], this.minGreen);
-                this.maxGreen = Math.max(rgba[1], this.maxGreen);
-                this.minBlue = Math.min(rgba[2], this.minBlue);
-                this.maxBlue = Math.max(rgba[2], this.maxBlue);
-                const histoIndex = this.getHistogramIndex(rgba[0], rgba[1], rgba[2]);
-                this.data[histoIndex] += 1;
-                this.total++;
-            }
-        }
-    }
-}

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

@@ -1,19 +0,0 @@
-export * from "./color-blending.js";
-export * from "./color-converters.js";
-export * from "./color-hsl.js";
-export * from "./color-hsv.js";
-export * from "./color-interpolation.js";
-export * from "./color-lab.js";
-export * from "./color-lch.js";
-export * from "./color-palette.js";
-export * from "./color-quantization.js";
-export * from "./color-rgba-64.js";
-export * from "./color-scale.js";
-export * from "./color-xyz.js";
-export * from "./component-state-color-palette.js";
-export * from "./histogram.js";
-export * from "./math-utilities.js";
-export * from "./palette-extractor.js";
-export * from "./parse-color.js";
-export * from "./pixel-blob.js";
-export * from "./pixel-box.js";

package/dist/bundled/js/@microsoft/fast-colors@5.3.1/dist/math-utilities.js

@@ -1,138 +0,0 @@
-/**
- * Ensures that an input number does not exceed a max value and is not less than a min value.
- * @param i - the number to clamp
- * @param min - the maximum (inclusive) value
- * @param max - the minimum (inclusive) value
- * @public
- */
-export function clamp(i, min, max) {
-    if (isNaN(i) || i <= min) {
-        return min;
-    }
-    else if (i >= max) {
-        return max;
-    }
-    return i;
-}
-/**
- * Scales an input to a number between 0 and 1
- * @param i - a number between min and max
- * @param min - the max value
- * @param max - the min value
- * @public
- */
-export function normalize(i, min, max) {
-    if (isNaN(i) || i <= min) {
-        return 0.0;
-    }
-    else if (i >= max) {
-        return 1.0;
-    }
-    return i / (max - min);
-}
-/**
- * Scales a number between 0 and 1
- * @param i - the number to denormalize
- * @param min - the min value
- * @param max - the max value
- * @public
- */
-export function denormalize(i, min, max) {
-    if (isNaN(i)) {
-        return min;
-    }
-    return min + i * (max - min);
-}
-/**
- * Converts degrees to radians.
- * @param i - degrees
- * @public
- */
-export function degreesToRadians(i) {
-    return i * (Math.PI / 180.0);
-}
-/**
- * Converts radians to degrees.
- * @param i - radians
- * @public
- */
-export function radiansToDegrees(i) {
-    return i * (180.0 / Math.PI);
-}
-/**
- * Converts a number between 0 and 255 to a hex string.
- * @param i - the number to convert to a hex string
- * @public
- */
-export function getHexStringForByte(i) {
-    const s = Math.round(clamp(i, 0.0, 255.0)).toString(16);
-    if (s.length === 1) {
-        return "0" + s;
-    }
-    return s;
-}
-/**
- * Linearly interpolate
- * @public
- */
-export function lerp(i, min, max) {
-    if (isNaN(i) || i <= 0.0) {
-        return min;
-    }
-    else if (i >= 1.0) {
-        return max;
-    }
-    return min + i * (max - min);
-}
-/**
- * Linearly interpolate angles in degrees
- * @public
- */
-export function lerpAnglesInDegrees(i, min, max) {
-    if (i <= 0.0) {
-        return min % 360.0;
-    }
-    else if (i >= 1.0) {
-        return max % 360.0;
-    }
-    const a = (min - max + 360.0) % 360.0;
-    const b = (max - min + 360.0) % 360.0;
-    if (a <= b) {
-        return (min - a * i + 360.0) % 360.0;
-    }
-    return (min + a * i + 360.0) % 360.0;
-}
-const TwoPI = Math.PI * 2;
-/**
- * Linearly interpolate angles in radians
- * @public
- */
-export function lerpAnglesInRadians(i, min, max) {
-    if (isNaN(i) || i <= 0.0) {
-        return min % TwoPI;
-    }
-    else if (i >= 1.0) {
-        return max % TwoPI;
-    }
-    const a = (min - max + TwoPI) % TwoPI;
-    const b = (max - min + TwoPI) % TwoPI;
-    if (a <= b) {
-        return (min - a * i + TwoPI) % TwoPI;
-    }
-    return (min + a * i + TwoPI) % TwoPI;
-}
-/**
- *
- * Will return infinity if i*10^(precision) overflows number
- * note that floating point rounding rules come into play here
- * so values that end up rounding on a .5 round to the nearest
- * even not always up so 2.5 rounds to 2
- * @param i - the number to round
- * @param precision - the precision to round to
- *
- * @public
- */
-export function roundToPrecisionSmall(i, precision) {
-    const factor = Math.pow(10, precision);
-    return Math.round(i * factor) / factor;
-}