@umbraco-cms/backoffice 16.1.1 → 16.2.0-rc2

package/dist-cms/monaco-editor/vs/base/common/color.js

@@ -1,462 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-function roundFloat(number, decimalPoints) {
-    const decimal = Math.pow(10, decimalPoints);
-    return Math.round(number * decimal) / decimal;
-}
-export class RGBA {
-    constructor(r, g, b, a = 1) {
-        this._rgbaBrand = undefined;
-        this.r = Math.min(255, Math.max(0, r)) | 0;
-        this.g = Math.min(255, Math.max(0, g)) | 0;
-        this.b = Math.min(255, Math.max(0, b)) | 0;
-        this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);
-    }
-    static equals(a, b) {
-        return a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a;
-    }
-}
-export class HSLA {
-    constructor(h, s, l, a) {
-        this._hslaBrand = undefined;
-        this.h = Math.max(Math.min(360, h), 0) | 0;
-        this.s = roundFloat(Math.max(Math.min(1, s), 0), 3);
-        this.l = roundFloat(Math.max(Math.min(1, l), 0), 3);
-        this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);
-    }
-    static equals(a, b) {
-        return a.h === b.h && a.s === b.s && a.l === b.l && a.a === b.a;
-    }
-    /**
-     * Converts an RGB color value to HSL. Conversion formula
-     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
-     * Assumes r, g, and b are contained in the set [0, 255] and
-     * returns h in the set [0, 360], s, and l in the set [0, 1].
-     */
-    static fromRGBA(rgba) {
-        const r = rgba.r / 255;
-        const g = rgba.g / 255;
-        const b = rgba.b / 255;
-        const a = rgba.a;
-        const max = Math.max(r, g, b);
-        const min = Math.min(r, g, b);
-        let h = 0;
-        let s = 0;
-        const l = (min + max) / 2;
-        const chroma = max - min;
-        if (chroma > 0) {
-            s = Math.min((l <= 0.5 ? chroma / (2 * l) : chroma / (2 - (2 * l))), 1);
-            switch (max) {
-                case r:
-                    h = (g - b) / chroma + (g < b ? 6 : 0);
-                    break;
-                case g:
-                    h = (b - r) / chroma + 2;
-                    break;
-                case b:
-                    h = (r - g) / chroma + 4;
-                    break;
-            }
-            h *= 60;
-            h = Math.round(h);
-        }
-        return new HSLA(h, s, l, a);
-    }
-    static _hue2rgb(p, q, t) {
-        if (t < 0) {
-            t += 1;
-        }
-        if (t > 1) {
-            t -= 1;
-        }
-        if (t < 1 / 6) {
-            return p + (q - p) * 6 * t;
-        }
-        if (t < 1 / 2) {
-            return q;
-        }
-        if (t < 2 / 3) {
-            return p + (q - p) * (2 / 3 - t) * 6;
-        }
-        return p;
-    }
-    /**
-     * Converts an HSL color value to RGB. Conversion formula
-     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
-     * Assumes h in the set [0, 360] s, and l are contained in the set [0, 1] and
-     * returns r, g, and b in the set [0, 255].
-     */
-    static toRGBA(hsla) {
-        const h = hsla.h / 360;
-        const { s, l, a } = hsla;
-        let r, g, b;
-        if (s === 0) {
-            r = g = b = l; // achromatic
-        }
-        else {
-            const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
-            const p = 2 * l - q;
-            r = HSLA._hue2rgb(p, q, h + 1 / 3);
-            g = HSLA._hue2rgb(p, q, h);
-            b = HSLA._hue2rgb(p, q, h - 1 / 3);
-        }
-        return new RGBA(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), a);
-    }
-}
-export class HSVA {
-    constructor(h, s, v, a) {
-        this._hsvaBrand = undefined;
-        this.h = Math.max(Math.min(360, h), 0) | 0;
-        this.s = roundFloat(Math.max(Math.min(1, s), 0), 3);
-        this.v = roundFloat(Math.max(Math.min(1, v), 0), 3);
-        this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);
-    }
-    static equals(a, b) {
-        return a.h === b.h && a.s === b.s && a.v === b.v && a.a === b.a;
-    }
-    // from http://www.rapidtables.com/convert/color/rgb-to-hsv.htm
-    static fromRGBA(rgba) {
-        const r = rgba.r / 255;
-        const g = rgba.g / 255;
-        const b = rgba.b / 255;
-        const cmax = Math.max(r, g, b);
-        const cmin = Math.min(r, g, b);
-        const delta = cmax - cmin;
-        const s = cmax === 0 ? 0 : (delta / cmax);
-        let m;
-        if (delta === 0) {
-            m = 0;
-        }
-        else if (cmax === r) {
-            m = ((((g - b) / delta) % 6) + 6) % 6;
-        }
-        else if (cmax === g) {
-            m = ((b - r) / delta) + 2;
-        }
-        else {
-            m = ((r - g) / delta) + 4;
-        }
-        return new HSVA(Math.round(m * 60), s, cmax, rgba.a);
-    }
-    // from http://www.rapidtables.com/convert/color/hsv-to-rgb.htm
-    static toRGBA(hsva) {
-        const { h, s, v, a } = hsva;
-        const c = v * s;
-        const x = c * (1 - Math.abs((h / 60) % 2 - 1));
-        const m = v - c;
-        let [r, g, b] = [0, 0, 0];
-        if (h < 60) {
-            r = c;
-            g = x;
-        }
-        else if (h < 120) {
-            r = x;
-            g = c;
-        }
-        else if (h < 180) {
-            g = c;
-            b = x;
-        }
-        else if (h < 240) {
-            g = x;
-            b = c;
-        }
-        else if (h < 300) {
-            r = x;
-            b = c;
-        }
-        else if (h <= 360) {
-            r = c;
-            b = x;
-        }
-        r = Math.round((r + m) * 255);
-        g = Math.round((g + m) * 255);
-        b = Math.round((b + m) * 255);
-        return new RGBA(r, g, b, a);
-    }
-}
-export class Color {
-    static fromHex(hex) {
-        return Color.Format.CSS.parseHex(hex) || Color.red;
-    }
-    static equals(a, b) {
-        if (!a && !b) {
-            return true;
-        }
-        if (!a || !b) {
-            return false;
-        }
-        return a.equals(b);
-    }
-    get hsla() {
-        if (this._hsla) {
-            return this._hsla;
-        }
-        else {
-            return HSLA.fromRGBA(this.rgba);
-        }
-    }
-    get hsva() {
-        if (this._hsva) {
-            return this._hsva;
-        }
-        return HSVA.fromRGBA(this.rgba);
-    }
-    constructor(arg) {
-        if (!arg) {
-            throw new Error('Color needs a value');
-        }
-        else if (arg instanceof RGBA) {
-            this.rgba = arg;
-        }
-        else if (arg instanceof HSLA) {
-            this._hsla = arg;
-            this.rgba = HSLA.toRGBA(arg);
-        }
-        else if (arg instanceof HSVA) {
-            this._hsva = arg;
-            this.rgba = HSVA.toRGBA(arg);
-        }
-        else {
-            throw new Error('Invalid color ctor argument');
-        }
-    }
-    equals(other) {
-        return !!other && RGBA.equals(this.rgba, other.rgba) && HSLA.equals(this.hsla, other.hsla) && HSVA.equals(this.hsva, other.hsva);
-    }
-    /**
-     * http://www.w3.org/TR/WCAG20/#relativeluminancedef
-     * Returns the number in the set [0, 1]. O => Darkest Black. 1 => Lightest white.
-     */
-    getRelativeLuminance() {
-        const R = Color._relativeLuminanceForComponent(this.rgba.r);
-        const G = Color._relativeLuminanceForComponent(this.rgba.g);
-        const B = Color._relativeLuminanceForComponent(this.rgba.b);
-        const luminance = 0.2126 * R + 0.7152 * G + 0.0722 * B;
-        return roundFloat(luminance, 4);
-    }
-    static _relativeLuminanceForComponent(color) {
-        const c = color / 255;
-        return (c <= 0.03928) ? c / 12.92 : Math.pow(((c + 0.055) / 1.055), 2.4);
-    }
-    /**
-     *	http://24ways.org/2010/calculating-color-contrast
-     *  Return 'true' if lighter color otherwise 'false'
-     */
-    isLighter() {
-        const yiq = (this.rgba.r * 299 + this.rgba.g * 587 + this.rgba.b * 114) / 1000;
-        return yiq >= 128;
-    }
-    isLighterThan(another) {
-        const lum1 = this.getRelativeLuminance();
-        const lum2 = another.getRelativeLuminance();
-        return lum1 > lum2;
-    }
-    isDarkerThan(another) {
-        const lum1 = this.getRelativeLuminance();
-        const lum2 = another.getRelativeLuminance();
-        return lum1 < lum2;
-    }
-    lighten(factor) {
-        return new Color(new HSLA(this.hsla.h, this.hsla.s, this.hsla.l + this.hsla.l * factor, this.hsla.a));
-    }
-    darken(factor) {
-        return new Color(new HSLA(this.hsla.h, this.hsla.s, this.hsla.l - this.hsla.l * factor, this.hsla.a));
-    }
-    transparent(factor) {
-        const { r, g, b, a } = this.rgba;
-        return new Color(new RGBA(r, g, b, a * factor));
-    }
-    isTransparent() {
-        return this.rgba.a === 0;
-    }
-    isOpaque() {
-        return this.rgba.a === 1;
-    }
-    opposite() {
-        return new Color(new RGBA(255 - this.rgba.r, 255 - this.rgba.g, 255 - this.rgba.b, this.rgba.a));
-    }
-    makeOpaque(opaqueBackground) {
-        if (this.isOpaque() || opaqueBackground.rgba.a !== 1) {
-            // only allow to blend onto a non-opaque color onto a opaque color
-            return this;
-        }
-        const { r, g, b, a } = this.rgba;
-        // https://stackoverflow.com/questions/12228548/finding-equivalent-color-with-opacity
-        return new Color(new RGBA(opaqueBackground.rgba.r - a * (opaqueBackground.rgba.r - r), opaqueBackground.rgba.g - a * (opaqueBackground.rgba.g - g), opaqueBackground.rgba.b - a * (opaqueBackground.rgba.b - b), 1));
-    }
-    toString() {
-        if (!this._toString) {
-            this._toString = Color.Format.CSS.format(this);
-        }
-        return this._toString;
-    }
-    static getLighterColor(of, relative, factor) {
-        if (of.isLighterThan(relative)) {
-            return of;
-        }
-        factor = factor ? factor : 0.5;
-        const lum1 = of.getRelativeLuminance();
-        const lum2 = relative.getRelativeLuminance();
-        factor = factor * (lum2 - lum1) / lum2;
-        return of.lighten(factor);
-    }
-    static getDarkerColor(of, relative, factor) {
-        if (of.isDarkerThan(relative)) {
-            return of;
-        }
-        factor = factor ? factor : 0.5;
-        const lum1 = of.getRelativeLuminance();
-        const lum2 = relative.getRelativeLuminance();
-        factor = factor * (lum1 - lum2) / lum1;
-        return of.darken(factor);
-    }
-    static { this.white = new Color(new RGBA(255, 255, 255, 1)); }
-    static { this.black = new Color(new RGBA(0, 0, 0, 1)); }
-    static { this.red = new Color(new RGBA(255, 0, 0, 1)); }
-    static { this.blue = new Color(new RGBA(0, 0, 255, 1)); }
-    static { this.green = new Color(new RGBA(0, 255, 0, 1)); }
-    static { this.cyan = new Color(new RGBA(0, 255, 255, 1)); }
-    static { this.lightgrey = new Color(new RGBA(211, 211, 211, 1)); }
-    static { this.transparent = new Color(new RGBA(0, 0, 0, 0)); }
-}
-(function (Color) {
-    let Format;
-    (function (Format) {
-        let CSS;
-        (function (CSS) {
-            function formatRGB(color) {
-                if (color.rgba.a === 1) {
-                    return `rgb(${color.rgba.r}, ${color.rgba.g}, ${color.rgba.b})`;
-                }
-                return Color.Format.CSS.formatRGBA(color);
-            }
-            CSS.formatRGB = formatRGB;
-            function formatRGBA(color) {
-                return `rgba(${color.rgba.r}, ${color.rgba.g}, ${color.rgba.b}, ${+(color.rgba.a).toFixed(2)})`;
-            }
-            CSS.formatRGBA = formatRGBA;
-            function formatHSL(color) {
-                if (color.hsla.a === 1) {
-                    return `hsl(${color.hsla.h}, ${(color.hsla.s * 100).toFixed(2)}%, ${(color.hsla.l * 100).toFixed(2)}%)`;
-                }
-                return Color.Format.CSS.formatHSLA(color);
-            }
-            CSS.formatHSL = formatHSL;
-            function formatHSLA(color) {
-                return `hsla(${color.hsla.h}, ${(color.hsla.s * 100).toFixed(2)}%, ${(color.hsla.l * 100).toFixed(2)}%, ${color.hsla.a.toFixed(2)})`;
-            }
-            CSS.formatHSLA = formatHSLA;
-            function _toTwoDigitHex(n) {
-                const r = n.toString(16);
-                return r.length !== 2 ? '0' + r : r;
-            }
-            /**
-             * Formats the color as #RRGGBB
-             */
-            function formatHex(color) {
-                return `#${_toTwoDigitHex(color.rgba.r)}${_toTwoDigitHex(color.rgba.g)}${_toTwoDigitHex(color.rgba.b)}`;
-            }
-            CSS.formatHex = formatHex;
-            /**
-             * Formats the color as #RRGGBBAA
-             * If 'compact' is set, colors without transparancy will be printed as #RRGGBB
-             */
-            function formatHexA(color, compact = false) {
-                if (compact && color.rgba.a === 1) {
-                    return Color.Format.CSS.formatHex(color);
-                }
-                return `#${_toTwoDigitHex(color.rgba.r)}${_toTwoDigitHex(color.rgba.g)}${_toTwoDigitHex(color.rgba.b)}${_toTwoDigitHex(Math.round(color.rgba.a * 255))}`;
-            }
-            CSS.formatHexA = formatHexA;
-            /**
-             * The default format will use HEX if opaque and RGBA otherwise.
-             */
-            function format(color) {
-                if (color.isOpaque()) {
-                    return Color.Format.CSS.formatHex(color);
-                }
-                return Color.Format.CSS.formatRGBA(color);
-            }
-            CSS.format = format;
-            /**
-             * Converts an Hex color value to a Color.
-             * returns r, g, and b are contained in the set [0, 255]
-             * @param hex string (#RGB, #RGBA, #RRGGBB or #RRGGBBAA).
-             */
-            function parseHex(hex) {
-                const length = hex.length;
-                if (length === 0) {
-                    // Invalid color
-                    return null;
-                }
-                if (hex.charCodeAt(0) !== 35 /* CharCode.Hash */) {
-                    // Does not begin with a #
-                    return null;
-                }
-                if (length === 7) {
-                    // #RRGGBB format
-                    const r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2));
-                    const g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4));
-                    const b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6));
-                    return new Color(new RGBA(r, g, b, 1));
-                }
-                if (length === 9) {
-                    // #RRGGBBAA format
-                    const r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2));
-                    const g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4));
-                    const b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6));
-                    const a = 16 * _parseHexDigit(hex.charCodeAt(7)) + _parseHexDigit(hex.charCodeAt(8));
-                    return new Color(new RGBA(r, g, b, a / 255));
-                }
-                if (length === 4) {
-                    // #RGB format
-                    const r = _parseHexDigit(hex.charCodeAt(1));
-                    const g = _parseHexDigit(hex.charCodeAt(2));
-                    const b = _parseHexDigit(hex.charCodeAt(3));
-                    return new Color(new RGBA(16 * r + r, 16 * g + g, 16 * b + b));
-                }
-                if (length === 5) {
-                    // #RGBA format
-                    const r = _parseHexDigit(hex.charCodeAt(1));
-                    const g = _parseHexDigit(hex.charCodeAt(2));
-                    const b = _parseHexDigit(hex.charCodeAt(3));
-                    const a = _parseHexDigit(hex.charCodeAt(4));
-                    return new Color(new RGBA(16 * r + r, 16 * g + g, 16 * b + b, (16 * a + a) / 255));
-                }
-                // Invalid color
-                return null;
-            }
-            CSS.parseHex = parseHex;
-            function _parseHexDigit(charCode) {
-                switch (charCode) {
-                    case 48 /* CharCode.Digit0 */: return 0;
-                    case 49 /* CharCode.Digit1 */: return 1;
-                    case 50 /* CharCode.Digit2 */: return 2;
-                    case 51 /* CharCode.Digit3 */: return 3;
-                    case 52 /* CharCode.Digit4 */: return 4;
-                    case 53 /* CharCode.Digit5 */: return 5;
-                    case 54 /* CharCode.Digit6 */: return 6;
-                    case 55 /* CharCode.Digit7 */: return 7;
-                    case 56 /* CharCode.Digit8 */: return 8;
-                    case 57 /* CharCode.Digit9 */: return 9;
-                    case 97 /* CharCode.a */: return 10;
-                    case 65 /* CharCode.A */: return 10;
-                    case 98 /* CharCode.b */: return 11;
-                    case 66 /* CharCode.B */: return 11;
-                    case 99 /* CharCode.c */: return 12;
-                    case 67 /* CharCode.C */: return 12;
-                    case 100 /* CharCode.d */: return 13;
-                    case 68 /* CharCode.D */: return 13;
-                    case 101 /* CharCode.e */: return 14;
-                    case 69 /* CharCode.E */: return 14;
-                    case 102 /* CharCode.f */: return 15;
-                    case 70 /* CharCode.F */: return 15;
-                }
-                return 0;
-            }
-        })(CSS = Format.CSS || (Format.CSS = {}));
-    })(Format = Color.Format || (Color.Format = {}));
-})(Color || (Color = {}));

