{"version":3,"file":"static/js/vendors-bdb2c300.5ee59106.js","mappings":"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","sources":["../node_modules/tinycolor2/tinycolor.js","../node_modules/tippy.js/src/constants.ts","../node_modules/tippy.js/src/utils.ts","../node_modules/tippy.js/src/dom-utils.ts","../node_modules/tippy.js/src/bindGlobalEventListeners.ts","../node_modules/tippy.js/src/browser.ts","../node_modules/tippy.js/src/props.ts","../node_modules/tippy.js/src/template.ts","../node_modules/tippy.js/src/createTippy.ts","../node_modules/tippy.js/src/index.ts","../node_modules/tippy.js/src/addons/createSingleton.ts","../node_modules/tippy.js/build/base.js"],"sourcesContent":["// TinyColor v1.4.2\n// https://github.com/bgrins/TinyColor\n// Brian Grinstead, MIT License\n\n(function(Math) {\n\nvar trimLeft = /^\\s+/,\n    trimRight = /\\s+$/,\n    tinyCounter = 0,\n    mathRound = Math.round,\n    mathMin = Math.min,\n    mathMax = Math.max,\n    mathRandom = Math.random;\n\nfunction tinycolor (color, opts) {\n\n    color = (color) ? color : '';\n    opts = opts || { };\n\n    // If input is already a tinycolor, return itself\n    if (color instanceof tinycolor) {\n       return color;\n    }\n    // If we are called as a function, call using new instead\n    if (!(this instanceof tinycolor)) {\n        return new tinycolor(color, opts);\n    }\n\n    var rgb = inputToRGB(color);\n    this._originalInput = color,\n    this._r = rgb.r,\n    this._g = rgb.g,\n    this._b = rgb.b,\n    this._a = rgb.a,\n    this._roundA = mathRound(100*this._a) / 100,\n    this._format = opts.format || rgb.format;\n    this._gradientType = opts.gradientType;\n\n    // Don't let the range of [0,255] come back in [0,1].\n    // Potentially lose a little bit of precision here, but will fix issues where\n    // .5 gets interpreted as half of the total, instead of half of 1\n    // If it was supposed to be 128, this was already taken care of by `inputToRgb`\n    if (this._r < 1) { this._r = mathRound(this._r); }\n    if (this._g < 1) { this._g = mathRound(this._g); }\n    if (this._b < 1) { this._b = mathRound(this._b); }\n\n    this._ok = rgb.ok;\n    this._tc_id = tinyCounter++;\n}\n\ntinycolor.prototype = {\n    isDark: function() {\n        return this.getBrightness() < 128;\n    },\n    isLight: function() {\n        return !this.isDark();\n    },\n    isValid: function() {\n        return this._ok;\n    },\n    getOriginalInput: function() {\n      return this._originalInput;\n    },\n    getFormat: function() {\n        return this._format;\n    },\n    getAlpha: function() {\n        return this._a;\n    },\n    getBrightness: function() {\n        //http://www.w3.org/TR/AERT#color-contrast\n        var rgb = this.toRgb();\n        return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;\n    },\n    getLuminance: function() {\n        //http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef\n        var rgb = this.toRgb();\n        var RsRGB, GsRGB, BsRGB, R, G, B;\n        RsRGB = rgb.r/255;\n        GsRGB = rgb.g/255;\n        BsRGB = rgb.b/255;\n\n        if (RsRGB <= 0.03928) {R = RsRGB / 12.92;} else {R = Math.pow(((RsRGB + 0.055) / 1.055), 2.4);}\n        if (GsRGB <= 0.03928) {G = GsRGB / 12.92;} else {G = Math.pow(((GsRGB + 0.055) / 1.055), 2.4);}\n        if (BsRGB <= 0.03928) {B = BsRGB / 12.92;} else {B = Math.pow(((BsRGB + 0.055) / 1.055), 2.4);}\n        return (0.2126 * R) + (0.7152 * G) + (0.0722 * B);\n    },\n    setAlpha: function(value) {\n        this._a = boundAlpha(value);\n        this._roundA = mathRound(100*this._a) / 100;\n        return this;\n    },\n    toHsv: function() {\n        var hsv = rgbToHsv(this._r, this._g, this._b);\n        return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this._a };\n    },\n    toHsvString: function() {\n        var hsv = rgbToHsv(this._r, this._g, this._b);\n        var h = mathRound(hsv.h * 360), s = mathRound(hsv.s * 100), v = mathRound(hsv.v * 100);\n        return (this._a == 1) ?\n          \"hsv(\"  + h + \", \" + s + \"%, \" + v + \"%)\" :\n          \"hsva(\" + h + \", \" + s + \"%, \" + v + \"%, \"+ this._roundA + \")\";\n    },\n    toHsl: function() {\n        var hsl = rgbToHsl(this._r, this._g, this._b);\n        return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this._a };\n    },\n    toHslString: function() {\n        var hsl = rgbToHsl(this._r, this._g, this._b);\n        var h = mathRound(hsl.h * 360), s = mathRound(hsl.s * 100), l = mathRound(hsl.l * 100);\n        return (this._a == 1) ?\n          \"hsl(\"  + h + \", \" + s + \"%, \" + l + \"%)\" :\n          \"hsla(\" + h + \", \" + s + \"%, \" + l + \"%, \"+ this._roundA + \")\";\n    },\n    toHex: function(allow3Char) {\n        return rgbToHex(this._r, this._g, this._b, allow3Char);\n    },\n    toHexString: function(allow3Char) {\n        return '#' + this.toHex(allow3Char);\n    },\n    toHex8: function(allow4Char) {\n        return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char);\n    },\n    toHex8String: function(allow4Char) {\n        return '#' + this.toHex8(allow4Char);\n    },\n    toRgb: function() {\n        return { r: mathRound(this._r), g: mathRound(this._g), b: mathRound(this._b), a: this._a };\n    },\n    toRgbString: function() {\n        return (this._a == 1) ?\n          \"rgb(\"  + mathRound(this._r) + \", \" + mathRound(this._g) + \", \" + mathRound(this._b) + \")\" :\n          \"rgba(\" + mathRound(this._r) + \", \" + mathRound(this._g) + \", \" + mathRound(this._b) + \", \" + this._roundA + \")\";\n    },\n    toPercentageRgb: function() {\n        return { r: mathRound(bound01(this._r, 255) * 100) + \"%\", g: mathRound(bound01(this._g, 255) * 100) + \"%\", b: mathRound(bound01(this._b, 255) * 100) + \"%\", a: this._a };\n    },\n    toPercentageRgbString: function() {\n        return (this._a == 1) ?\n          \"rgb(\"  + mathRound(bound01(this._r, 255) * 100) + \"%, \" + mathRound(bound01(this._g, 255) * 100) + \"%, \" + mathRound(bound01(this._b, 255) * 100) + \"%)\" :\n          \"rgba(\" + mathRound(bound01(this._r, 255) * 100) + \"%, \" + mathRound(bound01(this._g, 255) * 100) + \"%, \" + mathRound(bound01(this._b, 255) * 100) + \"%, \" + this._roundA + \")\";\n    },\n    toName: function() {\n        if (this._a === 0) {\n            return \"transparent\";\n        }\n\n        if (this._a < 1) {\n            return false;\n        }\n\n        return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;\n    },\n    toFilter: function(secondColor) {\n        var hex8String = '#' + rgbaToArgbHex(this._r, this._g, this._b, this._a);\n        var secondHex8String = hex8String;\n        var gradientType = this._gradientType ? \"GradientType = 1, \" : \"\";\n\n        if (secondColor) {\n            var s = tinycolor(secondColor);\n            secondHex8String = '#' + rgbaToArgbHex(s._r, s._g, s._b, s._a);\n        }\n\n        return \"progid:DXImageTransform.Microsoft.gradient(\"+gradientType+\"startColorstr=\"+hex8String+\",endColorstr=\"+secondHex8String+\")\";\n    },\n    toString: function(format) {\n        var formatSet = !!format;\n        format = format || this._format;\n\n        var formattedString = false;\n        var hasAlpha = this._a < 1 && this._a >= 0;\n        var needsAlphaFormat = !formatSet && hasAlpha && (format === \"hex\" || format === \"hex6\" || format === \"hex3\" || format === \"hex4\" || format === \"hex8\" || format === \"name\");\n\n        if (needsAlphaFormat) {\n            // Special case for \"transparent\", all other non-alpha formats\n            // will return rgba when there is transparency.\n            if (format === \"name\" && this._a === 0) {\n                return this.toName();\n            }\n            return this.toRgbString();\n        }\n        if (format === \"rgb\") {\n            formattedString = this.toRgbString();\n        }\n        if (format === \"prgb\") {\n            formattedString = this.toPercentageRgbString();\n        }\n        if (format === \"hex\" || format === \"hex6\") {\n            formattedString = this.toHexString();\n        }\n        if (format === \"hex3\") {\n            formattedString = this.toHexString(true);\n        }\n        if (format === \"hex4\") {\n            formattedString = this.toHex8String(true);\n        }\n        if (format === \"hex8\") {\n            formattedString = this.toHex8String();\n        }\n        if (format === \"name\") {\n            formattedString = this.toName();\n        }\n        if (format === \"hsl\") {\n            formattedString = this.toHslString();\n        }\n        if (format === \"hsv\") {\n            formattedString = this.toHsvString();\n        }\n\n        return formattedString || this.toHexString();\n    },\n    clone: function() {\n        return tinycolor(this.toString());\n    },\n\n    _applyModification: function(fn, args) {\n        var color = fn.apply(null, [this].concat([].slice.call(args)));\n        this._r = color._r;\n        this._g = color._g;\n        this._b = color._b;\n        this.setAlpha(color._a);\n        return this;\n    },\n    lighten: function() {\n        return this._applyModification(lighten, arguments);\n    },\n    brighten: function() {\n        return this._applyModification(brighten, arguments);\n    },\n    darken: function() {\n        return this._applyModification(darken, arguments);\n    },\n    desaturate: function() {\n        return this._applyModification(desaturate, arguments);\n    },\n    saturate: function() {\n        return this._applyModification(saturate, arguments);\n    },\n    greyscale: function() {\n        return this._applyModification(greyscale, arguments);\n    },\n    spin: function() {\n        return this._applyModification(spin, arguments);\n    },\n\n    _applyCombination: function(fn, args) {\n        return fn.apply(null, [this].concat([].slice.call(args)));\n    },\n    analogous: function() {\n        return this._applyCombination(analogous, arguments);\n    },\n    complement: function() {\n        return this._applyCombination(complement, arguments);\n    },\n    monochromatic: function() {\n        return this._applyCombination(monochromatic, arguments);\n    },\n    splitcomplement: function() {\n        return this._applyCombination(splitcomplement, arguments);\n    },\n    triad: function() {\n        return this._applyCombination(triad, arguments);\n    },\n    tetrad: function() {\n        return this._applyCombination(tetrad, arguments);\n    }\n};\n\n// If input is an object, force 1 into \"1.0\" to handle ratios properly\n// String input requires \"1.0\" as input, so 1 will be treated as 1\ntinycolor.fromRatio = function(color, opts) {\n    if (typeof color == \"object\") {\n        var newColor = {};\n        for (var i in color) {\n            if (color.hasOwnProperty(i)) {\n                if (i === \"a\") {\n                    newColor[i] = color[i];\n                }\n                else {\n                    newColor[i] = convertToPercentage(color[i]);\n                }\n            }\n        }\n        color = newColor;\n    }\n\n    return tinycolor(color, opts);\n};\n\n// Given a string or object, convert that input to RGB\n// Possible string inputs:\n//\n//     \"red\"\n//     \"#f00\" or \"f00\"\n//     \"#ff0000\" or \"ff0000\"\n//     \"#ff000000\" or \"ff000000\"\n//     \"rgb 255 0 0\" or \"rgb (255, 0, 0)\"\n//     \"rgb 1.0 0 0\" or \"rgb (1, 0, 0)\"\n//     \"rgba (255, 0, 0, 1)\" or \"rgba 255, 0, 0, 1\"\n//     \"rgba (1.0, 0, 0, 1)\" or \"rgba 1.0, 0, 0, 1\"\n//     \"hsl(0, 100%, 50%)\" or \"hsl 0 100% 50%\"\n//     \"hsla(0, 100%, 50%, 1)\" or \"hsla 0 100% 50%, 1\"\n//     \"hsv(0, 100%, 100%)\" or \"hsv 0 100% 100%\"\n//\nfunction inputToRGB(color) {\n\n    var rgb = { r: 0, g: 0, b: 0 };\n    var a = 1;\n    var s = null;\n    var v = null;\n    var l = null;\n    var ok = false;\n    var format = false;\n\n    if (typeof color == \"string\") {\n        color = stringInputToObject(color);\n    }\n\n    if (typeof color == \"object\") {\n        if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {\n            rgb = rgbToRgb(color.r, color.g, color.b);\n            ok = true;\n            format = String(color.r).substr(-1) === \"%\" ? \"prgb\" : \"rgb\";\n        }\n        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {\n            s = convertToPercentage(color.s);\n            v = convertToPercentage(color.v);\n            rgb = hsvToRgb(color.h, s, v);\n            ok = true;\n            format = \"hsv\";\n        }\n        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {\n            s = convertToPercentage(color.s);\n            l = convertToPercentage(color.l);\n            rgb = hslToRgb(color.h, s, l);\n            ok = true;\n            format = \"hsl\";\n        }\n\n        if (color.hasOwnProperty(\"a\")) {\n            a = color.a;\n        }\n    }\n\n    a = boundAlpha(a);\n\n    return {\n        ok: ok,\n        format: color.format || format,\n        r: mathMin(255, mathMax(rgb.r, 0)),\n        g: mathMin(255, mathMax(rgb.g, 0)),\n        b: mathMin(255, mathMax(rgb.b, 0)),\n        a: a\n    };\n}\n\n\n// Conversion Functions\n// --------------------\n\n// `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:\n// <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>\n\n// `rgbToRgb`\n// Handle bounds / percentage checking to conform to CSS color spec\n// <http://www.w3.org/TR/css3-color/>\n// *Assumes:* r, g, b in [0, 255] or [0, 1]\n// *Returns:* { r, g, b } in [0, 255]\nfunction rgbToRgb(r, g, b){\n    return {\n        r: bound01(r, 255) * 255,\n        g: bound01(g, 255) * 255,\n        b: bound01(b, 255) * 255\n    };\n}\n\n// `rgbToHsl`\n// Converts an RGB color value to HSL.\n// *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]\n// *Returns:* { h, s, l } in [0,1]\nfunction rgbToHsl(r, g, b) {\n\n    r = bound01(r, 255);\n    g = bound01(g, 255);\n    b = bound01(b, 255);\n\n    var max = mathMax(r, g, b), min = mathMin(r, g, b);\n    var h, s, l = (max + min) / 2;\n\n    if(max == min) {\n        h = s = 0; // achromatic\n    }\n    else {\n        var d = max - min;\n        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);\n        switch(max) {\n            case r: h = (g - b) / d + (g < b ? 6 : 0); break;\n            case g: h = (b - r) / d + 2; break;\n            case b: h = (r - g) / d + 4; break;\n        }\n\n        h /= 6;\n    }\n\n    return { h: h, s: s, l: l };\n}\n\n// `hslToRgb`\n// Converts an HSL color value to RGB.\n// *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]\n// *Returns:* { r, g, b } in the set [0, 255]\nfunction hslToRgb(h, s, l) {\n    var r, g, b;\n\n    h = bound01(h, 360);\n    s = bound01(s, 100);\n    l = bound01(l, 100);\n\n    function hue2rgb(p, q, t) {\n        if(t < 0) t += 1;\n        if(t > 1) t -= 1;\n        if(t < 1/6) return p + (q - p) * 6 * t;\n        if(t < 1/2) return q;\n        if(t < 2/3) return p + (q - p) * (2/3 - t) * 6;\n        return p;\n    }\n\n    if(s === 0) {\n        r = g = b = l; // achromatic\n    }\n    else {\n        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n        var p = 2 * l - q;\n        r = hue2rgb(p, q, h + 1/3);\n        g = hue2rgb(p, q, h);\n        b = hue2rgb(p, q, h - 1/3);\n    }\n\n    return { r: r * 255, g: g * 255, b: b * 255 };\n}\n\n// `rgbToHsv`\n// Converts an RGB color value to HSV\n// *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]\n// *Returns:* { h, s, v } in [0,1]\nfunction rgbToHsv(r, g, b) {\n\n    r = bound01(r, 255);\n    g = bound01(g, 255);\n    b = bound01(b, 255);\n\n    var max = mathMax(r, g, b), min = mathMin(r, g, b);\n    var h, s, v = max;\n\n    var d = max - min;\n    s = max === 0 ? 0 : d / max;\n\n    if(max == min) {\n        h = 0; // achromatic\n    }\n    else {\n        switch(max) {\n            case r: h = (g - b) / d + (g < b ? 6 : 0); break;\n            case g: h = (b - r) / d + 2; break;\n            case b: h = (r - g) / d + 4; break;\n        }\n        h /= 6;\n    }\n    return { h: h, s: s, v: v };\n}\n\n// `hsvToRgb`\n// Converts an HSV color value to RGB.\n// *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]\n// *Returns:* { r, g, b } in the set [0, 255]\n function hsvToRgb(h, s, v) {\n\n    h = bound01(h, 360) * 6;\n    s = bound01(s, 100);\n    v = bound01(v, 100);\n\n    var i = Math.floor(h),\n        f = h - i,\n        p = v * (1 - s),\n        q = v * (1 - f * s),\n        t = v * (1 - (1 - f) * s),\n        mod = i % 6,\n        r = [v, q, p, p, t, v][mod],\n        g = [t, v, v, q, p, p][mod],\n        b = [p, p, t, v, v, q][mod];\n\n    return { r: r * 255, g: g * 255, b: b * 255 };\n}\n\n// `rgbToHex`\n// Converts an RGB color to hex\n// Assumes r, g, and b are contained in the set [0, 255]\n// Returns a 3 or 6 character hex\nfunction rgbToHex(r, g, b, allow3Char) {\n\n    var hex = [\n        pad2(mathRound(r).toString(16)),\n        pad2(mathRound(g).toString(16)),\n        pad2(mathRound(b).toString(16))\n    ];\n\n    // Return a 3 character hex if possible\n    if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) {\n        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);\n    }\n\n    return hex.join(\"\");\n}\n\n// `rgbaToHex`\n// Converts an RGBA color plus alpha transparency to hex\n// Assumes r, g, b are contained in the set [0, 255] and\n// a in [0, 1]. Returns a 4 or 8 character rgba hex\nfunction rgbaToHex(r, g, b, a, allow4Char) {\n\n    var hex = [\n        pad2(mathRound(r).toString(16)),\n        pad2(mathRound(g).toString(16)),\n        pad2(mathRound(b).toString(16)),\n        pad2(convertDecimalToHex(a))\n    ];\n\n    // Return a 4 character hex if possible\n    if (allow4Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1) && hex[3].charAt(0) == hex[3].charAt(1)) {\n        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);\n    }\n\n    return hex.join(\"\");\n}\n\n// `rgbaToArgbHex`\n// Converts an RGBA color to an ARGB Hex8 string\n// Rarely used, but required for \"toFilter()\"\nfunction rgbaToArgbHex(r, g, b, a) {\n\n    var hex = [\n        pad2(convertDecimalToHex(a)),\n        pad2(mathRound(r).toString(16)),\n        pad2(mathRound(g).toString(16)),\n        pad2(mathRound(b).toString(16))\n    ];\n\n    return hex.join(\"\");\n}\n\n// `equals`\n// Can be called with any tinycolor input\ntinycolor.equals = function (color1, color2) {\n    if (!color1 || !color2) { return false; }\n    return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();\n};\n\ntinycolor.random = function() {\n    return tinycolor.fromRatio({\n        r: mathRandom(),\n        g: mathRandom(),\n        b: mathRandom()\n    });\n};\n\n\n// Modification Functions\n// ----------------------\n// Thanks to less.js for some of the basics here\n// <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js>\n\nfunction desaturate(color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var hsl = tinycolor(color).toHsl();\n    hsl.s -= amount / 100;\n    hsl.s = clamp01(hsl.s);\n    return tinycolor(hsl);\n}\n\nfunction saturate(color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var hsl = tinycolor(color).toHsl();\n    hsl.s += amount / 100;\n    hsl.s = clamp01(hsl.s);\n    return tinycolor(hsl);\n}\n\nfunction greyscale(color) {\n    return tinycolor(color).desaturate(100);\n}\n\nfunction lighten (color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var hsl = tinycolor(color).toHsl();\n    hsl.l += amount / 100;\n    hsl.l = clamp01(hsl.l);\n    return tinycolor(hsl);\n}\n\nfunction brighten(color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var rgb = tinycolor(color).toRgb();\n    rgb.r = mathMax(0, mathMin(255, rgb.r - mathRound(255 * - (amount / 100))));\n    rgb.g = mathMax(0, mathMin(255, rgb.g - mathRound(255 * - (amount / 100))));\n    rgb.b = mathMax(0, mathMin(255, rgb.b - mathRound(255 * - (amount / 100))));\n    return tinycolor(rgb);\n}\n\nfunction darken (color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var hsl = tinycolor(color).toHsl();\n    hsl.l -= amount / 100;\n    hsl.l = clamp01(hsl.l);\n    return tinycolor(hsl);\n}\n\n// Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.\n// Values outside of this range will be wrapped into this range.\nfunction spin(color, amount) {\n    var hsl = tinycolor(color).toHsl();\n    var hue = (hsl.h + amount) % 360;\n    hsl.h = hue < 0 ? 360 + hue : hue;\n    return tinycolor(hsl);\n}\n\n// Combination Functions\n// ---------------------\n// Thanks to jQuery xColor for some of the ideas behind these\n// <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js>\n\nfunction complement(color) {\n    var hsl = tinycolor(color).toHsl();\n    hsl.h = (hsl.h + 180) % 360;\n    return tinycolor(hsl);\n}\n\nfunction triad(color) {\n    var hsl = tinycolor(color).toHsl();\n    var h = hsl.h;\n    return [\n        tinycolor(color),\n        tinycolor({ h: (h + 120) % 360, s: hsl.s, l: hsl.l }),\n        tinycolor({ h: (h + 240) % 360, s: hsl.s, l: hsl.l })\n    ];\n}\n\nfunction tetrad(color) {\n    var hsl = tinycolor(color).toHsl();\n    var h = hsl.h;\n    return [\n        tinycolor(color),\n        tinycolor({ h: (h + 90) % 360, s: hsl.s, l: hsl.l }),\n        tinycolor({ h: (h + 180) % 360, s: hsl.s, l: hsl.l }),\n        tinycolor({ h: (h + 270) % 360, s: hsl.s, l: hsl.l })\n    ];\n}\n\nfunction splitcomplement(color) {\n    var hsl = tinycolor(color).toHsl();\n    var h = hsl.h;\n    return [\n        tinycolor(color),\n        tinycolor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l}),\n        tinycolor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l})\n    ];\n}\n\nfunction analogous(color, results, slices) {\n    results = results || 6;\n    slices = slices || 30;\n\n    var hsl = tinycolor(color).toHsl();\n    var part = 360 / slices;\n    var ret = [tinycolor(color)];\n\n    for (hsl.h = ((hsl.h - (part * results >> 1)) + 720) % 360; --results; ) {\n        hsl.h = (hsl.h + part) % 360;\n        ret.push(tinycolor(hsl));\n    }\n    return ret;\n}\n\nfunction monochromatic(color, results) {\n    results = results || 6;\n    var hsv = tinycolor(color).toHsv();\n    var h = hsv.h, s = hsv.s, v = hsv.v;\n    var ret = [];\n    var modification = 1 / results;\n\n    while (results--) {\n        ret.push(tinycolor({ h: h, s: s, v: v}));\n        v = (v + modification) % 1;\n    }\n\n    return ret;\n}\n\n// Utility Functions\n// ---------------------\n\ntinycolor.mix = function(color1, color2, amount) {\n    amount = (amount === 0) ? 0 : (amount || 50);\n\n    var rgb1 = tinycolor(color1).toRgb();\n    var rgb2 = tinycolor(color2).toRgb();\n\n    var p = amount / 100;\n\n    var rgba = {\n        r: ((rgb2.r - rgb1.r) * p) + rgb1.r,\n        g: ((rgb2.g - rgb1.g) * p) + rgb1.g,\n        b: ((rgb2.b - rgb1.b) * p) + rgb1.b,\n        a: ((rgb2.a - rgb1.a) * p) + rgb1.a\n    };\n\n    return tinycolor(rgba);\n};\n\n\n// Readability Functions\n// ---------------------\n// <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)\n\n// `contrast`\n// Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)\ntinycolor.readability = function(color1, color2) {\n    var c1 = tinycolor(color1);\n    var c2 = tinycolor(color2);\n    return (Math.max(c1.getLuminance(),c2.getLuminance())+0.05) / (Math.min(c1.getLuminance(),c2.getLuminance())+0.05);\n};\n\n// `isReadable`\n// Ensure that foreground and background color combinations meet WCAG2 guidelines.\n// The third argument is an optional Object.\n//      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';\n//      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.\n// If the entire object is absent, isReadable defaults to {level:\"AA\",size:\"small\"}.\n\n// *Example*\n//    tinycolor.isReadable(\"#000\", \"#111\") => false\n//    tinycolor.isReadable(\"#000\", \"#111\",{level:\"AA\",size:\"large\"}) => false\ntinycolor.isReadable = function(color1, color2, wcag2) {\n    var readability = tinycolor.readability(color1, color2);\n    var wcag2Parms, out;\n\n    out = false;\n\n    wcag2Parms = validateWCAG2Parms(wcag2);\n    switch (wcag2Parms.level + wcag2Parms.size) {\n        case \"AAsmall\":\n        case \"AAAlarge\":\n            out = readability >= 4.5;\n            break;\n        case \"AAlarge\":\n            out = readability >= 3;\n            break;\n        case \"AAAsmall\":\n            out = readability >= 7;\n            break;\n    }\n    return out;\n\n};\n\n// `mostReadable`\n// Given a base color and a list of possible foreground or background\n// colors for that base, returns the most readable color.\n// Optionally returns Black or White if the most readable color is unreadable.\n// *Example*\n//    tinycolor.mostReadable(tinycolor.mostReadable(\"#123\", [\"#124\", \"#125\"],{includeFallbackColors:false}).toHexString(); // \"#112255\"\n//    tinycolor.mostReadable(tinycolor.mostReadable(\"#123\", [\"#124\", \"#125\"],{includeFallbackColors:true}).toHexString();  // \"#ffffff\"\n//    tinycolor.mostReadable(\"#a8015a\", [\"#faf3f3\"],{includeFallbackColors:true,level:\"AAA\",size:\"large\"}).toHexString(); // \"#faf3f3\"\n//    tinycolor.mostReadable(\"#a8015a\", [\"#faf3f3\"],{includeFallbackColors:true,level:\"AAA\",size:\"small\"}).toHexString(); // \"#ffffff\"\ntinycolor.mostReadable = function(baseColor, colorList, args) {\n    var bestColor = null;\n    var bestScore = 0;\n    var readability;\n    var includeFallbackColors, level, size ;\n    args = args || {};\n    includeFallbackColors = args.includeFallbackColors ;\n    level = args.level;\n    size = args.size;\n\n    for (var i= 0; i < colorList.length ; i++) {\n        readability = tinycolor.readability(baseColor, colorList[i]);\n        if (readability > bestScore) {\n            bestScore = readability;\n            bestColor = tinycolor(colorList[i]);\n        }\n    }\n\n    if (tinycolor.isReadable(baseColor, bestColor, {\"level\":level,\"size\":size}) || !includeFallbackColors) {\n        return bestColor;\n    }\n    else {\n        args.includeFallbackColors=false;\n        return tinycolor.mostReadable(baseColor,[\"#fff\", \"#000\"],args);\n    }\n};\n\n\n// Big List of Colors\n// ------------------\n// <http://www.w3.org/TR/css3-color/#svg-color>\nvar names = tinycolor.names = {\n    aliceblue: \"f0f8ff\",\n    antiquewhite: \"faebd7\",\n    aqua: \"0ff\",\n    aquamarine: \"7fffd4\",\n    azure: \"f0ffff\",\n    beige: \"f5f5dc\",\n    bisque: \"ffe4c4\",\n    black: \"000\",\n    blanchedalmond: \"ffebcd\",\n    blue: \"00f\",\n    blueviolet: \"8a2be2\",\n    brown: \"a52a2a\",\n    burlywood: \"deb887\",\n    burntsienna: \"ea7e5d\",\n    cadetblue: \"5f9ea0\",\n    chartreuse: \"7fff00\",\n    chocolate: \"d2691e\",\n    coral: \"ff7f50\",\n    cornflowerblue: \"6495ed\",\n    cornsilk: \"fff8dc\",\n    crimson: \"dc143c\",\n    cyan: \"0ff\",\n    darkblue: \"00008b\",\n    darkcyan: \"008b8b\",\n    darkgoldenrod: \"b8860b\",\n    darkgray: \"a9a9a9\",\n    darkgreen: \"006400\",\n    darkgrey: \"a9a9a9\",\n    darkkhaki: \"bdb76b\",\n    darkmagenta: \"8b008b\",\n    darkolivegreen: \"556b2f\",\n    darkorange: \"ff8c00\",\n    darkorchid: \"9932cc\",\n    darkred: \"8b0000\",\n    darksalmon: \"e9967a\",\n    darkseagreen: \"8fbc8f\",\n    darkslateblue: \"483d8b\",\n    darkslategray: \"2f4f4f\",\n    darkslategrey: \"2f4f4f\",\n    darkturquoise: \"00ced1\",\n    darkviolet: \"9400d3\",\n    deeppink: \"ff1493\",\n    deepskyblue: \"00bfff\",\n    dimgray: \"696969\",\n    dimgrey: \"696969\",\n    dodgerblue: \"1e90ff\",\n    firebrick: \"b22222\",\n    floralwhite: \"fffaf0\",\n    forestgreen: \"228b22\",\n    fuchsia: \"f0f\",\n    gainsboro: \"dcdcdc\",\n    ghostwhite: \"f8f8ff\",\n    gold: \"ffd700\",\n    goldenrod: \"daa520\",\n    gray: \"808080\",\n    green: \"008000\",\n    greenyellow: \"adff2f\",\n    grey: \"808080\",\n    honeydew: \"f0fff0\",\n    hotpink: \"ff69b4\",\n    indianred: \"cd5c5c\",\n    indigo: \"4b0082\",\n    ivory: \"fffff0\",\n    khaki: \"f0e68c\",\n    lavender: \"e6e6fa\",\n    lavenderblush: \"fff0f5\",\n    lawngreen: \"7cfc00\",\n    lemonchiffon: \"fffacd\",\n    lightblue: \"add8e6\",\n    lightcoral: \"f08080\",\n    lightcyan: \"e0ffff\",\n    lightgoldenrodyellow: \"fafad2\",\n    lightgray: \"d3d3d3\",\n    lightgreen: \"90ee90\",\n    lightgrey: \"d3d3d3\",\n    lightpink: \"ffb6c1\",\n    lightsalmon: \"ffa07a\",\n    lightseagreen: \"20b2aa\",\n    lightskyblue: \"87cefa\",\n    lightslategray: \"789\",\n    lightslategrey: \"789\",\n    lightsteelblue: \"b0c4de\",\n    lightyellow: \"ffffe0\",\n    lime: \"0f0\",\n    limegreen: \"32cd32\",\n    linen: \"faf0e6\",\n    magenta: \"f0f\",\n    maroon: \"800000\",\n    mediumaquamarine: \"66cdaa\",\n    mediumblue: \"0000cd\",\n    mediumorchid: \"ba55d3\",\n    mediumpurple: \"9370db\",\n    mediumseagreen: \"3cb371\",\n    mediumslateblue: \"7b68ee\",\n    mediumspringgreen: \"00fa9a\",\n    mediumturquoise: \"48d1cc\",\n    mediumvioletred: \"c71585\",\n    midnightblue: \"191970\",\n    mintcream: \"f5fffa\",\n    mistyrose: \"ffe4e1\",\n    moccasin: \"ffe4b5\",\n    navajowhite: \"ffdead\",\n    navy: \"000080\",\n    oldlace: \"fdf5e6\",\n    olive: \"808000\",\n    olivedrab: \"6b8e23\",\n    orange: \"ffa500\",\n    orangered: \"ff4500\",\n    orchid: \"da70d6\",\n    palegoldenrod: \"eee8aa\",\n    palegreen: \"98fb98\",\n    paleturquoise: \"afeeee\",\n    palevioletred: \"db7093\",\n    papayawhip: \"ffefd5\",\n    peachpuff: \"ffdab9\",\n    peru: \"cd853f\",\n    pink: \"ffc0cb\",\n    plum: \"dda0dd\",\n    powderblue: \"b0e0e6\",\n    purple: \"800080\",\n    rebeccapurple: \"663399\",\n    red: \"f00\",\n    rosybrown: \"bc8f8f\",\n    royalblue: \"4169e1\",\n    saddlebrown: \"8b4513\",\n    salmon: \"fa8072\",\n    sandybrown: \"f4a460\",\n    seagreen: \"2e8b57\",\n    seashell: \"fff5ee\",\n    sienna: \"a0522d\",\n    silver: \"c0c0c0\",\n    skyblue: \"87ceeb\",\n    slateblue: \"6a5acd\",\n    slategray: \"708090\",\n    slategrey: \"708090\",\n    snow: \"fffafa\",\n    springgreen: \"00ff7f\",\n    steelblue: \"4682b4\",\n    tan: \"d2b48c\",\n    teal: \"008080\",\n    thistle: \"d8bfd8\",\n    tomato: \"ff6347\",\n    turquoise: \"40e0d0\",\n    violet: \"ee82ee\",\n    wheat: \"f5deb3\",\n    white: \"fff\",\n    whitesmoke: \"f5f5f5\",\n    yellow: \"ff0\",\n    yellowgreen: \"9acd32\"\n};\n\n// Make it easy to access colors via `hexNames[hex]`\nvar hexNames = tinycolor.hexNames = flip(names);\n\n\n// Utilities\n// ---------\n\n// `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }`\nfunction flip(o) {\n    var flipped = { };\n    for (var i in o) {\n        if (o.hasOwnProperty(i)) {\n            flipped[o[i]] = i;\n        }\n    }\n    return flipped;\n}\n\n// Return a valid alpha value [0,1] with all invalid values being set to 1\nfunction boundAlpha(a) {\n    a = parseFloat(a);\n\n    if (isNaN(a) || a < 0 || a > 1) {\n        a = 1;\n    }\n\n    return a;\n}\n\n// Take input from [0, n] and return it as [0, 1]\nfunction bound01(n, max) {\n    if (isOnePointZero(n)) { n = \"100%\"; }\n\n    var processPercent = isPercentage(n);\n    n = mathMin(max, mathMax(0, parseFloat(n)));\n\n    // Automatically convert percentage into number\n    if (processPercent) {\n        n = parseInt(n * max, 10) / 100;\n    }\n\n    // Handle floating point rounding errors\n    if ((Math.abs(n - max) < 0.000001)) {\n        return 1;\n    }\n\n    // Convert into [0, 1] range if it isn't already\n    return (n % max) / parseFloat(max);\n}\n\n// Force a number between 0 and 1\nfunction clamp01(val) {\n    return mathMin(1, mathMax(0, val));\n}\n\n// Parse a base-16 hex value into a base-10 integer\nfunction parseIntFromHex(val) {\n    return parseInt(val, 16);\n}\n\n// Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1\n// <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>\nfunction isOnePointZero(n) {\n    return typeof n == \"string\" && n.indexOf('.') != -1 && parseFloat(n) === 1;\n}\n\n// Check to see if string passed in is a percentage\nfunction isPercentage(n) {\n    return typeof n === \"string\" && n.indexOf('%') != -1;\n}\n\n// Force a hex value to have 2 characters\nfunction pad2(c) {\n    return c.length == 1 ? '0' + c : '' + c;\n}\n\n// Replace a decimal with it's percentage value\nfunction convertToPercentage(n) {\n    if (n <= 1) {\n        n = (n * 100) + \"%\";\n    }\n\n    return n;\n}\n\n// Converts a decimal to a hex value\nfunction convertDecimalToHex(d) {\n    return Math.round(parseFloat(d) * 255).toString(16);\n}\n// Converts a hex value to a decimal\nfunction convertHexToDecimal(h) {\n    return (parseIntFromHex(h) / 255);\n}\n\nvar matchers = (function() {\n\n    // <http://www.w3.org/TR/css3-values/#integers>\n    var CSS_INTEGER = \"[-\\\\+]?\\\\d+%?\";\n\n    // <http://www.w3.org/TR/css3-values/#number-value>\n    var CSS_NUMBER = \"[-\\\\+]?\\\\d*\\\\.\\\\d+%?\";\n\n    // Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.\n    var CSS_UNIT = \"(?:\" + CSS_NUMBER + \")|(?:\" + CSS_INTEGER + \")\";\n\n    // Actual matching.\n    // Parentheses and commas are optional, but not required.\n    // Whitespace can take the place of commas or opening paren\n    var PERMISSIVE_MATCH3 = \"[\\\\s|\\\\(]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")\\\\s*\\\\)?\";\n    var PERMISSIVE_MATCH4 = \"[\\\\s|\\\\(]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")\\\\s*\\\\)?\";\n\n    return {\n        CSS_UNIT: new RegExp(CSS_UNIT),\n        rgb: new RegExp(\"rgb\" + PERMISSIVE_MATCH3),\n        rgba: new RegExp(\"rgba\" + PERMISSIVE_MATCH4),\n        hsl: new RegExp(\"hsl\" + PERMISSIVE_MATCH3),\n        hsla: new RegExp(\"hsla\" + PERMISSIVE_MATCH4),\n        hsv: new RegExp(\"hsv\" + PERMISSIVE_MATCH3),\n        hsva: new RegExp(\"hsva\" + PERMISSIVE_MATCH4),\n        hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,\n        hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,\n        hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,\n        hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/\n    };\n})();\n\n// `isValidCSSUnit`\n// Take in a single string / number and check to see if it looks like a CSS unit\n// (see `matchers` above for definition).\nfunction isValidCSSUnit(color) {\n    return !!matchers.CSS_UNIT.exec(color);\n}\n\n// `stringInputToObject`\n// Permissive string parsing.  Take in a number of formats, and output an object\n// based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`\nfunction stringInputToObject(color) {\n\n    color = color.replace(trimLeft,'').replace(trimRight, '').toLowerCase();\n    var named = false;\n    if (names[color]) {\n        color = names[color];\n        named = true;\n    }\n    else if (color == 'transparent') {\n        return { r: 0, g: 0, b: 0, a: 0, format: \"name\" };\n    }\n\n    // Try to match string input using regular expressions.\n    // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]\n    // Just return an object and let the conversion functions handle that.\n    // This way the result will be the same whether the tinycolor is initialized with string or object.\n    var match;\n    if ((match = matchers.rgb.exec(color))) {\n        return { r: match[1], g: match[2], b: match[3] };\n    }\n    if ((match = matchers.rgba.exec(color))) {\n        return { r: match[1], g: match[2], b: match[3], a: match[4] };\n    }\n    if ((match = matchers.hsl.exec(color))) {\n        return { h: match[1], s: match[2], l: match[3] };\n    }\n    if ((match = matchers.hsla.exec(color))) {\n        return { h: match[1], s: match[2], l: match[3], a: match[4] };\n    }\n    if ((match = matchers.hsv.exec(color))) {\n        return { h: match[1], s: match[2], v: match[3] };\n    }\n    if ((match = matchers.hsva.exec(color))) {\n        return { h: match[1], s: match[2], v: match[3], a: match[4] };\n    }\n    if ((match = matchers.hex8.exec(color))) {\n        return {\n            r: parseIntFromHex(match[1]),\n            g: parseIntFromHex(match[2]),\n            b: parseIntFromHex(match[3]),\n            a: convertHexToDecimal(match[4]),\n            format: named ? \"name\" : \"hex8\"\n        };\n    }\n    if ((match = matchers.hex6.exec(color))) {\n        return {\n            r: parseIntFromHex(match[1]),\n            g: parseIntFromHex(match[2]),\n            b: parseIntFromHex(match[3]),\n            format: named ? \"name\" : \"hex\"\n        };\n    }\n    if ((match = matchers.hex4.exec(color))) {\n        return {\n            r: parseIntFromHex(match[1] + '' + match[1]),\n            g: parseIntFromHex(match[2] + '' + match[2]),\n            b: parseIntFromHex(match[3] + '' + match[3]),\n            a: convertHexToDecimal(match[4] + '' + match[4]),\n            format: named ? \"name\" : \"hex8\"\n        };\n    }\n    if ((match = matchers.hex3.exec(color))) {\n        return {\n            r: parseIntFromHex(match[1] + '' + match[1]),\n            g: parseIntFromHex(match[2] + '' + match[2]),\n            b: parseIntFromHex(match[3] + '' + match[3]),\n            format: named ? \"name\" : \"hex\"\n        };\n    }\n\n    return false;\n}\n\nfunction validateWCAG2Parms(parms) {\n    // return valid WCAG2 parms for isReadable.\n    // If input parms are invalid, return {\"level\":\"AA\", \"size\":\"small\"}\n    var level, size;\n    parms = parms || {\"level\":\"AA\", \"size\":\"small\"};\n    level = (parms.level || \"AA\").toUpperCase();\n    size = (parms.size || \"small\").toLowerCase();\n    if (level !== \"AA\" && level !== \"AAA\") {\n        level = \"AA\";\n    }\n    if (size !== \"small\" && size !== \"large\") {\n        size = \"small\";\n    }\n    return {\"level\":level, \"size\":size};\n}\n\n// Node: Export function\nif (typeof module !== \"undefined\" && module.exports) {\n    module.exports = tinycolor;\n}\n// AMD/requirejs: Define the module\nelse if (typeof define === 'function' && define.amd) {\n    define(function () {return tinycolor;});\n}\n// Browser: Expose to window\nelse {\n    window.tinycolor = tinycolor;\n}\n\n})(Math);\n","export const ROUND_ARROW =\n  '<svg width=\"16\" height=\"6\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M0 6s1.796-.013 4.67-3.615C5.851.9 6.93.006 8 0c1.07-.006 2.148.887 3.343 2.385C14.233 6.005 16 6 16 6H0z\"></svg>';\n\nexport const BOX_CLASS = `__NAMESPACE_PREFIX__-box`;\nexport const CONTENT_CLASS = `__NAMESPACE_PREFIX__-content`;\nexport const BACKDROP_CLASS = `__NAMESPACE_PREFIX__-backdrop`;\nexport const ARROW_CLASS = `__NAMESPACE_PREFIX__-arrow`;\nexport const SVG_ARROW_CLASS = `__NAMESPACE_PREFIX__-svg-arrow`;\n\nexport const TOUCH_OPTIONS = {passive: true, capture: true};\n\nexport const TIPPY_DEFAULT_APPEND_TO = () => document.body;\n","import {BasePlacement, Placement} from './types';\n\nexport function hasOwnProperty(\n  obj: Record<string, unknown>,\n  key: string\n): boolean {\n  return {}.hasOwnProperty.call(obj, key);\n}\n\nexport function getValueAtIndexOrReturn<T>(\n  value: T | [T | null, T | null],\n  index: number,\n  defaultValue: T | [T, T]\n): T {\n  if (Array.isArray(value)) {\n    const v = value[index];\n    return v == null\n      ? Array.isArray(defaultValue)\n        ? defaultValue[index]\n        : defaultValue\n      : v;\n  }\n\n  return value;\n}\n\nexport function isType(value: any, type: string): boolean {\n  const str = {}.toString.call(value);\n  return str.indexOf('[object') === 0 && str.indexOf(`${type}]`) > -1;\n}\n\nexport function invokeWithArgsOrReturn(value: any, args: any[]): any {\n  return typeof value === 'function' ? value(...args) : value;\n}\n\nexport function debounce<T>(\n  fn: (arg: T) => void,\n  ms: number\n): (arg: T) => void {\n  // Avoid wrapping in `setTimeout` if ms is 0 anyway\n  if (ms === 0) {\n    return fn;\n  }\n\n  let timeout: any;\n\n  return (arg): void => {\n    clearTimeout(timeout);\n    timeout = setTimeout(() => {\n      fn(arg);\n    }, ms);\n  };\n}\n\nexport function removeProperties<T>(obj: T, keys: string[]): Partial<T> {\n  const clone = {...obj};\n  keys.forEach((key) => {\n    delete (clone as any)[key];\n  });\n  return clone;\n}\n\nexport function splitBySpaces(value: string): string[] {\n  return value.split(/\\s+/).filter(Boolean);\n}\n\nexport function normalizeToArray<T>(value: T | T[]): T[] {\n  return ([] as T[]).concat(value);\n}\n\nexport function pushIfUnique<T>(arr: T[], value: T): void {\n  if (arr.indexOf(value) === -1) {\n    arr.push(value);\n  }\n}\n\nexport function appendPxIfNumber(value: string | number): string {\n  return typeof value === 'number' ? `${value}px` : value;\n}\n\nexport function unique<T>(arr: T[]): T[] {\n  return arr.filter((item, index) => arr.indexOf(item) === index);\n}\n\nexport function getNumber(value: string | number): number {\n  return typeof value === 'number' ? value : parseFloat(value);\n}\n\nexport function getBasePlacement(placement: Placement): BasePlacement {\n  return placement.split('-')[0] as BasePlacement;\n}\n\nexport function arrayFrom(value: ArrayLike<any>): any[] {\n  return [].slice.call(value);\n}\n\nexport function removeUndefinedProps(\n  obj: Record<string, unknown>\n): Partial<Record<string, unknown>> {\n  return Object.keys(obj).reduce((acc, key) => {\n    if (obj[key] !== undefined) {\n      (acc as any)[key] = obj[key];\n    }\n\n    return acc;\n  }, {});\n}\n","import {ReferenceElement, Targets} from './types';\nimport {PopperTreeData} from './types-internal';\nimport {arrayFrom, isType, normalizeToArray, getBasePlacement} from './utils';\n\nexport function div(): HTMLDivElement {\n  return document.createElement('div');\n}\n\nexport function isElement(value: unknown): value is Element | DocumentFragment {\n  return ['Element', 'Fragment'].some((type) => isType(value, type));\n}\n\nexport function isNodeList(value: unknown): value is NodeList {\n  return isType(value, 'NodeList');\n}\n\nexport function isMouseEvent(value: unknown): value is MouseEvent {\n  return isType(value, 'MouseEvent');\n}\n\nexport function isReferenceElement(value: any): value is ReferenceElement {\n  return !!(value && value._tippy && value._tippy.reference === value);\n}\n\nexport function getArrayOfElements(value: Targets): Element[] {\n  if (isElement(value)) {\n    return [value];\n  }\n\n  if (isNodeList(value)) {\n    return arrayFrom(value);\n  }\n\n  if (Array.isArray(value)) {\n    return value;\n  }\n\n  return arrayFrom(document.querySelectorAll(value));\n}\n\nexport function setTransitionDuration(\n  els: (HTMLDivElement | null)[],\n  value: number\n): void {\n  els.forEach((el) => {\n    if (el) {\n      el.style.transitionDuration = `${value}ms`;\n    }\n  });\n}\n\nexport function setVisibilityState(\n  els: (HTMLDivElement | null)[],\n  state: 'visible' | 'hidden'\n): void {\n  els.forEach((el) => {\n    if (el) {\n      el.setAttribute('data-state', state);\n    }\n  });\n}\n\nexport function getOwnerDocument(\n  elementOrElements: Element | Element[]\n): Document {\n  const [element] = normalizeToArray(elementOrElements);\n\n  // Elements created via a <template> have an ownerDocument with no reference to the body\n  return element?.ownerDocument?.body ? element.ownerDocument : document;\n}\n\nexport function isCursorOutsideInteractiveBorder(\n  popperTreeData: PopperTreeData[],\n  event: MouseEvent\n): boolean {\n  const {clientX, clientY} = event;\n\n  return popperTreeData.every(({popperRect, popperState, props}) => {\n    const {interactiveBorder} = props;\n    const basePlacement = getBasePlacement(popperState.placement);\n    const offsetData = popperState.modifiersData.offset;\n\n    if (!offsetData) {\n      return true;\n    }\n\n    const topDistance = basePlacement === 'bottom' ? offsetData.top!.y : 0;\n    const bottomDistance = basePlacement === 'top' ? offsetData.bottom!.y : 0;\n    const leftDistance = basePlacement === 'right' ? offsetData.left!.x : 0;\n    const rightDistance = basePlacement === 'left' ? offsetData.right!.x : 0;\n\n    const exceedsTop =\n      popperRect.top - clientY + topDistance > interactiveBorder;\n    const exceedsBottom =\n      clientY - popperRect.bottom - bottomDistance > interactiveBorder;\n    const exceedsLeft =\n      popperRect.left - clientX + leftDistance > interactiveBorder;\n    const exceedsRight =\n      clientX - popperRect.right - rightDistance > interactiveBorder;\n\n    return exceedsTop || exceedsBottom || exceedsLeft || exceedsRight;\n  });\n}\n\nexport function updateTransitionEndListener(\n  box: HTMLDivElement,\n  action: 'add' | 'remove',\n  listener: (event: TransitionEvent) => void\n): void {\n  const method = `${action}EventListener` as\n    | 'addEventListener'\n    | 'removeEventListener';\n\n  // some browsers apparently support `transition` (unprefixed) but only fire\n  // `webkitTransitionEnd`...\n  ['transitionend', 'webkitTransitionEnd'].forEach((event) => {\n    box[method](event, listener as EventListener);\n  });\n}\n\n/**\n * Compared to xxx.contains, this function works for dom structures with shadow\n * dom\n */\nexport function actualContains(parent: Element, child: Element): boolean {\n  let target = child;\n  while (target) {\n    if (parent.contains(target)) {\n      return true;\n    }\n    target = (target.getRootNode?.() as any)?.host;\n  }\n  return false;\n}\n","import {TOUCH_OPTIONS} from './constants';\nimport {isReferenceElement} from './dom-utils';\n\nexport const currentInput = {isTouch: false};\nlet lastMouseMoveTime = 0;\n\n/**\n * When a `touchstart` event is fired, it's assumed the user is using touch\n * input. We'll bind a `mousemove` event listener to listen for mouse input in\n * the future. This way, the `isTouch` property is fully dynamic and will handle\n * hybrid devices that use a mix of touch + mouse input.\n */\nexport function onDocumentTouchStart(): void {\n  if (currentInput.isTouch) {\n    return;\n  }\n\n  currentInput.isTouch = true;\n\n  if (window.performance) {\n    document.addEventListener('mousemove', onDocumentMouseMove);\n  }\n}\n\n/**\n * When two `mousemove` event are fired consecutively within 20ms, it's assumed\n * the user is using mouse input again. `mousemove` can fire on touch devices as\n * well, but very rarely that quickly.\n */\nexport function onDocumentMouseMove(): void {\n  const now = performance.now();\n\n  if (now - lastMouseMoveTime < 20) {\n    currentInput.isTouch = false;\n\n    document.removeEventListener('mousemove', onDocumentMouseMove);\n  }\n\n  lastMouseMoveTime = now;\n}\n\n/**\n * When an element is in focus and has a tippy, leaving the tab/window and\n * returning causes it to show again. For mouse users this is unexpected, but\n * for keyboard use it makes sense.\n * TODO: find a better technique to solve this problem\n */\nexport function onWindowBlur(): void {\n  const activeElement = document.activeElement as HTMLElement | null;\n\n  if (isReferenceElement(activeElement)) {\n    const instance = activeElement._tippy!;\n\n    if (activeElement.blur && !instance.state.isVisible) {\n      activeElement.blur();\n    }\n  }\n}\n\nexport default function bindGlobalEventListeners(): void {\n  document.addEventListener('touchstart', onDocumentTouchStart, TOUCH_OPTIONS);\n  window.addEventListener('blur', onWindowBlur);\n}\n","export const isBrowser =\n  typeof window !== 'undefined' && typeof document !== 'undefined';\n\nexport const isIE11 = isBrowser\n  ? // @ts-ignore\n    !!window.msCrypto\n  : false;\n","import {DefaultProps, Plugin, Props, ReferenceElement, Tippy} from './types';\nimport {\n  hasOwnProperty,\n  removeProperties,\n  invokeWithArgsOrReturn,\n} from './utils';\nimport {warnWhen} from './validation';\nimport {TIPPY_DEFAULT_APPEND_TO} from './constants';\n\nconst pluginProps = {\n  animateFill: false,\n  followCursor: false,\n  inlinePositioning: false,\n  sticky: false,\n};\n\nconst renderProps = {\n  allowHTML: false,\n  animation: 'fade',\n  arrow: true,\n  content: '',\n  inertia: false,\n  maxWidth: 350,\n  role: 'tooltip',\n  theme: '',\n  zIndex: 9999,\n};\n\nexport const defaultProps: DefaultProps = {\n  appendTo: TIPPY_DEFAULT_APPEND_TO,\n  aria: {\n    content: 'auto',\n    expanded: 'auto',\n  },\n  delay: 0,\n  duration: [300, 250],\n  getReferenceClientRect: null,\n  hideOnClick: true,\n  ignoreAttributes: false,\n  interactive: false,\n  interactiveBorder: 2,\n  interactiveDebounce: 0,\n  moveTransition: '',\n  offset: [0, 10],\n  onAfterUpdate() {},\n  onBeforeUpdate() {},\n  onCreate() {},\n  onDestroy() {},\n  onHidden() {},\n  onHide() {},\n  onMount() {},\n  onShow() {},\n  onShown() {},\n  onTrigger() {},\n  onUntrigger() {},\n  onClickOutside() {},\n  placement: 'top',\n  plugins: [],\n  popperOptions: {},\n  render: null,\n  showOnCreate: false,\n  touch: true,\n  trigger: 'mouseenter focus',\n  triggerTarget: null,\n  ...pluginProps,\n  ...renderProps,\n};\n\nconst defaultKeys = Object.keys(defaultProps);\n\nexport const setDefaultProps: Tippy['setDefaultProps'] = (partialProps) => {\n  /* istanbul ignore else */\n  if (__DEV__) {\n    validateProps(partialProps, []);\n  }\n\n  const keys = Object.keys(partialProps) as Array<keyof DefaultProps>;\n  keys.forEach((key) => {\n    (defaultProps as any)[key] = partialProps[key];\n  });\n};\n\nexport function getExtendedPassedProps(\n  passedProps: Partial<Props> & Record<string, unknown>\n): Partial<Props> {\n  const plugins = passedProps.plugins || [];\n  const pluginProps = plugins.reduce<Record<string, unknown>>((acc, plugin) => {\n    const {name, defaultValue} = plugin;\n\n    if (name) {\n      acc[name] =\n        passedProps[name] !== undefined\n          ? passedProps[name]\n          : (defaultProps as any)[name] ?? defaultValue;\n    }\n\n    return acc;\n  }, {});\n\n  return {\n    ...passedProps,\n    ...pluginProps,\n  };\n}\n\nexport function getDataAttributeProps(\n  reference: ReferenceElement,\n  plugins: Plugin[]\n): Record<string, unknown> {\n  const propKeys = plugins\n    ? Object.keys(getExtendedPassedProps({...defaultProps, plugins}))\n    : defaultKeys;\n\n  const props = propKeys.reduce(\n    (acc: Partial<Props> & Record<string, unknown>, key) => {\n      const valueAsString = (\n        reference.getAttribute(`data-tippy-${key}`) || ''\n      ).trim();\n\n      if (!valueAsString) {\n        return acc;\n      }\n\n      if (key === 'content') {\n        acc[key] = valueAsString;\n      } else {\n        try {\n          acc[key] = JSON.parse(valueAsString);\n        } catch (e) {\n          acc[key] = valueAsString;\n        }\n      }\n\n      return acc;\n    },\n    {}\n  );\n\n  return props;\n}\n\nexport function evaluateProps(\n  reference: ReferenceElement,\n  props: Props\n): Props {\n  const out = {\n    ...props,\n    content: invokeWithArgsOrReturn(props.content, [reference]),\n    ...(props.ignoreAttributes\n      ? {}\n      : getDataAttributeProps(reference, props.plugins)),\n  };\n\n  out.aria = {\n    ...defaultProps.aria,\n    ...out.aria,\n  };\n\n  out.aria = {\n    expanded:\n      out.aria.expanded === 'auto' ? props.interactive : out.aria.expanded,\n    content:\n      out.aria.content === 'auto'\n        ? props.interactive\n          ? null\n          : 'describedby'\n        : out.aria.content,\n  };\n\n  return out;\n}\n\nexport function validateProps(\n  partialProps: Partial<Props> = {},\n  plugins: Plugin[] = []\n): void {\n  const keys = Object.keys(partialProps) as Array<keyof Props>;\n  keys.forEach((prop) => {\n    const nonPluginProps = removeProperties(\n      defaultProps,\n      Object.keys(pluginProps)\n    );\n\n    let didPassUnknownProp = !hasOwnProperty(nonPluginProps, prop);\n\n    // Check if the prop exists in `plugins`\n    if (didPassUnknownProp) {\n      didPassUnknownProp =\n        plugins.filter((plugin) => plugin.name === prop).length === 0;\n    }\n\n    warnWhen(\n      didPassUnknownProp,\n      [\n        `\\`${prop}\\``,\n        \"is not a valid prop. You may have spelled it incorrectly, or if it's\",\n        'a plugin, forgot to pass it in an array as props.plugins.',\n        '\\n\\n',\n        'All props: https://atomiks.github.io/tippyjs/v6/all-props/\\n',\n        'Plugins: https://atomiks.github.io/tippyjs/v6/plugins/',\n      ].join(' ')\n    );\n  });\n}\n","import {\n  ARROW_CLASS,\n  BACKDROP_CLASS,\n  BOX_CLASS,\n  CONTENT_CLASS,\n  SVG_ARROW_CLASS,\n} from './constants';\nimport {div, isElement} from './dom-utils';\nimport {Instance, PopperElement, Props} from './types';\nimport {PopperChildren} from './types-internal';\nimport {arrayFrom} from './utils';\n\n// Firefox extensions don't allow .innerHTML = \"...\" property. This tricks it.\nconst innerHTML = (): 'innerHTML' => 'innerHTML';\n\nfunction dangerouslySetInnerHTML(element: Element, html: string): void {\n  element[innerHTML()] = html;\n}\n\nfunction createArrowElement(value: Props['arrow']): HTMLDivElement {\n  const arrow = div();\n\n  if (value === true) {\n    arrow.className = ARROW_CLASS;\n  } else {\n    arrow.className = SVG_ARROW_CLASS;\n\n    if (isElement(value)) {\n      arrow.appendChild(value);\n    } else {\n      dangerouslySetInnerHTML(arrow, value as string);\n    }\n  }\n\n  return arrow;\n}\n\nexport function setContent(content: HTMLDivElement, props: Props): void {\n  if (isElement(props.content)) {\n    dangerouslySetInnerHTML(content, '');\n    content.appendChild(props.content);\n  } else if (typeof props.content !== 'function') {\n    if (props.allowHTML) {\n      dangerouslySetInnerHTML(content, props.content);\n    } else {\n      content.textContent = props.content;\n    }\n  }\n}\n\nexport function getChildren(popper: PopperElement): PopperChildren {\n  const box = popper.firstElementChild as HTMLDivElement;\n  const boxChildren = arrayFrom(box.children);\n\n  return {\n    box,\n    content: boxChildren.find((node) => node.classList.contains(CONTENT_CLASS)),\n    arrow: boxChildren.find(\n      (node) =>\n        node.classList.contains(ARROW_CLASS) ||\n        node.classList.contains(SVG_ARROW_CLASS)\n    ),\n    backdrop: boxChildren.find((node) =>\n      node.classList.contains(BACKDROP_CLASS)\n    ),\n  };\n}\n\nexport function render(\n  instance: Instance\n): {\n  popper: PopperElement;\n  onUpdate?: (prevProps: Props, nextProps: Props) => void;\n} {\n  const popper = div();\n\n  const box = div();\n  box.className = BOX_CLASS;\n  box.setAttribute('data-state', 'hidden');\n  box.setAttribute('tabindex', '-1');\n\n  const content = div();\n  content.className = CONTENT_CLASS;\n  content.setAttribute('data-state', 'hidden');\n\n  setContent(content, instance.props);\n\n  popper.appendChild(box);\n  box.appendChild(content);\n\n  onUpdate(instance.props, instance.props);\n\n  function onUpdate(prevProps: Props, nextProps: Props): void {\n    const {box, content, arrow} = getChildren(popper);\n\n    if (nextProps.theme) {\n      box.setAttribute('data-theme', nextProps.theme);\n    } else {\n      box.removeAttribute('data-theme');\n    }\n\n    if (typeof nextProps.animation === 'string') {\n      box.setAttribute('data-animation', nextProps.animation);\n    } else {\n      box.removeAttribute('data-animation');\n    }\n\n    if (nextProps.inertia) {\n      box.setAttribute('data-inertia', '');\n    } else {\n      box.removeAttribute('data-inertia');\n    }\n\n    box.style.maxWidth =\n      typeof nextProps.maxWidth === 'number'\n        ? `${nextProps.maxWidth}px`\n        : nextProps.maxWidth;\n\n    if (nextProps.role) {\n      box.setAttribute('role', nextProps.role);\n    } else {\n      box.removeAttribute('role');\n    }\n\n    if (\n      prevProps.content !== nextProps.content ||\n      prevProps.allowHTML !== nextProps.allowHTML\n    ) {\n      setContent(content, instance.props);\n    }\n\n    if (nextProps.arrow) {\n      if (!arrow) {\n        box.appendChild(createArrowElement(nextProps.arrow));\n      } else if (prevProps.arrow !== nextProps.arrow) {\n        box.removeChild(arrow);\n        box.appendChild(createArrowElement(nextProps.arrow));\n      }\n    } else if (arrow) {\n      box.removeChild(arrow!);\n    }\n  }\n\n  return {\n    popper,\n    onUpdate,\n  };\n}\n\n// Runtime check to identify if the render function is the default one; this\n// way we can apply default CSS transitions logic and it can be tree-shaken away\nrender.$$tippy = true;\n","import {createPopper, StrictModifiers, Modifier} from '@popperjs/core';\nimport {currentInput} from './bindGlobalEventListeners';\nimport {isIE11} from './browser';\nimport {TIPPY_DEFAULT_APPEND_TO, TOUCH_OPTIONS} from './constants';\nimport {\n  actualContains,\n  div,\n  getOwnerDocument,\n  isCursorOutsideInteractiveBorder,\n  isMouseEvent,\n  setTransitionDuration,\n  setVisibilityState,\n  updateTransitionEndListener,\n} from './dom-utils';\nimport {defaultProps, evaluateProps, getExtendedPassedProps} from './props';\nimport {getChildren} from './template';\nimport {\n  Content,\n  Instance,\n  LifecycleHooks,\n  PopperElement,\n  Props,\n  ReferenceElement,\n} from './types';\nimport {ListenerObject, PopperTreeData, PopperChildren} from './types-internal';\nimport {\n  arrayFrom,\n  debounce,\n  getValueAtIndexOrReturn,\n  invokeWithArgsOrReturn,\n  normalizeToArray,\n  pushIfUnique,\n  splitBySpaces,\n  unique,\n  removeUndefinedProps,\n} from './utils';\nimport {createMemoryLeakWarning, errorWhen, warnWhen} from './validation';\n\nlet idCounter = 1;\nlet mouseMoveListeners: ((event: MouseEvent) => void)[] = [];\n\n// Used by `hideAll()`\nexport let mountedInstances: Instance[] = [];\n\nexport default function createTippy(\n  reference: ReferenceElement,\n  passedProps: Partial<Props>\n): Instance {\n  const props = evaluateProps(reference, {\n    ...defaultProps,\n    ...getExtendedPassedProps(removeUndefinedProps(passedProps)),\n  });\n\n  // ===========================================================================\n  // 🔒 Private members\n  // ===========================================================================\n  let showTimeout: any;\n  let hideTimeout: any;\n  let scheduleHideAnimationFrame: number;\n  let isVisibleFromClick = false;\n  let didHideDueToDocumentMouseDown = false;\n  let didTouchMove = false;\n  let ignoreOnFirstUpdate = false;\n  let lastTriggerEvent: Event | undefined;\n  let currentTransitionEndListener: (event: TransitionEvent) => void;\n  let onFirstUpdate: () => void;\n  let listeners: ListenerObject[] = [];\n  let debouncedOnMouseMove = debounce(onMouseMove, props.interactiveDebounce);\n  let currentTarget: Element;\n\n  // ===========================================================================\n  // 🔑 Public members\n  // ===========================================================================\n  const id = idCounter++;\n  const popperInstance = null;\n  const plugins = unique(props.plugins);\n\n  const state = {\n    // Is the instance currently enabled?\n    isEnabled: true,\n    // Is the tippy currently showing and not transitioning out?\n    isVisible: false,\n    // Has the instance been destroyed?\n    isDestroyed: false,\n    // Is the tippy currently mounted to the DOM?\n    isMounted: false,\n    // Has the tippy finished transitioning in?\n    isShown: false,\n  };\n\n  const instance: Instance = {\n    // properties\n    id,\n    reference,\n    popper: div(),\n    popperInstance,\n    props,\n    state,\n    plugins,\n    // methods\n    clearDelayTimeouts,\n    setProps,\n    setContent,\n    show,\n    hide,\n    hideWithInteractivity,\n    enable,\n    disable,\n    unmount,\n    destroy,\n  };\n\n  // TODO: Investigate why this early return causes a TDZ error in the tests —\n  // it doesn't seem to happen in the browser\n  /* istanbul ignore if */\n  if (!props.render) {\n    if (__DEV__) {\n      errorWhen(true, 'render() function has not been supplied.');\n    }\n\n    return instance;\n  }\n\n  // ===========================================================================\n  // Initial mutations\n  // ===========================================================================\n  const {popper, onUpdate} = props.render(instance);\n\n  popper.setAttribute('data-__NAMESPACE_PREFIX__-root', '');\n  popper.id = `__NAMESPACE_PREFIX__-${instance.id}`;\n\n  instance.popper = popper;\n  reference._tippy = instance;\n  popper._tippy = instance;\n\n  const pluginsHooks = plugins.map((plugin) => plugin.fn(instance));\n  const hasAriaExpanded = reference.hasAttribute('aria-expanded');\n\n  addListeners();\n  handleAriaExpandedAttribute();\n  handleStyles();\n\n  invokeHook('onCreate', [instance]);\n\n  if (props.showOnCreate) {\n    scheduleShow();\n  }\n\n  // Prevent a tippy with a delay from hiding if the cursor left then returned\n  // before it started hiding\n  popper.addEventListener('mouseenter', () => {\n    if (instance.props.interactive && instance.state.isVisible) {\n      instance.clearDelayTimeouts();\n    }\n  });\n\n  popper.addEventListener('mouseleave', () => {\n    if (\n      instance.props.interactive &&\n      instance.props.trigger.indexOf('mouseenter') >= 0\n    ) {\n      getDocument().addEventListener('mousemove', debouncedOnMouseMove);\n    }\n  });\n\n  return instance;\n\n  // ===========================================================================\n  // 🔒 Private methods\n  // ===========================================================================\n  function getNormalizedTouchSettings(): [string | boolean, number] {\n    const {touch} = instance.props;\n    return Array.isArray(touch) ? touch : [touch, 0];\n  }\n\n  function getIsCustomTouchBehavior(): boolean {\n    return getNormalizedTouchSettings()[0] === 'hold';\n  }\n\n  function getIsDefaultRenderFn(): boolean {\n    // @ts-ignore\n    return !!instance.props.render?.$$tippy;\n  }\n\n  function getCurrentTarget(): Element {\n    return currentTarget || reference;\n  }\n\n  function getDocument(): Document {\n    const parent = getCurrentTarget().parentNode as Element;\n    return parent ? getOwnerDocument(parent) : document;\n  }\n\n  function getDefaultTemplateChildren(): PopperChildren {\n    return getChildren(popper);\n  }\n\n  function getDelay(isShow: boolean): number {\n    // For touch or keyboard input, force `0` delay for UX reasons\n    // Also if the instance is mounted but not visible (transitioning out),\n    // ignore delay\n    if (\n      (instance.state.isMounted && !instance.state.isVisible) ||\n      currentInput.isTouch ||\n      (lastTriggerEvent && lastTriggerEvent.type === 'focus')\n    ) {\n      return 0;\n    }\n\n    return getValueAtIndexOrReturn(\n      instance.props.delay,\n      isShow ? 0 : 1,\n      defaultProps.delay\n    );\n  }\n\n  function handleStyles(fromHide = false): void {\n    popper.style.pointerEvents =\n      instance.props.interactive && !fromHide ? '' : 'none';\n    popper.style.zIndex = `${instance.props.zIndex}`;\n  }\n\n  function invokeHook(\n    hook: keyof LifecycleHooks,\n    args: [Instance, any?],\n    shouldInvokePropsHook = true\n  ): void {\n    pluginsHooks.forEach((pluginHooks) => {\n      if (pluginHooks[hook]) {\n        pluginHooks[hook]!(...args);\n      }\n    });\n\n    if (shouldInvokePropsHook) {\n      instance.props[hook](...args);\n    }\n  }\n\n  function handleAriaContentAttribute(): void {\n    const {aria} = instance.props;\n\n    if (!aria.content) {\n      return;\n    }\n\n    const attr = `aria-${aria.content}`;\n    const id = popper.id;\n    const nodes = normalizeToArray(instance.props.triggerTarget || reference);\n\n    nodes.forEach((node) => {\n      const currentValue = node.getAttribute(attr);\n\n      if (instance.state.isVisible) {\n        node.setAttribute(attr, currentValue ? `${currentValue} ${id}` : id);\n      } else {\n        const nextValue = currentValue && currentValue.replace(id, '').trim();\n\n        if (nextValue) {\n          node.setAttribute(attr, nextValue);\n        } else {\n          node.removeAttribute(attr);\n        }\n      }\n    });\n  }\n\n  function handleAriaExpandedAttribute(): void {\n    if (hasAriaExpanded || !instance.props.aria.expanded) {\n      return;\n    }\n\n    const nodes = normalizeToArray(instance.props.triggerTarget || reference);\n\n    nodes.forEach((node) => {\n      if (instance.props.interactive) {\n        node.setAttribute(\n          'aria-expanded',\n          instance.state.isVisible && node === getCurrentTarget()\n            ? 'true'\n            : 'false'\n        );\n      } else {\n        node.removeAttribute('aria-expanded');\n      }\n    });\n  }\n\n  function cleanupInteractiveMouseListeners(): void {\n    getDocument().removeEventListener('mousemove', debouncedOnMouseMove);\n    mouseMoveListeners = mouseMoveListeners.filter(\n      (listener) => listener !== debouncedOnMouseMove\n    );\n  }\n\n  function onDocumentPress(event: MouseEvent | TouchEvent): void {\n    // Moved finger to scroll instead of an intentional tap outside\n    if (currentInput.isTouch) {\n      if (didTouchMove || event.type === 'mousedown') {\n        return;\n      }\n    }\n\n    const actualTarget =\n      (event.composedPath && event.composedPath()[0]) || event.target;\n\n    // Clicked on interactive popper\n    if (\n      instance.props.interactive &&\n      actualContains(popper, actualTarget as Element)\n    ) {\n      return;\n    }\n\n    // Clicked on the event listeners target\n    if (\n      normalizeToArray(instance.props.triggerTarget || reference).some((el) =>\n        actualContains(el, actualTarget as Element)\n      )\n    ) {\n      if (currentInput.isTouch) {\n        return;\n      }\n\n      if (\n        instance.state.isVisible &&\n        instance.props.trigger.indexOf('click') >= 0\n      ) {\n        return;\n      }\n    } else {\n      invokeHook('onClickOutside', [instance, event]);\n    }\n\n    if (instance.props.hideOnClick === true) {\n      instance.clearDelayTimeouts();\n      instance.hide();\n\n      // `mousedown` event is fired right before `focus` if pressing the\n      // currentTarget. This lets a tippy with `focus` trigger know that it\n      // should not show\n      didHideDueToDocumentMouseDown = true;\n      setTimeout(() => {\n        didHideDueToDocumentMouseDown = false;\n      });\n\n      // The listener gets added in `scheduleShow()`, but this may be hiding it\n      // before it shows, and hide()'s early bail-out behavior can prevent it\n      // from being cleaned up\n      if (!instance.state.isMounted) {\n        removeDocumentPress();\n      }\n    }\n  }\n\n  function onTouchMove(): void {\n    didTouchMove = true;\n  }\n\n  function onTouchStart(): void {\n    didTouchMove = false;\n  }\n\n  function addDocumentPress(): void {\n    const doc = getDocument();\n    doc.addEventListener('mousedown', onDocumentPress, true);\n    doc.addEventListener('touchend', onDocumentPress, TOUCH_OPTIONS);\n    doc.addEventListener('touchstart', onTouchStart, TOUCH_OPTIONS);\n    doc.addEventListener('touchmove', onTouchMove, TOUCH_OPTIONS);\n  }\n\n  function removeDocumentPress(): void {\n    const doc = getDocument();\n    doc.removeEventListener('mousedown', onDocumentPress, true);\n    doc.removeEventListener('touchend', onDocumentPress, TOUCH_OPTIONS);\n    doc.removeEventListener('touchstart', onTouchStart, TOUCH_OPTIONS);\n    doc.removeEventListener('touchmove', onTouchMove, TOUCH_OPTIONS);\n  }\n\n  function onTransitionedOut(duration: number, callback: () => void): void {\n    onTransitionEnd(duration, () => {\n      if (\n        !instance.state.isVisible &&\n        popper.parentNode &&\n        popper.parentNode.contains(popper)\n      ) {\n        callback();\n      }\n    });\n  }\n\n  function onTransitionedIn(duration: number, callback: () => void): void {\n    onTransitionEnd(duration, callback);\n  }\n\n  function onTransitionEnd(duration: number, callback: () => void): void {\n    const box = getDefaultTemplateChildren().box;\n\n    function listener(event: TransitionEvent): void {\n      if (event.target === box) {\n        updateTransitionEndListener(box, 'remove', listener);\n        callback();\n      }\n    }\n\n    // Make callback synchronous if duration is 0\n    // `transitionend` won't fire otherwise\n    if (duration === 0) {\n      return callback();\n    }\n\n    updateTransitionEndListener(box, 'remove', currentTransitionEndListener);\n    updateTransitionEndListener(box, 'add', listener);\n\n    currentTransitionEndListener = listener;\n  }\n\n  function on(\n    eventType: string,\n    handler: EventListener,\n    options: boolean | Record<string, unknown> = false\n  ): void {\n    const nodes = normalizeToArray(instance.props.triggerTarget || reference);\n    nodes.forEach((node) => {\n      node.addEventListener(eventType, handler, options);\n      listeners.push({node, eventType, handler, options});\n    });\n  }\n\n  function addListeners(): void {\n    if (getIsCustomTouchBehavior()) {\n      on('touchstart', onTrigger, {passive: true});\n      on('touchend', onMouseLeave as EventListener, {passive: true});\n    }\n\n    splitBySpaces(instance.props.trigger).forEach((eventType) => {\n      if (eventType === 'manual') {\n        return;\n      }\n\n      on(eventType, onTrigger);\n\n      switch (eventType) {\n        case 'mouseenter':\n          on('mouseleave', onMouseLeave as EventListener);\n          break;\n        case 'focus':\n          on(isIE11 ? 'focusout' : 'blur', onBlurOrFocusOut as EventListener);\n          break;\n        case 'focusin':\n          on('focusout', onBlurOrFocusOut as EventListener);\n          break;\n      }\n    });\n  }\n\n  function removeListeners(): void {\n    listeners.forEach(({node, eventType, handler, options}: ListenerObject) => {\n      node.removeEventListener(eventType, handler, options);\n    });\n    listeners = [];\n  }\n\n  function onTrigger(event: Event): void {\n    let shouldScheduleClickHide = false;\n\n    if (\n      !instance.state.isEnabled ||\n      isEventListenerStopped(event) ||\n      didHideDueToDocumentMouseDown\n    ) {\n      return;\n    }\n\n    const wasFocused = lastTriggerEvent?.type === 'focus';\n\n    lastTriggerEvent = event;\n    currentTarget = event.currentTarget as Element;\n\n    handleAriaExpandedAttribute();\n\n    if (!instance.state.isVisible && isMouseEvent(event)) {\n      // If scrolling, `mouseenter` events can be fired if the cursor lands\n      // over a new target, but `mousemove` events don't get fired. This\n      // causes interactive tooltips to get stuck open until the cursor is\n      // moved\n      mouseMoveListeners.forEach((listener) => listener(event));\n    }\n\n    // Toggle show/hide when clicking click-triggered tooltips\n    if (\n      event.type === 'click' &&\n      (instance.props.trigger.indexOf('mouseenter') < 0 ||\n        isVisibleFromClick) &&\n      instance.props.hideOnClick !== false &&\n      instance.state.isVisible\n    ) {\n      shouldScheduleClickHide = true;\n    } else {\n      scheduleShow(event);\n    }\n\n    if (event.type === 'click') {\n      isVisibleFromClick = !shouldScheduleClickHide;\n    }\n\n    if (shouldScheduleClickHide && !wasFocused) {\n      scheduleHide(event);\n    }\n  }\n\n  function onMouseMove(event: MouseEvent): void {\n    const target = event.target as Node;\n    const isCursorOverReferenceOrPopper =\n      getCurrentTarget().contains(target) || popper.contains(target);\n\n    if (event.type === 'mousemove' && isCursorOverReferenceOrPopper) {\n      return;\n    }\n\n    const popperTreeData = getNestedPopperTree()\n      .concat(popper)\n      .map((popper) => {\n        const instance = popper._tippy!;\n        const state = instance.popperInstance?.state;\n\n        if (state) {\n          return {\n            popperRect: popper.getBoundingClientRect(),\n            popperState: state,\n            props,\n          };\n        }\n\n        return null;\n      })\n      .filter(Boolean) as PopperTreeData[];\n\n    if (isCursorOutsideInteractiveBorder(popperTreeData, event)) {\n      cleanupInteractiveMouseListeners();\n      scheduleHide(event);\n    }\n  }\n\n  function onMouseLeave(event: MouseEvent): void {\n    const shouldBail =\n      isEventListenerStopped(event) ||\n      (instance.props.trigger.indexOf('click') >= 0 && isVisibleFromClick);\n\n    if (shouldBail) {\n      return;\n    }\n\n    if (instance.props.interactive) {\n      instance.hideWithInteractivity(event);\n      return;\n    }\n\n    scheduleHide(event);\n  }\n\n  function onBlurOrFocusOut(event: FocusEvent): void {\n    if (\n      instance.props.trigger.indexOf('focusin') < 0 &&\n      event.target !== getCurrentTarget()\n    ) {\n      return;\n    }\n\n    // If focus was moved to within the popper\n    if (\n      instance.props.interactive &&\n      event.relatedTarget &&\n      popper.contains(event.relatedTarget as Element)\n    ) {\n      return;\n    }\n\n    scheduleHide(event);\n  }\n\n  function isEventListenerStopped(event: Event): boolean {\n    return currentInput.isTouch\n      ? getIsCustomTouchBehavior() !== event.type.indexOf('touch') >= 0\n      : false;\n  }\n\n  function createPopperInstance(): void {\n    destroyPopperInstance();\n\n    const {\n      popperOptions,\n      placement,\n      offset,\n      getReferenceClientRect,\n      moveTransition,\n    } = instance.props;\n\n    const arrow = getIsDefaultRenderFn() ? getChildren(popper).arrow : null;\n\n    const computedReference = getReferenceClientRect\n      ? {\n          getBoundingClientRect: getReferenceClientRect,\n          contextElement:\n            getReferenceClientRect.contextElement || getCurrentTarget(),\n        }\n      : reference;\n\n    const tippyModifier: Modifier<'$$tippy', Record<string, unknown>> = {\n      name: '$$tippy',\n      enabled: true,\n      phase: 'beforeWrite',\n      requires: ['computeStyles'],\n      fn({state}) {\n        if (getIsDefaultRenderFn()) {\n          const {box} = getDefaultTemplateChildren();\n\n          ['placement', 'reference-hidden', 'escaped'].forEach((attr) => {\n            if (attr === 'placement') {\n              box.setAttribute('data-placement', state.placement);\n            } else {\n              if (state.attributes.popper[`data-popper-${attr}`]) {\n                box.setAttribute(`data-${attr}`, '');\n              } else {\n                box.removeAttribute(`data-${attr}`);\n              }\n            }\n          });\n\n          state.attributes.popper = {};\n        }\n      },\n    };\n\n    type TippyModifier = Modifier<'$$tippy', Record<string, unknown>>;\n    type ExtendedModifiers = StrictModifiers | Partial<TippyModifier>;\n\n    const modifiers: Array<ExtendedModifiers> = [\n      {\n        name: 'offset',\n        options: {\n          offset,\n        },\n      },\n      {\n        name: 'preventOverflow',\n        options: {\n          padding: {\n            top: 2,\n            bottom: 2,\n            left: 5,\n            right: 5,\n          },\n        },\n      },\n      {\n        name: 'flip',\n        options: {\n          padding: 5,\n        },\n      },\n      {\n        name: 'computeStyles',\n        options: {\n          adaptive: !moveTransition,\n        },\n      },\n      tippyModifier,\n    ];\n\n    if (getIsDefaultRenderFn() && arrow) {\n      modifiers.push({\n        name: 'arrow',\n        options: {\n          element: arrow,\n          padding: 3,\n        },\n      });\n    }\n\n    modifiers.push(...(popperOptions?.modifiers || []));\n\n    instance.popperInstance = createPopper<ExtendedModifiers>(\n      computedReference,\n      popper,\n      {\n        ...popperOptions,\n        placement,\n        onFirstUpdate,\n        modifiers,\n      }\n    );\n  }\n\n  function destroyPopperInstance(): void {\n    if (instance.popperInstance) {\n      instance.popperInstance.destroy();\n      instance.popperInstance = null;\n    }\n  }\n\n  function mount(): void {\n    const {appendTo} = instance.props;\n\n    let parentNode: any;\n\n    // By default, we'll append the popper to the triggerTargets's parentNode so\n    // it's directly after the reference element so the elements inside the\n    // tippy can be tabbed to\n    // If there are clipping issues, the user can specify a different appendTo\n    // and ensure focus management is handled correctly manually\n    const node = getCurrentTarget();\n\n    if (\n      (instance.props.interactive && appendTo === TIPPY_DEFAULT_APPEND_TO) ||\n      appendTo === 'parent'\n    ) {\n      parentNode = node.parentNode;\n    } else {\n      parentNode = invokeWithArgsOrReturn(appendTo, [node]);\n    }\n\n    // The popper element needs to exist on the DOM before its position can be\n    // updated as Popper needs to read its dimensions\n    if (!parentNode.contains(popper)) {\n      parentNode.appendChild(popper);\n    }\n\n    instance.state.isMounted = true;\n\n    createPopperInstance();\n\n    /* istanbul ignore else */\n    if (__DEV__) {\n      // Accessibility check\n      warnWhen(\n        instance.props.interactive &&\n          appendTo === defaultProps.appendTo &&\n          node.nextElementSibling !== popper,\n        [\n          'Interactive tippy element may not be accessible via keyboard',\n          'navigation because it is not directly after the reference element',\n          'in the DOM source order.',\n          '\\n\\n',\n          'Using a wrapper <div> or <span> tag around the reference element',\n          'solves this by creating a new parentNode context.',\n          '\\n\\n',\n          'Specifying `appendTo: document.body` silences this warning, but it',\n          'assumes you are using a focus management solution to handle',\n          'keyboard navigation.',\n          '\\n\\n',\n          'See: https://atomiks.github.io/tippyjs/v6/accessibility/#interactivity',\n        ].join(' ')\n      );\n    }\n  }\n\n  function getNestedPopperTree(): PopperElement[] {\n    return arrayFrom(\n      popper.querySelectorAll('[data-__NAMESPACE_PREFIX__-root]')\n    );\n  }\n\n  function scheduleShow(event?: Event): void {\n    instance.clearDelayTimeouts();\n\n    if (event) {\n      invokeHook('onTrigger', [instance, event]);\n    }\n\n    addDocumentPress();\n\n    let delay = getDelay(true);\n    const [touchValue, touchDelay] = getNormalizedTouchSettings();\n\n    if (currentInput.isTouch && touchValue === 'hold' && touchDelay) {\n      delay = touchDelay;\n    }\n\n    if (delay) {\n      showTimeout = setTimeout(() => {\n        instance.show();\n      }, delay);\n    } else {\n      instance.show();\n    }\n  }\n\n  function scheduleHide(event: Event): void {\n    instance.clearDelayTimeouts();\n\n    invokeHook('onUntrigger', [instance, event]);\n\n    if (!instance.state.isVisible) {\n      removeDocumentPress();\n\n      return;\n    }\n\n    // For interactive tippies, scheduleHide is added to a document.body handler\n    // from onMouseLeave so must intercept scheduled hides from mousemove/leave\n    // events when trigger contains mouseenter and click, and the tip is\n    // currently shown as a result of a click.\n    if (\n      instance.props.trigger.indexOf('mouseenter') >= 0 &&\n      instance.props.trigger.indexOf('click') >= 0 &&\n      ['mouseleave', 'mousemove'].indexOf(event.type) >= 0 &&\n      isVisibleFromClick\n    ) {\n      return;\n    }\n\n    const delay = getDelay(false);\n\n    if (delay) {\n      hideTimeout = setTimeout(() => {\n        if (instance.state.isVisible) {\n          instance.hide();\n        }\n      }, delay);\n    } else {\n      // Fixes a `transitionend` problem when it fires 1 frame too\n      // late sometimes, we don't want hide() to be called.\n      scheduleHideAnimationFrame = requestAnimationFrame(() => {\n        instance.hide();\n      });\n    }\n  }\n\n  // ===========================================================================\n  // 🔑 Public methods\n  // ===========================================================================\n  function enable(): void {\n    instance.state.isEnabled = true;\n  }\n\n  function disable(): void {\n    // Disabling the instance should also hide it\n    // https://github.com/atomiks/tippy.js-react/issues/106\n    instance.hide();\n    instance.state.isEnabled = false;\n  }\n\n  function clearDelayTimeouts(): void {\n    clearTimeout(showTimeout);\n    clearTimeout(hideTimeout);\n    cancelAnimationFrame(scheduleHideAnimationFrame);\n  }\n\n  function setProps(partialProps: Partial<Props>): void {\n    /* istanbul ignore else */\n    if (__DEV__) {\n      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('setProps'));\n    }\n\n    if (instance.state.isDestroyed) {\n      return;\n    }\n\n    invokeHook('onBeforeUpdate', [instance, partialProps]);\n\n    removeListeners();\n\n    const prevProps = instance.props;\n    const nextProps = evaluateProps(reference, {\n      ...prevProps,\n      ...removeUndefinedProps(partialProps),\n      ignoreAttributes: true,\n    });\n\n    instance.props = nextProps;\n\n    addListeners();\n\n    if (prevProps.interactiveDebounce !== nextProps.interactiveDebounce) {\n      cleanupInteractiveMouseListeners();\n      debouncedOnMouseMove = debounce(\n        onMouseMove,\n        nextProps.interactiveDebounce\n      );\n    }\n\n    // Ensure stale aria-expanded attributes are removed\n    if (prevProps.triggerTarget && !nextProps.triggerTarget) {\n      normalizeToArray(prevProps.triggerTarget).forEach((node) => {\n        node.removeAttribute('aria-expanded');\n      });\n    } else if (nextProps.triggerTarget) {\n      reference.removeAttribute('aria-expanded');\n    }\n\n    handleAriaExpandedAttribute();\n    handleStyles();\n\n    if (onUpdate) {\n      onUpdate(prevProps, nextProps);\n    }\n\n    if (instance.popperInstance) {\n      createPopperInstance();\n\n      // Fixes an issue with nested tippies if they are all getting re-rendered,\n      // and the nested ones get re-rendered first.\n      // https://github.com/atomiks/tippyjs-react/issues/177\n      // TODO: find a cleaner / more efficient solution(!)\n      getNestedPopperTree().forEach((nestedPopper) => {\n        // React (and other UI libs likely) requires a rAF wrapper as it flushes\n        // its work in one\n        requestAnimationFrame(nestedPopper._tippy!.popperInstance!.forceUpdate);\n      });\n    }\n\n    invokeHook('onAfterUpdate', [instance, partialProps]);\n  }\n\n  function setContent(content: Content): void {\n    instance.setProps({content});\n  }\n\n  function show(): void {\n    /* istanbul ignore else */\n    if (__DEV__) {\n      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('show'));\n    }\n\n    // Early bail-out\n    const isAlreadyVisible = instance.state.isVisible;\n    const isDestroyed = instance.state.isDestroyed;\n    const isDisabled = !instance.state.isEnabled;\n    const isTouchAndTouchDisabled =\n      currentInput.isTouch && !instance.props.touch;\n    const duration = getValueAtIndexOrReturn(\n      instance.props.duration,\n      0,\n      defaultProps.duration\n    );\n\n    if (\n      isAlreadyVisible ||\n      isDestroyed ||\n      isDisabled ||\n      isTouchAndTouchDisabled\n    ) {\n      return;\n    }\n\n    // Normalize `disabled` behavior across browsers.\n    // Firefox allows events on disabled elements, but Chrome doesn't.\n    // Using a wrapper element (i.e. <span>) is recommended.\n    if (getCurrentTarget().hasAttribute('disabled')) {\n      return;\n    }\n\n    invokeHook('onShow', [instance], false);\n    if (instance.props.onShow(instance) === false) {\n      return;\n    }\n\n    instance.state.isVisible = true;\n\n    if (getIsDefaultRenderFn()) {\n      popper.style.visibility = 'visible';\n    }\n\n    handleStyles();\n    addDocumentPress();\n\n    if (!instance.state.isMounted) {\n      popper.style.transition = 'none';\n    }\n\n    // If flipping to the opposite side after hiding at least once, the\n    // animation will use the wrong placement without resetting the duration\n    if (getIsDefaultRenderFn()) {\n      const {box, content} = getDefaultTemplateChildren();\n      setTransitionDuration([box, content], 0);\n    }\n\n    onFirstUpdate = (): void => {\n      if (!instance.state.isVisible || ignoreOnFirstUpdate) {\n        return;\n      }\n\n      ignoreOnFirstUpdate = true;\n\n      // reflow\n      void popper.offsetHeight;\n\n      popper.style.transition = instance.props.moveTransition;\n\n      if (getIsDefaultRenderFn() && instance.props.animation) {\n        const {box, content} = getDefaultTemplateChildren();\n        setTransitionDuration([box, content], duration);\n        setVisibilityState([box, content], 'visible');\n      }\n\n      handleAriaContentAttribute();\n      handleAriaExpandedAttribute();\n\n      pushIfUnique(mountedInstances, instance);\n\n      // certain modifiers (e.g. `maxSize`) require a second update after the\n      // popper has been positioned for the first time\n      instance.popperInstance?.forceUpdate();\n\n      invokeHook('onMount', [instance]);\n\n      if (instance.props.animation && getIsDefaultRenderFn()) {\n        onTransitionedIn(duration, () => {\n          instance.state.isShown = true;\n          invokeHook('onShown', [instance]);\n        });\n      }\n    };\n\n    mount();\n  }\n\n  function hide(): void {\n    /* istanbul ignore else */\n    if (__DEV__) {\n      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('hide'));\n    }\n\n    // Early bail-out\n    const isAlreadyHidden = !instance.state.isVisible;\n    const isDestroyed = instance.state.isDestroyed;\n    const isDisabled = !instance.state.isEnabled;\n    const duration = getValueAtIndexOrReturn(\n      instance.props.duration,\n      1,\n      defaultProps.duration\n    );\n\n    if (isAlreadyHidden || isDestroyed || isDisabled) {\n      return;\n    }\n\n    invokeHook('onHide', [instance], false);\n    if (instance.props.onHide(instance) === false) {\n      return;\n    }\n\n    instance.state.isVisible = false;\n    instance.state.isShown = false;\n    ignoreOnFirstUpdate = false;\n    isVisibleFromClick = false;\n\n    if (getIsDefaultRenderFn()) {\n      popper.style.visibility = 'hidden';\n    }\n\n    cleanupInteractiveMouseListeners();\n    removeDocumentPress();\n    handleStyles(true);\n\n    if (getIsDefaultRenderFn()) {\n      const {box, content} = getDefaultTemplateChildren();\n\n      if (instance.props.animation) {\n        setTransitionDuration([box, content], duration);\n        setVisibilityState([box, content], 'hidden');\n      }\n    }\n\n    handleAriaContentAttribute();\n    handleAriaExpandedAttribute();\n\n    if (instance.props.animation) {\n      if (getIsDefaultRenderFn()) {\n        onTransitionedOut(duration, instance.unmount);\n      }\n    } else {\n      instance.unmount();\n    }\n  }\n\n  function hideWithInteractivity(event: MouseEvent): void {\n    /* istanbul ignore else */\n    if (__DEV__) {\n      warnWhen(\n        instance.state.isDestroyed,\n        createMemoryLeakWarning('hideWithInteractivity')\n      );\n    }\n\n    getDocument().addEventListener('mousemove', debouncedOnMouseMove);\n    pushIfUnique(mouseMoveListeners, debouncedOnMouseMove);\n    debouncedOnMouseMove(event);\n  }\n\n  function unmount(): void {\n    /* istanbul ignore else */\n    if (__DEV__) {\n      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('unmount'));\n    }\n\n    if (instance.state.isVisible) {\n      instance.hide();\n    }\n\n    if (!instance.state.isMounted) {\n      return;\n    }\n\n    destroyPopperInstance();\n\n    // If a popper is not interactive, it will be appended outside the popper\n    // tree by default. This seems mainly for interactive tippies, but we should\n    // find a workaround if possible\n    getNestedPopperTree().forEach((nestedPopper) => {\n      nestedPopper._tippy!.unmount();\n    });\n\n    if (popper.parentNode) {\n      popper.parentNode.removeChild(popper);\n    }\n\n    mountedInstances = mountedInstances.filter((i) => i !== instance);\n\n    instance.state.isMounted = false;\n    invokeHook('onHidden', [instance]);\n  }\n\n  function destroy(): void {\n    /* istanbul ignore else */\n    if (__DEV__) {\n      warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('destroy'));\n    }\n\n    if (instance.state.isDestroyed) {\n      return;\n    }\n\n    instance.clearDelayTimeouts();\n    instance.unmount();\n\n    removeListeners();\n\n    delete reference._tippy;\n\n    instance.state.isDestroyed = true;\n\n    invokeHook('onDestroy', [instance]);\n  }\n}\n","import bindGlobalEventListeners, {\n  currentInput,\n} from './bindGlobalEventListeners';\nimport createTippy, {mountedInstances} from './createTippy';\nimport {getArrayOfElements, isElement, isReferenceElement} from './dom-utils';\nimport {defaultProps, setDefaultProps, validateProps} from './props';\nimport {HideAll, HideAllOptions, Instance, Props, Targets} from './types';\nimport {validateTargets, warnWhen} from './validation';\n\nfunction tippy(\n  targets: Targets,\n  optionalProps: Partial<Props> = {}\n): Instance | Instance[] {\n  const plugins = defaultProps.plugins.concat(optionalProps.plugins || []);\n\n  /* istanbul ignore else */\n  if (__DEV__) {\n    validateTargets(targets);\n    validateProps(optionalProps, plugins);\n  }\n\n  bindGlobalEventListeners();\n\n  const passedProps: Partial<Props> = {...optionalProps, plugins};\n\n  const elements = getArrayOfElements(targets);\n\n  /* istanbul ignore else */\n  if (__DEV__) {\n    const isSingleContentElement = isElement(passedProps.content);\n    const isMoreThanOneReferenceElement = elements.length > 1;\n    warnWhen(\n      isSingleContentElement && isMoreThanOneReferenceElement,\n      [\n        'tippy() was passed an Element as the `content` prop, but more than',\n        'one tippy instance was created by this invocation. This means the',\n        'content element will only be appended to the last tippy instance.',\n        '\\n\\n',\n        'Instead, pass the .innerHTML of the element, or use a function that',\n        'returns a cloned version of the element instead.',\n        '\\n\\n',\n        '1) content: element.innerHTML\\n',\n        '2) content: () => element.cloneNode(true)',\n      ].join(' ')\n    );\n  }\n\n  const instances = elements.reduce<Instance[]>(\n    (acc, reference): Instance[] => {\n      const instance = reference && createTippy(reference, passedProps);\n\n      if (instance) {\n        acc.push(instance);\n      }\n\n      return acc;\n    },\n    []\n  );\n\n  return isElement(targets) ? instances[0] : instances;\n}\n\ntippy.defaultProps = defaultProps;\ntippy.setDefaultProps = setDefaultProps;\ntippy.currentInput = currentInput;\n\nexport default tippy;\n\nexport const hideAll: HideAll = ({\n  exclude: excludedReferenceOrInstance,\n  duration,\n}: HideAllOptions = {}) => {\n  mountedInstances.forEach((instance) => {\n    let isExcluded = false;\n\n    if (excludedReferenceOrInstance) {\n      isExcluded = isReferenceElement(excludedReferenceOrInstance)\n        ? instance.reference === excludedReferenceOrInstance\n        : instance.popper === (excludedReferenceOrInstance as Instance).popper;\n    }\n\n    if (!isExcluded) {\n      const originalDuration = instance.props.duration;\n\n      instance.setProps({duration});\n      instance.hide();\n\n      if (!instance.state.isDestroyed) {\n        instance.setProps({duration: originalDuration});\n      }\n    }\n  });\n};\n","import tippy from '..';\nimport {div} from '../dom-utils';\nimport {\n  CreateSingleton,\n  Plugin,\n  CreateSingletonProps,\n  ReferenceElement,\n  CreateSingletonInstance,\n  Instance,\n  Props,\n} from '../types';\nimport {normalizeToArray, removeProperties} from '../utils';\nimport {errorWhen} from '../validation';\nimport {applyStyles, Modifier} from '@popperjs/core';\n\n// The default `applyStyles` modifier has a cleanup function that gets called\n// every time the popper is destroyed (i.e. a new target), removing the styles\n// and causing transitions to break for singletons when the console is open, but\n// most notably for non-transform styles being used, `gpuAcceleration: false`.\nconst applyStylesModifier: Modifier<'applyStyles', Record<string, unknown>> = {\n  ...applyStyles,\n  effect({state}) {\n    const initialStyles = {\n      popper: {\n        position: state.options.strategy,\n        left: '0',\n        top: '0',\n        margin: '0',\n      },\n      arrow: {\n        position: 'absolute',\n      },\n      reference: {},\n    };\n\n    Object.assign(state.elements.popper.style, initialStyles.popper);\n    state.styles = initialStyles;\n\n    if (state.elements.arrow) {\n      Object.assign(state.elements.arrow.style, initialStyles.arrow);\n    }\n\n    // intentionally return no cleanup function\n    // return () => { ... }\n  },\n};\n\nconst createSingleton: CreateSingleton = (\n  tippyInstances,\n  optionalProps = {}\n) => {\n  /* istanbul ignore else */\n  if (__DEV__) {\n    errorWhen(\n      !Array.isArray(tippyInstances),\n      [\n        'The first argument passed to createSingleton() must be an array of',\n        'tippy instances. The passed value was',\n        String(tippyInstances),\n      ].join(' ')\n    );\n  }\n\n  let individualInstances = tippyInstances;\n  let references: Array<ReferenceElement> = [];\n  let triggerTargets: Array<Element> = [];\n  let currentTarget: Element | null;\n  let overrides = optionalProps.overrides;\n  let interceptSetPropsCleanups: Array<() => void> = [];\n  let shownOnCreate = false;\n\n  function setTriggerTargets(): void {\n    triggerTargets = individualInstances\n      .map((instance) =>\n        normalizeToArray(instance.props.triggerTarget || instance.reference)\n      )\n      .reduce((acc, item) => acc.concat(item), []);\n  }\n\n  function setReferences(): void {\n    references = individualInstances.map((instance) => instance.reference);\n  }\n\n  function enableInstances(isEnabled: boolean): void {\n    individualInstances.forEach((instance) => {\n      if (isEnabled) {\n        instance.enable();\n      } else {\n        instance.disable();\n      }\n    });\n  }\n\n  function interceptSetProps(singleton: Instance): Array<() => void> {\n    return individualInstances.map((instance) => {\n      const originalSetProps = instance.setProps;\n\n      instance.setProps = (props): void => {\n        originalSetProps(props);\n\n        if (instance.reference === currentTarget) {\n          singleton.setProps(props);\n        }\n      };\n\n      return (): void => {\n        instance.setProps = originalSetProps;\n      };\n    });\n  }\n\n  // have to pass singleton, as it maybe undefined on first call\n  function prepareInstance(\n    singleton: Instance,\n    target: ReferenceElement\n  ): void {\n    const index = triggerTargets.indexOf(target);\n\n    // bail-out\n    if (target === currentTarget) {\n      return;\n    }\n\n    currentTarget = target;\n\n    const overrideProps: Partial<Props> = (overrides || [])\n      .concat('content')\n      .reduce((acc, prop) => {\n        (acc as any)[prop] = individualInstances[index].props[prop];\n        return acc;\n      }, {});\n\n    singleton.setProps({\n      ...overrideProps,\n      getReferenceClientRect:\n        typeof overrideProps.getReferenceClientRect === 'function'\n          ? overrideProps.getReferenceClientRect\n          : (): ClientRect => references[index]?.getBoundingClientRect(),\n    });\n  }\n\n  enableInstances(false);\n  setReferences();\n  setTriggerTargets();\n\n  const plugin: Plugin = {\n    fn() {\n      return {\n        onDestroy(): void {\n          enableInstances(true);\n        },\n        onHidden(): void {\n          currentTarget = null;\n        },\n        onClickOutside(instance): void {\n          if (instance.props.showOnCreate && !shownOnCreate) {\n            shownOnCreate = true;\n            currentTarget = null;\n          }\n        },\n        onShow(instance): void {\n          if (instance.props.showOnCreate && !shownOnCreate) {\n            shownOnCreate = true;\n            prepareInstance(instance, references[0]);\n          }\n        },\n        onTrigger(instance, event): void {\n          prepareInstance(instance, event.currentTarget as Element);\n        },\n      };\n    },\n  };\n\n  const singleton = tippy(div(), {\n    ...removeProperties(optionalProps, ['overrides']),\n    plugins: [plugin, ...(optionalProps.plugins || [])],\n    triggerTarget: triggerTargets,\n    popperOptions: {\n      ...optionalProps.popperOptions,\n      modifiers: [\n        ...(optionalProps.popperOptions?.modifiers || []),\n        applyStylesModifier,\n      ],\n    },\n  }) as CreateSingletonInstance<CreateSingletonProps>;\n\n  const originalShow = singleton.show;\n\n  singleton.show = (target?: ReferenceElement | Instance | number): void => {\n    originalShow();\n\n    // first time, showOnCreate or programmatic call with no params\n    // default to showing first instance\n    if (!currentTarget && target == null) {\n      return prepareInstance(singleton, references[0]);\n    }\n\n    // triggered from event (do nothing as prepareInstance already called by onTrigger)\n    // programmatic call with no params when already visible (do nothing again)\n    if (currentTarget && target == null) {\n      return;\n    }\n\n    // target is index of instance\n    if (typeof target === 'number') {\n      return (\n        references[target] && prepareInstance(singleton, references[target])\n      );\n    }\n\n    // target is a child tippy instance\n    if (individualInstances.indexOf(target as Instance) >= 0) {\n      const ref = (target as Instance).reference;\n      return prepareInstance(singleton, ref);\n    }\n\n    // target is a ReferenceElement\n    if (references.indexOf(target as ReferenceElement) >= 0) {\n      return prepareInstance(singleton, target as ReferenceElement);\n    }\n  };\n\n  singleton.showNext = (): void => {\n    const first = references[0];\n    if (!currentTarget) {\n      return singleton.show(0);\n    }\n    const index = references.indexOf(currentTarget);\n    singleton.show(references[index + 1] || first);\n  };\n\n  singleton.showPrevious = (): void => {\n    const last = references[references.length - 1];\n    if (!currentTarget) {\n      return singleton.show(last);\n    }\n    const index = references.indexOf(currentTarget);\n    const target = references[index - 1] || last;\n    singleton.show(target);\n  };\n\n  const originalSetProps = singleton.setProps;\n\n  singleton.setProps = (props): void => {\n    overrides = props.overrides || overrides;\n    originalSetProps(props);\n  };\n\n  singleton.setInstances = (nextInstances): void => {\n    enableInstances(true);\n    interceptSetPropsCleanups.forEach((fn) => fn());\n\n    individualInstances = nextInstances;\n\n    enableInstances(false);\n    setReferences();\n    setTriggerTargets();\n    interceptSetPropsCleanups = interceptSetProps(singleton);\n\n    singleton.setProps({triggerTarget: triggerTargets});\n  };\n\n  interceptSetPropsCleanups = interceptSetProps(singleton);\n\n  return singleton;\n};\n\nexport default createSingleton;\n","import tippy from '../src';\nimport {render} from '../src/template';\n\ntippy.setDefaultProps({render});\n\nexport {default, hideAll} from '../src';\nexport {default as createSingleton} from '../src/addons/createSingleton';\nexport {default as delegate} from '../src/addons/delegate';\nexport {default as animateFill} from '../src/plugins/animateFill';\nexport {default as followCursor} from '../src/plugins/followCursor';\nexport {default as inlinePositioning} from '../src/plugins/inlinePositioning';\nexport {default as sticky} from '../src/plugins/sticky';\nexport {ROUND_ARROW as roundArrow} from '../src/constants';\n"],"names":["Math","trimLeft","trimRight","tinyCounter","mathRound","round","mathMin","min","mathMax","max","mathRandom","random","tinycolor","color","opts","this","rgb","r","g","b","a","s","v","l","ok","format","replace","toLowerCase","match","named","names","matchers","exec","rgba","hsl","h","hsla","hsv","hsva","hex8","parseIntFromHex","convertHexToDecimal","hex6","hex4","hex3","stringInputToObject","isValidCSSUnit","bound01","String","substr","convertToPercentage","i","floor","f","p","q","t","mod","hsvToRgb","hue2rgb","hslToRgb","hasOwnProperty","boundAlpha","inputToRGB","_originalInput","_r","_g","_b","_a","_roundA","_format","_gradientType","gradientType","_ok","_tc_id","rgbToHsl","d","rgbToHsv","rgbToHex","allow3Char","hex","pad2","toString","charAt","join","rgbaToArgbHex","convertDecimalToHex","desaturate","amount","toHsl","clamp01","saturate","greyscale","lighten","brighten","toRgb","darken","spin","hue","complement","triad","tetrad","splitcomplement","analogous","results","slices","part","ret","push","monochromatic","toHsv","modification","prototype","isDark","getBrightness","isLight","isValid","getOriginalInput","getFormat","getAlpha","getLuminance","RsRGB","GsRGB","BsRGB","pow","setAlpha","value","toHsvString","toHslString","toHex","toHexString","toHex8","allow4Char","rgbaToHex","toHex8String","toRgbString","toPercentageRgb","toPercentageRgbString","toName","hexNames","toFilter","secondColor","hex8String","secondHex8String","formatSet","formattedString","hasAlpha","clone","_applyModification","fn","args","apply","concat","slice","call","arguments","_applyCombination","fromRatio","newColor","equals","color1","color2","mix","rgb1","rgb2","readability","c1","c2","isReadable","wcag2","wcag2Parms","out","parms","level","size","toUpperCase","validateWCAG2Parms","mostReadable","baseColor","colorList","includeFallbackColors","bestColor","bestScore","length","aliceblue","antiquewhite","aqua","aquamarine","azure","beige","bisque","black","blanchedalmond","blue","blueviolet","brown","burlywood","burntsienna","cadetblue","chartreuse","chocolate","coral","cornflowerblue","cornsilk","crimson","cyan","darkblue","darkcyan","darkgoldenrod","darkgray","darkgreen","darkgrey","darkkhaki","darkmagenta","darkolivegreen","darkorange","darkorchid","darkred","darksalmon","darkseagreen","darkslateblue","darkslategray","darkslategrey","darkturquoise","darkviolet","deeppink","deepskyblue","dimgray","dimgrey","dodgerblue","firebrick","floralwhite","forestgreen","fuchsia","gainsboro","ghostwhite","gold","goldenrod","gray","green","greenyellow","grey","honeydew","hotpink","indianred","indigo","ivory","khaki","lavender","lavenderblush","lawngreen","lemonchiffon","lightblue","lightcoral","lightcyan","lightgoldenrodyellow","lightgray","lightgreen","lightgrey","lightpink","lightsalmon","lightseagreen","lightskyblue","lightslategray","lightslategrey","lightsteelblue","lightyellow","lime","limegreen","linen","magenta","maroon","mediumaquamarine","mediumblue","mediumorchid","mediumpurple","mediumseagreen","mediumslateblue","mediumspringgreen","mediumturquoise","mediumvioletred","midnightblue","mintcream","mistyrose","moccasin","navajowhite","navy","oldlace","olive","olivedrab","orange","orangered","orchid","palegoldenrod","palegreen","paleturquoise","palevioletred","papayawhip","peachpuff","peru","pink","plum","powderblue","purple","rebeccapurple","red","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","slategrey","snow","springgreen","steelblue","tan","teal","thistle","tomato","turquoise","violet","wheat","white","whitesmoke","yellow","yellowgreen","o","flipped","flip","parseFloat","isNaN","n","indexOf","isOnePointZero","processPercent","isPercentage","parseInt","abs","val","c","CSS_UNIT","PERMISSIVE_MATCH3","PERMISSIVE_MATCH4","RegExp","module","exports","define","CONTENT_CLASS","BACKDROP_CLASS","ARROW_CLASS","SVG_ARROW_CLASS","TOUCH_OPTIONS","passive","capture","TIPPY_DEFAULT_APPEND_TO","document","body","getValueAtIndexOrReturn","index","defaultValue","Array","isArray","isType","type","str","invokeWithArgsOrReturn","debounce","ms","arg","clearTimeout","timeout","setTimeout","normalizeToArray","pushIfUnique","arr","getBasePlacement","placement","split","arrayFrom","removeUndefinedProps","obj","Object","keys","reduce","acc","key","undefined","div","createElement","isElement","some","isMouseEvent","isReferenceElement","_tippy","reference","getArrayOfElements","isNodeList","querySelectorAll","setTransitionDuration","els","forEach","el","style","transitionDuration","setVisibilityState","state","setAttribute","getOwnerDocument","elementOrElements","_element$ownerDocumen","element","ownerDocument","updateTransitionEndListener","box","action","listener","method","event","actualContains","parent","child","target","_target$getRootNode","contains","getRootNode","host","currentInput","isTouch","lastMouseMoveTime","onDocumentTouchStart","window","performance","addEventListener","onDocumentMouseMove","now","removeEventListener","onWindowBlur","activeElement","instance","blur","isVisible","isIE11","msCrypto","pluginProps","animateFill","followCursor","inlinePositioning","sticky","defaultProps","assign","appendTo","aria","content","expanded","delay","duration","getReferenceClientRect","hideOnClick","ignoreAttributes","interactive","interactiveBorder","interactiveDebounce","moveTransition","offset","onAfterUpdate","onBeforeUpdate","onCreate","onDestroy","onHidden","onHide","onMount","onShow","onShown","onTrigger","onUntrigger","onClickOutside","plugins","popperOptions","render","showOnCreate","touch","trigger","triggerTarget","allowHTML","animation","arrow","inertia","maxWidth","role","theme","zIndex","defaultKeys","getExtendedPassedProps","passedProps","plugin","_name","name","evaluateProps","props","valueAsString","getAttribute","trim","JSON","parse","e","getDataAttributeProps","dangerouslySetInnerHTML","html","createArrowElement","className","appendChild","setContent","textContent","getChildren","popper","firstElementChild","boxChildren","children","find","node","classList","backdrop","onUpdate","prevProps","nextProps","_getChildren","removeAttribute","removeChild","$$tippy","idCounter","mouseMoveListeners","mountedInstances","createTippy","showTimeout","hideTimeout","scheduleHideAnimationFrame","lastTriggerEvent","currentTransitionEndListener","onFirstUpdate","currentTarget","isVisibleFromClick","didHideDueToDocumentMouseDown","didTouchMove","ignoreOnFirstUpdate","listeners","debouncedOnMouseMove","onMouseMove","id","filter","item","popperInstance","isEnabled","isDestroyed","isMounted","isShown","clearDelayTimeouts","cancelAnimationFrame","setProps","partialProps","process","invokeHook","removeListeners","addListeners","cleanupInteractiveMouseListeners","handleAriaExpandedAttribute","handleStyles","createPopperInstance","getNestedPopperTree","nestedPopper","requestAnimationFrame","forceUpdate","show","isAlreadyVisible","isDisabled","isTouchAndTouchDisabled","getCurrentTarget","hasAttribute","getIsDefaultRenderFn","visibility","addDocumentPress","transition","_getDefaultTemplateCh2","getDefaultTemplateChildren","_instance$popperInsta2","offsetHeight","_getDefaultTemplateCh3","_box","_content","handleAriaContentAttribute","callback","onTransitionEnd","onTransitionedIn","parentNode","mount","hide","isAlreadyHidden","removeDocumentPress","_getDefaultTemplateCh4","onTransitionedOut","unmount","hideWithInteractivity","getDocument","enable","disable","destroyPopperInstance","destroy","_props$render","pluginsHooks","map","hasAriaExpanded","scheduleShow","getNormalizedTouchSettings","getIsCustomTouchBehavior","_instance$props$rende","getDelay","isShow","fromHide","pointerEvents","hook","shouldInvokePropsHook","_instance$props","pluginHooks","attr","currentValue","nextValue","onDocumentPress","actualTarget","composedPath","onTouchMove","onTouchStart","doc","on","eventType","handler","options","onMouseLeave","Boolean","onBlurOrFocusOut","_ref","_lastTriggerEvent","shouldScheduleClickHide","isEventListenerStopped","wasFocused","scheduleHide","isCursorOverReferenceOrPopper","popperTreeData","_instance$popperInsta","popperRect","getBoundingClientRect","popperState","clientX","clientY","every","basePlacement","offsetData","modifiersData","topDistance","top","y","bottomDistance","bottom","leftDistance","left","x","rightDistance","right","exceedsTop","exceedsBottom","exceedsLeft","exceedsRight","isCursorOutsideInteractiveBorder","relatedTarget","_instance$props2","computedReference","contextElement","tippyModifier","enabled","phase","requires","_ref2","attributes","modifiers","padding","adaptive","createPopper","_getNormalizedTouchSe","touchValue","touchDelay","tippy","targets","optionalProps","instances","setDefaultProps","applyStyles","effect","initialStyles","position","strategy","margin","elements","styles"],"sourceRoot":""}