{"version":3,"sources":["webpack:///./node_modules/@ionic/vue/node_modules/ionicons/dist/esm/legacy/shadow-css-984bac74-549b16dd.js"],"names":["scopeCss","cssText","scopeId","commentOriginalSelector","sc","ShadowCss","shimCssText","this","strictStyling","prototype","hostScopeId","slotScopeId","commentsWithHash","extractCommentsWithHash","stripComments","orgSelectors","processCommentedSelector_1","rule","placeholder","length","comment","selector","push","processRules","startsWith","content","scopedCssText","_scopeCssText","concat","join","forEach","_a","replace","_insertPolyfillHostInCssText","_convertColonHost","_convertColonHostContext","_convertColonSlotted","_convertShadowDOMSelectors","_scopeSelectors","trim","_convertColonRule","_cssColonHostRe","_colonHostPartReplacer","slotAttr","regExp","_cssColonSlottedRe","m","_i","arguments","compound","suffix","sel","_polyfillHostNoCombinator","_cssColonHostContextRe","_colonHostContextPartReplacer","partReplacer","parts","split","r","i","p","host","part","indexOf","_polyfillHost","_shadowDOMSelectorsRe","reduce","result","pattern","scopeSelector","hostSelector","slotSelector","_this","_scopeSelector","CssRule","strict","map","shallowPart","_selectorNeedsScoping","_applyStrictSelectorScope","_applySelectorScope","re","_makeScopeMatcher","test","lre","rre","RegExp","_selectorReSuffix","_applySimpleSelectorScope","_polyfillHostRe","lastIndex","replaceBy_1","_polyfillHostNoCombinatorRe","_","before","colon","after","isRe","className","_scopeSelectorPart","scopedP","t","matches","match","safeContent","SafeSelector","res","scopedSelector","startIndex","sep","hasHost","shouldScope","exec","separator","part_1","slice","index","scopedPart","substring","restore","_colonHostContextRe","_polyfillHostContext","_colonHostRe","_colonSlottedRe","_polyfillSlotted","placeholders","keep","replaceBy","_content","pseudo","exp","_parenSuffix","_commentRe","input","_commentWithHashRe","_ruleRe","_curlyRe","OPEN_CURLY","CLOSE_CURLY","BLOCK_PLACEHOLDER","ruleCallback","inputWithEscapedBlocks","escapeBlocks","nextBlockIndex","escapedString","contentPrefix","blocks","StringWithEscapedBlocks","inputParts","resultParts","escapedBlocks","bracketCount","currentBlockParts","partIndex"],"mappings":"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","file":"js/chunk-2d2140aa.057124c0.js","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n *\n * This file is a port of shadowCSS from webcomponents.js to TypeScript.\n * https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js\n * https://github.com/angular/angular/blob/master/packages/compiler/src/shadow_css.ts\n */\nfunction scopeCss(cssText, scopeId, commentOriginalSelector) {\n    var sc = new ShadowCss();\n    return sc.shimCssText(cssText, scopeId, scopeId + '-h', scopeId + '-s', commentOriginalSelector);\n}\nvar ShadowCss = /** @class */ (function () {\n    function ShadowCss() {\n        this.strictStyling = true;\n    }\n    ShadowCss.prototype.shimCssText = function (cssText, scopeId, hostScopeId, slotScopeId, commentOriginalSelector) {\n        if (hostScopeId === void 0) { hostScopeId = ''; }\n        if (slotScopeId === void 0) { slotScopeId = ''; }\n        if (commentOriginalSelector === void 0) { commentOriginalSelector = false; }\n        var commentsWithHash = extractCommentsWithHash(cssText);\n        cssText = stripComments(cssText);\n        var orgSelectors = [];\n        if (commentOriginalSelector) {\n            var processCommentedSelector_1 = function (rule) {\n                var placeholder = \"/*!@___\" + orgSelectors.length + \"___*/\";\n                var comment = \"/*!@\" + rule.selector + \"*/\";\n                orgSelectors.push({ placeholder: placeholder, comment: comment });\n                rule.selector = placeholder + rule.selector;\n                return rule;\n            };\n            cssText = processRules(cssText, function (rule) {\n                if (rule.selector[0] !== '@') {\n                    return processCommentedSelector_1(rule);\n                }\n                else if (rule.selector.startsWith('@media') || rule.selector.startsWith('@supports') ||\n                    rule.selector.startsWith('@page') || rule.selector.startsWith('@document')) {\n                    rule.content = processRules(rule.content, processCommentedSelector_1);\n                    return rule;\n                }\n                return rule;\n            });\n        }\n        var scopedCssText = this._scopeCssText(cssText, scopeId, hostScopeId, slotScopeId, commentOriginalSelector);\n        cssText = [scopedCssText].concat(commentsWithHash).join('\\n');\n        if (commentOriginalSelector) {\n            orgSelectors.forEach(function (_a) {\n                var placeholder = _a.placeholder, comment = _a.comment;\n                cssText = cssText.replace(placeholder, comment);\n            });\n        }\n        return cssText;\n    };\n    ShadowCss.prototype._scopeCssText = function (cssText, scopeId, hostScopeId, slotScopeId, commentOriginalSelector) {\n        // replace :host and :host-context -shadowcsshost and -shadowcsshost respectively\n        cssText = this._insertPolyfillHostInCssText(cssText);\n        cssText = this._convertColonHost(cssText);\n        cssText = this._convertColonHostContext(cssText);\n        cssText = this._convertColonSlotted(cssText, slotScopeId);\n        cssText = this._convertShadowDOMSelectors(cssText);\n        if (scopeId) {\n            cssText = this._scopeSelectors(cssText, scopeId, hostScopeId, slotScopeId, commentOriginalSelector);\n        }\n        cssText = cssText.replace(/-shadowcsshost-no-combinator/g, \".\" + hostScopeId);\n        cssText = cssText.replace(/>\\s*\\*\\s+([^{, ]+)/gm, ' $1 ');\n        return cssText.trim();\n    };\n    /*\n     * convert a rule like :host(.foo) > .bar { }\n     *\n     * to\n     *\n     * .foo<scopeName> > .bar\n    */\n    ShadowCss.prototype._convertColonHost = function (cssText) {\n        return this._convertColonRule(cssText, _cssColonHostRe, this._colonHostPartReplacer);\n    };\n    /*\n   * convert a rule like ::slotted(.foo) { }\n  */\n    ShadowCss.prototype._convertColonSlotted = function (cssText, slotAttr) {\n        var regExp = _cssColonSlottedRe;\n        return cssText.replace(regExp, function () {\n            var m = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                m[_i] = arguments[_i];\n            }\n            if (m[2]) {\n                var compound = m[2].trim();\n                var suffix = m[3];\n                var sel = '.' + slotAttr + ' > ' + compound + suffix;\n                return sel;\n            }\n            else {\n                return _polyfillHostNoCombinator + m[3];\n            }\n        });\n    };\n    /*\n     * convert a rule like :host-context(.foo) > .bar { }\n     *\n     * to\n     *\n     * .foo<scopeName> > .bar, .foo scopeName > .bar { }\n     *\n     * and\n     *\n     * :host-context(.foo:host) .bar { ... }\n     *\n     * to\n     *\n     * .foo<scopeName> .bar { ... }\n    */\n    ShadowCss.prototype._convertColonHostContext = function (cssText) {\n        return this._convertColonRule(cssText, _cssColonHostContextRe, this._colonHostContextPartReplacer);\n    };\n    ShadowCss.prototype._convertColonRule = function (cssText, regExp, partReplacer) {\n        // m[1] = :host(-context), m[2] = contents of (), m[3] rest of rule\n        return cssText.replace(regExp, function () {\n            var m = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                m[_i] = arguments[_i];\n            }\n            if (m[2]) {\n                var parts = m[2].split(',');\n                var r = [];\n                for (var i = 0; i < parts.length; i++) {\n                    var p = parts[i].trim();\n                    if (!p)\n                        break;\n                    r.push(partReplacer(_polyfillHostNoCombinator, p, m[3]));\n                }\n                return r.join(',');\n            }\n            else {\n                return _polyfillHostNoCombinator + m[3];\n            }\n        });\n    };\n    ShadowCss.prototype._colonHostContextPartReplacer = function (host, part, suffix) {\n        if (part.indexOf(_polyfillHost) > -1) {\n            return this._colonHostPartReplacer(host, part, suffix);\n        }\n        else {\n            return host + part + suffix + ', ' + part + ' ' + host + suffix;\n        }\n    };\n    ShadowCss.prototype._colonHostPartReplacer = function (host, part, suffix) {\n        return host + part.replace(_polyfillHost, '') + suffix;\n    };\n    /*\n     * Convert combinators like ::shadow and pseudo-elements like ::content\n     * by replacing with space.\n    */\n    ShadowCss.prototype._convertShadowDOMSelectors = function (cssText) {\n        return _shadowDOMSelectorsRe.reduce(function (result, pattern) { return result.replace(pattern, ' '); }, cssText);\n    };\n    // change a selector like 'div' to 'name div'\n    ShadowCss.prototype._scopeSelectors = function (cssText, scopeSelector, hostSelector, slotSelector, commentOriginalSelector) {\n        var _this = this;\n        return processRules(cssText, function (rule) {\n            var selector = rule.selector;\n            var content = rule.content;\n            if (rule.selector[0] !== '@') {\n                selector =\n                    _this._scopeSelector(rule.selector, scopeSelector, hostSelector, slotSelector, _this.strictStyling);\n            }\n            else if (rule.selector.startsWith('@media') || rule.selector.startsWith('@supports') ||\n                rule.selector.startsWith('@page') || rule.selector.startsWith('@document')) {\n                content = _this._scopeSelectors(rule.content, scopeSelector, hostSelector, slotSelector, commentOriginalSelector);\n            }\n            selector = selector.replace(/\\s{2,}/g, ' ').trim();\n            return new CssRule(selector, content);\n        });\n    };\n    ShadowCss.prototype._scopeSelector = function (selector, scopeSelector, hostSelector, slotSelector, strict) {\n        var _this = this;\n        return selector.split(',')\n            .map(function (shallowPart) {\n            if (slotSelector && shallowPart.indexOf('.' + slotSelector) > -1) {\n                return shallowPart.trim();\n            }\n            if (_this._selectorNeedsScoping(shallowPart, scopeSelector)) {\n                return strict ?\n                    _this._applyStrictSelectorScope(shallowPart, scopeSelector, hostSelector).trim() :\n                    _this._applySelectorScope(shallowPart, scopeSelector, hostSelector).trim();\n            }\n            else {\n                return shallowPart.trim();\n            }\n        })\n            .join(', ');\n    };\n    ShadowCss.prototype._selectorNeedsScoping = function (selector, scopeSelector) {\n        var re = this._makeScopeMatcher(scopeSelector);\n        return !re.test(selector);\n    };\n    ShadowCss.prototype._makeScopeMatcher = function (scopeSelector) {\n        var lre = /\\[/g;\n        var rre = /\\]/g;\n        scopeSelector = scopeSelector.replace(lre, '\\\\[').replace(rre, '\\\\]');\n        return new RegExp('^(' + scopeSelector + ')' + _selectorReSuffix, 'm');\n    };\n    ShadowCss.prototype._applySelectorScope = function (selector, scopeSelector, hostSelector) {\n        // Difference from webcomponents.js: scopeSelector could not be an array\n        return this._applySimpleSelectorScope(selector, scopeSelector, hostSelector);\n    };\n    // scope via name and [is=name]\n    ShadowCss.prototype._applySimpleSelectorScope = function (selector, scopeSelector, hostSelector) {\n        // In Android browser, the lastIndex is not reset when the regex is used in String.replace()\n        _polyfillHostRe.lastIndex = 0;\n        if (_polyfillHostRe.test(selector)) {\n            var replaceBy_1 = this.strictStyling ? \".\" + hostSelector : scopeSelector;\n            return selector\n                .replace(_polyfillHostNoCombinatorRe, function (_, selector) {\n                return selector.replace(/([^:]*)(:*)(.*)/, function (_, before, colon, after) {\n                    return before + replaceBy_1 + colon + after;\n                });\n            })\n                .replace(_polyfillHostRe, replaceBy_1 + ' ');\n        }\n        return scopeSelector + ' ' + selector;\n    };\n    ShadowCss.prototype._applyStrictSelectorScope = function (selector, scopeSelector, hostSelector) {\n        var _this = this;\n        var isRe = /\\[is=([^\\]]*)\\]/g;\n        scopeSelector = scopeSelector.replace(isRe, function (_) {\n            var parts = [];\n            for (var _i = 1; _i < arguments.length; _i++) {\n                parts[_i - 1] = arguments[_i];\n            }\n            return parts[0];\n        });\n        var className = '.' + scopeSelector;\n        var _scopeSelectorPart = function (p) {\n            var scopedP = p.trim();\n            if (!scopedP) {\n                return '';\n            }\n            if (p.indexOf(_polyfillHostNoCombinator) > -1) {\n                scopedP = _this._applySimpleSelectorScope(p, scopeSelector, hostSelector);\n            }\n            else {\n                // remove :host since it should be unnecessary\n                var t = p.replace(_polyfillHostRe, '');\n                if (t.length > 0) {\n                    var matches = t.match(/([^:]*)(:*)(.*)/);\n                    if (matches) {\n                        scopedP = matches[1] + className + matches[2] + matches[3];\n                    }\n                }\n            }\n            return scopedP;\n        };\n        var safeContent = new SafeSelector(selector);\n        selector = safeContent.content();\n        var scopedSelector = '';\n        var startIndex = 0;\n        var res;\n        var sep = /( |>|\\+|~(?!=))\\s*/g;\n        // If a selector appears before :host it should not be shimmed as it\n        // matches on ancestor elements and not on elements in the host's shadow\n        // `:host-context(div)` is transformed to\n        // `-shadowcsshost-no-combinatordiv, div -shadowcsshost-no-combinator`\n        // the `div` is not part of the component in the 2nd selectors and should not be scoped.\n        // Historically `component-tag:host` was matching the component so we also want to preserve\n        // this behavior to avoid breaking legacy apps (it should not match).\n        // The behavior should be:\n        // - `tag:host` -> `tag[h]` (this is to avoid breaking legacy apps, should not match anything)\n        // - `tag :host` -> `tag [h]` (`tag` is not scoped because it's considered part of a\n        //   `:host-context(tag)`)\n        var hasHost = selector.indexOf(_polyfillHostNoCombinator) > -1;\n        // Only scope parts after the first `-shadowcsshost-no-combinator` when it is present\n        var shouldScope = !hasHost;\n        while ((res = sep.exec(selector)) !== null) {\n            var separator = res[1];\n            var part_1 = selector.slice(startIndex, res.index).trim();\n            shouldScope = shouldScope || part_1.indexOf(_polyfillHostNoCombinator) > -1;\n            var scopedPart = shouldScope ? _scopeSelectorPart(part_1) : part_1;\n            scopedSelector += scopedPart + \" \" + separator + \" \";\n            startIndex = sep.lastIndex;\n        }\n        var part = selector.substring(startIndex);\n        shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;\n        scopedSelector += shouldScope ? _scopeSelectorPart(part) : part;\n        // replace the placeholders with their original values\n        return safeContent.restore(scopedSelector);\n    };\n    ShadowCss.prototype._insertPolyfillHostInCssText = function (selector) {\n        selector = selector\n            .replace(_colonHostContextRe, _polyfillHostContext)\n            .replace(_colonHostRe, _polyfillHost)\n            .replace(_colonSlottedRe, _polyfillSlotted);\n        return selector;\n    };\n    return ShadowCss;\n}());\nvar SafeSelector = /** @class */ (function () {\n    function SafeSelector(selector) {\n        var _this = this;\n        this.placeholders = [];\n        this.index = 0;\n        // Replaces attribute selectors with placeholders.\n        // The WS in [attr=\"va lue\"] would otherwise be interpreted as a selector separator.\n        selector = selector.replace(/(\\[[^\\]]*\\])/g, function (_, keep) {\n            var replaceBy = \"__ph-\" + _this.index + \"__\";\n            _this.placeholders.push(keep);\n            _this.index++;\n            return replaceBy;\n        });\n        // Replaces the expression in `:nth-child(2n + 1)` with a placeholder.\n        // WS and \"+\" would otherwise be interpreted as selector separators.\n        this._content = selector.replace(/(:nth-[-\\w]+)(\\([^)]+\\))/g, function (_, pseudo, exp) {\n            var replaceBy = \"__ph-\" + _this.index + \"__\";\n            _this.placeholders.push(exp);\n            _this.index++;\n            return pseudo + replaceBy;\n        });\n    }\n    SafeSelector.prototype.restore = function (content) {\n        var _this = this;\n        return content.replace(/__ph-(\\d+)__/g, function (_, index) { return _this.placeholders[+index]; });\n    };\n    SafeSelector.prototype.content = function () { return this._content; };\n    return SafeSelector;\n}());\nvar _polyfillHost = '-shadowcsshost';\nvar _polyfillSlotted = '-shadowcssslotted';\n// note: :host-context pre-processed to -shadowcsshostcontext.\nvar _polyfillHostContext = '-shadowcsscontext';\nvar _parenSuffix = ')(?:\\\\((' +\n    '(?:\\\\([^)(]*\\\\)|[^)(]*)+?' +\n    ')\\\\))?([^,{]*)';\nvar _cssColonHostRe = new RegExp('(' + _polyfillHost + _parenSuffix, 'gim');\nvar _cssColonHostContextRe = new RegExp('(' + _polyfillHostContext + _parenSuffix, 'gim');\nvar _cssColonSlottedRe = new RegExp('(' + _polyfillSlotted + _parenSuffix, 'gim');\nvar _polyfillHostNoCombinator = _polyfillHost + '-no-combinator';\nvar _polyfillHostNoCombinatorRe = /-shadowcsshost-no-combinator([^\\s]*)/;\nvar _shadowDOMSelectorsRe = [\n    /::shadow/g,\n    /::content/g\n];\nvar _selectorReSuffix = '([>\\\\s~+\\[.,{:][\\\\s\\\\S]*)?$';\nvar _polyfillHostRe = /-shadowcsshost/gim;\nvar _colonHostRe = /:host/gim;\nvar _colonSlottedRe = /::slotted/gim;\nvar _colonHostContextRe = /:host-context/gim;\nvar _commentRe = /\\/\\*\\s*[\\s\\S]*?\\*\\//g;\nfunction stripComments(input) {\n    return input.replace(_commentRe, '');\n}\nvar _commentWithHashRe = /\\/\\*\\s*#\\s*source(Mapping)?URL=[\\s\\S]+?\\*\\//g;\nfunction extractCommentsWithHash(input) {\n    return input.match(_commentWithHashRe) || [];\n}\nvar _ruleRe = /(\\s*)([^;\\{\\}]+?)(\\s*)((?:{%BLOCK%}?\\s*;?)|(?:\\s*;))/g;\nvar _curlyRe = /([{}])/g;\nvar OPEN_CURLY = '{';\nvar CLOSE_CURLY = '}';\nvar BLOCK_PLACEHOLDER = '%BLOCK%';\nvar CssRule = /** @class */ (function () {\n    function CssRule(selector, content) {\n        this.selector = selector;\n        this.content = content;\n    }\n    return CssRule;\n}());\nfunction processRules(input, ruleCallback) {\n    var inputWithEscapedBlocks = escapeBlocks(input);\n    var nextBlockIndex = 0;\n    return inputWithEscapedBlocks.escapedString.replace(_ruleRe, function () {\n        var m = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            m[_i] = arguments[_i];\n        }\n        var selector = m[2];\n        var content = '';\n        var suffix = m[4];\n        var contentPrefix = '';\n        if (suffix && suffix.startsWith('{' + BLOCK_PLACEHOLDER)) {\n            content = inputWithEscapedBlocks.blocks[nextBlockIndex++];\n            suffix = suffix.substring(BLOCK_PLACEHOLDER.length + 1);\n            contentPrefix = '{';\n        }\n        var rule = ruleCallback(new CssRule(selector, content));\n        return \"\" + m[1] + rule.selector + m[3] + contentPrefix + rule.content + suffix;\n    });\n}\nvar StringWithEscapedBlocks = /** @class */ (function () {\n    function StringWithEscapedBlocks(escapedString, blocks) {\n        this.escapedString = escapedString;\n        this.blocks = blocks;\n    }\n    return StringWithEscapedBlocks;\n}());\nfunction escapeBlocks(input) {\n    var inputParts = input.split(_curlyRe);\n    var resultParts = [];\n    var escapedBlocks = [];\n    var bracketCount = 0;\n    var currentBlockParts = [];\n    for (var partIndex = 0; partIndex < inputParts.length; partIndex++) {\n        var part = inputParts[partIndex];\n        if (part === CLOSE_CURLY) {\n            bracketCount--;\n        }\n        if (bracketCount > 0) {\n            currentBlockParts.push(part);\n        }\n        else {\n            if (currentBlockParts.length > 0) {\n                escapedBlocks.push(currentBlockParts.join(''));\n                resultParts.push(BLOCK_PLACEHOLDER);\n                currentBlockParts = [];\n            }\n            resultParts.push(part);\n        }\n        if (part === OPEN_CURLY) {\n            bracketCount++;\n        }\n    }\n    if (currentBlockParts.length > 0) {\n        escapedBlocks.push(currentBlockParts.join(''));\n        resultParts.push(BLOCK_PLACEHOLDER);\n    }\n    return new StringWithEscapedBlocks(resultParts.join(''), escapedBlocks);\n}\nexport { ShadowCss, scopeCss };\n"],"sourceRoot":""}