package/dist-cms/monaco-editor/vs/base/common/comparers.js

@@ -1,83 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { Lazy } from './lazy.js';
-// When comparing large numbers of strings it's better for performance to create an
-// Intl.Collator object and use the function provided by its compare property
-// than it is to use String.prototype.localeCompare()
-// A collator with numeric sorting enabled, and no sensitivity to case, accents or diacritics.
-const intlFileNameCollatorBaseNumeric = new Lazy(() => {
-    const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
-    return {
-        collator,
-        collatorIsNumeric: collator.resolvedOptions().numeric
-    };
-});
-// A collator with numeric sorting enabled.
-const intlFileNameCollatorNumeric = new Lazy(() => {
-    const collator = new Intl.Collator(undefined, { numeric: true });
-    return {
-        collator
-    };
-});
-// A collator with numeric sorting enabled, and sensitivity to accents and diacritics but not case.
-const intlFileNameCollatorNumericCaseInsensitive = new Lazy(() => {
-    const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'accent' });
-    return {
-        collator
-    };
-});
-/** Compares filenames without distinguishing the name from the extension. Disambiguates by unicode comparison. */
-export function compareFileNames(one, other, caseSensitive = false) {
-    const a = one || '';
-    const b = other || '';
-    const result = intlFileNameCollatorBaseNumeric.value.collator.compare(a, b);
-    // Using the numeric option will make compare(`foo1`, `foo01`) === 0. Disambiguate.
-    if (intlFileNameCollatorBaseNumeric.value.collatorIsNumeric && result === 0 && a !== b) {
-        return a < b ? -1 : 1;
-    }
-    return result;
-}
-export function compareAnything(one, other, lookFor) {
-    const elementAName = one.toLowerCase();
-    const elementBName = other.toLowerCase();
-    // Sort prefix matches over non prefix matches
-    const prefixCompare = compareByPrefix(one, other, lookFor);
-    if (prefixCompare) {
-        return prefixCompare;
-    }
-    // Sort suffix matches over non suffix matches
-    const elementASuffixMatch = elementAName.endsWith(lookFor);
-    const elementBSuffixMatch = elementBName.endsWith(lookFor);
-    if (elementASuffixMatch !== elementBSuffixMatch) {
-        return elementASuffixMatch ? -1 : 1;
-    }
-    // Understand file names
-    const r = compareFileNames(elementAName, elementBName);
-    if (r !== 0) {
-        return r;
-    }
-    // Compare by name
-    return elementAName.localeCompare(elementBName);
-}
-export function compareByPrefix(one, other, lookFor) {
-    const elementAName = one.toLowerCase();
-    const elementBName = other.toLowerCase();
-    // Sort prefix matches over non prefix matches
-    const elementAPrefixMatch = elementAName.startsWith(lookFor);
-    const elementBPrefixMatch = elementBName.startsWith(lookFor);
-    if (elementAPrefixMatch !== elementBPrefixMatch) {
-        return elementAPrefixMatch ? -1 : 1;
-    }
-    // Same prefix: Sort shorter matches to the top to have those on top that match more precisely
-    else if (elementAPrefixMatch && elementBPrefixMatch) {
-        if (elementAName.length < elementBName.length) {
-            return -1;
-        }
-        if (elementAName.length > elementBName.length) {
-            return 1;
-        }
-    }
-    return 0;
-}

