{"version":3,"sources":["webpack:///./node_modules/ionicons/dist/esm/legacy/shadow-css-984bac74-549b16dd.js"],"names":["scopeCss","cssText","scopeId","commentOriginalSelector","ShadowCss","shimCssText","prototype","hostScopeId","slotScopeId","processCommentedSelector_1","commentsWithHash","match","_commentWithHashRe","orgSelectors","replace","_commentRe","rule","placeholder","length","comment","selector","push","processRules","startsWith","content","this","_scopeCssText","concat","join","forEach","_a","_insertPolyfillHostInCssText","_convertColonHost","_convertColonHostContext","_convertColonSlotted","_convertShadowDOMSelectors","_scopeSelectors","trim","_convertColonRule","_cssColonHostRe","_colonHostPartReplacer","slotAttr","_cssColonSlottedRe","compound","m","_i","arguments","_polyfillHostNoCombinator","_cssColonHostContextRe","_colonHostContextPartReplacer","regExp","partReplacer","parts","split","r","i","p","host","part","suffix","indexOf","_polyfillHost","_shadowDOMSelectorsRe","reduce","result","pattern","scopeSelector","hostSelector","slotSelector","_this","_scopeSelector","strictStyling","CssRule","strict","map","shallowPart","_selectorNeedsScoping","_applyStrictSelectorScope","_applySelectorScope","_makeScopeMatcher","test","RegExp","_selectorReSuffix","_applySimpleSelectorScope","replaceBy_1","_polyfillHostRe","lastIndex","_polyfillHostNoCombinatorRe","_","before","colon","after","className","_scopeSelectorPart","scopedP","t","matches","safeContent","SafeSelector","scopedSelector","startIndex","sep","shouldScope","res","exec","separator","part_1","slice","index","substring","restore","_colonHostContextRe","_polyfillHostContext","_colonHostRe","_colonSlottedRe","_polyfillSlotted","placeholders","_content","keep","replaceBy","pseudo","exp","_parenSuffix","_ruleRe","_curlyRe","OPEN_CURLY","CLOSE_CURLY","BLOCK_PLACEHOLDER","input","ruleCallback","inputWithEscapedBlocks","inputParts","resultParts","escapedBlocks","bracketCount","currentBlockParts","partIndex","StringWithEscapedBlocks","nextBlockIndex","escapedString","contentPrefix","blocks"],"mappings":"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","file":"js/chunk-2d21d14c.0d8cc82e.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":""}