claude-flow-novice 2.3.1 → 2.3.3

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/base/common/color.js

@@ -0,0 +1,462 @@
+/*---------------------------------------------------------------------------------------------
+ *  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);
+    }
+}
+Color.white = new Color(new RGBA(255, 255, 255, 1));
+Color.black = new Color(new RGBA(0, 0, 0, 1));
+Color.red = new Color(new RGBA(255, 0, 0, 1));
+Color.blue = new Color(new RGBA(0, 0, 255, 1));
+Color.green = new Color(new RGBA(0, 255, 0, 1));
+Color.cyan = new Color(new RGBA(0, 255, 255, 1));
+Color.lightgrey = new Color(new RGBA(211, 211, 211, 1));
+Color.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/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/base/common/comparers.js

@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------------------------
+ *  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/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/base/common/dataTransfer.js

@@ -0,0 +1,129 @@
+/*---------------------------------------------------------------------------------------------
+ *  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) {
+        var _a;
+        return (_a = this._entries.get(this.toKey(mimeType))) === null || _a === void 0 ? void 0 : _a[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('#'));
+    }
+});