package/dist-cms/monaco-editor/vs/base/common/dataTransfer.js

@@ -1,128 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { distinct } from './arrays.js';
-import { Iterable } from './iterator.js';
-import { generateUuid } from './uuid.js';
-export function createStringDataTransferItem(stringOrPromise) {
-    return {
-        asString: async () => stringOrPromise,
-        asFile: () => undefined,
-        value: typeof stringOrPromise === 'string' ? stringOrPromise : undefined,
-    };
-}
-export function createFileDataTransferItem(fileName, uri, data) {
-    const file = { id: generateUuid(), name: fileName, uri, data };
-    return {
-        asString: async () => '',
-        asFile: () => file,
-        value: undefined,
-    };
-}
-export class VSDataTransfer {
-    constructor() {
-        this._entries = new Map();
-    }
-    get size() {
-        let size = 0;
-        for (const _ of this._entries) {
-            size++;
-        }
-        return size;
-    }
-    has(mimeType) {
-        return this._entries.has(this.toKey(mimeType));
-    }
-    matches(pattern) {
-        const mimes = [...this._entries.keys()];
-        if (Iterable.some(this, ([_, item]) => item.asFile())) {
-            mimes.push('files');
-        }
-        return matchesMimeType_normalized(normalizeMimeType(pattern), mimes);
-    }
-    get(mimeType) {
-        return this._entries.get(this.toKey(mimeType))?.[0];
-    }
-    /**
-     * Add a new entry to this data transfer.
-     *
-     * This does not replace existing entries for `mimeType`.
-     */
-    append(mimeType, value) {
-        const existing = this._entries.get(mimeType);
-        if (existing) {
-            existing.push(value);
-        }
-        else {
-            this._entries.set(this.toKey(mimeType), [value]);
-        }
-    }
-    /**
-     * Set the entry for a given mime type.
-     *
-     * This replaces all existing entries for `mimeType`.
-     */
-    replace(mimeType, value) {
-        this._entries.set(this.toKey(mimeType), [value]);
-    }
-    /**
-     * Remove all entries for `mimeType`.
-     */
-    delete(mimeType) {
-        this._entries.delete(this.toKey(mimeType));
-    }
-    /**
-     * Iterate over all `[mime, item]` pairs in this data transfer.
-     *
-     * There may be multiple entries for each mime type.
-     */
-    *[Symbol.iterator]() {
-        for (const [mine, items] of this._entries) {
-            for (const item of items) {
-                yield [mine, item];
-            }
-        }
-    }
-    toKey(mimeType) {
-        return normalizeMimeType(mimeType);
-    }
-}
-function normalizeMimeType(mimeType) {
-    return mimeType.toLowerCase();
-}
-export function matchesMimeType(pattern, mimeTypes) {
-    return matchesMimeType_normalized(normalizeMimeType(pattern), mimeTypes.map(normalizeMimeType));
-}
-function matchesMimeType_normalized(normalizedPattern, normalizedMimeTypes) {
-    // Anything wildcard
-    if (normalizedPattern === '*/*') {
-        return normalizedMimeTypes.length > 0;
-    }
-    // Exact match
-    if (normalizedMimeTypes.includes(normalizedPattern)) {
-        return true;
-    }
-    // Wildcard, such as `image/*`
-    const wildcard = normalizedPattern.match(/^([a-z]+)\/([a-z]+|\*)$/i);
-    if (!wildcard) {
-        return false;
-    }
-    const [_, type, subtype] = wildcard;
-    if (subtype === '*') {
-        return normalizedMimeTypes.some(mime => mime.startsWith(type + '/'));
-    }
-    return false;
-}
-export const UriList = Object.freeze({
-    // http://amundsen.com/hypermedia/urilist/
-    create: (entries) => {
-        return distinct(entries.map(x => x.toString())).join('\r\n');
-    },
-    split: (str) => {
-        return str.split('\r\n');
-    },
-    parse: (str) => {
-        return UriList.split(str).filter(value => !value.startsWith('#'));
-    }
-});

package/dist-cms/monaco-editor/vs/base/common/decorators.js

@@ -1,30 +0,0 @@
-export function memoize(_target, key, descriptor) {
-    let fnKey = null;
-    let fn = null;
-    if (typeof descriptor.value === 'function') {
-        fnKey = 'value';
-        fn = descriptor.value;
-        if (fn.length !== 0) {
-            console.warn('Memoize should only be used in functions with zero parameters');
-        }
-    }
-    else if (typeof descriptor.get === 'function') {
-        fnKey = 'get';
-        fn = descriptor.get;
-    }
-    if (!fn) {
-        throw new Error('not supported');
-    }
-    const memoizeKey = `$memoize$${key}`;
-    descriptor[fnKey] = function (...args) {
-        if (!this.hasOwnProperty(memoizeKey)) {
-            Object.defineProperty(this, memoizeKey, {
-                configurable: false,
-                enumerable: false,
-                writable: false,
-                value: fn.apply(this, args)
-            });
-        }
-        return this[memoizeKey];
-    };
-}