(function () {
    'use strict';

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */

    function __decorate(decorators, target, key, desc) {
        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
        return c > 3 && r && Object.defineProperty(target, key, r), r;
    }

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    const directives = new WeakMap();
    const isDirective = (o) => {
        return typeof o === 'function' && directives.has(o);
    };

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    /**
     * True if the custom elements polyfill is in use.
     */
    const isCEPolyfill = window.customElements !== undefined &&
        window.customElements.polyfillWrapFlushCallback !==
            undefined;
    /**
     * Removes nodes, starting from `start` (inclusive) to `end` (exclusive), from
     * `container`.
     */
    const removeNodes = (container, start, end = null) => {
        while (start !== end) {
            const n = start.nextSibling;
            container.removeChild(start);
            start = n;
        }
    };

    /**
     * @license
     * Copyright (c) 2018 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    /**
     * A sentinel value that signals that a value was handled by a directive and
     * should not be written to the DOM.
     */
    const noChange = {};
    /**
     * A sentinel value that signals a NodePart to fully clear its content.
     */
    const nothing = {};

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    /**
     * An expression marker with embedded unique key to avoid collision with
     * possible text in templates.
     */
    const marker = `{{lit-${String(Math.random()).slice(2)}}}`;
    /**
     * An expression marker used text-positions, multi-binding attributes, and
     * attributes with markup-like text values.
     */
    const nodeMarker = `<!--${marker}-->`;
    const markerRegex = new RegExp(`${marker}|${nodeMarker}`);
    /**
     * Suffix appended to all bound attribute names.
     */
    const boundAttributeSuffix = '$lit$';
    /**
     * An updateable Template that tracks the location of dynamic parts.
     */
    class Template {
        constructor(result, element) {
            this.parts = [];
            this.element = element;
            const nodesToRemove = [];
            const stack = [];
            // Edge needs all 4 parameters present; IE11 needs 3rd parameter to be null
            const walker = document.createTreeWalker(element.content, 133 /* NodeFilter.SHOW_{ELEMENT|COMMENT|TEXT} */, null, false);
            // Keeps track of the last index associated with a part. We try to delete
            // unnecessary nodes, but we never want to associate two different parts
            // to the same index. They must have a constant node between.
            let lastPartIndex = 0;
            let index = -1;
            let partIndex = 0;
            const { strings, values: { length } } = result;
            while (partIndex < length) {
                const node = walker.nextNode();
                if (node === null) {
                    // We've exhausted the content inside a nested template element.
                    // Because we still have parts (the outer for-loop), we know:
                    // - There is a template in the stack
                    // - The walker will find a nextNode outside the template
                    walker.currentNode = stack.pop();
                    continue;
                }
                index++;
                if (node.nodeType === 1 /* Node.ELEMENT_NODE */) {
                    if (node.hasAttributes()) {
                        const attributes = node.attributes;
                        const { length } = attributes;
                        // Per
                        // https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap,
                        // attributes are not guaranteed to be returned in document order.
                        // In particular, Edge/IE can return them out of order, so we cannot
                        // assume a correspondence between part index and attribute index.
                        let count = 0;
                        for (let i = 0; i < length; i++) {
                            if (endsWith(attributes[i].name, boundAttributeSuffix)) {
                                count++;
                            }
                        }
                        while (count-- > 0) {
                            // Get the template literal section leading up to the first
                            // expression in this attribute
                            const stringForPart = strings[partIndex];
                            // Find the attribute name
                            const name = lastAttributeNameRegex.exec(stringForPart)[2];
                            // Find the corresponding attribute
                            // All bound attributes have had a suffix added in
                            // TemplateResult#getHTML to opt out of special attribute
                            // handling. To look up the attribute value we also need to add
                            // the suffix.
                            const attributeLookupName = name.toLowerCase() + boundAttributeSuffix;
                            const attributeValue = node.getAttribute(attributeLookupName);
                            node.removeAttribute(attributeLookupName);
                            const statics = attributeValue.split(markerRegex);
                            this.parts.push({ type: 'attribute', index, name, strings: statics });
                            partIndex += statics.length - 1;
                        }
                    }
                    if (node.tagName === 'TEMPLATE') {
                        stack.push(node);
                        walker.currentNode = node.content;
                    }
                }
                else if (node.nodeType === 3 /* Node.TEXT_NODE */) {
                    const data = node.data;
                    if (data.indexOf(marker) >= 0) {
                        const parent = node.parentNode;
                        const strings = data.split(markerRegex);
                        const lastIndex = strings.length - 1;
                        // Generate a new text node for each literal section
                        // These nodes are also used as the markers for node parts
                        for (let i = 0; i < lastIndex; i++) {
                            let insert;
                            let s = strings[i];
                            if (s === '') {
                                insert = createMarker();
                            }
                            else {
                                const match = lastAttributeNameRegex.exec(s);
                                if (match !== null && endsWith(match[2], boundAttributeSuffix)) {
                                    s = s.slice(0, match.index) + match[1] +
                                        match[2].slice(0, -boundAttributeSuffix.length) + match[3];
                                }
                                insert = document.createTextNode(s);
                            }
                            parent.insertBefore(insert, node);
                            this.parts.push({ type: 'node', index: ++index });
                        }
                        // If there's no text, we must insert a comment to mark our place.
                        // Else, we can trust it will stick around after cloning.
                        if (strings[lastIndex] === '') {
                            parent.insertBefore(createMarker(), node);
                            nodesToRemove.push(node);
                        }
                        else {
                            node.data = strings[lastIndex];
                        }
                        // We have a part for each match found
                        partIndex += lastIndex;
                    }
                }
                else if (node.nodeType === 8 /* Node.COMMENT_NODE */) {
                    if (node.data === marker) {
                        const parent = node.parentNode;
                        // Add a new marker node to be the startNode of the Part if any of
                        // the following are true:
                        //  * We don't have a previousSibling
                        //  * The previousSibling is already the start of a previous part
                        if (node.previousSibling === null || index === lastPartIndex) {
                            index++;
                            parent.insertBefore(createMarker(), node);
                        }
                        lastPartIndex = index;
                        this.parts.push({ type: 'node', index });
                        // If we don't have a nextSibling, keep this node so we have an end.
                        // Else, we can remove it to save future costs.
                        if (node.nextSibling === null) {
                            node.data = '';
                        }
                        else {
                            nodesToRemove.push(node);
                            index--;
                        }
                        partIndex++;
                    }
                    else {
                        let i = -1;
                        while ((i = node.data.indexOf(marker, i + 1)) !== -1) {
                            // Comment node has a binding marker inside, make an inactive part
                            // The binding won't work, but subsequent bindings will
                            // TODO (justinfagnani): consider whether it's even worth it to
                            // make bindings in comments work
                            this.parts.push({ type: 'node', index: -1 });
                            partIndex++;
                        }
                    }
                }
            }
            // Remove text binding nodes after the walk to not disturb the TreeWalker
            for (const n of nodesToRemove) {
                n.parentNode.removeChild(n);
            }
        }
    }
    const endsWith = (str, suffix) => {
        const index = str.length - suffix.length;
        return index >= 0 && str.slice(index) === suffix;
    };
    const isTemplatePartActive = (part) => part.index !== -1;
    // Allows `document.createComment('')` to be renamed for a
    // small manual size-savings.
    const createMarker = () => document.createComment('');
    /**
     * This regex extracts the attribute name preceding an attribute-position
     * expression. It does this by matching the syntax allowed for attributes
     * against the string literal directly preceding the expression, assuming that
     * the expression is in an attribute-value position.
     *
     * See attributes in the HTML spec:
     * https://www.w3.org/TR/html5/syntax.html#elements-attributes
     *
     * " \x09\x0a\x0c\x0d" are HTML space characters:
     * https://www.w3.org/TR/html5/infrastructure.html#space-characters
     *
     * "\0-\x1F\x7F-\x9F" are Unicode control characters, which includes every
     * space character except " ".
     *
     * So an attribute is:
     *  * The name: any character except a control character, space character, ('),
     *    ("), ">", "=", or "/"
     *  * Followed by zero or more space characters
     *  * Followed by "="
     *  * Followed by zero or more space characters
     *  * Followed by:
     *    * Any character except space, ('), ("), "<", ">", "=", (`), or
     *    * (") then any non-("), or
     *    * (') then any non-(')
     */
    const lastAttributeNameRegex = /([ \x09\x0a\x0c\x0d])([^\0-\x1F\x7F-\x9F "'>=/]+)([ \x09\x0a\x0c\x0d]*=[ \x09\x0a\x0c\x0d]*(?:[^ \x09\x0a\x0c\x0d"'`<>=]*|"[^"]*|'[^']*))$/;

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    /**
     * An instance of a `Template` that can be attached to the DOM and updated
     * with new values.
     */
    class TemplateInstance {
        constructor(template, processor, options) {
            this.__parts = [];
            this.template = template;
            this.processor = processor;
            this.options = options;
        }
        update(values) {
            let i = 0;
            for (const part of this.__parts) {
                if (part !== undefined) {
                    part.setValue(values[i]);
                }
                i++;
            }
            for (const part of this.__parts) {
                if (part !== undefined) {
                    part.commit();
                }
            }
        }
        _clone() {
            // There are a number of steps in the lifecycle of a template instance's
            // DOM fragment:
            //  1. Clone - create the instance fragment
            //  2. Adopt - adopt into the main document
            //  3. Process - find part markers and create parts
            //  4. Upgrade - upgrade custom elements
            //  5. Update - set node, attribute, property, etc., values
            //  6. Connect - connect to the document. Optional and outside of this
            //     method.
            //
            // We have a few constraints on the ordering of these steps:
            //  * We need to upgrade before updating, so that property values will pass
            //    through any property setters.
            //  * We would like to process before upgrading so that we're sure that the
            //    cloned fragment is inert and not disturbed by self-modifying DOM.
            //  * We want custom elements to upgrade even in disconnected fragments.
            //
            // Given these constraints, with full custom elements support we would
            // prefer the order: Clone, Process, Adopt, Upgrade, Update, Connect
            //
            // But Safari dooes not implement CustomElementRegistry#upgrade, so we
            // can not implement that order and still have upgrade-before-update and
            // upgrade disconnected fragments. So we instead sacrifice the
            // process-before-upgrade constraint, since in Custom Elements v1 elements
            // must not modify their light DOM in the constructor. We still have issues
            // when co-existing with CEv0 elements like Polymer 1, and with polyfills
            // that don't strictly adhere to the no-modification rule because shadow
            // DOM, which may be created in the constructor, is emulated by being placed
            // in the light DOM.
            //
            // The resulting order is on native is: Clone, Adopt, Upgrade, Process,
            // Update, Connect. document.importNode() performs Clone, Adopt, and Upgrade
            // in one step.
            //
            // The Custom Elements v1 polyfill supports upgrade(), so the order when
            // polyfilled is the more ideal: Clone, Process, Adopt, Upgrade, Update,
            // Connect.
            const fragment = isCEPolyfill ?
                this.template.element.content.cloneNode(true) :
                document.importNode(this.template.element.content, true);
            const stack = [];
            const parts = this.template.parts;
            // Edge needs all 4 parameters present; IE11 needs 3rd parameter to be null
            const walker = document.createTreeWalker(fragment, 133 /* NodeFilter.SHOW_{ELEMENT|COMMENT|TEXT} */, null, false);
            let partIndex = 0;
            let nodeIndex = 0;
            let part;
            let node = walker.nextNode();
            // Loop through all the nodes and parts of a template
            while (partIndex < parts.length) {
                part = parts[partIndex];
                if (!isTemplatePartActive(part)) {
                    this.__parts.push(undefined);
                    partIndex++;
                    continue;
                }
                // Progress the tree walker until we find our next part's node.
                // Note that multiple parts may share the same node (attribute parts
                // on a single element), so this loop may not run at all.
                while (nodeIndex < part.index) {
                    nodeIndex++;
                    if (node.nodeName === 'TEMPLATE') {
                        stack.push(node);
                        walker.currentNode = node.content;
                    }
                    if ((node = walker.nextNode()) === null) {
                        // We've exhausted the content inside a nested template element.
                        // Because we still have parts (the outer for-loop), we know:
                        // - There is a template in the stack
                        // - The walker will find a nextNode outside the template
                        walker.currentNode = stack.pop();
                        node = walker.nextNode();
                    }
                }
                // We've arrived at our part's node.
                if (part.type === 'node') {
                    const part = this.processor.handleTextExpression(this.options);
                    part.insertAfterNode(node.previousSibling);
                    this.__parts.push(part);
                }
                else {
                    this.__parts.push(...this.processor.handleAttributeExpressions(node, part.name, part.strings, this.options));
                }
                partIndex++;
            }
            if (isCEPolyfill) {
                document.adoptNode(fragment);
                customElements.upgrade(fragment);
            }
            return fragment;
        }
    }

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    const commentMarker = ` ${marker} `;
    /**
     * The return type of `html`, which holds a Template and the values from
     * interpolated expressions.
     */
    class TemplateResult {
        constructor(strings, values, type, processor) {
            this.strings = strings;
            this.values = values;
            this.type = type;
            this.processor = processor;
        }
        /**
         * Returns a string of HTML used to create a `<template>` element.
         */
        getHTML() {
            const l = this.strings.length - 1;
            let html = '';
            let isCommentBinding = false;
            for (let i = 0; i < l; i++) {
                const s = this.strings[i];
                // For each binding we want to determine the kind of marker to insert
                // into the template source before it's parsed by the browser's HTML
                // parser. The marker type is based on whether the expression is in an
                // attribute, text, or comment poisition.
                //   * For node-position bindings we insert a comment with the marker
                //     sentinel as its text content, like <!--{{lit-guid}}-->.
                //   * For attribute bindings we insert just the marker sentinel for the
                //     first binding, so that we support unquoted attribute bindings.
                //     Subsequent bindings can use a comment marker because multi-binding
                //     attributes must be quoted.
                //   * For comment bindings we insert just the marker sentinel so we don't
                //     close the comment.
                //
                // The following code scans the template source, but is *not* an HTML
                // parser. We don't need to track the tree structure of the HTML, only
                // whether a binding is inside a comment, and if not, if it appears to be
                // the first binding in an attribute.
                const commentOpen = s.lastIndexOf('<!--');
                // We're in comment position if we have a comment open with no following
                // comment close. Because <-- can appear in an attribute value there can
                // be false positives.
                isCommentBinding = (commentOpen > -1 || isCommentBinding) &&
                    s.indexOf('-->', commentOpen + 1) === -1;
                // Check to see if we have an attribute-like sequence preceeding the
                // expression. This can match "name=value" like structures in text,
                // comments, and attribute values, so there can be false-positives.
                const attributeMatch = lastAttributeNameRegex.exec(s);
                if (attributeMatch === null) {
                    // We're only in this branch if we don't have a attribute-like
                    // preceeding sequence. For comments, this guards against unusual
                    // attribute values like <div foo="<!--${'bar'}">. Cases like
                    // <!-- foo=${'bar'}--> are handled correctly in the attribute branch
                    // below.
                    html += s + (isCommentBinding ? commentMarker : nodeMarker);
                }
                else {
                    // For attributes we use just a marker sentinel, and also append a
                    // $lit$ suffix to the name to opt-out of attribute-specific parsing
                    // that IE and Edge do for style and certain SVG attributes.
                    html += s.substr(0, attributeMatch.index) + attributeMatch[1] +
                        attributeMatch[2] + boundAttributeSuffix + attributeMatch[3] +
                        marker;
                }
            }
            html += this.strings[l];
            return html;
        }
        getTemplateElement() {
            const template = document.createElement('template');
            template.innerHTML = this.getHTML();
            return template;
        }
    }

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    const isPrimitive = (value) => {
        return (value === null ||
            !(typeof value === 'object' || typeof value === 'function'));
    };
    const isIterable = (value) => {
        return Array.isArray(value) ||
            // tslint:disable-next-line:no-any
            !!(value && value[Symbol.iterator]);
    };
    /**
     * Writes attribute values to the DOM for a group of AttributeParts bound to a
     * single attibute. The value is only set once even if there are multiple parts
     * for an attribute.
     */
    class AttributeCommitter {
        constructor(element, name, strings) {
            this.dirty = true;
            this.element = element;
            this.name = name;
            this.strings = strings;
            this.parts = [];
            for (let i = 0; i < strings.length - 1; i++) {
                this.parts[i] = this._createPart();
            }
        }
        /**
         * Creates a single part. Override this to create a differnt type of part.
         */
        _createPart() {
            return new AttributePart(this);
        }
        _getValue() {
            const strings = this.strings;
            const l = strings.length - 1;
            let text = '';
            for (let i = 0; i < l; i++) {
                text += strings[i];
                const part = this.parts[i];
                if (part !== undefined) {
                    const v = part.value;
                    if (isPrimitive(v) || !isIterable(v)) {
                        text += typeof v === 'string' ? v : String(v);
                    }
                    else {
                        for (const t of v) {
                            text += typeof t === 'string' ? t : String(t);
                        }
                    }
                }
            }
            text += strings[l];
            return text;
        }
        commit() {
            if (this.dirty) {
                this.dirty = false;
                this.element.setAttribute(this.name, this._getValue());
            }
        }
    }
    /**
     * A Part that controls all or part of an attribute value.
     */
    class AttributePart {
        constructor(committer) {
            this.value = undefined;
            this.committer = committer;
        }
        setValue(value) {
            if (value !== noChange && (!isPrimitive(value) || value !== this.value)) {
                this.value = value;
                // If the value is a not a directive, dirty the committer so that it'll
                // call setAttribute. If the value is a directive, it'll dirty the
                // committer if it calls setValue().
                if (!isDirective(value)) {
                    this.committer.dirty = true;
                }
            }
        }
        commit() {
            while (isDirective(this.value)) {
                const directive = this.value;
                this.value = noChange;
                directive(this);
            }
            if (this.value === noChange) {
                return;
            }
            this.committer.commit();
        }
    }
    /**
     * A Part that controls a location within a Node tree. Like a Range, NodePart
     * has start and end locations and can set and update the Nodes between those
     * locations.
     *
     * NodeParts support several value types: primitives, Nodes, TemplateResults,
     * as well as arrays and iterables of those types.
     */
    class NodePart {
        constructor(options) {
            this.value = undefined;
            this.__pendingValue = undefined;
            this.options = options;
        }
        /**
         * Appends this part into a container.
         *
         * This part must be empty, as its contents are not automatically moved.
         */
        appendInto(container) {
            this.startNode = container.appendChild(createMarker());
            this.endNode = container.appendChild(createMarker());
        }
        /**
         * Inserts this part after the `ref` node (between `ref` and `ref`'s next
         * sibling). Both `ref` and its next sibling must be static, unchanging nodes
         * such as those that appear in a literal section of a template.
         *
         * This part must be empty, as its contents are not automatically moved.
         */
        insertAfterNode(ref) {
            this.startNode = ref;
            this.endNode = ref.nextSibling;
        }
        /**
         * Appends this part into a parent part.
         *
         * This part must be empty, as its contents are not automatically moved.
         */
        appendIntoPart(part) {
            part.__insert(this.startNode = createMarker());
            part.__insert(this.endNode = createMarker());
        }
        /**
         * Inserts this part after the `ref` part.
         *
         * This part must be empty, as its contents are not automatically moved.
         */
        insertAfterPart(ref) {
            ref.__insert(this.startNode = createMarker());
            this.endNode = ref.endNode;
            ref.endNode = this.startNode;
        }
        setValue(value) {
            this.__pendingValue = value;
        }
        commit() {
            while (isDirective(this.__pendingValue)) {
                const directive = this.__pendingValue;
                this.__pendingValue = noChange;
                directive(this);
            }
            const value = this.__pendingValue;
            if (value === noChange) {
                return;
            }
            if (isPrimitive(value)) {
                if (value !== this.value) {
                    this.__commitText(value);
                }
            }
            else if (value instanceof TemplateResult) {
                this.__commitTemplateResult(value);
            }
            else if (value instanceof Node) {
                this.__commitNode(value);
            }
            else if (isIterable(value)) {
                this.__commitIterable(value);
            }
            else if (value === nothing) {
                this.value = nothing;
                this.clear();
            }
            else {
                // Fallback, will render the string representation
                this.__commitText(value);
            }
        }
        __insert(node) {
            this.endNode.parentNode.insertBefore(node, this.endNode);
        }
        __commitNode(value) {
            if (this.value === value) {
                return;
            }
            this.clear();
            this.__insert(value);
            this.value = value;
        }
        __commitText(value) {
            const node = this.startNode.nextSibling;
            value = value == null ? '' : value;
            // If `value` isn't already a string, we explicitly convert it here in case
            // it can't be implicitly converted - i.e. it's a symbol.
            const valueAsString = typeof value === 'string' ? value : String(value);
            if (node === this.endNode.previousSibling &&
                node.nodeType === 3 /* Node.TEXT_NODE */) {
                // If we only have a single text node between the markers, we can just
                // set its value, rather than replacing it.
                // TODO(justinfagnani): Can we just check if this.value is primitive?
                node.data = valueAsString;
            }
            else {
                this.__commitNode(document.createTextNode(valueAsString));
            }
            this.value = value;
        }
        __commitTemplateResult(value) {
            const template = this.options.templateFactory(value);
            if (this.value instanceof TemplateInstance &&
                this.value.template === template) {
                this.value.update(value.values);
            }
            else {
                // Make sure we propagate the template processor from the TemplateResult
                // so that we use its syntax extension, etc. The template factory comes
                // from the render function options so that it can control template
                // caching and preprocessing.
                const instance = new TemplateInstance(template, value.processor, this.options);
                const fragment = instance._clone();
                instance.update(value.values);
                this.__commitNode(fragment);
                this.value = instance;
            }
        }
        __commitIterable(value) {
            // For an Iterable, we create a new InstancePart per item, then set its
            // value to the item. This is a little bit of overhead for every item in
            // an Iterable, but it lets us recurse easily and efficiently update Arrays
            // of TemplateResults that will be commonly returned from expressions like:
            // array.map((i) => html`${i}`), by reusing existing TemplateInstances.
            // If _value is an array, then the previous render was of an
            // iterable and _value will contain the NodeParts from the previous
            // render. If _value is not an array, clear this part and make a new
            // array for NodeParts.
            if (!Array.isArray(this.value)) {
                this.value = [];
                this.clear();
            }
            // Lets us keep track of how many items we stamped so we can clear leftover
            // items from a previous render
            const itemParts = this.value;
            let partIndex = 0;
            let itemPart;
            for (const item of value) {
                // Try to reuse an existing part
                itemPart = itemParts[partIndex];
                // If no existing part, create a new one
                if (itemPart === undefined) {
                    itemPart = new NodePart(this.options);
                    itemParts.push(itemPart);
                    if (partIndex === 0) {
                        itemPart.appendIntoPart(this);
                    }
                    else {
                        itemPart.insertAfterPart(itemParts[partIndex - 1]);
                    }
                }
                itemPart.setValue(item);
                itemPart.commit();
                partIndex++;
            }
            if (partIndex < itemParts.length) {
                // Truncate the parts array so _value reflects the current state
                itemParts.length = partIndex;
                this.clear(itemPart && itemPart.endNode);
            }
        }
        clear(startNode = this.startNode) {
            removeNodes(this.startNode.parentNode, startNode.nextSibling, this.endNode);
        }
    }
    /**
     * Implements a boolean attribute, roughly as defined in the HTML
     * specification.
     *
     * If the value is truthy, then the attribute is present with a value of
     * ''. If the value is falsey, the attribute is removed.
     */
    class BooleanAttributePart {
        constructor(element, name, strings) {
            this.value = undefined;
            this.__pendingValue = undefined;
            if (strings.length !== 2 || strings[0] !== '' || strings[1] !== '') {
                throw new Error('Boolean attributes can only contain a single expression');
            }
            this.element = element;
            this.name = name;
            this.strings = strings;
        }
        setValue(value) {
            this.__pendingValue = value;
        }
        commit() {
            while (isDirective(this.__pendingValue)) {
                const directive = this.__pendingValue;
                this.__pendingValue = noChange;
                directive(this);
            }
            if (this.__pendingValue === noChange) {
                return;
            }
            const value = !!this.__pendingValue;
            if (this.value !== value) {
                if (value) {
                    this.element.setAttribute(this.name, '');
                }
                else {
                    this.element.removeAttribute(this.name);
                }
                this.value = value;
            }
            this.__pendingValue = noChange;
        }
    }
    /**
     * Sets attribute values for PropertyParts, so that the value is only set once
     * even if there are multiple parts for a property.
     *
     * If an expression controls the whole property value, then the value is simply
     * assigned to the property under control. If there are string literals or
     * multiple expressions, then the strings are expressions are interpolated into
     * a string first.
     */
    class PropertyCommitter extends AttributeCommitter {
        constructor(element, name, strings) {
            super(element, name, strings);
            this.single =
                (strings.length === 2 && strings[0] === '' && strings[1] === '');
        }
        _createPart() {
            return new PropertyPart(this);
        }
        _getValue() {
            if (this.single) {
                return this.parts[0].value;
            }
            return super._getValue();
        }
        commit() {
            if (this.dirty) {
                this.dirty = false;
                // tslint:disable-next-line:no-any
                this.element[this.name] = this._getValue();
            }
        }
    }
    class PropertyPart extends AttributePart {
    }
    // Detect event listener options support. If the `capture` property is read
    // from the options object, then options are supported. If not, then the thrid
    // argument to add/removeEventListener is interpreted as the boolean capture
    // value so we should only pass the `capture` property.
    let eventOptionsSupported = false;
    try {
        const options = {
            get capture() {
                eventOptionsSupported = true;
                return false;
            }
        };
        // tslint:disable-next-line:no-any
        window.addEventListener('test', options, options);
        // tslint:disable-next-line:no-any
        window.removeEventListener('test', options, options);
    }
    catch (_e) {
    }
    class EventPart {
        constructor(element, eventName, eventContext) {
            this.value = undefined;
            this.__pendingValue = undefined;
            this.element = element;
            this.eventName = eventName;
            this.eventContext = eventContext;
            this.__boundHandleEvent = (e) => this.handleEvent(e);
        }
        setValue(value) {
            this.__pendingValue = value;
        }
        commit() {
            while (isDirective(this.__pendingValue)) {
                const directive = this.__pendingValue;
                this.__pendingValue = noChange;
                directive(this);
            }
            if (this.__pendingValue === noChange) {
                return;
            }
            const newListener = this.__pendingValue;
            const oldListener = this.value;
            const shouldRemoveListener = newListener == null ||
                oldListener != null &&
                    (newListener.capture !== oldListener.capture ||
                        newListener.once !== oldListener.once ||
                        newListener.passive !== oldListener.passive);
            const shouldAddListener = newListener != null && (oldListener == null || shouldRemoveListener);
            if (shouldRemoveListener) {
                this.element.removeEventListener(this.eventName, this.__boundHandleEvent, this.__options);
            }
            if (shouldAddListener) {
                this.__options = getOptions(newListener);
                this.element.addEventListener(this.eventName, this.__boundHandleEvent, this.__options);
            }
            this.value = newListener;
            this.__pendingValue = noChange;
        }
        handleEvent(event) {
            if (typeof this.value === 'function') {
                this.value.call(this.eventContext || this.element, event);
            }
            else {
                this.value.handleEvent(event);
            }
        }
    }
    // We copy options because of the inconsistent behavior of browsers when reading
    // the third argument of add/removeEventListener. IE11 doesn't support options
    // at all. Chrome 41 only reads `capture` if the argument is an object.
    const getOptions = (o) => o &&
        (eventOptionsSupported ?
            { capture: o.capture, passive: o.passive, once: o.once } :
            o.capture);

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    /**
     * Creates Parts when a template is instantiated.
     */
    class DefaultTemplateProcessor {
        /**
         * Create parts for an attribute-position binding, given the event, attribute
         * name, and string literals.
         *
         * @param element The element containing the binding
         * @param name  The attribute name
         * @param strings The string literals. There are always at least two strings,
         *   event for fully-controlled bindings with a single expression.
         */
        handleAttributeExpressions(element, name, strings, options) {
            const prefix = name[0];
            if (prefix === '.') {
                const committer = new PropertyCommitter(element, name.slice(1), strings);
                return committer.parts;
            }
            if (prefix === '@') {
                return [new EventPart(element, name.slice(1), options.eventContext)];
            }
            if (prefix === '?') {
                return [new BooleanAttributePart(element, name.slice(1), strings)];
            }
            const committer = new AttributeCommitter(element, name, strings);
            return committer.parts;
        }
        /**
         * Create parts for a text-position binding.
         * @param templateFactory
         */
        handleTextExpression(options) {
            return new NodePart(options);
        }
    }
    const defaultTemplateProcessor = new DefaultTemplateProcessor();

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    /**
     * The default TemplateFactory which caches Templates keyed on
     * result.type and result.strings.
     */
    function templateFactory(result) {
        let templateCache = templateCaches.get(result.type);
        if (templateCache === undefined) {
            templateCache = {
                stringsArray: new WeakMap(),
                keyString: new Map()
            };
            templateCaches.set(result.type, templateCache);
        }
        let template = templateCache.stringsArray.get(result.strings);
        if (template !== undefined) {
            return template;
        }
        // If the TemplateStringsArray is new, generate a key from the strings
        // This key is shared between all templates with identical content
        const key = result.strings.join(marker);
        // Check if we already have a Template for this key
        template = templateCache.keyString.get(key);
        if (template === undefined) {
            // If we have not seen this key before, create a new Template
            template = new Template(result, result.getTemplateElement());
            // Cache the Template for this key
            templateCache.keyString.set(key, template);
        }
        // Cache all future queries for this TemplateStringsArray
        templateCache.stringsArray.set(result.strings, template);
        return template;
    }
    const templateCaches = new Map();

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    const parts = new WeakMap();
    /**
     * Renders a template result or other value to a container.
     *
     * To update a container with new values, reevaluate the template literal and
     * call `render` with the new result.
     *
     * @param result Any value renderable by NodePart - typically a TemplateResult
     *     created by evaluating a template tag like `html` or `svg`.
     * @param container A DOM parent to render to. The entire contents are either
     *     replaced, or efficiently updated if the same result type was previous
     *     rendered there.
     * @param options RenderOptions for the entire render tree rendered to this
     *     container. Render options must *not* change between renders to the same
     *     container, as those changes will not effect previously rendered DOM.
     */
    const render = (result, container, options) => {
        let part = parts.get(container);
        if (part === undefined) {
            removeNodes(container, container.firstChild);
            parts.set(container, part = new NodePart(Object.assign({ templateFactory }, options)));
            part.appendInto(container);
        }
        part.setValue(result);
        part.commit();
    };

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    // IMPORTANT: do not change the property name or the assignment expression.
    // This line will be used in regexes to search for lit-html usage.
    // TODO(justinfagnani): inject version number at build time
    (window['litHtmlVersions'] || (window['litHtmlVersions'] = [])).push('1.1.2');
    /**
     * Interprets a template literal as an HTML template that can efficiently
     * render to and update a container.
     */
    const html = (strings, ...values) => new TemplateResult(strings, values, 'html', defaultTemplateProcessor);

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    const walkerNodeFilter = 133 /* NodeFilter.SHOW_{ELEMENT|COMMENT|TEXT} */;
    /**
     * Removes the list of nodes from a Template safely. In addition to removing
     * nodes from the Template, the Template part indices are updated to match
     * the mutated Template DOM.
     *
     * As the template is walked the removal state is tracked and
     * part indices are adjusted as needed.
     *
     * div
     *   div#1 (remove) <-- start removing (removing node is div#1)
     *     div
     *       div#2 (remove)  <-- continue removing (removing node is still div#1)
     *         div
     * div <-- stop removing since previous sibling is the removing node (div#1,
     * removed 4 nodes)
     */
    function removeNodesFromTemplate(template, nodesToRemove) {
        const { element: { content }, parts } = template;
        const walker = document.createTreeWalker(content, walkerNodeFilter, null, false);
        let partIndex = nextActiveIndexInTemplateParts(parts);
        let part = parts[partIndex];
        let nodeIndex = -1;
        let removeCount = 0;
        const nodesToRemoveInTemplate = [];
        let currentRemovingNode = null;
        while (walker.nextNode()) {
            nodeIndex++;
            const node = walker.currentNode;
            // End removal if stepped past the removing node
            if (node.previousSibling === currentRemovingNode) {
                currentRemovingNode = null;
            }
            // A node to remove was found in the template
            if (nodesToRemove.has(node)) {
                nodesToRemoveInTemplate.push(node);
                // Track node we're removing
                if (currentRemovingNode === null) {
                    currentRemovingNode = node;
                }
            }
            // When removing, increment count by which to adjust subsequent part indices
            if (currentRemovingNode !== null) {
                removeCount++;
            }
            while (part !== undefined && part.index === nodeIndex) {
                // If part is in a removed node deactivate it by setting index to -1 or
                // adjust the index as needed.
                part.index = currentRemovingNode !== null ? -1 : part.index - removeCount;
                // go to the next active part.
                partIndex = nextActiveIndexInTemplateParts(parts, partIndex);
                part = parts[partIndex];
            }
        }
        nodesToRemoveInTemplate.forEach((n) => n.parentNode.removeChild(n));
    }
    const countNodes = (node) => {
        let count = (node.nodeType === 11 /* Node.DOCUMENT_FRAGMENT_NODE */) ? 0 : 1;
        const walker = document.createTreeWalker(node, walkerNodeFilter, null, false);
        while (walker.nextNode()) {
            count++;
        }
        return count;
    };
    const nextActiveIndexInTemplateParts = (parts, startIndex = -1) => {
        for (let i = startIndex + 1; i < parts.length; i++) {
            const part = parts[i];
            if (isTemplatePartActive(part)) {
                return i;
            }
        }
        return -1;
    };
    /**
     * Inserts the given node into the Template, optionally before the given
     * refNode. In addition to inserting the node into the Template, the Template
     * part indices are updated to match the mutated Template DOM.
     */
    function insertNodeIntoTemplate(template, node, refNode = null) {
        const { element: { content }, parts } = template;
        // If there's no refNode, then put node at end of template.
        // No part indices need to be shifted in this case.
        if (refNode === null || refNode === undefined) {
            content.appendChild(node);
            return;
        }
        const walker = document.createTreeWalker(content, walkerNodeFilter, null, false);
        let partIndex = nextActiveIndexInTemplateParts(parts);
        let insertCount = 0;
        let walkerIndex = -1;
        while (walker.nextNode()) {
            walkerIndex++;
            const walkerNode = walker.currentNode;
            if (walkerNode === refNode) {
                insertCount = countNodes(node);
                refNode.parentNode.insertBefore(node, refNode);
            }
            while (partIndex !== -1 && parts[partIndex].index === walkerIndex) {
                // If we've inserted the node, simply adjust all subsequent parts
                if (insertCount > 0) {
                    while (partIndex !== -1) {
                        parts[partIndex].index += insertCount;
                        partIndex = nextActiveIndexInTemplateParts(parts, partIndex);
                    }
                    return;
                }
                partIndex = nextActiveIndexInTemplateParts(parts, partIndex);
            }
        }
    }

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    // Get a key to lookup in `templateCaches`.
    const getTemplateCacheKey = (type, scopeName) => `${type}--${scopeName}`;
    let compatibleShadyCSSVersion = true;
    if (typeof window.ShadyCSS === 'undefined') {
        compatibleShadyCSSVersion = false;
    }
    else if (typeof window.ShadyCSS.prepareTemplateDom === 'undefined') {
        console.warn(`Incompatible ShadyCSS version detected. ` +
            `Please update to at least @webcomponents/webcomponentsjs@2.0.2 and ` +
            `@webcomponents/shadycss@1.3.1.`);
        compatibleShadyCSSVersion = false;
    }
    /**
     * Template factory which scopes template DOM using ShadyCSS.
     * @param scopeName {string}
     */
    const shadyTemplateFactory = (scopeName) => (result) => {
        const cacheKey = getTemplateCacheKey(result.type, scopeName);
        let templateCache = templateCaches.get(cacheKey);
        if (templateCache === undefined) {
            templateCache = {
                stringsArray: new WeakMap(),
                keyString: new Map()
            };
            templateCaches.set(cacheKey, templateCache);
        }
        let template = templateCache.stringsArray.get(result.strings);
        if (template !== undefined) {
            return template;
        }
        const key = result.strings.join(marker);
        template = templateCache.keyString.get(key);
        if (template === undefined) {
            const element = result.getTemplateElement();
            if (compatibleShadyCSSVersion) {
                window.ShadyCSS.prepareTemplateDom(element, scopeName);
            }
            template = new Template(result, element);
            templateCache.keyString.set(key, template);
        }
        templateCache.stringsArray.set(result.strings, template);
        return template;
    };
    const TEMPLATE_TYPES = ['html', 'svg'];
    /**
     * Removes all style elements from Templates for the given scopeName.
     */
    const removeStylesFromLitTemplates = (scopeName) => {
        TEMPLATE_TYPES.forEach((type) => {
            const templates = templateCaches.get(getTemplateCacheKey(type, scopeName));
            if (templates !== undefined) {
                templates.keyString.forEach((template) => {
                    const { element: { content } } = template;
                    // IE 11 doesn't support the iterable param Set constructor
                    const styles = new Set();
                    Array.from(content.querySelectorAll('style')).forEach((s) => {
                        styles.add(s);
                    });
                    removeNodesFromTemplate(template, styles);
                });
            }
        });
    };
    const shadyRenderSet = new Set();
    /**
     * For the given scope name, ensures that ShadyCSS style scoping is performed.
     * This is done just once per scope name so the fragment and template cannot
     * be modified.
     * (1) extracts styles from the rendered fragment and hands them to ShadyCSS
     * to be scoped and appended to the document
     * (2) removes style elements from all lit-html Templates for this scope name.
     *
     * Note, <style> elements can only be placed into templates for the
     * initial rendering of the scope. If <style> elements are included in templates
     * dynamically rendered to the scope (after the first scope render), they will
     * not be scoped and the <style> will be left in the template and rendered
     * output.
     */
    const prepareTemplateStyles = (scopeName, renderedDOM, template) => {
        shadyRenderSet.add(scopeName);
        // If `renderedDOM` is stamped from a Template, then we need to edit that
        // Template's underlying template element. Otherwise, we create one here
        // to give to ShadyCSS, which still requires one while scoping.
        const templateElement = !!template ? template.element : document.createElement('template');
        // Move styles out of rendered DOM and store.
        const styles = renderedDOM.querySelectorAll('style');
        const { length } = styles;
        // If there are no styles, skip unnecessary work
        if (length === 0) {
            // Ensure prepareTemplateStyles is called to support adding
            // styles via `prepareAdoptedCssText` since that requires that
            // `prepareTemplateStyles` is called.
            //
            // ShadyCSS will only update styles containing @apply in the template
            // given to `prepareTemplateStyles`. If no lit Template was given,
            // ShadyCSS will not be able to update uses of @apply in any relevant
            // template. However, this is not a problem because we only create the
            // template for the purpose of supporting `prepareAdoptedCssText`,
            // which doesn't support @apply at all.
            window.ShadyCSS.prepareTemplateStyles(templateElement, scopeName);
            return;
        }
        const condensedStyle = document.createElement('style');
        // Collect styles into a single style. This helps us make sure ShadyCSS
        // manipulations will not prevent us from being able to fix up template
        // part indices.
        // NOTE: collecting styles is inefficient for browsers but ShadyCSS
        // currently does this anyway. When it does not, this should be changed.
        for (let i = 0; i < length; i++) {
            const style = styles[i];
            style.parentNode.removeChild(style);
            condensedStyle.textContent += style.textContent;
        }
        // Remove styles from nested templates in this scope.
        removeStylesFromLitTemplates(scopeName);
        // And then put the condensed style into the "root" template passed in as
        // `template`.
        const content = templateElement.content;
        if (!!template) {
            insertNodeIntoTemplate(template, condensedStyle, content.firstChild);
        }
        else {
            content.insertBefore(condensedStyle, content.firstChild);
        }
        // Note, it's important that ShadyCSS gets the template that `lit-html`
        // will actually render so that it can update the style inside when
        // needed (e.g. @apply native Shadow DOM case).
        window.ShadyCSS.prepareTemplateStyles(templateElement, scopeName);
        const style = content.querySelector('style');
        if (window.ShadyCSS.nativeShadow && style !== null) {
            // When in native Shadow DOM, ensure the style created by ShadyCSS is
            // included in initially rendered output (`renderedDOM`).
            renderedDOM.insertBefore(style.cloneNode(true), renderedDOM.firstChild);
        }
        else if (!!template) {
            // When no style is left in the template, parts will be broken as a
            // result. To fix this, we put back the style node ShadyCSS removed
            // and then tell lit to remove that node from the template.
            // There can be no style in the template in 2 cases (1) when Shady DOM
            // is in use, ShadyCSS removes all styles, (2) when native Shadow DOM
            // is in use ShadyCSS removes the style if it contains no content.
            // NOTE, ShadyCSS creates its own style so we can safely add/remove
            // `condensedStyle` here.
            content.insertBefore(condensedStyle, content.firstChild);
            const removes = new Set();
            removes.add(condensedStyle);
            removeNodesFromTemplate(template, removes);
        }
    };
    /**
     * Extension to the standard `render` method which supports rendering
     * to ShadowRoots when the ShadyDOM (https://github.com/webcomponents/shadydom)
     * and ShadyCSS (https://github.com/webcomponents/shadycss) polyfills are used
     * or when the webcomponentsjs
     * (https://github.com/webcomponents/webcomponentsjs) polyfill is used.
     *
     * Adds a `scopeName` option which is used to scope element DOM and stylesheets
     * when native ShadowDOM is unavailable. The `scopeName` will be added to
     * the class attribute of all rendered DOM. In addition, any style elements will
     * be automatically re-written with this `scopeName` selector and moved out
     * of the rendered DOM and into the document `<head>`.
     *
     * It is common to use this render method in conjunction with a custom element
     * which renders a shadowRoot. When this is done, typically the element's
     * `localName` should be used as the `scopeName`.
     *
     * In addition to DOM scoping, ShadyCSS also supports a basic shim for css
     * custom properties (needed only on older browsers like IE11) and a shim for
     * a deprecated feature called `@apply` that supports applying a set of css
     * custom properties to a given location.
     *
     * Usage considerations:
     *
     * * Part values in `<style>` elements are only applied the first time a given
     * `scopeName` renders. Subsequent changes to parts in style elements will have
     * no effect. Because of this, parts in style elements should only be used for
     * values that will never change, for example parts that set scope-wide theme
     * values or parts which render shared style elements.
     *
     * * Note, due to a limitation of the ShadyDOM polyfill, rendering in a
     * custom element's `constructor` is not supported. Instead rendering should
     * either done asynchronously, for example at microtask timing (for example
     * `Promise.resolve()`), or be deferred until the first time the element's
     * `connectedCallback` runs.
     *
     * Usage considerations when using shimmed custom properties or `@apply`:
     *
     * * Whenever any dynamic changes are made which affect
     * css custom properties, `ShadyCSS.styleElement(element)` must be called
     * to update the element. There are two cases when this is needed:
     * (1) the element is connected to a new parent, (2) a class is added to the
     * element that causes it to match different custom properties.
     * To address the first case when rendering a custom element, `styleElement`
     * should be called in the element's `connectedCallback`.
     *
     * * Shimmed custom properties may only be defined either for an entire
     * shadowRoot (for example, in a `:host` rule) or via a rule that directly
     * matches an element with a shadowRoot. In other words, instead of flowing from
     * parent to child as do native css custom properties, shimmed custom properties
     * flow only from shadowRoots to nested shadowRoots.
     *
     * * When using `@apply` mixing css shorthand property names with
     * non-shorthand names (for example `border` and `border-width`) is not
     * supported.
     */
    const render$1 = (result, container, options) => {
        if (!options || typeof options !== 'object' || !options.scopeName) {
            throw new Error('The `scopeName` option is required.');
        }
        const scopeName = options.scopeName;
        const hasRendered = parts.has(container);
        const needsScoping = compatibleShadyCSSVersion &&
            container.nodeType === 11 /* Node.DOCUMENT_FRAGMENT_NODE */ &&
            !!container.host;
        // Handle first render to a scope specially...
        const firstScopeRender = needsScoping && !shadyRenderSet.has(scopeName);
        // On first scope render, render into a fragment; this cannot be a single
        // fragment that is reused since nested renders can occur synchronously.
        const renderContainer = firstScopeRender ? document.createDocumentFragment() : container;
        render(result, renderContainer, Object.assign({ templateFactory: shadyTemplateFactory(scopeName) }, options));
        // When performing first scope render,
        // (1) We've rendered into a fragment so that there's a chance to
        // `prepareTemplateStyles` before sub-elements hit the DOM
        // (which might cause them to render based on a common pattern of
        // rendering in a custom element's `connectedCallback`);
        // (2) Scope the template with ShadyCSS one time only for this scope.
        // (3) Render the fragment into the container and make sure the
        // container knows its `part` is the one we just rendered. This ensures
        // DOM will be re-used on subsequent renders.
        if (firstScopeRender) {
            const part = parts.get(renderContainer);
            parts.delete(renderContainer);
            // ShadyCSS might have style sheets (e.g. from `prepareAdoptedCssText`)
            // that should apply to `renderContainer` even if the rendered value is
            // not a TemplateInstance. However, it will only insert scoped styles
            // into the document if `prepareTemplateStyles` has already been called
            // for the given scope name.
            const template = part.value instanceof TemplateInstance ?
                part.value.template :
                undefined;
            prepareTemplateStyles(scopeName, renderContainer, template);
            removeNodes(container, container.firstChild);
            container.appendChild(renderContainer);
            parts.set(container, part);
        }
        // After elements have hit the DOM, update styling if this is the
        // initial render to this container.
        // This is needed whenever dynamic changes are made so it would be
        // safest to do every render; however, this would regress performance
        // so we leave it up to the user to call `ShadyCSS.styleElement`
        // for dynamic changes.
        if (!hasRendered && needsScoping) {
            window.ShadyCSS.styleElement(container.host);
        }
    };

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    var _a;
    /**
     * When using Closure Compiler, JSCompiler_renameProperty(property, object) is
     * replaced at compile time by the munged name for object[property]. We cannot
     * alias this function, so we have to use a small shim that has the same
     * behavior when not compiling.
     */
    window.JSCompiler_renameProperty =
        (prop, _obj) => prop;
    const defaultConverter = {
        toAttribute(value, type) {
            switch (type) {
                case Boolean:
                    return value ? '' : null;
                case Object:
                case Array:
                    // if the value is `null` or `undefined` pass this through
                    // to allow removing/no change behavior.
                    return value == null ? value : JSON.stringify(value);
            }
            return value;
        },
        fromAttribute(value, type) {
            switch (type) {
                case Boolean:
                    return value !== null;
                case Number:
                    return value === null ? null : Number(value);
                case Object:
                case Array:
                    return JSON.parse(value);
            }
            return value;
        }
    };
    /**
     * Change function that returns true if `value` is different from `oldValue`.
     * This method is used as the default for a property's `hasChanged` function.
     */
    const notEqual = (value, old) => {
        // This ensures (old==NaN, value==NaN) always returns false
        return old !== value && (old === old || value === value);
    };
    const defaultPropertyDeclaration = {
        attribute: true,
        type: String,
        converter: defaultConverter,
        reflect: false,
        hasChanged: notEqual
    };
    const microtaskPromise = Promise.resolve(true);
    const STATE_HAS_UPDATED = 1;
    const STATE_UPDATE_REQUESTED = 1 << 2;
    const STATE_IS_REFLECTING_TO_ATTRIBUTE = 1 << 3;
    const STATE_IS_REFLECTING_TO_PROPERTY = 1 << 4;
    const STATE_HAS_CONNECTED = 1 << 5;
    /**
     * The Closure JS Compiler doesn't currently have good support for static
     * property semantics where "this" is dynamic (e.g.
     * https://github.com/google/closure-compiler/issues/3177 and others) so we use
     * this hack to bypass any rewriting by the compiler.
     */
    const finalized = 'finalized';
    /**
     * Base element class which manages element properties and attributes. When
     * properties change, the `update` method is asynchronously called. This method
     * should be supplied by subclassers to render updates as desired.
     */
    class UpdatingElement extends HTMLElement {
        constructor() {
            super();
            this._updateState = 0;
            this._instanceProperties = undefined;
            this._updatePromise = microtaskPromise;
            this._hasConnectedResolver = undefined;
            /**
             * Map with keys for any properties that have changed since the last
             * update cycle with previous values.
             */
            this._changedProperties = new Map();
            /**
             * Map with keys of properties that should be reflected when updated.
             */
            this._reflectingProperties = undefined;
            this.initialize();
        }
        /**
         * Returns a list of attributes corresponding to the registered properties.
         * @nocollapse
         */
        static get observedAttributes() {
            // note: piggy backing on this to ensure we're finalized.
            this.finalize();
            const attributes = [];
            // Use forEach so this works even if for/of loops are compiled to for loops
            // expecting arrays
            this._classProperties.forEach((v, p) => {
                const attr = this._attributeNameForProperty(p, v);
                if (attr !== undefined) {
                    this._attributeToPropertyMap.set(attr, p);
                    attributes.push(attr);
                }
            });
            return attributes;
        }
        /**
         * Ensures the private `_classProperties` property metadata is created.
         * In addition to `finalize` this is also called in `createProperty` to
         * ensure the `@property` decorator can add property metadata.
         */
        /** @nocollapse */
        static _ensureClassProperties() {
            // ensure private storage for property declarations.
            if (!this.hasOwnProperty(JSCompiler_renameProperty('_classProperties', this))) {
                this._classProperties = new Map();
                // NOTE: Workaround IE11 not supporting Map constructor argument.
                const superProperties = Object.getPrototypeOf(this)._classProperties;
                if (superProperties !== undefined) {
                    superProperties.forEach((v, k) => this._classProperties.set(k, v));
                }
            }
        }
        /**
         * Creates a property accessor on the element prototype if one does not exist.
         * The property setter calls the property's `hasChanged` property option
         * or uses a strict identity check to determine whether or not to request
         * an update.
         * @nocollapse
         */
        static createProperty(name, options = defaultPropertyDeclaration) {
            // Note, since this can be called by the `@property` decorator which
            // is called before `finalize`, we ensure storage exists for property
            // metadata.
            this._ensureClassProperties();
            this._classProperties.set(name, options);
            // Do not generate an accessor if the prototype already has one, since
            // it would be lost otherwise and that would never be the user's intention;
            // Instead, we expect users to call `requestUpdate` themselves from
            // user-defined accessors. Note that if the super has an accessor we will
            // still overwrite it
            if (options.noAccessor || this.prototype.hasOwnProperty(name)) {
                return;
            }
            const key = typeof name === 'symbol' ? Symbol() : `__${name}`;
            Object.defineProperty(this.prototype, name, {
                // tslint:disable-next-line:no-any no symbol in index
                get() {
                    return this[key];
                },
                set(value) {
                    const oldValue = this[name];
                    this[key] = value;
                    this._requestUpdate(name, oldValue);
                },
                configurable: true,
                enumerable: true
            });
        }
        /**
         * Creates property accessors for registered properties and ensures
         * any superclasses are also finalized.
         * @nocollapse
         */
        static finalize() {
            // finalize any superclasses
            const superCtor = Object.getPrototypeOf(this);
            if (!superCtor.hasOwnProperty(finalized)) {
                superCtor.finalize();
            }
            this[finalized] = true;
            this._ensureClassProperties();
            // initialize Map populated in observedAttributes
            this._attributeToPropertyMap = new Map();
            // make any properties
            // Note, only process "own" properties since this element will inherit
            // any properties defined on the superClass, and finalization ensures
            // the entire prototype chain is finalized.
            if (this.hasOwnProperty(JSCompiler_renameProperty('properties', this))) {
                const props = this.properties;
                // support symbols in properties (IE11 does not support this)
                const propKeys = [
                    ...Object.getOwnPropertyNames(props),
                    ...(typeof Object.getOwnPropertySymbols === 'function') ?
                        Object.getOwnPropertySymbols(props) :
                        []
                ];
                // This for/of is ok because propKeys is an array
                for (const p of propKeys) {
                    // note, use of `any` is due to TypeSript lack of support for symbol in
                    // index types
                    // tslint:disable-next-line:no-any no symbol in index
                    this.createProperty(p, props[p]);
                }
            }
        }
        /**
         * Returns the property name for the given attribute `name`.
         * @nocollapse
         */
        static _attributeNameForProperty(name, options) {
            const attribute = options.attribute;
            return attribute === false ?
                undefined :
                (typeof attribute === 'string' ?
                    attribute :
                    (typeof name === 'string' ? name.toLowerCase() : undefined));
        }
        /**
         * Returns true if a property should request an update.
         * Called when a property value is set and uses the `hasChanged`
         * option for the property if present or a strict identity check.
         * @nocollapse
         */
        static _valueHasChanged(value, old, hasChanged = notEqual) {
            return hasChanged(value, old);
        }
        /**
         * Returns the property value for the given attribute value.
         * Called via the `attributeChangedCallback` and uses the property's
         * `converter` or `converter.fromAttribute` property option.
         * @nocollapse
         */
        static _propertyValueFromAttribute(value, options) {
            const type = options.type;
            const converter = options.converter || defaultConverter;
            const fromAttribute = (typeof converter === 'function' ? converter : converter.fromAttribute);
            return fromAttribute ? fromAttribute(value, type) : value;
        }
        /**
         * Returns the attribute value for the given property value. If this
         * returns undefined, the property will *not* be reflected to an attribute.
         * If this returns null, the attribute will be removed, otherwise the
         * attribute will be set to the value.
         * This uses the property's `reflect` and `type.toAttribute` property options.
         * @nocollapse
         */
        static _propertyValueToAttribute(value, options) {
            if (options.reflect === undefined) {
                return;
            }
            const type = options.type;
            const converter = options.converter;
            const toAttribute = converter && converter.toAttribute ||
                defaultConverter.toAttribute;
            return toAttribute(value, type);
        }
        /**
         * Performs element initialization. By default captures any pre-set values for
         * registered properties.
         */
        initialize() {
            this._saveInstanceProperties();
            // ensures first update will be caught by an early access of
            // `updateComplete`
            this._requestUpdate();
        }
        /**
         * Fixes any properties set on the instance before upgrade time.
         * Otherwise these would shadow the accessor and break these properties.
         * The properties are stored in a Map which is played back after the
         * constructor runs. Note, on very old versions of Safari (<=9) or Chrome
         * (<=41), properties created for native platform properties like (`id` or
         * `name`) may not have default values set in the element constructor. On
         * these browsers native properties appear on instances and therefore their
         * default value will overwrite any element default (e.g. if the element sets
         * this.id = 'id' in the constructor, the 'id' will become '' since this is
         * the native platform default).
         */
        _saveInstanceProperties() {
            // Use forEach so this works even if for/of loops are compiled to for loops
            // expecting arrays
            this.constructor
                ._classProperties.forEach((_v, p) => {
                if (this.hasOwnProperty(p)) {
                    const value = this[p];
                    delete this[p];
                    if (!this._instanceProperties) {
                        this._instanceProperties = new Map();
                    }
                    this._instanceProperties.set(p, value);
                }
            });
        }
        /**
         * Applies previously saved instance properties.
         */
        _applyInstanceProperties() {
            // Use forEach so this works even if for/of loops are compiled to for loops
            // expecting arrays
            // tslint:disable-next-line:no-any
            this._instanceProperties.forEach((v, p) => this[p] = v);
            this._instanceProperties = undefined;
        }
        connectedCallback() {
            this._updateState = this._updateState | STATE_HAS_CONNECTED;
            // Ensure first connection completes an update. Updates cannot complete
            // before connection and if one is pending connection the
            // `_hasConnectionResolver` will exist. If so, resolve it to complete the
            // update, otherwise requestUpdate.
            if (this._hasConnectedResolver) {
                this._hasConnectedResolver();
                this._hasConnectedResolver = undefined;
            }
        }
        /**
         * Allows for `super.disconnectedCallback()` in extensions while
         * reserving the possibility of making non-breaking feature additions
         * when disconnecting at some point in the future.
         */
        disconnectedCallback() {
        }
        /**
         * Synchronizes property values when attributes change.
         */
        attributeChangedCallback(name, old, value) {
            if (old !== value) {
                this._attributeToProperty(name, value);
            }
        }
        _propertyToAttribute(name, value, options = defaultPropertyDeclaration) {
            const ctor = this.constructor;
            const attr = ctor._attributeNameForProperty(name, options);
            if (attr !== undefined) {
                const attrValue = ctor._propertyValueToAttribute(value, options);
                // an undefined value does not change the attribute.
                if (attrValue === undefined) {
                    return;
                }
                // Track if the property is being reflected to avoid
                // setting the property again via `attributeChangedCallback`. Note:
                // 1. this takes advantage of the fact that the callback is synchronous.
                // 2. will behave incorrectly if multiple attributes are in the reaction
                // stack at time of calling. However, since we process attributes
                // in `update` this should not be possible (or an extreme corner case
                // that we'd like to discover).
                // mark state reflecting
                this._updateState = this._updateState | STATE_IS_REFLECTING_TO_ATTRIBUTE;
                if (attrValue == null) {
                    this.removeAttribute(attr);
                }
                else {
                    this.setAttribute(attr, attrValue);
                }
                // mark state not reflecting
                this._updateState = this._updateState & ~STATE_IS_REFLECTING_TO_ATTRIBUTE;
            }
        }
        _attributeToProperty(name, value) {
            // Use tracking info to avoid deserializing attribute value if it was
            // just set from a property setter.
            if (this._updateState & STATE_IS_REFLECTING_TO_ATTRIBUTE) {
                return;
            }
            const ctor = this.constructor;
            const propName = ctor._attributeToPropertyMap.get(name);
            if (propName !== undefined) {
                const options = ctor._classProperties.get(propName) || defaultPropertyDeclaration;
                // mark state reflecting
                this._updateState = this._updateState | STATE_IS_REFLECTING_TO_PROPERTY;
                this[propName] =
                    // tslint:disable-next-line:no-any
                    ctor._propertyValueFromAttribute(value, options);
                // mark state not reflecting
                this._updateState = this._updateState & ~STATE_IS_REFLECTING_TO_PROPERTY;
            }
        }
        /**
         * This private version of `requestUpdate` does not access or return the
         * `updateComplete` promise. This promise can be overridden and is therefore
         * not free to access.
         */
        _requestUpdate(name, oldValue) {
            let shouldRequestUpdate = true;
            // If we have a property key, perform property update steps.
            if (name !== undefined) {
                const ctor = this.constructor;
                const options = ctor._classProperties.get(name) || defaultPropertyDeclaration;
                if (ctor._valueHasChanged(this[name], oldValue, options.hasChanged)) {
                    if (!this._changedProperties.has(name)) {
                        this._changedProperties.set(name, oldValue);
                    }
                    // Add to reflecting properties set.
                    // Note, it's important that every change has a chance to add the
                    // property to `_reflectingProperties`. This ensures setting
                    // attribute + property reflects correctly.
                    if (options.reflect === true &&
                        !(this._updateState & STATE_IS_REFLECTING_TO_PROPERTY)) {
                        if (this._reflectingProperties === undefined) {
                            this._reflectingProperties = new Map();
                        }
                        this._reflectingProperties.set(name, options);
                    }
                }
                else {
                    // Abort the request if the property should not be considered changed.
                    shouldRequestUpdate = false;
                }
            }
            if (!this._hasRequestedUpdate && shouldRequestUpdate) {
                this._enqueueUpdate();
            }
        }
        /**
         * Requests an update which is processed asynchronously. This should
         * be called when an element should update based on some state not triggered
         * by setting a property. In this case, pass no arguments. It should also be
         * called when manually implementing a property setter. In this case, pass the
         * property `name` and `oldValue` to ensure that any configured property
         * options are honored. Returns the `updateComplete` Promise which is resolved
         * when the update completes.
         *
         * @param name {PropertyKey} (optional) name of requesting property
         * @param oldValue {any} (optional) old value of requesting property
         * @returns {Promise} A Promise that is resolved when the update completes.
         */
        requestUpdate(name, oldValue) {
            this._requestUpdate(name, oldValue);
            return this.updateComplete;
        }
        /**
         * Sets up the element to asynchronously update.
         */
        async _enqueueUpdate() {
            // Mark state updating...
            this._updateState = this._updateState | STATE_UPDATE_REQUESTED;
            let resolve;
            let reject;
            const previousUpdatePromise = this._updatePromise;
            this._updatePromise = new Promise((res, rej) => {
                resolve = res;
                reject = rej;
            });
            try {
                // Ensure any previous update has resolved before updating.
                // This `await` also ensures that property changes are batched.
                await previousUpdatePromise;
            }
            catch (e) {
                // Ignore any previous errors. We only care that the previous cycle is
                // done. Any error should have been handled in the previous update.
            }
            // Make sure the element has connected before updating.
            if (!this._hasConnected) {
                await new Promise((res) => this._hasConnectedResolver = res);
            }
            try {
                const result = this.performUpdate();
                // If `performUpdate` returns a Promise, we await it. This is done to
                // enable coordinating updates with a scheduler. Note, the result is
                // checked to avoid delaying an additional microtask unless we need to.
                if (result != null) {
                    await result;
                }
            }
            catch (e) {
                reject(e);
            }
            resolve(!this._hasRequestedUpdate);
        }
        get _hasConnected() {
            return (this._updateState & STATE_HAS_CONNECTED);
        }
        get _hasRequestedUpdate() {
            return (this._updateState & STATE_UPDATE_REQUESTED);
        }
        get hasUpdated() {
            return (this._updateState & STATE_HAS_UPDATED);
        }
        /**
         * Performs an element update. Note, if an exception is thrown during the
         * update, `firstUpdated` and `updated` will not be called.
         *
         * You can override this method to change the timing of updates. If this
         * method is overridden, `super.performUpdate()` must be called.
         *
         * For instance, to schedule updates to occur just before the next frame:
         *
         * ```
         * protected async performUpdate(): Promise<unknown> {
         *   await new Promise((resolve) => requestAnimationFrame(() => resolve()));
         *   super.performUpdate();
         * }
         * ```
         */
        performUpdate() {
            // Mixin instance properties once, if they exist.
            if (this._instanceProperties) {
                this._applyInstanceProperties();
            }
            let shouldUpdate = false;
            const changedProperties = this._changedProperties;
            try {
                shouldUpdate = this.shouldUpdate(changedProperties);
                if (shouldUpdate) {
                    this.update(changedProperties);
                }
            }
            catch (e) {
                // Prevent `firstUpdated` and `updated` from running when there's an
                // update exception.
                shouldUpdate = false;
                throw e;
            }
            finally {
                // Ensure element can accept additional updates after an exception.
                this._markUpdated();
            }
            if (shouldUpdate) {
                if (!(this._updateState & STATE_HAS_UPDATED)) {
                    this._updateState = this._updateState | STATE_HAS_UPDATED;
                    this.firstUpdated(changedProperties);
                }
                this.updated(changedProperties);
            }
        }
        _markUpdated() {
            this._changedProperties = new Map();
            this._updateState = this._updateState & ~STATE_UPDATE_REQUESTED;
        }
        /**
         * Returns a Promise that resolves when the element has completed updating.
         * The Promise value is a boolean that is `true` if the element completed the
         * update without triggering another update. The Promise result is `false` if
         * a property was set inside `updated()`. If the Promise is rejected, an
         * exception was thrown during the update.
         *
         * To await additional asynchronous work, override the `_getUpdateComplete`
         * method. For example, it is sometimes useful to await a rendered element
         * before fulfilling this Promise. To do this, first await
         * `super._getUpdateComplete()`, then any subsequent state.
         *
         * @returns {Promise} The Promise returns a boolean that indicates if the
         * update resolved without triggering another update.
         */
        get updateComplete() {
            return this._getUpdateComplete();
        }
        /**
         * Override point for the `updateComplete` promise.
         *
         * It is not safe to override the `updateComplete` getter directly due to a
         * limitation in TypeScript which means it is not possible to call a
         * superclass getter (e.g. `super.updateComplete.then(...)`) when the target
         * language is ES5 (https://github.com/microsoft/TypeScript/issues/338).
         * This method should be overridden instead. For example:
         *
         *   class MyElement extends LitElement {
         *     async _getUpdateComplete() {
         *       await super._getUpdateComplete();
         *       await this._myChild.updateComplete;
         *     }
         *   }
         */
        _getUpdateComplete() {
            return this._updatePromise;
        }
        /**
         * Controls whether or not `update` should be called when the element requests
         * an update. By default, this method always returns `true`, but this can be
         * customized to control when to update.
         *
         * * @param _changedProperties Map of changed properties with old values
         */
        shouldUpdate(_changedProperties) {
            return true;
        }
        /**
         * Updates the element. This method reflects property values to attributes.
         * It can be overridden to render and keep updated element DOM.
         * Setting properties inside this method will *not* trigger
         * another update.
         *
         * * @param _changedProperties Map of changed properties with old values
         */
        update(_changedProperties) {
            if (this._reflectingProperties !== undefined &&
                this._reflectingProperties.size > 0) {
                // Use forEach so this works even if for/of loops are compiled to for
                // loops expecting arrays
                this._reflectingProperties.forEach((v, k) => this._propertyToAttribute(k, this[k], v));
                this._reflectingProperties = undefined;
            }
        }
        /**
         * Invoked whenever the element is updated. Implement to perform
         * post-updating tasks via DOM APIs, for example, focusing an element.
         *
         * Setting properties inside this method will trigger the element to update
         * again after this update cycle completes.
         *
         * * @param _changedProperties Map of changed properties with old values
         */
        updated(_changedProperties) {
        }
        /**
         * Invoked when the element is first updated. Implement to perform one time
         * work on the element after update.
         *
         * Setting properties inside this method will trigger the element to update
         * again after this update cycle completes.
         *
         * * @param _changedProperties Map of changed properties with old values
         */
        firstUpdated(_changedProperties) {
        }
    }
    _a = finalized;
    /**
     * Marks class as having finished creating properties.
     */
    UpdatingElement[_a] = true;

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    const legacyCustomElement = (tagName, clazz) => {
        window.customElements.define(tagName, clazz);
        // Cast as any because TS doesn't recognize the return type as being a
        // subtype of the decorated class when clazz is typed as
        // `Constructor<HTMLElement>` for some reason.
        // `Constructor<HTMLElement>` is helpful to make sure the decorator is
        // applied to elements however.
        // tslint:disable-next-line:no-any
        return clazz;
    };
    const standardCustomElement = (tagName, descriptor) => {
        const { kind, elements } = descriptor;
        return {
            kind,
            elements,
            // This callback is called once the class is otherwise fully defined
            finisher(clazz) {
                window.customElements.define(tagName, clazz);
            }
        };
    };
    /**
     * Class decorator factory that defines the decorated class as a custom element.
     *
     * @param tagName the name of the custom element to define
     */
    const customElement = (tagName) => (classOrDescriptor) => (typeof classOrDescriptor === 'function') ?
        legacyCustomElement(tagName, classOrDescriptor) :
        standardCustomElement(tagName, classOrDescriptor);
    const standardProperty = (options, element) => {
        // When decorating an accessor, pass it through and add property metadata.
        // Note, the `hasOwnProperty` check in `createProperty` ensures we don't
        // stomp over the user's accessor.
        if (element.kind === 'method' && element.descriptor &&
            !('value' in element.descriptor)) {
            return Object.assign({}, element, { finisher(clazz) {
                    clazz.createProperty(element.key, options);
                } });
        }
        else {
            // createProperty() takes care of defining the property, but we still
            // must return some kind of descriptor, so return a descriptor for an
            // unused prototype field. The finisher calls createProperty().
            return {
                kind: 'field',
                key: Symbol(),
                placement: 'own',
                descriptor: {},
                // When @babel/plugin-proposal-decorators implements initializers,
                // do this instead of the initializer below. See:
                // https://github.com/babel/babel/issues/9260 extras: [
                //   {
                //     kind: 'initializer',
                //     placement: 'own',
                //     initializer: descriptor.initializer,
                //   }
                // ],
                initializer() {
                    if (typeof element.initializer === 'function') {
                        this[element.key] = element.initializer.call(this);
                    }
                },
                finisher(clazz) {
                    clazz.createProperty(element.key, options);
                }
            };
        }
    };
    const legacyProperty = (options, proto, name) => {
        proto.constructor
            .createProperty(name, options);
    };
    /**
     * A property decorator which creates a LitElement property which reflects a
     * corresponding attribute value. A `PropertyDeclaration` may optionally be
     * supplied to configure property features.
     *
     * @ExportDecoratedItems
     */
    function property(options) {
        // tslint:disable-next-line:no-any decorator
        return (protoOrDescriptor, name) => (name !== undefined) ?
            legacyProperty(options, protoOrDescriptor, name) :
            standardProperty(options, protoOrDescriptor);
    }
    /**
     * A property decorator that converts a class property into a getter that
     * executes a querySelector on the element's renderRoot.
     *
     * @ExportDecoratedItems
     */
    function query(selector) {
        return (protoOrDescriptor, 
        // tslint:disable-next-line:no-any decorator
        name) => {
            const descriptor = {
                get() {
                    return this.renderRoot.querySelector(selector);
                },
                enumerable: true,
                configurable: true,
            };
            return (name !== undefined) ?
                legacyQuery(descriptor, protoOrDescriptor, name) :
                standardQuery(descriptor, protoOrDescriptor);
        };
    }
    const legacyQuery = (descriptor, proto, name) => {
        Object.defineProperty(proto, name, descriptor);
    };
    const standardQuery = (descriptor, element) => ({
        kind: 'method',
        placement: 'prototype',
        key: element.key,
        descriptor,
    });

    /**
    @license
    Copyright (c) 2019 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
    const supportsAdoptingStyleSheets = ('adoptedStyleSheets' in Document.prototype) &&
        ('replace' in CSSStyleSheet.prototype);
    const constructionToken = Symbol();
    class CSSResult {
        constructor(cssText, safeToken) {
            if (safeToken !== constructionToken) {
                throw new Error('CSSResult is not constructable. Use `unsafeCSS` or `css` instead.');
            }
            this.cssText = cssText;
        }
        // Note, this is a getter so that it's lazy. In practice, this means
        // stylesheets are not created until the first element instance is made.
        get styleSheet() {
            if (this._styleSheet === undefined) {
                // Note, if `adoptedStyleSheets` is supported then we assume CSSStyleSheet
                // is constructable.
                if (supportsAdoptingStyleSheets) {
                    this._styleSheet = new CSSStyleSheet();
                    this._styleSheet.replaceSync(this.cssText);
                }
                else {
                    this._styleSheet = null;
                }
            }
            return this._styleSheet;
        }
        toString() {
            return this.cssText;
        }
    }
    const textFromCSSResult = (value) => {
        if (value instanceof CSSResult) {
            return value.cssText;
        }
        else if (typeof value === 'number') {
            return value;
        }
        else {
            throw new Error(`Value passed to 'css' function must be a 'css' function result: ${value}. Use 'unsafeCSS' to pass non-literal values, but
            take care to ensure page security.`);
        }
    };
    /**
     * Template tag which which can be used with LitElement's `style` property to
     * set element styles. For security reasons, only literal string values may be
     * used. To incorporate non-literal values `unsafeCSS` may be used inside a
     * template string part.
     */
    const css = (strings, ...values) => {
        const cssText = values.reduce((acc, v, idx) => acc + textFromCSSResult(v) + strings[idx + 1], strings[0]);
        return new CSSResult(cssText, constructionToken);
    };

    /**
     * @license
     * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt
     * The complete set of authors may be found at
     * http://polymer.github.io/AUTHORS.txt
     * The complete set of contributors may be found at
     * http://polymer.github.io/CONTRIBUTORS.txt
     * Code distributed by Google as part of the polymer project is also
     * subject to an additional IP rights grant found at
     * http://polymer.github.io/PATENTS.txt
     */
    // IMPORTANT: do not change the property name or the assignment expression.
    // This line will be used in regexes to search for LitElement usage.
    // TODO(justinfagnani): inject version number at build time
    (window['litElementVersions'] || (window['litElementVersions'] = []))
        .push('2.2.1');
    /**
     * Minimal implementation of Array.prototype.flat
     * @param arr the array to flatten
     * @param result the accumlated result
     */
    function arrayFlat(styles, result = []) {
        for (let i = 0, length = styles.length; i < length; i++) {
            const value = styles[i];
            if (Array.isArray(value)) {
                arrayFlat(value, result);
            }
            else {
                result.push(value);
            }
        }
        return result;
    }
    /** Deeply flattens styles array. Uses native flat if available. */
    const flattenStyles = (styles) => styles.flat ? styles.flat(Infinity) : arrayFlat(styles);
    class LitElement extends UpdatingElement {
        /** @nocollapse */
        static finalize() {
            // The Closure JS Compiler does not always preserve the correct "this"
            // when calling static super methods (b/137460243), so explicitly bind.
            super.finalize.call(this);
            // Prepare styling that is stamped at first render time. Styling
            // is built from user provided `styles` or is inherited from the superclass.
            this._styles =
                this.hasOwnProperty(JSCompiler_renameProperty('styles', this)) ?
                    this._getUniqueStyles() :
                    this._styles || [];
        }
        /** @nocollapse */
        static _getUniqueStyles() {
            // Take care not to call `this.styles` multiple times since this generates
            // new CSSResults each time.
            // TODO(sorvell): Since we do not cache CSSResults by input, any
            // shared styles will generate new stylesheet objects, which is wasteful.
            // This should be addressed when a browser ships constructable
            // stylesheets.
            const userStyles = this.styles;
            const styles = [];
            if (Array.isArray(userStyles)) {
                const flatStyles = flattenStyles(userStyles);
                // As a performance optimization to avoid duplicated styling that can
                // occur especially when composing via subclassing, de-duplicate styles
                // preserving the last item in the list. The last item is kept to
                // try to preserve cascade order with the assumption that it's most
                // important that last added styles override previous styles.
                const styleSet = flatStyles.reduceRight((set, s) => {
                    set.add(s);
                    // on IE set.add does not return the set.
                    return set;
                }, new Set());
                // Array.from does not work on Set in IE
                styleSet.forEach((v) => styles.unshift(v));
            }
            else if (userStyles) {
                styles.push(userStyles);
            }
            return styles;
        }
        /**
         * Performs element initialization. By default this calls `createRenderRoot`
         * to create the element `renderRoot` node and captures any pre-set values for
         * registered properties.
         */
        initialize() {
            super.initialize();
            this.renderRoot =
                this.createRenderRoot();
            // Note, if renderRoot is not a shadowRoot, styles would/could apply to the
            // element's getRootNode(). While this could be done, we're choosing not to
            // support this now since it would require different logic around de-duping.
            if (window.ShadowRoot && this.renderRoot instanceof window.ShadowRoot) {
                this.adoptStyles();
            }
        }
        /**
         * Returns the node into which the element should render and by default
         * creates and returns an open shadowRoot. Implement to customize where the
         * element's DOM is rendered. For example, to render into the element's
         * childNodes, return `this`.
         * @returns {Element|DocumentFragment} Returns a node into which to render.
         */
        createRenderRoot() {
            return this.attachShadow({ mode: 'open' });
        }
        /**
         * Applies styling to the element shadowRoot using the `static get styles`
         * property. Styling will apply using `shadowRoot.adoptedStyleSheets` where
         * available and will fallback otherwise. When Shadow DOM is polyfilled,
         * ShadyCSS scopes styles and adds them to the document. When Shadow DOM
         * is available but `adoptedStyleSheets` is not, styles are appended to the
         * end of the `shadowRoot` to [mimic spec
         * behavior](https://wicg.github.io/construct-stylesheets/#using-constructed-stylesheets).
         */
        adoptStyles() {
            const styles = this.constructor._styles;
            if (styles.length === 0) {
                return;
            }
            // There are three separate cases here based on Shadow DOM support.
            // (1) shadowRoot polyfilled: use ShadyCSS
            // (2) shadowRoot.adoptedStyleSheets available: use it.
            // (3) shadowRoot.adoptedStyleSheets polyfilled: append styles after
            // rendering
            if (window.ShadyCSS !== undefined && !window.ShadyCSS.nativeShadow) {
                window.ShadyCSS.ScopingShim.prepareAdoptedCssText(styles.map((s) => s.cssText), this.localName);
            }
            else if (supportsAdoptingStyleSheets) {
                this.renderRoot.adoptedStyleSheets =
                    styles.map((s) => s.styleSheet);
            }
            else {
                // This must be done after rendering so the actual style insertion is done
                // in `update`.
                this._needsShimAdoptedStyleSheets = true;
            }
        }
        connectedCallback() {
            super.connectedCallback();
            // Note, first update/render handles styleElement so we only call this if
            // connected after first update.
            if (this.hasUpdated && window.ShadyCSS !== undefined) {
                window.ShadyCSS.styleElement(this);
            }
        }
        /**
         * Updates the element. This method reflects property values to attributes
         * and calls `render` to render DOM via lit-html. Setting properties inside
         * this method will *not* trigger another update.
         * * @param _changedProperties Map of changed properties with old values
         */
        update(changedProperties) {
            super.update(changedProperties);
            const templateResult = this.render();
            if (templateResult instanceof TemplateResult) {
                this.constructor
                    .render(templateResult, this.renderRoot, { scopeName: this.localName, eventContext: this });
            }
            // When native Shadow DOM is used but adoptedStyles are not supported,
            // insert styling after rendering to ensure adoptedStyles have highest
            // priority.
            if (this._needsShimAdoptedStyleSheets) {
                this._needsShimAdoptedStyleSheets = false;
                this.constructor._styles.forEach((s) => {
                    const style = document.createElement('style');
                    style.textContent = s.cssText;
                    this.renderRoot.appendChild(style);
                });
            }
        }
        /**
         * Invoked on each update to perform rendering tasks. This method must return
         * a lit-html TemplateResult. Setting properties inside this method will *not*
         * trigger the element to update.
         */
        render() {
        }
    }
    /**
     * Ensure this class is marked as `finalized` as an optimization ensuring
     * it will not needlessly try to `finalize`.
     *
     * Note this property name is a string to prevent breaking Closure JS Compiler
     * optimizations. See updating-element.ts for more information.
     */
    LitElement['finalized'] = true;
    /**
     * Render method used to render the lit-html TemplateResult to the element's
     * DOM.
     * @param {TemplateResult} Template to render.
     * @param {Element|DocumentFragment} Node into which to render.
     * @param {String} Element name.
     * @nocollapse
     */
    LitElement.render = render$1;

    var common = {
    	about: "Om",
    	appdaemon_apps: "AppDaemon Apps",
    	background_task: "Baggrundsopgave kører, denne side vil genindlæses automatisk.",
    	check_log_file: "Tjek din logfil for flere detaljer.",
    	"continue": "Fortsæt",
    	disabled: "Deaktiveret",
    	documentation: "Dokumentation",
    	hacs_is_disabled: "HACS er deaktiveret",
    	installed: "installeret",
    	integration: "Integration",
    	integrations: "Integrationer",
    	manage: "administrer",
    	plugin: "Plugin",
    	plugins: "Plugins",
    	python_script: "Python Script",
    	python_scripts: "Python Scripts",
    	repositories: "Repositories",
    	settings: "indstillinger",
    	theme: "Tema",
    	themes: "Temaer",
    	version: "Version"
    };
    var config = {
    	abort: {
    		single_instance_allowed: "Kun en enkelt konfiguration af HACS er tilladt."
    	},
    	error: {
    		auth: "Personlig Adgang Token er ikke korrekt."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Aktiver AppDaemon apps opdagelse & sporing",
    				python_script: "Aktivér opdagelse og sporing af python_scripts",
    				sidepanel_icon: "Side panel ikon",
    				sidepanel_title: "Side panel titel",
    				theme: "Aktivér opdagelse og sporing af temaer",
    				token: "GitHub personlig adgangstoken"
    			},
    			description: "Hvis du har brug for hjælp til konfigurationen, så kig her: https://hacs.xyz/docs/configuration/start"
    		}
    	}
    };
    var confirm = {
    	add_to_lovelace: "Er du sikker på, at du vil tilføje dette til dine Lovelace-ressourcer?",
    	bg_task: "Handlingen er deaktiveret, mens baggrundsopgaver kører.",
    	cancel: "Annuller",
    	"continue": "Er du sikker på, at du vil fortsætte?",
    	"delete": "Er du sikker på, at du vil slette '{Item}'?",
    	delete_installed: "'{item}' er installeret, du skal afinstallere det, før du kan slette det.",
    	exist: "{item} findes allerede",
    	generic: "Er du sikker?",
    	no: "Nej",
    	no_upgrades: "Der er ingen opdateringer tilgængelig",
    	ok: "OK",
    	overwrite: "Dette vil overskrive den.",
    	reload_data: "Dette genindlæser data fra alle repositories, som HACS kender til, dette vil tage nogen tid at afslutte.",
    	uninstall: "Er du sikker på, at du vil afinstallere '{Item}'?",
    	upgrade_all: "Dette vil opdatere alle repositories, sørg for at du har læst release notes for dem alle inden du fortsætter.",
    	yes: "Ja"
    };
    var options = {
    	step: {
    		user: {
    			data: {
    				country: "Filtrer med landekode.",
    				debug: "Aktiver debug.",
    				experimental: "Aktivér eksperimentelle funktioner",
    				release_limit: "Antal udgivelser, der skal vises."
    			}
    		}
    	}
    };
    var repository_banner = {
    	integration_not_loaded: "Denne integration er ikke indlæst i Home Assistant.",
    	not_loaded: "Ikke indlæst",
    	plugin_not_loaded: "Dette plugin er ikke føjet til dine Lovelace ressourcer.",
    	restart: "Du skal genstarte Home Assistant.",
    	restart_pending: "Afventer genstart"
    };
    var repository = {
    	add_to_lovelace: "Tilføj til Lovelace",
    	authors: "Forfattere",
    	available: "Tilgængelig",
    	back_to: "Tilbage til",
    	changelog: "Change log",
    	downloads: "Downloads",
    	flag_this: "Marker denne",
    	frontend_version: "Frontend version",
    	hide: "Skjul",
    	hide_beta: "Skjul beta",
    	install: "Installer",
    	installed: "Installeret",
    	lovelace_copy_example: "Kopiér eksemplet til din Udklipsholder",
    	lovelace_instruction: "Tilføj dette til din lovelace konfiguration",
    	lovelace_no_js_type: "Kunne ikke afgøre typen af dette plugin, tjek venligst repository.",
    	newest: "nyeste",
    	note_appdaemon: "Du skal stadig føje den til filen 'apps.yaml'",
    	note_installed: "Når det er installeret, vil dette være placeret i",
    	note_integration: "du skal stadig føje den til filen 'configuration.yaml'",
    	note_plugin: "du skal stadig tilføje det til din lovelace konfiguration ('ui-lovelace.yaml \" eller Tekstbaseret redigering)",
    	open_issue: "Opret issue",
    	open_plugin: "Åbn plugin",
    	reinstall: "Geninstaller",
    	repository: "Repository",
    	show_beta: "Vis beta",
    	uninstall: "Afinstaller",
    	update_information: "Opdater oplysninger",
    	upgrade: "Opdater"
    };
    var settings = {
    	add_custom_repository: "TILFØJ ET BRUGERDEFINERET REPOSITORY",
    	adding_new_repo: "Tilføjer nyt repository '{repo}'",
    	adding_new_repo_category: "Med kategorien '{category}'.",
    	bg_task_custom: "Brugerdefinerede repositories er skjult, mens opgaver i baggrunden kører.",
    	category: "Kategori",
    	compact_mode: "Kompakt tilstand",
    	custom_repositories: "BRUGERDEFINEREDE REPOSITORIES",
    	"delete": "Slet",
    	display: "Visning",
    	grid: "Gitter",
    	hacs_repo: "HACS repo",
    	hidden_repositories: "Skjulte repositories",
    	missing_category: "Du skal vælge en kategori",
    	open_repository: "Åbn repository",
    	reload_data: "Genindlæs data",
    	repository_configuration: "Konfiguration af repository",
    	save: "Gem",
    	table: "Tabel",
    	table_view: "Tabel visning",
    	unhide: "Vis",
    	upgrade_all: "Opdater alle"
    };
    var store = {
    	ascending: "stigende",
    	clear_new: "Marker alle som set",
    	descending: "faldende",
    	last_updated: "Sidst opdateret",
    	name: "Navn",
    	new_repositories: "Nye repositories",
    	pending_upgrades: "Afventende opdateringer",
    	placeholder_search: "Indtast et søgeudtryk ...",
    	sort: "sorter",
    	stars: "Stjerner",
    	status: "Status"
    };
    var time = {
    	ago: "siden",
    	day: "dag",
    	days: "dage",
    	hour: "time",
    	hours: "timer",
    	minute: "minut",
    	minutes: "minutter",
    	month: "måned",
    	months: "måneder",
    	one: "Et",
    	second: "sekund",
    	seconds: "sekunder",
    	year: "år",
    	years: "år"
    };
    var da = {
    	common: common,
    	config: config,
    	confirm: confirm,
    	options: options,
    	repository_banner: repository_banner,
    	repository: repository,
    	settings: settings,
    	store: store,
    	time: time
    };

    var da$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common,
        config: config,
        confirm: confirm,
        options: options,
        repository_banner: repository_banner,
        repository: repository,
        settings: settings,
        store: store,
        time: time,
        'default': da
    });

    var common$1 = {
    	about: "Über",
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "AppDaemon Apps",
    	background_task: "Hintergrundprozess läuft. Diese Seite lädt neu, sobald dieser fertig ist.",
    	check_log_file: "Überprüfe die Logdatei für weitere Informationen.",
    	"continue": "Fortfahren",
    	disabled: "Deaktiviert",
    	documentation: "Dokumentation",
    	hacs_is_disabled: "HACS ist deaktiviert",
    	installed: "Installiert",
    	integration: "Integration",
    	integrations: "Integrationen",
    	manage: "verwalten",
    	plugin: "Plugin",
    	plugins: "Plugins",
    	python_script: "Python Skript",
    	python_scripts: "Python Skripte",
    	repositories: "Repositories",
    	settings: "Einstellungen",
    	theme: "Theme",
    	themes: "Themes",
    	version: "Version"
    };
    var config$1 = {
    	abort: {
    		single_instance_allowed: "Es ist nur eine einzelne HACS-Instanz erlaubt."
    	},
    	error: {
    		auth: "Persönlicher Zugriffstoken ist falsch."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "AppDaemon App-Discovery & Tracking aktivieren",
    				python_script: "Python Script-Discovery & Tracking aktivieren",
    				sidepanel_icon: "Sidepanel Symbol",
    				sidepanel_title: "Sidepanel Titel",
    				theme: "Theme-Discovery & Tracking aktivieren",
    				token: "Persönlicher GitHub Zugriffstoken"
    			},
    			description: "Wenn du Hilfe mit den Einstellungen brauchst, kannst du hier nachsehen: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$1 = {
    	add_to_lovelace: "Möchtest du dies wirklich zu deinen Lovelace-Ressourcen hinzufügen?",
    	bg_task: "Die Aktion ist deaktiviert, während Hintergrundprozesse ausgeführt werden.",
    	cancel: "Abbrechen",
    	"continue": "Bist du dir sicher, dass du fortfahren möchtest?",
    	"delete": "Möchtest du '{item}' wirklich löschen?",
    	delete_installed: "'{item}' ist installiert. Du musst es deinstallieren, bevor du es löschen kannst.",
    	exist: "{item} existiert bereits",
    	generic: "Bist du dir sicher?",
    	home_assistant_is_restarting: "Bitte warte, Home Assistant wird jetzt neu gestartet.",
    	no: "Nein",
    	no_upgrades: "Keine Upgrades ausstehend",
    	ok: "OK",
    	overwrite: "Dadurch wird die Datei überschrieben.",
    	reload_data: "Hierdurch werden die Daten aller Repositories die HACS kennt neu geladen. Dies wird einige Zeit in Anspruch nehmen.",
    	restart_home_assistant: "Bist du dir sicher, dass du Home Assistant neu starten möchtest?",
    	uninstall: "Möchtest du '{item}' wirklich deinstallieren?",
    	upgrade_all: "Hierdurch werden all diese Repositories aktualisiert. Stelle sicher, dass du die Versionshinweise vorher gelesen hast.",
    	yes: "Ja"
    };
    var options$1 = {
    	step: {
    		user: {
    			data: {
    				country: "Nach Ländercode filtern.",
    				debug: "Debug aktivieren.",
    				experimental: "Experimentelle Funktionen aktivieren",
    				release_limit: "Anzahl anzuzeigender Releases."
    			}
    		}
    	}
    };
    var repository_banner$1 = {
    	config_flow: "Diese Integration unterstützt config_flow. Das bedeutet, dass du jetzt in den Integrationsbereich deiner Benutzeroberfläche wechseln kannst, um es zu konfigurieren.",
    	integration_not_loaded: "Diese Integration ist in Home Assistant nicht geladen.",
    	no_restart_required: "Kein Neustart erforderlich",
    	not_loaded: "Nicht geladen",
    	plugin_not_loaded: "Dieses Plugin wurde deinen Lovelace-Ressourcen nicht hinzugefügt.",
    	restart: "Du musst Home Assistant neu starten.",
    	restart_pending: "Neustart ausstehend"
    };
    var repository$1 = {
    	add_to_lovelace: "Zu Lovelace hinzufügen",
    	authors: "Autoren",
    	available: "Verfügbar",
    	back_to: "Zurück zu",
    	changelog: "Änderungsprotokoll",
    	downloads: "Downloads",
    	flag_this: "Melden",
    	frontend_version: "Frontend Version",
    	github_stars: "GitHub Sterne",
    	goto_integrations: "Gehe zu Integrationen",
    	hide: "Verstecken",
    	hide_beta: "Beta verstecken",
    	install: "Installieren",
    	installed: "Installiert",
    	lovelace_copy_example: "Beispiel in die Zwischenablage kopieren",
    	lovelace_instruction: "Zum Hinzufügen zu deinen Lovelace-Einstellungen, benutze Folgendes",
    	lovelace_no_js_type: "Konnte die Art dieses Plugins nicht erkennen. Prüfe das Repository.",
    	newest: "neueste",
    	note_appdaemon: "du musst es dann noch in die Datei 'apps.yaml' hinzufügen",
    	note_installed: "Wird installiert nach",
    	note_integration: "du musst es dann noch in die Datei 'configuration.yaml' hinzufügen",
    	note_plugin: "du musst es dann noch in deine Lovelace-Einstellungen ('ui-lovelace.yaml' oder im Raw-Konfigurationseditor) hinzufügen",
    	open_issue: "Problem melden",
    	open_plugin: "Plugin öffnen",
    	reinstall: "Neu installieren",
    	repository: "Repository",
    	restart_home_assistant: "Home Assistant neu starten",
    	show_beta: "Beta anzeigen",
    	uninstall: "Deinstallieren",
    	update_information: "Aktualisierungsinformationen",
    	upgrade: "Aktualisieren"
    };
    var settings$1 = {
    	add_custom_repository: "BENUTZERDEFINIERTES REPOSITORY HINZUFÜGEN",
    	adding_new_repo: "Hinzufügen eines neuen Repository '{repo}'",
    	adding_new_repo_category: "Mit der Kategorie '{category}'.",
    	bg_task_custom: "Custom Repositorys werden ausgeblendet, während Hintergrundaufgaben ausgeführt werden.",
    	category: "Kategorie",
    	compact_mode: "Kompakter Modus",
    	custom_repositories: "BENUTZERDEFINIERTE REPOSITORIES",
    	"delete": "Löschen",
    	display: "Anzeige",
    	grid: "Gitter",
    	hacs_repo: "HACS repo",
    	hidden_repositories: "versteckte Repositories",
    	missing_category: "Du musst eine Kategorie auswählen.",
    	open_repository: "Repository öffnen",
    	reload_data: "Daten neu laden",
    	reload_window: "Fenster neu laden",
    	repository_configuration: "Repository Konfiguration",
    	save: "Speichern",
    	table: "Tabelle",
    	table_view: "Tabellenansicht",
    	unhide: "einblenden",
    	upgrade_all: "Alles aktualisieren"
    };
    var store$1 = {
    	ascending: "Aufsteigend",
    	clear_new: "Alle neuen Repositories als gesehen markieren",
    	descending: "Absteigend",
    	last_updated: "Zuletzt aktualisiert",
    	name: "Name",
    	new_repositories: "Neue Repositories",
    	pending_upgrades: "Ausstehende Upgrades",
    	placeholder_search: "Suchbegriff eingeben…",
    	sort: "Sortieren",
    	stars: "Sterne",
    	status: "Status"
    };
    var time$1 = {
    	ago: "vor",
    	day: "Tag",
    	days: "Tage",
    	hour: "Stunde",
    	hours: "Stunden",
    	minute: "Minute",
    	minutes: "Minuten",
    	month: "Monat",
    	months: "Monate",
    	one: "Eins",
    	one_day_ago: "vor einem Tag",
    	one_hour_ago: "vor einer Stunde",
    	one_minute_ago: "vor einer Minute",
    	one_month_ago: "vor einem Monat",
    	one_second_ago: "vor einer Sekunde",
    	one_year_ago: "vor einem Jahr",
    	second: "Sekunde",
    	seconds: "Sekunden",
    	x_days_ago: "vor {x} Tagen",
    	x_hours_ago: "vor {x} Stunden",
    	x_minutes_ago: "vor {x} Minuten",
    	x_months_ago: "vor {x} Monaten",
    	x_seconds_ago: "vor {x} Sekunden",
    	x_years_ago: "vor {x} Jahren",
    	year: "Jahr",
    	years: "Jahre"
    };
    var de = {
    	common: common$1,
    	config: config$1,
    	confirm: confirm$1,
    	options: options$1,
    	repository_banner: repository_banner$1,
    	repository: repository$1,
    	settings: settings$1,
    	store: store$1,
    	time: time$1
    };

    var de$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$1,
        config: config$1,
        confirm: confirm$1,
        options: options$1,
        repository_banner: repository_banner$1,
        repository: repository$1,
        settings: settings$1,
        store: store$1,
        time: time$1,
        'default': de
    });

    var common$2 = {
    	about: "Σχετικά με",
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "AppDaemon Apps",
    	background_task: "Τρέχει μια διεργασία στο παρασκήνιο, η σελίδα θα ανανεωθεί μόλις αυτό ολοκληρωθεί.",
    	check_log_file: "Ελέγξτε το αρχείο καταγραφής για περισσότερες λεπτομέρειες.",
    	disabled: "Απενεργοποιημένο",
    	documentation: "Τεκμηρίωση",
    	hacs_is_disabled: "Το HACS είναι απενεργοποιημένο",
    	installed: "εγκατεστημένο",
    	integration: "Ενσωμάτωση",
    	integrations: "Ενσωματωμένα",
    	plugin: "Πρόσθετο",
    	plugins: "Πρόσθετα",
    	python_script: "Πρόγραμμα Python",
    	python_scripts: "Προγράμματα Python",
    	repositories: "Αποθετήρια",
    	settings: "ρυθμίσεις",
    	theme: "Θέμα",
    	themes: "Θέματα",
    	version: "Έκδοση"
    };
    var config$2 = {
    	abort: {
    		single_instance_allowed: "Μονάχα μία ρύθμιση των παραμέτρων του HACS επιτρέπεται."
    	},
    	error: {
    		auth: "Το διακριτικό πρόσβασης δεν είναι σωστό."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Ενεργοποίηση εύρεσης & παρακολούθησης για το AppDaemon",
    				python_script: "Ενεργοποίηση εύρεσης & παρακολούθησης για τα python_scripts",
    				sidepanel_icon: "Εικονίδιο πλαϊνού πάνελ",
    				sidepanel_title: "Τίτλος πλαϊνού πάνελ",
    				theme: "Ενεργοποίηση εύρεσης & παρακολούθησης για τα θεμάτων",
    				token: "Διακριτικό πρόσβασης του GitHub"
    			},
    			description: "Εάν χρειαστείτε βοήθεια με τις ρυθμίσεις ανατρέξτε εδώ: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$2 = {
    	add_to_lovelace: "Είστε βέβαιοι ότι θέλετε να προσθέσετε αυτό στους πόρους του Lovelace;",
    	bg_task: "Η ενέργεια είναι απενεργοποιημένη όσο εκτελούνται εργασίες στο παρασκήνιο",
    	cancel: "Ακύρωση",
    	"continue": "Είστε βέβαιοι ότι θέλετε να συνεχίσετε;",
    	"delete": "Είστε σίγουροι ότι θέλετε να διαγράψετε το \"{item}\";",
    	exist: "{item} υπάρχει ήδη",
    	generic: "Είστε βέβαιοι;",
    	home_assistant_is_restarting: "Περιμένετε, το Home Assistant επανεκκινείται τώρα.",
    	no: "Οχι",
    	no_upgrades: "Δεν υπάρχουν αναβαθμίσεις σε εκκρεμότητα",
    	ok: "Εντάξει",
    	overwrite: "Αυτό θα το αντικαταστήσει.",
    	restart_home_assistant: "Είστε βέβαιοι ότι θέλετε να κάνετε επανεκκίνηση του Home Assistant;",
    	uninstall: "Είστε βέβαιοι ότι θέλετε να απεγκαταστήσετε το '{item}';",
    	upgrade_all: "Αυτό θα αναβαθμίσει όλα αυτά τα αποθετήρια, βεβαιωθείτε ότι έχετε διαβάσει τις σημειώσεις έκδοσης για όλα πριν προχωρήσετε.",
    	yes: "Ναι"
    };
    var options$2 = {
    	step: {
    		user: {
    			data: {
    				country: "Κριτήριο με βάση τον κωδικό χώρας.",
    				debug: "Ενεργοποίηση εντοπισμού σφαλμάτων.",
    				experimental: "Ενεργοποίση πειραματικών λειτουργιών",
    				release_limit: "Αριθμός εκδόσεων που να παραθέτονται."
    			}
    		}
    	}
    };
    var repository_banner$2 = {
    	integration_not_loaded: "Αυτή η ενσωμάτωση δεν φορτώθηκε στο Home Assistant.",
    	no_restart_required: "Δεν απαιτείται επανεκκίνηση",
    	not_loaded: "Δεν έχει φορτωθεί",
    	plugin_not_loaded: "Αυτό το πρόσθετο δεν προστέθηκε στους πόρους του Lovelace.",
    	restart: "Πρέπει να κάνετε επανεκκίνηση του Home Assistant.",
    	restart_pending: "Επανεκκίνηση σε εκκρεμότητα"
    };
    var repository$2 = {
    	add_to_lovelace: "Προσθήκη στο Lovelace",
    	authors: "Συγγραφείς",
    	available: "Διαθέσιμο",
    	back_to: "Πίσω στο",
    	changelog: "Σημειώσεις των αλλαγών",
    	downloads: "Λήψεις",
    	flag_this: "Σημείωσε αυτό",
    	frontend_version: "Έκδοση Frontend",
    	hide: "Απόκρυψη",
    	hide_beta: "Απόκριση του beta",
    	install: "Εγκατάσταση",
    	installed: "Εγκατεστημένο",
    	lovelace_copy_example: "Αντίγραψε το παράδειγμα στο πρόχειρο",
    	lovelace_instruction: "Όταν το προσθέσετε στις ρυθμίσεις του lovelace χρησιμοποιήστε τούτο",
    	lovelace_no_js_type: "Δεν καταφέραμε να προσδιορίσουμε τον τύπο αυτού του προσθέτου, ελέξτε το αποθετήριο.",
    	newest: "νεότερο",
    	note_appdaemon: "εξακολουθεί να χρειάζεται να το προσθέσετε στο αρχείο 'apps.yaml'",
    	note_installed: "Όταν εγκατασταθεί, θα προστεθεί στο",
    	note_integration: "εξακολουθεί να χρειάζεται να το προσθέσετε στο αρχείο 'configuration.yaml'",
    	note_plugin: "εξακολουθεί να χρειάζετε να το προσθέσετε στις ρυθμίσεις του lovelace ('ui-lovelace.yaml' ή μέσω του γραφικού επεξεργαστή των ρυθμίσεων)",
    	open_issue: "Εκκρεμόν ζήτημα",
    	open_plugin: "Ανοιχτό πρόσθετο",
    	reinstall: "Επανεγκατάσταση",
    	repository: "Αποθετήριο",
    	show_beta: "Εμφάνιση του beta",
    	uninstall: "Απεγκατάσταση",
    	update_information: "Ενημέρωση πληροφοριών",
    	upgrade: "Ενημέρωση"
    };
    var settings$2 = {
    	add_custom_repository: "ΠΡΟΣΘΕΣΤΕ ΕΝΑ ΕΙΔΙΚΟ ΑΠΟΘΕΤΗΡΙΟ",
    	adding_new_repo_category: "Με κατηγορία '{category}'.",
    	category: "Κατηγορία",
    	compact_mode: "Συμπαγής λειτουργία",
    	custom_repositories: "ΕΙΔΙΚΑ ΑΠΟΘΕΤΗΡΙΑ",
    	"delete": "Διαγραφή",
    	display: "Εμφάνιση",
    	grid: "Πλέγμα",
    	hacs_repo: "Αποθετήριο του HACS",
    	hidden_repositories: "κρυφά αποθετήρια",
    	missing_category: "Πρέπει να επιλέξετε μια κατηγορία",
    	reload_data: "Επαναφόρτωση δεδομένων",
    	reload_window: "Επαναφόρτωση του παραθύρου",
    	save: "Αποθήκευση",
    	table: "Πίνακας",
    	upgrade_all: "Αναβάθμιση όλων"
    };
    var store$2 = {
    	ascending: "αύξουσα",
    	clear_new: "Απαλοιφή όλων των νέων αποθετηρίων",
    	descending: "φθίνουσα",
    	last_updated: "Τελευταία ενημέρωση",
    	name: "Ονομα",
    	new_repositories: "Νέα αποθετήρια",
    	pending_upgrades: "Εκκρεμείς αναβαθμίσεις",
    	placeholder_search: "Παρακαλώ πληκτρολογήστε έναν όρο προς αναζήτηση...",
    	status: "Κατάσταση"
    };
    var time$2 = {
    	ago: "πριν",
    	day: "ημέρα",
    	days: "ημέρες",
    	hour: "ώρα",
    	hours: "ώρες",
    	minute: "λεπτό",
    	minutes: "λεπτά",
    	month: "μήνας",
    	months: "μήνες",
    	one: "Ένα",
    	one_day_ago: "πριν από μία ημέρα",
    	one_hour_ago: "πριν από μια ώρα",
    	one_minute_ago: "πριν από ένα λεπτό",
    	one_month_ago: "πριν από ένα μήνα",
    	one_second_ago: "πριν από ένα δευτερόλεπτο",
    	one_year_ago: "πριν από ένα χρόνο",
    	second: "δευτερόλεπτο",
    	seconds: "δευτερόλεπτα",
    	x_days_ago: "{x} ημέρες πριν",
    	x_hours_ago: "{x} ώρες πριν",
    	x_minutes_ago: "{x} λεπτά πριν",
    	x_months_ago: "{x} μήνες πριν",
    	x_seconds_ago: "{x} δευτερόλεπτα πριν",
    	x_years_ago: "{x} χρόνια πριν",
    	year: "έτος",
    	years: "χρόνια"
    };
    var el = {
    	common: common$2,
    	config: config$2,
    	confirm: confirm$2,
    	options: options$2,
    	repository_banner: repository_banner$2,
    	repository: repository$2,
    	settings: settings$2,
    	store: store$2,
    	time: time$2
    };

    var el$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$2,
        config: config$2,
        confirm: confirm$2,
        options: options$2,
        repository_banner: repository_banner$2,
        repository: repository$2,
        settings: settings$2,
        store: store$2,
        time: time$2,
        'default': el
    });

    var common$3 = {
    	about: "About",
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "AppDaemon Apps",
    	background_task: "Background task running, this page will reload when it's done.",
    	check_log_file: "Check your log file for more details.",
    	"continue": "Continue",
    	disabled: "Disabled",
    	documentation: "Documentation",
    	hacs_is_disabled: "HACS is disabled",
    	installed: "installed",
    	integration: "Integration",
    	integrations: "Integrations",
    	manage: "manage",
    	plugin: "Plugin",
    	plugins: "Plugins",
    	python_script: "Python Script",
    	python_scripts: "Python Scripts",
    	repositories: "Repositories",
    	settings: "settings",
    	theme: "Theme",
    	themes: "Themes",
    	version: "Version"
    };
    var config$3 = {
    	abort: {
    		single_instance_allowed: "Only a single configuration of HACS is allowed."
    	},
    	error: {
    		auth: "Personal Access Token is not correct."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Enable AppDaemon apps discovery & tracking",
    				python_script: "Enable python_scripts discovery & tracking",
    				sidepanel_icon: "Side panel icon",
    				sidepanel_title: "Side panel title",
    				theme: "Enable Themes discovery & tracking",
    				token: "GitHub Personal Access Token"
    			},
    			description: "If you need help with the configuration have a look here: https://hacs.xyz/docs/configuration/start/",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$3 = {
    	add_to_lovelace: "Are you sure you want to add this to your Lovelace resources?",
    	bg_task: "Action is disabled while background tasks is running.",
    	cancel: "Cancel",
    	"continue": "Are you sure you want to continue?",
    	"delete": "Are you sure you want to delete \"{item}\"?",
    	delete_installed: "'{item}' is installed, you need to uninstall it before you can delete it.",
    	exist: "{item} already exists",
    	generic: "Are you sure?",
    	home_assistant_is_restarting: "Hold on, Home Assistant is now restarting.",
    	no: "No",
    	no_upgrades: "No upgrades pending",
    	ok: "OK",
    	overwrite: "Doing this will overwrite it.",
    	reload_data: "This reloads the data of all repositories HACS knows about, this will take some time to finish.",
    	restart_home_assistant: "Are you sure you want to restart Home Assistant?",
    	uninstall: "Are you sure you want to uninstall \"{item}\"?",
    	upgrade_all: "This will upgrade all of these repositories, make sure that you have read the release notes for all of them before proceeding.",
    	yes: "Yes"
    };
    var options$3 = {
    	step: {
    		user: {
    			data: {
    				country: "Filter with country code.",
    				debug: "Enable debug.",
    				experimental: "Enable experimental features",
    				release_limit: "Number of releases to show."
    			}
    		}
    	}
    };
    var repository_banner$3 = {
    	config_flow: "This integration supports config_flow, that means that you now can go to the integration section of your UI to configure it.",
    	integration_not_loaded: "This integration is not loaded in Home Assistant.",
    	no_restart_required: "No restart required",
    	not_loaded: "Not loaded",
    	plugin_not_loaded: "This plugin is not added to your Lovelace resources.",
    	restart: "You need to restart Home Assistant.",
    	restart_pending: "Restart pending"
    };
    var repository$3 = {
    	add_to_lovelace: "Add to Lovelace",
    	authors: "Authors",
    	available: "Available",
    	back_to: "Back to",
    	changelog: "Change log",
    	downloads: "Downloads",
    	flag_this: "Flag this",
    	frontend_version: "Frontend version",
    	github_stars: "GitHub stars",
    	goto_integrations: "Go to integrations",
    	hide: "Hide",
    	hide_beta: "Hide beta",
    	install: "Install",
    	installed: "Installed",
    	lovelace_copy_example: "Copy the example to your clipboard",
    	lovelace_instruction: "When you add this to your lovelace configuration use this",
    	lovelace_no_js_type: "Could not determine the type of this plugin, check the repository.",
    	newest: "newest",
    	note_appdaemon: "you still need to add it to your 'apps.yaml' file",
    	note_installed: "When installed, this will be located in",
    	note_integration: "you still need to add it to your 'configuration.yaml' file",
    	note_plugin: "you still need to add it to your lovelace configuration ('ui-lovelace.yaml' or the raw UI config editor)",
    	open_issue: "Open issue",
    	open_plugin: "Open plugin",
    	reinstall: "Reinstall",
    	repository: "Repository",
    	restart_home_assistant: "Restart Home Assistant",
    	show_beta: "Show beta",
    	uninstall: "Uninstall",
    	update_information: "Update information",
    	upgrade: "Update"
    };
    var settings$3 = {
    	add_custom_repository: "ADD CUSTOM REPOSITORY",
    	adding_new_repo: "Adding new repository '{repo}'",
    	adding_new_repo_category: "With category '{category}'.",
    	bg_task_custom: "Custom repositories are hidden while background tasks is running.",
    	category: "Category",
    	compact_mode: "Compact mode",
    	custom_repositories: "CUSTOM REPOSITORIES",
    	"delete": "Delete",
    	display: "Display",
    	grid: "Grid",
    	hacs_repo: "HACS repo",
    	hidden_repositories: "hidden repositories",
    	missing_category: "You need to select a category",
    	open_repository: "Open repository",
    	reload_data: "Reload data",
    	reload_window: "Reload window",
    	repository_configuration: "Repository configuration",
    	save: "Save",
    	table: "Table",
    	table_view: "Table view",
    	unhide: "unhide",
    	upgrade_all: "Upgrade all"
    };
    var store$3 = {
    	ascending: "ascending",
    	clear_new: "Clear all new repositories",
    	descending: "descending",
    	last_updated: "Last updated",
    	name: "Name",
    	new_repositories: "New Repositories",
    	pending_upgrades: "Pending upgrades",
    	placeholder_search: "Please enter a search term...",
    	sort: "sort",
    	stars: "Stars",
    	status: "Status"
    };
    var time$3 = {
    	ago: "ago",
    	day: "day",
    	days: "days",
    	hour: "hour",
    	hours: "hours",
    	minute: "minute",
    	minutes: "minutes",
    	month: "month",
    	months: "months",
    	one: "One",
    	one_day_ago: "one day ago",
    	one_hour_ago: "one hour ago",
    	one_minute_ago: "one minute ago",
    	one_month_ago: "one month ago",
    	one_second_ago: "one second ago",
    	one_year_ago: "one year ago",
    	second: "second",
    	seconds: "seconds",
    	x_days_ago: "{x} days ago",
    	x_hours_ago: "{x} hours ago",
    	x_minutes_ago: "{x} minutes ago",
    	x_months_ago: "{x} months ago",
    	x_seconds_ago: "{x} seconds ago",
    	x_years_ago: "{x} years ago",
    	year: "year",
    	years: "years"
    };
    var en = {
    	common: common$3,
    	config: config$3,
    	confirm: confirm$3,
    	options: options$3,
    	repository_banner: repository_banner$3,
    	repository: repository$3,
    	settings: settings$3,
    	store: store$3,
    	time: time$3
    };

    var en$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$3,
        config: config$3,
        confirm: confirm$3,
        options: options$3,
        repository_banner: repository_banner$3,
        repository: repository$3,
        settings: settings$3,
        store: store$3,
        time: time$3,
        'default': en
    });

    var common$4 = {
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "AppDaemon Apps",
    	background_task: "Ejecutando tareas en segundo plano. Se refrescará automaticamente esta página al finalizar.",
    	installed: "instalado",
    	integration: "Integración",
    	integrations: "Integraciones",
    	plugin: "Plugin",
    	plugins: "Plugins",
    	python_script: "Python Script",
    	python_scripts: "Python Scripts",
    	repositories: "Repositorios",
    	settings: "configuraciones",
    	theme: "Tema",
    	themes: "Temas",
    	version: "Versión"
    };
    var config$4 = {
    	abort: {
    		single_instance_allowed: "Sólo se permite una única configuración de HACS."
    	},
    	error: {
    		auth: "El token de acceso personal no es correcto."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Habilitar el descubrimiento y seguimiento de las aplicaciones de AppDaemon",
    				python_script: "Habilitar el descubrimiento y seguimiento en python_scripts",
    				sidepanel_icon: "Ícono del panel lateral",
    				sidepanel_title: "Título del panel lateral",
    				theme: "Habilitar el descubrimiento y seguimiento de temas",
    				token: "Token de acceso personal de GitHub"
    			},
    			description: "Si necesitas ayuda con la configuración dirigete a: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$4 = {
    	"delete": "¿Seguro que quieres eliminar \" {item} \"?"
    };
    var options$4 = {
    	step: {
    		user: {
    			data: {
    				country: "Filtrar por el código de país.",
    				experimental: "Habilitar funciones experimentales",
    				release_limit: "Número de versiones a mostrar."
    			}
    		}
    	}
    };
    var repository$4 = {
    	authors: "Autores",
    	available: "Disponible",
    	back_to: "Volver a",
    	changelog: "Changelog",
    	flag_this: "Marcar esto",
    	hide: "Ocultar",
    	hide_beta: "Ocultar beta",
    	install: "Instalar",
    	installed: "Instalado",
    	lovelace_copy_example: "Copiar el ejemplo al clipboard",
    	lovelace_instruction: "Cuando agregue esto a su configuración de lovelace, use esto",
    	lovelace_no_js_type: "No se pudo determinar el tipo de plugin, revise el repositorio.",
    	newest: "más nuevo",
    	note_appdaemon: "deberá agregar esto a su archivo 'apps.yaml'",
    	note_installed: "Al instalarse se encontrará en",
    	note_integration: "deberá agregar esto a su archivo 'configuration.yaml'",
    	note_plugin: "deberá agregar esto a su configuración de lovelace ('ui-lovelace.yaml' o en el editor UI de lovelace)",
    	open_issue: "Abrir issue",
    	open_plugin: "Abrir plugin",
    	reinstall: "Reinstalar",
    	repository: "Repositorio",
    	show_beta: "Mostrar beta",
    	uninstall: "Desinstalar",
    	update_information: "Actualizar información",
    	upgrade: "Actualizar"
    };
    var settings$4 = {
    	add_custom_repository: "AGREGAR CUSTOM REPOSITORY",
    	category: "Categoría",
    	custom_repositories: "CUSTOM REPOSITORIES",
    	"delete": "Eliminar",
    	display: "Display",
    	grid: "Grilla",
    	hacs_repo: "HACS repo",
    	reload_data: "Releer datos",
    	save: "Grabar",
    	table: "Tabla",
    	upgrade_all: "Actualizar todo"
    };
    var store$4 = {
    	placeholder_search: "Por favor escriba una palabra clave de búsqueda..."
    };
    var time$4 = {
    	one: "Uno"
    };
    var es = {
    	common: common$4,
    	config: config$4,
    	confirm: confirm$4,
    	options: options$4,
    	repository: repository$4,
    	settings: settings$4,
    	store: store$4,
    	time: time$4
    };

    var es$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$4,
        config: config$4,
        confirm: confirm$4,
        options: options$4,
        repository: repository$4,
        settings: settings$4,
        store: store$4,
        time: time$4,
        'default': es
    });

    var common$5 = {
    	about: "À propos de",
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "Applications AppDaemon",
    	background_task: "Tache de fond en cours, cette page se rechargera une fois terminée",
    	check_log_file: "Consultez votre fichier journal pour plus de détails.",
    	"continue": "Continuer",
    	disabled: "Désactivé",
    	documentation: "Documentation",
    	hacs_is_disabled: "HACS est désactivé",
    	installed: "installés",
    	integration: "Intégration",
    	integrations: "Intégrations",
    	manage: "gérer",
    	plugin: "Plugin",
    	plugins: "Plugins",
    	python_script: "Script Python",
    	python_scripts: "Scripts Python",
    	repositories: "Dépôts",
    	settings: "paramètres",
    	theme: "Thème",
    	themes: "Thèmes",
    	version: "Version"
    };
    var config$5 = {
    	abort: {
    		single_instance_allowed: "Une seule configuration de HACS est autorisée."
    	},
    	error: {
    		auth: "Le jeton personnel d'accès est invalide."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Activer la découverte et le suivi des applications AppDaemon",
    				python_script: "Activer la découverte et le suivi des scripts python",
    				sidepanel_icon: "Icône de la barre latérale",
    				sidepanel_title: "Titre de la barre latérale",
    				theme: "Activer la découverte et le suivi des thèmes",
    				token: "Jeton d'accès personnel GitHub"
    			},
    			description: "Si vous avez besoin d'aide pour la configuration, jetez un œil ici: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$5 = {
    	add_to_lovelace: "Êtes-vous sûr de vouloir l'ajouter à vos ressources Lovelace ?",
    	bg_task: "L'action est désactivée pendant l'exécution de tâches en arrière-plan.",
    	cancel: "Annuler",
    	"continue": "Es-tu sur de vouloir continuer?",
    	"delete": "Êtes-vous sûr de vouloir supprimer \"{item}\"?",
    	delete_installed: "'{item}' est installé, vous devez le désinstaller avant de pouvoir le supprimer.",
    	exist: "{item} existe déjà",
    	generic: "Êtes-vous sûr?",
    	home_assistant_is_restarting: "Attendez, Home Assistant redémarre maintenant.",
    	no: "Non",
    	no_upgrades: "Aucune mise à niveau en attente",
    	ok: "OK",
    	overwrite: "En faisant cela, cela l'écrasera.",
    	reload_data: "Cela recharge les données de tous les dépôts dont HACS a connaissance, cela prendra un certain temps à terminer.",
    	restart_home_assistant: "Voulez-vous vraiment redémarrer Home Assistant ?",
    	uninstall: "Êtes-vous sûr de vouloir désinstaller \"{item}\"?",
    	upgrade_all: "Cela mettra à niveau tous ces dépôts, assurez-vous d'avoir lu les notes de publication pour chacun d'entre eux avant de continuer.",
    	yes: "Oui"
    };
    var options$5 = {
    	step: {
    		user: {
    			data: {
    				country: "Filtrer par code pays.",
    				debug: "Activez le débogage.",
    				experimental: "Activer les fonctionnalités expérimentales",
    				release_limit: "Nombre de recensés à afficher."
    			}
    		}
    	}
    };
    var repository_banner$4 = {
    	config_flow: "Cette intégration prend en charge config_flow, ce qui signifie que vous pouvez maintenant accéder à la section d'intégration de votre interface utilisateur pour le configurer.",
    	integration_not_loaded: "Cette intégration n'est pas chargée dans Home Assistant.",
    	no_restart_required: "Aucun redémarrage requis",
    	not_loaded: "Non chargé",
    	plugin_not_loaded: "Ce plugin n'est pas ajouté à vos ressources Lovelace.",
    	restart: "Vous devez redémarrer Home Assistant.",
    	restart_pending: "Redémarrage en attente"
    };
    var repository$5 = {
    	add_to_lovelace: "Ajouter à Lovelace",
    	authors: "Auteurs",
    	available: "Disponible",
    	back_to: "Retour",
    	changelog: "Change log",
    	downloads: "Téléchargements",
    	flag_this: "Marquer",
    	frontend_version: "Version de l'interface",
    	github_stars: "Étoiles GitHub",
    	goto_integrations: "Aller aux intégrations",
    	hide: "Masquer",
    	hide_beta: "Masquer les bêta",
    	install: "Installer",
    	installed: "Installé",
    	lovelace_copy_example: "Copier cet exemple dans le presse-papier",
    	lovelace_instruction: "Quand vous l'ajoutez à votre configuration lovelace, utilisez",
    	lovelace_no_js_type: "Impossible de déterminer le type de plugin, veuillez vérifier le dépôt",
    	newest: "nouveau",
    	note_appdaemon: "vous devez toujours l'ajouter à votre fichier 'apps.yaml'",
    	note_installed: "Une fois installé, il se trouvera dans",
    	note_integration: "Vous devez toujours l'ajouter à votre fichier 'configuration.yaml'",
    	note_plugin: "Vous devez toujours l'ajouter à votre configuration lovelace ('ui-lovelace.yaml' ou l'éditeur de configuration de l'interface)",
    	open_issue: "Ouvrir un ticket",
    	open_plugin: "Ouvrir le plugin",
    	reinstall: "Réinstaller",
    	repository: "Dépôt",
    	restart_home_assistant: "Redémarrer Home Assistant",
    	show_beta: "Afficher les bêta",
    	uninstall: "Désinstaller",
    	update_information: "Mettre à jour les informations",
    	upgrade: "Mettre à jour"
    };
    var settings$5 = {
    	add_custom_repository: "AJOUTER UN DÉPÔT PERSONNALISÉ",
    	adding_new_repo: "Ajout d'un nouveau dépôt '{repo}'",
    	adding_new_repo_category: "Avec la catégorie '{category}'.",
    	bg_task_custom: "Les dépôts personnalisés sont masqués pendant l'exécution de tâches en arrière-plan.",
    	category: "Catégorie",
    	compact_mode: "Mode compact",
    	custom_repositories: "DÉPÔTS PERSONNALISÉS",
    	"delete": "Supprimer",
    	display: "Affichage",
    	grid: "Grille",
    	hacs_repo: "Dépôt HACS",
    	hidden_repositories: "dépôts cachés",
    	missing_category: "Vous devez sélectionner une catégorie",
    	open_repository: "Ouvrir dépôt",
    	reload_data: "Recharger les données",
    	reload_window: "Recharger la fenêtre",
    	repository_configuration: "Configuration de dépôt",
    	save: "Enregistrer",
    	table: "Tableau",
    	table_view: "Vue table",
    	unhide: "Afficher",
    	upgrade_all: "Tout mettre à jour"
    };
    var store$5 = {
    	ascending: "ascendant",
    	clear_new: "Effacer tous les nouveaux dépôts",
    	descending: "descendant",
    	last_updated: "Dernière mise à jour",
    	name: "Nom",
    	new_repositories: "Nouveaux dépôts",
    	pending_upgrades: "Mises à niveau en attente",
    	placeholder_search: "Veuillez entrer un terme de recherche...",
    	sort: "Trier",
    	stars: "Étoiles",
    	status: "Statut"
    };
    var time$5 = {
    	ago: "il y a",
    	day: "jour",
    	days: "jours",
    	hour: "heure",
    	hours: "heures",
    	minute: "minute",
    	minutes: "minutes",
    	month: "mois",
    	months: "mois",
    	one: "Un",
    	one_day_ago: "il y a 1 jour",
    	one_hour_ago: "il y a 1 heure",
    	one_minute_ago: "il y a 1 minute",
    	one_month_ago: "il y a 1 mois",
    	one_second_ago: "il y a 1 seconde",
    	one_year_ago: "il y a 1 an",
    	second: "seconde",
    	seconds: "secondes",
    	x_days_ago: "il y a {x} jours",
    	x_hours_ago: "il y a {x} heures",
    	x_minutes_ago: "il y a {x} minutes",
    	x_months_ago: "il y a {x} mois",
    	x_seconds_ago: "il y a {x} secondes",
    	x_years_ago: "il y a {x} ans",
    	year: "an",
    	years: "ans"
    };
    var fr = {
    	common: common$5,
    	config: config$5,
    	confirm: confirm$5,
    	options: options$5,
    	repository_banner: repository_banner$4,
    	repository: repository$5,
    	settings: settings$5,
    	store: store$5,
    	time: time$5
    };

    var fr$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$5,
        config: config$5,
        confirm: confirm$5,
        options: options$5,
        repository_banner: repository_banner$4,
        repository: repository$5,
        settings: settings$5,
        store: store$5,
        time: time$5,
        'default': fr
    });

    var common$6 = {
    	about: "Névjegy",
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "AppDaemon Appok",
    	background_task: "Éppen háttérfeladat fut, ez az oldal frissülni fog, ha kész.",
    	check_log_file: "További részletekért ellenőrizd a naplófájlt.",
    	"continue": "Folytatás",
    	disabled: "Tiltva",
    	documentation: "Dokumentáció",
    	hacs_is_disabled: "A HACS le van tiltva",
    	installed: "Telepített",
    	integration: "Integráció",
    	integrations: "Integrációk",
    	manage: "kezelés",
    	plugin: "Bővítmény",
    	plugins: "Bővítmények",
    	python_script: "Python Szkript",
    	python_scripts: "Python Szkriptek",
    	repositories: "Tárolók",
    	settings: "beállítások",
    	theme: "Téma",
    	themes: "Témák",
    	version: "Verzió"
    };
    var config$6 = {
    	abort: {
    		single_instance_allowed: "Csak egyetlen HACS-konfiguráció megengedett."
    	},
    	error: {
    		auth: "A Személyes Hozzáférési Token nem megfelelő."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "AppDaemon appok felfedezésének és nyomon követésének engedélyezése",
    				python_script: "Python szkriptek felfedezésének és nyomon követésének engedélyezése",
    				sidepanel_icon: "Oldalsó panel ikon",
    				sidepanel_title: "Oldalsó panel cím",
    				theme: "Témák felfedezésének és nyomon követésének engedélyezése",
    				token: "GitHub Személyes Hozzáférési Token"
    			},
    			description: "Ha segítségre van szükséged a konfigurációval kapcsolatban, akkor tekintsd meg ezt az oldalt: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$6 = {
    	add_to_lovelace: "Biztosan hozzá szeretnéd ezt adni a Lovelace erőforrásokhoz?",
    	bg_task: "A művelet le van tiltva, amíg háttérfeladat fut.",
    	cancel: "Mégse",
    	"continue": "Biztosan folytatni szeretnéd?",
    	"delete": "Biztosan törölni szeretnéd a(z) '{item}'-t?",
    	delete_installed: "A(z) '{item}' telepítve van, törlés előtt el kell távolítanod.",
    	exist: "{item} már létezik",
    	generic: "Biztos vagy benne?",
    	home_assistant_is_restarting: "Várj, a Home Assistant éppen újraindul.",
    	no: "Nem",
    	no_upgrades: "Nincs függőben lévő frissítés",
    	ok: "OK",
    	overwrite: "Ezzel felül fogod írni.",
    	reload_data: "Ez újratölti a HACS által ismert összes tároló adatát, ami némi időbe telhet.",
    	restart_home_assistant: "Biztosan újraindítod a Home Assistant programot?",
    	uninstall: "Biztosan el szeretnéd távolítani a(z) '{item}'-t?",
    	upgrade_all: "Ez frissíteni fogja az összes tárolót. Győzödj meg róla, hogy elolvastad az összes kiadási megjegyzést, mielőtt továbblépnél.",
    	yes: "Igen"
    };
    var options$6 = {
    	step: {
    		user: {
    			data: {
    				country: "Szűrés országkóddal.",
    				debug: "Hibakeresés engedélyezése.",
    				experimental: "Kísérleti funkciók engedélyezése",
    				release_limit: "Megjelenítendő kiadások száma."
    			}
    		}
    	}
    };
    var repository_banner$5 = {
    	config_flow: "Ez az integráció támogatja a config_flow-t, vagyis a felhasználó felületen az integrációk menüben lehet konfigurálni.",
    	integration_not_loaded: "Ez az integráció nincs betöltve a Home Assistantban.",
    	no_restart_required: "Nincs szükség újraindításra",
    	not_loaded: "Nincs betöltve",
    	plugin_not_loaded: "Ez a bővítmény nincs hozzáadva a Lovelace erőforrásokhoz.",
    	restart: "Indítsd újra a Home Assistant programot.",
    	restart_pending: "Újraindítás függőben"
    };
    var repository$6 = {
    	add_to_lovelace: "Hozzáadás a Lovelace-hez",
    	authors: "Szerzők",
    	available: "Elérhető",
    	back_to: "Vissza -",
    	changelog: "Változási napló",
    	downloads: "Letöltések",
    	flag_this: "Megjelölés",
    	frontend_version: "Frontend verzió",
    	github_stars: "GitHub csillagok",
    	goto_integrations: "Ugrás az integrációkhoz",
    	hide: "Elrejtés",
    	hide_beta: "Béta elrejtése",
    	install: "Telepítés",
    	installed: "Telepített",
    	lovelace_copy_example: "Példa másolása a vágólapra",
    	lovelace_instruction: "Amikor hozzáadod ezt a lovelace konfigurációdhoz, használd ezt",
    	lovelace_no_js_type: "Nem sikerült meghatározni a beépülő modul típusát, ellenőrizd a tárolót.",
    	newest: "legújabb",
    	note_appdaemon: "de még hozzá kell adnod az 'apps.yaml' fájlhoz",
    	note_installed: "Telepítéskor a következő helyre kerül:",
    	note_integration: "de még hozzá kell adnod a 'configuration.yaml' fájlhoz",
    	note_plugin: "de még hozzá kell adnod a lovelace konfigurációhoz (az 'ui-lovelace.yaml' fájlban vagy a Lovelace felületen a konfiguráció szerkesztőben)",
    	open_issue: "Probléma jelentése",
    	open_plugin: "Bővítmény megnyitása",
    	reinstall: "Újratelepítés",
    	repository: "Tároló",
    	restart_home_assistant: "Home Assistant újraindítása",
    	show_beta: "Béta megjelenítése",
    	uninstall: "Eltávolítás",
    	update_information: "Frissítési információk",
    	upgrade: "Frissítés"
    };
    var settings$6 = {
    	add_custom_repository: "EGYÉNI TÁROLÓ HOZZÁADÁSA",
    	adding_new_repo: "Új tároló hozzáadása '{repo}'",
    	adding_new_repo_category: "A '{category}' kategóriával.",
    	bg_task_custom: "Az egyéni tárolók rejtve vannak, amíg háttérfeladat fut.",
    	category: "Kategória",
    	compact_mode: "Kompakt mód",
    	custom_repositories: "EGYÉNI TÁROLÓK",
    	"delete": "Törlés",
    	display: "Megjelenítés",
    	grid: "Rács",
    	hacs_repo: "HACS tároló",
    	hidden_repositories: "rejtett tárolók",
    	missing_category: "Ki kell választanod egy kategóriát",
    	open_repository: "Tároló megnyitása",
    	reload_data: "Adatok újratöltése",
    	reload_window: "Ablak újratöltése",
    	repository_configuration: "Tároló konfiguráció",
    	save: "Mentés",
    	table: "Táblázat",
    	table_view: "Táblázat nézet",
    	unhide: "felfedés",
    	upgrade_all: "Minden frissítése"
    };
    var store$6 = {
    	ascending: "növekvő",
    	clear_new: "Új tárolók megjelölése látottként",
    	descending: "csökkenő",
    	last_updated: "Utolsó frissítés",
    	name: "Név",
    	new_repositories: "Új tárolók",
    	pending_upgrades: "Függőben lévő frissítések",
    	placeholder_search: "Kérlek adj meg egy keresési kifejezést...",
    	sort: "rendezés",
    	stars: "Csillag",
    	status: "Állapot"
    };
    var time$6 = {
    	ago: "ezelőtt",
    	day: "nap",
    	days: "nap",
    	hour: "óra",
    	hours: "óra",
    	minute: "perc",
    	minutes: "perc",
    	month: "hónap",
    	months: "hónap",
    	one: "Egy",
    	one_day_ago: "egy nappal ezelőtt",
    	one_hour_ago: "egy órával ezelőtt",
    	one_minute_ago: "egy perccel ezelőtt",
    	one_month_ago: "egy hónappal ezelőtt",
    	one_second_ago: "egy másodperccel ezelőtt",
    	one_year_ago: "egy évvel ezelőtt",
    	second: "másodperc",
    	seconds: "másodperc",
    	x_days_ago: "{x} nappal ezelőtt",
    	x_hours_ago: "{x} órával ezelőtt",
    	x_minutes_ago: "{x} perccel ezelőtt",
    	x_months_ago: "{x} hónappal ezelőtt",
    	x_seconds_ago: "{x} másodperccel ezelőtt",
    	x_years_ago: "{x} évvel ezelőtt",
    	year: "év",
    	years: "év"
    };
    var hu = {
    	common: common$6,
    	config: config$6,
    	confirm: confirm$6,
    	options: options$6,
    	repository_banner: repository_banner$5,
    	repository: repository$6,
    	settings: settings$6,
    	store: store$6,
    	time: time$6
    };

    var hu$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$6,
        config: config$6,
        confirm: confirm$6,
        options: options$6,
        repository_banner: repository_banner$5,
        repository: repository$6,
        settings: settings$6,
        store: store$6,
        time: time$6,
        'default': hu
    });

    var common$7 = {
    	about: "Informazioni su",
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "Applicazioni AppDaemon",
    	background_task: "Attività in esecuzione, questa pagina sarà ricaricata al termine.",
    	check_log_file: "Controlla il tuo file di registro per maggiori dettagli.",
    	"continue": "Continua",
    	disabled: "Disabilitato",
    	documentation: "Documentazione",
    	hacs_is_disabled: "HACS è disabilitato",
    	installed: "Installati",
    	integration: "Integrazione",
    	integrations: "Integrazioni",
    	manage: "gestione",
    	plugin: "Plugin",
    	plugins: "Plugin",
    	python_script: "Script python",
    	python_scripts: "Script python",
    	repositories: "Repository",
    	settings: "Impostazioni",
    	theme: "Tema",
    	themes: "Temi",
    	version: "Versione"
    };
    var config$7 = {
    	abort: {
    		single_instance_allowed: "È consentita una sola configurazione di HACS."
    	},
    	error: {
    		auth: "Il token di accesso personale non è corretto."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Abilita il rilevamento e il monitoraggio delle applicazioni AppDaemon",
    				python_script: "Abilita il rilevamento e il monitoraggio dei python_scripts",
    				sidepanel_icon: "Icona nel pannello laterale",
    				sidepanel_title: "Titolo nel pannello laterale",
    				theme: "Abilita individuazione e tracciamento dei temi",
    				token: "Token di accesso personale GitHub"
    			},
    			description: "Se hai bisogno di aiuto con la configurazione dai un'occhiata qui: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$7 = {
    	add_to_lovelace: "Sei sicuro di voler aggiungerlo alle tue risorse Lovelace?",
    	bg_task: "L'azione è disabilitata mentre sono in esecuzione attività in background.",
    	cancel: "Annulla",
    	"continue": "Sei sicuro di voler continuare?",
    	"delete": "Sei sicuro di voler disinstallare '{item}'?",
    	delete_installed: "'{item}' è installato, è necessario disinstallarlo prima di poterlo eliminare.",
    	exist: "'{item}' esiste già",
    	generic: "Sei sicuro?",
    	home_assistant_is_restarting: "Aspetta, Home Assistant si sta riavviando.",
    	no: "No",
    	no_upgrades: "Nessun aggiornamento in sospeso",
    	ok: "OK",
    	overwrite: "In questo modo lo sovrascriverà.",
    	reload_data: "Questo ricarica i dati di tutte le repository di cui HACS è a conoscenza, ci vorrà del tempo per finire.",
    	restart_home_assistant: "Sei sicuro di voler riavviare Home Assistant?",
    	uninstall: "Sei sicuro di voler disinstallare '{item}'?",
    	upgrade_all: "Questa azione aggiornerà tutti i repository, assicurati di aver letto le note di rilascio prima di procedere.",
    	yes: "Sì"
    };
    var options$7 = {
    	step: {
    		user: {
    			data: {
    				country: "Filtra con prefisso internazionale.",
    				debug: "Abilita debug.",
    				experimental: "Abilita funzionalità sperimentali",
    				release_limit: "Numero di versioni da mostrare."
    			}
    		}
    	}
    };
    var repository_banner$6 = {
    	integration_not_loaded: "Questa integrazione non è caricata in Home Assistant.",
    	not_loaded: "Non caricato",
    	plugin_not_loaded: "Questo plugin non è stato aggiunto alle risorse di Lovelace.",
    	restart: "È necessario riavviare Home Assistant.",
    	restart_pending: "Riavvio in attesa"
    };
    var repository$7 = {
    	add_to_lovelace: "Aggiungi a Lovelace",
    	authors: "Autori",
    	available: "Disponibile",
    	back_to: "Torna a",
    	changelog: "Change log",
    	downloads: "Downloads",
    	flag_this: "Spunta questo",
    	frontend_version: "Frontend versione",
    	github_stars: "GitHub stelle",
    	hide: "Nascondi",
    	hide_beta: "Nascondi beta",
    	install: "Installa",
    	installed: "Installato",
    	lovelace_copy_example: "Copia l'esempio negli appunti",
    	lovelace_instruction: "Quando lo aggiungi nella configurazione di lovelace, usa questo",
    	lovelace_no_js_type: "Impossibile determinare il tipo di plugin, verificare il repository.",
    	newest: "Più recente",
    	note_appdaemon: "dovrai aggiungerlo nel file 'apps.yaml'",
    	note_installed: "Una volta installato, si troverà in",
    	note_integration: "dovrai aggiungerlo nel file 'configuration.yaml'",
    	note_plugin: "devi aggiungere la configurazione nel file 'ui-lovelace.yaml' oppure via Editor RAW della UI.",
    	open_issue: "Segnala anomalia",
    	open_plugin: "Apri plugin",
    	reinstall: "Reinstalla",
    	repository: "Archivio Software (Repository)",
    	restart_home_assistant: "Riavvia Home Assistant",
    	show_beta: "Visualizza beta",
    	uninstall: "Rimuovi",
    	update_information: "Aggiorna informazioni",
    	upgrade: "Aggiorna"
    };
    var settings$7 = {
    	add_custom_repository: "AGGIUNGI REPOSITORY PERSONALIZZATA",
    	adding_new_repo: "Aggiunta di un nuovo repository '{repo}'",
    	adding_new_repo_category: "Con la categoria '{category}'.",
    	bg_task_custom: "I repository personalizzati sono nascosti mentre sono in esecuzione attività in background.",
    	category: "Categoria",
    	compact_mode: "Modalità compatta",
    	custom_repositories: "REPOSITORY PERSONALIZZATE",
    	"delete": "Cancella",
    	display: "Visualizza",
    	grid: "Griglia",
    	hacs_repo: "HACS repo",
    	hidden_repositories: "repository nascosti",
    	missing_category: "Devi selezionare una categoria",
    	open_repository: "Apri il repository",
    	reload_data: "Ricarica i dati",
    	repository_configuration: "Configurazione del repository",
    	save: "Salva",
    	table: "Tabella",
    	table_view: "Vista tabella",
    	unhide: "Mostra",
    	upgrade_all: "Aggiorna tutto"
    };
    var store$7 = {
    	ascending: "ascendente",
    	clear_new: "Ripulisci i nuovi repository",
    	descending: "discendente",
    	last_updated: "Ultimo aggiornamento",
    	name: "Nome",
    	new_repositories: "Nuovi repository",
    	pending_upgrades: "Aggiornamenti in sospeso",
    	placeholder_search: "Inserire un termine di ricerca",
    	sort: "Ordinare",
    	stars: "Stelle",
    	status: "Stato"
    };
    var time$7 = {
    	ago: "fa",
    	day: "giorno",
    	days: "giorni",
    	hour: "ora",
    	hours: "ore",
    	minute: "minuto",
    	minutes: "minuti",
    	month: "mese",
    	months: "mesi",
    	one: "Un",
    	one_day_ago: "un giorno fa",
    	one_hour_ago: "un'ora fa",
    	one_minute_ago: "un minuto fa",
    	one_month_ago: "un mese fa",
    	one_second_ago: "un secondo fa",
    	one_year_ago: "un anno fa",
    	second: "secondo",
    	seconds: "secondi",
    	x_days_ago: "{x} giorni fa",
    	x_hours_ago: "{x} ore fa",
    	x_minutes_ago: "{x} minuti fa",
    	x_months_ago: "{x} mesi fa",
    	x_seconds_ago: "{x} secondi fa",
    	x_years_ago: "{x} anni fa",
    	year: "anno",
    	years: "anni"
    };
    var it = {
    	common: common$7,
    	config: config$7,
    	confirm: confirm$7,
    	options: options$7,
    	repository_banner: repository_banner$6,
    	repository: repository$7,
    	settings: settings$7,
    	store: store$7,
    	time: time$7
    };

    var it$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$7,
        config: config$7,
        confirm: confirm$7,
        options: options$7,
        repository_banner: repository_banner$6,
        repository: repository$7,
        settings: settings$7,
        store: store$7,
        time: time$7,
        'default': it
    });

    var common$8 = {
    	about: "Om",
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "AppDaemon Apper",
    	background_task: "Bakgrunnsoppgaven kjører. Denne siden lastes inn på nytt når den er ferdig.",
    	check_log_file: "Sjekk loggfilen din for mer informasjon.",
    	"continue": "Fortsett",
    	disabled: "Deaktivert",
    	documentation: "dokumentasjon",
    	hacs_is_disabled: "HACS er deaktivert",
    	installed: "Installert",
    	integration: "Integrasjon",
    	integrations: "Integrasjoner",
    	manage: "manage",
    	plugin: "Plugin",
    	plugins: "Plugins",
    	python_script: "Python-skript",
    	python_scripts: "Python-skript",
    	repositories: "Repositories",
    	settings: "Innstillinger",
    	theme: "Tema",
    	themes: "Temaer",
    	version: "Versjon"
    };
    var config$8 = {
    	abort: {
    		single_instance_allowed: "Bare en konfigurasjon av HACS er tillatt."
    	},
    	error: {
    		auth: "Personlig tilgangstoken er ikke korrekt."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Aktiver oppdagelse og sporing av AppDaemon-apper",
    				python_script: "Aktiver oppdagelse og sporing av python_scripts",
    				sidepanel_icon: "Sidepanel ikon",
    				sidepanel_title: "Sidepanel tittel",
    				theme: "Aktiver oppdagelse og sporing av temaer",
    				token: "GitHub Personal Access Token"
    			},
    			description: "Hvis du trenger hjelp med konfigurasjonen, ta en titt her: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$8 = {
    	add_to_lovelace: "Er du sikker på at du vil legge dette til i dine Lovelace resources?",
    	bg_task: "Handlingen er deaktivert mens bakgrunnsoppgaver kjører.",
    	cancel: "Avbryt",
    	"continue": "Er du sikker på at du vil fortsette?",
    	"delete": "Er du sikker på at du vil fjerne \"{item}\"?",
    	delete_installed: "'{item}' er installert, du må avinstallere det før du kan slette det.",
    	exist: "{item} eksisterer allerede",
    	generic: "Er du sikker?",
    	home_assistant_is_restarting: "Vent, Home Assistant starter nå på nytt.",
    	no: "Nei",
    	no_upgrades: "Ingen oppgraderinger tilgjengelig",
    	ok: "OK",
    	overwrite: "Å gjøre dette vil overskrive det.",
    	reload_data: "Dette laster inn dataene til alle repositories HACS vet om, dette vil ta litt tid å fullføre.",
    	restart_home_assistant: "Er du sikker på at du vil starte Home Assistant på nytt?",
    	uninstall: "Er du sikker på at du vil avinstallere \"{item}\"?",
    	upgrade_all: "Dette vil oppgradere alle disse repositorene, sørg for at du har lest utgivelses notatene for dem alle før du fortsetter.",
    	yes: "Ja"
    };
    var options$8 = {
    	step: {
    		user: {
    			data: {
    				country: "Filtrer med landskode.",
    				debug: "Aktiver debug",
    				experimental: "Aktiver eksperimentelle funksjoner",
    				release_limit: "Antall utgivelser som skal vises."
    			}
    		}
    	}
    };
    var repository_banner$7 = {
    	config_flow: "Denne integrasjonen støtter config_flow, det betyr at du nå kan gå til integrasjoner i brukergrensesnittet for å konfigurere den.",
    	integration_not_loaded: "Integrasjonen er ikke lastet inn i Home Assistant.",
    	no_restart_required: "Ingen omstart kreves",
    	not_loaded: "Ikke lastet inn",
    	plugin_not_loaded: "Denne pluginen er ikke lagt til i lovelace under \"resource\" delen av konfigurasjonen.",
    	restart: "Du må restart Home Assistant",
    	restart_pending: "Restart er nødvendig"
    };
    var repository$8 = {
    	add_to_lovelace: "Legg til i Lovelace",
    	authors: "Laget av",
    	available: "Tilgjengelig",
    	back_to: "Tilbake til",
    	changelog: "Endringslogg",
    	downloads: "Nedlastinger",
    	flag_this: "Flag dette",
    	frontend_version: "Frontend versjon",
    	github_stars: "GitHub-stjerner",
    	goto_integrations: "Gå til integrasjoner",
    	hide: "Skjul",
    	hide_beta: "Skjul beta",
    	installed: "Installert",
    	lovelace_copy_example: "Kopier eksemplet til utklippstavlen",
    	lovelace_instruction: "Når du legger til dette i lovelace-konfigurasjonen din, bruk dette",
    	lovelace_no_js_type: "Kunne ikke bestemme typen for denne plugin, sjekk repository.",
    	newest: "Nyeste",
    	note_appdaemon: "du må fortsatt legge den til i 'apps.yaml' filen",
    	note_installed: "Når det er installert, vil dette ligge i",
    	note_integration: "du må fortsatt legge den til 'configuration.yaml' filen",
    	note_plugin: "du må fortsatt legge den til i lovelace-konfigurasjonen ('ui-lovelace.yaml' eller den rå UI-konfigurasjonsredigereren)",
    	open_issue: "Meld et problem",
    	open_plugin: "Åpne plugin",
    	reinstall: "Installer på nytt",
    	repository: "Repository",
    	restart_home_assistant: "Start Home Assistant på nytt",
    	show_beta: "Vis beta",
    	uninstall: "Avinstaller",
    	update_information: "Oppdater informasjon",
    	upgrade: "Oppdater"
    };
    var settings$8 = {
    	add_custom_repository: "LEGG TIL REPOSITORY",
    	adding_new_repo: "Legger til ny repository '{repo}'",
    	adding_new_repo_category: "Med kategori '{category}'.",
    	bg_task_custom: "Custom repositories er skjult mens bakgrunnsoppgaver kjører.",
    	category: "Kategori",
    	compact_mode: "Kompakt modus",
    	custom_repositories: "TILPASSEDE REPOSITORIER",
    	"delete": "Slett",
    	display: "Vise",
    	grid: "Nett",
    	hacs_repo: "HACS repo",
    	hidden_repositories: "Gjemte repositories",
    	missing_category: "Du må velge en kategori",
    	open_repository: "Åpne repository",
    	reload_data: "Last inn data på nytt",
    	reload_window: "Last inn vinduet på nytt",
    	repository_configuration: "Repository konfigurasjon",
    	save: "Lagre",
    	table: "Tabell",
    	table_view: "Tabellvisning",
    	unhide: "Vis igjen",
    	upgrade_all: "Oppgradere alle"
    };
    var store$8 = {
    	ascending: "stigende",
    	clear_new: "Tøm nye repositories",
    	descending: "synkende",
    	last_updated: "Sist oppdatert",
    	name: "Navn",
    	new_repositories: "Nye repositories",
    	pending_upgrades: "Venter på oppgradering",
    	placeholder_search: "Skriv inn et søkeord ...",
    	sort: "sorter",
    	stars: "Stjerner",
    	status: "Status"
    };
    var time$8 = {
    	ago: "siden",
    	day: "dag",
    	days: "dager",
    	hour: "time",
    	hours: "timer",
    	minute: "minutt",
    	minutes: "minutter",
    	month: "måned",
    	months: "måneder",
    	one: "En",
    	one_day_ago: "for en dag siden",
    	one_hour_ago: "en time siden",
    	one_minute_ago: "ett minutt siden",
    	one_month_ago: "en måned siden",
    	one_second_ago: "ett sekund siden",
    	one_year_ago: "ett år siden",
    	second: "sekund",
    	seconds: "sekunder",
    	x_days_ago: "{x} dager siden",
    	x_hours_ago: "{x} timer siden",
    	x_minutes_ago: "{x} minutter siden",
    	x_months_ago: "{x} måneder siden",
    	x_seconds_ago: "{x} sekunder siden",
    	x_years_ago: "{x} år siden",
    	year: "år",
    	years: "år"
    };
    var nb = {
    	common: common$8,
    	config: config$8,
    	confirm: confirm$8,
    	options: options$8,
    	repository_banner: repository_banner$7,
    	repository: repository$8,
    	settings: settings$8,
    	store: store$8,
    	time: time$8
    };

    var nb$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$8,
        config: config$8,
        confirm: confirm$8,
        options: options$8,
        repository_banner: repository_banner$7,
        repository: repository$8,
        settings: settings$8,
        store: store$8,
        time: time$8,
        'default': nb
    });

    var common$9 = {
    	about: "Over",
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "AppDaemon Apps",
    	background_task: "Achtergrond taak is draaiende, de pagina herhaalt zichzelf wanneer dit klaar is.",
    	check_log_file: "Controleer het logbestand voor meer details.",
    	disabled: "Uitgeschakeld",
    	documentation: "Documentatie",
    	hacs_is_disabled: "HACS is uitgeschakeld",
    	installed: "geinstalleerd",
    	integration: "Integratie",
    	integrations: "Integraties",
    	manage: "beheer",
    	plugin: "Plugin",
    	plugins: "Plugins",
    	python_script: "Python Script",
    	python_scripts: "Python Scripts",
    	repositories: "Repositories",
    	settings: "instellingen",
    	theme: "Thema",
    	themes: "Themas",
    	version: "Versie"
    };
    var config$9 = {
    	abort: {
    		single_instance_allowed: "Je kunt maar een enkele configuratie van HACS tegelijk hebben."
    	},
    	error: {
    		auth: "Persoonlijke Toegang Token is niet correct."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Zet AppDaemon apps ontdekken & traceren aan",
    				python_script: "Zet python_scripts ontdekken & traceren aan",
    				sidepanel_icon: "Zijpaneel icoon",
    				sidepanel_title: "Zijpaneel titel",
    				theme: "Zet Themes ontdekken & traceren aan",
    				token: "GitHub Persoonlijke Toegang Token"
    			},
    			description: "Als je hulp nodig hebt met de configuratie, kun je hier verder kijken: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$9 = {
    	add_to_lovelace: "Weet u zeker dat u dit wilt toevoegen aan uw Lovelace bronnen?",
    	bg_task: "Actie is geblokkeerd terwijl achtergrondtaken actief zijn.",
    	cancel: "Annuleer",
    	"continue": "Weet je zeker dat je wilt doorgaan?",
    	"delete": "Weet u zeker dat u \"{item}\" wilt verwijderen?",
    	delete_installed: "'{item}' is geïnstalleerd, je dient het eerst te deïnstalleren voordat je het kan verwijderen.",
    	exist: "{item} bestaat al.",
    	generic: "Weet je het zeker?",
    	no: "Nee",
    	no_upgrades: "Geen upgrades in afwachting.",
    	ok: "Oké",
    	overwrite: "Door dit te doen, wordt het overschreven.",
    	reload_data: "Dit zal alle bekende data herladen van alle repositories van HACS. Dit kan even duren",
    	uninstall: "Weet u zeker dat u \"{item}\" wilt verwijderen?",
    	upgrade_all: "Hiermee worden al deze repositories geüpgraded. Zorg ervoor dat u de release-opmerkingen van allen heeft gelezen voordat u doorgaat.",
    	yes: "Ja"
    };
    var options$9 = {
    	step: {
    		user: {
    			data: {
    				country: "Filter met land code.",
    				debug: "Schakel debug in.",
    				experimental: "Zet experimentele functies aan",
    				release_limit: "Aantal releases om te laten zien."
    			}
    		}
    	}
    };
    var repository_banner$8 = {
    	integration_not_loaded: "Deze integratie wordt niet geladen in Home Assistant.",
    	not_loaded: "Niet geladen",
    	plugin_not_loaded: "Deze plugin wordt niet toegevoegd aan je Lovelace resources.",
    	restart: "U moet Home Assistant opnieuw starten.",
    	restart_pending: "Wachten op herstart"
    };
    var repository$9 = {
    	add_to_lovelace: "Toevoegen aan Lovelace",
    	authors: "Auteurs",
    	available: "Beschikbaar",
    	back_to: "Terug naar",
    	changelog: "Changelog",
    	downloads: "Downloads",
    	flag_this: "Vlag dit",
    	hide: "Verberg",
    	hide_beta: "Verberg beta",
    	install: "Installeer",
    	installed: "Geinstalleerd",
    	lovelace_copy_example: "Kopier het voorbeeld naar je klembord",
    	lovelace_instruction: "Wanneer je dit gaat toevoegen aan je lovelace configuratie gebruik dit",
    	lovelace_no_js_type: "Kon niet achterhalen welk type plugin dit is, controleer de repository van de plugin.",
    	newest: "nieuwste",
    	note_appdaemon: "je moet het nog steeds toevoegen aan je 'apps.yaml' bestand",
    	note_installed: "Wanneer geïnstalleerd, staat het in",
    	note_integration: "je moet het nog steeds toevoegen aan je 'configuration.yaml' bestand",
    	note_plugin: "je moet het nog steeds toevoegen aan je lovelace configuratie ('ui-lovelace.yaml') of raw UI config editor.",
    	open_issue: "Meld probleem",
    	open_plugin: "Open plugin",
    	reinstall: "Herinstalleer",
    	repository: "Repository",
    	show_beta: "Laat beta zien",
    	uninstall: "Verwijder",
    	update_information: "Update informatie",
    	upgrade: "Update"
    };
    var settings$9 = {
    	add_custom_repository: "VOEG EIGEN REPOSITORY TOE",
    	adding_new_repo: "Nieuwe repository '{repo}' toevoegen",
    	adding_new_repo_category: "Met categorie '{category}'.",
    	bg_task_custom: "Aangepaste repositories zijn verborgen terwijl de achtergrondtaken actief zijn.",
    	category: "Categorie",
    	compact_mode: "Compacte modus",
    	custom_repositories: "EIGEN REPOSITORIES",
    	"delete": "Verwijder",
    	display: "Weergave",
    	grid: "Rooster",
    	hacs_repo: "HACS repo",
    	hidden_repositories: "verborgen repositories",
    	missing_category: "Je moet een categorie selecteren.",
    	open_repository: "Open repository",
    	reload_data: "Herlaad data",
    	repository_configuration: "Repository configuratie",
    	save: "Opslaan",
    	table: "Tabel",
    	table_view: "Tabelweergave",
    	unhide: "zichtbaar maken",
    	upgrade_all: "Upgrade alles"
    };
    var store$9 = {
    	ascending: "oplopend",
    	clear_new: "Wissen van alle nieuwe repositories",
    	descending: "Aflopend",
    	last_updated: "Laatste update",
    	name: "Naam",
    	new_repositories: "Nieuwe Repositories",
    	pending_upgrades: "Upgrades in afwachting",
    	placeholder_search: "Typ iets om te zoeken...",
    	sort: "sorteer",
    	stars: "Sterren",
    	status: "Status"
    };
    var time$9 = {
    	ago: "geleden",
    	day: "dag",
    	days: "dagen",
    	hour: "uur",
    	hours: "uren",
    	minute: "minuut",
    	minutes: "minuten",
    	month: "maand",
    	months: "maanden",
    	one: "Eén",
    	second: "seconde",
    	seconds: "seconden",
    	year: "jaar",
    	years: "jaren"
    };
    var nl = {
    	common: common$9,
    	config: config$9,
    	confirm: confirm$9,
    	options: options$9,
    	repository_banner: repository_banner$8,
    	repository: repository$9,
    	settings: settings$9,
    	store: store$9,
    	time: time$9
    };

    var nl$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$9,
        config: config$9,
        confirm: confirm$9,
        options: options$9,
        repository_banner: repository_banner$8,
        repository: repository$9,
        settings: settings$9,
        store: store$9,
        time: time$9,
        'default': nl
    });

    var common$a = {
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "AppDeamon-appar",
    	background_task: "Bakgrunnsoppgåve køyrer. Denne sida kjem til å laste seg omatt når ho er ferdig.",
    	installed: "Installert",
    	integration: "Integrasjon",
    	integrations: "Integrasjonar",
    	plugin: "Tillegg",
    	plugins: "Tillegg",
    	python_script: "Pythonskript",
    	python_scripts: "Pythonskript",
    	repositories: "Repositories",
    	settings: "innstillingar",
    	theme: "Tema",
    	themes: "Tema",
    	version: "Versjon"
    };
    var config$a = {
    	abort: {
    		single_instance_allowed: "Berre éin enkelt konfigurasjon av HACS er tillete."
    	},
    	error: {
    		auth: "Personleg tilgangsnøkkel er ikkje korrekt."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Aktiver AppDeamon-appar-oppdaging og sporing",
    				python_script: "Aktiver pythonscript-oppdaging og sporing",
    				sidepanel_icon: "Sidepanelikon",
    				sidepanel_title: "Sidepaneltittel",
    				theme: "Aktiver tema-oppdaging og sporing",
    				token: "Personleg GitHub tilgangsnøkkel"
    			},
    			description: "Dersom du treng hjelp med konfigurasjonen, ta ein kik her: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$a = {
    	add_to_lovelace: "Er du sikker på at du vil legge til dette i Lovelace-ressursane dine?",
    	"continue": "Er du sikker på at du vil halde fram?",
    	"delete": "Er du sikker på at du vil slette \"{item}\"?",
    	generic: "Er du sikker?",
    	overwrite: "Ved å gjere dette kjem du til å overskrive.",
    	uninstall: "Er du sikker på at du vil avinstallere \"{item}\"?"
    };
    var options$a = {
    	step: {
    		user: {
    			data: {
    				country: "Filterer med landskode",
    				experimental: "Aktiver ekspreimentelle funksjonar",
    				release_limit: "Talet på utgivingar"
    			}
    		}
    	}
    };
    var repository_banner$9 = {
    	integration_not_loaded: "Integrasjonen er ikkje lasta inn i Home Assistant.",
    	not_loaded: "Ikkje lasta",
    	plugin_not_loaded: "Tillegget er ikkje lagt til i Lovelace-ressursane dine.",
    	restart: "Du må starte Home Assistant på nytt",
    	restart_pending: "Omstart venter"
    };
    var repository$a = {
    	add_to_lovelace: "Legg til i Lovelace",
    	authors: "Forfatter(e)",
    	available: "Tilgjengeleg",
    	back_to: "Tilbake til",
    	changelog: "Endre logg",
    	flag_this: "Marker dette",
    	hide: "Gøym",
    	hide_beta: "Gøym beta",
    	install: "Installer",
    	installed: "Installert",
    	lovelace_copy_example: "Kopier eksempelet til utklippsbreittet ditt",
    	lovelace_instruction: "Når du legg til dette i Lovelace-konfigurasjonen din, bruk dette",
    	lovelace_no_js_type: "Kunne ikkje slå fast typen til dette tilegget. Sjå i repositoryet.",
    	newest: "nyaste",
    	note_appdaemon: "du må framleis legge dette til i \"apps.yaml\"-fila di",
    	note_installed: "Når dette er installert, kjem den til å vere plassert i",
    	note_integration: "du må framleis legge dette til i \"configuration.yaml\"-fila di",
    	note_plugin: "du må framleis dette til i Lovelace-konfigurasjonen (\"ui-lovelace.yaml\" eller i rå-brukargrensesnittredigeraren",
    	open_issue: "Opne problem",
    	open_plugin: "Opne tillegg",
    	reinstall: "Installer på nytt",
    	repository: "Repository",
    	show_beta: "Vis beta",
    	uninstall: "Avinstaller",
    	update_information: "Oppdater informasjonen",
    	upgrade: "Oppdater"
    };
    var settings$a = {
    	add_custom_repository: "LEGG TIL EIN ANNAN REPOSITORY",
    	category: "Kategori",
    	compact_mode: "Kompaktmodus",
    	custom_repositories: "VANLEG REPOSITORY",
    	"delete": "Slett",
    	display: "Vis",
    	grid: "rutenett",
    	hacs_repo: "HACS repo",
    	hidden_repositories: "gøymde repositories",
    	reload_data: "Last om dataa",
    	save: "Lagre",
    	table: "Tavle",
    	table_view: "Tabellvisning",
    	unhide: "vis",
    	upgrade_all: "Oppdater alle"
    };
    var store$a = {
    	clear_new: "Fjern alle nye repositories",
    	name: "Namn",
    	new_repositories: "Ny repository",
    	placeholder_search: "Ver vennleg og skriv inn ei søkefrase",
    	sort: "Sorter",
    	status: "Status"
    };
    var nn = {
    	common: common$a,
    	config: config$a,
    	confirm: confirm$a,
    	options: options$a,
    	repository_banner: repository_banner$9,
    	repository: repository$a,
    	settings: settings$a,
    	store: store$a
    };

    var nn$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$a,
        config: config$a,
        confirm: confirm$a,
        options: options$a,
        repository_banner: repository_banner$9,
        repository: repository$a,
        settings: settings$a,
        store: store$a,
        'default': nn
    });

    var common$b = {
    	about: "O",
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "Aplikacje AppDaemon",
    	background_task: "Wykonywanie zadania w tle, ta strona zostanie odświeżona, gdy zadanie zostanie ukończone.",
    	check_log_file: "Sprawdź plik dziennika, aby uzyskać więcej informacji.",
    	"continue": "Kontynuuj",
    	disabled: "Wyłączony",
    	documentation: "Dokumentacja",
    	hacs_is_disabled: "HACS jest wyłączony",
    	installed: "zainstalowane",
    	integration: "Integracja",
    	integrations: "Integracje",
    	manage: "zarządzaj",
    	plugin: "Wtyczka",
    	plugins: "Wtyczki",
    	python_script: "Skrypt Python",
    	python_scripts: "Skrypty Python",
    	repositories: "Repozytoria",
    	settings: "ustawienia",
    	theme: "Motyw",
    	themes: "Motywy",
    	version: "Wersja"
    };
    var config$b = {
    	abort: {
    		single_instance_allowed: "Dozwolona jest tylko jedna konfiguracja HACS."
    	},
    	error: {
    		auth: "Osobisty token dostępu jest nieprawidłowy."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Włącz wykrywanie i śledzenie aplikacji AppDaemon",
    				python_script: "Włącz wykrywanie i śledzenie skryptów Python",
    				sidepanel_icon: "Ikona w panelu bocznym",
    				sidepanel_title: "Tytuł w panelu bocznym",
    				theme: "Włącz wykrywanie i śledzenie motywów",
    				token: "Osobisty token dostępu GitHub"
    			},
    			description: "Jeśli potrzebujesz pomocy w konfiguracji, przejdź na stronę: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$b = {
    	add_to_lovelace: "Na pewno chcesz dodać to do swoich zasobów Lovelace?",
    	bg_task: "Akcja jest wyłączona podczas wykonywania zadań w tle.",
    	cancel: "Anuluj",
    	"continue": "Na pewno chcesz kontynuować?",
    	"delete": "Na pewno chcesz usunąć \"{item}\"?",
    	delete_installed: "'{item}' jest zainstalowany, musisz go odinstalować zanim będziesz mógł go usunąć.",
    	exist: "{item} już istnieje",
    	generic: "Jesteś pewny?",
    	home_assistant_is_restarting: "Poczekaj, Home Assistant jest teraz ponownie uruchamiany.",
    	no: "Nie",
    	no_upgrades: "Brak oczekujących aktualizacji",
    	ok: "Ok",
    	overwrite: "Spowoduje to zastąpienie istniejącej kopii.",
    	reload_data: "To przeładowuje dane wszystkich repozytoriów, o których wie HACS, może to trochę potrwać.",
    	restart_home_assistant: "Na pewno chcesz ponownie uruchomić Home Assistant'a?",
    	uninstall: "Na pewno chcesz odinstalować \"{item}\"?",
    	upgrade_all: "To uaktualni wszystkie te repozytoria, upewnij się, że przeczytałeś uwagi do wydania dla wszystkich z nich przed kontynuacją.",
    	yes: "Tak"
    };
    var options$b = {
    	step: {
    		user: {
    			data: {
    				country: "Filtruj według kodu kraju",
    				debug: "Włącz debugowanie.",
    				experimental: "Włącz funkcje eksperymentalne",
    				release_limit: "Liczba wydań do wyświetlenia"
    			}
    		}
    	}
    };
    var repository_banner$a = {
    	integration_not_loaded: "Ta integracja nie jest załadowana do Home Assistant'a.",
    	not_loaded: "Nie załadowano",
    	plugin_not_loaded: "Ta wtyczka nie jest dodana do zasobów Lovelace.",
    	restart: "Musisz ponownie uruchomić Home Assistant'a.",
    	restart_pending: "Oczekiwanie na ponowne uruchomienie"
    };
    var repository$b = {
    	add_to_lovelace: "Dodaj do Lovelace",
    	authors: "Autorzy",
    	available: "Dostępna",
    	back_to: "Wróć do",
    	changelog: "Lista zmian",
    	downloads: "Pliki do pobrania",
    	flag_this: "Oflaguj",
    	frontend_version: "Wersja frontendu",
    	github_stars: "Gwiazdki GitHub",
    	hide: "Ukryj",
    	hide_beta: "Ukryj wydania beta",
    	install: "Zainstaluj",
    	installed: "Zainstalowano",
    	lovelace_copy_example: "Skopiuj przykład do schowka",
    	lovelace_instruction: "Interfejs użytkownika użyje tej wtyczki po dodaniu konfiguracji",
    	lovelace_no_js_type: "Nie można określić typu tej wtyczki, sprawdź repozytorium.",
    	newest: "najnowsza",
    	note_appdaemon: "musisz jeszcze dodać aplikację do pliku 'apps.yaml'",
    	note_installed: "Po zainstalowaniu dodatek będzie znajdować się w",
    	note_integration: "musisz jeszcze dodać integrację do pliku 'configuration.yaml'",
    	note_plugin: "musisz jeszcze dodać wtyczkę do konfiguracji interfejsu użytkownika (plik 'ui-lovelace.yaml' lub edytor interfejsu użytkownika)",
    	open_issue: "Powiadom o problemie",
    	open_plugin: "Otwórz dodatek",
    	reinstall: "Przeinstaluj",
    	repository: "Repozytorium",
    	restart_home_assistant: "Uruchom ponownie Home Assistant'a",
    	show_beta: "Wyświetl wydania beta",
    	uninstall: "Odinstaluj",
    	update_information: "Informacje o aktualizacji",
    	upgrade: "Uaktualnij"
    };
    var settings$b = {
    	add_custom_repository: "DODAJ REPOZYTORIUM NIESTANDARDOWE",
    	adding_new_repo: "Dodawanie nowego repozytorium '{repo}'",
    	adding_new_repo_category: "Z kategorią '{category}'.",
    	bg_task_custom: "Niestandardowe repozytoria są ukryte podczas wykonywania zadań w tle.",
    	category: "Kategoria",
    	compact_mode: "Tryb kompaktowy",
    	custom_repositories: "REPOZYTORIA NIESTANDARDOWE",
    	"delete": "Usuń",
    	display: "Sposób wyświetlania",
    	grid: "Siatka",
    	hacs_repo: "Repozytorium HACS",
    	hidden_repositories: "ukryte repozytoria",
    	missing_category: "Musisz wybrać kategorię",
    	open_repository: "Otwórz repozytorium",
    	reload_data: "Wczytaj ponownie dane",
    	repository_configuration: "Konfiguracja repozytorium",
    	save: "Zapisz",
    	table: "tabela",
    	table_view: "Widok tabeli",
    	unhide: "pokaż",
    	upgrade_all: "Uaktualnij wszystkie"
    };
    var store$b = {
    	ascending: "rosnąco",
    	clear_new: "Wyczyść wszystkie nowe repozytoria",
    	descending: "malejąco",
    	last_updated: "Ostatnia aktualizacja",
    	name: "Nazwa",
    	new_repositories: "Nowe repozytoria",
    	pending_upgrades: "Oczekujące aktualizacje",
    	placeholder_search: "Wprowadź wyszukiwane hasło...",
    	sort: "sortowanie",
    	stars: "Gwiazdy",
    	status: "Status"
    };
    var time$a = {
    	ago: "temu",
    	day: "dzień",
    	days: "dni",
    	hour: "godzina",
    	hours: "godziny",
    	minute: "minuta",
    	minutes: "minuty",
    	month: "miesiąc",
    	months: "miesięcy",
    	one: "Jeden",
    	one_day_ago: "jeden dzień temu",
    	one_hour_ago: "jedna godzina temu",
    	one_minute_ago: "jedna minuta temu",
    	one_month_ago: "jeden miesiąc temu",
    	one_second_ago: "jedna sekunda temu",
    	one_year_ago: "jeden rok temu",
    	second: "sekunda",
    	seconds: "sekundy",
    	x_days_ago: "{x} dni temu",
    	x_hours_ago: "{x} godzin(-y) temu",
    	x_minutes_ago: "{x} minut(-y) temu",
    	x_months_ago: "{x} miesi(-ące/-ęcy) temu",
    	x_seconds_ago: "{x} sekund(-y) temu",
    	x_years_ago: "{x} lat(-a) temu",
    	year: "rok",
    	years: "lata"
    };
    var pl = {
    	common: common$b,
    	config: config$b,
    	confirm: confirm$b,
    	options: options$b,
    	repository_banner: repository_banner$a,
    	repository: repository$b,
    	settings: settings$b,
    	store: store$b,
    	time: time$a
    };

    var pl$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$b,
        config: config$b,
        confirm: confirm$b,
        options: options$b,
        repository_banner: repository_banner$a,
        repository: repository$b,
        settings: settings$b,
        store: store$b,
        time: time$a,
        'default': pl
    });

    var common$c = {
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "AppDaemon Apps",
    	background_task: "Tarefa em segundo plano em execução, esta página será recarregada quando terminar.",
    	installed: "instalado",
    	integration: "Integração",
    	integrations: "Integrações",
    	plugin: "Plugin",
    	plugins: "Plugins",
    	python_script: "Python Script",
    	python_scripts: "Python Scripts",
    	repositories: "Repositórios",
    	settings: "configurações",
    	theme: "Tema",
    	themes: "Temas",
    	version: "Versão"
    };
    var config$c = {
    	abort: {
    		single_instance_allowed: "Apenas uma configuração do HACS é permitida."
    	},
    	error: {
    		auth: "Token de acesso pessoal incorreto."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Habilitar AppDaemon apps descoberta & rastreamento",
    				python_script: "Habilitar python_scripts descoberta & rastreamento",
    				sidepanel_icon: "Icone do painel lateral",
    				sidepanel_title: "Titulo do painel lateral",
    				theme: "Habilitar temas descoberta & rastreamento",
    				token: "GitHub Token de acesso pessoal"
    			},
    			description: "Se você preciar de ajuda com a configuração olhe aqui: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var options$c = {
    	step: {
    		user: {
    			data: {
    				country: "Filtro pelo código do país.",
    				experimental: "Ativar recursos experimentais",
    				release_limit: "Número de lançamentos a serem exibidos."
    			}
    		}
    	}
    };
    var repository$c = {
    	authors: "Autores",
    	available: "Disponível",
    	back_to: "Voltar para",
    	changelog: "Changelog",
    	flag_this: "Sinalizar isso",
    	hide: "Esconder",
    	hide_beta: "Esconder beta",
    	install: "Instalar",
    	installed: "Instalado",
    	lovelace_copy_example: "Copie este exemplo para seu clipboard",
    	lovelace_instruction: "Quando você adicionar isso à sua configuração do lovelace, use este",
    	lovelace_no_js_type: "Não foi possível determinar o tipo deste plug-in, verifique o repositório.",
    	newest: "O mais novo",
    	note_appdaemon: "Você ainda precisa adicioná-lo ao seu arquivo 'apps.yaml'",
    	note_installed: "Quando instalado, ele estará localizado em",
    	note_integration: "Você ainda precisa adicioná-lo ao seu arquivo 'configuration.yaml'",
    	note_plugin: "você ainda precisará adicioná-lo à sua configuração do lovelace ('ui-lovelace.yaml' ou o editor de configuração da interface do usuário)",
    	open_issue: "Open issue",
    	open_plugin: "Plugin aberto",
    	reinstall: "Reinstalar",
    	repository: "Repositório",
    	show_beta: "Mostrar beta",
    	uninstall: "Desinstalar",
    	update_information: "Atualizar informação",
    	upgrade: "Melhorar"
    };
    var settings$c = {
    	add_custom_repository: "ADICIONAR REPOSITÓRIO PERSONALIZADO",
    	category: "Categoria",
    	custom_repositories: "REPOSITÓRIOS PERSONALIZADOS",
    	"delete": "Deletar",
    	display: "Display",
    	grid: "Grade",
    	hacs_repo: "HACS repo",
    	reload_data: "Recarregar dados",
    	save: "Salvar",
    	table: "Tabela",
    	upgrade_all: "Atualizar tudo"
    };
    var store$c = {
    	placeholder_search: "Por favor insira um termo de pesquisa..."
    };
    var ptBR = {
    	common: common$c,
    	config: config$c,
    	options: options$c,
    	repository: repository$c,
    	settings: settings$c,
    	store: store$c
    };

    var pt_BR = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$c,
        config: config$c,
        options: options$c,
        repository: repository$c,
        settings: settings$c,
        store: store$c,
        'default': ptBR
    });

    var common$d = {
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "Aplicații AppDaemon",
    	background_task: "Activitatea de fundal se execută, această pagină se va reîncărca atunci când este gata.",
    	installed: "instalat",
    	integration: "Integrare",
    	integrations: "Integrări",
    	plugin: "Plugin",
    	plugins: "Plugin-uri",
    	python_script: "Script Python",
    	python_scripts: "Scripturi Python",
    	repositories: "Depozite",
    	settings: "setări",
    	theme: "Temă",
    	themes: "Teme",
    	version: "Versiune"
    };
    var config$d = {
    	abort: {
    		single_instance_allowed: "Doar o singură configurație pentru HACS este permisă."
    	},
    	error: {
    		auth: "Token-ul de acces personal nu este corect."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Activați descoperirea și urmărirea aplicațiilor AppDaemon",
    				python_script: "Activați descoperirea și urmărirea python_scripts",
    				sidepanel_icon: "Pictogramă Panou lateral",
    				sidepanel_title: "Titlu panou lateral",
    				theme: "Activați descoperirea și urmărirea temelor",
    				token: "Token de acces personal GitHub"
    			},
    			description: "Dacă aveți nevoie de ajutor pentru configurare, uitați-vă aici: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$c = {
    	"delete": "Sigur doriți să ștergeți „{item}”?"
    };
    var options$d = {
    	step: {
    		user: {
    			data: {
    				country: "Filtrează cu codul țării.",
    				experimental: "Activați funcțiile experimentale",
    				release_limit: "Număr de versiuni afișate."
    			}
    		}
    	}
    };
    var repository$d = {
    	authors: "Autori",
    	available: "Disponibil",
    	back_to: "Înapoi la",
    	changelog: "Jurnal modificari",
    	flag_this: "Semnalizează",
    	hide: "Ascunde",
    	hide_beta: "Ascundere beta",
    	install: "Instalează",
    	installed: "Instalat",
    	lovelace_copy_example: "Copiați exemplul în clipboard",
    	lovelace_instruction: "Când adăugați acest lucru la configurația lovelace, folosiți acest",
    	lovelace_no_js_type: "Nu s-a putut determina tipul acestui plugin, verificați \"repository\".",
    	newest: "cele mai noi",
    	note_appdaemon: "mai trebuie să o adăugați in fișierul „apps.yaml”",
    	note_installed: "Când este instalat, acesta va fi localizat în",
    	note_integration: "mai trebuie să o adăugați in fișierul „configuration.yaml”",
    	note_plugin: "mai trebuie să o adăugați la configurația lovelace ('ui-lovelace.yaml' sau in editorul UI)",
    	open_issue: "Deschidere problemă",
    	open_plugin: "Deschide plugin",
    	reinstall: "Reinstalare",
    	repository: "Depozit",
    	show_beta: "Afișare beta",
    	uninstall: "Dezinstalare",
    	update_information: "Actualizare informație",
    	upgrade: "Actualizare"
    };
    var settings$d = {
    	add_custom_repository: "ADĂUGARE DEPOZIT PERSONALIZAT",
    	category: "Categorie",
    	custom_repositories: "DEPOZITE PERSONALIZATE",
    	"delete": "Șterge",
    	display: "Afişeaza",
    	grid: "Grilă",
    	hacs_repo: "HACS repo",
    	reload_data: "Reîncărcați datele",
    	save: "Salveaza",
    	table: "Tabel",
    	upgrade_all: "Actualizați toate"
    };
    var store$d = {
    	placeholder_search: "Vă rugăm să introduceți un termen de căutare ..."
    };
    var ro = {
    	common: common$d,
    	config: config$d,
    	confirm: confirm$c,
    	options: options$d,
    	repository: repository$d,
    	settings: settings$d,
    	store: store$d
    };

    var ro$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$d,
        config: config$d,
        confirm: confirm$c,
        options: options$d,
        repository: repository$d,
        settings: settings$d,
        store: store$d,
        'default': ro
    });

    var common$e = {
    	about: "О проекте",
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "Приложения AppDaemon",
    	background_task: "Выполняется фоновая задача, страница перезагрузится по готовности.",
    	check_log_file: "Проверьте логи для получения более подробной информации.",
    	"continue": "Продолжить",
    	disabled: "Отключено",
    	documentation: "Документация",
    	hacs_is_disabled: "HACS отключен",
    	installed: "установлено",
    	integration: "Интеграция",
    	integrations: "Интеграции",
    	manage: "управлять",
    	plugin: "Плагин",
    	plugins: "Плагины",
    	python_script: "Скрипт Python",
    	python_scripts: "Скрипты Python",
    	repositories: "Репозитории",
    	settings: "настройки",
    	theme: "Тема",
    	themes: "Темы",
    	version: "Версия"
    };
    var config$e = {
    	abort: {
    		single_instance_allowed: "Разрешена только одна настройка HACS."
    	},
    	error: {
    		auth: "Неверный токен персонального доступа."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Включить поиск и отслеживание приложений AppDaemon",
    				python_script: "Включить поиск и отслеживание скриптов Python",
    				sidepanel_icon: "Иконка в боковом меню",
    				sidepanel_title: "Название в боковом меню",
    				theme: "Включить поиск и отслеживание тем",
    				token: "Персональный токен доступа GitHub"
    			},
    			description: "Если вам нужна помощь с настройкой, посмотрите: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$d = {
    	add_to_lovelace: "Вы уверены, что хотите добавить это в ресурсы Lovelace?",
    	bg_task: "Действие отключено во время выполнения фоновых задач.",
    	cancel: "Отмена",
    	"continue": "Вы уверены, что хотите продолжить?",
    	"delete": "Вы уверены, что хотите удалить \"{item}\"?",
    	delete_installed: "'{item}' установлен, вам нужно нажать 'Удалить', чтобы удалить его.",
    	exist: "{item} уже существует.",
    	generic: "Вы уверены?",
    	no: "Нет",
    	no_upgrades: "Нет обновлений",
    	ok: "ОК",
    	overwrite: "После подтверждения файлы будут перезаписаны.",
    	reload_data: "Выполняется перезагрузка данных всех репозиториев в HACS, это займет некоторое время.",
    	uninstall: "Вы уверены, что хотите удалить \"{item}\"?",
    	yes: "Да"
    };
    var options$e = {
    	step: {
    		user: {
    			data: {
    				country: "Фильтр с кодом страны.",
    				debug: "Включить отладку.",
    				experimental: "Включить экспериментальные функции",
    				release_limit: "Число доступных версий."
    			}
    		}
    	}
    };
    var repository_banner$b = {
    	integration_not_loaded: "Эта интеграция не загружена в Home Assistant.",
    	not_loaded: "Не загружено",
    	plugin_not_loaded: "Этот плагин не добавлен к ресурсам Lovelace.",
    	restart: "Вам нужно перезапустить Home Assistant.",
    	restart_pending: "Ожидается перезапуск"
    };
    var repository$e = {
    	add_to_lovelace: "Добавить в Lovelace",
    	authors: "Авторы",
    	available: "Доступно",
    	back_to: "Назад к",
    	changelog: "Изменения",
    	downloads: "Загрузки",
    	flag_this: "Пожаловаться",
    	frontend_version: "Версия",
    	hide: "Скрыть",
    	hide_beta: "Скрыть бета",
    	install: "Установить",
    	installed: "Установлено",
    	lovelace_copy_example: "Скопируйте пример в буфер обмена",
    	lovelace_instruction: "Для добавления в конфигурацию Lovelace, используйте",
    	lovelace_no_js_type: "Не удалось определить тип этого плагина, проверьте репозиторий.",
    	newest: "новейшая",
    	note_appdaemon: "вам всё ещё нужно добавить код для настройки приложения в файл 'apps.yaml'",
    	note_installed: "После установки, файлы будут расположены в",
    	note_integration: "вам всё ещё нужно добавить код для настройки интеграции в файл 'configuration.yaml'",
    	note_plugin: "вам всё ещё нужно добавить код для настройки плагина в конфигурацию Lovelace ('ui-lovelace.yaml')",
    	open_issue: "Сообщить о проблеме",
    	open_plugin: "Открыть плагин",
    	reinstall: "Переустановить",
    	repository: "Репозиторий",
    	show_beta: "Показать бета",
    	uninstall: "Удалить",
    	update_information: "Обновить информацию",
    	upgrade: "Обновить"
    };
    var settings$e = {
    	add_custom_repository: "ДОБАВИТЬ СВОЙ РЕПОЗИТОРИЙ",
    	adding_new_repo: "Добавление нового репозитория '{repo}'",
    	adding_new_repo_category: "С категорией '{category}'.",
    	bg_task_custom: "Свои репозитории скрыты во время выполнения фоновых задач.",
    	category: "Категория",
    	compact_mode: "Компактный режим",
    	custom_repositories: "СВОИ РЕПОЗИТОРИИ",
    	"delete": "Удалить",
    	display: "Вид",
    	grid: "Сетка",
    	hacs_repo: "Репозиторий HACS",
    	hidden_repositories: "Скрытые репозитории",
    	missing_category: "Вы должны выбрать категорию",
    	open_repository: "Открыть репозиторий",
    	reload_data: "Перезагрузить",
    	repository_configuration: "Конфигурация репозитория",
    	save: "Сохранить",
    	table: "Таблица",
    	table_view: "Таблица",
    	unhide: "Показать",
    	upgrade_all: "Обновить всё"
    };
    var store$e = {
    	ascending: "по возрастанию",
    	clear_new: "Очистить все новые репозитории",
    	descending: "по убыванию",
    	last_updated: "Последнее обновление",
    	name: "Название",
    	new_repositories: "Новые репозитории",
    	pending_upgrades: "Ожидается обновление",
    	placeholder_search: "Пожалуйста, введите условие для поиска...",
    	sort: "Сортировка",
    	stars: "Звезды",
    	status: "Статус"
    };
    var time$b = {
    	ago: "назад",
    	day: "день",
    	days: "дней",
    	hour: "час",
    	hours: "часов",
    	minute: "минута",
    	minutes: "минут",
    	month: "месяц",
    	months: "месяца",
    	one: "Одна",
    	second: "секунда",
    	seconds: "секунд",
    	year: "год",
    	years: "лет"
    };
    var ru = {
    	common: common$e,
    	config: config$e,
    	confirm: confirm$d,
    	options: options$e,
    	repository_banner: repository_banner$b,
    	repository: repository$e,
    	settings: settings$e,
    	store: store$e,
    	time: time$b
    };

    var ru$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$e,
        config: config$e,
        confirm: confirm$d,
        options: options$e,
        repository_banner: repository_banner$b,
        repository: repository$e,
        settings: settings$e,
        store: store$e,
        time: time$b,
        'default': ru
    });

    var common$f = {
    	about: "O tem",
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "AppDaemon Aplikacije",
    	background_task: "V ozadju se izvaja naloga, ko se konča, se bo stran osvežila.",
    	check_log_file: "Za več podrobnosti preverite datoteko dnevnika.",
    	"continue": "Nadaljuj",
    	disabled: "Onemogočeno",
    	documentation: "Dokumentacija",
    	hacs_is_disabled: "HACS je onemogočen",
    	installed: "Nameščeno",
    	integration: "Integracija",
    	integrations: "Integracije",
    	manage: "upravljanje",
    	plugin: "vtičnik",
    	plugins: "Vtičniki",
    	python_script: "Python skripta",
    	python_scripts: "Python skripte",
    	repositories: "Repozitoriji",
    	settings: "nastavitve",
    	theme: "Tema",
    	themes: "Teme",
    	version: "Različica"
    };
    var config$f = {
    	abort: {
    		single_instance_allowed: "Dovoljena je samo ena konfiguracija HACS."
    	},
    	error: {
    		auth: "Osebni dostopni žeton ni pravilen."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Omogoči odkrivanje in sledenje aplikacij AppDaemon",
    				python_script: "Omogoči odkrivanje in sledenje python_scripts",
    				sidepanel_icon: "Ikona stranske plošče",
    				sidepanel_title: "Naslov stranske plošče",
    				theme: "Omogoči odkrivanje in sledenje tem",
    				token: "GitHub žeton za osebni dostop"
    			},
    			description: "Če potrebujete pomoč pri konfiguraciji, poglejte tukaj: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$e = {
    	add_to_lovelace: "Ali si prepričan, da želiš to dodati med svoje vire Lovelace?",
    	bg_task: "Dejanje je onemogočeno, medtem ko se izvajajo opravila v ozadju.",
    	cancel: "Prekliči",
    	"continue": "Ali ste prepričani, da želite nadaljevati?",
    	"delete": "Ali ste prepričani, da želite izbrisati \"{item}\"?",
    	delete_installed: "'{item}' je nameščen, pred odstranitvijo ga morate odstraniti.",
    	exist: "{item} že obstaja",
    	generic: "Ali si prepričan?",
    	no: "Ne",
    	no_upgrades: "Ni nadgradenj",
    	ok: "V redu",
    	overwrite: "Če to storite, bo to prepisano.",
    	reload_data: "Ponovno se naložijo podatki vseh shramb HA, to bo trajalo nekaj časa.",
    	uninstall: "Ali ste prepričani, da želite odstraniti \"{item}\"?",
    	upgrade_all: "To bo nadgradil vse te repozitorije, preden nadaljujete poskrbite, da ste prebrali vse opombe ob izdaji.",
    	yes: "Da"
    };
    var options$f = {
    	step: {
    		user: {
    			data: {
    				country: "Filtrirajte s kodo države.",
    				debug: "Omogoči odpravljanje napak.",
    				experimental: "Omogočite poskusne funkcije",
    				release_limit: "Število izdaj, ki jih želite prikazati."
    			}
    		}
    	}
    };
    var repository_banner$c = {
    	integration_not_loaded: "Ta integracija ni naložena v programu Home Assistant.",
    	not_loaded: "Ni naloženo",
    	plugin_not_loaded: "Ta vtičnik ni dodan vašim virom Lovelace.",
    	restart: "Znova morate zagnati Home Assistant.",
    	restart_pending: "Vnovični zagon v čakanju"
    };
    var repository$f = {
    	add_to_lovelace: "Dodaj v Lovelace",
    	authors: "Avtorji",
    	available: "Na voljo",
    	back_to: "Nazaj na",
    	changelog: "Dnevnik sprememb",
    	downloads: "Prenosi",
    	flag_this: "Označite to",
    	hide: "Skrij",
    	hide_beta: "Skrij različico beta",
    	install: "Namestite",
    	installed: "Nameščeno",
    	lovelace_copy_example: "Kopirajte primer v odložišče",
    	lovelace_instruction: "Ko ga boste dodajali v svojo lovelace konfiguracijo uporabite to:",
    	lovelace_no_js_type: "Ni bilo mogoče določiti vrsto tega vtičnika, preverite repozitorij.",
    	newest: "najnovejše",
    	note_appdaemon: "Še vedno ga morate dodati v svojo 'apps.yaml' datoteko",
    	note_installed: "Ko bo nameščen, se bo nahajal v",
    	note_integration: "Še vedno ga morate dodati v svojo 'configuration.yaml' datoteko",
    	note_plugin: "vendar ga še vedno morate dodati v svojo lovelace konfiguracijo ('ui-lovelace.yaml' ali \"raw\" UI config urejevalnik)",
    	open_issue: "Odprite težavo",
    	open_plugin: "Odprite vtičnik",
    	reinstall: "Znova namestite",
    	repository: "Repozitorij",
    	show_beta: "Pokaži različico beta",
    	uninstall: "Odstranite",
    	update_information: "Posodobite podatke",
    	upgrade: "Nadgradnja"
    };
    var settings$f = {
    	add_custom_repository: "DODAJTE SVOJ REPOZITORIJ",
    	adding_new_repo: "Dodajanje novega repozitorija '{repo}'",
    	adding_new_repo_category: "S kategorijo '{category}'.",
    	bg_task_custom: "Med izvajanjem nalog v ozadju so repozitoriji po meri skriti.",
    	category: "Kategorija",
    	compact_mode: "Kompaktni način",
    	custom_repositories: "VAŠI REPOZITORIJI",
    	"delete": "Izbriši",
    	display: "Prikaz",
    	grid: "Mreža",
    	hacs_repo: "HACS repo",
    	hidden_repositories: "skriti repozitoriji",
    	missing_category: "Izbrati moraš kategorijo",
    	open_repository: "Odprite skladišče",
    	reload_data: "Ponovno naloži podatke",
    	repository_configuration: "Konfiguracija skladišč",
    	save: "Shranite",
    	table: "Tabela",
    	table_view: "Pogled tabele",
    	unhide: "Razkrij",
    	upgrade_all: "Nadgradite vse"
    };
    var store$f = {
    	ascending: "naraščajoče",
    	clear_new: "Počisti vse nove repozitorije",
    	descending: "padajoče",
    	last_updated: "Nazadnje posodobljeno",
    	name: "Ime",
    	new_repositories: "Novi repozitoriji",
    	pending_upgrades: "Nadgradnje na čakanju",
    	placeholder_search: "Prosim vnesite iskalni izraz ...",
    	sort: "razvrsti",
    	stars: "Zvezd",
    	status: "Stanje"
    };
    var time$c = {
    	ago: "nazaj",
    	day: "dan",
    	days: "Dni",
    	hour: "ura",
    	hours: "Ur",
    	minute: "minuta",
    	minutes: "minut",
    	month: "mesec",
    	months: "mesecev",
    	one: "Eno",
    	second: "drugič",
    	seconds: "sekund",
    	year: "leto",
    	years: "Let"
    };
    var sl = {
    	common: common$f,
    	config: config$f,
    	confirm: confirm$e,
    	options: options$f,
    	repository_banner: repository_banner$c,
    	repository: repository$f,
    	settings: settings$f,
    	store: store$f,
    	time: time$c
    };

    var sl$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$f,
        config: config$f,
        confirm: confirm$e,
        options: options$f,
        repository_banner: repository_banner$c,
        repository: repository$f,
        settings: settings$f,
        store: store$f,
        time: time$c,
        'default': sl
    });

    var common$g = {
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "Appdaemon Applikationer",
    	background_task: "Bakgrundsjobb körs, denna sida kommer att laddas igen när det är klart.",
    	installed: "installerad",
    	integration: "Integration",
    	integrations: "Integrationer",
    	plugin: "Plugin",
    	plugins: "Plugins",
    	python_script: "Python skript",
    	python_scripts: "Python skript",
    	repositories: "Repositories",
    	settings: "inställningar",
    	theme: "Tema",
    	themes: "Teman",
    	version: "Version"
    };
    var config$g = {
    	abort: {
    		single_instance_allowed: "Endast en konfiguration kan användas i HACS."
    	},
    	error: {
    		auth: "Personal Access Token är inte korrekt."
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "Upptäck och följ Appdaemon applikationer",
    				python_script: "Upptäck och följ python_scripts",
    				sidepanel_icon: "Ikon för sidpanel",
    				sidepanel_title: "Rubrik för sidpanel",
    				theme: "Upptäck och följ teman",
    				token: "GitHub Personal Access Token"
    			},
    			description: "Om du behöver hjälp med konfigurationen, se här: https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$f = {
    	add_to_lovelace: "Är du säker på att du vill lägga till detta till dina Lovelace-resurser?",
    	bg_task: "Åtgärden är inaktiverad medan aktiviteter i bakgrunden körs",
    	cancel: "Avbryt",
    	"continue": "Är du säker på att du vill fortsätta?",
    	"delete": "Är du säker på att du vill ta bort \"{item}\"?",
    	delete_installed: "'{item}' är installerat, du måste avinstallera det innan du kan ta bort det.",
    	exist: "{item} existerar redan",
    	generic: "Är du säker?",
    	no: "Nej",
    	no_upgrades: "Inga uppgraderingar väntar",
    	ok: "OK",
    	overwrite: "Detta kommer att skriva över den.",
    	uninstall: "Är du säker på att du vill avinstallera \" {item} \"?",
    	upgrade_all: "Detta kommer uppgradera alla dessa repositories, säkerhetsställ att du läst release anteckningarna för dem alla innan du fortsätter",
    	yes: "Ja"
    };
    var options$g = {
    	step: {
    		user: {
    			data: {
    				country: "Filtrera på landskod.",
    				debug: "Aktivera felsökning",
    				experimental: "Använd experimentella funktioner",
    				release_limit: "Antalet releaser som visas."
    			}
    		}
    	}
    };
    var repository_banner$d = {
    	integration_not_loaded: "Denna integration inte laddats i Hem Assistent.",
    	not_loaded: "Ej laddad",
    	plugin_not_loaded: "Detta plugin är inte tillagt till din Lovelaceresurs.",
    	restart: "Du måste starta om Home Assistant.",
    	restart_pending: "Omstart väntar"
    };
    var repository$g = {
    	add_to_lovelace: "Lägg till i Lovelace",
    	authors: "Författare",
    	available: "Tillgänglig",
    	back_to: "Tillbaka till",
    	changelog: "Ändringslogg",
    	flag_this: "Flagga denna",
    	hide: "Göm",
    	hide_beta: "Göm betaversioner",
    	install: "Installera",
    	installed: "Installerad",
    	lovelace_copy_example: "Kopiera exemplet till urklipp",
    	lovelace_instruction: "När du lägger till denna till din lovelace konfiguration, använd",
    	lovelace_no_js_type: "Kan inte avgöra villken typ av plugin, kontrollera i GIT \nrepository",
    	newest: "nyaste",
    	note_appdaemon: "du behöver fortfarande lägga till den till filen 'apps.yaml'",
    	note_installed: "När den är installerad kommer den finnas i",
    	note_integration: "du behöver fortfarande lägga den till filen 'configuration.yaml'",
    	note_plugin: "du behöver fortfarande lägga till den till din lovelace konfiguration ('ui-lovelace.yaml' eller raw UI config redigerare)",
    	open_issue: "Rapportera problem",
    	open_plugin: "Öppna plugin",
    	reinstall: "Ominstallera",
    	repository: "Repository",
    	show_beta: "Visa betaversioner",
    	uninstall: "Avinstallera",
    	update_information: "Uppdatera information",
    	upgrade: "Uppdatera"
    };
    var settings$g = {
    	add_custom_repository: "LÄGG TILL ETT REPOSITORY",
    	adding_new_repo: "Lägger till nytt repository '{repo}'",
    	adding_new_repo_category: "Med kategori '{kategori}'.",
    	bg_task_custom: "Anpassade repositories är dolda under tiden aktiviteter i bakgrunden körs",
    	category: "Kategori",
    	compact_mode: "Kompakt läge",
    	custom_repositories: "REPOSITORIES",
    	"delete": "Ta bort",
    	display: "Visa",
    	grid: "Rutnät",
    	hacs_repo: "HACS repo",
    	hidden_repositories: "dolda förråd",
    	missing_category: "Du behöver välja en kategori",
    	reload_data: "Ladda om data",
    	save: "Spara",
    	table: "Tabell",
    	table_view: "Tabellvy",
    	unhide: "ta fram",
    	upgrade_all: "Uppgradera alla"
    };
    var store$g = {
    	clear_new: "Rensa alla nya förvar",
    	name: "Namn",
    	new_repositories: "Nya förvar",
    	pending_upgrades: "Väntande uppgraderingar",
    	placeholder_search: "Skriv ett sökord...",
    	sort: "sortera",
    	stars: "Stjärnor",
    	status: "Status"
    };
    var sv = {
    	common: common$g,
    	config: config$g,
    	confirm: confirm$f,
    	options: options$g,
    	repository_banner: repository_banner$d,
    	repository: repository$g,
    	settings: settings$g,
    	store: store$g
    };

    var sv$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$g,
        config: config$g,
        confirm: confirm$f,
        options: options$g,
        repository_banner: repository_banner$d,
        repository: repository$g,
        settings: settings$g,
        store: store$g,
        'default': sv
    });

    var common$h = {
    	about: "关于",
    	appdaemon: "AppDaemon",
    	appdaemon_apps: "AppDaemon应用",
    	background_task: "后台任务正在运行，完成后将重新加载此页面。",
    	check_log_file: "请查看日志文件以了解更多信息。",
    	"continue": "继续",
    	disabled: "禁用",
    	documentation: "文档",
    	hacs_is_disabled: "HACS已禁用",
    	installed: "已安装",
    	integration: "自定义组件",
    	integrations: "自定义组件",
    	manage: "管理",
    	plugin: "Lovelace插件",
    	plugins: "Lovelace插件",
    	python_script: "Python脚本",
    	python_scripts: "Python脚本",
    	repositories: "仓库数量",
    	settings: "设置",
    	theme: "主题",
    	themes: "主题",
    	version: "版本"
    };
    var config$h = {
    	abort: {
    		single_instance_allowed: "仅允许单个HACS配置。"
    	},
    	error: {
    		auth: "个人访问令牌不正确。"
    	},
    	step: {
    		user: {
    			data: {
    				appdaemon: "启用AppDaemon应用发现和跟踪",
    				python_script: "启用python_scripts发现和跟踪",
    				sidepanel_icon: "侧面板图标",
    				sidepanel_title: "侧面板标题",
    				theme: "启用主题发现和跟踪",
    				token: "GitHub个人访问令牌"
    			},
    			description: "如果您需要有关配置的帮助，请在此处查看：https://hacs.xyz/docs/configuration/start",
    			title: "HACS (Home Assistant Community Store)"
    		}
    	},
    	title: "HACS (Home Assistant Community Store)"
    };
    var confirm$g = {
    	add_to_lovelace: "您确定要将此添加到Lovelace资源中吗？",
    	bg_task: "后台任务正在运行时，操作被禁用。",
    	cancel: "取消",
    	"continue": "你确定你要继续吗？",
    	"delete": "是否确实要删除\"{item}\"？",
    	delete_installed: "已安装“ {item}”，需要先将其卸载，然后才能将其删除。",
    	exist: "{item}已经存在",
    	generic: "你确定吗？",
    	no: "不",
    	no_upgrades: "暂无升级",
    	ok: "确定",
    	overwrite: "这样做会覆盖它。",
    	reload_data: "这将重新加载HACS知道的所有仓库的数据，这需要一些时间才能完成。",
    	uninstall: "您确定要卸载“ {item} ”吗？",
    	upgrade_all: "这将升级所有这些仓库，请确保在继续之前已阅读所有仓库的发行说明。",
    	yes: "是"
    };
    var options$h = {
    	step: {
    		user: {
    			data: {
    				country: "用国家代码过滤。",
    				debug: "启用调试。",
    				experimental: "启用实验功能",
    				release_limit: "要显示的发行数量。"
    			}
    		}
    	}
    };
    var repository_banner$e = {
    	integration_not_loaded: "此集成未加载到Home Assistant中。",
    	not_loaded: "未加载",
    	plugin_not_loaded: "该插件未添加到您的Lovelace资源中。",
    	restart: "您需要重新启动Home Assistant。",
    	restart_pending: "重新启动待处理"
    };
    var repository$h = {
    	add_to_lovelace: "添加到Lovelace",
    	authors: "作者",
    	available: "版本号",
    	back_to: "返回",
    	changelog: "更新日志",
    	downloads: "下载",
    	flag_this: "标记",
    	frontend_version: "前端版本",
    	hide: "隐藏",
    	hide_beta: "隐藏测试版",
    	install: "安装",
    	installed: "已安装版本",
    	lovelace_copy_example: "复制样例代码到你的剪贴板",
    	lovelace_instruction: "您仍然需要将下列代码添加到lovelace配置中（“ ui-lovelace.yaml”或原始配置编辑器）:",
    	lovelace_no_js_type: "无法确定此插件的类型，请检查仓库。",
    	newest: "最新",
    	note_appdaemon: "您仍然需要将其添加到“ apps.yaml”文件中",
    	note_installed: "安装后，它将位于",
    	note_integration: "您仍然需要将其添加到“ configuration.yaml”文件中",
    	note_plugin: "您仍然需要将其添加到lovelace配置中（“ ui-lovelace.yaml”或原始配置编辑器）ui-lovelace.yaml",
    	open_issue: "提交问题",
    	open_plugin: "打开插件",
    	reinstall: "重新安装",
    	repository: "仓库",
    	show_beta: "显示测试版",
    	uninstall: "卸载",
    	update_information: "更新信息",
    	upgrade: "升级"
    };
    var settings$h = {
    	add_custom_repository: "添加自定义仓库",
    	adding_new_repo: "添加新的仓库“ {repo}”",
    	adding_new_repo_category: "类别为“ {category}”。",
    	bg_task_custom: "自定义仓库在后台任务运行时被隐藏。",
    	category: "类别",
    	compact_mode: "紧凑模式",
    	custom_repositories: "自定义仓库",
    	"delete": "删除",
    	display: "视图方式",
    	grid: "网格",
    	hacs_repo: "HACS仓库",
    	hidden_repositories: "隐藏的仓库",
    	missing_category: "您需要选择一个类别",
    	open_repository: "打开仓库",
    	reload_data: "重载数据",
    	repository_configuration: "仓库数据配置",
    	save: "保存",
    	table: "列表",
    	table_view: "表视图",
    	unhide: "取消隐藏",
    	upgrade_all: "升级全部"
    };
    var store$h = {
    	ascending: "升序",
    	clear_new: "清除所有新仓库标记",
    	descending: "降序",
    	last_updated: "最近更新时间",
    	name: "名称",
    	new_repositories: "新仓库",
    	pending_upgrades: "待升级",
    	placeholder_search: "搜索项目...",
    	sort: "排序",
    	stars: "星级",
    	status: "状态"
    };
    var time$d = {
    	ago: "过去",
    	day: "天",
    	days: "天",
    	hour: "小时",
    	hours: "小时",
    	minute: "分",
    	minutes: "分",
    	month: "月",
    	months: "月",
    	one: "一",
    	second: "秒",
    	seconds: "秒",
    	year: "年",
    	years: "年"
    };
    var zhHans = {
    	common: common$h,
    	config: config$h,
    	confirm: confirm$g,
    	options: options$h,
    	repository_banner: repository_banner$e,
    	repository: repository$h,
    	settings: settings$h,
    	store: store$h,
    	time: time$d
    };

    var zh_Hans = /*#__PURE__*/Object.freeze({
        __proto__: null,
        common: common$h,
        config: config$h,
        confirm: confirm$g,
        options: options$h,
        repository_banner: repository_banner$e,
        repository: repository$h,
        settings: settings$h,
        store: store$h,
        time: time$d,
        'default': zhHans
    });

    function localize(string, search = undefined, replace = undefined) {
        const languages = {
            da: da$1,
            de: de$1,
            el: el$1,
            en: en$1,
            es: es$1,
            fr: fr$1,
            hu: hu$1,
            it: it$1,
            nb: nb$1,
            nl: nl$1,
            nn: nn$1,
            pl: pl$1,
            pt_BR: pt_BR,
            ro: ro$1,
            ru: ru$1,
            sl: sl$1,
            sv: sv$1,
            zh_Hans: zh_Hans
        };
        const section = string.split(".")[0];
        const key = string.split(".")[1];
        const lang = (localStorage.getItem("selectedLanguage") || "en")
            .replace(/['"]+/g, "")
            .replace("-", "_");
        var translated;
        try {
            translated = languages[lang][section][key];
        }
        catch (e) {
            translated = languages["en"][section][key];
        }
        if (translated === undefined)
            translated = languages["en"][section][key];
        if (search !== undefined && replace !== undefined) {
            translated = translated.replace(search, replace);
        }
        return translated;
    }

    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

    function unwrapExports (x) {
    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
    }

    function createCommonjsModule(fn, module) {
    	return module = { exports: {} }, fn(module, module.exports), module.exports;
    }

    function getCjsExportFromNamespace (n) {
    	return n && n['default'] || n;
    }

    /**
     * lodash (Custom Build) <https://lodash.com/>
     * Build: `lodash modularize exports="npm" -o ./`
     * Copyright jQuery Foundation and other contributors <https://jquery.org/>
     * Released under MIT license <https://lodash.com/license>
     * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
     * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
     */

    /** Used as references for various `Number` constants. */
    var MAX_SAFE_INTEGER = 9007199254740991;

    /** `Object#toString` result references. */
    var argsTag = '[object Arguments]',
        funcTag = '[object Function]',
        genTag = '[object GeneratorFunction]',
        mapTag = '[object Map]',
        objectTag = '[object Object]',
        promiseTag = '[object Promise]',
        setTag = '[object Set]',
        stringTag = '[object String]',
        weakMapTag = '[object WeakMap]';

    var dataViewTag = '[object DataView]';

    /**
     * Used to match `RegExp`
     * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
     */
    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;

    /** Used to detect host constructors (Safari). */
    var reIsHostCtor = /^\[object .+?Constructor\]$/;

    /** Used to detect unsigned integer values. */
    var reIsUint = /^(?:0|[1-9]\d*)$/;

    /** Used to compose unicode character classes. */
    var rsAstralRange = '\\ud800-\\udfff',
        rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
        rsComboSymbolsRange = '\\u20d0-\\u20f0',
        rsVarRange = '\\ufe0e\\ufe0f';

    /** Used to compose unicode capture groups. */
    var rsAstral = '[' + rsAstralRange + ']',
        rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']',
        rsFitz = '\\ud83c[\\udffb-\\udfff]',
        rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
        rsNonAstral = '[^' + rsAstralRange + ']',
        rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
        rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
        rsZWJ = '\\u200d';

    /** Used to compose unicode regexes. */
    var reOptMod = rsModifier + '?',
        rsOptVar = '[' + rsVarRange + ']?',
        rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
        rsSeq = rsOptVar + reOptMod + rsOptJoin,
        rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';

    /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
    var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');

    /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
    var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']');

    /** Detect free variable `global` from Node.js. */
    var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;

    /** Detect free variable `self`. */
    var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

    /** Used as a reference to the global object. */
    var root = freeGlobal || freeSelf || Function('return this')();

    /**
     * A specialized version of `_.map` for arrays without support for iteratee
     * shorthands.
     *
     * @private
     * @param {Array} [array] The array to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array} Returns the new mapped array.
     */
    function arrayMap(array, iteratee) {
      var index = -1,
          length = array ? array.length : 0,
          result = Array(length);

      while (++index < length) {
        result[index] = iteratee(array[index], index, array);
      }
      return result;
    }

    /**
     * Converts an ASCII `string` to an array.
     *
     * @private
     * @param {string} string The string to convert.
     * @returns {Array} Returns the converted array.
     */
    function asciiToArray(string) {
      return string.split('');
    }

    /**
     * The base implementation of `_.times` without support for iteratee shorthands
     * or max array length checks.
     *
     * @private
     * @param {number} n The number of times to invoke `iteratee`.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array} Returns the array of results.
     */
    function baseTimes(n, iteratee) {
      var index = -1,
          result = Array(n);

      while (++index < n) {
        result[index] = iteratee(index);
      }
      return result;
    }

    /**
     * The base implementation of `_.values` and `_.valuesIn` which creates an
     * array of `object` property values corresponding to the property names
     * of `props`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Array} props The property names to get values for.
     * @returns {Object} Returns the array of property values.
     */
    function baseValues(object, props) {
      return arrayMap(props, function(key) {
        return object[key];
      });
    }

    /**
     * Gets the value at `key` of `object`.
     *
     * @private
     * @param {Object} [object] The object to query.
     * @param {string} key The key of the property to get.
     * @returns {*} Returns the property value.
     */
    function getValue(object, key) {
      return object == null ? undefined : object[key];
    }

    /**
     * Checks if `string` contains Unicode symbols.
     *
     * @private
     * @param {string} string The string to inspect.
     * @returns {boolean} Returns `true` if a symbol is found, else `false`.
     */
    function hasUnicode(string) {
      return reHasUnicode.test(string);
    }

    /**
     * Checks if `value` is a host object in IE < 9.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
     */
    function isHostObject(value) {
      // Many host objects are `Object` objects that can coerce to strings
      // despite having improperly defined `toString` methods.
      var result = false;
      if (value != null && typeof value.toString != 'function') {
        try {
          result = !!(value + '');
        } catch (e) {}
      }
      return result;
    }

    /**
     * Converts `iterator` to an array.
     *
     * @private
     * @param {Object} iterator The iterator to convert.
     * @returns {Array} Returns the converted array.
     */
    function iteratorToArray(iterator) {
      var data,
          result = [];

      while (!(data = iterator.next()).done) {
        result.push(data.value);
      }
      return result;
    }

    /**
     * Converts `map` to its key-value pairs.
     *
     * @private
     * @param {Object} map The map to convert.
     * @returns {Array} Returns the key-value pairs.
     */
    function mapToArray(map) {
      var index = -1,
          result = Array(map.size);

      map.forEach(function(value, key) {
        result[++index] = [key, value];
      });
      return result;
    }

    /**
     * Creates a unary function that invokes `func` with its argument transformed.
     *
     * @private
     * @param {Function} func The function to wrap.
     * @param {Function} transform The argument transform.
     * @returns {Function} Returns the new function.
     */
    function overArg(func, transform) {
      return function(arg) {
        return func(transform(arg));
      };
    }

    /**
     * Converts `set` to an array of its values.
     *
     * @private
     * @param {Object} set The set to convert.
     * @returns {Array} Returns the values.
     */
    function setToArray(set) {
      var index = -1,
          result = Array(set.size);

      set.forEach(function(value) {
        result[++index] = value;
      });
      return result;
    }

    /**
     * Converts `string` to an array.
     *
     * @private
     * @param {string} string The string to convert.
     * @returns {Array} Returns the converted array.
     */
    function stringToArray(string) {
      return hasUnicode(string)
        ? unicodeToArray(string)
        : asciiToArray(string);
    }

    /**
     * Converts a Unicode `string` to an array.
     *
     * @private
     * @param {string} string The string to convert.
     * @returns {Array} Returns the converted array.
     */
    function unicodeToArray(string) {
      return string.match(reUnicode) || [];
    }

    /** Used for built-in method references. */
    var funcProto = Function.prototype,
        objectProto = Object.prototype;

    /** Used to detect overreaching core-js shims. */
    var coreJsData = root['__core-js_shared__'];

    /** Used to detect methods masquerading as native. */
    var maskSrcKey = (function() {
      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
      return uid ? ('Symbol(src)_1.' + uid) : '';
    }());

    /** Used to resolve the decompiled source of functions. */
    var funcToString = funcProto.toString;

    /** Used to check objects for own properties. */
    var hasOwnProperty = objectProto.hasOwnProperty;

    /**
     * Used to resolve the
     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
     * of values.
     */
    var objectToString = objectProto.toString;

    /** Used to detect if a method is native. */
    var reIsNative = RegExp('^' +
      funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
      .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
    );

    /** Built-in value references. */
    var Symbol$1 = root.Symbol,
        iteratorSymbol = Symbol$1 ? Symbol$1.iterator : undefined,
        propertyIsEnumerable = objectProto.propertyIsEnumerable;

    /* Built-in method references for those with the same name as other `lodash` methods. */
    var nativeKeys = overArg(Object.keys, Object);

    /* Built-in method references that are verified to be native. */
    var DataView = getNative(root, 'DataView'),
        Map$1 = getNative(root, 'Map'),
        Promise$1 = getNative(root, 'Promise'),
        Set$1 = getNative(root, 'Set'),
        WeakMap$1 = getNative(root, 'WeakMap');

    /** Used to detect maps, sets, and weakmaps. */
    var dataViewCtorString = toSource(DataView),
        mapCtorString = toSource(Map$1),
        promiseCtorString = toSource(Promise$1),
        setCtorString = toSource(Set$1),
        weakMapCtorString = toSource(WeakMap$1);

    /**
     * Creates an array of the enumerable property names of the array-like `value`.
     *
     * @private
     * @param {*} value The value to query.
     * @param {boolean} inherited Specify returning inherited property names.
     * @returns {Array} Returns the array of property names.
     */
    function arrayLikeKeys(value, inherited) {
      // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
      // Safari 9 makes `arguments.length` enumerable in strict mode.
      var result = (isArray(value) || isArguments(value))
        ? baseTimes(value.length, String)
        : [];

      var length = result.length,
          skipIndexes = !!length;

      for (var key in value) {
        if ((inherited || hasOwnProperty.call(value, key)) &&
            !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
          result.push(key);
        }
      }
      return result;
    }

    /**
     * The base implementation of `getTag`.
     *
     * @private
     * @param {*} value The value to query.
     * @returns {string} Returns the `toStringTag`.
     */
    function baseGetTag(value) {
      return objectToString.call(value);
    }

    /**
     * The base implementation of `_.isNative` without bad shim checks.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a native function,
     *  else `false`.
     */
    function baseIsNative(value) {
      if (!isObject(value) || isMasked(value)) {
        return false;
      }
      var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
      return pattern.test(toSource(value));
    }

    /**
     * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     */
    function baseKeys(object) {
      if (!isPrototype(object)) {
        return nativeKeys(object);
      }
      var result = [];
      for (var key in Object(object)) {
        if (hasOwnProperty.call(object, key) && key != 'constructor') {
          result.push(key);
        }
      }
      return result;
    }

    /**
     * Copies the values of `source` to `array`.
     *
     * @private
     * @param {Array} source The array to copy values from.
     * @param {Array} [array=[]] The array to copy values to.
     * @returns {Array} Returns `array`.
     */
    function copyArray(source, array) {
      var index = -1,
          length = source.length;

      array || (array = Array(length));
      while (++index < length) {
        array[index] = source[index];
      }
      return array;
    }

    /**
     * Gets the native function at `key` of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {string} key The key of the method to get.
     * @returns {*} Returns the function if it's native, else `undefined`.
     */
    function getNative(object, key) {
      var value = getValue(object, key);
      return baseIsNative(value) ? value : undefined;
    }

    /**
     * Gets the `toStringTag` of `value`.
     *
     * @private
     * @param {*} value The value to query.
     * @returns {string} Returns the `toStringTag`.
     */
    var getTag = baseGetTag;

    // Fallback for data views, maps, sets, and weak maps in IE 11,
    // for data views in Edge < 14, and promises in Node.js.
    if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
        (Map$1 && getTag(new Map$1) != mapTag) ||
        (Promise$1 && getTag(Promise$1.resolve()) != promiseTag) ||
        (Set$1 && getTag(new Set$1) != setTag) ||
        (WeakMap$1 && getTag(new WeakMap$1) != weakMapTag)) {
      getTag = function(value) {
        var result = objectToString.call(value),
            Ctor = result == objectTag ? value.constructor : undefined,
            ctorString = Ctor ? toSource(Ctor) : undefined;

        if (ctorString) {
          switch (ctorString) {
            case dataViewCtorString: return dataViewTag;
            case mapCtorString: return mapTag;
            case promiseCtorString: return promiseTag;
            case setCtorString: return setTag;
            case weakMapCtorString: return weakMapTag;
          }
        }
        return result;
      };
    }

    /**
     * Checks if `value` is a valid array-like index.
     *
     * @private
     * @param {*} value The value to check.
     * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
     * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
     */
    function isIndex(value, length) {
      length = length == null ? MAX_SAFE_INTEGER : length;
      return !!length &&
        (typeof value == 'number' || reIsUint.test(value)) &&
        (value > -1 && value % 1 == 0 && value < length);
    }

    /**
     * Checks if `func` has its source masked.
     *
     * @private
     * @param {Function} func The function to check.
     * @returns {boolean} Returns `true` if `func` is masked, else `false`.
     */
    function isMasked(func) {
      return !!maskSrcKey && (maskSrcKey in func);
    }

    /**
     * Checks if `value` is likely a prototype object.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
     */
    function isPrototype(value) {
      var Ctor = value && value.constructor,
          proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;

      return value === proto;
    }

    /**
     * Converts `func` to its source code.
     *
     * @private
     * @param {Function} func The function to process.
     * @returns {string} Returns the source code.
     */
    function toSource(func) {
      if (func != null) {
        try {
          return funcToString.call(func);
        } catch (e) {}
        try {
          return (func + '');
        } catch (e) {}
      }
      return '';
    }

    /**
     * Checks if `value` is likely an `arguments` object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
     *  else `false`.
     * @example
     *
     * _.isArguments(function() { return arguments; }());
     * // => true
     *
     * _.isArguments([1, 2, 3]);
     * // => false
     */
    function isArguments(value) {
      // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
      return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
        (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
    }

    /**
     * Checks if `value` is classified as an `Array` object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an array, else `false`.
     * @example
     *
     * _.isArray([1, 2, 3]);
     * // => true
     *
     * _.isArray(document.body.children);
     * // => false
     *
     * _.isArray('abc');
     * // => false
     *
     * _.isArray(_.noop);
     * // => false
     */
    var isArray = Array.isArray;

    /**
     * Checks if `value` is array-like. A value is considered array-like if it's
     * not a function and has a `value.length` that's an integer greater than or
     * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
     * @example
     *
     * _.isArrayLike([1, 2, 3]);
     * // => true
     *
     * _.isArrayLike(document.body.children);
     * // => true
     *
     * _.isArrayLike('abc');
     * // => true
     *
     * _.isArrayLike(_.noop);
     * // => false
     */
    function isArrayLike(value) {
      return value != null && isLength(value.length) && !isFunction(value);
    }

    /**
     * This method is like `_.isArrayLike` except that it also checks if `value`
     * is an object.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an array-like object,
     *  else `false`.
     * @example
     *
     * _.isArrayLikeObject([1, 2, 3]);
     * // => true
     *
     * _.isArrayLikeObject(document.body.children);
     * // => true
     *
     * _.isArrayLikeObject('abc');
     * // => false
     *
     * _.isArrayLikeObject(_.noop);
     * // => false
     */
    function isArrayLikeObject(value) {
      return isObjectLike(value) && isArrayLike(value);
    }

    /**
     * Checks if `value` is classified as a `Function` object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a function, else `false`.
     * @example
     *
     * _.isFunction(_);
     * // => true
     *
     * _.isFunction(/abc/);
     * // => false
     */
    function isFunction(value) {
      // The use of `Object#toString` avoids issues with the `typeof` operator
      // in Safari 8-9 which returns 'object' for typed array and other constructors.
      var tag = isObject(value) ? objectToString.call(value) : '';
      return tag == funcTag || tag == genTag;
    }

    /**
     * Checks if `value` is a valid array-like length.
     *
     * **Note:** This method is loosely based on
     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
     * @example
     *
     * _.isLength(3);
     * // => true
     *
     * _.isLength(Number.MIN_VALUE);
     * // => false
     *
     * _.isLength(Infinity);
     * // => false
     *
     * _.isLength('3');
     * // => false
     */
    function isLength(value) {
      return typeof value == 'number' &&
        value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
    }

    /**
     * Checks if `value` is the
     * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
     * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an object, else `false`.
     * @example
     *
     * _.isObject({});
     * // => true
     *
     * _.isObject([1, 2, 3]);
     * // => true
     *
     * _.isObject(_.noop);
     * // => true
     *
     * _.isObject(null);
     * // => false
     */
    function isObject(value) {
      var type = typeof value;
      return !!value && (type == 'object' || type == 'function');
    }

    /**
     * Checks if `value` is object-like. A value is object-like if it's not `null`
     * and has a `typeof` result of "object".
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
     * @example
     *
     * _.isObjectLike({});
     * // => true
     *
     * _.isObjectLike([1, 2, 3]);
     * // => true
     *
     * _.isObjectLike(_.noop);
     * // => false
     *
     * _.isObjectLike(null);
     * // => false
     */
    function isObjectLike(value) {
      return !!value && typeof value == 'object';
    }

    /**
     * Checks if `value` is classified as a `String` primitive or object.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a string, else `false`.
     * @example
     *
     * _.isString('abc');
     * // => true
     *
     * _.isString(1);
     * // => false
     */
    function isString(value) {
      return typeof value == 'string' ||
        (!isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag);
    }

    /**
     * Converts `value` to an array.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {Array} Returns the converted array.
     * @example
     *
     * _.toArray({ 'a': 1, 'b': 2 });
     * // => [1, 2]
     *
     * _.toArray('abc');
     * // => ['a', 'b', 'c']
     *
     * _.toArray(1);
     * // => []
     *
     * _.toArray(null);
     * // => []
     */
    function toArray(value) {
      if (!value) {
        return [];
      }
      if (isArrayLike(value)) {
        return isString(value) ? stringToArray(value) : copyArray(value);
      }
      if (iteratorSymbol && value[iteratorSymbol]) {
        return iteratorToArray(value[iteratorSymbol]());
      }
      var tag = getTag(value),
          func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);

      return func(value);
    }

    /**
     * Creates an array of the own enumerable property names of `object`.
     *
     * **Note:** Non-object values are coerced to objects. See the
     * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
     * for more details.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.keys(new Foo);
     * // => ['a', 'b'] (iteration order is not guaranteed)
     *
     * _.keys('hi');
     * // => ['0', '1']
     */
    function keys(object) {
      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
    }

    /**
     * Creates an array of the own enumerable string keyed property values of `object`.
     *
     * **Note:** Non-object values are coerced to objects.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property values.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.values(new Foo);
     * // => [1, 2] (iteration order is not guaranteed)
     *
     * _.values('hi');
     * // => ['h', 'i']
     */
    function values(object) {
      return object ? baseValues(object, keys(object)) : [];
    }

    var lodash_toarray = toArray;

    var umbrella_with_rain_drops = "☔";
    var coffee = "☕";
    var aries = "♈";
    var taurus = "♉";
    var sagittarius = "♐";
    var capricorn = "♑";
    var aquarius = "♒";
    var pisces = "♓";
    var anchor = "⚓";
    var white_check_mark = "✅";
    var sparkles = "✨";
    var question = "❓";
    var grey_question = "❔";
    var grey_exclamation = "❕";
    var exclamation = "❗";
    var heavy_exclamation_mark = "❗";
    var heavy_plus_sign = "➕";
    var heavy_minus_sign = "➖";
    var heavy_division_sign = "➗";
    var hash = "#️⃣";
    var keycap_star = "*️⃣";
    var zero = "0️⃣";
    var one = "1️⃣";
    var two = "2️⃣";
    var three = "3️⃣";
    var four = "4️⃣";
    var five = "5️⃣";
    var six = "6️⃣";
    var seven = "7️⃣";
    var eight = "8️⃣";
    var nine = "9️⃣";
    var copyright = "©️";
    var registered = "®️";
    var mahjong = "🀄";
    var black_joker = "🃏";
    var a = "🅰️";
    var b = "🅱️";
    var o2 = "🅾️";
    var parking = "🅿️";
    var ab = "🆎";
    var cl = "🆑";
    var cool = "🆒";
    var free = "🆓";
    var id = "🆔";
    var ng = "🆖";
    var ok = "🆗";
    var sos = "🆘";
    var up = "🆙";
    var vs = "🆚";
    var koko = "🈁";
    var sa = "🈂️";
    var u7121 = "🈚";
    var u6307 = "🈯";
    var u7981 = "🈲";
    var u7a7a = "🈳";
    var u5408 = "🈴";
    var u6e80 = "🈵";
    var u6709 = "🈶";
    var u6708 = "🈷️";
    var u7533 = "🈸";
    var u5272 = "🈹";
    var u55b6 = "🈺";
    var ideograph_advantage = "🉐";
    var accept = "🉑";
    var cyclone = "🌀";
    var foggy = "🌁";
    var closed_umbrella = "🌂";
    var night_with_stars = "🌃";
    var sunrise_over_mountains = "🌄";
    var sunrise = "🌅";
    var city_sunset = "🌆";
    var city_sunrise = "🌇";
    var rainbow = "🌈";
    var bridge_at_night = "🌉";
    var ocean = "🌊";
    var volcano = "🌋";
    var milky_way = "🌌";
    var earth_africa = "🌍";
    var earth_americas = "🌎";
    var earth_asia = "🌏";
    var globe_with_meridians = "🌐";
    var new_moon = "🌑";
    var waxing_crescent_moon = "🌒";
    var first_quarter_moon = "🌓";
    var moon = "🌔";
    var waxing_gibbous_moon = "🌔";
    var full_moon = "🌕";
    var waning_gibbous_moon = "🌖";
    var last_quarter_moon = "🌗";
    var waning_crescent_moon = "🌘";
    var crescent_moon = "🌙";
    var new_moon_with_face = "🌚";
    var first_quarter_moon_with_face = "🌛";
    var last_quarter_moon_with_face = "🌜";
    var full_moon_with_face = "🌝";
    var sun_with_face = "🌞";
    var star2 = "🌟";
    var stars = "🌠";
    var thermometer = "🌡️";
    var mostly_sunny = "🌤️";
    var sun_small_cloud = "🌤️";
    var barely_sunny = "🌥️";
    var sun_behind_cloud = "🌥️";
    var partly_sunny_rain = "🌦️";
    var sun_behind_rain_cloud = "🌦️";
    var rain_cloud = "🌧️";
    var snow_cloud = "🌨️";
    var lightning = "🌩️";
    var lightning_cloud = "🌩️";
    var tornado = "🌪️";
    var tornado_cloud = "🌪️";
    var fog = "🌫️";
    var wind_blowing_face = "🌬️";
    var hotdog = "🌭";
    var taco = "🌮";
    var burrito = "🌯";
    var chestnut = "🌰";
    var seedling = "🌱";
    var evergreen_tree = "🌲";
    var deciduous_tree = "🌳";
    var palm_tree = "🌴";
    var cactus = "🌵";
    var hot_pepper = "🌶️";
    var tulip = "🌷";
    var cherry_blossom = "🌸";
    var rose = "🌹";
    var hibiscus = "🌺";
    var sunflower = "🌻";
    var blossom = "🌼";
    var corn = "🌽";
    var ear_of_rice = "🌾";
    var herb = "🌿";
    var four_leaf_clover = "🍀";
    var maple_leaf = "🍁";
    var fallen_leaf = "🍂";
    var leaves = "🍃";
    var mushroom = "🍄";
    var tomato = "🍅";
    var eggplant = "🍆";
    var grapes = "🍇";
    var melon = "🍈";
    var watermelon = "🍉";
    var tangerine = "🍊";
    var lemon = "🍋";
    var banana = "🍌";
    var pineapple = "🍍";
    var apple = "🍎";
    var green_apple = "🍏";
    var pear = "🍐";
    var peach = "🍑";
    var cherries = "🍒";
    var strawberry = "🍓";
    var hamburger = "🍔";
    var pizza = "🍕";
    var meat_on_bone = "🍖";
    var poultry_leg = "🍗";
    var rice_cracker = "🍘";
    var rice_ball = "🍙";
    var rice = "🍚";
    var curry = "🍛";
    var ramen = "🍜";
    var spaghetti = "🍝";
    var bread = "🍞";
    var fries = "🍟";
    var sweet_potato = "🍠";
    var dango = "🍡";
    var oden = "🍢";
    var sushi = "🍣";
    var fried_shrimp = "🍤";
    var fish_cake = "🍥";
    var icecream = "🍦";
    var shaved_ice = "🍧";
    var ice_cream = "🍨";
    var doughnut = "🍩";
    var cookie = "🍪";
    var chocolate_bar = "🍫";
    var candy = "🍬";
    var lollipop = "🍭";
    var custard = "🍮";
    var honey_pot = "🍯";
    var cake = "🍰";
    var bento = "🍱";
    var stew = "🍲";
    var fried_egg = "🍳";
    var cooking = "🍳";
    var fork_and_knife = "🍴";
    var tea = "🍵";
    var sake = "🍶";
    var wine_glass = "🍷";
    var cocktail = "🍸";
    var tropical_drink = "🍹";
    var beer = "🍺";
    var beers = "🍻";
    var baby_bottle = "🍼";
    var knife_fork_plate = "🍽️";
    var champagne = "🍾";
    var popcorn = "🍿";
    var ribbon = "🎀";
    var gift = "🎁";
    var birthday = "🎂";
    var jack_o_lantern = "🎃";
    var christmas_tree = "🎄";
    var santa = "🎅";
    var fireworks = "🎆";
    var sparkler = "🎇";
    var balloon = "🎈";
    var tada = "🎉";
    var confetti_ball = "🎊";
    var tanabata_tree = "🎋";
    var crossed_flags = "🎌";
    var bamboo = "🎍";
    var dolls = "🎎";
    var flags = "🎏";
    var wind_chime = "🎐";
    var rice_scene = "🎑";
    var school_satchel = "🎒";
    var mortar_board = "🎓";
    var medal = "🎖️";
    var reminder_ribbon = "🎗️";
    var studio_microphone = "🎙️";
    var level_slider = "🎚️";
    var control_knobs = "🎛️";
    var film_frames = "🎞️";
    var admission_tickets = "🎟️";
    var carousel_horse = "🎠";
    var ferris_wheel = "🎡";
    var roller_coaster = "🎢";
    var fishing_pole_and_fish = "🎣";
    var microphone = "🎤";
    var movie_camera = "🎥";
    var cinema = "🎦";
    var headphones = "🎧";
    var art = "🎨";
    var tophat = "🎩";
    var circus_tent = "🎪";
    var ticket = "🎫";
    var clapper = "🎬";
    var performing_arts = "🎭";
    var video_game = "🎮";
    var dart = "🎯";
    var slot_machine = "🎰";
    var game_die = "🎲";
    var bowling = "🎳";
    var flower_playing_cards = "🎴";
    var musical_note = "🎵";
    var notes = "🎶";
    var saxophone = "🎷";
    var guitar = "🎸";
    var musical_keyboard = "🎹";
    var trumpet = "🎺";
    var violin = "🎻";
    var musical_score = "🎼";
    var running_shirt_with_sash = "🎽";
    var tennis = "🎾";
    var ski = "🎿";
    var basketball = "🏀";
    var checkered_flag = "🏁";
    var snowboarder = "🏂";
    var runner = "🏃‍♂️";
    var running = "🏃‍♂️";
    var surfer = "🏄‍♂️";
    var sports_medal = "🏅";
    var trophy = "🏆";
    var horse_racing = "🏇";
    var football = "🏈";
    var rugby_football = "🏉";
    var swimmer = "🏊‍♂️";
    var weight_lifter = "🏋️‍♂️";
    var golfer = "🏌️‍♂️";
    var racing_motorcycle = "🏍️";
    var racing_car = "🏎️";
    var cricket_bat_and_ball = "🏏";
    var volleyball = "🏐";
    var field_hockey_stick_and_ball = "🏑";
    var ice_hockey_stick_and_puck = "🏒";
    var table_tennis_paddle_and_ball = "🏓";
    var snow_capped_mountain = "🏔️";
    var camping = "🏕️";
    var beach_with_umbrella = "🏖️";
    var building_construction = "🏗️";
    var house_buildings = "🏘️";
    var cityscape = "🏙️";
    var derelict_house_building = "🏚️";
    var classical_building = "🏛️";
    var desert = "🏜️";
    var desert_island = "🏝️";
    var national_park = "🏞️";
    var stadium = "🏟️";
    var house = "🏠";
    var house_with_garden = "🏡";
    var office = "🏢";
    var post_office = "🏣";
    var european_post_office = "🏤";
    var hospital = "🏥";
    var bank = "🏦";
    var atm = "🏧";
    var hotel = "🏨";
    var love_hotel = "🏩";
    var convenience_store = "🏪";
    var school = "🏫";
    var department_store = "🏬";
    var factory = "🏭";
    var izakaya_lantern = "🏮";
    var lantern = "🏮";
    var japanese_castle = "🏯";
    var european_castle = "🏰";
    var waving_white_flag = "🏳️";
    var waving_black_flag = "🏴";
    var rosette = "🏵️";
    var label = "🏷️";
    var badminton_racquet_and_shuttlecock = "🏸";
    var bow_and_arrow = "🏹";
    var amphora = "🏺";
    var rat = "🐀";
    var mouse2 = "🐁";
    var ox = "🐂";
    var water_buffalo = "🐃";
    var cow2 = "🐄";
    var tiger2 = "🐅";
    var leopard = "🐆";
    var rabbit2 = "🐇";
    var cat2 = "🐈";
    var dragon = "🐉";
    var crocodile = "🐊";
    var whale2 = "🐋";
    var snail = "🐌";
    var snake = "🐍";
    var racehorse = "🐎";
    var ram = "🐏";
    var goat = "🐐";
    var sheep = "🐑";
    var monkey = "🐒";
    var rooster = "🐓";
    var chicken = "🐔";
    var dog2 = "🐕";
    var pig2 = "🐖";
    var boar = "🐗";
    var elephant = "🐘";
    var octopus = "🐙";
    var shell = "🐚";
    var bug = "🐛";
    var ant = "🐜";
    var bee = "🐝";
    var honeybee = "🐝";
    var beetle = "🐞";
    var fish = "🐟";
    var tropical_fish = "🐠";
    var blowfish = "🐡";
    var turtle = "🐢";
    var hatching_chick = "🐣";
    var baby_chick = "🐤";
    var hatched_chick = "🐥";
    var bird = "🐦";
    var penguin = "🐧";
    var koala = "🐨";
    var poodle = "🐩";
    var dromedary_camel = "🐪";
    var camel = "🐫";
    var dolphin = "🐬";
    var flipper = "🐬";
    var mouse = "🐭";
    var cow = "🐮";
    var tiger = "🐯";
    var rabbit = "🐰";
    var cat = "🐱";
    var dragon_face = "🐲";
    var whale = "🐳";
    var horse = "🐴";
    var monkey_face = "🐵";
    var dog = "🐶";
    var pig = "🐷";
    var frog = "🐸";
    var hamster = "🐹";
    var wolf = "🐺";
    var bear = "🐻";
    var panda_face = "🐼";
    var pig_nose = "🐽";
    var feet = "🐾";
    var paw_prints = "🐾";
    var chipmunk = "🐿️";
    var eyes = "👀";
    var eye = "👁️";
    var ear = "👂";
    var nose = "👃";
    var lips = "👄";
    var tongue = "👅";
    var point_up_2 = "👆";
    var point_down = "👇";
    var point_left = "👈";
    var point_right = "👉";
    var facepunch = "👊";
    var punch = "👊";
    var wave = "👋";
    var ok_hand = "👌";
    var thumbsup = "👍";
    var thumbsdown = "👎";
    var clap = "👏";
    var open_hands = "👐";
    var crown = "👑";
    var womans_hat = "👒";
    var eyeglasses = "👓";
    var necktie = "👔";
    var shirt = "👕";
    var tshirt = "👕";
    var jeans = "👖";
    var dress = "👗";
    var kimono = "👘";
    var bikini = "👙";
    var womans_clothes = "👚";
    var purse = "👛";
    var handbag = "👜";
    var pouch = "👝";
    var mans_shoe = "👞";
    var shoe = "👞";
    var athletic_shoe = "👟";
    var high_heel = "👠";
    var sandal = "👡";
    var boot = "👢";
    var footprints = "👣";
    var bust_in_silhouette = "👤";
    var busts_in_silhouette = "👥";
    var boy = "👦";
    var girl = "👧";
    var family = "👨‍👩‍👦";
    var man = "👨";
    var couple_with_heart = "👩‍❤️‍👨";
    var couplekiss = "👩‍❤️‍💋‍👨";
    var woman = "👩";
    var couple = "👫";
    var man_and_woman_holding_hands = "👫";
    var two_men_holding_hands = "👬";
    var two_women_holding_hands = "👭";
    var cop = "👮‍♂️";
    var dancers = "👯‍♀️";
    var bride_with_veil = "👰";
    var person_with_blond_hair = "👱‍♂️";
    var man_with_gua_pi_mao = "👲";
    var man_with_turban = "👳‍♂️";
    var older_man = "👴";
    var older_woman = "👵";
    var baby = "👶";
    var construction_worker = "👷‍♂️";
    var princess = "👸";
    var japanese_ogre = "👹";
    var japanese_goblin = "👺";
    var ghost = "👻";
    var angel = "👼";
    var alien = "👽";
    var space_invader = "👾";
    var imp = "👿";
    var skull = "💀";
    var information_desk_person = "💁‍♀️";
    var guardsman = "💂‍♂️";
    var dancer = "💃";
    var lipstick = "💄";
    var nail_care = "💅";
    var massage = "💆‍♀️";
    var haircut = "💇‍♀️";
    var barber = "💈";
    var syringe = "💉";
    var pill = "💊";
    var kiss = "💋";
    var love_letter = "💌";
    var ring = "💍";
    var gem = "💎";
    var bouquet = "💐";
    var wedding = "💒";
    var heartbeat = "💓";
    var broken_heart = "💔";
    var two_hearts = "💕";
    var sparkling_heart = "💖";
    var heartpulse = "💗";
    var cupid = "💘";
    var blue_heart = "💙";
    var green_heart = "💚";
    var yellow_heart = "💛";
    var purple_heart = "💜";
    var gift_heart = "💝";
    var revolving_hearts = "💞";
    var heart_decoration = "💟";
    var diamond_shape_with_a_dot_inside = "💠";
    var bulb = "💡";
    var anger = "💢";
    var bomb = "💣";
    var zzz = "💤";
    var boom = "💥";
    var collision = "💥";
    var sweat_drops = "💦";
    var droplet = "💧";
    var dash = "💨";
    var poop = "💩";
    var muscle = "💪";
    var dizzy = "💫";
    var speech_balloon = "💬";
    var thought_balloon = "💭";
    var white_flower = "💮";
    var moneybag = "💰";
    var currency_exchange = "💱";
    var heavy_dollar_sign = "💲";
    var credit_card = "💳";
    var yen = "💴";
    var dollar = "💵";
    var euro = "💶";
    var pound = "💷";
    var money_with_wings = "💸";
    var chart = "💹";
    var seat = "💺";
    var computer = "💻";
    var briefcase = "💼";
    var minidisc = "💽";
    var floppy_disk = "💾";
    var cd = "💿";
    var dvd = "📀";
    var file_folder = "📁";
    var open_file_folder = "📂";
    var page_with_curl = "📃";
    var page_facing_up = "📄";
    var date = "📅";
    var calendar = "📆";
    var card_index = "📇";
    var chart_with_upwards_trend = "📈";
    var chart_with_downwards_trend = "📉";
    var bar_chart = "📊";
    var clipboard = "📋";
    var pushpin = "📌";
    var round_pushpin = "📍";
    var paperclip = "📎";
    var straight_ruler = "📏";
    var triangular_ruler = "📐";
    var bookmark_tabs = "📑";
    var ledger = "📒";
    var notebook = "📓";
    var notebook_with_decorative_cover = "📔";
    var closed_book = "📕";
    var book = "📖";
    var open_book = "📖";
    var green_book = "📗";
    var blue_book = "📘";
    var orange_book = "📙";
    var books = "📚";
    var name_badge = "📛";
    var scroll = "📜";
    var memo = "📝";
    var pencil = "📝";
    var telephone_receiver = "📞";
    var pager = "📟";
    var fax = "📠";
    var satellite_antenna = "📡";
    var loudspeaker = "📢";
    var mega = "📣";
    var outbox_tray = "📤";
    var inbox_tray = "📥";
    var incoming_envelope = "📨";
    var envelope_with_arrow = "📩";
    var mailbox_closed = "📪";
    var mailbox = "📫";
    var mailbox_with_mail = "📬";
    var mailbox_with_no_mail = "📭";
    var postbox = "📮";
    var postal_horn = "📯";
    var newspaper = "📰";
    var iphone = "📱";
    var calling = "📲";
    var vibration_mode = "📳";
    var mobile_phone_off = "📴";
    var no_mobile_phones = "📵";
    var signal_strength = "📶";
    var camera = "📷";
    var camera_with_flash = "📸";
    var video_camera = "📹";
    var tv = "📺";
    var radio = "📻";
    var vhs = "📼";
    var film_projector = "📽️";
    var prayer_beads = "📿";
    var twisted_rightwards_arrows = "🔀";
    var repeat = "🔁";
    var repeat_one = "🔂";
    var arrows_clockwise = "🔃";
    var arrows_counterclockwise = "🔄";
    var low_brightness = "🔅";
    var high_brightness = "🔆";
    var mute = "🔇";
    var speaker = "🔈";
    var sound = "🔉";
    var loud_sound = "🔊";
    var battery = "🔋";
    var electric_plug = "🔌";
    var mag = "🔍";
    var mag_right = "🔎";
    var lock_with_ink_pen = "🔏";
    var closed_lock_with_key = "🔐";
    var key = "🔑";
    var lock = "🔒";
    var unlock = "🔓";
    var bell = "🔔";
    var no_bell = "🔕";
    var bookmark = "🔖";
    var link = "🔗";
    var radio_button = "🔘";
    var back = "🔙";
    var end = "🔚";
    var on = "🔛";
    var soon = "🔜";
    var underage = "🔞";
    var keycap_ten = "🔟";
    var capital_abcd = "🔠";
    var abcd = "🔡";
    var symbols = "🔣";
    var abc = "🔤";
    var fire = "🔥";
    var flashlight = "🔦";
    var wrench = "🔧";
    var hammer = "🔨";
    var nut_and_bolt = "🔩";
    var hocho = "🔪";
    var knife = "🔪";
    var gun = "🔫";
    var microscope = "🔬";
    var telescope = "🔭";
    var crystal_ball = "🔮";
    var six_pointed_star = "🔯";
    var beginner = "🔰";
    var trident = "🔱";
    var black_square_button = "🔲";
    var white_square_button = "🔳";
    var red_circle = "🔴";
    var large_blue_circle = "🔵";
    var large_orange_diamond = "🔶";
    var large_blue_diamond = "🔷";
    var small_orange_diamond = "🔸";
    var small_blue_diamond = "🔹";
    var small_red_triangle = "🔺";
    var small_red_triangle_down = "🔻";
    var arrow_up_small = "🔼";
    var arrow_down_small = "🔽";
    var om_symbol = "🕉️";
    var dove_of_peace = "🕊️";
    var kaaba = "🕋";
    var mosque = "🕌";
    var synagogue = "🕍";
    var menorah_with_nine_branches = "🕎";
    var candle = "🕯️";
    var mantelpiece_clock = "🕰️";
    var hole = "🕳️";
    var man_in_business_suit_levitating = "🕴️";
    var sleuth_or_spy = "🕵️‍♂️";
    var dark_sunglasses = "🕶️";
    var spider = "🕷️";
    var spider_web = "🕸️";
    var joystick = "🕹️";
    var man_dancing = "🕺";
    var linked_paperclips = "🖇️";
    var lower_left_ballpoint_pen = "🖊️";
    var lower_left_fountain_pen = "🖋️";
    var lower_left_paintbrush = "🖌️";
    var lower_left_crayon = "🖍️";
    var raised_hand_with_fingers_splayed = "🖐️";
    var middle_finger = "🖕";
    var reversed_hand_with_middle_finger_extended = "🖕";
    var black_heart = "🖤";
    var desktop_computer = "🖥️";
    var printer = "🖨️";
    var three_button_mouse = "🖱️";
    var trackball = "🖲️";
    var frame_with_picture = "🖼️";
    var card_index_dividers = "🗂️";
    var card_file_box = "🗃️";
    var file_cabinet = "🗄️";
    var wastebasket = "🗑️";
    var spiral_note_pad = "🗒️";
    var spiral_calendar_pad = "🗓️";
    var compression = "🗜️";
    var old_key = "🗝️";
    var rolled_up_newspaper = "🗞️";
    var dagger_knife = "🗡️";
    var speaking_head_in_silhouette = "🗣️";
    var left_speech_bubble = "🗨️";
    var right_anger_bubble = "🗯️";
    var ballot_box_with_ballot = "🗳️";
    var world_map = "🗺️";
    var mount_fuji = "🗻";
    var tokyo_tower = "🗼";
    var statue_of_liberty = "🗽";
    var japan = "🗾";
    var moyai = "🗿";
    var grinning = "😀";
    var grin = "😁";
    var joy = "😂";
    var smiley = "😃";
    var smile = "😄";
    var sweat_smile = "😅";
    var laughing = "😆";
    var satisfied = "😆";
    var innocent = "😇";
    var smiling_imp = "😈";
    var wink = "😉";
    var blush = "😊";
    var yum = "😋";
    var relieved = "😌";
    var heart_eyes = "😍";
    var sunglasses = "😎";
    var smirk = "😏";
    var neutral_face = "😐";
    var expressionless = "😑";
    var unamused = "😒";
    var sweat = "😓";
    var pensive = "😔";
    var confused = "😕";
    var confounded = "😖";
    var kissing = "😗";
    var kissing_heart = "😘";
    var kissing_smiling_eyes = "😙";
    var kissing_closed_eyes = "😚";
    var stuck_out_tongue = "😛";
    var stuck_out_tongue_winking_eye = "😜";
    var stuck_out_tongue_closed_eyes = "😝";
    var disappointed = "😞";
    var worried = "😟";
    var angry = "😠";
    var rage = "😡";
    var cry = "😢";
    var persevere = "😣";
    var triumph = "😤";
    var disappointed_relieved = "😥";
    var frowning = "😦";
    var anguished = "😧";
    var fearful = "😨";
    var weary = "😩";
    var sleepy = "😪";
    var tired_face = "😫";
    var grimacing = "😬";
    var sob = "😭";
    var open_mouth = "😮";
    var hushed = "😯";
    var cold_sweat = "😰";
    var scream = "😱";
    var astonished = "😲";
    var flushed = "😳";
    var sleeping = "😴";
    var dizzy_face = "😵";
    var no_mouth = "😶";
    var mask = "😷";
    var smile_cat = "😸";
    var joy_cat = "😹";
    var smiley_cat = "😺";
    var heart_eyes_cat = "😻";
    var smirk_cat = "😼";
    var kissing_cat = "😽";
    var pouting_cat = "😾";
    var crying_cat_face = "😿";
    var scream_cat = "🙀";
    var slightly_frowning_face = "🙁";
    var slightly_smiling_face = "🙂";
    var upside_down_face = "🙃";
    var face_with_rolling_eyes = "🙄";
    var no_good = "🙅‍♀️";
    var ok_woman = "🙆‍♀️";
    var bow = "🙇‍♂️";
    var see_no_evil = "🙈";
    var hear_no_evil = "🙉";
    var speak_no_evil = "🙊";
    var raising_hand = "🙋‍♀️";
    var raised_hands = "🙌";
    var person_frowning = "🙍‍♀️";
    var person_with_pouting_face = "🙎‍♀️";
    var pray = "🙏";
    var rocket = "🚀";
    var helicopter = "🚁";
    var steam_locomotive = "🚂";
    var railway_car = "🚃";
    var bullettrain_side = "🚄";
    var bullettrain_front = "🚅";
    var train2 = "🚆";
    var metro = "🚇";
    var light_rail = "🚈";
    var station = "🚉";
    var tram = "🚊";
    var train = "🚋";
    var bus = "🚌";
    var oncoming_bus = "🚍";
    var trolleybus = "🚎";
    var busstop = "🚏";
    var minibus = "🚐";
    var ambulance = "🚑";
    var fire_engine = "🚒";
    var police_car = "🚓";
    var oncoming_police_car = "🚔";
    var taxi = "🚕";
    var oncoming_taxi = "🚖";
    var car = "🚗";
    var red_car = "🚗";
    var oncoming_automobile = "🚘";
    var blue_car = "🚙";
    var truck = "🚚";
    var articulated_lorry = "🚛";
    var tractor = "🚜";
    var monorail = "🚝";
    var mountain_railway = "🚞";
    var suspension_railway = "🚟";
    var mountain_cableway = "🚠";
    var aerial_tramway = "🚡";
    var ship = "🚢";
    var rowboat = "🚣‍♂️";
    var speedboat = "🚤";
    var traffic_light = "🚥";
    var vertical_traffic_light = "🚦";
    var construction = "🚧";
    var rotating_light = "🚨";
    var triangular_flag_on_post = "🚩";
    var door = "🚪";
    var no_entry_sign = "🚫";
    var smoking = "🚬";
    var no_smoking = "🚭";
    var put_litter_in_its_place = "🚮";
    var do_not_litter = "🚯";
    var potable_water = "🚰";
    var bike = "🚲";
    var no_bicycles = "🚳";
    var bicyclist = "🚴‍♂️";
    var mountain_bicyclist = "🚵‍♂️";
    var walking = "🚶‍♂️";
    var no_pedestrians = "🚷";
    var children_crossing = "🚸";
    var mens = "🚹";
    var womens = "🚺";
    var restroom = "🚻";
    var baby_symbol = "🚼";
    var toilet = "🚽";
    var wc = "🚾";
    var shower = "🚿";
    var bath = "🛀";
    var bathtub = "🛁";
    var passport_control = "🛂";
    var customs = "🛃";
    var baggage_claim = "🛄";
    var left_luggage = "🛅";
    var couch_and_lamp = "🛋️";
    var sleeping_accommodation = "🛌";
    var shopping_bags = "🛍️";
    var bellhop_bell = "🛎️";
    var bed = "🛏️";
    var place_of_worship = "🛐";
    var octagonal_sign = "🛑";
    var shopping_trolley = "🛒";
    var hammer_and_wrench = "🛠️";
    var shield = "🛡️";
    var oil_drum = "🛢️";
    var motorway = "🛣️";
    var railway_track = "🛤️";
    var motor_boat = "🛥️";
    var small_airplane = "🛩️";
    var airplane_departure = "🛫";
    var airplane_arriving = "🛬";
    var satellite = "🛰️";
    var passenger_ship = "🛳️";
    var scooter = "🛴";
    var motor_scooter = "🛵";
    var canoe = "🛶";
    var sled = "🛷";
    var flying_saucer = "🛸";
    var zipper_mouth_face = "🤐";
    var money_mouth_face = "🤑";
    var face_with_thermometer = "🤒";
    var nerd_face = "🤓";
    var thinking_face = "🤔";
    var face_with_head_bandage = "🤕";
    var robot_face = "🤖";
    var hugging_face = "🤗";
    var the_horns = "🤘";
    var sign_of_the_horns = "🤘";
    var call_me_hand = "🤙";
    var raised_back_of_hand = "🤚";
    var handshake = "🤝";
    var crossed_fingers = "🤞";
    var hand_with_index_and_middle_fingers_crossed = "🤞";
    var i_love_you_hand_sign = "🤟";
    var face_with_cowboy_hat = "🤠";
    var clown_face = "🤡";
    var nauseated_face = "🤢";
    var rolling_on_the_floor_laughing = "🤣";
    var drooling_face = "🤤";
    var lying_face = "🤥";
    var face_palm = "🤦";
    var sneezing_face = "🤧";
    var face_with_raised_eyebrow = "🤨";
    var face_with_one_eyebrow_raised = "🤨";
    var grinning_face_with_star_eyes = "🤩";
    var zany_face = "🤪";
    var grinning_face_with_one_large_and_one_small_eye = "🤪";
    var shushing_face = "🤫";
    var face_with_finger_covering_closed_lips = "🤫";
    var face_with_symbols_on_mouth = "🤬";
    var serious_face_with_symbols_covering_mouth = "🤬";
    var face_with_hand_over_mouth = "🤭";
    var smiling_face_with_smiling_eyes_and_hand_covering_mouth = "🤭";
    var face_vomiting = "🤮";
    var face_with_open_mouth_vomiting = "🤮";
    var exploding_head = "🤯";
    var shocked_face_with_exploding_head = "🤯";
    var pregnant_woman = "🤰";
    var palms_up_together = "🤲";
    var selfie = "🤳";
    var prince = "🤴";
    var man_in_tuxedo = "🤵";
    var mrs_claus = "🤶";
    var mother_christmas = "🤶";
    var shrug = "🤷";
    var person_doing_cartwheel = "🤸";
    var juggling = "🤹";
    var fencer = "🤺";
    var wrestlers = "🤼";
    var water_polo = "🤽";
    var handball = "🤾";
    var wilted_flower = "🥀";
    var drum_with_drumsticks = "🥁";
    var clinking_glasses = "🥂";
    var tumbler_glass = "🥃";
    var spoon = "🥄";
    var goal_net = "🥅";
    var first_place_medal = "🥇";
    var second_place_medal = "🥈";
    var third_place_medal = "🥉";
    var boxing_glove = "🥊";
    var martial_arts_uniform = "🥋";
    var curling_stone = "🥌";
    var croissant = "🥐";
    var avocado = "🥑";
    var cucumber = "🥒";
    var bacon = "🥓";
    var potato = "🥔";
    var carrot = "🥕";
    var baguette_bread = "🥖";
    var green_salad = "🥗";
    var shallow_pan_of_food = "🥘";
    var stuffed_flatbread = "🥙";
    var egg = "🥚";
    var glass_of_milk = "🥛";
    var peanuts = "🥜";
    var kiwifruit = "🥝";
    var pancakes = "🥞";
    var dumpling = "🥟";
    var fortune_cookie = "🥠";
    var takeout_box = "🥡";
    var chopsticks = "🥢";
    var bowl_with_spoon = "🥣";
    var cup_with_straw = "🥤";
    var coconut = "🥥";
    var broccoli = "🥦";
    var pie = "🥧";
    var pretzel = "🥨";
    var cut_of_meat = "🥩";
    var sandwich = "🥪";
    var canned_food = "🥫";
    var crab = "🦀";
    var lion_face = "🦁";
    var scorpion = "🦂";
    var turkey = "🦃";
    var unicorn_face = "🦄";
    var eagle = "🦅";
    var duck = "🦆";
    var bat = "🦇";
    var shark = "🦈";
    var owl = "🦉";
    var fox_face = "🦊";
    var butterfly = "🦋";
    var deer = "🦌";
    var gorilla = "🦍";
    var lizard = "🦎";
    var rhinoceros = "🦏";
    var shrimp = "🦐";
    var squid = "🦑";
    var giraffe_face = "🦒";
    var zebra_face = "🦓";
    var hedgehog = "🦔";
    var sauropod = "🦕";
    var cricket = "🦗";
    var cheese_wedge = "🧀";
    var face_with_monocle = "🧐";
    var adult = "🧑";
    var child = "🧒";
    var older_adult = "🧓";
    var bearded_person = "🧔";
    var person_with_headscarf = "🧕";
    var woman_in_steamy_room = "🧖‍♀️";
    var man_in_steamy_room = "🧖‍♂️";
    var person_in_steamy_room = "🧖‍♂️";
    var woman_climbing = "🧗‍♀️";
    var person_climbing = "🧗‍♀️";
    var man_climbing = "🧗‍♂️";
    var woman_in_lotus_position = "🧘‍♀️";
    var person_in_lotus_position = "🧘‍♀️";
    var man_in_lotus_position = "🧘‍♂️";
    var female_mage = "🧙‍♀️";
    var mage = "🧙‍♀️";
    var male_mage = "🧙‍♂️";
    var female_fairy = "🧚‍♀️";
    var fairy = "🧚‍♀️";
    var male_fairy = "🧚‍♂️";
    var female_vampire = "🧛‍♀️";
    var vampire = "🧛‍♀️";
    var male_vampire = "🧛‍♂️";
    var mermaid = "🧜‍♀️";
    var merman = "🧜‍♂️";
    var merperson = "🧜‍♂️";
    var female_elf = "🧝‍♀️";
    var male_elf = "🧝‍♂️";
    var elf = "🧝‍♂️";
    var female_genie = "🧞‍♀️";
    var male_genie = "🧞‍♂️";
    var genie = "🧞‍♂️";
    var female_zombie = "🧟‍♀️";
    var male_zombie = "🧟‍♂️";
    var zombie = "🧟‍♂️";
    var brain = "🧠";
    var orange_heart = "🧡";
    var billed_cap = "🧢";
    var scarf = "🧣";
    var gloves = "🧤";
    var coat = "🧥";
    var socks = "🧦";
    var bangbang = "‼️";
    var interrobang = "⁉️";
    var tm = "™️";
    var information_source = "ℹ️";
    var left_right_arrow = "↔️";
    var arrow_up_down = "↕️";
    var arrow_upper_left = "↖️";
    var arrow_upper_right = "↗️";
    var arrow_lower_right = "↘️";
    var arrow_lower_left = "↙️";
    var leftwards_arrow_with_hook = "↩️";
    var arrow_right_hook = "↪️";
    var watch = "⌚";
    var hourglass = "⌛";
    var keyboard = "⌨️";
    var eject = "⏏️";
    var fast_forward = "⏩";
    var rewind = "⏪";
    var arrow_double_up = "⏫";
    var arrow_double_down = "⏬";
    var black_right_pointing_double_triangle_with_vertical_bar = "⏭️";
    var black_left_pointing_double_triangle_with_vertical_bar = "⏮️";
    var black_right_pointing_triangle_with_double_vertical_bar = "⏯️";
    var alarm_clock = "⏰";
    var stopwatch = "⏱️";
    var timer_clock = "⏲️";
    var hourglass_flowing_sand = "⏳";
    var double_vertical_bar = "⏸️";
    var black_square_for_stop = "⏹️";
    var black_circle_for_record = "⏺️";
    var m = "Ⓜ️";
    var black_small_square = "▪️";
    var white_small_square = "▫️";
    var arrow_forward = "▶️";
    var arrow_backward = "◀️";
    var white_medium_square = "◻️";
    var black_medium_square = "◼️";
    var white_medium_small_square = "◽";
    var black_medium_small_square = "◾";
    var sunny = "☀️";
    var cloud = "☁️";
    var umbrella = "☂️";
    var snowman = "☃️";
    var comet = "☄️";
    var phone = "☎️";
    var telephone = "☎️";
    var ballot_box_with_check = "☑️";
    var shamrock = "☘️";
    var point_up = "☝️";
    var skull_and_crossbones = "☠️";
    var radioactive_sign = "☢️";
    var biohazard_sign = "☣️";
    var orthodox_cross = "☦️";
    var star_and_crescent = "☪️";
    var peace_symbol = "☮️";
    var yin_yang = "☯️";
    var wheel_of_dharma = "☸️";
    var white_frowning_face = "☹️";
    var relaxed = "☺️";
    var female_sign = "♀️";
    var male_sign = "♂️";
    var gemini = "♊";
    var cancer = "♋";
    var leo = "♌";
    var virgo = "♍";
    var libra = "♎";
    var scorpius = "♏";
    var spades = "♠️";
    var clubs = "♣️";
    var hearts = "♥️";
    var diamonds = "♦️";
    var hotsprings = "♨️";
    var recycle = "♻️";
    var wheelchair = "♿";
    var hammer_and_pick = "⚒️";
    var crossed_swords = "⚔️";
    var medical_symbol = "⚕️";
    var staff_of_aesculapius = "⚕️";
    var scales = "⚖️";
    var alembic = "⚗️";
    var gear = "⚙️";
    var atom_symbol = "⚛️";
    var fleur_de_lis = "⚜️";
    var warning = "⚠️";
    var zap = "⚡";
    var white_circle = "⚪";
    var black_circle = "⚫";
    var coffin = "⚰️";
    var funeral_urn = "⚱️";
    var soccer = "⚽";
    var baseball = "⚾";
    var snowman_without_snow = "⛄";
    var partly_sunny = "⛅";
    var thunder_cloud_and_rain = "⛈️";
    var ophiuchus = "⛎";
    var pick = "⛏️";
    var helmet_with_white_cross = "⛑️";
    var chains = "⛓️";
    var no_entry = "⛔";
    var shinto_shrine = "⛩️";
    var church = "⛪";
    var mountain = "⛰️";
    var umbrella_on_ground = "⛱️";
    var fountain = "⛲";
    var golf = "⛳";
    var ferry = "⛴️";
    var boat = "⛵";
    var sailboat = "⛵";
    var skier = "⛷️";
    var ice_skate = "⛸️";
    var person_with_ball = "⛹️‍♂️";
    var tent = "⛺";
    var fuelpump = "⛽";
    var scissors = "✂️";
    var airplane = "✈️";
    var email = "✉️";
    var envelope = "✉️";
    var fist = "✊";
    var hand = "✋";
    var raised_hand = "✋";
    var v = "✌️";
    var writing_hand = "✍️";
    var pencil2 = "✏️";
    var black_nib = "✒️";
    var heavy_check_mark = "✔️";
    var heavy_multiplication_x = "✖️";
    var latin_cross = "✝️";
    var star_of_david = "✡️";
    var eight_spoked_asterisk = "✳️";
    var eight_pointed_black_star = "✴️";
    var snowflake = "❄️";
    var sparkle = "❇️";
    var x = "❌";
    var negative_squared_cross_mark = "❎";
    var heavy_heart_exclamation_mark_ornament = "❣️";
    var heart = "❤️";
    var arrow_right = "➡️";
    var curly_loop = "➰";
    var loop = "➿";
    var arrow_heading_up = "⤴️";
    var arrow_heading_down = "⤵️";
    var arrow_left = "⬅️";
    var arrow_up = "⬆️";
    var arrow_down = "⬇️";
    var black_large_square = "⬛";
    var white_large_square = "⬜";
    var star = "⭐";
    var o = "⭕";
    var wavy_dash = "〰️";
    var part_alternation_mark = "〽️";
    var congratulations = "㊗️";
    var secret = "㊙️";
    var emoji = {
    	"100": "💯",
    	"1234": "🔢",
    	umbrella_with_rain_drops: umbrella_with_rain_drops,
    	coffee: coffee,
    	aries: aries,
    	taurus: taurus,
    	sagittarius: sagittarius,
    	capricorn: capricorn,
    	aquarius: aquarius,
    	pisces: pisces,
    	anchor: anchor,
    	white_check_mark: white_check_mark,
    	sparkles: sparkles,
    	question: question,
    	grey_question: grey_question,
    	grey_exclamation: grey_exclamation,
    	exclamation: exclamation,
    	heavy_exclamation_mark: heavy_exclamation_mark,
    	heavy_plus_sign: heavy_plus_sign,
    	heavy_minus_sign: heavy_minus_sign,
    	heavy_division_sign: heavy_division_sign,
    	hash: hash,
    	keycap_star: keycap_star,
    	zero: zero,
    	one: one,
    	two: two,
    	three: three,
    	four: four,
    	five: five,
    	six: six,
    	seven: seven,
    	eight: eight,
    	nine: nine,
    	copyright: copyright,
    	registered: registered,
    	mahjong: mahjong,
    	black_joker: black_joker,
    	a: a,
    	b: b,
    	o2: o2,
    	parking: parking,
    	ab: ab,
    	cl: cl,
    	cool: cool,
    	free: free,
    	id: id,
    	"new": "🆕",
    	ng: ng,
    	ok: ok,
    	sos: sos,
    	up: up,
    	vs: vs,
    	koko: koko,
    	sa: sa,
    	u7121: u7121,
    	u6307: u6307,
    	u7981: u7981,
    	u7a7a: u7a7a,
    	u5408: u5408,
    	u6e80: u6e80,
    	u6709: u6709,
    	u6708: u6708,
    	u7533: u7533,
    	u5272: u5272,
    	u55b6: u55b6,
    	ideograph_advantage: ideograph_advantage,
    	accept: accept,
    	cyclone: cyclone,
    	foggy: foggy,
    	closed_umbrella: closed_umbrella,
    	night_with_stars: night_with_stars,
    	sunrise_over_mountains: sunrise_over_mountains,
    	sunrise: sunrise,
    	city_sunset: city_sunset,
    	city_sunrise: city_sunrise,
    	rainbow: rainbow,
    	bridge_at_night: bridge_at_night,
    	ocean: ocean,
    	volcano: volcano,
    	milky_way: milky_way,
    	earth_africa: earth_africa,
    	earth_americas: earth_americas,
    	earth_asia: earth_asia,
    	globe_with_meridians: globe_with_meridians,
    	new_moon: new_moon,
    	waxing_crescent_moon: waxing_crescent_moon,
    	first_quarter_moon: first_quarter_moon,
    	moon: moon,
    	waxing_gibbous_moon: waxing_gibbous_moon,
    	full_moon: full_moon,
    	waning_gibbous_moon: waning_gibbous_moon,
    	last_quarter_moon: last_quarter_moon,
    	waning_crescent_moon: waning_crescent_moon,
    	crescent_moon: crescent_moon,
    	new_moon_with_face: new_moon_with_face,
    	first_quarter_moon_with_face: first_quarter_moon_with_face,
    	last_quarter_moon_with_face: last_quarter_moon_with_face,
    	full_moon_with_face: full_moon_with_face,
    	sun_with_face: sun_with_face,
    	star2: star2,
    	stars: stars,
    	thermometer: thermometer,
    	mostly_sunny: mostly_sunny,
    	sun_small_cloud: sun_small_cloud,
    	barely_sunny: barely_sunny,
    	sun_behind_cloud: sun_behind_cloud,
    	partly_sunny_rain: partly_sunny_rain,
    	sun_behind_rain_cloud: sun_behind_rain_cloud,
    	rain_cloud: rain_cloud,
    	snow_cloud: snow_cloud,
    	lightning: lightning,
    	lightning_cloud: lightning_cloud,
    	tornado: tornado,
    	tornado_cloud: tornado_cloud,
    	fog: fog,
    	wind_blowing_face: wind_blowing_face,
    	hotdog: hotdog,
    	taco: taco,
    	burrito: burrito,
    	chestnut: chestnut,
    	seedling: seedling,
    	evergreen_tree: evergreen_tree,
    	deciduous_tree: deciduous_tree,
    	palm_tree: palm_tree,
    	cactus: cactus,
    	hot_pepper: hot_pepper,
    	tulip: tulip,
    	cherry_blossom: cherry_blossom,
    	rose: rose,
    	hibiscus: hibiscus,
    	sunflower: sunflower,
    	blossom: blossom,
    	corn: corn,
    	ear_of_rice: ear_of_rice,
    	herb: herb,
    	four_leaf_clover: four_leaf_clover,
    	maple_leaf: maple_leaf,
    	fallen_leaf: fallen_leaf,
    	leaves: leaves,
    	mushroom: mushroom,
    	tomato: tomato,
    	eggplant: eggplant,
    	grapes: grapes,
    	melon: melon,
    	watermelon: watermelon,
    	tangerine: tangerine,
    	lemon: lemon,
    	banana: banana,
    	pineapple: pineapple,
    	apple: apple,
    	green_apple: green_apple,
    	pear: pear,
    	peach: peach,
    	cherries: cherries,
    	strawberry: strawberry,
    	hamburger: hamburger,
    	pizza: pizza,
    	meat_on_bone: meat_on_bone,
    	poultry_leg: poultry_leg,
    	rice_cracker: rice_cracker,
    	rice_ball: rice_ball,
    	rice: rice,
    	curry: curry,
    	ramen: ramen,
    	spaghetti: spaghetti,
    	bread: bread,
    	fries: fries,
    	sweet_potato: sweet_potato,
    	dango: dango,
    	oden: oden,
    	sushi: sushi,
    	fried_shrimp: fried_shrimp,
    	fish_cake: fish_cake,
    	icecream: icecream,
    	shaved_ice: shaved_ice,
    	ice_cream: ice_cream,
    	doughnut: doughnut,
    	cookie: cookie,
    	chocolate_bar: chocolate_bar,
    	candy: candy,
    	lollipop: lollipop,
    	custard: custard,
    	honey_pot: honey_pot,
    	cake: cake,
    	bento: bento,
    	stew: stew,
    	fried_egg: fried_egg,
    	cooking: cooking,
    	fork_and_knife: fork_and_knife,
    	tea: tea,
    	sake: sake,
    	wine_glass: wine_glass,
    	cocktail: cocktail,
    	tropical_drink: tropical_drink,
    	beer: beer,
    	beers: beers,
    	baby_bottle: baby_bottle,
    	knife_fork_plate: knife_fork_plate,
    	champagne: champagne,
    	popcorn: popcorn,
    	ribbon: ribbon,
    	gift: gift,
    	birthday: birthday,
    	jack_o_lantern: jack_o_lantern,
    	christmas_tree: christmas_tree,
    	santa: santa,
    	fireworks: fireworks,
    	sparkler: sparkler,
    	balloon: balloon,
    	tada: tada,
    	confetti_ball: confetti_ball,
    	tanabata_tree: tanabata_tree,
    	crossed_flags: crossed_flags,
    	bamboo: bamboo,
    	dolls: dolls,
    	flags: flags,
    	wind_chime: wind_chime,
    	rice_scene: rice_scene,
    	school_satchel: school_satchel,
    	mortar_board: mortar_board,
    	medal: medal,
    	reminder_ribbon: reminder_ribbon,
    	studio_microphone: studio_microphone,
    	level_slider: level_slider,
    	control_knobs: control_knobs,
    	film_frames: film_frames,
    	admission_tickets: admission_tickets,
    	carousel_horse: carousel_horse,
    	ferris_wheel: ferris_wheel,
    	roller_coaster: roller_coaster,
    	fishing_pole_and_fish: fishing_pole_and_fish,
    	microphone: microphone,
    	movie_camera: movie_camera,
    	cinema: cinema,
    	headphones: headphones,
    	art: art,
    	tophat: tophat,
    	circus_tent: circus_tent,
    	ticket: ticket,
    	clapper: clapper,
    	performing_arts: performing_arts,
    	video_game: video_game,
    	dart: dart,
    	slot_machine: slot_machine,
    	"8ball": "🎱",
    	game_die: game_die,
    	bowling: bowling,
    	flower_playing_cards: flower_playing_cards,
    	musical_note: musical_note,
    	notes: notes,
    	saxophone: saxophone,
    	guitar: guitar,
    	musical_keyboard: musical_keyboard,
    	trumpet: trumpet,
    	violin: violin,
    	musical_score: musical_score,
    	running_shirt_with_sash: running_shirt_with_sash,
    	tennis: tennis,
    	ski: ski,
    	basketball: basketball,
    	checkered_flag: checkered_flag,
    	snowboarder: snowboarder,
    	"woman-running": "🏃‍♀️",
    	"man-running": "🏃‍♂️",
    	runner: runner,
    	running: running,
    	"woman-surfing": "🏄‍♀️",
    	"man-surfing": "🏄‍♂️",
    	surfer: surfer,
    	sports_medal: sports_medal,
    	trophy: trophy,
    	horse_racing: horse_racing,
    	football: football,
    	rugby_football: rugby_football,
    	"woman-swimming": "🏊‍♀️",
    	"man-swimming": "🏊‍♂️",
    	swimmer: swimmer,
    	"woman-lifting-weights": "🏋️‍♀️",
    	"man-lifting-weights": "🏋️‍♂️",
    	weight_lifter: weight_lifter,
    	"woman-golfing": "🏌️‍♀️",
    	"man-golfing": "🏌️‍♂️",
    	golfer: golfer,
    	racing_motorcycle: racing_motorcycle,
    	racing_car: racing_car,
    	cricket_bat_and_ball: cricket_bat_and_ball,
    	volleyball: volleyball,
    	field_hockey_stick_and_ball: field_hockey_stick_and_ball,
    	ice_hockey_stick_and_puck: ice_hockey_stick_and_puck,
    	table_tennis_paddle_and_ball: table_tennis_paddle_and_ball,
    	snow_capped_mountain: snow_capped_mountain,
    	camping: camping,
    	beach_with_umbrella: beach_with_umbrella,
    	building_construction: building_construction,
    	house_buildings: house_buildings,
    	cityscape: cityscape,
    	derelict_house_building: derelict_house_building,
    	classical_building: classical_building,
    	desert: desert,
    	desert_island: desert_island,
    	national_park: national_park,
    	stadium: stadium,
    	house: house,
    	house_with_garden: house_with_garden,
    	office: office,
    	post_office: post_office,
    	european_post_office: european_post_office,
    	hospital: hospital,
    	bank: bank,
    	atm: atm,
    	hotel: hotel,
    	love_hotel: love_hotel,
    	convenience_store: convenience_store,
    	school: school,
    	department_store: department_store,
    	factory: factory,
    	izakaya_lantern: izakaya_lantern,
    	lantern: lantern,
    	japanese_castle: japanese_castle,
    	european_castle: european_castle,
    	"rainbow-flag": "🏳️‍🌈",
    	waving_white_flag: waving_white_flag,
    	"flag-england": "🏴󠁧󠁢󠁥󠁮󠁧󠁿",
    	"flag-scotland": "🏴󠁧󠁢󠁳󠁣󠁴󠁿",
    	"flag-wales": "🏴󠁧󠁢󠁷󠁬󠁳󠁿",
    	waving_black_flag: waving_black_flag,
    	rosette: rosette,
    	label: label,
    	badminton_racquet_and_shuttlecock: badminton_racquet_and_shuttlecock,
    	bow_and_arrow: bow_and_arrow,
    	amphora: amphora,
    	rat: rat,
    	mouse2: mouse2,
    	ox: ox,
    	water_buffalo: water_buffalo,
    	cow2: cow2,
    	tiger2: tiger2,
    	leopard: leopard,
    	rabbit2: rabbit2,
    	cat2: cat2,
    	dragon: dragon,
    	crocodile: crocodile,
    	whale2: whale2,
    	snail: snail,
    	snake: snake,
    	racehorse: racehorse,
    	ram: ram,
    	goat: goat,
    	sheep: sheep,
    	monkey: monkey,
    	rooster: rooster,
    	chicken: chicken,
    	dog2: dog2,
    	pig2: pig2,
    	boar: boar,
    	elephant: elephant,
    	octopus: octopus,
    	shell: shell,
    	bug: bug,
    	ant: ant,
    	bee: bee,
    	honeybee: honeybee,
    	beetle: beetle,
    	fish: fish,
    	tropical_fish: tropical_fish,
    	blowfish: blowfish,
    	turtle: turtle,
    	hatching_chick: hatching_chick,
    	baby_chick: baby_chick,
    	hatched_chick: hatched_chick,
    	bird: bird,
    	penguin: penguin,
    	koala: koala,
    	poodle: poodle,
    	dromedary_camel: dromedary_camel,
    	camel: camel,
    	dolphin: dolphin,
    	flipper: flipper,
    	mouse: mouse,
    	cow: cow,
    	tiger: tiger,
    	rabbit: rabbit,
    	cat: cat,
    	dragon_face: dragon_face,
    	whale: whale,
    	horse: horse,
    	monkey_face: monkey_face,
    	dog: dog,
    	pig: pig,
    	frog: frog,
    	hamster: hamster,
    	wolf: wolf,
    	bear: bear,
    	panda_face: panda_face,
    	pig_nose: pig_nose,
    	feet: feet,
    	paw_prints: paw_prints,
    	chipmunk: chipmunk,
    	eyes: eyes,
    	"eye-in-speech-bubble": "👁️‍🗨️",
    	eye: eye,
    	ear: ear,
    	nose: nose,
    	lips: lips,
    	tongue: tongue,
    	point_up_2: point_up_2,
    	point_down: point_down,
    	point_left: point_left,
    	point_right: point_right,
    	facepunch: facepunch,
    	punch: punch,
    	wave: wave,
    	ok_hand: ok_hand,
    	"+1": "👍",
    	thumbsup: thumbsup,
    	"-1": "👎",
    	thumbsdown: thumbsdown,
    	clap: clap,
    	open_hands: open_hands,
    	crown: crown,
    	womans_hat: womans_hat,
    	eyeglasses: eyeglasses,
    	necktie: necktie,
    	shirt: shirt,
    	tshirt: tshirt,
    	jeans: jeans,
    	dress: dress,
    	kimono: kimono,
    	bikini: bikini,
    	womans_clothes: womans_clothes,
    	purse: purse,
    	handbag: handbag,
    	pouch: pouch,
    	mans_shoe: mans_shoe,
    	shoe: shoe,
    	athletic_shoe: athletic_shoe,
    	high_heel: high_heel,
    	sandal: sandal,
    	boot: boot,
    	footprints: footprints,
    	bust_in_silhouette: bust_in_silhouette,
    	busts_in_silhouette: busts_in_silhouette,
    	boy: boy,
    	girl: girl,
    	"male-farmer": "👨‍🌾",
    	"male-cook": "👨‍🍳",
    	"male-student": "👨‍🎓",
    	"male-singer": "👨‍🎤",
    	"male-artist": "👨‍🎨",
    	"male-teacher": "👨‍🏫",
    	"male-factory-worker": "👨‍🏭",
    	"man-boy-boy": "👨‍👦‍👦",
    	"man-boy": "👨‍👦",
    	"man-girl-boy": "👨‍👧‍👦",
    	"man-girl-girl": "👨‍👧‍👧",
    	"man-girl": "👨‍👧",
    	"man-man-boy": "👨‍👨‍👦",
    	"man-man-boy-boy": "👨‍👨‍👦‍👦",
    	"man-man-girl": "👨‍👨‍👧",
    	"man-man-girl-boy": "👨‍👨‍👧‍👦",
    	"man-man-girl-girl": "👨‍👨‍👧‍👧",
    	"man-woman-boy": "👨‍👩‍👦",
    	family: family,
    	"man-woman-boy-boy": "👨‍👩‍👦‍👦",
    	"man-woman-girl": "👨‍👩‍👧",
    	"man-woman-girl-boy": "👨‍👩‍👧‍👦",
    	"man-woman-girl-girl": "👨‍👩‍👧‍👧",
    	"male-technologist": "👨‍💻",
    	"male-office-worker": "👨‍💼",
    	"male-mechanic": "👨‍🔧",
    	"male-scientist": "👨‍🔬",
    	"male-astronaut": "👨‍🚀",
    	"male-firefighter": "👨‍🚒",
    	"male-doctor": "👨‍⚕️",
    	"male-judge": "👨‍⚖️",
    	"male-pilot": "👨‍✈️",
    	"man-heart-man": "👨‍❤️‍👨",
    	"man-kiss-man": "👨‍❤️‍💋‍👨",
    	man: man,
    	"female-farmer": "👩‍🌾",
    	"female-cook": "👩‍🍳",
    	"female-student": "👩‍🎓",
    	"female-singer": "👩‍🎤",
    	"female-artist": "👩‍🎨",
    	"female-teacher": "👩‍🏫",
    	"female-factory-worker": "👩‍🏭",
    	"woman-boy-boy": "👩‍👦‍👦",
    	"woman-boy": "👩‍👦",
    	"woman-girl-boy": "👩‍👧‍👦",
    	"woman-girl-girl": "👩‍👧‍👧",
    	"woman-girl": "👩‍👧",
    	"woman-woman-boy": "👩‍👩‍👦",
    	"woman-woman-boy-boy": "👩‍👩‍👦‍👦",
    	"woman-woman-girl": "👩‍👩‍👧",
    	"woman-woman-girl-boy": "👩‍👩‍👧‍👦",
    	"woman-woman-girl-girl": "👩‍👩‍👧‍👧",
    	"female-technologist": "👩‍💻",
    	"female-office-worker": "👩‍💼",
    	"female-mechanic": "👩‍🔧",
    	"female-scientist": "👩‍🔬",
    	"female-astronaut": "👩‍🚀",
    	"female-firefighter": "👩‍🚒",
    	"female-doctor": "👩‍⚕️",
    	"female-judge": "👩‍⚖️",
    	"female-pilot": "👩‍✈️",
    	"woman-heart-man": "👩‍❤️‍👨",
    	couple_with_heart: couple_with_heart,
    	"woman-heart-woman": "👩‍❤️‍👩",
    	"woman-kiss-man": "👩‍❤️‍💋‍👨",
    	couplekiss: couplekiss,
    	"woman-kiss-woman": "👩‍❤️‍💋‍👩",
    	woman: woman,
    	couple: couple,
    	man_and_woman_holding_hands: man_and_woman_holding_hands,
    	two_men_holding_hands: two_men_holding_hands,
    	two_women_holding_hands: two_women_holding_hands,
    	"female-police-officer": "👮‍♀️",
    	"male-police-officer": "👮‍♂️",
    	cop: cop,
    	"woman-with-bunny-ears-partying": "👯‍♀️",
    	dancers: dancers,
    	"man-with-bunny-ears-partying": "👯‍♂️",
    	bride_with_veil: bride_with_veil,
    	"blond-haired-woman": "👱‍♀️",
    	"blond-haired-man": "👱‍♂️",
    	person_with_blond_hair: person_with_blond_hair,
    	man_with_gua_pi_mao: man_with_gua_pi_mao,
    	"woman-wearing-turban": "👳‍♀️",
    	"man-wearing-turban": "👳‍♂️",
    	man_with_turban: man_with_turban,
    	older_man: older_man,
    	older_woman: older_woman,
    	baby: baby,
    	"female-construction-worker": "👷‍♀️",
    	"male-construction-worker": "👷‍♂️",
    	construction_worker: construction_worker,
    	princess: princess,
    	japanese_ogre: japanese_ogre,
    	japanese_goblin: japanese_goblin,
    	ghost: ghost,
    	angel: angel,
    	alien: alien,
    	space_invader: space_invader,
    	imp: imp,
    	skull: skull,
    	"woman-tipping-hand": "💁‍♀️",
    	information_desk_person: information_desk_person,
    	"man-tipping-hand": "💁‍♂️",
    	"female-guard": "💂‍♀️",
    	"male-guard": "💂‍♂️",
    	guardsman: guardsman,
    	dancer: dancer,
    	lipstick: lipstick,
    	nail_care: nail_care,
    	"woman-getting-massage": "💆‍♀️",
    	massage: massage,
    	"man-getting-massage": "💆‍♂️",
    	"woman-getting-haircut": "💇‍♀️",
    	haircut: haircut,
    	"man-getting-haircut": "💇‍♂️",
    	barber: barber,
    	syringe: syringe,
    	pill: pill,
    	kiss: kiss,
    	love_letter: love_letter,
    	ring: ring,
    	gem: gem,
    	bouquet: bouquet,
    	wedding: wedding,
    	heartbeat: heartbeat,
    	broken_heart: broken_heart,
    	two_hearts: two_hearts,
    	sparkling_heart: sparkling_heart,
    	heartpulse: heartpulse,
    	cupid: cupid,
    	blue_heart: blue_heart,
    	green_heart: green_heart,
    	yellow_heart: yellow_heart,
    	purple_heart: purple_heart,
    	gift_heart: gift_heart,
    	revolving_hearts: revolving_hearts,
    	heart_decoration: heart_decoration,
    	diamond_shape_with_a_dot_inside: diamond_shape_with_a_dot_inside,
    	bulb: bulb,
    	anger: anger,
    	bomb: bomb,
    	zzz: zzz,
    	boom: boom,
    	collision: collision,
    	sweat_drops: sweat_drops,
    	droplet: droplet,
    	dash: dash,
    	poop: poop,
    	muscle: muscle,
    	dizzy: dizzy,
    	speech_balloon: speech_balloon,
    	thought_balloon: thought_balloon,
    	white_flower: white_flower,
    	moneybag: moneybag,
    	currency_exchange: currency_exchange,
    	heavy_dollar_sign: heavy_dollar_sign,
    	credit_card: credit_card,
    	yen: yen,
    	dollar: dollar,
    	euro: euro,
    	pound: pound,
    	money_with_wings: money_with_wings,
    	chart: chart,
    	seat: seat,
    	computer: computer,
    	briefcase: briefcase,
    	minidisc: minidisc,
    	floppy_disk: floppy_disk,
    	cd: cd,
    	dvd: dvd,
    	file_folder: file_folder,
    	open_file_folder: open_file_folder,
    	page_with_curl: page_with_curl,
    	page_facing_up: page_facing_up,
    	date: date,
    	calendar: calendar,
    	card_index: card_index,
    	chart_with_upwards_trend: chart_with_upwards_trend,
    	chart_with_downwards_trend: chart_with_downwards_trend,
    	bar_chart: bar_chart,
    	clipboard: clipboard,
    	pushpin: pushpin,
    	round_pushpin: round_pushpin,
    	paperclip: paperclip,
    	straight_ruler: straight_ruler,
    	triangular_ruler: triangular_ruler,
    	bookmark_tabs: bookmark_tabs,
    	ledger: ledger,
    	notebook: notebook,
    	notebook_with_decorative_cover: notebook_with_decorative_cover,
    	closed_book: closed_book,
    	book: book,
    	open_book: open_book,
    	green_book: green_book,
    	blue_book: blue_book,
    	orange_book: orange_book,
    	books: books,
    	name_badge: name_badge,
    	scroll: scroll,
    	memo: memo,
    	pencil: pencil,
    	telephone_receiver: telephone_receiver,
    	pager: pager,
    	fax: fax,
    	satellite_antenna: satellite_antenna,
    	loudspeaker: loudspeaker,
    	mega: mega,
    	outbox_tray: outbox_tray,
    	inbox_tray: inbox_tray,
    	"package": "📦",
    	"e-mail": "📧",
    	incoming_envelope: incoming_envelope,
    	envelope_with_arrow: envelope_with_arrow,
    	mailbox_closed: mailbox_closed,
    	mailbox: mailbox,
    	mailbox_with_mail: mailbox_with_mail,
    	mailbox_with_no_mail: mailbox_with_no_mail,
    	postbox: postbox,
    	postal_horn: postal_horn,
    	newspaper: newspaper,
    	iphone: iphone,
    	calling: calling,
    	vibration_mode: vibration_mode,
    	mobile_phone_off: mobile_phone_off,
    	no_mobile_phones: no_mobile_phones,
    	signal_strength: signal_strength,
    	camera: camera,
    	camera_with_flash: camera_with_flash,
    	video_camera: video_camera,
    	tv: tv,
    	radio: radio,
    	vhs: vhs,
    	film_projector: film_projector,
    	prayer_beads: prayer_beads,
    	twisted_rightwards_arrows: twisted_rightwards_arrows,
    	repeat: repeat,
    	repeat_one: repeat_one,
    	arrows_clockwise: arrows_clockwise,
    	arrows_counterclockwise: arrows_counterclockwise,
    	low_brightness: low_brightness,
    	high_brightness: high_brightness,
    	mute: mute,
    	speaker: speaker,
    	sound: sound,
    	loud_sound: loud_sound,
    	battery: battery,
    	electric_plug: electric_plug,
    	mag: mag,
    	mag_right: mag_right,
    	lock_with_ink_pen: lock_with_ink_pen,
    	closed_lock_with_key: closed_lock_with_key,
    	key: key,
    	lock: lock,
    	unlock: unlock,
    	bell: bell,
    	no_bell: no_bell,
    	bookmark: bookmark,
    	link: link,
    	radio_button: radio_button,
    	back: back,
    	end: end,
    	on: on,
    	soon: soon,
    	underage: underage,
    	keycap_ten: keycap_ten,
    	capital_abcd: capital_abcd,
    	abcd: abcd,
    	symbols: symbols,
    	abc: abc,
    	fire: fire,
    	flashlight: flashlight,
    	wrench: wrench,
    	hammer: hammer,
    	nut_and_bolt: nut_and_bolt,
    	hocho: hocho,
    	knife: knife,
    	gun: gun,
    	microscope: microscope,
    	telescope: telescope,
    	crystal_ball: crystal_ball,
    	six_pointed_star: six_pointed_star,
    	beginner: beginner,
    	trident: trident,
    	black_square_button: black_square_button,
    	white_square_button: white_square_button,
    	red_circle: red_circle,
    	large_blue_circle: large_blue_circle,
    	large_orange_diamond: large_orange_diamond,
    	large_blue_diamond: large_blue_diamond,
    	small_orange_diamond: small_orange_diamond,
    	small_blue_diamond: small_blue_diamond,
    	small_red_triangle: small_red_triangle,
    	small_red_triangle_down: small_red_triangle_down,
    	arrow_up_small: arrow_up_small,
    	arrow_down_small: arrow_down_small,
    	om_symbol: om_symbol,
    	dove_of_peace: dove_of_peace,
    	kaaba: kaaba,
    	mosque: mosque,
    	synagogue: synagogue,
    	menorah_with_nine_branches: menorah_with_nine_branches,
    	candle: candle,
    	mantelpiece_clock: mantelpiece_clock,
    	hole: hole,
    	man_in_business_suit_levitating: man_in_business_suit_levitating,
    	"female-detective": "🕵️‍♀️",
    	"male-detective": "🕵️‍♂️",
    	sleuth_or_spy: sleuth_or_spy,
    	dark_sunglasses: dark_sunglasses,
    	spider: spider,
    	spider_web: spider_web,
    	joystick: joystick,
    	man_dancing: man_dancing,
    	linked_paperclips: linked_paperclips,
    	lower_left_ballpoint_pen: lower_left_ballpoint_pen,
    	lower_left_fountain_pen: lower_left_fountain_pen,
    	lower_left_paintbrush: lower_left_paintbrush,
    	lower_left_crayon: lower_left_crayon,
    	raised_hand_with_fingers_splayed: raised_hand_with_fingers_splayed,
    	middle_finger: middle_finger,
    	reversed_hand_with_middle_finger_extended: reversed_hand_with_middle_finger_extended,
    	"spock-hand": "🖖",
    	black_heart: black_heart,
    	desktop_computer: desktop_computer,
    	printer: printer,
    	three_button_mouse: three_button_mouse,
    	trackball: trackball,
    	frame_with_picture: frame_with_picture,
    	card_index_dividers: card_index_dividers,
    	card_file_box: card_file_box,
    	file_cabinet: file_cabinet,
    	wastebasket: wastebasket,
    	spiral_note_pad: spiral_note_pad,
    	spiral_calendar_pad: spiral_calendar_pad,
    	compression: compression,
    	old_key: old_key,
    	rolled_up_newspaper: rolled_up_newspaper,
    	dagger_knife: dagger_knife,
    	speaking_head_in_silhouette: speaking_head_in_silhouette,
    	left_speech_bubble: left_speech_bubble,
    	right_anger_bubble: right_anger_bubble,
    	ballot_box_with_ballot: ballot_box_with_ballot,
    	world_map: world_map,
    	mount_fuji: mount_fuji,
    	tokyo_tower: tokyo_tower,
    	statue_of_liberty: statue_of_liberty,
    	japan: japan,
    	moyai: moyai,
    	grinning: grinning,
    	grin: grin,
    	joy: joy,
    	smiley: smiley,
    	smile: smile,
    	sweat_smile: sweat_smile,
    	laughing: laughing,
    	satisfied: satisfied,
    	innocent: innocent,
    	smiling_imp: smiling_imp,
    	wink: wink,
    	blush: blush,
    	yum: yum,
    	relieved: relieved,
    	heart_eyes: heart_eyes,
    	sunglasses: sunglasses,
    	smirk: smirk,
    	neutral_face: neutral_face,
    	expressionless: expressionless,
    	unamused: unamused,
    	sweat: sweat,
    	pensive: pensive,
    	confused: confused,
    	confounded: confounded,
    	kissing: kissing,
    	kissing_heart: kissing_heart,
    	kissing_smiling_eyes: kissing_smiling_eyes,
    	kissing_closed_eyes: kissing_closed_eyes,
    	stuck_out_tongue: stuck_out_tongue,
    	stuck_out_tongue_winking_eye: stuck_out_tongue_winking_eye,
    	stuck_out_tongue_closed_eyes: stuck_out_tongue_closed_eyes,
    	disappointed: disappointed,
    	worried: worried,
    	angry: angry,
    	rage: rage,
    	cry: cry,
    	persevere: persevere,
    	triumph: triumph,
    	disappointed_relieved: disappointed_relieved,
    	frowning: frowning,
    	anguished: anguished,
    	fearful: fearful,
    	weary: weary,
    	sleepy: sleepy,
    	tired_face: tired_face,
    	grimacing: grimacing,
    	sob: sob,
    	open_mouth: open_mouth,
    	hushed: hushed,
    	cold_sweat: cold_sweat,
    	scream: scream,
    	astonished: astonished,
    	flushed: flushed,
    	sleeping: sleeping,
    	dizzy_face: dizzy_face,
    	no_mouth: no_mouth,
    	mask: mask,
    	smile_cat: smile_cat,
    	joy_cat: joy_cat,
    	smiley_cat: smiley_cat,
    	heart_eyes_cat: heart_eyes_cat,
    	smirk_cat: smirk_cat,
    	kissing_cat: kissing_cat,
    	pouting_cat: pouting_cat,
    	crying_cat_face: crying_cat_face,
    	scream_cat: scream_cat,
    	slightly_frowning_face: slightly_frowning_face,
    	slightly_smiling_face: slightly_smiling_face,
    	upside_down_face: upside_down_face,
    	face_with_rolling_eyes: face_with_rolling_eyes,
    	"woman-gesturing-no": "🙅‍♀️",
    	no_good: no_good,
    	"man-gesturing-no": "🙅‍♂️",
    	"woman-gesturing-ok": "🙆‍♀️",
    	ok_woman: ok_woman,
    	"man-gesturing-ok": "🙆‍♂️",
    	"woman-bowing": "🙇‍♀️",
    	"man-bowing": "🙇‍♂️",
    	bow: bow,
    	see_no_evil: see_no_evil,
    	hear_no_evil: hear_no_evil,
    	speak_no_evil: speak_no_evil,
    	"woman-raising-hand": "🙋‍♀️",
    	raising_hand: raising_hand,
    	"man-raising-hand": "🙋‍♂️",
    	raised_hands: raised_hands,
    	"woman-frowning": "🙍‍♀️",
    	person_frowning: person_frowning,
    	"man-frowning": "🙍‍♂️",
    	"woman-pouting": "🙎‍♀️",
    	person_with_pouting_face: person_with_pouting_face,
    	"man-pouting": "🙎‍♂️",
    	pray: pray,
    	rocket: rocket,
    	helicopter: helicopter,
    	steam_locomotive: steam_locomotive,
    	railway_car: railway_car,
    	bullettrain_side: bullettrain_side,
    	bullettrain_front: bullettrain_front,
    	train2: train2,
    	metro: metro,
    	light_rail: light_rail,
    	station: station,
    	tram: tram,
    	train: train,
    	bus: bus,
    	oncoming_bus: oncoming_bus,
    	trolleybus: trolleybus,
    	busstop: busstop,
    	minibus: minibus,
    	ambulance: ambulance,
    	fire_engine: fire_engine,
    	police_car: police_car,
    	oncoming_police_car: oncoming_police_car,
    	taxi: taxi,
    	oncoming_taxi: oncoming_taxi,
    	car: car,
    	red_car: red_car,
    	oncoming_automobile: oncoming_automobile,
    	blue_car: blue_car,
    	truck: truck,
    	articulated_lorry: articulated_lorry,
    	tractor: tractor,
    	monorail: monorail,
    	mountain_railway: mountain_railway,
    	suspension_railway: suspension_railway,
    	mountain_cableway: mountain_cableway,
    	aerial_tramway: aerial_tramway,
    	ship: ship,
    	"woman-rowing-boat": "🚣‍♀️",
    	"man-rowing-boat": "🚣‍♂️",
    	rowboat: rowboat,
    	speedboat: speedboat,
    	traffic_light: traffic_light,
    	vertical_traffic_light: vertical_traffic_light,
    	construction: construction,
    	rotating_light: rotating_light,
    	triangular_flag_on_post: triangular_flag_on_post,
    	door: door,
    	no_entry_sign: no_entry_sign,
    	smoking: smoking,
    	no_smoking: no_smoking,
    	put_litter_in_its_place: put_litter_in_its_place,
    	do_not_litter: do_not_litter,
    	potable_water: potable_water,
    	"non-potable_water": "🚱",
    	bike: bike,
    	no_bicycles: no_bicycles,
    	"woman-biking": "🚴‍♀️",
    	"man-biking": "🚴‍♂️",
    	bicyclist: bicyclist,
    	"woman-mountain-biking": "🚵‍♀️",
    	"man-mountain-biking": "🚵‍♂️",
    	mountain_bicyclist: mountain_bicyclist,
    	"woman-walking": "🚶‍♀️",
    	"man-walking": "🚶‍♂️",
    	walking: walking,
    	no_pedestrians: no_pedestrians,
    	children_crossing: children_crossing,
    	mens: mens,
    	womens: womens,
    	restroom: restroom,
    	baby_symbol: baby_symbol,
    	toilet: toilet,
    	wc: wc,
    	shower: shower,
    	bath: bath,
    	bathtub: bathtub,
    	passport_control: passport_control,
    	customs: customs,
    	baggage_claim: baggage_claim,
    	left_luggage: left_luggage,
    	couch_and_lamp: couch_and_lamp,
    	sleeping_accommodation: sleeping_accommodation,
    	shopping_bags: shopping_bags,
    	bellhop_bell: bellhop_bell,
    	bed: bed,
    	place_of_worship: place_of_worship,
    	octagonal_sign: octagonal_sign,
    	shopping_trolley: shopping_trolley,
    	hammer_and_wrench: hammer_and_wrench,
    	shield: shield,
    	oil_drum: oil_drum,
    	motorway: motorway,
    	railway_track: railway_track,
    	motor_boat: motor_boat,
    	small_airplane: small_airplane,
    	airplane_departure: airplane_departure,
    	airplane_arriving: airplane_arriving,
    	satellite: satellite,
    	passenger_ship: passenger_ship,
    	scooter: scooter,
    	motor_scooter: motor_scooter,
    	canoe: canoe,
    	sled: sled,
    	flying_saucer: flying_saucer,
    	zipper_mouth_face: zipper_mouth_face,
    	money_mouth_face: money_mouth_face,
    	face_with_thermometer: face_with_thermometer,
    	nerd_face: nerd_face,
    	thinking_face: thinking_face,
    	face_with_head_bandage: face_with_head_bandage,
    	robot_face: robot_face,
    	hugging_face: hugging_face,
    	the_horns: the_horns,
    	sign_of_the_horns: sign_of_the_horns,
    	call_me_hand: call_me_hand,
    	raised_back_of_hand: raised_back_of_hand,
    	"left-facing_fist": "🤛",
    	"right-facing_fist": "🤜",
    	handshake: handshake,
    	crossed_fingers: crossed_fingers,
    	hand_with_index_and_middle_fingers_crossed: hand_with_index_and_middle_fingers_crossed,
    	i_love_you_hand_sign: i_love_you_hand_sign,
    	face_with_cowboy_hat: face_with_cowboy_hat,
    	clown_face: clown_face,
    	nauseated_face: nauseated_face,
    	rolling_on_the_floor_laughing: rolling_on_the_floor_laughing,
    	drooling_face: drooling_face,
    	lying_face: lying_face,
    	"woman-facepalming": "🤦‍♀️",
    	"man-facepalming": "🤦‍♂️",
    	face_palm: face_palm,
    	sneezing_face: sneezing_face,
    	face_with_raised_eyebrow: face_with_raised_eyebrow,
    	face_with_one_eyebrow_raised: face_with_one_eyebrow_raised,
    	"star-struck": "🤩",
    	grinning_face_with_star_eyes: grinning_face_with_star_eyes,
    	zany_face: zany_face,
    	grinning_face_with_one_large_and_one_small_eye: grinning_face_with_one_large_and_one_small_eye,
    	shushing_face: shushing_face,
    	face_with_finger_covering_closed_lips: face_with_finger_covering_closed_lips,
    	face_with_symbols_on_mouth: face_with_symbols_on_mouth,
    	serious_face_with_symbols_covering_mouth: serious_face_with_symbols_covering_mouth,
    	face_with_hand_over_mouth: face_with_hand_over_mouth,
    	smiling_face_with_smiling_eyes_and_hand_covering_mouth: smiling_face_with_smiling_eyes_and_hand_covering_mouth,
    	face_vomiting: face_vomiting,
    	face_with_open_mouth_vomiting: face_with_open_mouth_vomiting,
    	exploding_head: exploding_head,
    	shocked_face_with_exploding_head: shocked_face_with_exploding_head,
    	pregnant_woman: pregnant_woman,
    	"breast-feeding": "🤱",
    	palms_up_together: palms_up_together,
    	selfie: selfie,
    	prince: prince,
    	man_in_tuxedo: man_in_tuxedo,
    	mrs_claus: mrs_claus,
    	mother_christmas: mother_christmas,
    	"woman-shrugging": "🤷‍♀️",
    	"man-shrugging": "🤷‍♂️",
    	shrug: shrug,
    	"woman-cartwheeling": "🤸‍♀️",
    	"man-cartwheeling": "🤸‍♂️",
    	person_doing_cartwheel: person_doing_cartwheel,
    	"woman-juggling": "🤹‍♀️",
    	"man-juggling": "🤹‍♂️",
    	juggling: juggling,
    	fencer: fencer,
    	"woman-wrestling": "🤼‍♀️",
    	"man-wrestling": "🤼‍♂️",
    	wrestlers: wrestlers,
    	"woman-playing-water-polo": "🤽‍♀️",
    	"man-playing-water-polo": "🤽‍♂️",
    	water_polo: water_polo,
    	"woman-playing-handball": "🤾‍♀️",
    	"man-playing-handball": "🤾‍♂️",
    	handball: handball,
    	wilted_flower: wilted_flower,
    	drum_with_drumsticks: drum_with_drumsticks,
    	clinking_glasses: clinking_glasses,
    	tumbler_glass: tumbler_glass,
    	spoon: spoon,
    	goal_net: goal_net,
    	first_place_medal: first_place_medal,
    	second_place_medal: second_place_medal,
    	third_place_medal: third_place_medal,
    	boxing_glove: boxing_glove,
    	martial_arts_uniform: martial_arts_uniform,
    	curling_stone: curling_stone,
    	croissant: croissant,
    	avocado: avocado,
    	cucumber: cucumber,
    	bacon: bacon,
    	potato: potato,
    	carrot: carrot,
    	baguette_bread: baguette_bread,
    	green_salad: green_salad,
    	shallow_pan_of_food: shallow_pan_of_food,
    	stuffed_flatbread: stuffed_flatbread,
    	egg: egg,
    	glass_of_milk: glass_of_milk,
    	peanuts: peanuts,
    	kiwifruit: kiwifruit,
    	pancakes: pancakes,
    	dumpling: dumpling,
    	fortune_cookie: fortune_cookie,
    	takeout_box: takeout_box,
    	chopsticks: chopsticks,
    	bowl_with_spoon: bowl_with_spoon,
    	cup_with_straw: cup_with_straw,
    	coconut: coconut,
    	broccoli: broccoli,
    	pie: pie,
    	pretzel: pretzel,
    	cut_of_meat: cut_of_meat,
    	sandwich: sandwich,
    	canned_food: canned_food,
    	crab: crab,
    	lion_face: lion_face,
    	scorpion: scorpion,
    	turkey: turkey,
    	unicorn_face: unicorn_face,
    	eagle: eagle,
    	duck: duck,
    	bat: bat,
    	shark: shark,
    	owl: owl,
    	fox_face: fox_face,
    	butterfly: butterfly,
    	deer: deer,
    	gorilla: gorilla,
    	lizard: lizard,
    	rhinoceros: rhinoceros,
    	shrimp: shrimp,
    	squid: squid,
    	giraffe_face: giraffe_face,
    	zebra_face: zebra_face,
    	hedgehog: hedgehog,
    	sauropod: sauropod,
    	"t-rex": "🦖",
    	cricket: cricket,
    	cheese_wedge: cheese_wedge,
    	face_with_monocle: face_with_monocle,
    	adult: adult,
    	child: child,
    	older_adult: older_adult,
    	bearded_person: bearded_person,
    	person_with_headscarf: person_with_headscarf,
    	woman_in_steamy_room: woman_in_steamy_room,
    	man_in_steamy_room: man_in_steamy_room,
    	person_in_steamy_room: person_in_steamy_room,
    	woman_climbing: woman_climbing,
    	person_climbing: person_climbing,
    	man_climbing: man_climbing,
    	woman_in_lotus_position: woman_in_lotus_position,
    	person_in_lotus_position: person_in_lotus_position,
    	man_in_lotus_position: man_in_lotus_position,
    	female_mage: female_mage,
    	mage: mage,
    	male_mage: male_mage,
    	female_fairy: female_fairy,
    	fairy: fairy,
    	male_fairy: male_fairy,
    	female_vampire: female_vampire,
    	vampire: vampire,
    	male_vampire: male_vampire,
    	mermaid: mermaid,
    	merman: merman,
    	merperson: merperson,
    	female_elf: female_elf,
    	male_elf: male_elf,
    	elf: elf,
    	female_genie: female_genie,
    	male_genie: male_genie,
    	genie: genie,
    	female_zombie: female_zombie,
    	male_zombie: male_zombie,
    	zombie: zombie,
    	brain: brain,
    	orange_heart: orange_heart,
    	billed_cap: billed_cap,
    	scarf: scarf,
    	gloves: gloves,
    	coat: coat,
    	socks: socks,
    	bangbang: bangbang,
    	interrobang: interrobang,
    	tm: tm,
    	information_source: information_source,
    	left_right_arrow: left_right_arrow,
    	arrow_up_down: arrow_up_down,
    	arrow_upper_left: arrow_upper_left,
    	arrow_upper_right: arrow_upper_right,
    	arrow_lower_right: arrow_lower_right,
    	arrow_lower_left: arrow_lower_left,
    	leftwards_arrow_with_hook: leftwards_arrow_with_hook,
    	arrow_right_hook: arrow_right_hook,
    	watch: watch,
    	hourglass: hourglass,
    	keyboard: keyboard,
    	eject: eject,
    	fast_forward: fast_forward,
    	rewind: rewind,
    	arrow_double_up: arrow_double_up,
    	arrow_double_down: arrow_double_down,
    	black_right_pointing_double_triangle_with_vertical_bar: black_right_pointing_double_triangle_with_vertical_bar,
    	black_left_pointing_double_triangle_with_vertical_bar: black_left_pointing_double_triangle_with_vertical_bar,
    	black_right_pointing_triangle_with_double_vertical_bar: black_right_pointing_triangle_with_double_vertical_bar,
    	alarm_clock: alarm_clock,
    	stopwatch: stopwatch,
    	timer_clock: timer_clock,
    	hourglass_flowing_sand: hourglass_flowing_sand,
    	double_vertical_bar: double_vertical_bar,
    	black_square_for_stop: black_square_for_stop,
    	black_circle_for_record: black_circle_for_record,
    	m: m,
    	black_small_square: black_small_square,
    	white_small_square: white_small_square,
    	arrow_forward: arrow_forward,
    	arrow_backward: arrow_backward,
    	white_medium_square: white_medium_square,
    	black_medium_square: black_medium_square,
    	white_medium_small_square: white_medium_small_square,
    	black_medium_small_square: black_medium_small_square,
    	sunny: sunny,
    	cloud: cloud,
    	umbrella: umbrella,
    	snowman: snowman,
    	comet: comet,
    	phone: phone,
    	telephone: telephone,
    	ballot_box_with_check: ballot_box_with_check,
    	shamrock: shamrock,
    	point_up: point_up,
    	skull_and_crossbones: skull_and_crossbones,
    	radioactive_sign: radioactive_sign,
    	biohazard_sign: biohazard_sign,
    	orthodox_cross: orthodox_cross,
    	star_and_crescent: star_and_crescent,
    	peace_symbol: peace_symbol,
    	yin_yang: yin_yang,
    	wheel_of_dharma: wheel_of_dharma,
    	white_frowning_face: white_frowning_face,
    	relaxed: relaxed,
    	female_sign: female_sign,
    	male_sign: male_sign,
    	gemini: gemini,
    	cancer: cancer,
    	leo: leo,
    	virgo: virgo,
    	libra: libra,
    	scorpius: scorpius,
    	spades: spades,
    	clubs: clubs,
    	hearts: hearts,
    	diamonds: diamonds,
    	hotsprings: hotsprings,
    	recycle: recycle,
    	wheelchair: wheelchair,
    	hammer_and_pick: hammer_and_pick,
    	crossed_swords: crossed_swords,
    	medical_symbol: medical_symbol,
    	staff_of_aesculapius: staff_of_aesculapius,
    	scales: scales,
    	alembic: alembic,
    	gear: gear,
    	atom_symbol: atom_symbol,
    	fleur_de_lis: fleur_de_lis,
    	warning: warning,
    	zap: zap,
    	white_circle: white_circle,
    	black_circle: black_circle,
    	coffin: coffin,
    	funeral_urn: funeral_urn,
    	soccer: soccer,
    	baseball: baseball,
    	snowman_without_snow: snowman_without_snow,
    	partly_sunny: partly_sunny,
    	thunder_cloud_and_rain: thunder_cloud_and_rain,
    	ophiuchus: ophiuchus,
    	pick: pick,
    	helmet_with_white_cross: helmet_with_white_cross,
    	chains: chains,
    	no_entry: no_entry,
    	shinto_shrine: shinto_shrine,
    	church: church,
    	mountain: mountain,
    	umbrella_on_ground: umbrella_on_ground,
    	fountain: fountain,
    	golf: golf,
    	ferry: ferry,
    	boat: boat,
    	sailboat: sailboat,
    	skier: skier,
    	ice_skate: ice_skate,
    	"woman-bouncing-ball": "⛹️‍♀️",
    	"man-bouncing-ball": "⛹️‍♂️",
    	person_with_ball: person_with_ball,
    	tent: tent,
    	fuelpump: fuelpump,
    	scissors: scissors,
    	airplane: airplane,
    	email: email,
    	envelope: envelope,
    	fist: fist,
    	hand: hand,
    	raised_hand: raised_hand,
    	v: v,
    	writing_hand: writing_hand,
    	pencil2: pencil2,
    	black_nib: black_nib,
    	heavy_check_mark: heavy_check_mark,
    	heavy_multiplication_x: heavy_multiplication_x,
    	latin_cross: latin_cross,
    	star_of_david: star_of_david,
    	eight_spoked_asterisk: eight_spoked_asterisk,
    	eight_pointed_black_star: eight_pointed_black_star,
    	snowflake: snowflake,
    	sparkle: sparkle,
    	x: x,
    	negative_squared_cross_mark: negative_squared_cross_mark,
    	heavy_heart_exclamation_mark_ornament: heavy_heart_exclamation_mark_ornament,
    	heart: heart,
    	arrow_right: arrow_right,
    	curly_loop: curly_loop,
    	loop: loop,
    	arrow_heading_up: arrow_heading_up,
    	arrow_heading_down: arrow_heading_down,
    	arrow_left: arrow_left,
    	arrow_up: arrow_up,
    	arrow_down: arrow_down,
    	black_large_square: black_large_square,
    	white_large_square: white_large_square,
    	star: star,
    	o: o,
    	wavy_dash: wavy_dash,
    	part_alternation_mark: part_alternation_mark,
    	congratulations: congratulations,
    	secret: secret
    };

    var emoji$1 = /*#__PURE__*/Object.freeze({
        __proto__: null,
        umbrella_with_rain_drops: umbrella_with_rain_drops,
        coffee: coffee,
        aries: aries,
        taurus: taurus,
        sagittarius: sagittarius,
        capricorn: capricorn,
        aquarius: aquarius,
        pisces: pisces,
        anchor: anchor,
        white_check_mark: white_check_mark,
        sparkles: sparkles,
        question: question,
        grey_question: grey_question,
        grey_exclamation: grey_exclamation,
        exclamation: exclamation,
        heavy_exclamation_mark: heavy_exclamation_mark,
        heavy_plus_sign: heavy_plus_sign,
        heavy_minus_sign: heavy_minus_sign,
        heavy_division_sign: heavy_division_sign,
        hash: hash,
        keycap_star: keycap_star,
        zero: zero,
        one: one,
        two: two,
        three: three,
        four: four,
        five: five,
        six: six,
        seven: seven,
        eight: eight,
        nine: nine,
        copyright: copyright,
        registered: registered,
        mahjong: mahjong,
        black_joker: black_joker,
        a: a,
        b: b,
        o2: o2,
        parking: parking,
        ab: ab,
        cl: cl,
        cool: cool,
        free: free,
        id: id,
        ng: ng,
        ok: ok,
        sos: sos,
        up: up,
        vs: vs,
        koko: koko,
        sa: sa,
        u7121: u7121,
        u6307: u6307,
        u7981: u7981,
        u7a7a: u7a7a,
        u5408: u5408,
        u6e80: u6e80,
        u6709: u6709,
        u6708: u6708,
        u7533: u7533,
        u5272: u5272,
        u55b6: u55b6,
        ideograph_advantage: ideograph_advantage,
        accept: accept,
        cyclone: cyclone,
        foggy: foggy,
        closed_umbrella: closed_umbrella,
        night_with_stars: night_with_stars,
        sunrise_over_mountains: sunrise_over_mountains,
        sunrise: sunrise,
        city_sunset: city_sunset,
        city_sunrise: city_sunrise,
        rainbow: rainbow,
        bridge_at_night: bridge_at_night,
        ocean: ocean,
        volcano: volcano,
        milky_way: milky_way,
        earth_africa: earth_africa,
        earth_americas: earth_americas,
        earth_asia: earth_asia,
        globe_with_meridians: globe_with_meridians,
        new_moon: new_moon,
        waxing_crescent_moon: waxing_crescent_moon,
        first_quarter_moon: first_quarter_moon,
        moon: moon,
        waxing_gibbous_moon: waxing_gibbous_moon,
        full_moon: full_moon,
        waning_gibbous_moon: waning_gibbous_moon,
        last_quarter_moon: last_quarter_moon,
        waning_crescent_moon: waning_crescent_moon,
        crescent_moon: crescent_moon,
        new_moon_with_face: new_moon_with_face,
        first_quarter_moon_with_face: first_quarter_moon_with_face,
        last_quarter_moon_with_face: last_quarter_moon_with_face,
        full_moon_with_face: full_moon_with_face,
        sun_with_face: sun_with_face,
        star2: star2,
        stars: stars,
        thermometer: thermometer,
        mostly_sunny: mostly_sunny,
        sun_small_cloud: sun_small_cloud,
        barely_sunny: barely_sunny,
        sun_behind_cloud: sun_behind_cloud,
        partly_sunny_rain: partly_sunny_rain,
        sun_behind_rain_cloud: sun_behind_rain_cloud,
        rain_cloud: rain_cloud,
        snow_cloud: snow_cloud,
        lightning: lightning,
        lightning_cloud: lightning_cloud,
        tornado: tornado,
        tornado_cloud: tornado_cloud,
        fog: fog,
        wind_blowing_face: wind_blowing_face,
        hotdog: hotdog,
        taco: taco,
        burrito: burrito,
        chestnut: chestnut,
        seedling: seedling,
        evergreen_tree: evergreen_tree,
        deciduous_tree: deciduous_tree,
        palm_tree: palm_tree,
        cactus: cactus,
        hot_pepper: hot_pepper,
        tulip: tulip,
        cherry_blossom: cherry_blossom,
        rose: rose,
        hibiscus: hibiscus,
        sunflower: sunflower,
        blossom: blossom,
        corn: corn,
        ear_of_rice: ear_of_rice,
        herb: herb,
        four_leaf_clover: four_leaf_clover,
        maple_leaf: maple_leaf,
        fallen_leaf: fallen_leaf,
        leaves: leaves,
        mushroom: mushroom,
        tomato: tomato,
        eggplant: eggplant,
        grapes: grapes,
        melon: melon,
        watermelon: watermelon,
        tangerine: tangerine,
        lemon: lemon,
        banana: banana,
        pineapple: pineapple,
        apple: apple,
        green_apple: green_apple,
        pear: pear,
        peach: peach,
        cherries: cherries,
        strawberry: strawberry,
        hamburger: hamburger,
        pizza: pizza,
        meat_on_bone: meat_on_bone,
        poultry_leg: poultry_leg,
        rice_cracker: rice_cracker,
        rice_ball: rice_ball,
        rice: rice,
        curry: curry,
        ramen: ramen,
        spaghetti: spaghetti,
        bread: bread,
        fries: fries,
        sweet_potato: sweet_potato,
        dango: dango,
        oden: oden,
        sushi: sushi,
        fried_shrimp: fried_shrimp,
        fish_cake: fish_cake,
        icecream: icecream,
        shaved_ice: shaved_ice,
        ice_cream: ice_cream,
        doughnut: doughnut,
        cookie: cookie,
        chocolate_bar: chocolate_bar,
        candy: candy,
        lollipop: lollipop,
        custard: custard,
        honey_pot: honey_pot,
        cake: cake,
        bento: bento,
        stew: stew,
        fried_egg: fried_egg,
        cooking: cooking,
        fork_and_knife: fork_and_knife,
        tea: tea,
        sake: sake,
        wine_glass: wine_glass,
        cocktail: cocktail,
        tropical_drink: tropical_drink,
        beer: beer,
        beers: beers,
        baby_bottle: baby_bottle,
        knife_fork_plate: knife_fork_plate,
        champagne: champagne,
        popcorn: popcorn,
        ribbon: ribbon,
        gift: gift,
        birthday: birthday,
        jack_o_lantern: jack_o_lantern,
        christmas_tree: christmas_tree,
        santa: santa,
        fireworks: fireworks,
        sparkler: sparkler,
        balloon: balloon,
        tada: tada,
        confetti_ball: confetti_ball,
        tanabata_tree: tanabata_tree,
        crossed_flags: crossed_flags,
        bamboo: bamboo,
        dolls: dolls,
        flags: flags,
        wind_chime: wind_chime,
        rice_scene: rice_scene,
        school_satchel: school_satchel,
        mortar_board: mortar_board,
        medal: medal,
        reminder_ribbon: reminder_ribbon,
        studio_microphone: studio_microphone,
        level_slider: level_slider,
        control_knobs: control_knobs,
        film_frames: film_frames,
        admission_tickets: admission_tickets,
        carousel_horse: carousel_horse,
        ferris_wheel: ferris_wheel,
        roller_coaster: roller_coaster,
        fishing_pole_and_fish: fishing_pole_and_fish,
        microphone: microphone,
        movie_camera: movie_camera,
        cinema: cinema,
        headphones: headphones,
        art: art,
        tophat: tophat,
        circus_tent: circus_tent,
        ticket: ticket,
        clapper: clapper,
        performing_arts: performing_arts,
        video_game: video_game,
        dart: dart,
        slot_machine: slot_machine,
        game_die: game_die,
        bowling: bowling,
        flower_playing_cards: flower_playing_cards,
        musical_note: musical_note,
        notes: notes,
        saxophone: saxophone,
        guitar: guitar,
        musical_keyboard: musical_keyboard,
        trumpet: trumpet,
        violin: violin,
        musical_score: musical_score,
        running_shirt_with_sash: running_shirt_with_sash,
        tennis: tennis,
        ski: ski,
        basketball: basketball,
        checkered_flag: checkered_flag,
        snowboarder: snowboarder,
        runner: runner,
        running: running,
        surfer: surfer,
        sports_medal: sports_medal,
        trophy: trophy,
        horse_racing: horse_racing,
        football: football,
        rugby_football: rugby_football,
        swimmer: swimmer,
        weight_lifter: weight_lifter,
        golfer: golfer,
        racing_motorcycle: racing_motorcycle,
        racing_car: racing_car,
        cricket_bat_and_ball: cricket_bat_and_ball,
        volleyball: volleyball,
        field_hockey_stick_and_ball: field_hockey_stick_and_ball,
        ice_hockey_stick_and_puck: ice_hockey_stick_and_puck,
        table_tennis_paddle_and_ball: table_tennis_paddle_and_ball,
        snow_capped_mountain: snow_capped_mountain,
        camping: camping,
        beach_with_umbrella: beach_with_umbrella,
        building_construction: building_construction,
        house_buildings: house_buildings,
        cityscape: cityscape,
        derelict_house_building: derelict_house_building,
        classical_building: classical_building,
        desert: desert,
        desert_island: desert_island,
        national_park: national_park,
        stadium: stadium,
        house: house,
        house_with_garden: house_with_garden,
        office: office,
        post_office: post_office,
        european_post_office: european_post_office,
        hospital: hospital,
        bank: bank,
        atm: atm,
        hotel: hotel,
        love_hotel: love_hotel,
        convenience_store: convenience_store,
        school: school,
        department_store: department_store,
        factory: factory,
        izakaya_lantern: izakaya_lantern,
        lantern: lantern,
        japanese_castle: japanese_castle,
        european_castle: european_castle,
        waving_white_flag: waving_white_flag,
        waving_black_flag: waving_black_flag,
        rosette: rosette,
        label: label,
        badminton_racquet_and_shuttlecock: badminton_racquet_and_shuttlecock,
        bow_and_arrow: bow_and_arrow,
        amphora: amphora,
        rat: rat,
        mouse2: mouse2,
        ox: ox,
        water_buffalo: water_buffalo,
        cow2: cow2,
        tiger2: tiger2,
        leopard: leopard,
        rabbit2: rabbit2,
        cat2: cat2,
        dragon: dragon,
        crocodile: crocodile,
        whale2: whale2,
        snail: snail,
        snake: snake,
        racehorse: racehorse,
        ram: ram,
        goat: goat,
        sheep: sheep,
        monkey: monkey,
        rooster: rooster,
        chicken: chicken,
        dog2: dog2,
        pig2: pig2,
        boar: boar,
        elephant: elephant,
        octopus: octopus,
        shell: shell,
        bug: bug,
        ant: ant,
        bee: bee,
        honeybee: honeybee,
        beetle: beetle,
        fish: fish,
        tropical_fish: tropical_fish,
        blowfish: blowfish,
        turtle: turtle,
        hatching_chick: hatching_chick,
        baby_chick: baby_chick,
        hatched_chick: hatched_chick,
        bird: bird,
        penguin: penguin,
        koala: koala,
        poodle: poodle,
        dromedary_camel: dromedary_camel,
        camel: camel,
        dolphin: dolphin,
        flipper: flipper,
        mouse: mouse,
        cow: cow,
        tiger: tiger,
        rabbit: rabbit,
        cat: cat,
        dragon_face: dragon_face,
        whale: whale,
        horse: horse,
        monkey_face: monkey_face,
        dog: dog,
        pig: pig,
        frog: frog,
        hamster: hamster,
        wolf: wolf,
        bear: bear,
        panda_face: panda_face,
        pig_nose: pig_nose,
        feet: feet,
        paw_prints: paw_prints,
        chipmunk: chipmunk,
        eyes: eyes,
        eye: eye,
        ear: ear,
        nose: nose,
        lips: lips,
        tongue: tongue,
        point_up_2: point_up_2,
        point_down: point_down,
        point_left: point_left,
        point_right: point_right,
        facepunch: facepunch,
        punch: punch,
        wave: wave,
        ok_hand: ok_hand,
        thumbsup: thumbsup,
        thumbsdown: thumbsdown,
        clap: clap,
        open_hands: open_hands,
        crown: crown,
        womans_hat: womans_hat,
        eyeglasses: eyeglasses,
        necktie: necktie,
        shirt: shirt,
        tshirt: tshirt,
        jeans: jeans,
        dress: dress,
        kimono: kimono,
        bikini: bikini,
        womans_clothes: womans_clothes,
        purse: purse,
        handbag: handbag,
        pouch: pouch,
        mans_shoe: mans_shoe,
        shoe: shoe,
        athletic_shoe: athletic_shoe,
        high_heel: high_heel,
        sandal: sandal,
        boot: boot,
        footprints: footprints,
        bust_in_silhouette: bust_in_silhouette,
        busts_in_silhouette: busts_in_silhouette,
        boy: boy,
        girl: girl,
        family: family,
        man: man,
        couple_with_heart: couple_with_heart,
        couplekiss: couplekiss,
        woman: woman,
        couple: couple,
        man_and_woman_holding_hands: man_and_woman_holding_hands,
        two_men_holding_hands: two_men_holding_hands,
        two_women_holding_hands: two_women_holding_hands,
        cop: cop,
        dancers: dancers,
        bride_with_veil: bride_with_veil,
        person_with_blond_hair: person_with_blond_hair,
        man_with_gua_pi_mao: man_with_gua_pi_mao,
        man_with_turban: man_with_turban,
        older_man: older_man,
        older_woman: older_woman,
        baby: baby,
        construction_worker: construction_worker,
        princess: princess,
        japanese_ogre: japanese_ogre,
        japanese_goblin: japanese_goblin,
        ghost: ghost,
        angel: angel,
        alien: alien,
        space_invader: space_invader,
        imp: imp,
        skull: skull,
        information_desk_person: information_desk_person,
        guardsman: guardsman,
        dancer: dancer,
        lipstick: lipstick,
        nail_care: nail_care,
        massage: massage,
        haircut: haircut,
        barber: barber,
        syringe: syringe,
        pill: pill,
        kiss: kiss,
        love_letter: love_letter,
        ring: ring,
        gem: gem,
        bouquet: bouquet,
        wedding: wedding,
        heartbeat: heartbeat,
        broken_heart: broken_heart,
        two_hearts: two_hearts,
        sparkling_heart: sparkling_heart,
        heartpulse: heartpulse,
        cupid: cupid,
        blue_heart: blue_heart,
        green_heart: green_heart,
        yellow_heart: yellow_heart,
        purple_heart: purple_heart,
        gift_heart: gift_heart,
        revolving_hearts: revolving_hearts,
        heart_decoration: heart_decoration,
        diamond_shape_with_a_dot_inside: diamond_shape_with_a_dot_inside,
        bulb: bulb,
        anger: anger,
        bomb: bomb,
        zzz: zzz,
        boom: boom,
        collision: collision,
        sweat_drops: sweat_drops,
        droplet: droplet,
        dash: dash,
        poop: poop,
        muscle: muscle,
        dizzy: dizzy,
        speech_balloon: speech_balloon,
        thought_balloon: thought_balloon,
        white_flower: white_flower,
        moneybag: moneybag,
        currency_exchange: currency_exchange,
        heavy_dollar_sign: heavy_dollar_sign,
        credit_card: credit_card,
        yen: yen,
        dollar: dollar,
        euro: euro,
        pound: pound,
        money_with_wings: money_with_wings,
        chart: chart,
        seat: seat,
        computer: computer,
        briefcase: briefcase,
        minidisc: minidisc,
        floppy_disk: floppy_disk,
        cd: cd,
        dvd: dvd,
        file_folder: file_folder,
        open_file_folder: open_file_folder,
        page_with_curl: page_with_curl,
        page_facing_up: page_facing_up,
        date: date,
        calendar: calendar,
        card_index: card_index,
        chart_with_upwards_trend: chart_with_upwards_trend,
        chart_with_downwards_trend: chart_with_downwards_trend,
        bar_chart: bar_chart,
        clipboard: clipboard,
        pushpin: pushpin,
        round_pushpin: round_pushpin,
        paperclip: paperclip,
        straight_ruler: straight_ruler,
        triangular_ruler: triangular_ruler,
        bookmark_tabs: bookmark_tabs,
        ledger: ledger,
        notebook: notebook,
        notebook_with_decorative_cover: notebook_with_decorative_cover,
        closed_book: closed_book,
        book: book,
        open_book: open_book,
        green_book: green_book,
        blue_book: blue_book,
        orange_book: orange_book,
        books: books,
        name_badge: name_badge,
        scroll: scroll,
        memo: memo,
        pencil: pencil,
        telephone_receiver: telephone_receiver,
        pager: pager,
        fax: fax,
        satellite_antenna: satellite_antenna,
        loudspeaker: loudspeaker,
        mega: mega,
        outbox_tray: outbox_tray,
        inbox_tray: inbox_tray,
        incoming_envelope: incoming_envelope,
        envelope_with_arrow: envelope_with_arrow,
        mailbox_closed: mailbox_closed,
        mailbox: mailbox,
        mailbox_with_mail: mailbox_with_mail,
        mailbox_with_no_mail: mailbox_with_no_mail,
        postbox: postbox,
        postal_horn: postal_horn,
        newspaper: newspaper,
        iphone: iphone,
        calling: calling,
        vibration_mode: vibration_mode,
        mobile_phone_off: mobile_phone_off,
        no_mobile_phones: no_mobile_phones,
        signal_strength: signal_strength,
        camera: camera,
        camera_with_flash: camera_with_flash,
        video_camera: video_camera,
        tv: tv,
        radio: radio,
        vhs: vhs,
        film_projector: film_projector,
        prayer_beads: prayer_beads,
        twisted_rightwards_arrows: twisted_rightwards_arrows,
        repeat: repeat,
        repeat_one: repeat_one,
        arrows_clockwise: arrows_clockwise,
        arrows_counterclockwise: arrows_counterclockwise,
        low_brightness: low_brightness,
        high_brightness: high_brightness,
        mute: mute,
        speaker: speaker,
        sound: sound,
        loud_sound: loud_sound,
        battery: battery,
        electric_plug: electric_plug,
        mag: mag,
        mag_right: mag_right,
        lock_with_ink_pen: lock_with_ink_pen,
        closed_lock_with_key: closed_lock_with_key,
        key: key,
        lock: lock,
        unlock: unlock,
        bell: bell,
        no_bell: no_bell,
        bookmark: bookmark,
        link: link,
        radio_button: radio_button,
        back: back,
        end: end,
        on: on,
        soon: soon,
        underage: underage,
        keycap_ten: keycap_ten,
        capital_abcd: capital_abcd,
        abcd: abcd,
        symbols: symbols,
        abc: abc,
        fire: fire,
        flashlight: flashlight,
        wrench: wrench,
        hammer: hammer,
        nut_and_bolt: nut_and_bolt,
        hocho: hocho,
        knife: knife,
        gun: gun,
        microscope: microscope,
        telescope: telescope,
        crystal_ball: crystal_ball,
        six_pointed_star: six_pointed_star,
        beginner: beginner,
        trident: trident,
        black_square_button: black_square_button,
        white_square_button: white_square_button,
        red_circle: red_circle,
        large_blue_circle: large_blue_circle,
        large_orange_diamond: large_orange_diamond,
        large_blue_diamond: large_blue_diamond,
        small_orange_diamond: small_orange_diamond,
        small_blue_diamond: small_blue_diamond,
        small_red_triangle: small_red_triangle,
        small_red_triangle_down: small_red_triangle_down,
        arrow_up_small: arrow_up_small,
        arrow_down_small: arrow_down_small,
        om_symbol: om_symbol,
        dove_of_peace: dove_of_peace,
        kaaba: kaaba,
        mosque: mosque,
        synagogue: synagogue,
        menorah_with_nine_branches: menorah_with_nine_branches,
        candle: candle,
        mantelpiece_clock: mantelpiece_clock,
        hole: hole,
        man_in_business_suit_levitating: man_in_business_suit_levitating,
        sleuth_or_spy: sleuth_or_spy,
        dark_sunglasses: dark_sunglasses,
        spider: spider,
        spider_web: spider_web,
        joystick: joystick,
        man_dancing: man_dancing,
        linked_paperclips: linked_paperclips,
        lower_left_ballpoint_pen: lower_left_ballpoint_pen,
        lower_left_fountain_pen: lower_left_fountain_pen,
        lower_left_paintbrush: lower_left_paintbrush,
        lower_left_crayon: lower_left_crayon,
        raised_hand_with_fingers_splayed: raised_hand_with_fingers_splayed,
        middle_finger: middle_finger,
        reversed_hand_with_middle_finger_extended: reversed_hand_with_middle_finger_extended,
        black_heart: black_heart,
        desktop_computer: desktop_computer,
        printer: printer,
        three_button_mouse: three_button_mouse,
        trackball: trackball,
        frame_with_picture: frame_with_picture,
        card_index_dividers: card_index_dividers,
        card_file_box: card_file_box,
        file_cabinet: file_cabinet,
        wastebasket: wastebasket,
        spiral_note_pad: spiral_note_pad,
        spiral_calendar_pad: spiral_calendar_pad,
        compression: compression,
        old_key: old_key,
        rolled_up_newspaper: rolled_up_newspaper,
        dagger_knife: dagger_knife,
        speaking_head_in_silhouette: speaking_head_in_silhouette,
        left_speech_bubble: left_speech_bubble,
        right_anger_bubble: right_anger_bubble,
        ballot_box_with_ballot: ballot_box_with_ballot,
        world_map: world_map,
        mount_fuji: mount_fuji,
        tokyo_tower: tokyo_tower,
        statue_of_liberty: statue_of_liberty,
        japan: japan,
        moyai: moyai,
        grinning: grinning,
        grin: grin,
        joy: joy,
        smiley: smiley,
        smile: smile,
        sweat_smile: sweat_smile,
        laughing: laughing,
        satisfied: satisfied,
        innocent: innocent,
        smiling_imp: smiling_imp,
        wink: wink,
        blush: blush,
        yum: yum,
        relieved: relieved,
        heart_eyes: heart_eyes,
        sunglasses: sunglasses,
        smirk: smirk,
        neutral_face: neutral_face,
        expressionless: expressionless,
        unamused: unamused,
        sweat: sweat,
        pensive: pensive,
        confused: confused,
        confounded: confounded,
        kissing: kissing,
        kissing_heart: kissing_heart,
        kissing_smiling_eyes: kissing_smiling_eyes,
        kissing_closed_eyes: kissing_closed_eyes,
        stuck_out_tongue: stuck_out_tongue,
        stuck_out_tongue_winking_eye: stuck_out_tongue_winking_eye,
        stuck_out_tongue_closed_eyes: stuck_out_tongue_closed_eyes,
        disappointed: disappointed,
        worried: worried,
        angry: angry,
        rage: rage,
        cry: cry,
        persevere: persevere,
        triumph: triumph,
        disappointed_relieved: disappointed_relieved,
        frowning: frowning,
        anguished: anguished,
        fearful: fearful,
        weary: weary,
        sleepy: sleepy,
        tired_face: tired_face,
        grimacing: grimacing,
        sob: sob,
        open_mouth: open_mouth,
        hushed: hushed,
        cold_sweat: cold_sweat,
        scream: scream,
        astonished: astonished,
        flushed: flushed,
        sleeping: sleeping,
        dizzy_face: dizzy_face,
        no_mouth: no_mouth,
        mask: mask,
        smile_cat: smile_cat,
        joy_cat: joy_cat,
        smiley_cat: smiley_cat,
        heart_eyes_cat: heart_eyes_cat,
        smirk_cat: smirk_cat,
        kissing_cat: kissing_cat,
        pouting_cat: pouting_cat,
        crying_cat_face: crying_cat_face,
        scream_cat: scream_cat,
        slightly_frowning_face: slightly_frowning_face,
        slightly_smiling_face: slightly_smiling_face,
        upside_down_face: upside_down_face,
        face_with_rolling_eyes: face_with_rolling_eyes,
        no_good: no_good,
        ok_woman: ok_woman,
        bow: bow,
        see_no_evil: see_no_evil,
        hear_no_evil: hear_no_evil,
        speak_no_evil: speak_no_evil,
        raising_hand: raising_hand,
        raised_hands: raised_hands,
        person_frowning: person_frowning,
        person_with_pouting_face: person_with_pouting_face,
        pray: pray,
        rocket: rocket,
        helicopter: helicopter,
        steam_locomotive: steam_locomotive,
        railway_car: railway_car,
        bullettrain_side: bullettrain_side,
        bullettrain_front: bullettrain_front,
        train2: train2,
        metro: metro,
        light_rail: light_rail,
        station: station,
        tram: tram,
        train: train,
        bus: bus,
        oncoming_bus: oncoming_bus,
        trolleybus: trolleybus,
        busstop: busstop,
        minibus: minibus,
        ambulance: ambulance,
        fire_engine: fire_engine,
        police_car: police_car,
        oncoming_police_car: oncoming_police_car,
        taxi: taxi,
        oncoming_taxi: oncoming_taxi,
        car: car,
        red_car: red_car,
        oncoming_automobile: oncoming_automobile,
        blue_car: blue_car,
        truck: truck,
        articulated_lorry: articulated_lorry,
        tractor: tractor,
        monorail: monorail,
        mountain_railway: mountain_railway,
        suspension_railway: suspension_railway,
        mountain_cableway: mountain_cableway,
        aerial_tramway: aerial_tramway,
        ship: ship,
        rowboat: rowboat,
        speedboat: speedboat,
        traffic_light: traffic_light,
        vertical_traffic_light: vertical_traffic_light,
        construction: construction,
        rotating_light: rotating_light,
        triangular_flag_on_post: triangular_flag_on_post,
        door: door,
        no_entry_sign: no_entry_sign,
        smoking: smoking,
        no_smoking: no_smoking,
        put_litter_in_its_place: put_litter_in_its_place,
        do_not_litter: do_not_litter,
        potable_water: potable_water,
        bike: bike,
        no_bicycles: no_bicycles,
        bicyclist: bicyclist,
        mountain_bicyclist: mountain_bicyclist,
        walking: walking,
        no_pedestrians: no_pedestrians,
        children_crossing: children_crossing,
        mens: mens,
        womens: womens,
        restroom: restroom,
        baby_symbol: baby_symbol,
        toilet: toilet,
        wc: wc,
        shower: shower,
        bath: bath,
        bathtub: bathtub,
        passport_control: passport_control,
        customs: customs,
        baggage_claim: baggage_claim,
        left_luggage: left_luggage,
        couch_and_lamp: couch_and_lamp,
        sleeping_accommodation: sleeping_accommodation,
        shopping_bags: shopping_bags,
        bellhop_bell: bellhop_bell,
        bed: bed,
        place_of_worship: place_of_worship,
        octagonal_sign: octagonal_sign,
        shopping_trolley: shopping_trolley,
        hammer_and_wrench: hammer_and_wrench,
        shield: shield,
        oil_drum: oil_drum,
        motorway: motorway,
        railway_track: railway_track,
        motor_boat: motor_boat,
        small_airplane: small_airplane,
        airplane_departure: airplane_departure,
        airplane_arriving: airplane_arriving,
        satellite: satellite,
        passenger_ship: passenger_ship,
        scooter: scooter,
        motor_scooter: motor_scooter,
        canoe: canoe,
        sled: sled,
        flying_saucer: flying_saucer,
        zipper_mouth_face: zipper_mouth_face,
        money_mouth_face: money_mouth_face,
        face_with_thermometer: face_with_thermometer,
        nerd_face: nerd_face,
        thinking_face: thinking_face,
        face_with_head_bandage: face_with_head_bandage,
        robot_face: robot_face,
        hugging_face: hugging_face,
        the_horns: the_horns,
        sign_of_the_horns: sign_of_the_horns,
        call_me_hand: call_me_hand,
        raised_back_of_hand: raised_back_of_hand,
        handshake: handshake,
        crossed_fingers: crossed_fingers,
        hand_with_index_and_middle_fingers_crossed: hand_with_index_and_middle_fingers_crossed,
        i_love_you_hand_sign: i_love_you_hand_sign,
        face_with_cowboy_hat: face_with_cowboy_hat,
        clown_face: clown_face,
        nauseated_face: nauseated_face,
        rolling_on_the_floor_laughing: rolling_on_the_floor_laughing,
        drooling_face: drooling_face,
        lying_face: lying_face,
        face_palm: face_palm,
        sneezing_face: sneezing_face,
        face_with_raised_eyebrow: face_with_raised_eyebrow,
        face_with_one_eyebrow_raised: face_with_one_eyebrow_raised,
        grinning_face_with_star_eyes: grinning_face_with_star_eyes,
        zany_face: zany_face,
        grinning_face_with_one_large_and_one_small_eye: grinning_face_with_one_large_and_one_small_eye,
        shushing_face: shushing_face,
        face_with_finger_covering_closed_lips: face_with_finger_covering_closed_lips,
        face_with_symbols_on_mouth: face_with_symbols_on_mouth,
        serious_face_with_symbols_covering_mouth: serious_face_with_symbols_covering_mouth,
        face_with_hand_over_mouth: face_with_hand_over_mouth,
        smiling_face_with_smiling_eyes_and_hand_covering_mouth: smiling_face_with_smiling_eyes_and_hand_covering_mouth,
        face_vomiting: face_vomiting,
        face_with_open_mouth_vomiting: face_with_open_mouth_vomiting,
        exploding_head: exploding_head,
        shocked_face_with_exploding_head: shocked_face_with_exploding_head,
        pregnant_woman: pregnant_woman,
        palms_up_together: palms_up_together,
        selfie: selfie,
        prince: prince,
        man_in_tuxedo: man_in_tuxedo,
        mrs_claus: mrs_claus,
        mother_christmas: mother_christmas,
        shrug: shrug,
        person_doing_cartwheel: person_doing_cartwheel,
        juggling: juggling,
        fencer: fencer,
        wrestlers: wrestlers,
        water_polo: water_polo,
        handball: handball,
        wilted_flower: wilted_flower,
        drum_with_drumsticks: drum_with_drumsticks,
        clinking_glasses: clinking_glasses,
        tumbler_glass: tumbler_glass,
        spoon: spoon,
        goal_net: goal_net,
        first_place_medal: first_place_medal,
        second_place_medal: second_place_medal,
        third_place_medal: third_place_medal,
        boxing_glove: boxing_glove,
        martial_arts_uniform: martial_arts_uniform,
        curling_stone: curling_stone,
        croissant: croissant,
        avocado: avocado,
        cucumber: cucumber,
        bacon: bacon,
        potato: potato,
        carrot: carrot,
        baguette_bread: baguette_bread,
        green_salad: green_salad,
        shallow_pan_of_food: shallow_pan_of_food,
        stuffed_flatbread: stuffed_flatbread,
        egg: egg,
        glass_of_milk: glass_of_milk,
        peanuts: peanuts,
        kiwifruit: kiwifruit,
        pancakes: pancakes,
        dumpling: dumpling,
        fortune_cookie: fortune_cookie,
        takeout_box: takeout_box,
        chopsticks: chopsticks,
        bowl_with_spoon: bowl_with_spoon,
        cup_with_straw: cup_with_straw,
        coconut: coconut,
        broccoli: broccoli,
        pie: pie,
        pretzel: pretzel,
        cut_of_meat: cut_of_meat,
        sandwich: sandwich,
        canned_food: canned_food,
        crab: crab,
        lion_face: lion_face,
        scorpion: scorpion,
        turkey: turkey,
        unicorn_face: unicorn_face,
        eagle: eagle,
        duck: duck,
        bat: bat,
        shark: shark,
        owl: owl,
        fox_face: fox_face,
        butterfly: butterfly,
        deer: deer,
        gorilla: gorilla,
        lizard: lizard,
        rhinoceros: rhinoceros,
        shrimp: shrimp,
        squid: squid,
        giraffe_face: giraffe_face,
        zebra_face: zebra_face,
        hedgehog: hedgehog,
        sauropod: sauropod,
        cricket: cricket,
        cheese_wedge: cheese_wedge,
        face_with_monocle: face_with_monocle,
        adult: adult,
        child: child,
        older_adult: older_adult,
        bearded_person: bearded_person,
        person_with_headscarf: person_with_headscarf,
        woman_in_steamy_room: woman_in_steamy_room,
        man_in_steamy_room: man_in_steamy_room,
        person_in_steamy_room: person_in_steamy_room,
        woman_climbing: woman_climbing,
        person_climbing: person_climbing,
        man_climbing: man_climbing,
        woman_in_lotus_position: woman_in_lotus_position,
        person_in_lotus_position: person_in_lotus_position,
        man_in_lotus_position: man_in_lotus_position,
        female_mage: female_mage,
        mage: mage,
        male_mage: male_mage,
        female_fairy: female_fairy,
        fairy: fairy,
        male_fairy: male_fairy,
        female_vampire: female_vampire,
        vampire: vampire,
        male_vampire: male_vampire,
        mermaid: mermaid,
        merman: merman,
        merperson: merperson,
        female_elf: female_elf,
        male_elf: male_elf,
        elf: elf,
        female_genie: female_genie,
        male_genie: male_genie,
        genie: genie,
        female_zombie: female_zombie,
        male_zombie: male_zombie,
        zombie: zombie,
        brain: brain,
        orange_heart: orange_heart,
        billed_cap: billed_cap,
        scarf: scarf,
        gloves: gloves,
        coat: coat,
        socks: socks,
        bangbang: bangbang,
        interrobang: interrobang,
        tm: tm,
        information_source: information_source,
        left_right_arrow: left_right_arrow,
        arrow_up_down: arrow_up_down,
        arrow_upper_left: arrow_upper_left,
        arrow_upper_right: arrow_upper_right,
        arrow_lower_right: arrow_lower_right,
        arrow_lower_left: arrow_lower_left,
        leftwards_arrow_with_hook: leftwards_arrow_with_hook,
        arrow_right_hook: arrow_right_hook,
        watch: watch,
        hourglass: hourglass,
        keyboard: keyboard,
        eject: eject,
        fast_forward: fast_forward,
        rewind: rewind,
        arrow_double_up: arrow_double_up,
        arrow_double_down: arrow_double_down,
        black_right_pointing_double_triangle_with_vertical_bar: black_right_pointing_double_triangle_with_vertical_bar,
        black_left_pointing_double_triangle_with_vertical_bar: black_left_pointing_double_triangle_with_vertical_bar,
        black_right_pointing_triangle_with_double_vertical_bar: black_right_pointing_triangle_with_double_vertical_bar,
        alarm_clock: alarm_clock,
        stopwatch: stopwatch,
        timer_clock: timer_clock,
        hourglass_flowing_sand: hourglass_flowing_sand,
        double_vertical_bar: double_vertical_bar,
        black_square_for_stop: black_square_for_stop,
        black_circle_for_record: black_circle_for_record,
        m: m,
        black_small_square: black_small_square,
        white_small_square: white_small_square,
        arrow_forward: arrow_forward,
        arrow_backward: arrow_backward,
        white_medium_square: white_medium_square,
        black_medium_square: black_medium_square,
        white_medium_small_square: white_medium_small_square,
        black_medium_small_square: black_medium_small_square,
        sunny: sunny,
        cloud: cloud,
        umbrella: umbrella,
        snowman: snowman,
        comet: comet,
        phone: phone,
        telephone: telephone,
        ballot_box_with_check: ballot_box_with_check,
        shamrock: shamrock,
        point_up: point_up,
        skull_and_crossbones: skull_and_crossbones,
        radioactive_sign: radioactive_sign,
        biohazard_sign: biohazard_sign,
        orthodox_cross: orthodox_cross,
        star_and_crescent: star_and_crescent,
        peace_symbol: peace_symbol,
        yin_yang: yin_yang,
        wheel_of_dharma: wheel_of_dharma,
        white_frowning_face: white_frowning_face,
        relaxed: relaxed,
        female_sign: female_sign,
        male_sign: male_sign,
        gemini: gemini,
        cancer: cancer,
        leo: leo,
        virgo: virgo,
        libra: libra,
        scorpius: scorpius,
        spades: spades,
        clubs: clubs,
        hearts: hearts,
        diamonds: diamonds,
        hotsprings: hotsprings,
        recycle: recycle,
        wheelchair: wheelchair,
        hammer_and_pick: hammer_and_pick,
        crossed_swords: crossed_swords,
        medical_symbol: medical_symbol,
        staff_of_aesculapius: staff_of_aesculapius,
        scales: scales,
        alembic: alembic,
        gear: gear,
        atom_symbol: atom_symbol,
        fleur_de_lis: fleur_de_lis,
        warning: warning,
        zap: zap,
        white_circle: white_circle,
        black_circle: black_circle,
        coffin: coffin,
        funeral_urn: funeral_urn,
        soccer: soccer,
        baseball: baseball,
        snowman_without_snow: snowman_without_snow,
        partly_sunny: partly_sunny,
        thunder_cloud_and_rain: thunder_cloud_and_rain,
        ophiuchus: ophiuchus,
        pick: pick,
        helmet_with_white_cross: helmet_with_white_cross,
        chains: chains,
        no_entry: no_entry,
        shinto_shrine: shinto_shrine,
        church: church,
        mountain: mountain,
        umbrella_on_ground: umbrella_on_ground,
        fountain: fountain,
        golf: golf,
        ferry: ferry,
        boat: boat,
        sailboat: sailboat,
        skier: skier,
        ice_skate: ice_skate,
        person_with_ball: person_with_ball,
        tent: tent,
        fuelpump: fuelpump,
        scissors: scissors,
        airplane: airplane,
        email: email,
        envelope: envelope,
        fist: fist,
        hand: hand,
        raised_hand: raised_hand,
        v: v,
        writing_hand: writing_hand,
        pencil2: pencil2,
        black_nib: black_nib,
        heavy_check_mark: heavy_check_mark,
        heavy_multiplication_x: heavy_multiplication_x,
        latin_cross: latin_cross,
        star_of_david: star_of_david,
        eight_spoked_asterisk: eight_spoked_asterisk,
        eight_pointed_black_star: eight_pointed_black_star,
        snowflake: snowflake,
        sparkle: sparkle,
        x: x,
        negative_squared_cross_mark: negative_squared_cross_mark,
        heavy_heart_exclamation_mark_ornament: heavy_heart_exclamation_mark_ornament,
        heart: heart,
        arrow_right: arrow_right,
        curly_loop: curly_loop,
        loop: loop,
        arrow_heading_up: arrow_heading_up,
        arrow_heading_down: arrow_heading_down,
        arrow_left: arrow_left,
        arrow_up: arrow_up,
        arrow_down: arrow_down,
        black_large_square: black_large_square,
        white_large_square: white_large_square,
        star: star,
        o: o,
        wavy_dash: wavy_dash,
        part_alternation_mark: part_alternation_mark,
        congratulations: congratulations,
        secret: secret,
        'default': emoji
    });

    var emojiByName = getCjsExportFromNamespace(emoji$1);

    /**
     * regex to parse emoji in a string - finds emoji, e.g. :coffee:
     */
    var emojiNameRegex = /:([a-zA-Z0-9_\-\+]+):/g;

    /**
     * regex to trim whitespace
     * use instead of String.prototype.trim() for IE8 support
     */
    var trimSpaceRegex = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;

    /**
     * Removes colons on either side
     * of the string if present
     * @param  {string} str
     * @return {string}
     */
    function stripColons(str) {
      var colonIndex = str.indexOf(':');
      if (colonIndex > -1) {
        // :emoji: (http://www.emoji-cheat-sheet.com/)
        if (colonIndex === str.length - 1) {
          str = str.substring(0, colonIndex);
          return stripColons(str);
        } else {
          str = str.substr(colonIndex + 1);
          return stripColons(str);
        }
      }

      return str;
    }

    /**
     * Adds colons to either side
     * of the string
     * @param {string} str
     * @return {string}
     */
    function wrapColons(str) {
      return (typeof str === 'string' && str.length > 0) ? ':' + str + ':' : str;
    }

    /**
     * Ensure that the word is wrapped in colons
     * by only adding them, if they are not there.
     * @param {string} str
     * @return {string}
     */
    function ensureColons(str) {
      return (typeof str === 'string' && str[0] !== ':') ? wrapColons(str) : str;
    }

    // Remove the non-spacing-mark from the code, never send a stripped version
    // to the client, as it kills graphical emoticons.
    function stripNSB(code) {
      return code;
    }
    // Reversed hash table, where as emojiByName contains a { heart: '❤' }
    // dictionary emojiByCode contains { ❤: 'heart' }. The codes are normalized
    // to the text version.
    var emojiByCode = Object.keys(emojiByName).reduce(function (h, k) {
      h[stripNSB(emojiByName[k])] = k;
      return h;
    }, {});

    /**
     * Emoji namespace
     */
    var Emoji = {
      emoji: emojiByName,
    };

    /**
     * get emoji code from name
     * @param  {string} emoji
     * @return {string}
     */
    Emoji._get = function _get(emoji) {
      if (emojiByName.hasOwnProperty(emoji)) {
        return emojiByName[emoji];
      }

      return ensureColons(emoji);
    };

    /**
     * get emoji code from :emoji: string or name
     * @param  {string} emoji
     * @return {string}
     */
    Emoji.get = function get(emoji) {
      emoji = stripColons(emoji);

      return Emoji._get(emoji);
    };

    /**
     * find the emoji by either code or name
     * @param {string} nameOrCode The emoji to find, either `coffee`, `:coffee:` or `☕`;
     * @return {object}
     */
    Emoji.find = function find(nameOrCode) {
      return Emoji.findByName(nameOrCode) || Emoji.findByCode(nameOrCode);
    };

    /**
     * find the emoji by name
     * @param {string} name The emoji to find either `coffee` or `:coffee:`;
     * @return {object}
     */
    Emoji.findByName = function findByName(name) {
      var stripped = stripColons(name);
      var emoji = emojiByName[stripped];

      return emoji ? ({ emoji: emoji, key: stripped }) : undefined;
    };

    /**
     * find the emoji by code (emoji)
     * @param {string} code The emoji to find; for example `☕` or `☔`
     * @return {object}
     */
    Emoji.findByCode = function findByCode(code) {
      var stripped = stripNSB(code);
      var name = emojiByCode[stripped];

      // lookup emoji to ensure the Variant Form is returned
      return name ? ({ emoji: emojiByName[name], key: name }) : undefined;
    };


    /**
     * Check if an emoji is known by this library
     * @param {string} nameOrCode The emoji to validate, either `coffee`, `:coffee:` or `☕`;
     * @return {object}
     */
    Emoji.hasEmoji = function hasEmoji(nameOrCode) {
      return Emoji.hasEmojiByName(nameOrCode) || Emoji.hasEmojiByCode(nameOrCode);
    };

    /**
     * Check if an emoji with given name is known by this library
     * @param {string} name The emoji to validate either `coffee` or `:coffee:`;
     * @return {object}
     */
    Emoji.hasEmojiByName = function hasEmojiByName(name) {
      var result = Emoji.findByName(name);
      return !!result && result.key === stripColons(name);
    };

    /**
     * Check if a given emoji is known by this library
     * @param {string} code The emoji to validate; for example `☕` or `☔`
     * @return {object}
     */
    Emoji.hasEmojiByCode = function hasEmojiByCode(code) {
      var result = Emoji.findByCode(code);
      return !!result && stripNSB(result.emoji) === stripNSB(code);
    };

    /**
     * get emoji name from code
     * @param  {string} emoji
     * @param  {boolean} includeColons should the result include the ::
     * @return {string}
     */
    Emoji.which = function which(emoji_code, includeColons) {
      var code = stripNSB(emoji_code);
      var word = emojiByCode[code];

      return includeColons ? wrapColons(word) : word;
    };

    /**
     * emojify a string (replace :emoji: with an emoji)
     * @param  {string} str
     * @param  {function} on_missing (gets emoji name without :: and returns a proper emoji if no emoji was found)
     * @param  {function} format (wrap the returned emoji in a custom element)
     * @return {string}
     */
    Emoji.emojify = function emojify(str, on_missing, format) {
      if (!str) return '';

      return str.split(emojiNameRegex) // parse emoji via regex
        .map(function parseEmoji(s, i) {
          // every second element is an emoji, e.g. "test :fast_forward:" -> [ "test ", "fast_forward" ]
          if (i % 2 === 0) return s;
          var emoji = Emoji._get(s);
          var isMissing = emoji.indexOf(':') > -1;

          if (isMissing && typeof on_missing === 'function') {
            return on_missing(s);
          }

          if (!isMissing && typeof format === 'function') {
            return format(emoji, s);
          }

          return emoji;
        })
        .join('') // convert back to string
        ;
    };

    /**
     * return a random emoji
     * @return {string}
     */
    Emoji.random = function random() {
      var emojiKeys = Object.keys(emojiByName);
      var randomIndex = Math.floor(Math.random() * emojiKeys.length);
      var key = emojiKeys[randomIndex];
      var emoji = Emoji._get(key);
      return { key: key, emoji: emoji };
    };

    /**
     *  return an collection of potential emoji matches
     *  @param {string} str
     *  @return {Array.<Object>}
     */
    Emoji.search = function search(str) {
      var emojiKeys = Object.keys(emojiByName);
      var matcher = stripColons(str);
      var matchingKeys = emojiKeys.filter(function (key) {
        return key.toString().indexOf(matcher) === 0;
      });
      return matchingKeys.map(function (key) {
        return {
          key: key,
          emoji: Emoji._get(key),
        };
      });
    };

    /**
     * unemojify a string (replace emoji with :emoji:)
     * @param  {string} str
     * @return {string}
     */
    Emoji.unemojify = function unemojify(str) {
      if (!str) return '';
      var words = lodash_toarray(str);

      return words.map(function (word) {
        return Emoji.which(word, true) || word;
      }).join('');
    };

    /**
     * replace emojis with replacement value
     * @param {string} str
     * @param {function|string} the string or callback function to replace the emoji with
     * @param {boolean} should trailing whitespaces be cleaned? Defaults false
     * @return {string}
     */
    Emoji.replace = function replace(str, replacement, cleanSpaces) {
      if (!str) return '';

      var replace = typeof replacement === 'function' ? replacement : function () { return replacement; };
      var words = lodash_toarray(str);

      var replaced = words.map(function (word, idx) {
        var emoji = Emoji.findByCode(word);
        
        if (emoji && cleanSpaces && words[idx + 1] === ' ') {
          words[idx + 1] = '';
        }

        return emoji ? replace(emoji) : word;
      }).join('');

      return cleanSpaces ? replaced.replace(trimSpaceRegex, '') : replaced;
    };


    /**
     * remove all emojis from a string
     * @param {string} str
     * @return {string}
     */
    Emoji.strip = function strip(str) {
      return Emoji.replace(str, '', true);
    };

    var emoji$2 = Emoji;

    var nodeEmoji = emoji$2;

    var defaults = createCommonjsModule(function (module) {
    function getDefaults() {
      return {
        baseUrl: null,
        breaks: false,
        gfm: true,
        headerIds: true,
        headerPrefix: '',
        highlight: null,
        langPrefix: 'language-',
        mangle: true,
        pedantic: false,
        renderer: null,
        sanitize: false,
        sanitizer: null,
        silent: false,
        smartLists: false,
        smartypants: false,
        xhtml: false
      };
    }

    function changeDefaults(newDefaults) {
      module.exports.defaults = newDefaults;
    }

    module.exports = {
      defaults: getDefaults(),
      getDefaults,
      changeDefaults
    };
    });
    var defaults_1 = defaults.defaults;
    var defaults_2 = defaults.getDefaults;
    var defaults_3 = defaults.changeDefaults;

    /**
     * Helpers
     */
    const escapeTest = /[&<>"']/;
    const escapeReplace = /[&<>"']/g;
    const escapeTestNoEncode = /[<>"']|&(?!#?\w+;)/;
    const escapeReplaceNoEncode = /[<>"']|&(?!#?\w+;)/g;
    const escapeReplacements = {
      '&': '&amp;',
      '<': '&lt;',
      '>': '&gt;',
      '"': '&quot;',
      "'": '&#39;'
    };
    const getEscapeReplacement = (ch) => escapeReplacements[ch];
    function escape(html, encode) {
      if (encode) {
        if (escapeTest.test(html)) {
          return html.replace(escapeReplace, getEscapeReplacement);
        }
      } else {
        if (escapeTestNoEncode.test(html)) {
          return html.replace(escapeReplaceNoEncode, getEscapeReplacement);
        }
      }

      return html;
    }

    const unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;

    function unescape$1(html) {
      // explicitly match decimal, hex, and named HTML entities
      return html.replace(unescapeTest, (_, n) => {
        n = n.toLowerCase();
        if (n === 'colon') return ':';
        if (n.charAt(0) === '#') {
          return n.charAt(1) === 'x'
            ? String.fromCharCode(parseInt(n.substring(2), 16))
            : String.fromCharCode(+n.substring(1));
        }
        return '';
      });
    }

    const caret = /(^|[^\[])\^/g;
    function edit(regex, opt) {
      regex = regex.source || regex;
      opt = opt || '';
      const obj = {
        replace: (name, val) => {
          val = val.source || val;
          val = val.replace(caret, '$1');
          regex = regex.replace(name, val);
          return obj;
        },
        getRegex: () => {
          return new RegExp(regex, opt);
        }
      };
      return obj;
    }

    const nonWordAndColonTest = /[^\w:]/g;
    const originIndependentUrl = /^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;
    function cleanUrl(sanitize, base, href) {
      if (sanitize) {
        let prot;
        try {
          prot = decodeURIComponent(unescape$1(href))
            .replace(nonWordAndColonTest, '')
            .toLowerCase();
        } catch (e) {
          return null;
        }
        if (prot.indexOf('javascript:') === 0 || prot.indexOf('vbscript:') === 0 || prot.indexOf('data:') === 0) {
          return null;
        }
      }
      if (base && !originIndependentUrl.test(href)) {
        href = resolveUrl(base, href);
      }
      try {
        href = encodeURI(href).replace(/%25/g, '%');
      } catch (e) {
        return null;
      }
      return href;
    }

    const baseUrls = {};
    const justDomain = /^[^:]+:\/*[^/]*$/;
    const protocol = /^([^:]+:)[\s\S]*$/;
    const domain = /^([^:]+:\/*[^/]*)[\s\S]*$/;

    function resolveUrl(base, href) {
      if (!baseUrls[' ' + base]) {
        // we can ignore everything in base after the last slash of its path component,
        // but we might need to add _that_
        // https://tools.ietf.org/html/rfc3986#section-3
        if (justDomain.test(base)) {
          baseUrls[' ' + base] = base + '/';
        } else {
          baseUrls[' ' + base] = rtrim(base, '/', true);
        }
      }
      base = baseUrls[' ' + base];
      const relativeBase = base.indexOf(':') === -1;

      if (href.substring(0, 2) === '//') {
        if (relativeBase) {
          return href;
        }
        return base.replace(protocol, '$1') + href;
      } else if (href.charAt(0) === '/') {
        if (relativeBase) {
          return href;
        }
        return base.replace(domain, '$1') + href;
      } else {
        return base + href;
      }
    }

    const noopTest = { exec: function noopTest() {} };

    function merge(obj) {
      let i = 1,
        target,
        key;

      for (; i < arguments.length; i++) {
        target = arguments[i];
        for (key in target) {
          if (Object.prototype.hasOwnProperty.call(target, key)) {
            obj[key] = target[key];
          }
        }
      }

      return obj;
    }

    function splitCells(tableRow, count) {
      // ensure that every cell-delimiting pipe has a space
      // before it to distinguish it from an escaped pipe
      const row = tableRow.replace(/\|/g, (match, offset, str) => {
          let escaped = false,
            curr = offset;
          while (--curr >= 0 && str[curr] === '\\') escaped = !escaped;
          if (escaped) {
            // odd number of slashes means | is escaped
            // so we leave it alone
            return '|';
          } else {
            // add space before unescaped |
            return ' |';
          }
        }),
        cells = row.split(/ \|/);
      let i = 0;

      if (cells.length > count) {
        cells.splice(count);
      } else {
        while (cells.length < count) cells.push('');
      }

      for (; i < cells.length; i++) {
        // leading or trailing whitespace is ignored per the gfm spec
        cells[i] = cells[i].trim().replace(/\\\|/g, '|');
      }
      return cells;
    }

    // Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
    // /c*$/ is vulnerable to REDOS.
    // invert: Remove suffix of non-c chars instead. Default falsey.
    function rtrim(str, c, invert) {
      const l = str.length;
      if (l === 0) {
        return '';
      }

      // Length of suffix matching the invert condition.
      let suffLen = 0;

      // Step left until we fail to match the invert condition.
      while (suffLen < l) {
        const currChar = str.charAt(l - suffLen - 1);
        if (currChar === c && !invert) {
          suffLen++;
        } else if (currChar !== c && invert) {
          suffLen++;
        } else {
          break;
        }
      }

      return str.substr(0, l - suffLen);
    }

    function findClosingBracket(str, b) {
      if (str.indexOf(b[1]) === -1) {
        return -1;
      }
      const l = str.length;
      let level = 0,
        i = 0;
      for (; i < l; i++) {
        if (str[i] === '\\') {
          i++;
        } else if (str[i] === b[0]) {
          level++;
        } else if (str[i] === b[1]) {
          level--;
          if (level < 0) {
            return i;
          }
        }
      }
      return -1;
    }

    function checkSanitizeDeprecation(opt) {
      if (opt && opt.sanitize && !opt.silent) {
        console.warn('marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options');
      }
    }

    var helpers = {
      escape,
      unescape: unescape$1,
      edit,
      cleanUrl,
      resolveUrl,
      noopTest,
      merge,
      splitCells,
      rtrim,
      findClosingBracket,
      checkSanitizeDeprecation
    };

    const {
      noopTest: noopTest$1,
      edit: edit$1,
      merge: merge$1
    } = helpers;

    /**
     * Block-Level Grammar
     */
    const block = {
      newline: /^\n+/,
      code: /^( {4}[^\n]+\n*)+/,
      fences: /^ {0,3}(`{3,}|~{3,})([^`~\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?:\n+|$)|$)/,
      hr: /^ {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)/,
      heading: /^ {0,3}(#{1,6}) +([^\n]*?)(?: +#+)? *(?:\n+|$)/,
      blockquote: /^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,
      list: /^( {0,3})(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?!\1bull )\n*|\s*$)/,
      html: '^ {0,3}(?:' // optional indentation
        + '<(script|pre|style)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)' // (1)
        + '|comment[^\\n]*(\\n+|$)' // (2)
        + '|<\\?[\\s\\S]*?\\?>\\n*' // (3)
        + '|<![A-Z][\\s\\S]*?>\\n*' // (4)
        + '|<!\\[CDATA\\[[\\s\\S]*?\\]\\]>\\n*' // (5)
        + '|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:\\n{2,}|$)' // (6)
        + '|<(?!script|pre|style)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$)' // (7) open tag
        + '|</(?!script|pre|style)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$)' // (7) closing tag
        + ')',
      def: /^ {0,3}\[(label)\]: *\n? *<?([^\s>]+)>?(?:(?: +\n? *| *\n *)(title))? *(?:\n+|$)/,
      nptable: noopTest$1,
      table: noopTest$1,
      lheading: /^([^\n]+)\n {0,3}(=+|-+) *(?:\n+|$)/,
      // regex template, placeholders will be replaced according to different paragraph
      // interruption rules of commonmark and the original markdown spec:
      _paragraph: /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html)[^\n]+)*)/,
      text: /^[^\n]+/
    };

    block._label = /(?!\s*\])(?:\\[\[\]]|[^\[\]])+/;
    block._title = /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/;
    block.def = edit$1(block.def)
      .replace('label', block._label)
      .replace('title', block._title)
      .getRegex();

    block.bullet = /(?:[*+-]|\d{1,9}\.)/;
    block.item = /^( *)(bull) ?[^\n]*(?:\n(?!\1bull ?)[^\n]*)*/;
    block.item = edit$1(block.item, 'gm')
      .replace(/bull/g, block.bullet)
      .getRegex();

    block.list = edit$1(block.list)
      .replace(/bull/g, block.bullet)
      .replace('hr', '\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))')
      .replace('def', '\\n+(?=' + block.def.source + ')')
      .getRegex();

    block._tag = 'address|article|aside|base|basefont|blockquote|body|caption'
      + '|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption'
      + '|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe'
      + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option'
      + '|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr'
      + '|track|ul';
    block._comment = /<!--(?!-?>)[\s\S]*?-->/;
    block.html = edit$1(block.html, 'i')
      .replace('comment', block._comment)
      .replace('tag', block._tag)
      .replace('attribute', / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/)
      .getRegex();

    block.paragraph = edit$1(block._paragraph)
      .replace('hr', block.hr)
      .replace('heading', ' {0,3}#{1,6} +')
      .replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
      .replace('blockquote', ' {0,3}>')
      .replace('fences', ' {0,3}(?:`{3,}|~{3,})[^`\\n]*\\n')
      .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
      .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)')
      .replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
      .getRegex();

    block.blockquote = edit$1(block.blockquote)
      .replace('paragraph', block.paragraph)
      .getRegex();

    /**
     * Normal Block Grammar
     */

    block.normal = merge$1({}, block);

    /**
     * GFM Block Grammar
     */

    block.gfm = merge$1({}, block.normal, {
      nptable: /^ *([^|\n ].*\|.*)\n *([-:]+ *\|[-| :]*)(?:\n((?:.*[^>\n ].*(?:\n|$))*)\n*|$)/,
      table: /^ *\|(.+)\n *\|?( *[-:]+[-| :]*)(?:\n((?: *[^>\n ].*(?:\n|$))*)\n*|$)/
    });

    /**
     * Pedantic grammar (original John Gruber's loose markdown specification)
     */

    block.pedantic = merge$1({}, block.normal, {
      html: edit$1(
        '^ *(?:comment *(?:\\n|\\s*$)'
        + '|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)' // closed tag
        + '|<tag(?:"[^"]*"|\'[^\']*\'|\\s[^\'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))')
        .replace('comment', block._comment)
        .replace(/tag/g, '(?!(?:'
          + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub'
          + '|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)'
          + '\\b)\\w+(?!:|[^\\w\\s@]*@)\\b')
        .getRegex(),
      def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
      heading: /^ *(#{1,6}) *([^\n]+?) *(?:#+ *)?(?:\n+|$)/,
      fences: noopTest$1, // fences not supported
      paragraph: edit$1(block.normal._paragraph)
        .replace('hr', block.hr)
        .replace('heading', ' *#{1,6} *[^\n]')
        .replace('lheading', block.lheading)
        .replace('blockquote', ' {0,3}>')
        .replace('|fences', '')
        .replace('|list', '')
        .replace('|html', '')
        .getRegex()
    });

    /**
     * Inline-Level Grammar
     */
    const inline = {
      escape: /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,
      autolink: /^<(scheme:[^\s\x00-\x1f<>]*|email)>/,
      url: noopTest$1,
      tag: '^comment'
        + '|^</[a-zA-Z][\\w:-]*\\s*>' // self-closing tag
        + '|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>' // open tag
        + '|^<\\?[\\s\\S]*?\\?>' // processing instruction, e.g. <?php ?>
        + '|^<![a-zA-Z]+\\s[\\s\\S]*?>' // declaration, e.g. <!DOCTYPE html>
        + '|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>', // CDATA section
      link: /^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/,
      reflink: /^!?\[(label)\]\[(?!\s*\])((?:\\[\[\]]?|[^\[\]\\])+)\]/,
      nolink: /^!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?/,
      strong: /^__([^\s_])__(?!_)|^\*\*([^\s*])\*\*(?!\*)|^__([^\s][\s\S]*?[^\s])__(?!_)|^\*\*([^\s][\s\S]*?[^\s])\*\*(?!\*)/,
      em: /^_([^\s_])_(?!_)|^\*([^\s*<\[])\*(?!\*)|^_([^\s<][\s\S]*?[^\s_])_(?!_|[^\spunctuation])|^_([^\s_<][\s\S]*?[^\s])_(?!_|[^\spunctuation])|^\*([^\s<"][\s\S]*?[^\s\*])\*(?!\*|[^\spunctuation])|^\*([^\s*"<\[][\s\S]*?[^\s])\*(?!\*)/,
      code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
      br: /^( {2,}|\\)\n(?!\s*$)/,
      del: noopTest$1,
      text: /^(`+|[^`])(?:[\s\S]*?(?:(?=[\\<!\[`*]|\b_|$)|[^ ](?= {2,}\n))|(?= {2,}\n))/
    };

    // list of punctuation marks from common mark spec
    // without ` and ] to workaround Rule 17 (inline code blocks/links)
    inline._punctuation = '!"#$%&\'()*+,\\-./:;<=>?@\\[^_{|}~';
    inline.em = edit$1(inline.em).replace(/punctuation/g, inline._punctuation).getRegex();

    inline._escapes = /\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g;

    inline._scheme = /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/;
    inline._email = /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/;
    inline.autolink = edit$1(inline.autolink)
      .replace('scheme', inline._scheme)
      .replace('email', inline._email)
      .getRegex();

    inline._attribute = /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/;

    inline.tag = edit$1(inline.tag)
      .replace('comment', block._comment)
      .replace('attribute', inline._attribute)
      .getRegex();

    inline._label = /(?:\[[^\[\]]*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
    inline._href = /<(?:\\[<>]?|[^\s<>\\])*>|[^\s\x00-\x1f]*/;
    inline._title = /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/;

    inline.link = edit$1(inline.link)
      .replace('label', inline._label)
      .replace('href', inline._href)
      .replace('title', inline._title)
      .getRegex();

    inline.reflink = edit$1(inline.reflink)
      .replace('label', inline._label)
      .getRegex();

    /**
     * Normal Inline Grammar
     */

    inline.normal = merge$1({}, inline);

    /**
     * Pedantic Inline Grammar
     */

    inline.pedantic = merge$1({}, inline.normal, {
      strong: /^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,
      em: /^_(?=\S)([\s\S]*?\S)_(?!_)|^\*(?=\S)([\s\S]*?\S)\*(?!\*)/,
      link: edit$1(/^!?\[(label)\]\((.*?)\)/)
        .replace('label', inline._label)
        .getRegex(),
      reflink: edit$1(/^!?\[(label)\]\s*\[([^\]]*)\]/)
        .replace('label', inline._label)
        .getRegex()
    });

    /**
     * GFM Inline Grammar
     */

    inline.gfm = merge$1({}, inline.normal, {
      escape: edit$1(inline.escape).replace('])', '~|])').getRegex(),
      _extended_email: /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/,
      url: /^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,
      _backpedal: /(?:[^?!.,:;*_~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_~)]+(?!$))+/,
      del: /^~+(?=\S)([\s\S]*?\S)~+/,
      text: /^(`+|[^`])(?:[\s\S]*?(?:(?=[\\<!\[`*~]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))|(?= {2,}\n|[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))/
    });

    inline.gfm.url = edit$1(inline.gfm.url, 'i')
      .replace('email', inline.gfm._extended_email)
      .getRegex();
    /**
     * GFM + Line Breaks Inline Grammar
     */

    inline.breaks = merge$1({}, inline.gfm, {
      br: edit$1(inline.br).replace('{2,}', '*').getRegex(),
      text: edit$1(inline.gfm.text)
        .replace('\\b_', '\\b_| {2,}\\n')
        .replace(/\{2,\}/g, '*')
        .getRegex()
    });

    var rules = {
      block,
      inline
    };

    const { defaults: defaults$1 } = defaults;
    const { block: block$1 } = rules;
    const {
      rtrim: rtrim$1,
      splitCells: splitCells$1,
      escape: escape$1
    } = helpers;

    /**
     * Block Lexer
     */
    var Lexer_1 = class Lexer {
      constructor(options) {
        this.tokens = [];
        this.tokens.links = Object.create(null);
        this.options = options || defaults$1;
        this.rules = block$1.normal;

        if (this.options.pedantic) {
          this.rules = block$1.pedantic;
        } else if (this.options.gfm) {
          this.rules = block$1.gfm;
        }
      }

      /**
       * Expose Block Rules
       */
      static get rules() {
        return block$1;
      }

      /**
       * Static Lex Method
       */
      static lex(src, options) {
        const lexer = new Lexer(options);
        return lexer.lex(src);
      };

      /**
       * Preprocessing
       */
      lex(src) {
        src = src
          .replace(/\r\n|\r/g, '\n')
          .replace(/\t/g, '    ');

        return this.token(src, true);
      };

      /**
       * Lexing
       */
      token(src, top) {
        src = src.replace(/^ +$/gm, '');
        let next,
          loose,
          cap,
          bull,
          b,
          item,
          listStart,
          listItems,
          t,
          space,
          i,
          tag,
          l,
          isordered,
          istask,
          ischecked;

        while (src) {
          // newline
          if (cap = this.rules.newline.exec(src)) {
            src = src.substring(cap[0].length);
            if (cap[0].length > 1) {
              this.tokens.push({
                type: 'space'
              });
            }
          }

          // code
          if (cap = this.rules.code.exec(src)) {
            const lastToken = this.tokens[this.tokens.length - 1];
            src = src.substring(cap[0].length);
            // An indented code block cannot interrupt a paragraph.
            if (lastToken && lastToken.type === 'paragraph') {
              lastToken.text += '\n' + cap[0].trimRight();
            } else {
              cap = cap[0].replace(/^ {4}/gm, '');
              this.tokens.push({
                type: 'code',
                codeBlockStyle: 'indented',
                text: !this.options.pedantic
                  ? rtrim$1(cap, '\n')
                  : cap
              });
            }
            continue;
          }

          // fences
          if (cap = this.rules.fences.exec(src)) {
            src = src.substring(cap[0].length);
            this.tokens.push({
              type: 'code',
              lang: cap[2] ? cap[2].trim() : cap[2],
              text: cap[3] || ''
            });
            continue;
          }

          // heading
          if (cap = this.rules.heading.exec(src)) {
            src = src.substring(cap[0].length);
            this.tokens.push({
              type: 'heading',
              depth: cap[1].length,
              text: cap[2]
            });
            continue;
          }

          // table no leading pipe (gfm)
          if (cap = this.rules.nptable.exec(src)) {
            item = {
              type: 'table',
              header: splitCells$1(cap[1].replace(/^ *| *\| *$/g, '')),
              align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
              cells: cap[3] ? cap[3].replace(/\n$/, '').split('\n') : []
            };

            if (item.header.length === item.align.length) {
              src = src.substring(cap[0].length);

              for (i = 0; i < item.align.length; i++) {
                if (/^ *-+: *$/.test(item.align[i])) {
                  item.align[i] = 'right';
                } else if (/^ *:-+: *$/.test(item.align[i])) {
                  item.align[i] = 'center';
                } else if (/^ *:-+ *$/.test(item.align[i])) {
                  item.align[i] = 'left';
                } else {
                  item.align[i] = null;
                }
              }

              for (i = 0; i < item.cells.length; i++) {
                item.cells[i] = splitCells$1(item.cells[i], item.header.length);
              }

              this.tokens.push(item);

              continue;
            }
          }

          // hr
          if (cap = this.rules.hr.exec(src)) {
            src = src.substring(cap[0].length);
            this.tokens.push({
              type: 'hr'
            });
            continue;
          }

          // blockquote
          if (cap = this.rules.blockquote.exec(src)) {
            src = src.substring(cap[0].length);

            this.tokens.push({
              type: 'blockquote_start'
            });

            cap = cap[0].replace(/^ *> ?/gm, '');

            // Pass `top` to keep the current
            // "toplevel" state. This is exactly
            // how markdown.pl works.
            this.token(cap, top);

            this.tokens.push({
              type: 'blockquote_end'
            });

            continue;
          }

          // list
          if (cap = this.rules.list.exec(src)) {
            src = src.substring(cap[0].length);
            bull = cap[2];
            isordered = bull.length > 1;

            listStart = {
              type: 'list_start',
              ordered: isordered,
              start: isordered ? +bull : '',
              loose: false
            };

            this.tokens.push(listStart);

            // Get each top-level item.
            cap = cap[0].match(this.rules.item);

            listItems = [];
            next = false;
            l = cap.length;
            i = 0;

            for (; i < l; i++) {
              item = cap[i];

              // Remove the list item's bullet
              // so it is seen as the next token.
              space = item.length;
              item = item.replace(/^ *([*+-]|\d+\.) */, '');

              // Outdent whatever the
              // list item contains. Hacky.
              if (~item.indexOf('\n ')) {
                space -= item.length;
                item = !this.options.pedantic
                  ? item.replace(new RegExp('^ {1,' + space + '}', 'gm'), '')
                  : item.replace(/^ {1,4}/gm, '');
              }

              // Determine whether the next list item belongs here.
              // Backpedal if it does not belong in this list.
              if (i !== l - 1) {
                b = block$1.bullet.exec(cap[i + 1])[0];
                if (bull.length > 1 ? b.length === 1
                  : (b.length > 1 || (this.options.smartLists && b !== bull))) {
                  src = cap.slice(i + 1).join('\n') + src;
                  i = l - 1;
                }
              }

              // Determine whether item is loose or not.
              // Use: /(^|\n)(?! )[^\n]+\n\n(?!\s*$)/
              // for discount behavior.
              loose = next || /\n\n(?!\s*$)/.test(item);
              if (i !== l - 1) {
                next = item.charAt(item.length - 1) === '\n';
                if (!loose) loose = next;
              }

              if (loose) {
                listStart.loose = true;
              }

              // Check for task list items
              istask = /^\[[ xX]\] /.test(item);
              ischecked = undefined;
              if (istask) {
                ischecked = item[1] !== ' ';
                item = item.replace(/^\[[ xX]\] +/, '');
              }

              t = {
                type: 'list_item_start',
                task: istask,
                checked: ischecked,
                loose: loose
              };

              listItems.push(t);
              this.tokens.push(t);

              // Recurse.
              this.token(item, false);

              this.tokens.push({
                type: 'list_item_end'
              });
            }

            if (listStart.loose) {
              l = listItems.length;
              i = 0;
              for (; i < l; i++) {
                listItems[i].loose = true;
              }
            }

            this.tokens.push({
              type: 'list_end'
            });

            continue;
          }

          // html
          if (cap = this.rules.html.exec(src)) {
            src = src.substring(cap[0].length);
            this.tokens.push({
              type: this.options.sanitize
                ? 'paragraph'
                : 'html',
              pre: !this.options.sanitizer
                && (cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style'),
              text: this.options.sanitize ? (this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape$1(cap[0])) : cap[0]
            });
            continue;
          }

          // def
          if (top && (cap = this.rules.def.exec(src))) {
            src = src.substring(cap[0].length);
            if (cap[3]) cap[3] = cap[3].substring(1, cap[3].length - 1);
            tag = cap[1].toLowerCase().replace(/\s+/g, ' ');
            if (!this.tokens.links[tag]) {
              this.tokens.links[tag] = {
                href: cap[2],
                title: cap[3]
              };
            }
            continue;
          }

          // table (gfm)
          if (cap = this.rules.table.exec(src)) {
            item = {
              type: 'table',
              header: splitCells$1(cap[1].replace(/^ *| *\| *$/g, '')),
              align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
              cells: cap[3] ? cap[3].replace(/\n$/, '').split('\n') : []
            };

            if (item.header.length === item.align.length) {
              src = src.substring(cap[0].length);

              for (i = 0; i < item.align.length; i++) {
                if (/^ *-+: *$/.test(item.align[i])) {
                  item.align[i] = 'right';
                } else if (/^ *:-+: *$/.test(item.align[i])) {
                  item.align[i] = 'center';
                } else if (/^ *:-+ *$/.test(item.align[i])) {
                  item.align[i] = 'left';
                } else {
                  item.align[i] = null;
                }
              }

              for (i = 0; i < item.cells.length; i++) {
                item.cells[i] = splitCells$1(
                  item.cells[i].replace(/^ *\| *| *\| *$/g, ''),
                  item.header.length);
              }

              this.tokens.push(item);

              continue;
            }
          }

          // lheading
          if (cap = this.rules.lheading.exec(src)) {
            src = src.substring(cap[0].length);
            this.tokens.push({
              type: 'heading',
              depth: cap[2].charAt(0) === '=' ? 1 : 2,
              text: cap[1]
            });
            continue;
          }

          // top-level paragraph
          if (top && (cap = this.rules.paragraph.exec(src))) {
            src = src.substring(cap[0].length);
            this.tokens.push({
              type: 'paragraph',
              text: cap[1].charAt(cap[1].length - 1) === '\n'
                ? cap[1].slice(0, -1)
                : cap[1]
            });
            continue;
          }

          // text
          if (cap = this.rules.text.exec(src)) {
            // Top-level should never reach here.
            src = src.substring(cap[0].length);
            this.tokens.push({
              type: 'text',
              text: cap[0]
            });
            continue;
          }

          if (src) {
            throw new Error('Infinite loop on byte: ' + src.charCodeAt(0));
          }
        }

        return this.tokens;
      };
    };

    const { defaults: defaults$2 } = defaults;
    const {
      cleanUrl: cleanUrl$1,
      escape: escape$2
    } = helpers;

    /**
     * Renderer
     */
    var Renderer_1 = class Renderer {
      constructor(options) {
        this.options = options || defaults$2;
      }

      code(code, infostring, escaped) {
        const lang = (infostring || '').match(/\S*/)[0];
        if (this.options.highlight) {
          const out = this.options.highlight(code, lang);
          if (out != null && out !== code) {
            escaped = true;
            code = out;
          }
        }

        if (!lang) {
          return '<pre><code>'
            + (escaped ? code : escape$2(code, true))
            + '</code></pre>';
        }

        return '<pre><code class="'
          + this.options.langPrefix
          + escape$2(lang, true)
          + '">'
          + (escaped ? code : escape$2(code, true))
          + '</code></pre>\n';
      };

      blockquote(quote) {
        return '<blockquote>\n' + quote + '</blockquote>\n';
      };

      html(html) {
        return html;
      };

      heading(text, level, raw, slugger) {
        if (this.options.headerIds) {
          return '<h'
            + level
            + ' id="'
            + this.options.headerPrefix
            + slugger.slug(raw)
            + '">'
            + text
            + '</h'
            + level
            + '>\n';
        }
        // ignore IDs
        return '<h' + level + '>' + text + '</h' + level + '>\n';
      };

      hr() {
        return this.options.xhtml ? '<hr/>\n' : '<hr>\n';
      };

      list(body, ordered, start) {
        const type = ordered ? 'ol' : 'ul',
          startatt = (ordered && start !== 1) ? (' start="' + start + '"') : '';
        return '<' + type + startatt + '>\n' + body + '</' + type + '>\n';
      };

      listitem(text) {
        return '<li>' + text + '</li>\n';
      };

      checkbox(checked) {
        return '<input '
          + (checked ? 'checked="" ' : '')
          + 'disabled="" type="checkbox"'
          + (this.options.xhtml ? ' /' : '')
          + '> ';
      };

      paragraph(text) {
        return '<p>' + text + '</p>\n';
      };

      table(header, body) {
        if (body) body = '<tbody>' + body + '</tbody>';

        return '<table>\n'
          + '<thead>\n'
          + header
          + '</thead>\n'
          + body
          + '</table>\n';
      };

      tablerow(content) {
        return '<tr>\n' + content + '</tr>\n';
      };

      tablecell(content, flags) {
        const type = flags.header ? 'th' : 'td';
        const tag = flags.align
          ? '<' + type + ' align="' + flags.align + '">'
          : '<' + type + '>';
        return tag + content + '</' + type + '>\n';
      };

      // span level renderer
      strong(text) {
        return '<strong>' + text + '</strong>';
      };

      em(text) {
        return '<em>' + text + '</em>';
      };

      codespan(text) {
        return '<code>' + text + '</code>';
      };

      br() {
        return this.options.xhtml ? '<br/>' : '<br>';
      };

      del(text) {
        return '<del>' + text + '</del>';
      };

      link(href, title, text) {
        href = cleanUrl$1(this.options.sanitize, this.options.baseUrl, href);
        if (href === null) {
          return text;
        }
        let out = '<a href="' + escape$2(href) + '"';
        if (title) {
          out += ' title="' + title + '"';
        }
        out += '>' + text + '</a>';
        return out;
      };

      image(href, title, text) {
        href = cleanUrl$1(this.options.sanitize, this.options.baseUrl, href);
        if (href === null) {
          return text;
        }

        let out = '<img src="' + href + '" alt="' + text + '"';
        if (title) {
          out += ' title="' + title + '"';
        }
        out += this.options.xhtml ? '/>' : '>';
        return out;
      };

      text(text) {
        return text;
      };
    };

    /**
     * Slugger generates header id
     */
    var Slugger_1 = class Slugger {
      constructor() {
        this.seen = {};
      }

      /**
       * Convert string to unique id
       */
      slug(value) {
        let slug = value
          .toLowerCase()
          .trim()
          .replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, '')
          .replace(/\s/g, '-');

        if (this.seen.hasOwnProperty(slug)) {
          const originalSlug = slug;
          do {
            this.seen[originalSlug]++;
            slug = originalSlug + '-' + this.seen[originalSlug];
          } while (this.seen.hasOwnProperty(slug));
        }
        this.seen[slug] = 0;

        return slug;
      };
    };

    const { defaults: defaults$3 } = defaults;
    const { inline: inline$1 } = rules;
    const {
      findClosingBracket: findClosingBracket$1,
      escape: escape$3
    } = helpers;

    /**
     * Inline Lexer & Compiler
     */
    var InlineLexer_1 = class InlineLexer {
      constructor(links, options) {
        this.options = options || defaults$3;
        this.links = links;
        this.rules = inline$1.normal;
        this.options.renderer = this.options.renderer || new Renderer_1();
        this.renderer = this.options.renderer;
        this.renderer.options = this.options;

        if (!this.links) {
          throw new Error('Tokens array requires a `links` property.');
        }

        if (this.options.pedantic) {
          this.rules = inline$1.pedantic;
        } else if (this.options.gfm) {
          if (this.options.breaks) {
            this.rules = inline$1.breaks;
          } else {
            this.rules = inline$1.gfm;
          }
        }
      }

      /**
       * Expose Inline Rules
       */
      static get rules() {
        return inline$1;
      }

      /**
       * Static Lexing/Compiling Method
       */
      static output(src, links, options) {
        const inline = new InlineLexer(links, options);
        return inline.output(src);
      }

      /**
       * Lexing/Compiling
       */
      output(src) {
        let out = '',
          link,
          text,
          href,
          title,
          cap,
          prevCapZero;

        while (src) {
          // escape
          if (cap = this.rules.escape.exec(src)) {
            src = src.substring(cap[0].length);
            out += escape$3(cap[1]);
            continue;
          }

          // tag
          if (cap = this.rules.tag.exec(src)) {
            if (!this.inLink && /^<a /i.test(cap[0])) {
              this.inLink = true;
            } else if (this.inLink && /^<\/a>/i.test(cap[0])) {
              this.inLink = false;
            }
            if (!this.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
              this.inRawBlock = true;
            } else if (this.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
              this.inRawBlock = false;
            }

            src = src.substring(cap[0].length);
            out += this.options.sanitize
              ? this.options.sanitizer
                ? this.options.sanitizer(cap[0])
                : escape$3(cap[0])
              : cap[0];
            continue;
          }

          // link
          if (cap = this.rules.link.exec(src)) {
            const lastParenIndex = findClosingBracket$1(cap[2], '()');
            if (lastParenIndex > -1) {
              const start = cap[0].indexOf('!') === 0 ? 5 : 4;
              const linkLen = start + cap[1].length + lastParenIndex;
              cap[2] = cap[2].substring(0, lastParenIndex);
              cap[0] = cap[0].substring(0, linkLen).trim();
              cap[3] = '';
            }
            src = src.substring(cap[0].length);
            this.inLink = true;
            href = cap[2];
            if (this.options.pedantic) {
              link = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href);

              if (link) {
                href = link[1];
                title = link[3];
              } else {
                title = '';
              }
            } else {
              title = cap[3] ? cap[3].slice(1, -1) : '';
            }
            href = href.trim().replace(/^<([\s\S]*)>$/, '$1');
            out += this.outputLink(cap, {
              href: InlineLexer.escapes(href),
              title: InlineLexer.escapes(title)
            });
            this.inLink = false;
            continue;
          }

          // reflink, nolink
          if ((cap = this.rules.reflink.exec(src))
              || (cap = this.rules.nolink.exec(src))) {
            src = src.substring(cap[0].length);
            link = (cap[2] || cap[1]).replace(/\s+/g, ' ');
            link = this.links[link.toLowerCase()];
            if (!link || !link.href) {
              out += cap[0].charAt(0);
              src = cap[0].substring(1) + src;
              continue;
            }
            this.inLink = true;
            out += this.outputLink(cap, link);
            this.inLink = false;
            continue;
          }

          // strong
          if (cap = this.rules.strong.exec(src)) {
            src = src.substring(cap[0].length);
            out += this.renderer.strong(this.output(cap[4] || cap[3] || cap[2] || cap[1]));
            continue;
          }

          // em
          if (cap = this.rules.em.exec(src)) {
            src = src.substring(cap[0].length);
            out += this.renderer.em(this.output(cap[6] || cap[5] || cap[4] || cap[3] || cap[2] || cap[1]));
            continue;
          }

          // code
          if (cap = this.rules.code.exec(src)) {
            src = src.substring(cap[0].length);
            out += this.renderer.codespan(escape$3(cap[2].trim(), true));
            continue;
          }

          // br
          if (cap = this.rules.br.exec(src)) {
            src = src.substring(cap[0].length);
            out += this.renderer.br();
            continue;
          }

          // del (gfm)
          if (cap = this.rules.del.exec(src)) {
            src = src.substring(cap[0].length);
            out += this.renderer.del(this.output(cap[1]));
            continue;
          }

          // autolink
          if (cap = this.rules.autolink.exec(src)) {
            src = src.substring(cap[0].length);
            if (cap[2] === '@') {
              text = escape$3(this.mangle(cap[1]));
              href = 'mailto:' + text;
            } else {
              text = escape$3(cap[1]);
              href = text;
            }
            out += this.renderer.link(href, null, text);
            continue;
          }

          // url (gfm)
          if (!this.inLink && (cap = this.rules.url.exec(src))) {
            if (cap[2] === '@') {
              text = escape$3(cap[0]);
              href = 'mailto:' + text;
            } else {
              // do extended autolink path validation
              do {
                prevCapZero = cap[0];
                cap[0] = this.rules._backpedal.exec(cap[0])[0];
              } while (prevCapZero !== cap[0]);
              text = escape$3(cap[0]);
              if (cap[1] === 'www.') {
                href = 'http://' + text;
              } else {
                href = text;
              }
            }
            src = src.substring(cap[0].length);
            out += this.renderer.link(href, null, text);
            continue;
          }

          // text
          if (cap = this.rules.text.exec(src)) {
            src = src.substring(cap[0].length);
            if (this.inRawBlock) {
              out += this.renderer.text(this.options.sanitize ? (this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape$3(cap[0])) : cap[0]);
            } else {
              out += this.renderer.text(escape$3(this.smartypants(cap[0])));
            }
            continue;
          }

          if (src) {
            throw new Error('Infinite loop on byte: ' + src.charCodeAt(0));
          }
        }

        return out;
      }

      static escapes(text) {
        return text ? text.replace(InlineLexer.rules._escapes, '$1') : text;
      }

      /**
       * Compile Link
       */
      outputLink(cap, link) {
        const href = link.href,
          title = link.title ? escape$3(link.title) : null;

        return cap[0].charAt(0) !== '!'
          ? this.renderer.link(href, title, this.output(cap[1]))
          : this.renderer.image(href, title, escape$3(cap[1]));
      }

      /**
       * Smartypants Transformations
       */
      smartypants(text) {
        if (!this.options.smartypants) return text;
        return text
          // em-dashes
          .replace(/---/g, '\u2014')
          // en-dashes
          .replace(/--/g, '\u2013')
          // opening singles
          .replace(/(^|[-\u2014/(\[{"\s])'/g, '$1\u2018')
          // closing singles & apostrophes
          .replace(/'/g, '\u2019')
          // opening doubles
          .replace(/(^|[-\u2014/(\[{\u2018\s])"/g, '$1\u201c')
          // closing doubles
          .replace(/"/g, '\u201d')
          // ellipses
          .replace(/\.{3}/g, '\u2026');
      }

      /**
       * Mangle Links
       */
      mangle(text) {
        if (!this.options.mangle) return text;
        const l = text.length;
        let out = '',
          i = 0,
          ch;

        for (; i < l; i++) {
          ch = text.charCodeAt(i);
          if (Math.random() > 0.5) {
            ch = 'x' + ch.toString(16);
          }
          out += '&#' + ch + ';';
        }

        return out;
      }
    };

    /**
     * TextRenderer
     * returns only the textual part of the token
     */
    var TextRenderer_1 = class TextRenderer {
      // no need for block level renderers
      strong(text) {
        return text;
      }

      em(text) {
        return text;
      }

      codespan(text) {
        return text;
      }

      del(text) {
        return text;
      }

      text(text) {
        return text;
      }

      link(href, title, text) {
        return '' + text;
      }

      image(href, title, text) {
        return '' + text;
      }

      br() {
        return '';
      }
    };

    const { defaults: defaults$4 } = defaults;
    const {
      merge: merge$2,
      unescape: unescape$2
    } = helpers;

    /**
     * Parsing & Compiling
     */
    var Parser_1 = class Parser {
      constructor(options) {
        this.tokens = [];
        this.token = null;
        this.options = options || defaults$4;
        this.options.renderer = this.options.renderer || new Renderer_1();
        this.renderer = this.options.renderer;
        this.renderer.options = this.options;
        this.slugger = new Slugger_1();
      }

      /**
       * Static Parse Method
       */
      static parse(tokens, options) {
        const parser = new Parser(options);
        return parser.parse(tokens);
      };

      /**
       * Parse Loop
       */
      parse(tokens) {
        this.inline = new InlineLexer_1(tokens.links, this.options);
        // use an InlineLexer with a TextRenderer to extract pure text
        this.inlineText = new InlineLexer_1(
          tokens.links,
          merge$2({}, this.options, { renderer: new TextRenderer_1() })
        );
        this.tokens = tokens.reverse();

        let out = '';
        while (this.next()) {
          out += this.tok();
        }

        return out;
      };

      /**
       * Next Token
       */
      next() {
        this.token = this.tokens.pop();
        return this.token;
      };

      /**
       * Preview Next Token
       */
      peek() {
        return this.tokens[this.tokens.length - 1] || 0;
      };

      /**
       * Parse Text Tokens
       */
      parseText() {
        let body = this.token.text;

        while (this.peek().type === 'text') {
          body += '\n' + this.next().text;
        }

        return this.inline.output(body);
      };

      /**
       * Parse Current Token
       */
      tok() {
        let body = '';
        switch (this.token.type) {
          case 'space': {
            return '';
          }
          case 'hr': {
            return this.renderer.hr();
          }
          case 'heading': {
            return this.renderer.heading(
              this.inline.output(this.token.text),
              this.token.depth,
              unescape$2(this.inlineText.output(this.token.text)),
              this.slugger);
          }
          case 'code': {
            return this.renderer.code(this.token.text,
              this.token.lang,
              this.token.escaped);
          }
          case 'table': {
            let header = '',
              i,
              row,
              cell,
              j;

            // header
            cell = '';
            for (i = 0; i < this.token.header.length; i++) {
              cell += this.renderer.tablecell(
                this.inline.output(this.token.header[i]),
                { header: true, align: this.token.align[i] }
              );
            }
            header += this.renderer.tablerow(cell);

            for (i = 0; i < this.token.cells.length; i++) {
              row = this.token.cells[i];

              cell = '';
              for (j = 0; j < row.length; j++) {
                cell += this.renderer.tablecell(
                  this.inline.output(row[j]),
                  { header: false, align: this.token.align[j] }
                );
              }

              body += this.renderer.tablerow(cell);
            }
            return this.renderer.table(header, body);
          }
          case 'blockquote_start': {
            body = '';

            while (this.next().type !== 'blockquote_end') {
              body += this.tok();
            }

            return this.renderer.blockquote(body);
          }
          case 'list_start': {
            body = '';
            const ordered = this.token.ordered,
              start = this.token.start;

            while (this.next().type !== 'list_end') {
              body += this.tok();
            }

            return this.renderer.list(body, ordered, start);
          }
          case 'list_item_start': {
            body = '';
            const loose = this.token.loose;
            const checked = this.token.checked;
            const task = this.token.task;

            if (this.token.task) {
              if (loose) {
                if (this.peek().type === 'text') {
                  const nextToken = this.peek();
                  nextToken.text = this.renderer.checkbox(checked) + ' ' + nextToken.text;
                } else {
                  this.tokens.push({
                    type: 'text',
                    text: this.renderer.checkbox(checked)
                  });
                }
              } else {
                body += this.renderer.checkbox(checked);
              }
            }

            while (this.next().type !== 'list_item_end') {
              body += !loose && this.token.type === 'text'
                ? this.parseText()
                : this.tok();
            }
            return this.renderer.listitem(body, task, checked);
          }
          case 'html': {
            // TODO parse inline content if parameter markdown=1
            return this.renderer.html(this.token.text);
          }
          case 'paragraph': {
            return this.renderer.paragraph(this.inline.output(this.token.text));
          }
          case 'text': {
            return this.renderer.paragraph(this.parseText());
          }
          default: {
            const errMsg = 'Token with "' + this.token.type + '" type was not found.';
            if (this.options.silent) {
              console.log(errMsg);
            } else {
              throw new Error(errMsg);
            }
          }
        }
      };
    };

    const {
      merge: merge$3,
      checkSanitizeDeprecation: checkSanitizeDeprecation$1,
      escape: escape$4
    } = helpers;
    const {
      getDefaults,
      changeDefaults,
      defaults: defaults$5
    } = defaults;

    /**
     * Marked
     */
    function marked(src, opt, callback) {
      // throw error in case of non string input
      if (typeof src === 'undefined' || src === null) {
        throw new Error('marked(): input parameter is undefined or null');
      }
      if (typeof src !== 'string') {
        throw new Error('marked(): input parameter is of type '
          + Object.prototype.toString.call(src) + ', string expected');
      }

      if (callback || typeof opt === 'function') {
        if (!callback) {
          callback = opt;
          opt = null;
        }

        opt = merge$3({}, marked.defaults, opt || {});
        checkSanitizeDeprecation$1(opt);
        const highlight = opt.highlight;
        let tokens,
          pending,
          i = 0;

        try {
          tokens = Lexer_1.lex(src, opt);
        } catch (e) {
          return callback(e);
        }

        pending = tokens.length;

        const done = function(err) {
          if (err) {
            opt.highlight = highlight;
            return callback(err);
          }

          let out;

          try {
            out = Parser_1.parse(tokens, opt);
          } catch (e) {
            err = e;
          }

          opt.highlight = highlight;

          return err
            ? callback(err)
            : callback(null, out);
        };

        if (!highlight || highlight.length < 3) {
          return done();
        }

        delete opt.highlight;

        if (!pending) return done();

        for (; i < tokens.length; i++) {
          (function(token) {
            if (token.type !== 'code') {
              return --pending || done();
            }
            return highlight(token.text, token.lang, function(err, code) {
              if (err) return done(err);
              if (code == null || code === token.text) {
                return --pending || done();
              }
              token.text = code;
              token.escaped = true;
              --pending || done();
            });
          })(tokens[i]);
        }

        return;
      }
      try {
        opt = merge$3({}, marked.defaults, opt || {});
        checkSanitizeDeprecation$1(opt);
        return Parser_1.parse(Lexer_1.lex(src, opt), opt);
      } catch (e) {
        e.message += '\nPlease report this to https://github.com/markedjs/marked.';
        if ((opt || marked.defaults).silent) {
          return '<p>An error occurred:</p><pre>'
            + escape$4(e.message + '', true)
            + '</pre>';
        }
        throw e;
      }
    }

    /**
     * Options
     */

    marked.options =
    marked.setOptions = function(opt) {
      merge$3(marked.defaults, opt);
      changeDefaults(marked.defaults);
      return marked;
    };

    marked.getDefaults = getDefaults;

    marked.defaults = defaults$5;

    /**
     * Expose
     */

    marked.Parser = Parser_1;
    marked.parser = Parser_1.parse;

    marked.Renderer = Renderer_1;
    marked.TextRenderer = TextRenderer_1;

    marked.Lexer = Lexer_1;
    marked.lexer = Lexer_1.lex;

    marked.InlineLexer = InlineLexer_1;
    marked.inlineLexer = InlineLexer_1.output;

    marked.Slugger = Slugger_1;

    marked.parse = marked;

    var marked_1 = marked;

    /**
     * cssfilter
     *
     * @author 老雷<leizongmin@gmail.com>
     */

    function getDefaultWhiteList () {
      // 白名单值说明：
      // true: 允许该属性
      // Function: function (val) { } 返回true表示允许该属性，其他值均表示不允许
      // RegExp: regexp.test(val) 返回true表示允许该属性，其他值均表示不允许
      // 除上面列出的值外均表示不允许
      var whiteList = {};

      whiteList['align-content'] = false; // default: auto
      whiteList['align-items'] = false; // default: auto
      whiteList['align-self'] = false; // default: auto
      whiteList['alignment-adjust'] = false; // default: auto
      whiteList['alignment-baseline'] = false; // default: baseline
      whiteList['all'] = false; // default: depending on individual properties
      whiteList['anchor-point'] = false; // default: none
      whiteList['animation'] = false; // default: depending on individual properties
      whiteList['animation-delay'] = false; // default: 0
      whiteList['animation-direction'] = false; // default: normal
      whiteList['animation-duration'] = false; // default: 0
      whiteList['animation-fill-mode'] = false; // default: none
      whiteList['animation-iteration-count'] = false; // default: 1
      whiteList['animation-name'] = false; // default: none
      whiteList['animation-play-state'] = false; // default: running
      whiteList['animation-timing-function'] = false; // default: ease
      whiteList['azimuth'] = false; // default: center
      whiteList['backface-visibility'] = false; // default: visible
      whiteList['background'] = true; // default: depending on individual properties
      whiteList['background-attachment'] = true; // default: scroll
      whiteList['background-clip'] = true; // default: border-box
      whiteList['background-color'] = true; // default: transparent
      whiteList['background-image'] = true; // default: none
      whiteList['background-origin'] = true; // default: padding-box
      whiteList['background-position'] = true; // default: 0% 0%
      whiteList['background-repeat'] = true; // default: repeat
      whiteList['background-size'] = true; // default: auto
      whiteList['baseline-shift'] = false; // default: baseline
      whiteList['binding'] = false; // default: none
      whiteList['bleed'] = false; // default: 6pt
      whiteList['bookmark-label'] = false; // default: content()
      whiteList['bookmark-level'] = false; // default: none
      whiteList['bookmark-state'] = false; // default: open
      whiteList['border'] = true; // default: depending on individual properties
      whiteList['border-bottom'] = true; // default: depending on individual properties
      whiteList['border-bottom-color'] = true; // default: current color
      whiteList['border-bottom-left-radius'] = true; // default: 0
      whiteList['border-bottom-right-radius'] = true; // default: 0
      whiteList['border-bottom-style'] = true; // default: none
      whiteList['border-bottom-width'] = true; // default: medium
      whiteList['border-collapse'] = true; // default: separate
      whiteList['border-color'] = true; // default: depending on individual properties
      whiteList['border-image'] = true; // default: none
      whiteList['border-image-outset'] = true; // default: 0
      whiteList['border-image-repeat'] = true; // default: stretch
      whiteList['border-image-slice'] = true; // default: 100%
      whiteList['border-image-source'] = true; // default: none
      whiteList['border-image-width'] = true; // default: 1
      whiteList['border-left'] = true; // default: depending on individual properties
      whiteList['border-left-color'] = true; // default: current color
      whiteList['border-left-style'] = true; // default: none
      whiteList['border-left-width'] = true; // default: medium
      whiteList['border-radius'] = true; // default: 0
      whiteList['border-right'] = true; // default: depending on individual properties
      whiteList['border-right-color'] = true; // default: current color
      whiteList['border-right-style'] = true; // default: none
      whiteList['border-right-width'] = true; // default: medium
      whiteList['border-spacing'] = true; // default: 0
      whiteList['border-style'] = true; // default: depending on individual properties
      whiteList['border-top'] = true; // default: depending on individual properties
      whiteList['border-top-color'] = true; // default: current color
      whiteList['border-top-left-radius'] = true; // default: 0
      whiteList['border-top-right-radius'] = true; // default: 0
      whiteList['border-top-style'] = true; // default: none
      whiteList['border-top-width'] = true; // default: medium
      whiteList['border-width'] = true; // default: depending on individual properties
      whiteList['bottom'] = false; // default: auto
      whiteList['box-decoration-break'] = true; // default: slice
      whiteList['box-shadow'] = true; // default: none
      whiteList['box-sizing'] = true; // default: content-box
      whiteList['box-snap'] = true; // default: none
      whiteList['box-suppress'] = true; // default: show
      whiteList['break-after'] = true; // default: auto
      whiteList['break-before'] = true; // default: auto
      whiteList['break-inside'] = true; // default: auto
      whiteList['caption-side'] = false; // default: top
      whiteList['chains'] = false; // default: none
      whiteList['clear'] = true; // default: none
      whiteList['clip'] = false; // default: auto
      whiteList['clip-path'] = false; // default: none
      whiteList['clip-rule'] = false; // default: nonzero
      whiteList['color'] = true; // default: implementation dependent
      whiteList['color-interpolation-filters'] = true; // default: auto
      whiteList['column-count'] = false; // default: auto
      whiteList['column-fill'] = false; // default: balance
      whiteList['column-gap'] = false; // default: normal
      whiteList['column-rule'] = false; // default: depending on individual properties
      whiteList['column-rule-color'] = false; // default: current color
      whiteList['column-rule-style'] = false; // default: medium
      whiteList['column-rule-width'] = false; // default: medium
      whiteList['column-span'] = false; // default: none
      whiteList['column-width'] = false; // default: auto
      whiteList['columns'] = false; // default: depending on individual properties
      whiteList['contain'] = false; // default: none
      whiteList['content'] = false; // default: normal
      whiteList['counter-increment'] = false; // default: none
      whiteList['counter-reset'] = false; // default: none
      whiteList['counter-set'] = false; // default: none
      whiteList['crop'] = false; // default: auto
      whiteList['cue'] = false; // default: depending on individual properties
      whiteList['cue-after'] = false; // default: none
      whiteList['cue-before'] = false; // default: none
      whiteList['cursor'] = false; // default: auto
      whiteList['direction'] = false; // default: ltr
      whiteList['display'] = true; // default: depending on individual properties
      whiteList['display-inside'] = true; // default: auto
      whiteList['display-list'] = true; // default: none
      whiteList['display-outside'] = true; // default: inline-level
      whiteList['dominant-baseline'] = false; // default: auto
      whiteList['elevation'] = false; // default: level
      whiteList['empty-cells'] = false; // default: show
      whiteList['filter'] = false; // default: none
      whiteList['flex'] = false; // default: depending on individual properties
      whiteList['flex-basis'] = false; // default: auto
      whiteList['flex-direction'] = false; // default: row
      whiteList['flex-flow'] = false; // default: depending on individual properties
      whiteList['flex-grow'] = false; // default: 0
      whiteList['flex-shrink'] = false; // default: 1
      whiteList['flex-wrap'] = false; // default: nowrap
      whiteList['float'] = false; // default: none
      whiteList['float-offset'] = false; // default: 0 0
      whiteList['flood-color'] = false; // default: black
      whiteList['flood-opacity'] = false; // default: 1
      whiteList['flow-from'] = false; // default: none
      whiteList['flow-into'] = false; // default: none
      whiteList['font'] = true; // default: depending on individual properties
      whiteList['font-family'] = true; // default: implementation dependent
      whiteList['font-feature-settings'] = true; // default: normal
      whiteList['font-kerning'] = true; // default: auto
      whiteList['font-language-override'] = true; // default: normal
      whiteList['font-size'] = true; // default: medium
      whiteList['font-size-adjust'] = true; // default: none
      whiteList['font-stretch'] = true; // default: normal
      whiteList['font-style'] = true; // default: normal
      whiteList['font-synthesis'] = true; // default: weight style
      whiteList['font-variant'] = true; // default: normal
      whiteList['font-variant-alternates'] = true; // default: normal
      whiteList['font-variant-caps'] = true; // default: normal
      whiteList['font-variant-east-asian'] = true; // default: normal
      whiteList['font-variant-ligatures'] = true; // default: normal
      whiteList['font-variant-numeric'] = true; // default: normal
      whiteList['font-variant-position'] = true; // default: normal
      whiteList['font-weight'] = true; // default: normal
      whiteList['grid'] = false; // default: depending on individual properties
      whiteList['grid-area'] = false; // default: depending on individual properties
      whiteList['grid-auto-columns'] = false; // default: auto
      whiteList['grid-auto-flow'] = false; // default: none
      whiteList['grid-auto-rows'] = false; // default: auto
      whiteList['grid-column'] = false; // default: depending on individual properties
      whiteList['grid-column-end'] = false; // default: auto
      whiteList['grid-column-start'] = false; // default: auto
      whiteList['grid-row'] = false; // default: depending on individual properties
      whiteList['grid-row-end'] = false; // default: auto
      whiteList['grid-row-start'] = false; // default: auto
      whiteList['grid-template'] = false; // default: depending on individual properties
      whiteList['grid-template-areas'] = false; // default: none
      whiteList['grid-template-columns'] = false; // default: none
      whiteList['grid-template-rows'] = false; // default: none
      whiteList['hanging-punctuation'] = false; // default: none
      whiteList['height'] = true; // default: auto
      whiteList['hyphens'] = false; // default: manual
      whiteList['icon'] = false; // default: auto
      whiteList['image-orientation'] = false; // default: auto
      whiteList['image-resolution'] = false; // default: normal
      whiteList['ime-mode'] = false; // default: auto
      whiteList['initial-letters'] = false; // default: normal
      whiteList['inline-box-align'] = false; // default: last
      whiteList['justify-content'] = false; // default: auto
      whiteList['justify-items'] = false; // default: auto
      whiteList['justify-self'] = false; // default: auto
      whiteList['left'] = false; // default: auto
      whiteList['letter-spacing'] = true; // default: normal
      whiteList['lighting-color'] = true; // default: white
      whiteList['line-box-contain'] = false; // default: block inline replaced
      whiteList['line-break'] = false; // default: auto
      whiteList['line-grid'] = false; // default: match-parent
      whiteList['line-height'] = false; // default: normal
      whiteList['line-snap'] = false; // default: none
      whiteList['line-stacking'] = false; // default: depending on individual properties
      whiteList['line-stacking-ruby'] = false; // default: exclude-ruby
      whiteList['line-stacking-shift'] = false; // default: consider-shifts
      whiteList['line-stacking-strategy'] = false; // default: inline-line-height
      whiteList['list-style'] = true; // default: depending on individual properties
      whiteList['list-style-image'] = true; // default: none
      whiteList['list-style-position'] = true; // default: outside
      whiteList['list-style-type'] = true; // default: disc
      whiteList['margin'] = true; // default: depending on individual properties
      whiteList['margin-bottom'] = true; // default: 0
      whiteList['margin-left'] = true; // default: 0
      whiteList['margin-right'] = true; // default: 0
      whiteList['margin-top'] = true; // default: 0
      whiteList['marker-offset'] = false; // default: auto
      whiteList['marker-side'] = false; // default: list-item
      whiteList['marks'] = false; // default: none
      whiteList['mask'] = false; // default: border-box
      whiteList['mask-box'] = false; // default: see individual properties
      whiteList['mask-box-outset'] = false; // default: 0
      whiteList['mask-box-repeat'] = false; // default: stretch
      whiteList['mask-box-slice'] = false; // default: 0 fill
      whiteList['mask-box-source'] = false; // default: none
      whiteList['mask-box-width'] = false; // default: auto
      whiteList['mask-clip'] = false; // default: border-box
      whiteList['mask-image'] = false; // default: none
      whiteList['mask-origin'] = false; // default: border-box
      whiteList['mask-position'] = false; // default: center
      whiteList['mask-repeat'] = false; // default: no-repeat
      whiteList['mask-size'] = false; // default: border-box
      whiteList['mask-source-type'] = false; // default: auto
      whiteList['mask-type'] = false; // default: luminance
      whiteList['max-height'] = true; // default: none
      whiteList['max-lines'] = false; // default: none
      whiteList['max-width'] = true; // default: none
      whiteList['min-height'] = true; // default: 0
      whiteList['min-width'] = true; // default: 0
      whiteList['move-to'] = false; // default: normal
      whiteList['nav-down'] = false; // default: auto
      whiteList['nav-index'] = false; // default: auto
      whiteList['nav-left'] = false; // default: auto
      whiteList['nav-right'] = false; // default: auto
      whiteList['nav-up'] = false; // default: auto
      whiteList['object-fit'] = false; // default: fill
      whiteList['object-position'] = false; // default: 50% 50%
      whiteList['opacity'] = false; // default: 1
      whiteList['order'] = false; // default: 0
      whiteList['orphans'] = false; // default: 2
      whiteList['outline'] = false; // default: depending on individual properties
      whiteList['outline-color'] = false; // default: invert
      whiteList['outline-offset'] = false; // default: 0
      whiteList['outline-style'] = false; // default: none
      whiteList['outline-width'] = false; // default: medium
      whiteList['overflow'] = false; // default: depending on individual properties
      whiteList['overflow-wrap'] = false; // default: normal
      whiteList['overflow-x'] = false; // default: visible
      whiteList['overflow-y'] = false; // default: visible
      whiteList['padding'] = true; // default: depending on individual properties
      whiteList['padding-bottom'] = true; // default: 0
      whiteList['padding-left'] = true; // default: 0
      whiteList['padding-right'] = true; // default: 0
      whiteList['padding-top'] = true; // default: 0
      whiteList['page'] = false; // default: auto
      whiteList['page-break-after'] = false; // default: auto
      whiteList['page-break-before'] = false; // default: auto
      whiteList['page-break-inside'] = false; // default: auto
      whiteList['page-policy'] = false; // default: start
      whiteList['pause'] = false; // default: implementation dependent
      whiteList['pause-after'] = false; // default: implementation dependent
      whiteList['pause-before'] = false; // default: implementation dependent
      whiteList['perspective'] = false; // default: none
      whiteList['perspective-origin'] = false; // default: 50% 50%
      whiteList['pitch'] = false; // default: medium
      whiteList['pitch-range'] = false; // default: 50
      whiteList['play-during'] = false; // default: auto
      whiteList['position'] = false; // default: static
      whiteList['presentation-level'] = false; // default: 0
      whiteList['quotes'] = false; // default: text
      whiteList['region-fragment'] = false; // default: auto
      whiteList['resize'] = false; // default: none
      whiteList['rest'] = false; // default: depending on individual properties
      whiteList['rest-after'] = false; // default: none
      whiteList['rest-before'] = false; // default: none
      whiteList['richness'] = false; // default: 50
      whiteList['right'] = false; // default: auto
      whiteList['rotation'] = false; // default: 0
      whiteList['rotation-point'] = false; // default: 50% 50%
      whiteList['ruby-align'] = false; // default: auto
      whiteList['ruby-merge'] = false; // default: separate
      whiteList['ruby-position'] = false; // default: before
      whiteList['shape-image-threshold'] = false; // default: 0.0
      whiteList['shape-outside'] = false; // default: none
      whiteList['shape-margin'] = false; // default: 0
      whiteList['size'] = false; // default: auto
      whiteList['speak'] = false; // default: auto
      whiteList['speak-as'] = false; // default: normal
      whiteList['speak-header'] = false; // default: once
      whiteList['speak-numeral'] = false; // default: continuous
      whiteList['speak-punctuation'] = false; // default: none
      whiteList['speech-rate'] = false; // default: medium
      whiteList['stress'] = false; // default: 50
      whiteList['string-set'] = false; // default: none
      whiteList['tab-size'] = false; // default: 8
      whiteList['table-layout'] = false; // default: auto
      whiteList['text-align'] = true; // default: start
      whiteList['text-align-last'] = true; // default: auto
      whiteList['text-combine-upright'] = true; // default: none
      whiteList['text-decoration'] = true; // default: none
      whiteList['text-decoration-color'] = true; // default: currentColor
      whiteList['text-decoration-line'] = true; // default: none
      whiteList['text-decoration-skip'] = true; // default: objects
      whiteList['text-decoration-style'] = true; // default: solid
      whiteList['text-emphasis'] = true; // default: depending on individual properties
      whiteList['text-emphasis-color'] = true; // default: currentColor
      whiteList['text-emphasis-position'] = true; // default: over right
      whiteList['text-emphasis-style'] = true; // default: none
      whiteList['text-height'] = true; // default: auto
      whiteList['text-indent'] = true; // default: 0
      whiteList['text-justify'] = true; // default: auto
      whiteList['text-orientation'] = true; // default: mixed
      whiteList['text-overflow'] = true; // default: clip
      whiteList['text-shadow'] = true; // default: none
      whiteList['text-space-collapse'] = true; // default: collapse
      whiteList['text-transform'] = true; // default: none
      whiteList['text-underline-position'] = true; // default: auto
      whiteList['text-wrap'] = true; // default: normal
      whiteList['top'] = false; // default: auto
      whiteList['transform'] = false; // default: none
      whiteList['transform-origin'] = false; // default: 50% 50% 0
      whiteList['transform-style'] = false; // default: flat
      whiteList['transition'] = false; // default: depending on individual properties
      whiteList['transition-delay'] = false; // default: 0s
      whiteList['transition-duration'] = false; // default: 0s
      whiteList['transition-property'] = false; // default: all
      whiteList['transition-timing-function'] = false; // default: ease
      whiteList['unicode-bidi'] = false; // default: normal
      whiteList['vertical-align'] = false; // default: baseline
      whiteList['visibility'] = false; // default: visible
      whiteList['voice-balance'] = false; // default: center
      whiteList['voice-duration'] = false; // default: auto
      whiteList['voice-family'] = false; // default: implementation dependent
      whiteList['voice-pitch'] = false; // default: medium
      whiteList['voice-range'] = false; // default: medium
      whiteList['voice-rate'] = false; // default: normal
      whiteList['voice-stress'] = false; // default: normal
      whiteList['voice-volume'] = false; // default: medium
      whiteList['volume'] = false; // default: medium
      whiteList['white-space'] = false; // default: normal
      whiteList['widows'] = false; // default: 2
      whiteList['width'] = true; // default: auto
      whiteList['will-change'] = false; // default: auto
      whiteList['word-break'] = true; // default: normal
      whiteList['word-spacing'] = true; // default: normal
      whiteList['word-wrap'] = true; // default: normal
      whiteList['wrap-flow'] = false; // default: auto
      whiteList['wrap-through'] = false; // default: wrap
      whiteList['writing-mode'] = false; // default: horizontal-tb
      whiteList['z-index'] = false; // default: auto

      return whiteList;
    }


    /**
     * 匹配到白名单上的一个属性时
     *
     * @param {String} name
     * @param {String} value
     * @param {Object} options
     * @return {String}
     */
    function onAttr (name, value, options) {
      // do nothing
    }

    /**
     * 匹配到不在白名单上的一个属性时
     *
     * @param {String} name
     * @param {String} value
     * @param {Object} options
     * @return {String}
     */
    function onIgnoreAttr (name, value, options) {
      // do nothing
    }

    var REGEXP_URL_JAVASCRIPT = /javascript\s*\:/img;

    /**
     * 过滤属性值
     *
     * @param {String} name
     * @param {String} value
     * @return {String}
     */
    function safeAttrValue(name, value) {
      if (REGEXP_URL_JAVASCRIPT.test(value)) return '';
      return value;
    }


    var whiteList = getDefaultWhiteList();
    var getDefaultWhiteList_1 = getDefaultWhiteList;
    var onAttr_1 = onAttr;
    var onIgnoreAttr_1 = onIgnoreAttr;
    var safeAttrValue_1 = safeAttrValue;

    var _default = {
    	whiteList: whiteList,
    	getDefaultWhiteList: getDefaultWhiteList_1,
    	onAttr: onAttr_1,
    	onIgnoreAttr: onIgnoreAttr_1,
    	safeAttrValue: safeAttrValue_1
    };

    var util = {
      indexOf: function (arr, item) {
        var i, j;
        if (Array.prototype.indexOf) {
          return arr.indexOf(item);
        }
        for (i = 0, j = arr.length; i < j; i++) {
          if (arr[i] === item) {
            return i;
          }
        }
        return -1;
      },
      forEach: function (arr, fn, scope) {
        var i, j;
        if (Array.prototype.forEach) {
          return arr.forEach(fn, scope);
        }
        for (i = 0, j = arr.length; i < j; i++) {
          fn.call(scope, arr[i], i, arr);
        }
      },
      trim: function (str) {
        if (String.prototype.trim) {
          return str.trim();
        }
        return str.replace(/(^\s*)|(\s*$)/g, '');
      },
      trimRight: function (str) {
        if (String.prototype.trimRight) {
          return str.trimRight();
        }
        return str.replace(/(\s*$)/g, '');
      }
    };

    /**
     * cssfilter
     *
     * @author 老雷<leizongmin@gmail.com>
     */




    /**
     * 解析style
     *
     * @param {String} css
     * @param {Function} onAttr 处理属性的函数
     *   参数格式： function (sourcePosition, position, name, value, source)
     * @return {String}
     */
    function parseStyle (css, onAttr) {
      css = util.trimRight(css);
      if (css[css.length - 1] !== ';') css += ';';
      var cssLength = css.length;
      var isParenthesisOpen = false;
      var lastPos = 0;
      var i = 0;
      var retCSS = '';

      function addNewAttr () {
        // 如果没有正常的闭合圆括号，则直接忽略当前属性
        if (!isParenthesisOpen) {
          var source = util.trim(css.slice(lastPos, i));
          var j = source.indexOf(':');
          if (j !== -1) {
            var name = util.trim(source.slice(0, j));
            var value = util.trim(source.slice(j + 1));
            // 必须有属性名称
            if (name) {
              var ret = onAttr(lastPos, retCSS.length, name, value, source);
              if (ret) retCSS += ret + '; ';
            }
          }
        }
        lastPos = i + 1;
      }

      for (; i < cssLength; i++) {
        var c = css[i];
        if (c === '/' && css[i + 1] === '*') {
          // 备注开始
          var j = css.indexOf('*/', i + 2);
          // 如果没有正常的备注结束，则后面的部分全部跳过
          if (j === -1) break;
          // 直接将当前位置调到备注结尾，并且初始化状态
          i = j + 1;
          lastPos = i + 1;
          isParenthesisOpen = false;
        } else if (c === '(') {
          isParenthesisOpen = true;
        } else if (c === ')') {
          isParenthesisOpen = false;
        } else if (c === ';') {
          if (isParenthesisOpen) ; else {
            addNewAttr();
          }
        } else if (c === '\n') {
          addNewAttr();
        }
      }

      return util.trim(retCSS);
    }

    var parser = parseStyle;

    /**
     * cssfilter
     *
     * @author 老雷<leizongmin@gmail.com>
     */






    /**
     * 返回值是否为空
     *
     * @param {Object} obj
     * @return {Boolean}
     */
    function isNull (obj) {
      return (obj === undefined || obj === null);
    }

    /**
     * 浅拷贝对象
     *
     * @param {Object} obj
     * @return {Object}
     */
    function shallowCopyObject (obj) {
      var ret = {};
      for (var i in obj) {
        ret[i] = obj[i];
      }
      return ret;
    }

    /**
     * 创建CSS过滤器
     *
     * @param {Object} options
     *   - {Object} whiteList
     *   - {Function} onAttr
     *   - {Function} onIgnoreAttr
     *   - {Function} safeAttrValue
     */
    function FilterCSS (options) {
      options = shallowCopyObject(options || {});
      options.whiteList = options.whiteList || _default.whiteList;
      options.onAttr = options.onAttr || _default.onAttr;
      options.onIgnoreAttr = options.onIgnoreAttr || _default.onIgnoreAttr;
      options.safeAttrValue = options.safeAttrValue || _default.safeAttrValue;
      this.options = options;
    }

    FilterCSS.prototype.process = function (css) {
      // 兼容各种奇葩输入
      css = css || '';
      css = css.toString();
      if (!css) return '';

      var me = this;
      var options = me.options;
      var whiteList = options.whiteList;
      var onAttr = options.onAttr;
      var onIgnoreAttr = options.onIgnoreAttr;
      var safeAttrValue = options.safeAttrValue;

      var retCSS = parser(css, function (sourcePosition, position, name, value, source) {

        var check = whiteList[name];
        var isWhite = false;
        if (check === true) isWhite = check;
        else if (typeof check === 'function') isWhite = check(value);
        else if (check instanceof RegExp) isWhite = check.test(value);
        if (isWhite !== true) isWhite = false;

        // 如果过滤后 value 为空则直接忽略
        value = safeAttrValue(name, value);
        if (!value) return;

        var opts = {
          position: position,
          sourcePosition: sourcePosition,
          source: source,
          isWhite: isWhite
        };

        if (isWhite) {

          var ret = onAttr(name, value, opts);
          if (isNull(ret)) {
            return name + ':' + value;
          } else {
            return ret;
          }

        } else {

          var ret = onIgnoreAttr(name, value, opts);
          if (!isNull(ret)) {
            return ret;
          }

        }
      });

      return retCSS;
    };


    var css$1 = FilterCSS;

    var lib = createCommonjsModule(function (module, exports) {
    /**
     * cssfilter
     *
     * @author 老雷<leizongmin@gmail.com>
     */





    /**
     * XSS过滤
     *
     * @param {String} css 要过滤的CSS代码
     * @param {Object} options 选项：whiteList, onAttr, onIgnoreAttr
     * @return {String}
     */
    function filterCSS (html, options) {
      var xss = new css$1(options);
      return xss.process(html);
    }


    // 输出
    exports = module.exports = filterCSS;
    exports.FilterCSS = css$1;
    for (var i in _default) exports[i] = _default[i];

    // 在浏览器端使用
    if (typeof window !== 'undefined') {
      window.filterCSS = module.exports;
    }
    });
    var lib_1 = lib.FilterCSS;

    var util$1 = {
      indexOf: function(arr, item) {
        var i, j;
        if (Array.prototype.indexOf) {
          return arr.indexOf(item);
        }
        for (i = 0, j = arr.length; i < j; i++) {
          if (arr[i] === item) {
            return i;
          }
        }
        return -1;
      },
      forEach: function(arr, fn, scope) {
        var i, j;
        if (Array.prototype.forEach) {
          return arr.forEach(fn, scope);
        }
        for (i = 0, j = arr.length; i < j; i++) {
          fn.call(scope, arr[i], i, arr);
        }
      },
      trim: function(str) {
        if (String.prototype.trim) {
          return str.trim();
        }
        return str.replace(/(^\s*)|(\s*$)/g, "");
      },
      spaceIndex: function(str) {
        var reg = /\s|\n|\t/;
        var match = reg.exec(str);
        return match ? match.index : -1;
      }
    };

    /**
     * default settings
     *
     * @author Zongmin Lei<leizongmin@gmail.com>
     */

    var FilterCSS$1 = lib.FilterCSS;
    var getDefaultCSSWhiteList = lib.getDefaultWhiteList;


    function getDefaultWhiteList$1() {
      return {
        a: ["target", "href", "title"],
        abbr: ["title"],
        address: [],
        area: ["shape", "coords", "href", "alt"],
        article: [],
        aside: [],
        audio: ["autoplay", "controls", "loop", "preload", "src"],
        b: [],
        bdi: ["dir"],
        bdo: ["dir"],
        big: [],
        blockquote: ["cite"],
        br: [],
        caption: [],
        center: [],
        cite: [],
        code: [],
        col: ["align", "valign", "span", "width"],
        colgroup: ["align", "valign", "span", "width"],
        dd: [],
        del: ["datetime"],
        details: ["open"],
        div: [],
        dl: [],
        dt: [],
        em: [],
        font: ["color", "size", "face"],
        footer: [],
        h1: [],
        h2: [],
        h3: [],
        h4: [],
        h5: [],
        h6: [],
        header: [],
        hr: [],
        i: [],
        img: ["src", "alt", "title", "width", "height"],
        ins: ["datetime"],
        li: [],
        mark: [],
        nav: [],
        ol: [],
        p: [],
        pre: [],
        s: [],
        section: [],
        small: [],
        span: [],
        sub: [],
        sup: [],
        strong: [],
        table: ["width", "border", "align", "valign"],
        tbody: ["align", "valign"],
        td: ["width", "rowspan", "colspan", "align", "valign"],
        tfoot: ["align", "valign"],
        th: ["width", "rowspan", "colspan", "align", "valign"],
        thead: ["align", "valign"],
        tr: ["rowspan", "align", "valign"],
        tt: [],
        u: [],
        ul: [],
        video: ["autoplay", "controls", "loop", "preload", "src", "height", "width"]
      };
    }

    var defaultCSSFilter = new FilterCSS$1();

    /**
     * default onTag function
     *
     * @param {String} tag
     * @param {String} html
     * @param {Object} options
     * @return {String}
     */
    function onTag(tag, html, options) {
      // do nothing
    }

    /**
     * default onIgnoreTag function
     *
     * @param {String} tag
     * @param {String} html
     * @param {Object} options
     * @return {String}
     */
    function onIgnoreTag(tag, html, options) {
      // do nothing
    }

    /**
     * default onTagAttr function
     *
     * @param {String} tag
     * @param {String} name
     * @param {String} value
     * @return {String}
     */
    function onTagAttr(tag, name, value) {
      // do nothing
    }

    /**
     * default onIgnoreTagAttr function
     *
     * @param {String} tag
     * @param {String} name
     * @param {String} value
     * @return {String}
     */
    function onIgnoreTagAttr(tag, name, value) {
      // do nothing
    }

    /**
     * default escapeHtml function
     *
     * @param {String} html
     */
    function escapeHtml(html) {
      return html.replace(REGEXP_LT, "&lt;").replace(REGEXP_GT, "&gt;");
    }

    /**
     * default safeAttrValue function
     *
     * @param {String} tag
     * @param {String} name
     * @param {String} value
     * @param {Object} cssFilter
     * @return {String}
     */
    function safeAttrValue$1(tag, name, value, cssFilter) {
      // unescape attribute value firstly
      value = friendlyAttrValue(value);

      if (name === "href" || name === "src") {
        // filter `href` and `src` attribute
        // only allow the value that starts with `http://` | `https://` | `mailto:` | `/` | `#`
        value = util$1.trim(value);
        if (value === "#") return "#";
        if (
          !(
            value.substr(0, 7) === "http://" ||
            value.substr(0, 8) === "https://" ||
            value.substr(0, 7) === "mailto:" ||
            value.substr(0, 4) === "tel:" ||
            value[0] === "#" ||
            value[0] === "/"
          )
        ) {
          return "";
        }
      } else if (name === "background") {
        // filter `background` attribute (maybe no use)
        // `javascript:`
        REGEXP_DEFAULT_ON_TAG_ATTR_4.lastIndex = 0;
        if (REGEXP_DEFAULT_ON_TAG_ATTR_4.test(value)) {
          return "";
        }
      } else if (name === "style") {
        // `expression()`
        REGEXP_DEFAULT_ON_TAG_ATTR_7.lastIndex = 0;
        if (REGEXP_DEFAULT_ON_TAG_ATTR_7.test(value)) {
          return "";
        }
        // `url()`
        REGEXP_DEFAULT_ON_TAG_ATTR_8.lastIndex = 0;
        if (REGEXP_DEFAULT_ON_TAG_ATTR_8.test(value)) {
          REGEXP_DEFAULT_ON_TAG_ATTR_4.lastIndex = 0;
          if (REGEXP_DEFAULT_ON_TAG_ATTR_4.test(value)) {
            return "";
          }
        }
        if (cssFilter !== false) {
          cssFilter = cssFilter || defaultCSSFilter;
          value = cssFilter.process(value);
        }
      }

      // escape `<>"` before returns
      value = escapeAttrValue(value);
      return value;
    }

    // RegExp list
    var REGEXP_LT = /</g;
    var REGEXP_GT = />/g;
    var REGEXP_QUOTE = /"/g;
    var REGEXP_QUOTE_2 = /&quot;/g;
    var REGEXP_ATTR_VALUE_1 = /&#([a-zA-Z0-9]*);?/gim;
    var REGEXP_ATTR_VALUE_COLON = /&colon;?/gim;
    var REGEXP_ATTR_VALUE_NEWLINE = /&newline;?/gim;
    var REGEXP_DEFAULT_ON_TAG_ATTR_4 = /((j\s*a\s*v\s*a|v\s*b|l\s*i\s*v\s*e)\s*s\s*c\s*r\s*i\s*p\s*t\s*|m\s*o\s*c\s*h\s*a)\:/gi;
    var REGEXP_DEFAULT_ON_TAG_ATTR_7 = /e\s*x\s*p\s*r\s*e\s*s\s*s\s*i\s*o\s*n\s*\(.*/gi;
    var REGEXP_DEFAULT_ON_TAG_ATTR_8 = /u\s*r\s*l\s*\(.*/gi;

    /**
     * escape doube quote
     *
     * @param {String} str
     * @return {String} str
     */
    function escapeQuote(str) {
      return str.replace(REGEXP_QUOTE, "&quot;");
    }

    /**
     * unescape double quote
     *
     * @param {String} str
     * @return {String} str
     */
    function unescapeQuote(str) {
      return str.replace(REGEXP_QUOTE_2, '"');
    }

    /**
     * escape html entities
     *
     * @param {String} str
     * @return {String}
     */
    function escapeHtmlEntities(str) {
      return str.replace(REGEXP_ATTR_VALUE_1, function replaceUnicode(str, code) {
        return code[0] === "x" || code[0] === "X"
          ? String.fromCharCode(parseInt(code.substr(1), 16))
          : String.fromCharCode(parseInt(code, 10));
      });
    }

    /**
     * escape html5 new danger entities
     *
     * @param {String} str
     * @return {String}
     */
    function escapeDangerHtml5Entities(str) {
      return str
        .replace(REGEXP_ATTR_VALUE_COLON, ":")
        .replace(REGEXP_ATTR_VALUE_NEWLINE, " ");
    }

    /**
     * clear nonprintable characters
     *
     * @param {String} str
     * @return {String}
     */
    function clearNonPrintableCharacter(str) {
      var str2 = "";
      for (var i = 0, len = str.length; i < len; i++) {
        str2 += str.charCodeAt(i) < 32 ? " " : str.charAt(i);
      }
      return util$1.trim(str2);
    }

    /**
     * get friendly attribute value
     *
     * @param {String} str
     * @return {String}
     */
    function friendlyAttrValue(str) {
      str = unescapeQuote(str);
      str = escapeHtmlEntities(str);
      str = escapeDangerHtml5Entities(str);
      str = clearNonPrintableCharacter(str);
      return str;
    }

    /**
     * unescape attribute value
     *
     * @param {String} str
     * @return {String}
     */
    function escapeAttrValue(str) {
      str = escapeQuote(str);
      str = escapeHtml(str);
      return str;
    }

    /**
     * `onIgnoreTag` function for removing all the tags that are not in whitelist
     */
    function onIgnoreTagStripAll() {
      return "";
    }

    /**
     * remove tag body
     * specify a `tags` list, if the tag is not in the `tags` list then process by the specify function (optional)
     *
     * @param {array} tags
     * @param {function} next
     */
    function StripTagBody(tags, next) {
      if (typeof next !== "function") {
        next = function() {};
      }

      var isRemoveAllTag = !Array.isArray(tags);
      function isRemoveTag(tag) {
        if (isRemoveAllTag) return true;
        return util$1.indexOf(tags, tag) !== -1;
      }

      var removeList = [];
      var posStart = false;

      return {
        onIgnoreTag: function(tag, html, options) {
          if (isRemoveTag(tag)) {
            if (options.isClosing) {
              var ret = "[/removed]";
              var end = options.position + ret.length;
              removeList.push([
                posStart !== false ? posStart : options.position,
                end
              ]);
              posStart = false;
              return ret;
            } else {
              if (!posStart) {
                posStart = options.position;
              }
              return "[removed]";
            }
          } else {
            return next(tag, html, options);
          }
        },
        remove: function(html) {
          var rethtml = "";
          var lastPos = 0;
          util$1.forEach(removeList, function(pos) {
            rethtml += html.slice(lastPos, pos[0]);
            lastPos = pos[1];
          });
          rethtml += html.slice(lastPos);
          return rethtml;
        }
      };
    }

    /**
     * remove html comments
     *
     * @param {String} html
     * @return {String}
     */
    function stripCommentTag(html) {
      return html.replace(STRIP_COMMENT_TAG_REGEXP, "");
    }
    var STRIP_COMMENT_TAG_REGEXP = /<!--[\s\S]*?-->/g;

    /**
     * remove invisible characters
     *
     * @param {String} html
     * @return {String}
     */
    function stripBlankChar(html) {
      var chars = html.split("");
      chars = chars.filter(function(char) {
        var c = char.charCodeAt(0);
        if (c === 127) return false;
        if (c <= 31) {
          if (c === 10 || c === 13) return true;
          return false;
        }
        return true;
      });
      return chars.join("");
    }

    var whiteList$1 = getDefaultWhiteList$1();
    var getDefaultWhiteList_1$1 = getDefaultWhiteList$1;
    var onTag_1 = onTag;
    var onIgnoreTag_1 = onIgnoreTag;
    var onTagAttr_1 = onTagAttr;
    var onIgnoreTagAttr_1 = onIgnoreTagAttr;
    var safeAttrValue_1$1 = safeAttrValue$1;
    var escapeHtml_1 = escapeHtml;
    var escapeQuote_1 = escapeQuote;
    var unescapeQuote_1 = unescapeQuote;
    var escapeHtmlEntities_1 = escapeHtmlEntities;
    var escapeDangerHtml5Entities_1 = escapeDangerHtml5Entities;
    var clearNonPrintableCharacter_1 = clearNonPrintableCharacter;
    var friendlyAttrValue_1 = friendlyAttrValue;
    var escapeAttrValue_1 = escapeAttrValue;
    var onIgnoreTagStripAll_1 = onIgnoreTagStripAll;
    var StripTagBody_1 = StripTagBody;
    var stripCommentTag_1 = stripCommentTag;
    var stripBlankChar_1 = stripBlankChar;
    var cssFilter = defaultCSSFilter;
    var getDefaultCSSWhiteList_1 = getDefaultCSSWhiteList;

    var _default$1 = {
    	whiteList: whiteList$1,
    	getDefaultWhiteList: getDefaultWhiteList_1$1,
    	onTag: onTag_1,
    	onIgnoreTag: onIgnoreTag_1,
    	onTagAttr: onTagAttr_1,
    	onIgnoreTagAttr: onIgnoreTagAttr_1,
    	safeAttrValue: safeAttrValue_1$1,
    	escapeHtml: escapeHtml_1,
    	escapeQuote: escapeQuote_1,
    	unescapeQuote: unescapeQuote_1,
    	escapeHtmlEntities: escapeHtmlEntities_1,
    	escapeDangerHtml5Entities: escapeDangerHtml5Entities_1,
    	clearNonPrintableCharacter: clearNonPrintableCharacter_1,
    	friendlyAttrValue: friendlyAttrValue_1,
    	escapeAttrValue: escapeAttrValue_1,
    	onIgnoreTagStripAll: onIgnoreTagStripAll_1,
    	StripTagBody: StripTagBody_1,
    	stripCommentTag: stripCommentTag_1,
    	stripBlankChar: stripBlankChar_1,
    	cssFilter: cssFilter,
    	getDefaultCSSWhiteList: getDefaultCSSWhiteList_1
    };

    /**
     * Simple HTML Parser
     *
     * @author Zongmin Lei<leizongmin@gmail.com>
     */



    /**
     * get tag name
     *
     * @param {String} html e.g. '<a hef="#">'
     * @return {String}
     */
    function getTagName(html) {
      var i = util$1.spaceIndex(html);
      if (i === -1) {
        var tagName = html.slice(1, -1);
      } else {
        var tagName = html.slice(1, i + 1);
      }
      tagName = util$1.trim(tagName).toLowerCase();
      if (tagName.slice(0, 1) === "/") tagName = tagName.slice(1);
      if (tagName.slice(-1) === "/") tagName = tagName.slice(0, -1);
      return tagName;
    }

    /**
     * is close tag?
     *
     * @param {String} html 如：'<a hef="#">'
     * @return {Boolean}
     */
    function isClosing(html) {
      return html.slice(0, 2) === "</";
    }

    /**
     * parse input html and returns processed html
     *
     * @param {String} html
     * @param {Function} onTag e.g. function (sourcePosition, position, tag, html, isClosing)
     * @param {Function} escapeHtml
     * @return {String}
     */
    function parseTag(html, onTag, escapeHtml) {
      "user strict";

      var rethtml = "";
      var lastPos = 0;
      var tagStart = false;
      var quoteStart = false;
      var currentPos = 0;
      var len = html.length;
      var currentTagName = "";
      var currentHtml = "";

      for (currentPos = 0; currentPos < len; currentPos++) {
        var c = html.charAt(currentPos);
        if (tagStart === false) {
          if (c === "<") {
            tagStart = currentPos;
            continue;
          }
        } else {
          if (quoteStart === false) {
            if (c === "<") {
              rethtml += escapeHtml(html.slice(lastPos, currentPos));
              tagStart = currentPos;
              lastPos = currentPos;
              continue;
            }
            if (c === ">") {
              rethtml += escapeHtml(html.slice(lastPos, tagStart));
              currentHtml = html.slice(tagStart, currentPos + 1);
              currentTagName = getTagName(currentHtml);
              rethtml += onTag(
                tagStart,
                rethtml.length,
                currentTagName,
                currentHtml,
                isClosing(currentHtml)
              );
              lastPos = currentPos + 1;
              tagStart = false;
              continue;
            }
            if ((c === '"' || c === "'") && html.charAt(currentPos - 1) === "=") {
              quoteStart = c;
              continue;
            }
          } else {
            if (c === quoteStart) {
              quoteStart = false;
              continue;
            }
          }
        }
      }
      if (lastPos < html.length) {
        rethtml += escapeHtml(html.substr(lastPos));
      }

      return rethtml;
    }

    var REGEXP_ILLEGAL_ATTR_NAME = /[^a-zA-Z0-9_:\.\-]/gim;

    /**
     * parse input attributes and returns processed attributes
     *
     * @param {String} html e.g. `href="#" target="_blank"`
     * @param {Function} onAttr e.g. `function (name, value)`
     * @return {String}
     */
    function parseAttr(html, onAttr) {
      "user strict";

      var lastPos = 0;
      var retAttrs = [];
      var tmpName = false;
      var len = html.length;

      function addAttr(name, value) {
        name = util$1.trim(name);
        name = name.replace(REGEXP_ILLEGAL_ATTR_NAME, "").toLowerCase();
        if (name.length < 1) return;
        var ret = onAttr(name, value || "");
        if (ret) retAttrs.push(ret);
      }

      // 逐个分析字符
      for (var i = 0; i < len; i++) {
        var c = html.charAt(i);
        var v, j;
        if (tmpName === false && c === "=") {
          tmpName = html.slice(lastPos, i);
          lastPos = i + 1;
          continue;
        }
        if (tmpName !== false) {
          if (
            i === lastPos &&
            (c === '"' || c === "'") &&
            html.charAt(i - 1) === "="
          ) {
            j = html.indexOf(c, i + 1);
            if (j === -1) {
              break;
            } else {
              v = util$1.trim(html.slice(lastPos + 1, j));
              addAttr(tmpName, v);
              tmpName = false;
              i = j;
              lastPos = i + 1;
              continue;
            }
          }
        }
        if (/\s|\n|\t/.test(c)) {
          html = html.replace(/\s|\n|\t/g, " ");
          if (tmpName === false) {
            j = findNextEqual(html, i);
            if (j === -1) {
              v = util$1.trim(html.slice(lastPos, i));
              addAttr(v);
              tmpName = false;
              lastPos = i + 1;
              continue;
            } else {
              i = j - 1;
              continue;
            }
          } else {
            j = findBeforeEqual(html, i - 1);
            if (j === -1) {
              v = util$1.trim(html.slice(lastPos, i));
              v = stripQuoteWrap(v);
              addAttr(tmpName, v);
              tmpName = false;
              lastPos = i + 1;
              continue;
            } else {
              continue;
            }
          }
        }
      }

      if (lastPos < html.length) {
        if (tmpName === false) {
          addAttr(html.slice(lastPos));
        } else {
          addAttr(tmpName, stripQuoteWrap(util$1.trim(html.slice(lastPos))));
        }
      }

      return util$1.trim(retAttrs.join(" "));
    }

    function findNextEqual(str, i) {
      for (; i < str.length; i++) {
        var c = str[i];
        if (c === " ") continue;
        if (c === "=") return i;
        return -1;
      }
    }

    function findBeforeEqual(str, i) {
      for (; i > 0; i--) {
        var c = str[i];
        if (c === " ") continue;
        if (c === "=") return i;
        return -1;
      }
    }

    function isQuoteWrapString(text) {
      if (
        (text[0] === '"' && text[text.length - 1] === '"') ||
        (text[0] === "'" && text[text.length - 1] === "'")
      ) {
        return true;
      } else {
        return false;
      }
    }

    function stripQuoteWrap(text) {
      if (isQuoteWrapString(text)) {
        return text.substr(1, text.length - 2);
      } else {
        return text;
      }
    }

    var parseTag_1 = parseTag;
    var parseAttr_1 = parseAttr;

    var parser$1 = {
    	parseTag: parseTag_1,
    	parseAttr: parseAttr_1
    };

    /**
     * filter xss
     *
     * @author Zongmin Lei<leizongmin@gmail.com>
     */

    var FilterCSS$2 = lib.FilterCSS;


    var parseTag$1 = parser$1.parseTag;
    var parseAttr$1 = parser$1.parseAttr;


    /**
     * returns `true` if the input value is `undefined` or `null`
     *
     * @param {Object} obj
     * @return {Boolean}
     */
    function isNull$1(obj) {
      return obj === undefined || obj === null;
    }

    /**
     * get attributes for a tag
     *
     * @param {String} html
     * @return {Object}
     *   - {String} html
     *   - {Boolean} closing
     */
    function getAttrs(html) {
      var i = util$1.spaceIndex(html);
      if (i === -1) {
        return {
          html: "",
          closing: html[html.length - 2] === "/"
        };
      }
      html = util$1.trim(html.slice(i + 1, -1));
      var isClosing = html[html.length - 1] === "/";
      if (isClosing) html = util$1.trim(html.slice(0, -1));
      return {
        html: html,
        closing: isClosing
      };
    }

    /**
     * shallow copy
     *
     * @param {Object} obj
     * @return {Object}
     */
    function shallowCopyObject$1(obj) {
      var ret = {};
      for (var i in obj) {
        ret[i] = obj[i];
      }
      return ret;
    }

    /**
     * FilterXSS class
     *
     * @param {Object} options
     *        whiteList, onTag, onTagAttr, onIgnoreTag,
     *        onIgnoreTagAttr, safeAttrValue, escapeHtml
     *        stripIgnoreTagBody, allowCommentTag, stripBlankChar
     *        css{whiteList, onAttr, onIgnoreAttr} `css=false` means don't use `cssfilter`
     */
    function FilterXSS(options) {
      options = shallowCopyObject$1(options || {});

      if (options.stripIgnoreTag) {
        if (options.onIgnoreTag) {
          console.error(
            'Notes: cannot use these two options "stripIgnoreTag" and "onIgnoreTag" at the same time'
          );
        }
        options.onIgnoreTag = _default$1.onIgnoreTagStripAll;
      }

      options.whiteList = options.whiteList || _default$1.whiteList;
      options.onTag = options.onTag || _default$1.onTag;
      options.onTagAttr = options.onTagAttr || _default$1.onTagAttr;
      options.onIgnoreTag = options.onIgnoreTag || _default$1.onIgnoreTag;
      options.onIgnoreTagAttr = options.onIgnoreTagAttr || _default$1.onIgnoreTagAttr;
      options.safeAttrValue = options.safeAttrValue || _default$1.safeAttrValue;
      options.escapeHtml = options.escapeHtml || _default$1.escapeHtml;
      this.options = options;

      if (options.css === false) {
        this.cssFilter = false;
      } else {
        options.css = options.css || {};
        this.cssFilter = new FilterCSS$2(options.css);
      }
    }

    /**
     * start process and returns result
     *
     * @param {String} html
     * @return {String}
     */
    FilterXSS.prototype.process = function(html) {
      // compatible with the input
      html = html || "";
      html = html.toString();
      if (!html) return "";

      var me = this;
      var options = me.options;
      var whiteList = options.whiteList;
      var onTag = options.onTag;
      var onIgnoreTag = options.onIgnoreTag;
      var onTagAttr = options.onTagAttr;
      var onIgnoreTagAttr = options.onIgnoreTagAttr;
      var safeAttrValue = options.safeAttrValue;
      var escapeHtml = options.escapeHtml;
      var cssFilter = me.cssFilter;

      // remove invisible characters
      if (options.stripBlankChar) {
        html = _default$1.stripBlankChar(html);
      }

      // remove html comments
      if (!options.allowCommentTag) {
        html = _default$1.stripCommentTag(html);
      }

      // if enable stripIgnoreTagBody
      var stripIgnoreTagBody = false;
      if (options.stripIgnoreTagBody) {
        var stripIgnoreTagBody = _default$1.StripTagBody(
          options.stripIgnoreTagBody,
          onIgnoreTag
        );
        onIgnoreTag = stripIgnoreTagBody.onIgnoreTag;
      }

      var retHtml = parseTag$1(
        html,
        function(sourcePosition, position, tag, html, isClosing) {
          var info = {
            sourcePosition: sourcePosition,
            position: position,
            isClosing: isClosing,
            isWhite: whiteList.hasOwnProperty(tag)
          };

          // call `onTag()`
          var ret = onTag(tag, html, info);
          if (!isNull$1(ret)) return ret;

          if (info.isWhite) {
            if (info.isClosing) {
              return "</" + tag + ">";
            }

            var attrs = getAttrs(html);
            var whiteAttrList = whiteList[tag];
            var attrsHtml = parseAttr$1(attrs.html, function(name, value) {
              // call `onTagAttr()`
              var isWhiteAttr = util$1.indexOf(whiteAttrList, name) !== -1;
              var ret = onTagAttr(tag, name, value, isWhiteAttr);
              if (!isNull$1(ret)) return ret;

              if (isWhiteAttr) {
                // call `safeAttrValue()`
                value = safeAttrValue(tag, name, value, cssFilter);
                if (value) {
                  return name + '="' + value + '"';
                } else {
                  return name;
                }
              } else {
                // call `onIgnoreTagAttr()`
                var ret = onIgnoreTagAttr(tag, name, value, isWhiteAttr);
                if (!isNull$1(ret)) return ret;
                return;
              }
            });

            // build new tag html
            var html = "<" + tag;
            if (attrsHtml) html += " " + attrsHtml;
            if (attrs.closing) html += " /";
            html += ">";
            return html;
          } else {
            // call `onIgnoreTag()`
            var ret = onIgnoreTag(tag, html, info);
            if (!isNull$1(ret)) return ret;
            return escapeHtml(html);
          }
        },
        escapeHtml
      );

      // if enable stripIgnoreTagBody
      if (stripIgnoreTagBody) {
        retHtml = stripIgnoreTagBody.remove(retHtml);
      }

      return retHtml;
    };

    var xss = FilterXSS;

    var lib$1 = createCommonjsModule(function (module, exports) {
    /**
     * xss
     *
     * @author Zongmin Lei<leizongmin@gmail.com>
     */





    /**
     * filter xss function
     *
     * @param {String} html
     * @param {Object} options { whiteList, onTag, onTagAttr, onIgnoreTag, onIgnoreTagAttr, safeAttrValue, escapeHtml }
     * @return {String}
     */
    function filterXSS(html, options) {
      var xss$1 = new xss(options);
      return xss$1.process(html);
    }

    exports = module.exports = filterXSS;
    exports.filterXSS = filterXSS;
    exports.FilterXSS = xss;
    for (var i in _default$1) exports[i] = _default$1[i];
    for (var i in parser$1) exports[i] = parser$1[i];

    // using `xss` on the browser, output `filterXSS` to the globals
    if (typeof window !== "undefined") {
      window.filterXSS = module.exports;
    }

    // using `xss` on the WebWorker, output `filterXSS` to the globals
    function isWorkerEnv() {
      return typeof self !== 'undefined' && typeof DedicatedWorkerGlobalScope !== 'undefined' && self instanceof DedicatedWorkerGlobalScope;
    }
    if (isWorkerEnv()) {
      self.filterXSS = module.exports;
    }
    });
    var lib_1$1 = lib$1.filterXSS;
    var lib_2 = lib$1.FilterXSS;

    var highlight = createCommonjsModule(function (module, exports) {
    /*
    Syntax highlighting with language autodetection.
    https://highlightjs.org/
    */

    (function(factory) {

      // Find the global object for export to both the browser and web workers.
      var globalObject = typeof window === 'object' && window ||
                         typeof self === 'object' && self;

      // Setup highlight.js for different environments. First is Node.js or
      // CommonJS.
      // `nodeType` is checked to ensure that `exports` is not a HTML element.
      if( !exports.nodeType) {
        factory(exports);
      } else if(globalObject) {
        // Export hljs globally even when using AMD for cases when this script
        // is loaded with others that may still expect a global hljs.
        globalObject.hljs = factory({});
      }

    }(function(hljs) {
      // Convenience variables for build-in objects
      var ArrayProto = [],
          objectKeys = Object.keys;

      // Global internal variables used within the highlight.js library.
      var languages = {},
          aliases   = {};

      // safe/production mode - swallows more errors, tries to keep running
      // even if a single syntax or parse hits a fatal error
      var SAFE_MODE = true;

      // Regular expressions used throughout the highlight.js library.
      var noHighlightRe    = /^(no-?highlight|plain|text)$/i,
          languagePrefixRe = /\blang(?:uage)?-([\w-]+)\b/i,
          fixMarkupRe      = /((^(<[^>]+>|\t|)+|(?:\n)))/gm;

      var spanEndTag = '</span>';
      var LANGUAGE_NOT_FOUND = "Could not find the language '{}', did you forget to load/include a language module?";

      // Global options used when within external APIs. This is modified when
      // calling the `hljs.configure` function.
      var options = {
        classPrefix: 'hljs-',
        tabReplace: null,
        useBR: false,
        languages: undefined
      };

      // keywords that should have no default relevance value
      var COMMON_KEYWORDS = 'of and for in not or if then'.split(' ');


      /* Utility functions */

      function escape(value) {
        return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
      }

      function tag(node) {
        return node.nodeName.toLowerCase();
      }

      function testRe(re, lexeme) {
        var match = re && re.exec(lexeme);
        return match && match.index === 0;
      }

      function isNotHighlighted(language) {
        return noHighlightRe.test(language);
      }

      function blockLanguage(block) {
        var i, match, length, _class;
        var classes = block.className + ' ';

        classes += block.parentNode ? block.parentNode.className : '';

        // language-* takes precedence over non-prefixed class names.
        match = languagePrefixRe.exec(classes);
        if (match) {
          var language = getLanguage(match[1]);
          if (!language) {
            console.warn(LANGUAGE_NOT_FOUND.replace("{}", match[1]));
            console.warn("Falling back to no-highlight mode for this block.", block);
          }
          return language ? match[1] : 'no-highlight';
        }

        classes = classes.split(/\s+/);

        for (i = 0, length = classes.length; i < length; i++) {
          _class = classes[i];

          if (isNotHighlighted(_class) || getLanguage(_class)) {
            return _class;
          }
        }
      }

      /**
       * performs a shallow merge of multiple objects into one
       *
       * @arguments list of objects with properties to merge
       * @returns a single new object
       */
      function inherit(parent) {  // inherit(parent, override_obj, override_obj, ...)
        var key;
        var result = {};
        var objects = Array.prototype.slice.call(arguments, 1);

        for (key in parent)
          result[key] = parent[key];
        objects.forEach(function(obj) {
          for (key in obj)
            result[key] = obj[key];
        });
        return result;
      }

      /* Stream merging */

      function nodeStream(node) {
        var result = [];
        (function _nodeStream(node, offset) {
          for (var child = node.firstChild; child; child = child.nextSibling) {
            if (child.nodeType === 3)
              offset += child.nodeValue.length;
            else if (child.nodeType === 1) {
              result.push({
                event: 'start',
                offset: offset,
                node: child
              });
              offset = _nodeStream(child, offset);
              // Prevent void elements from having an end tag that would actually
              // double them in the output. There are more void elements in HTML
              // but we list only those realistically expected in code display.
              if (!tag(child).match(/br|hr|img|input/)) {
                result.push({
                  event: 'stop',
                  offset: offset,
                  node: child
                });
              }
            }
          }
          return offset;
        })(node, 0);
        return result;
      }

      function mergeStreams(original, highlighted, value) {
        var processed = 0;
        var result = '';
        var nodeStack = [];

        function selectStream() {
          if (!original.length || !highlighted.length) {
            return original.length ? original : highlighted;
          }
          if (original[0].offset !== highlighted[0].offset) {
            return (original[0].offset < highlighted[0].offset) ? original : highlighted;
          }

          /*
          To avoid starting the stream just before it should stop the order is
          ensured that original always starts first and closes last:

          if (event1 == 'start' && event2 == 'start')
            return original;
          if (event1 == 'start' && event2 == 'stop')
            return highlighted;
          if (event1 == 'stop' && event2 == 'start')
            return original;
          if (event1 == 'stop' && event2 == 'stop')
            return highlighted;

          ... which is collapsed to:
          */
          return highlighted[0].event === 'start' ? original : highlighted;
        }

        function open(node) {
          function attr_str(a) {
            return ' ' + a.nodeName + '="' + escape(a.value).replace(/"/g, '&quot;') + '"';
          }
          result += '<' + tag(node) + ArrayProto.map.call(node.attributes, attr_str).join('') + '>';
        }

        function close(node) {
          result += '</' + tag(node) + '>';
        }

        function render(event) {
          (event.event === 'start' ? open : close)(event.node);
        }

        while (original.length || highlighted.length) {
          var stream = selectStream();
          result += escape(value.substring(processed, stream[0].offset));
          processed = stream[0].offset;
          if (stream === original) {
            /*
            On any opening or closing tag of the original markup we first close
            the entire highlighted node stack, then render the original tag along
            with all the following original tags at the same offset and then
            reopen all the tags on the highlighted stack.
            */
            nodeStack.reverse().forEach(close);
            do {
              render(stream.splice(0, 1)[0]);
              stream = selectStream();
            } while (stream === original && stream.length && stream[0].offset === processed);
            nodeStack.reverse().forEach(open);
          } else {
            if (stream[0].event === 'start') {
              nodeStack.push(stream[0].node);
            } else {
              nodeStack.pop();
            }
            render(stream.splice(0, 1)[0]);
          }
        }
        return result + escape(value.substr(processed));
      }

      /* Initialization */

      function dependencyOnParent(mode) {
        if (!mode) return false;

        return mode.endsWithParent || dependencyOnParent(mode.starts);
      }

      function expand_or_clone_mode(mode) {
        if (mode.variants && !mode.cached_variants) {
          mode.cached_variants = mode.variants.map(function(variant) {
            return inherit(mode, {variants: null}, variant);
          });
        }

        // EXPAND
        // if we have variants then essentially "replace" the mode with the variants
        // this happens in compileMode, where this function is called from
        if (mode.cached_variants)
          return mode.cached_variants;

        // CLONE
        // if we have dependencies on parents then we need a unique
        // instance of ourselves, so we can be reused with many
        // different parents without issue
        if (dependencyOnParent(mode))
          return [inherit(mode, { starts: mode.starts ? inherit(mode.starts) : null })];

        if (Object.isFrozen(mode))
          return [inherit(mode)];

        // no special dependency issues, just return ourselves
        return [mode];
      }

      function compileKeywords(rawKeywords, case_insensitive) {
          var compiled_keywords = {};

          if (typeof rawKeywords === 'string') { // string
            splitAndCompile('keyword', rawKeywords);
          } else {
            objectKeys(rawKeywords).forEach(function (className) {
              splitAndCompile(className, rawKeywords[className]);
            });
          }
        return compiled_keywords;

        // ---

        function splitAndCompile(className, str) {
          if (case_insensitive) {
            str = str.toLowerCase();
          }
          str.split(' ').forEach(function(keyword) {
            var pair = keyword.split('|');
            compiled_keywords[pair[0]] = [className, scoreForKeyword(pair[0], pair[1])];
          });
        }
      }

      function scoreForKeyword(keyword, providedScore) {
        // manual scores always win over common keywords
        // so you can force a score of 1 if you really insist
        if (providedScore)
          return Number(providedScore);

        return commonKeyword(keyword) ? 0 : 1;
      }

      function commonKeyword(word) {
        return COMMON_KEYWORDS.indexOf(word.toLowerCase()) != -1;
      }

      function compileLanguage(language) {

        function reStr(re) {
            return (re && re.source) || re;
        }

        function langRe(value, global) {
          return new RegExp(
            reStr(value),
            'm' + (language.case_insensitive ? 'i' : '') + (global ? 'g' : '')
          );
        }

        function reCountMatchGroups(re) {
          return (new RegExp(re.toString() + '|')).exec('').length - 1;
        }

        // joinRe logically computes regexps.join(separator), but fixes the
        // backreferences so they continue to match.
        // it also places each individual regular expression into it's own
        // match group, keeping track of the sequencing of those match groups
        // is currently an exercise for the caller. :-)
        function joinRe(regexps, separator) {
          // backreferenceRe matches an open parenthesis or backreference. To avoid
          // an incorrect parse, it additionally matches the following:
          // - [...] elements, where the meaning of parentheses and escapes change
          // - other escape sequences, so we do not misparse escape sequences as
          //   interesting elements
          // - non-matching or lookahead parentheses, which do not capture. These
          //   follow the '(' with a '?'.
          var backreferenceRe = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
          var numCaptures = 0;
          var ret = '';
          for (var i = 0; i < regexps.length; i++) {
            numCaptures += 1;
            var offset = numCaptures;
            var re = reStr(regexps[i]);
            if (i > 0) {
              ret += separator;
            }
            ret += "(";
            while (re.length > 0) {
              var match = backreferenceRe.exec(re);
              if (match == null) {
                ret += re;
                break;
              }
              ret += re.substring(0, match.index);
              re = re.substring(match.index + match[0].length);
              if (match[0][0] == '\\' && match[1]) {
                // Adjust the backreference.
                ret += '\\' + String(Number(match[1]) + offset);
              } else {
                ret += match[0];
                if (match[0] == '(') {
                  numCaptures++;
                }
              }
            }
            ret += ")";
          }
          return ret;
        }

        function buildModeRegex(mode) {

          var matchIndexes = {};
          var matcherRe;
          var regexes = [];
          var matcher = {};
          var matchAt = 1;

          function addRule(rule, regex) {
            matchIndexes[matchAt] = rule;
            regexes.push([rule, regex]);
            matchAt += reCountMatchGroups(regex) + 1;
          }

          var term;
          for (var i=0; i < mode.contains.length; i++) {
            var re;
            term = mode.contains[i];
            if (term.beginKeywords) {
              re = '\\.?(?:' + term.begin + ')\\.?';
            } else {
              re = term.begin;
            }
            addRule(term, re);
          }
          if (mode.terminator_end)
            addRule("end", mode.terminator_end);
          if (mode.illegal)
            addRule("illegal", mode.illegal);

          var terminators = regexes.map(function(el) { return el[1]; });
          matcherRe = langRe(joinRe(terminators, '|'), true);

          matcher.lastIndex = 0;
          matcher.exec = function(s) {
            var rule;

            if( regexes.length === 0) return null;

            matcherRe.lastIndex = matcher.lastIndex;
            var match = matcherRe.exec(s);
            if (!match) { return null; }

            for(var i = 0; i<match.length; i++) {
              if (match[i] != undefined && matchIndexes["" +i] != undefined ) {
                rule = matchIndexes[""+i];
                break;
              }
            }

            // illegal or end match
            if (typeof rule === "string") {
              match.type = rule;
              match.extra = [mode.illegal, mode.terminator_end];
            } else {
              match.type = "begin";
              match.rule = rule;
            }
            return match;
          };

          return matcher;
        }

        function compileMode(mode, parent) {
          if (mode.compiled)
            return;
          mode.compiled = true;

          mode.keywords = mode.keywords || mode.beginKeywords;
          if (mode.keywords)
            mode.keywords = compileKeywords(mode.keywords, language.case_insensitive);

          mode.lexemesRe = langRe(mode.lexemes || /\w+/, true);

          if (parent) {
            if (mode.beginKeywords) {
              mode.begin = '\\b(' + mode.beginKeywords.split(' ').join('|') + ')\\b';
            }
            if (!mode.begin)
              mode.begin = /\B|\b/;
            mode.beginRe = langRe(mode.begin);
            if (mode.endSameAsBegin)
              mode.end = mode.begin;
            if (!mode.end && !mode.endsWithParent)
              mode.end = /\B|\b/;
            if (mode.end)
              mode.endRe = langRe(mode.end);
            mode.terminator_end = reStr(mode.end) || '';
            if (mode.endsWithParent && parent.terminator_end)
              mode.terminator_end += (mode.end ? '|' : '') + parent.terminator_end;
          }
          if (mode.illegal)
            mode.illegalRe = langRe(mode.illegal);
          if (mode.relevance == null)
            mode.relevance = 1;
          if (!mode.contains) {
            mode.contains = [];
          }
          mode.contains = Array.prototype.concat.apply([], mode.contains.map(function(c) {
            return expand_or_clone_mode(c === 'self' ? mode : c);
          }));
          mode.contains.forEach(function(c) {compileMode(c, mode);});

          if (mode.starts) {
            compileMode(mode.starts, parent);
          }

          mode.terminators = buildModeRegex(mode);
        }

        // self is not valid at the top-level
        if (language.contains && language.contains.indexOf('self') != -1) {
          if (!SAFE_MODE) {
            throw new Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.")
          } else {
            // silently remove the broken rule (effectively ignoring it), this has historically
            // been the behavior in the past, so this removal preserves compatibility with broken
            // grammars when running in Safe Mode
            language.contains = language.contains.filter(function(mode) { return mode != 'self'; });
          }
        }
        compileMode(language);
      }

      /*
      Core highlighting function. Accepts a language name, or an alias, and a
      string with the code to highlight. Returns an object with the following
      properties:

      - relevance (int)
      - value (an HTML string with highlighting markup)

      */
      function highlight(name, value, ignore_illegals, continuation) {

        function escapeRe(value) {
          return new RegExp(value.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), 'm');
        }

        function endOfMode(mode, lexeme) {
          if (testRe(mode.endRe, lexeme)) {
            while (mode.endsParent && mode.parent) {
              mode = mode.parent;
            }
            return mode;
          }
          if (mode.endsWithParent) {
            return endOfMode(mode.parent, lexeme);
          }
        }

        function keywordMatch(mode, match) {
          var match_str = language.case_insensitive ? match[0].toLowerCase() : match[0];
          return mode.keywords.hasOwnProperty(match_str) && mode.keywords[match_str];
        }

        function buildSpan(className, insideSpan, leaveOpen, noPrefix) {
          if (!leaveOpen && insideSpan === '') return '';
          if (!className) return insideSpan;

          var classPrefix = noPrefix ? '' : options.classPrefix,
              openSpan    = '<span class="' + classPrefix,
              closeSpan   = leaveOpen ? '' : spanEndTag;

          openSpan += className + '">';

          return openSpan + insideSpan + closeSpan;
        }

        function processKeywords() {
          var keyword_match, last_index, match, result;

          if (!top.keywords)
            return escape(mode_buffer);

          result = '';
          last_index = 0;
          top.lexemesRe.lastIndex = 0;
          match = top.lexemesRe.exec(mode_buffer);

          while (match) {
            result += escape(mode_buffer.substring(last_index, match.index));
            keyword_match = keywordMatch(top, match);
            if (keyword_match) {
              relevance += keyword_match[1];
              result += buildSpan(keyword_match[0], escape(match[0]));
            } else {
              result += escape(match[0]);
            }
            last_index = top.lexemesRe.lastIndex;
            match = top.lexemesRe.exec(mode_buffer);
          }
          return result + escape(mode_buffer.substr(last_index));
        }

        function processSubLanguage() {
          var explicit = typeof top.subLanguage === 'string';
          if (explicit && !languages[top.subLanguage]) {
            return escape(mode_buffer);
          }

          var result = explicit ?
                       highlight(top.subLanguage, mode_buffer, true, continuations[top.subLanguage]) :
                       highlightAuto(mode_buffer, top.subLanguage.length ? top.subLanguage : undefined);

          // Counting embedded language score towards the host language may be disabled
          // with zeroing the containing mode relevance. Use case in point is Markdown that
          // allows XML everywhere and makes every XML snippet to have a much larger Markdown
          // score.
          if (top.relevance > 0) {
            relevance += result.relevance;
          }
          if (explicit) {
            continuations[top.subLanguage] = result.top;
          }
          return buildSpan(result.language, result.value, false, true);
        }

        function processBuffer() {
          result += (top.subLanguage != null ? processSubLanguage() : processKeywords());
          mode_buffer = '';
        }

        function startNewMode(mode) {
          result += mode.className? buildSpan(mode.className, '', true): '';
          top = Object.create(mode, {parent: {value: top}});
        }


        function doBeginMatch(match) {
          var lexeme = match[0];
          var new_mode = match.rule;

          if (new_mode && new_mode.endSameAsBegin) {
            new_mode.endRe = escapeRe( lexeme );
          }

          if (new_mode.skip) {
            mode_buffer += lexeme;
          } else {
            if (new_mode.excludeBegin) {
              mode_buffer += lexeme;
            }
            processBuffer();
            if (!new_mode.returnBegin && !new_mode.excludeBegin) {
              mode_buffer = lexeme;
            }
          }
          startNewMode(new_mode);
          return new_mode.returnBegin ? 0 : lexeme.length;
        }

        function doEndMatch(match) {
          var lexeme = match[0];
          var matchPlusRemainder = value.substr(match.index);
          var end_mode = endOfMode(top, matchPlusRemainder);
          if (!end_mode) { return; }

          var origin = top;
          if (origin.skip) {
            mode_buffer += lexeme;
          } else {
            if (!(origin.returnEnd || origin.excludeEnd)) {
              mode_buffer += lexeme;
            }
            processBuffer();
            if (origin.excludeEnd) {
              mode_buffer = lexeme;
            }
          }
          do {
            if (top.className) {
              result += spanEndTag;
            }
            if (!top.skip && !top.subLanguage) {
              relevance += top.relevance;
            }
            top = top.parent;
          } while (top !== end_mode.parent);
          if (end_mode.starts) {
            if (end_mode.endSameAsBegin) {
              end_mode.starts.endRe = end_mode.endRe;
            }
            startNewMode(end_mode.starts);
          }
          return origin.returnEnd ? 0 : lexeme.length;
        }

        var lastMatch = {};
        function processLexeme(text_before_match, match) {

          var lexeme = match && match[0];

          // add non-matched text to the current mode buffer
          mode_buffer += text_before_match;

          if (lexeme == null) {
            processBuffer();
            return 0;
          }

          // we've found a 0 width match and we're stuck, so we need to advance
          // this happens when we have badly behaved rules that have optional matchers to the degree that
          // sometimes they can end up matching nothing at all
          // Ref: https://github.com/highlightjs/highlight.js/issues/2140
          if (lastMatch.type=="begin" && match.type=="end" && lastMatch.index == match.index && lexeme === "") {
            // spit the "skipped" character that our regex choked on back into the output sequence
            mode_buffer += value.slice(match.index, match.index + 1);
            return 1;
          }
          lastMatch = match;

          if (match.type==="begin") {
            return doBeginMatch(match);
          } else if (match.type==="illegal" && !ignore_illegals) {
            // illegal match, we do not continue processing
            throw new Error('Illegal lexeme "' + lexeme + '" for mode "' + (top.className || '<unnamed>') + '"');
          } else if (match.type==="end") {
            var processed = doEndMatch(match);
            if (processed != undefined)
              return processed;
          }

          /*
          Why might be find ourselves here?  Only one occasion now.  An end match that was
          triggered but could not be completed.  When might this happen?  When an `endSameasBegin`
          rule sets the end rule to a specific match.  Since the overall mode termination rule that's
          being used to scan the text isn't recompiled that means that any match that LOOKS like
          the end (but is not, because it is not an exact match to the beginning) will
          end up here.  A definite end match, but when `doEndMatch` tries to "reapply"
          the end rule and fails to match, we wind up here, and just silently ignore the end.

          This causes no real harm other than stopping a few times too many.
          */

          mode_buffer += lexeme;
          return lexeme.length;
        }

        var language = getLanguage(name);
        if (!language) {
          console.error(LANGUAGE_NOT_FOUND.replace("{}", name));
          throw new Error('Unknown language: "' + name + '"');
        }

        compileLanguage(language);
        var top = continuation || language;
        var continuations = {}; // keep continuations for sub-languages
        var result = '', current;
        for(current = top; current !== language; current = current.parent) {
          if (current.className) {
            result = buildSpan(current.className, '', true) + result;
          }
        }
        var mode_buffer = '';
        var relevance = 0;
        try {
          var match, count, index = 0;
          while (true) {
            top.terminators.lastIndex = index;
            match = top.terminators.exec(value);
            if (!match)
              break;
            count = processLexeme(value.substring(index, match.index), match);
            index = match.index + count;
          }
          processLexeme(value.substr(index));
          for(current = top; current.parent; current = current.parent) { // close dangling modes
            if (current.className) {
              result += spanEndTag;
            }
          }
          return {
            relevance: relevance,
            value: result,
            illegal:false,
            language: name,
            top: top
          };
        } catch (err) {
          if (err.message && err.message.indexOf('Illegal') !== -1) {
            return {
              illegal: true,
              relevance: 0,
              value: escape(value)
            };
          } else if (SAFE_MODE) {
            return {
              relevance: 0,
              value: escape(value),
              language: name,
              top: top,
              errorRaised: err
            };
          } else {
            throw err;
          }
        }
      }

      /*
      Highlighting with language detection. Accepts a string with the code to
      highlight. Returns an object with the following properties:

      - language (detected language)
      - relevance (int)
      - value (an HTML string with highlighting markup)
      - second_best (object with the same structure for second-best heuristically
        detected language, may be absent)

      */
      function highlightAuto(text, languageSubset) {
        languageSubset = languageSubset || options.languages || objectKeys(languages);
        var result = {
          relevance: 0,
          value: escape(text)
        };
        var second_best = result;
        languageSubset.filter(getLanguage).filter(autoDetection).forEach(function(name) {
          var current = highlight(name, text, false);
          current.language = name;
          if (current.relevance > second_best.relevance) {
            second_best = current;
          }
          if (current.relevance > result.relevance) {
            second_best = result;
            result = current;
          }
        });
        if (second_best.language) {
          result.second_best = second_best;
        }
        return result;
      }

      /*
      Post-processing of the highlighted markup:

      - replace TABs with something more useful
      - replace real line-breaks with '<br>' for non-pre containers

      */
      function fixMarkup(value) {
        if (!(options.tabReplace || options.useBR)) {
          return value;
        }

        return value.replace(fixMarkupRe, function(match, p1) {
            if (options.useBR && match === '\n') {
              return '<br>';
            } else if (options.tabReplace) {
              return p1.replace(/\t/g, options.tabReplace);
            }
            return '';
        });
      }

      function buildClassName(prevClassName, currentLang, resultLang) {
        var language = currentLang ? aliases[currentLang] : resultLang,
            result   = [prevClassName.trim()];

        if (!prevClassName.match(/\bhljs\b/)) {
          result.push('hljs');
        }

        if (prevClassName.indexOf(language) === -1) {
          result.push(language);
        }

        return result.join(' ').trim();
      }

      /*
      Applies highlighting to a DOM node containing code. Accepts a DOM node and
      two optional parameters for fixMarkup.
      */
      function highlightBlock(block) {
        var node, originalStream, result, resultNode, text;
        var language = blockLanguage(block);

        if (isNotHighlighted(language))
            return;

        if (options.useBR) {
          node = document.createElement('div');
          node.innerHTML = block.innerHTML.replace(/\n/g, '').replace(/<br[ \/]*>/g, '\n');
        } else {
          node = block;
        }
        text = node.textContent;
        result = language ? highlight(language, text, true) : highlightAuto(text);

        originalStream = nodeStream(node);
        if (originalStream.length) {
          resultNode = document.createElement('div');
          resultNode.innerHTML = result.value;
          result.value = mergeStreams(originalStream, nodeStream(resultNode), text);
        }
        result.value = fixMarkup(result.value);

        block.innerHTML = result.value;
        block.className = buildClassName(block.className, language, result.language);
        block.result = {
          language: result.language,
          re: result.relevance
        };
        if (result.second_best) {
          block.second_best = {
            language: result.second_best.language,
            re: result.second_best.relevance
          };
        }
      }

      /*
      Updates highlight.js global options with values passed in the form of an object.
      */
      function configure(user_options) {
        options = inherit(options, user_options);
      }

      /*
      Applies highlighting to all <pre><code>..</code></pre> blocks on a page.
      */
      function initHighlighting() {
        if (initHighlighting.called)
          return;
        initHighlighting.called = true;

        var blocks = document.querySelectorAll('pre code');
        ArrayProto.forEach.call(blocks, highlightBlock);
      }

      /*
      Attaches highlighting to the page load event.
      */
      function initHighlightingOnLoad() {
        window.addEventListener('DOMContentLoaded', initHighlighting, false);
        window.addEventListener('load', initHighlighting, false);
      }

      var PLAINTEXT_LANGUAGE = { disableAutodetect: true };

      function registerLanguage(name, language) {
        var lang;
        try { lang = language(hljs); }
        catch (error) {
          console.error("Language definition for '{}' could not be registered.".replace("{}", name));
          // hard or soft error
          if (!SAFE_MODE) { throw error; } else { console.error(error); }
          // languages that have serious errors are replaced with essentially a
          // "plaintext" stand-in so that the code blocks will still get normal
          // css classes applied to them - and one bad language won't break the
          // entire highlighter
          lang = PLAINTEXT_LANGUAGE;
        }
        languages[name] = lang;
        lang.rawDefinition = language.bind(null,hljs);

        if (lang.aliases) {
          lang.aliases.forEach(function(alias) {aliases[alias] = name;});
        }
      }

      function listLanguages() {
        return objectKeys(languages);
      }

      /*
        intended usage: When one language truly requires another

        Unlike `getLanguage`, this will throw when the requested language
        is not available.
      */
      function requireLanguage(name) {
        var lang = getLanguage(name);
        if (lang) { return lang; }

        var err = new Error('The \'{}\' language is required, but not loaded.'.replace('{}',name));
        throw err;
      }

      function getLanguage(name) {
        name = (name || '').toLowerCase();
        return languages[name] || languages[aliases[name]];
      }

      function autoDetection(name) {
        var lang = getLanguage(name);
        return lang && !lang.disableAutodetect;
      }

      /* Interface definition */

      hljs.highlight = highlight;
      hljs.highlightAuto = highlightAuto;
      hljs.fixMarkup = fixMarkup;
      hljs.highlightBlock = highlightBlock;
      hljs.configure = configure;
      hljs.initHighlighting = initHighlighting;
      hljs.initHighlightingOnLoad = initHighlightingOnLoad;
      hljs.registerLanguage = registerLanguage;
      hljs.listLanguages = listLanguages;
      hljs.getLanguage = getLanguage;
      hljs.requireLanguage = requireLanguage;
      hljs.autoDetection = autoDetection;
      hljs.inherit = inherit;
      hljs.debugMode = function() { SAFE_MODE = false; };

      // Common regexps
      hljs.IDENT_RE = '[a-zA-Z]\\w*';
      hljs.UNDERSCORE_IDENT_RE = '[a-zA-Z_]\\w*';
      hljs.NUMBER_RE = '\\b\\d+(\\.\\d+)?';
      hljs.C_NUMBER_RE = '(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)'; // 0x..., 0..., decimal, float
      hljs.BINARY_NUMBER_RE = '\\b(0b[01]+)'; // 0b...
      hljs.RE_STARTERS_RE = '!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~';

      // Common modes
      hljs.BACKSLASH_ESCAPE = {
        begin: '\\\\[\\s\\S]', relevance: 0
      };
      hljs.APOS_STRING_MODE = {
        className: 'string',
        begin: '\'', end: '\'',
        illegal: '\\n',
        contains: [hljs.BACKSLASH_ESCAPE]
      };
      hljs.QUOTE_STRING_MODE = {
        className: 'string',
        begin: '"', end: '"',
        illegal: '\\n',
        contains: [hljs.BACKSLASH_ESCAPE]
      };
      hljs.PHRASAL_WORDS_MODE = {
        begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
      };
      hljs.COMMENT = function (begin, end, inherits) {
        var mode = hljs.inherit(
          {
            className: 'comment',
            begin: begin, end: end,
            contains: []
          },
          inherits || {}
        );
        mode.contains.push(hljs.PHRASAL_WORDS_MODE);
        mode.contains.push({
          className: 'doctag',
          begin: '(?:TODO|FIXME|NOTE|BUG|XXX):',
          relevance: 0
        });
        return mode;
      };
      hljs.C_LINE_COMMENT_MODE = hljs.COMMENT('//', '$');
      hljs.C_BLOCK_COMMENT_MODE = hljs.COMMENT('/\\*', '\\*/');
      hljs.HASH_COMMENT_MODE = hljs.COMMENT('#', '$');
      hljs.NUMBER_MODE = {
        className: 'number',
        begin: hljs.NUMBER_RE,
        relevance: 0
      };
      hljs.C_NUMBER_MODE = {
        className: 'number',
        begin: hljs.C_NUMBER_RE,
        relevance: 0
      };
      hljs.BINARY_NUMBER_MODE = {
        className: 'number',
        begin: hljs.BINARY_NUMBER_RE,
        relevance: 0
      };
      hljs.CSS_NUMBER_MODE = {
        className: 'number',
        begin: hljs.NUMBER_RE + '(' +
          '%|em|ex|ch|rem'  +
          '|vw|vh|vmin|vmax' +
          '|cm|mm|in|pt|pc|px' +
          '|deg|grad|rad|turn' +
          '|s|ms' +
          '|Hz|kHz' +
          '|dpi|dpcm|dppx' +
          ')?',
        relevance: 0
      };
      hljs.REGEXP_MODE = {
        className: 'regexp',
        begin: /\//, end: /\/[gimuy]*/,
        illegal: /\n/,
        contains: [
          hljs.BACKSLASH_ESCAPE,
          {
            begin: /\[/, end: /\]/,
            relevance: 0,
            contains: [hljs.BACKSLASH_ESCAPE]
          }
        ]
      };
      hljs.TITLE_MODE = {
        className: 'title',
        begin: hljs.IDENT_RE,
        relevance: 0
      };
      hljs.UNDERSCORE_TITLE_MODE = {
        className: 'title',
        begin: hljs.UNDERSCORE_IDENT_RE,
        relevance: 0
      };
      hljs.METHOD_GUARD = {
        // excludes method names from keyword processing
        begin: '\\.\\s*' + hljs.UNDERSCORE_IDENT_RE,
        relevance: 0
      };

      var constants = [
        hljs.BACKSLASH_ESCAPE,
        hljs.APOS_STRING_MODE,
        hljs.QUOTE_STRING_MODE,
        hljs.PHRASAL_WORDS_MODE,
        hljs.COMMENT,
        hljs.C_LINE_COMMENT_MODE,
        hljs.C_BLOCK_COMMENT_MODE,
        hljs.HASH_COMMENT_MODE,
        hljs.NUMBER_MODE,
        hljs.C_NUMBER_MODE,
        hljs.BINARY_NUMBER_MODE,
        hljs.CSS_NUMBER_MODE,
        hljs.REGEXP_MODE,
        hljs.TITLE_MODE,
        hljs.UNDERSCORE_TITLE_MODE,
        hljs.METHOD_GUARD
      ];
      constants.forEach(function(obj) { deepFreeze(obj); });

      // https://github.com/substack/deep-freeze/blob/master/index.js
      function deepFreeze (o) {
        Object.freeze(o);

        var objIsFunction = typeof o === 'function';

        Object.getOwnPropertyNames(o).forEach(function (prop) {
          if (o.hasOwnProperty(prop)
          && o[prop] !== null
          && (typeof o[prop] === "object" || typeof o[prop] === "function")
          // IE11 fix: https://github.com/highlightjs/highlight.js/issues/2318
          // TODO: remove in the future
          && (objIsFunction ? prop !== 'caller' && prop !== 'callee' && prop !== 'arguments' : true)
          && !Object.isFrozen(o[prop])) {
            deepFreeze(o[prop]);
          }
        });

        return o;
      }

      return hljs;
    }));
    });

    var yaml = function(hljs) {
      var LITERALS = 'true false yes no null';

      // Define keys as starting with a word character
      // ...containing word chars, spaces, colons, forward-slashes, hyphens and periods
      // ...and ending with a colon followed immediately by a space, tab or newline.
      // The YAML spec allows for much more than this, but this covers most use-cases.
      var KEY = {
        className: 'attr',
        variants: [
          { begin: '\\w[\\w :\\/.-]*:(?=[ \t]|$)' },
          { begin: '"\\w[\\w :\\/.-]*":(?=[ \t]|$)' }, //double quoted keys
          { begin: '\'\\w[\\w :\\/.-]*\':(?=[ \t]|$)' } //single quoted keys
        ]
      };

      var TEMPLATE_VARIABLES = {
        className: 'template-variable',
        variants: [
          { begin: '\{\{', end: '\}\}' }, // jinja templates Ansible
          { begin: '%\{', end: '\}' } // Ruby i18n
        ]
      };
      var STRING = {
        className: 'string',
        relevance: 0,
        variants: [
          {begin: /'/, end: /'/},
          {begin: /"/, end: /"/},
          {begin: /\S+/}
        ],
        contains: [
          hljs.BACKSLASH_ESCAPE,
          TEMPLATE_VARIABLES
        ]
      };

      return {
        case_insensitive: true,
        aliases: ['yml', 'YAML', 'yaml'],
        contains: [
          KEY,
          {
            className: 'meta',
            begin: '^---\s*$',
            relevance: 10
          },
          { // multi line string
            // Blocks start with a | or > followed by a newline
            //
            // Indentation of subsequent lines must be the same to
            // be considered part of the block
            className: 'string',
            begin: '[\\|>]([0-9]?[+-])?[ ]*\\n( *)[\\S ]+\\n(\\2[\\S ]+\\n?)*',
          },
          { // Ruby/Rails erb
            begin: '<%[%=-]?', end: '[%-]?%>',
            subLanguage: 'ruby',
            excludeBegin: true,
            excludeEnd: true,
            relevance: 0
          },
          { // local tags
            className: 'type',
            begin: '!' + hljs.UNDERSCORE_IDENT_RE,
          },
          { // data type
            className: 'type',
            begin: '!!' + hljs.UNDERSCORE_IDENT_RE,
          },
          { // fragment id &ref
            className: 'meta',
            begin: '&' + hljs.UNDERSCORE_IDENT_RE + '$',
          },
          { // fragment reference *ref
            className: 'meta',
            begin: '\\*' + hljs.UNDERSCORE_IDENT_RE + '$'
          },
          { // array listing
            className: 'bullet',
          // TODO: remove |$ hack when we have proper look-ahead support
          begin: '\\-(?=[ ]|$)',
            relevance: 0
          },
          hljs.HASH_COMMENT_MODE,
          {
            beginKeywords: LITERALS,
            keywords: {literal: LITERALS}
          },
          // numbers are any valid C-style number that
          // sit isolated from other words
          {
            className: 'number',
            begin: hljs.C_NUMBER_RE + '\\b'
          },
          STRING
        ]
      };
    };

    // from https://raw.githubusercontent.com/highlightjs/highlight.js/master/src/styles/github.css
    const HLJS = css `
  /*

github.com style (c) Vasily Polovnyov <vast@whiteants.net>

*/

  .hljs {
    display: block;
    overflow-x: auto;
    padding: 0.5em;
    color: #333;
    background: #f8f8f8;
  }

  .hljs-comment,
  .hljs-quote {
    color: #998;
    font-style: italic;
  }

  .hljs-keyword,
  .hljs-selector-tag,
  .hljs-subst {
    color: #333;
    font-weight: bold;
  }

  .hljs-number,
  .hljs-literal,
  .hljs-variable,
  .hljs-template-variable,
  .hljs-tag .hljs-attr {
    color: #008080;
  }

  .hljs-string,
  .hljs-doctag {
    color: #d14;
  }

  .hljs-title,
  .hljs-section,
  .hljs-selector-id {
    color: #900;
    font-weight: bold;
  }

  .hljs-subst {
    font-weight: normal;
  }

  .hljs-type,
  .hljs-class .hljs-title {
    color: #458;
    font-weight: bold;
  }

  .hljs-tag,
  .hljs-name,
  .hljs-attribute {
    color: #000080;
    font-weight: normal;
  }

  .hljs-regexp,
  .hljs-link {
    color: #009926;
  }

  .hljs-symbol,
  .hljs-bullet {
    color: #990073;
  }

  .hljs-built_in,
  .hljs-builtin-name {
    color: #0086b3;
  }

  .hljs-meta {
    color: #999;
    font-weight: bold;
  }

  .hljs-deletion {
    background: #fdd;
  }

  .hljs-addition {
    background: #dfd;
  }

  .hljs-emphasis {
    font-style: italic;
  }

  .hljs-strong {
    font-weight: bold;
  }
`;
    // From https://github.com/sindresorhus/github-markdown-css/blob/gh-pages/github-markdown.css
    const GFM1 = css `
  @font-face {
    font-family: octicons-link;
    src: url(data:font/woff;charset=utf-8;base64,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)
      format("woff");
  }
`;
    const GFM2 = css `
  .markdown-body .octicon {
    display: inline-block;
    fill: currentColor;
    vertical-align: text-bottom;
  }

  .markdown-body .anchor {
    float: left;
    line-height: 1;
    margin-left: -20px;
    padding-right: 4px;
  }

  .markdown-body .anchor:focus {
    outline: none;
  }

  .markdown-body h1 .octicon-link,
  .markdown-body h2 .octicon-link,
  .markdown-body h3 .octicon-link,
  .markdown-body h4 .octicon-link,
  .markdown-body h5 .octicon-link,
  .markdown-body h6 .octicon-link {
    color: #1b1f23;
    vertical-align: middle;
    visibility: hidden;
  }

  .markdown-body h1:hover .anchor,
  .markdown-body h2:hover .anchor,
  .markdown-body h3:hover .anchor,
  .markdown-body h4:hover .anchor,
  .markdown-body h5:hover .anchor,
  .markdown-body h6:hover .anchor {
    text-decoration: none;
  }

  .markdown-body h1:hover .anchor .octicon-link,
  .markdown-body h2:hover .anchor .octicon-link,
  .markdown-body h3:hover .anchor .octicon-link,
  .markdown-body h4:hover .anchor .octicon-link,
  .markdown-body h5:hover .anchor .octicon-link,
  .markdown-body h6:hover .anchor .octicon-link {
    visibility: visible;
  }
  .markdown-body {
    -ms-text-size-adjust: 100%;
    -webkit-text-size-adjust: 100%;
    line-height: 1.5;
    font-family: -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica, Arial,
      sans-serif, Apple Color Emoji, Segoe UI Emoji;
    font-size: 16px;
    line-height: 1.5;
    word-wrap: break-word;
  }

  .markdown-body .pl-c {
    color: #6a737d;
  }

  .markdown-body .pl-c1,
  .markdown-body .pl-s .pl-v {
    color: #005cc5;
  }

  .markdown-body .pl-e,
  .markdown-body .pl-en {
    color: #6f42c1;
  }

  .markdown-body .pl-s .pl-s1,
  .markdown-body .pl-smi {
    color: #24292e;
  }

  .markdown-body .pl-ent {
    color: #22863a;
  }

  .markdown-body .pl-k {
    color: #d73a49;
  }

  .markdown-body .pl-pds,
  .markdown-body .pl-s,
  .markdown-body .pl-s .pl-pse .pl-s1,
  .markdown-body .pl-sr,
  .markdown-body .pl-sr .pl-cce,
  .markdown-body .pl-sr .pl-sra,
  .markdown-body .pl-sr .pl-sre {
    color: #032f62;
  }

  .markdown-body .pl-smw,
  .markdown-body .pl-v {
    color: #e36209;
  }

  .markdown-body .pl-bu {
    color: #b31d28;
  }

  .markdown-body .pl-ii {
    color: #fafbfc;
    background-color: #b31d28;
  }

  .markdown-body .pl-c2 {
    color: #fafbfc;
    background-color: #d73a49;
  }

  .markdown-body .pl-c2:before {
    content: "^M";
  }

  .markdown-body .pl-sr .pl-cce {
    font-weight: 700;
    color: #22863a;
  }

  .markdown-body .pl-ml {
    color: #735c0f;
  }

  .markdown-body .pl-mh,
  .markdown-body .pl-mh .pl-en,
  .markdown-body .pl-ms {
    font-weight: 700;
    color: #005cc5;
  }

  .markdown-body .pl-mi {
    font-style: italic;
    color: #24292e;
  }

  .markdown-body .pl-mb {
    font-weight: 700;
    color: #24292e;
  }

  .markdown-body .pl-md {
    color: #b31d28;
    background-color: #ffeef0;
  }

  .markdown-body .pl-mi1 {
    color: #22863a;
    background-color: #f0fff4;
  }

  .markdown-body .pl-mc {
    color: #e36209;
    background-color: #ffebda;
  }

  .markdown-body .pl-mi2 {
    color: #f6f8fa;
    background-color: #005cc5;
  }

  .markdown-body .pl-mdr {
    font-weight: 700;
    color: #6f42c1;
  }

  .markdown-body .pl-ba {
    color: #586069;
  }

  .markdown-body .pl-sg {
    color: #959da5;
  }

  .markdown-body .pl-corl {
    text-decoration: underline;
    color: #032f62;
  }

  .markdown-body details {
    display: block;
  }

  .markdown-body summary {
    display: list-item;
  }

  .markdown-body a {
    background-color: initial;
  }

  .markdown-body a:active,
  .markdown-body a:hover {
    outline-width: 0;
  }

  .markdown-body strong {
    font-weight: inherit;
    font-weight: bolder;
  }

  .markdown-body h1 {
    font-size: 2em;
    margin: 0.67em 0;
  }

  .markdown-body img {
    border-style: none;
  }

  .markdown-body code,
  .markdown-body kbd,
  .markdown-body pre {
    font-family: monospace, monospace;
    font-size: 1em;
  }

  .markdown-body hr {
    box-sizing: initial;
    height: 0;
    overflow: visible;
  }

  .markdown-body input {
    font: inherit;
    margin: 0;
  }

  .markdown-body input {
    overflow: visible;
  }

  .markdown-body [type="checkbox"] {
    box-sizing: border-box;
    padding: 0;
  }

  .markdown-body * {
    box-sizing: border-box;
  }

  .markdown-body input {
    font-family: inherit;
    font-size: inherit;
    line-height: inherit;
  }

  .markdown-body a {
    color: var(--link-text-color, var(--accent-color));
    font-weight: 600;
    text-decoration: none;
  }

  .markdown-body a:hover {
    text-decoration: underline;
  }

  .markdown-body strong {
    font-weight: 600;
  }

  .markdown-body hr {
    height: 0;
    margin: 15px 0;
    overflow: hidden;
    background: transparent;
    border: 0;
    border-bottom: 1px solid #dfe2e5;
  }

  .markdown-body hr:after,
  .markdown-body hr:before {
    display: table;
    content: "";
  }

  .markdown-body hr:after {
    clear: both;
  }

  .markdown-body table {
    border-spacing: 0;
    border-collapse: collapse;
  }

  .markdown-body td,
  .markdown-body th {
    padding: 0;
  }

  .markdown-body details summary {
    cursor: pointer;
  }

  .markdown-body kbd {
    display: inline-block;
    padding: 3px 5px;
    font: 11px SFMono-Regular, Consolas, Liberation Mono, Menlo, monospace;
    line-height: 10px;
    color: #444d56;
    vertical-align: middle;
    background-color: #fafbfc;
    border: 1px solid #d1d5da;
    border-radius: 3px;
    box-shadow: inset 0 -1px 0 #d1d5da;
  }

  .markdown-body h1,
  .markdown-body h2,
  .markdown-body h3,
  .markdown-body h4,
  .markdown-body h5,
  .markdown-body h6 {
    margin-top: 0;
    margin-bottom: 0;
  }

  .markdown-body h1 {
    font-size: 32px;
  }

  .markdown-body h1,
  .markdown-body h2 {
    font-weight: 600;
  }

  .markdown-body h2 {
    font-size: 24px;
  }

  .markdown-body h3 {
    font-size: 20px;
  }

  .markdown-body h3,
  .markdown-body h4 {
    font-weight: 600;
  }

  .markdown-body h4 {
    font-size: 16px;
  }

  .markdown-body h5 {
    font-size: 14px;
  }

  .markdown-body h5,
  .markdown-body h6 {
    font-weight: 600;
  }

  .markdown-body h6 {
    font-size: 12px;
  }

  .markdown-body p {
    margin-top: 0;
    margin-bottom: 10px;
  }

  .markdown-body blockquote {
    margin: 0;
  }

  .markdown-body ol,
  .markdown-body ul {
    padding-left: 0;
    margin-top: 0;
    margin-bottom: 0;
  }

  .markdown-body ol ol,
  .markdown-body ul ol {
    list-style-type: lower-roman;
  }

  .markdown-body ol ol ol,
  .markdown-body ol ul ol,
  .markdown-body ul ol ol,
  .markdown-body ul ul ol {
    list-style-type: lower-alpha;
  }

  .markdown-body dd {
    margin-left: 0;
  }

  .markdown-body code,
  .markdown-body pre {
    font-family: SFMono-Regular, Consolas, Liberation Mono, Menlo, monospace;
    font-size: 12px;
  }

  .markdown-body pre {
    margin-top: 0;
    margin-bottom: 0;
  }

  .markdown-body input::-webkit-inner-spin-button,
  .markdown-body input::-webkit-outer-spin-button {
    margin: 0;
    -webkit-appearance: none;
    appearance: none;
  }

  .markdown-body .border {
    border: 1px solid #e1e4e8 !important;
  }

  .markdown-body .border-0 {
    border: 0 !important;
  }

  .markdown-body .border-bottom {
    border-bottom: 1px solid #e1e4e8 !important;
  }

  .markdown-body .rounded-1 {
    border-radius: 3px !important;
  }

  .markdown-body .bg-white {
    background-color: #fff !important;
  }

  .markdown-body .bg-gray-light {
    background-color: #fafbfc !important;
  }

  .markdown-body .text-gray-light {
    color: #6a737d !important;
  }

  .markdown-body .mb-0 {
    margin-bottom: 0 !important;
  }

  .markdown-body .my-2 {
    margin-top: 8px !important;
    margin-bottom: 8px !important;
  }

  .markdown-body .pl-0 {
    padding-left: 0 !important;
  }

  .markdown-body .py-0 {
    padding-top: 0 !important;
    padding-bottom: 0 !important;
  }

  .markdown-body .pl-1 {
    padding-left: 4px !important;
  }

  .markdown-body .pl-2 {
    padding-left: 8px !important;
  }

  .markdown-body .py-2 {
    padding-top: 8px !important;
    padding-bottom: 8px !important;
  }

  .markdown-body .pl-3,
  .markdown-body .px-3 {
    padding-left: 16px !important;
  }

  .markdown-body .px-3 {
    padding-right: 16px !important;
  }

  .markdown-body .pl-4 {
    padding-left: 24px !important;
  }

  .markdown-body .pl-5 {
    padding-left: 32px !important;
  }

  .markdown-body .pl-6 {
    padding-left: 40px !important;
  }

  .markdown-body .f6 {
    font-size: 12px !important;
  }

  .markdown-body .lh-condensed {
    line-height: 1.25 !important;
  }

  .markdown-body .text-bold {
    font-weight: 600 !important;
  }

  .markdown-body .pl-7 {
    padding-left: 48px !important;
  }

  .markdown-body .pl-8 {
    padding-left: 64px !important;
  }

  .markdown-body .pl-9 {
    padding-left: 80px !important;
  }

  .markdown-body .pl-10 {
    padding-left: 96px !important;
  }

  .markdown-body .pl-11 {
    padding-left: 112px !important;
  }

  .markdown-body .pl-12 {
    padding-left: 128px !important;
  }

  .markdown-body hr {
    border-bottom-color: #eee;
  }

  .markdown-body kbd {
    display: inline-block;
    padding: 3px 5px;
    font: 11px SFMono-Regular, Consolas, Liberation Mono, Menlo, monospace;
    line-height: 10px;
    color: #444d56;
    vertical-align: middle;
    background-color: #fafbfc;
    border: 1px solid #d1d5da;
    border-radius: 3px;
    box-shadow: inset 0 -1px 0 #d1d5da;
  }

  .markdown-body:after,
  .markdown-body:before {
    display: table;
    content: "";
  }

  .markdown-body:after {
    clear: both;
  }

  .markdown-body > :first-child {
    margin-top: 0 !important;
  }

  .markdown-body > :last-child {
    margin-bottom: 0 !important;
  }

  .markdown-body a:not([href]) {
    color: inherit;
    text-decoration: none;
  }
`;
    const GFM3 = css `
  .markdown-body blockquote,
  .markdown-body details,
  .markdown-body dl,
  .markdown-body ol,
  .markdown-body p,
  .markdown-body pre,
  .markdown-body table,
  .markdown-body ul {
    margin-top: 0;
    margin-bottom: 16px;
  }

  .markdown-body hr {
    height: 0.25em;
    padding: 0;
    margin: 24px 0;
    background-color: #e1e4e8;
    border: 0;
  }

  .markdown-body blockquote {
    padding: 0 1em;
    color: #6a737d;
    border-left: 0.25em solid #dfe2e5;
  }

  .markdown-body blockquote > :first-child {
    margin-top: 0;
  }

  .markdown-body blockquote > :last-child {
    margin-bottom: 0;
  }

  .markdown-body h1,
  .markdown-body h2,
  .markdown-body h3,
  .markdown-body h4,
  .markdown-body h5,
  .markdown-body h6 {
    margin-top: 24px;
    margin-bottom: 16px;
    font-weight: 600;
    line-height: 1.25;
  }

  .markdown-body h1 {
    font-size: 2em;
  }

  .markdown-body h1,
  .markdown-body h2 {
    padding-bottom: 0.3em;
    border-bottom: 1px solid #eaecef;
  }

  .markdown-body h2 {
    font-size: 1.5em;
  }

  .markdown-body h3 {
    font-size: 1.25em;
  }

  .markdown-body h4 {
    font-size: 1em;
  }

  .markdown-body h5 {
    font-size: 0.875em;
  }

  .markdown-body h6 {
    font-size: 0.85em;
    color: #6a737d;
  }

  .markdown-body ol,
  .markdown-body ul {
    padding-left: 2em;
  }

  .markdown-body ol ol,
  .markdown-body ol ul,
  .markdown-body ul ol,
  .markdown-body ul ul {
    margin-top: 0;
    margin-bottom: 0;
  }

  .markdown-body li {
    word-wrap: break-all;
  }

  .markdown-body li > p {
    margin-top: 16px;
  }

  .markdown-body li + li {
    margin-top: 0.25em;
  }

  .markdown-body dl {
    padding: 0;
  }

  .markdown-body dl dt {
    padding: 0;
    margin-top: 16px;
    font-size: 1em;
    font-style: italic;
    font-weight: 600;
  }

  .markdown-body dl dd {
    padding: 0 16px;
    margin-bottom: 16px;
  }

  .markdown-body table {
    display: block;
    width: 100%;
    overflow: auto;
  }

  .markdown-body table th {
    font-weight: 600;
  }

  .markdown-body table td,
  .markdown-body table th {
    padding: 6px 13px;
    border: 1px solid #dfe2e5;
  }

  .markdown-body table th {
    background-color: var(--primary-background-color, #fff);
  }

  .markdown-body table tr {
    background-color: hsla(var(--primary-background-color, #fff), 0.1);
    border-top: 1px solid #c6cbd1;
  }

  .markdown-body table tr:nth-child(2n) {
    background-color: var(--primary-background-color, #fff);
  }

  .markdown-body img {
    max-width: 100%;
    box-sizing: initial;
    background-color: #fff;
    border-radius: var(--ha-card-border-radius);
  }

  .markdown-body img[align="right"] {
    padding-left: 20px;
  }

  .markdown-body img[align="left"] {
    padding-right: 20px;
  }

  .markdown-body code {
    padding: 0.2em 0.4em;
    margin: 0;
    font-size: 85%;
    background-color: rgba(27, 31, 35, 0.05);
    border-radius: 3px;
  }

  .markdown-body pre {
    word-wrap: normal;
  }

  .markdown-body pre > code {
    padding: 0;
    margin: 0;
    font-size: 100%;
    word-break: normal;
    white-space: pre;
    background: transparent;
    border: 0;
  }

  .markdown-body .highlight {
    margin-bottom: 16px;
  }

  .markdown-body .highlight pre {
    margin-bottom: 0;
    word-break: normal;
  }

  .markdown-body .highlight pre,
  .markdown-body pre {
    padding: 16px;
    overflow: auto;
    font-size: 85%;
    line-height: 1.45;
    background-color: var(--primary-background-color, #f6f8fa);
    border-radius: var(--ha-card-border-radius, 3px);
  }

  .markdown-body pre code {
    display: inline;
    max-width: auto;
    padding: 0;
    margin: 0;
    overflow: visible;
    line-height: inherit;
    word-wrap: normal;
    background-color: initial;
    border: 0;
  }

  .markdown-body .commit-tease-sha {
    display: inline-block;
    font-family: SFMono-Regular, Consolas, Liberation Mono, Menlo, monospace;
    font-size: 90%;
    color: #444d56;
  }

  .markdown-body .full-commit .btn-outline:not(:disabled):hover {
    color: #005cc5;
    border-color: #005cc5;
  }

  .markdown-body .blob-wrapper {
    overflow-x: auto;
    overflow-y: hidden;
  }

  .markdown-body .blob-wrapper-embedded {
    max-height: 240px;
    overflow-y: auto;
  }

  .markdown-body .blob-num {
    width: 1%;
    min-width: 50px;
    padding-right: 10px;
    padding-left: 10px;
    font-family: SFMono-Regular, Consolas, Liberation Mono, Menlo, monospace;
    font-size: 12px;
    line-height: 20px;
    color: rgba(27, 31, 35, 0.3);
    text-align: right;
    white-space: nowrap;
    vertical-align: top;
    cursor: pointer;
    -webkit-user-select: none;
    -moz-user-select: none;
    -ms-user-select: none;
    user-select: none;
  }

  .markdown-body .blob-num:hover {
    color: rgba(27, 31, 35, 0.6);
  }

  .markdown-body .blob-num:before {
    content: attr(data-line-number);
  }

  .markdown-body .blob-code {
    position: relative;
    padding-right: 10px;
    padding-left: 10px;
    line-height: 20px;
    vertical-align: top;
  }

  .markdown-body .blob-code-inner {
    overflow: visible;
    font-family: SFMono-Regular, Consolas, Liberation Mono, Menlo, monospace;
    font-size: 12px;
    color: #24292e;
    word-wrap: normal;
    white-space: pre;
  }

  .markdown-body .pl-token.active,
  .markdown-body .pl-token:hover {
    cursor: pointer;
    background: #ffea7f;
  }

  .markdown-body :checked + .radio-label {
    position: relative;
    z-index: 1;
    border-color: var(--link-text-color, var(--accent-color));
  }

  .markdown-body
    .select-menu-item
    input[type="radio"]:not(:checked)
    + .octicon-check,
  .markdown-body
    .select-menu-item
    input[type="radio"]:not(:checked)
    + .octicon-circle-slash {
    visibility: hidden;
  }

  .markdown-body .pl-7 {
    padding-left: 48px !important;
  }

  .markdown-body .pl-8 {
    padding-left: 64px !important;
  }

  .markdown-body .pl-9 {
    padding-left: 80px !important;
  }

  .markdown-body .pl-10 {
    padding-left: 96px !important;
  }

  .markdown-body .pl-11 {
    padding-left: 112px !important;
  }

  .markdown-body .pl-12 {
    padding-left: 128px !important;
  }

  .markdown-body .tab-size[data-tab-size="1"] {
    -moz-tab-size: 1;
    tab-size: 1;
  }

  .markdown-body .tab-size[data-tab-size="2"] {
    -moz-tab-size: 2;
    tab-size: 2;
  }

  .markdown-body .tab-size[data-tab-size="3"] {
    -moz-tab-size: 3;
    tab-size: 3;
  }

  .markdown-body .tab-size[data-tab-size="4"] {
    -moz-tab-size: 4;
    tab-size: 4;
  }

  .markdown-body .tab-size[data-tab-size="5"] {
    -moz-tab-size: 5;
    tab-size: 5;
  }

  .markdown-body .tab-size[data-tab-size="6"] {
    -moz-tab-size: 6;
    tab-size: 6;
  }

  .markdown-body .tab-size[data-tab-size="7"] {
    -moz-tab-size: 7;
    tab-size: 7;
  }

  .markdown-body .tab-size[data-tab-size="8"] {
    -moz-tab-size: 8;
    tab-size: 8;
  }

  .markdown-body .tab-size[data-tab-size="9"] {
    -moz-tab-size: 9;
    tab-size: 9;
  }

  .markdown-body .tab-size[data-tab-size="10"] {
    -moz-tab-size: 10;
    tab-size: 10;
  }

  .markdown-body .tab-size[data-tab-size="11"] {
    -moz-tab-size: 11;
    tab-size: 11;
  }

  .markdown-body .tab-size[data-tab-size="12"] {
    -moz-tab-size: 12;
    tab-size: 12;
  }

  .markdown-body .task-list-item {
    list-style-type: none;
  }

  .markdown-body .task-list-item + .task-list-item {
    margin-top: 3px;
  }

  .markdown-body .task-list-item input {
    margin: 0 0.2em 0.25em -1.6em;
    vertical-align: middle;
  }
`;
    const GFM = [GFM1, GFM2, GFM3];

    highlight.registerLanguage("yaml", yaml);
    const hljs = highlight, marked$1 = marked_1;
    marked$1.setOptions({
        highlight: function (code, lang) {
            if (lang && hljs.getLanguage(lang)) {
                return hljs.highlight(lang, code, true).value;
            }
            else {
                return hljs.highlightAuto(code).value;
            }
        },
        breaks: true,
        gfm: true,
        tables: true,
        langPrefix: ""
    });
    class markdown {
        static convert(input) {
            return marked$1(input);
        }
        static html(input, repo) {
            // Convert emoji short codes to real emojis
            input = nodeEmoji.emojify(input);
            // Handle convertion to raw GitHub URL
            input = input.replace(/(https:\/\/github\.com\/.*.\/blob*.[^\s]+)/g, function (x) {
                let url = x
                    .replace("https://github.com/", "https://raw.githubusercontent.com/")
                    .replace("/blob/", "/");
                return url;
            });
            // Handle relative links
            input = input.replace(/\!\[*.*\]\(\w*\.\w*\)/g, function (x) {
                let url = x
                    .replace("(", `(https://raw.githubusercontent.com/${repo.full_name}/master/`)
                    .replace("/blob/", "/");
                return url;
            });
            const content = document.createElement("div");
            content.innerHTML = lib_1$1(marked$1(input)).replace(/\<a href="http\w:\/\/.*.\">.*.\<\/a>\W/g, function (x) {
                return x
                    .replace(/<a href=/gm, "<hacs-link url=")
                    .replace(/<\/a>/gm, "</hacs-link>");
            });
            content.style.cssText = `${GFM} ${HLJS}`;
            return html `
      ${content}
    `;
        }
    }

    /*
    Simple logger class to make logging consistent

    Usage:

    Basic: const logger = new Logger()
    Advanced: const logger = new Logger("main")

    logger.info("My message")
    logger.error("My message")
    logger.warning("My message")

    const obj = {test: "string"}
    logger.info(obj)

    */
    class Logger {
        constructor(section) {
            const name = "HACS";
            this.section = section;
            if (section === undefined)
                this.prefix = name;
            else
                this.prefix = `${name}.${section}`;
        }
        info(content, object) {
            if (content instanceof Object)
                console.log(`[${this.prefix}] `, content);
            else
                console.log(`[${this.prefix}] ${content}`, object || "");
        }
        warning(content, object) {
            if (content instanceof Object)
                console.warn(`[${this.prefix}] `, content);
            else
                console.warn(`[${this.prefix}] ${content}`, object || "");
        }
        error(content, object) {
            if (content instanceof Object)
                console.error(`[${this.prefix}] `, content);
            else
                console.error(`[${this.prefix}] ${content}`, object || "");
        }
    }

    function RepositoryWebSocketAction(hass, repository, Action, Data = undefined) {
        let message;
        if (Data !== undefined) {
            message = {
                type: "hacs/repository/data",
                action: Action,
                repository: repository,
                data: Data
            };
        }
        else {
            message = {
                type: "hacs/repository",
                action: Action,
                repository: repository
            };
        }
        hass.connection.sendMessage(message);
    }
    function scrollToTarget(element, target) {
        const top = 0;
        const scroller = target;
        const easingFn = function easeOutQuad(t, b, c, d) {
            /* eslint-disable no-param-reassign, space-infix-ops, no-mixed-operators */
            t /= d;
            return -c * t * (t - 2) + b;
            /* eslint-enable no-param-reassign, space-infix-ops, no-mixed-operators */
        };
        const animationId = Math.random();
        const duration = 200;
        const startTime = Date.now();
        const currentScrollTop = scroller.scrollTop;
        const deltaScrollTop = top - currentScrollTop;
        element._currentAnimationId = animationId;
        (function updateFrame() {
            const now = Date.now();
            const elapsedTime = now - startTime;
            if (elapsedTime > duration) {
                scroller.scrollTop = top;
            }
            else if (element._currentAnimationId === animationId) {
                scroller.scrollTop = easingFn(elapsedTime, currentScrollTop, deltaScrollTop, duration);
                requestAnimationFrame(updateFrame.bind(element));
            }
        }.call(element));
    }
    const navigate = (_node, path) => {
        history.pushState(null, "", path);
    };
    function isnullorempty(test) {
        if (test === undefined)
            return true;
        if (test === null)
            return true;
        if (test === "")
            return true;
        if (test === 0)
            return true;
        if (String(test).length === 0)
            return true;
        return false;
    }

    class Hacs {
        constructor(configuration, repositories, status) {
            this.logger = new Logger();
            this.localize = function (str, s, r) {
                return localize(str, s, r);
            };
            this.emojify = function (string) {
                return nodeEmoji.emojify(string);
            };
            this.scrollToTarget = function (element, target) {
                scrollToTarget(element, target);
            };
            this.navigate = (_node, path) => {
                navigate(_node, path);
            };
            this.markdown = function (input) {
                return markdown.convert(input);
            };
            this.isnullorempty = function (test) {
                return isnullorempty(test);
            };
            this.RepositoryWebSocketAction = function (hass, repository, action, data) {
                RepositoryWebSocketAction(hass, repository, action, data);
            };
            this.configuration = configuration;
            this.repositories = repositories;
            this.status = status;
        }
        RelativeTimeSince(input) {
            let current = new Date().getTime();
            let target = Date.parse(input);
            var value;
            const msPerMinute = 60 * 1000;
            const msPerHour = msPerMinute * 60;
            const msPerDay = msPerHour * 24;
            const msPerMonth = msPerDay * 30;
            const msPerYear = msPerDay * 365;
            const elapsed = current - target;
            if (elapsed < msPerMinute) {
                value = Math.round(elapsed / 1000);
                return `${value === 1
                ? this.localize(`time.one_second_ago`)
                : this.localize("time.x_seconds_ago", "{x}", String(value))}`;
            }
            else if (elapsed < msPerHour) {
                value = Math.round(elapsed / msPerMinute);
                return `${value === 1
                ? this.localize(`time.one_minute_ago`)
                : this.localize("time.x_minutes_ago", "{x}", String(value))}`;
            }
            else if (elapsed < msPerDay) {
                value = Math.round(elapsed / msPerHour);
                return `${value === 1
                ? this.localize(`time.one_hour_ago`)
                : this.localize("time.x_hours_ago", "{x}", String(value))}`;
            }
            else if (elapsed < msPerMonth) {
                value = Math.round(elapsed / msPerDay);
                return `${value === 1
                ? this.localize(`time.one_day_ago`)
                : this.localize("time.x_days_ago", "{x}", String(value))}`;
            }
            else if (elapsed < msPerYear) {
                value = Math.round(elapsed / msPerMonth);
                return `${value === 1
                ? this.localize(`time.one_month_ago`)
                : this.localize("time.x_months_ago", "{x}", String(value))}`;
            }
            else {
                value = Math.round(elapsed / msPerYear);
                return `${value === 1
                ? this.localize(`time.one_year_ago`)
                : this.localize("time.x_years_ago", "{x}", String(value))}`;
            }
        }
    }

    const _haStyle = css `
  :host {
    @apply --paper-font-body1;
  }

  app-header-layout,
  ha-app-layout {
    background-color: var(--primary-background-color);
  }

  app-header,
  app-toolbar {
    background-color: var(--app-header-background-color, var(--primary-color));
    font-weight: 400;
    color: var(--app-header-text-color, var(--text-primary-color, white));
  }

  app-toolbar ha-menu-button + [main-title],
  app-toolbar ha-paper-icon-button-arrow-prev + [main-title],
  app-toolbar paper-icon-button + [main-title] {
    margin-left: 24px;
  }

  button.link {
    background: none;
    color: inherit;
    border: none;
    padding: 0;
    font: inherit;
    text-align: left;
    text-decoration: underline;
    cursor: pointer;
  }

  .card-actions a {
    text-decoration: none;
  }

  .card-actions .warning {
    --mdc-theme-primary: var(--google-red-500);
  }
`;

    const _navStyle = css `
  :host {
    font-family: var(--paper-font-body1_-_font-family);
    -webkit-font-smoothing: var(--paper-font-body1_-_-webkit-font-smoothing);
    font-size: var(--paper-font-body1_-_font-size);
    font-weight: var(--paper-font-body1_-_font-weight);
    line-height: var(--paper-font-body1_-_line-height);
  }

  app-header-layout {
    background-color: var(--primary-background-color);
  }

  app-header,
  app-toolbar,
  paper-tabs {
    background-color: var(--app-header-background-color, var(--primary-color));
    color: var(--app-header-text-color, var(--text-primary-color, white));
    font-weight: 400;
    text-transform: uppercase;
  }

  paper-tabs {
    --paper-tabs-selection-bar-color: #fff;
    margin-left: 12px;
  }

  app-toolbar ha-menu-button + [main-title],
  app-toolbar ha-paper-icon-button-arrow-prev + [main-title],
  app-toolbar paper-icon-button + [main-title] {
    margin-left: 24px;
  }
  .tabs {
    position: relative;
    z-index: -1;
  }
  div#contentContainer {
    z-index: 0;
  }
`;

    const baseHacsStyles = css `
  :root {
    font-family: var(--paper-font-body1_-_font-family);
    -webkit-font-smoothing: var(--paper-font-body1_-_-webkit-font-smoothing);
    font-size: var(--paper-font-body1_-_font-size);
    font-weight: var(--paper-font-body1_-_font-weight);
    line-height: var(--paper-font-body1_-_line-height);
  }
  a {
    text-decoration: none;
    color: var(--link-text-color, var(--accent-color));
  }
  h1 {
    font-family: var(--paper-font-title_-_font-family);
    -webkit-font-smoothing: var(--paper-font-title_-_-webkit-font-smoothing);
    white-space: var(--paper-font-title_-_white-space);
    overflow: var(--paper-font-title_-_overflow);
    text-overflow: var(--paper-font-title_-_text-overflow);
    font-size: var(--paper-font-title_-_font-size);
    font-weight: var(--paper-font-title_-_font-weight);
    line-height: var(--paper-font-title_-_line-height);
    @apply --paper-font-title;
  }
  .title {
    margin-bottom: 8px;
    padding-top: 4px;
    color: var(--primary-text-color);
    white-space: nowrap;
    text-overflow: ellipsis;
    overflow: hidden;
    width: calc(100% - 48px) !important;
  }
  .addition {
    color: var(--secondary-text-color);
    position: relative;
    width: 100% !important;
    height: auto;
    line-height: 1.2em;
    text-overflow: ellipsis;
    overflow: hidden;
  }
  ha-card {
    margin: 8px;
  }
  ha-icon {
    height: 24px;
    width: 24px;
    margin-right: 16px;
    float: left;
    color: var(--primary-text-color);
  }
  .installed {
    color: var(--hacs-status-installed, #126e15);
  }
  .pending-upgrade {
    color: var(--hacs-status-pending-update, #ffab40);
  }
  .pending-restart {
    color: var(--hacs-status-pending-restart, var(--google-red-500));
  }
  .not-loaded {
    color: var(--hacs-status-not-loaded, var(--google-red-500));
  }
  .new {
    color: var(--hacs-badge-color, var(--primary-color));
  }
  .card-group {
    margin-top: 24px;
  }

  .card-group {
    color: var(--primary-text-color);
    margin-bottom: 12px;
  }

  ha-card.compact {
    height: 80px !important;
  }

  ha-card.compact .addition {
    height: 1.2em;
    white-space: preliine !important;
  }

  ha-card.compact .title {
    height: 1.2em;
    white-space: preliine !important;
  }

  paper-item.compact {
    margin-bottom: 2px !important;
    white-space: nowrap !important;
  }

  .card-group ha-card {
    --card-group-columns: 5;
    width: calc(
      (100% - 12px * var(--card-group-columns)) / var(--card-group-columns)
    );
    margin: 4px;
    vertical-align: top;
    height: 136px;
  }

  @media screen and (max-width: 2400px) and (min-width: 1801px) {
    .card-group ha-card {
      --card-group-columns: 4;
    }
  }

  @media screen and (max-width: 1800px) and (min-width: 1201px) {
    .card-group ha-card {
      --card-group-columns: 3;
    }
  }

  @media screen and (max-width: 1200px) and (min-width: 601px) {
    .card-group ha-card {
      --card-group-columns: 2;
    }
  }

  @media screen and (max-width: 600px) and (min-width: 0) {
    .card-group ha-card {
      width: 100%;
      margin: 4px 0;
    }
    .content {
      padding: 0;
    }
  }
  hr {
    border-color: var(--accent-color);
  }
  .leftspace {
    margin-left: 8px !important;
  }
  .disabled-button {
    --mdc-theme-primary: var(--disabled-text-color);
  }
  .uninstall-button {
    --mdc-theme-primary: var(--google-red-500);
    color: var(--google-red-500);
  }
  .red-button {
    --mdc-theme-primary: var(--google-red-500);
  }
  .link {
    color: var(--link-text-color, var(--accent-color));
    font-weight: 600;
    text-decoration: none;
  }
  paper-item {
    border-radius: var(--ha-card-border-radius);
    background: var(--primary-background-color);
    display: block;
    cursor: pointer;
    margin-bottom: 12px;
  }
  paper-item.list {
    margin-bottom: 24px;
  }
  paper-item:hover {
    outline: 0;
    background: var(--table-row-alternative-background-color);
  }
  .right {
    float: right;
  }
  .griddy {
    display: grid;
  }
  .flexy {
    display: flex;
  }
  .flowroot {
    display: flow-root;
  }
`;
    const mobileHacsStyles = css `
  @media screen and (max-width: 600px) and (min-width: 0) {
    .MobileHide {
      display: none !important;
    }
    .MobileGrid {
      display: grid !important;
      text-align: center;
      position: initial !important;
      width: 100% !important;
      padding-left: 0px !important;
      padding-right: 0px !important;
    }
  }
`;
    const HacsStyle = [
        _haStyle,
        _navStyle,
        baseHacsStyles,
        mobileHacsStyles
    ];

    const AllCategories = [
        "integrations",
        "plugins",
        "appdaemon_apps",
        "python_scripts",
        "themes"
    ];
    const getConfiguration = async (hass) => {
        const response = await hass.connection.sendMessagePromise({
            type: "hacs/config"
        });
        return response;
    };
    const getRepositories = async (hass) => {
        const response = await hass.connection.sendMessagePromise({
            type: "hacs/repositories"
        });
        return response;
    };
    const getCritical = async (hass) => {
        const response = await hass.connection.sendMessagePromise({
            type: "hacs/get_critical"
        });
        return response;
    };
    const getStatus = async (hass) => {
        const response = await hass.connection.sendMessagePromise({
            type: "hacs/status"
        });
        return response;
    };
    const getLovelaceConfiguration = async (hass) => {
        try {
            const response = await hass.connection.sendMessagePromise({
                type: "lovelace/config"
            });
            return response;
        }
        catch (e) {
            return null;
        }
    };

    function hass() {
      return document.querySelector('home-assistant').hass
    }
    function load_lovelace() {
      if(customElements.get("hui-view")) return true;

      const res = document.createElement("partial-panel-resolver");
      res.hass = hass();
      res.route = {path: "/lovelace/"};
      // res._updateRoutes();
      try {
        document.querySelector("home-assistant").appendChild(res).catch((error) => {});
      } catch (error) {
        document.querySelector("home-assistant").removeChild(res);
      }
      if(customElements.get("hui-view")) return true;
      return false;

    }

    let HacsFrontendBase = class HacsFrontendBase extends LitElement {
        constructor() {
            super(...arguments);
            this.repository_view = false;
            this.logger = new Logger();
        }
        update(changedProperties) {
            super.update(changedProperties);
            if (this.hacs.configuration && this.hacs.configuration.debug)
                this.hacs.logger.info("Changed properties", changedProperties);
        }
        connectedCallback() {
            /* I have no idea why this is done, but without it shit breaks */
            super.connectedCallback();
            /* Create the HACS object */
            this.hacs = new Hacs(this.configuration, this.repositories, this.status);
            /* Add handlers for custom HACS browser events */
            this.addEventListener("hacs-location-change", this.locationChanged);
            this.addEventListener("hacs-repository-action", this.RepositoryAction);
            this.addEventListener("hacs-onboarding-done", this.onboardingDone);
            this.addEventListener("hacs-recreate", this._recreatehacs);
            this.addEventListener("hacs-force-reload", this._reload);
            /* "steal" Lovelace elements */
            load_lovelace();
            /* Backend event subscription */
            this.hass.connection.subscribeEvents(() => this.updateProperty("configuration"), "hacs/config");
            this.hass.connection.subscribeEvents(() => this.updateProperty("status"), "hacs/status");
            this.hass.connection.subscribeEvents(e => this._reload(e), "hacs/reload");
            this.hass.connection.subscribeEvents(() => this.updateProperty("repositories"), "hacs/repository");
            this.hass.connection.subscribeEvents(() => this.updateProperty("lovelaceconfig"), "lovelace_updated");
            /* Reset local storage */
            localStorage.setItem("hacs-search", "");
            localStorage.setItem("hacs-sort", "name-desc");
        }
        _recreatehacs() {
            var configuration = this.configuration;
            var repositories = this.repositories;
            var status = this.status;
            if (this.hacs.isnullorempty(configuration))
                configuration = this.hacs.configuration;
            if (this.hacs.isnullorempty(repositories))
                repositories = this.hacs.repositories;
            if (this.hacs.isnullorempty(status))
                status = this.hacs.status;
            this.hacs = new Hacs(configuration, repositories, status);
            this.requestUpdate();
        }
        RepositoryAction(ev) {
            if (this.configuration.debug)
                this.hacs.logger.info(ev.detail);
            const evdata = ev.detail;
            this.hacs.RepositoryWebSocketAction(this.hass, evdata.repo, evdata.action, evdata.data);
        }
        async firstUpdated() {
            window.onpopstate = function () {
                window.location.reload();
            };
            const [repositories, configuration, status, critical, lovelaceconfig] = await Promise.all([
                getRepositories(this.hass),
                getConfiguration(this.hass),
                getStatus(this.hass),
                getCritical(this.hass),
                getLovelaceConfiguration(this.hass)
            ]);
            this.repositories = repositories;
            this.configuration = configuration;
            this.status = status;
            this.critical = critical;
            this.lovelaceconfig = lovelaceconfig;
            this._recreatehacs();
        }
        async updateProperty(property) {
            if (property === "repositories")
                this.repositories = await getRepositories(this.hass);
            else if (property === "configuration")
                this.configuration = await getConfiguration(this.hass);
            else if (property === "status")
                this.status = await getStatus(this.hass);
            else if (property === "critical")
                this.critical = await getCritical(this.hass);
            else if (property === "lovelaceconfig")
                this.lovelaceconfig = await getLovelaceConfiguration(this.hass);
            this._recreatehacs();
        }
        _reload(e) {
            const force = (e.data && e.data.force) || (e.detail && e.detail.force) || false;
            window.location.reload(force);
        }
        render() {
            // Handle access to root
            if (this.route.path === "" || this.route.path === undefined) {
                this.hacs.navigate(this, `${this.route.prefix}/installed`);
                this.route.path = "/installed";
            }
            if (this.repositories === undefined ||
                this.configuration === undefined ||
                this.status === undefined) {
                return html `
        <div class="loader"><paper-spinner active></paper-spinner></div>
      `;
            }
            if ((!this.configuration.onboarding_done && !this.status.disabled) ||
                false) {
                return html `
        <hacs-onboarding
          .hacs=${this.hacs}
          .hass=${this.hass}
          .narrow=${this.narrow}
        ></hacs-onboarding>
      `;
            }
            return html `
      <app-header-layout has-scrolling-region>
        <app-header slot="header" fixed>
          <div id="contentContainer">
            <app-toolbar>
              <ha-menu-button
                .hass="${this.hass}"
                .narrow="${this.narrow}"
              ></ha-menu-button>
              <div main-title class="fulltitle">
                Home Assistant Community Store
                ${this._rootPath === "hacs_dev"
            ? html `
                      (DEVELOPMENT)
                    `
            : ""}
              </div>
              <div main-title class="mobiletitle">
                HACS
                ${this._rootPath === "hacs_dev"
            ? html `
                      (DEVELOPMENT)
                    `
            : ""}
              </div>
              <hacs-menu
                .location=${window.location.pathname}
                .hacs=${this.hacs}
                .hass=${this.hass}
                .configuration=${this.configuration}
                .status=${this.status}
                .repositories=${this.repositories}
              ></hacs-menu>
            </app-toolbar>

            <paper-tabs
              scrollable
              autoselect
              class="tabs"
              attr-for-selected="page-name"
              .selected=${this._activeTab}
              @iron-activate=${this.handlePageSelected}
            >
              <paper-tab page-name="installed"
                >${this.hacs.localize(`common.installed`)}</paper-tab
              >

              <paper-tab page-name="integration"
                >${this.hacs.localize(`common.integrations`)}</paper-tab
              >

              <paper-tab page-name="plugin"
                >${this.hacs.localize(`common.plugins`)}</paper-tab
              >

              ${this.configuration.categories.includes("appdaemon")
            ? html `
                    <paper-tab page-name="appdaemon">
                      ${this.hacs.localize(`common.appdaemon_apps`)}
                    </paper-tab>
                  `
            : ""}
              ${this.configuration.categories.includes("python_script")
            ? html `
                    <paper-tab page-name="python_script">
                      ${this.hacs.localize(`common.python_scripts`)}
                    </paper-tab>
                  `
            : ""}
              ${this.configuration.categories.includes("theme")
            ? html `
                    <paper-tab page-name="theme">
                      ${this.hacs.localize(`common.themes`)}
                    </paper-tab>
                  `
            : ""}
              <paper-tab page-name="settings"
                >${this.hacs.localize("common.settings")}</paper-tab
              >
            </paper-tabs>
          </div>
        </app-header>

        <hacs-progressbar
          .active=${this.status.background_task || this.status.disabled}
        ></hacs-progressbar>
        ${this.status.disabled
            ? html `
              <ha-card header="${this.hacs
                .localize("common.disabled")
                .toUpperCase()}!">
                <div class="card-content">
                  ${this.hacs.localize("common.hacs_is_disabled")}! </br> ${this.hacs.localize("common.check_log_file")}
                </div>
              </ha-card>
            `
            : ""}
        <hacs-body>
          <hacs-critical
            .hacs=${this.hacs}
            .hass=${this.hass}
            .critical=${this.critical}
          ></hacs-critical>
          <hacs-error .hacs=${this.hacs} .hass=${this.hass}></hacs-error>

          ${this.route.path === "/installed"
            ? html `
                <hacs-installed
                  .hacs=${this.hacs}
                  .hass=${this.hass}
                  .route=${this.route}
                  .lovelaceconfig=${this.lovelaceconfig}
                  .repositories=${this.repositories}
                  .configuration=${this.configuration}
                  .status=${this.status}
                ></hacs-installed>
              `
            : this.route.path === "/settings"
                ? html `
                <hacs-settings
                  .hacs=${this.hacs}
                  .hass=${this.hass}
                  .route=${this.route}
                >
                </hacs-settings>
              `
                : this.route.path.includes("/repository")
                    ? html `
                <hacs-repository
                  .hacs=${this.hacs}
                  .repository=${this._get_repository}
                  .hass=${this.hass}
                  .route=${this.route}
                  .lovelaceconfig=${this.lovelaceconfig}
                  .repositories=${this.repositories}
                  .configuration=${this.configuration}
                  .status=${this.status}
                ></hacs-repository>
              `
                    : html `
                <hacs-store
                  .hacs=${this.hacs}
                  .store=${this._get_store}
                  .hass=${this.hass}
                  .route=${this.route}
                  .repositories=${this.repositories}
                  .configuration=${this.configuration}
                  .status=${this.status}
                ></hacs-store>
              `}
        </hacs-body>
      </app-header-layout>
    `;
        }
        get _get_store() {
            return this.route.path.split("/")[1];
        }
        get _get_repository() {
            return this.route.path.split("/")[2];
        }
        locationChanged(ev) {
            if (this.configuration.debug)
                this.hacs.logger.info(ev.type, ev.detail);
            const new_path = `${ev.detail.value}`;
            if (new_path.startsWith("/")) {
                this.route.prefix = new_path;
                this.route.path = "";
            }
            else {
                this.route.path = `/${ev.detail.value}`;
            }
            const force = ev.detail.force;
            this.hacs.navigate(this, `${this.route.prefix}${this.route.path}`);
            if (force)
                window.location.reload();
            else
                this.requestUpdate();
            this.hacs.scrollToTarget(this, 
            // @ts-ignore
            this.shadowRoot.querySelector("app-header-layout").header.scrollTarget);
        }
        onboardingDone() {
            this.configuration.onboarding_done = true;
            this.hass.connection.sendMessage({
                type: "hacs/settings",
                action: "onboarding_done"
            });
            this.requestUpdate();
        }
        handlePageSelected(e) {
            this.dispatchEvent(new CustomEvent("hacs-location-change", {
                detail: { value: e.detail.selected },
                bubbles: true,
                composed: true
            }));
        }
        get _activeTab() {
            if (this.route.path.split("/")[1] === undefined)
                return "installed";
            return this.route.path.split("/")[1];
        }
        get _rootPath() {
            if (this.route.prefix.split("/")[1] === undefined)
                return "hacs";
            return this.route.prefix.split("/")[1];
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        app-header-layout {
          background: var(
            --lovelace-background,
            var(--primary-background-color)
          );
        }
        .loader {
          background-color: var(--primary-background-color);
          height: 100%;
          width: 100%;
        }
        paper-spinner {
          position: absolute;
          top: 30%;
          left: 50%;
          transform: translate(-50%, -50%);
          z-index: 99;
          width: 150px;
          height: 150px;
        }
        paper-tab {
          cursor: pointer;
        }

        .margin {
          width: 20%;
        }
        hacs-progressbar {
          top: 0;
          position: sticky;
          display: block;
          z-index: 1337;
        }
        .fulltitle {
          display: block;
        }
        .mobiletitle {
          display: none;
        }
        @media screen and (max-width: 612px) and (min-width: 0) {
          .fulltitle {
            display: none;
          }
          .mobiletitle {
            display: block;
            margin-left: 24px;
          }
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], HacsFrontendBase.prototype, "critical", void 0);
    __decorate([
        property()
    ], HacsFrontendBase.prototype, "narrow", void 0);
    __decorate([
        property()
    ], HacsFrontendBase.prototype, "repository_view", void 0);
    __decorate([
        property()
    ], HacsFrontendBase.prototype, "hacs", void 0);
    __decorate([
        property()
    ], HacsFrontendBase.prototype, "hass", void 0);
    __decorate([
        property()
    ], HacsFrontendBase.prototype, "lovelaceconfig", void 0);
    __decorate([
        property()
    ], HacsFrontendBase.prototype, "route", void 0);
    HacsFrontendBase = __decorate([
        customElement("hacs-frontendbase")
    ], HacsFrontendBase);

    function AddedToLovelace(repository, lovelaceconfig, status) {
        if (status.lovelace_mode === "yaml")
            return true;
        if (lovelaceconfig) {
            var loaded = false;
            var URL = `/community_plugin/${repository.full_name.split("/")[1]}/${repository.file_name}`;
            if (lovelaceconfig.resources !== undefined) {
                lovelaceconfig.resources.forEach((item) => {
                    if (!loaded) {
                        if (item.url === URL)
                            loaded = true;
                    }
                });
            }
            return loaded;
        }
        else
            return true;
    }

    class OviewItemBuilder {
        constructor(hass, configuration, lovelaceconfig, status, route) {
            this.hass = hass;
            this.configuration = configuration;
            this.lovelaceconfig = lovelaceconfig;
            this.status = status;
            this.route = route;
        }
        render_card(repository) {
            return html `
      <ha-card
        @click="${this.ShowRepository}"
        .RepoID="${repository.id}"
        class="${this.configuration.frontend_compact ? "compact" : ""}"
      >
        <div class="card-content">
          <div>
            <ha-icon
              icon=${repository.new ? "mdi:new-box" : "mdi:cube"}
              class="${this.StatusAndDescription(repository).status}"
              title="${this.StatusAndDescription(repository).description}"
            >
            </ha-icon>
            <div class="title">
              ${nodeEmoji.emojify(repository.name || "")}
            </div>
            <div class="addition">
              ${nodeEmoji.emojify(repository.description || "")}
            </div>
          </div>
        </div>
      </ha-card>
    `;
        }
        render_list_line(repository) {
            return html `
      <paper-item
        .RepoID=${repository.id}
        @click="${this.ShowRepository}"
        class="${this.configuration.frontend_compact ? "compact" : ""}"
      >
        <div class="icon">
          <ha-icon
            icon=${repository.new ? "mdi:new-box" : "mdi:cube"}
            class="${this.StatusAndDescription(repository).status}"
            title="${this.StatusAndDescription(repository).description}"
          >
          </ha-icon>
        </div>
        <paper-item-body two-line>
          <div>
            ${nodeEmoji.emojify(repository.name || "")}
            ${this.route.path === "/installed"
            ? html `
                  <div class="MobileHide right flexy">
                    <div>${repository.installed_version}</div>
                    &nbsp; (
                    <div
                      class="${repository.pending_upgrade
                ? this.StatusAndDescription(repository).status
                : ""}"
                    >
                      ${repository.available_version}
                    </div>
                    )
                  </div>
                `
            : ""}
          </div>
          <div class="addition">
            ${nodeEmoji.emojify(repository.description || "")}
          </div>
        </paper-item-body>
      </paper-item>
    `;
        }
        render(repository) {
            if (this.configuration.frontend_mode === "Grid")
                return this.render_card(repository);
            return this.render_list_line(repository);
        }
        ShowRepository(ev) {
            var RepoID;
            ev.composedPath().forEach((item) => {
                if (item.RepoID) {
                    RepoID = item.RepoID;
                }
            });
            this.dispatchEvent(new CustomEvent("hacs-location-change", {
                detail: { value: `repository/${RepoID}` },
                bubbles: true,
                composed: true
            }));
        }
        StatusAndDescription(repository) {
            var status = repository.status;
            if (this.status.startup && repository.installed)
                status = "installed";
            var description = repository.status_description;
            if (repository.installed && !this.status.background_task) {
                if (repository.category === "plugin" &&
                    !AddedToLovelace(repository, this.lovelaceconfig, this.status)) {
                    status = "not-loaded";
                    description = "Not loaded in lovelace";
                }
            }
            return { status: status, description: description };
        }
    }

    let HacsInstalled = class HacsInstalled extends LitElement {
        render() {
            if (this.repositories === undefined)
                return html `
        <hacs-progressbar></hacs-progressbar>
      `;
            const builder = new OviewItemBuilder(this.hass, this.configuration, this.lovelaceconfig, this.status, this.route);
            var categories = {
                integrations: [],
                plugins: [],
                appdaemon_apps: [],
                python_scripts: [],
                themes: []
            };
            var installed_repositories = this.repositories.filter(function (repository) {
                if (repository.installed) {
                    if (repository.category === "integration")
                        categories.integrations.push(repository);
                    if (repository.category === "plugin")
                        categories.plugins.push(repository);
                    if (repository.category === "appdaemon")
                        categories.appdaemon_apps.push(repository);
                    if (repository.category === "python_script")
                        categories.python_scripts.push(repository);
                    if (repository.category === "theme")
                        categories.themes.push(repository);
                    return true;
                }
                return false;
            });
            var updatable_repositories = installed_repositories.filter(function (repository) {
                if (repository.pending_upgrade)
                    return true;
                return false;
            });
            return html `
      <hacs-body>
        ${updatable_repositories.length !== 0 && !this.status.startup
            ? html `
              <div class="card-group">
                <div class="leftspace grouptitle">
                  ${this.hacs.localize("store.pending_upgrades")}
                </div>
                ${updatable_repositories
                .sort((a, b) => a.name > b.name ? 1 : -1)
                .map(repository => {
                return builder.render(repository);
            })}
              </div>
              <hr noshade />
            `
            : ""}
        ${AllCategories.map(category => {
            if (categories[category] === undefined ||
                categories[category].length === 0)
                return html ``;
            return html `
            <div class="card-group">
              <div class="leftspace grouptitle">
                ${this.hacs.localize(`common.${category}`)}
              </div>
              ${categories[category]
                .sort((a, b) => a.name > b.name ? 1 : -1)
                .map(repository => {
                return builder.render(repository);
            })}
            </div>
          `;
        })}
      </hacs-body>
    `;
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        .loader {
          background-color: var(--primary-background-color);
          height: 100%;
          width: 100%;
        }
        ha-card {
          display: inline-block;
          cursor: pointer;
        }
        .grouptitle {
          margin-bottom: 12px;
          font-size: larger;
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], HacsInstalled.prototype, "repositories", void 0);
    __decorate([
        property()
    ], HacsInstalled.prototype, "configuration", void 0);
    __decorate([
        property()
    ], HacsInstalled.prototype, "hacs", void 0);
    __decorate([
        property()
    ], HacsInstalled.prototype, "hass", void 0);
    __decorate([
        property()
    ], HacsInstalled.prototype, "lovelaceconfig", void 0);
    __decorate([
        property()
    ], HacsInstalled.prototype, "route", void 0);
    __decorate([
        property()
    ], HacsInstalled.prototype, "status", void 0);
    HacsInstalled = __decorate([
        customElement("hacs-installed")
    ], HacsInstalled);

    const version = "20200104192235";

    let HacsRepository = class HacsRepository extends LitElement {
        constructor() {
            super(...arguments);
            this.repository_view = false;
        }
        update(changedProperties) {
            super.update(changedProperties);
            if (this.hacs.configuration.debug)
                this.hacs.logger.info(changedProperties);
        }
        shouldUpdate(changedProperties) {
            changedProperties.forEach((_oldValue, propName) => {
                if (propName === "hacs") {
                    const _repository = this.repository;
                    const _repositories = this.hacs.repositories.filter(function (repo) {
                        return repo.id === _repository;
                    });
                    const repo = _repositories[0];
                    if (!this.repo || JSON.stringify(repo) !== JSON.stringify(this.repo)) {
                        this.repo = repo;
                    }
                }
            });
            return (changedProperties.has("repo") || changedProperties.has("lovelaceconfig"));
        }
        firstUpdated() {
            if (this.repo === undefined || !this.repo.updated_info) {
                this.repo.status = "other";
                this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                    detail: {
                        repo: this.repository,
                        action: "set_state",
                        data: "other"
                    },
                    bubbles: true,
                    composed: true
                }));
                this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                    detail: { repo: this.repository, action: "update" },
                    bubbles: true,
                    composed: true
                }));
            }
        }
        render() {
            if (this.repo === undefined)
                return html `
        <div class="loader"><paper-spinner active></paper-spinner></div>
      `;
            if (this.repo.installed) {
                var back = this.hacs.localize(`common.installed`);
            }
            else {
                if (this.repo.category === "appdaemon") {
                    var FE_cat = "appdaemon_apps";
                }
                else {
                    FE_cat = `${this.repo.category}s`;
                }
                var back = this.hacs.localize(`common.${FE_cat}`);
            }
            return html `
      <hacs-body>
        <div class="getBack">
          <mwc-button @click=${this.GoBackToStore} title="${back}">
            <ha-icon icon="mdi:arrow-left"></ha-icon>
            ${this.hacs.localize(`repository.back_to`)} ${back}
          </mwc-button>
          ${this.repo.state === "other"
            ? html `
                <div class="loader"><paper-spinner active></paper-spinner></div>
              `
            : ""}
        </div>

        <hacs-repository-banner-note
          .hacs=${this.hacs}
          .hass=${this.hass}
          .status=${this.status}
          .repository=${this.repo}
          .route=${this.route}
          .lovelaceconfig=${this.lovelaceconfig}
          .configuration=${this.configuration}
        >
        </hacs-repository-banner-note>

        <ha-card>
          <div class="repotitle">
            ${nodeEmoji.emojify(this.repo.name || "")}
          </div>
          <hacs-repository-menu
            .hass=${this.hass}
            .route=${this.route}
            .repository=${this.repo}
          ></hacs-repository-menu>

          <div class="card-content">
            <div class="description">
              ${nodeEmoji.emojify(this.repo.description || "")}
            </div>

            <div class="information">
              <hacs-authors
                .hass=${this.hass}
                .authors=${this.repo.authors}
              ></hacs-authors>
              ${!this.hacs.isnullorempty(this.repo.stars)
            ? html `
                    <div class="stars">
                      <b>${this.hacs.localize(`repository.github_stars`)}: </b>
                      ${this.repo.stars}
                    </div>
                  `
            : ""}
              ${!this.hacs.isnullorempty(this.repo.downloads)
            ? html `
                    <div class="downloads">
                      <b>${this.hacs.localize(`repository.downloads`)}: </b>
                      ${this.repo.downloads}
                    </div>
                  `
            : ""}
              ${!this.hacs.isnullorempty(this.repo.last_updated)
            ? html `
                    <div class="last_updated">
                      <b>${this.hacs.localize(`store.last_updated`)}: </b>
                      ${this.hacs.RelativeTimeSince(this.repo.last_updated)}
                    </div>
                  `
            : ""}
              ${this.repo.full_name === "hacs/integration"
            ? html `
                    <div class="frontend-version">
                      <b
                        >${this.hacs.localize(`repository.frontend_version`)}:
                      </b>
                      ${version}
                    </div>
                  `
            : ""}
              ${this.repo.installed
            ? html `
                    <div class="version-installed">
                      <b>${this.hacs.localize(`repository.installed`)}: </b>
                      ${this.repo.installed_version}
                    </div>
                  `
            : ""}
              ${String(this.repo.releases.length) === "0"
            ? html `
                    <div class="version-available">
                      <b>${this.hacs.localize(`repository.available`)}: </b>
                      ${this.repo.available_version}
                    </div>
                  `
            : html `
                    <div class="version-available-dropdown">
                      <paper-dropdown-menu
                        @value-changed="${this.setRepositoryVersion}"
                        label="${this.hacs.localize(`repository.available`)}:
                     (${this.hacs.localize(`repository.newest`)}: ${this.repo
                .releases[0]})"
                      >
                        <paper-listbox
                          slot="dropdown-content"
                          selected="${this.repo.selected_tag}"
                          attr-for-selected="value"
                        >
                          ${this.repo.releases.map(release => {
                return html `
                              <paper-item value="${release}"
                                >${release}</paper-item
                              >
                            `;
            })}
                          ${this.repo.full_name === "hacs/integration" ||
                this.repo.hide_default_branch
                ? ""
                : html `
                                <paper-item value="${this.repo.default_branch}"
                                  >${this.repo.default_branch}</paper-item
                                >
                              `}
                        </paper-listbox>
                      </paper-dropdown-menu>
                    </div>
                  `}
            </div>
          </div>

          <div class="card-actions MobileGrid">
            <hacs-button-main-action
              .hass=${this.hass}
              .repository=${this.repo}
              .status=${this.status}
            ></hacs-button-main-action>
            <hacs-button-changelog
              .hass=${this.hass}
              .repository=${this.repo}
            ></hacs-button-changelog>
            <hacs-button-open-repository
              .hass=${this.hass}
              .repository=${this.repo}
            ></hacs-button-open-repository>
            ${this.repo.category === "plugin"
            ? html `
                  <hacs-button-open-plugin
                    .hass=${this.hass}
                    .repository=${this.repo}
                  ></hacs-button-open-plugin>
                `
            : ""}
            <hacs-button-uninstall
              class="right"
              .hass=${this.hass}
              .repository=${this.repo}
              .status=${this.status}
            ></hacs-button-uninstall>
          </div>
        </ha-card>
        ${this.repo.updated_info
            ? html `
              <ha-card class="additional">
                <div class="card-content">
                  <div class="more_info markdown-body">
                    ${markdown.html(this.repo.additional_info || "", this.repo)}
                  </div>
                  <hacs-repository-note
                    .hass=${this.hass}
                    .configuration=${this.configuration}
                    .repository=${this.repo}
                  ></hacs-repository-note>
                </div>
              </ha-card>
            `
            : ""}
      </hacs-body>
    `;
        }
        setRepositoryVersion(e) {
            if (e.detail.value.length > 0) {
                this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                    detail: { repo: this.repository, action: "set_state", data: "other" },
                    bubbles: true,
                    composed: true
                }));
                this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                    detail: {
                        repo: this.repository,
                        action: "set_version",
                        data: e.detail.value
                    },
                    bubbles: true,
                    composed: true
                }));
            }
        }
        GoBackToStore() {
            this.repository = undefined;
            if (this.repo.installed) {
                this.panel = "installed";
            }
            else {
                this.panel = this.repo.category;
            }
            this.dispatchEvent(new CustomEvent("hacs-location-change", {
                detail: { value: this.panel },
                bubbles: true,
                composed: true
            }));
        }
        static get styles() {
            return [
                GFM,
                HLJS,
                HacsStyle,
                css `
        .loader {
          background-color: var(--primary-background-color);
          height: 100%;
          width: 100%;
        }
        paper-spinner {
          position: absolute;
          top: 30%;
          left: 50%;
          transform: translate(-50%, -50%);
          z-index: 99;
          width: 150px;
          height: 150px;
        }
        paper-dropdown-menu {
          width: 50%;
        }
        @media screen and (max-width: 600px) and (min-width: 0) {
          paper-dropdown-menu {
            width: 100%;
          }
          .getBack {
            margin-top: 0px !important;
          }
        }
        paper-item {
          display: flex;
          background-color: var(
            --paper-listbox-background-color,
            var(--primary-background-color)
          );
        }
        .description {
          width: 100%;
          margin-bottom: 8px;
          color: var(--secondary-text-color);
          text-align: left !important;
        }
        .version {
          padding-bottom: 8px;
        }
        .version-installed,
        .version-available {
          margin-top: 12px;
        }

        .options {
          float: right;
          width: 40%;
        }
        .information {
          width: 100%;
        }
        .additional {
          margin-bottom: 108px;
        }
        .getBack {
          margin-top: -12px;
          margin-bottom: 4px;
          margin-left: 5%;
        }
        .right {
          float: right;
        }
        .loading {
          text-align: center;
          width: 100%;
        }
        ha-card {
          width: 90%;
          margin-left: 5%;
        }
        .link-icon {
          color: var(--dark-primary-color);
          margin-right: 8px;
        }
        .repotitle {
          padding: 24px 24px 24px 18px;
          width: calc(100% - (24px + 4px + 24px + 56px));
          font-size: 1.5em;
          white-space: nowrap;
          text-overflow: ellipsis;
          overflow: hidden;
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], HacsRepository.prototype, "repositories", void 0);
    __decorate([
        property()
    ], HacsRepository.prototype, "repository_view", void 0);
    __decorate([
        property()
    ], HacsRepository.prototype, "repo", void 0);
    __decorate([
        property()
    ], HacsRepository.prototype, "configuration", void 0);
    __decorate([
        property()
    ], HacsRepository.prototype, "hacs", void 0);
    __decorate([
        property()
    ], HacsRepository.prototype, "hass", void 0);
    __decorate([
        property()
    ], HacsRepository.prototype, "lovelaceconfig", void 0);
    __decorate([
        property()
    ], HacsRepository.prototype, "route", void 0);
    __decorate([
        property()
    ], HacsRepository.prototype, "status", void 0);
    HacsRepository = __decorate([
        customElement("hacs-repository")
    ], HacsRepository);

    let HacsSettings = class HacsSettings extends LitElement {
        render() {
            if (this.hacs === undefined) {
                return html `
        <hacs-progressbar></hacs-progressbar>
      `;
            }
            return html `
      <hacs-body>
        <hacs-custom-repositories .hacs=${this.hacs} .route=${this.route}>
        </hacs-custom-repositories>
        <hacs-hidden-repositories .hacs=${this.hacs}>
        </hacs-hidden-repositories>
      </hacs-body>
    `;
        }
    };
    __decorate([
        property()
    ], HacsSettings.prototype, "hacs", void 0);
    __decorate([
        property()
    ], HacsSettings.prototype, "route", void 0);
    HacsSettings = __decorate([
        customElement("hacs-settings")
    ], HacsSettings);

    let HacsStore = class HacsStore extends LitElement {
        constructor() {
            super(...arguments);
            this.search = "";
            this.sort = "name-desc";
        }
        SortRepo(a, b) {
            const sorttype = this.sort.split("-")[1];
            const sortkey = this.sort.split("-")[0];
            if (sorttype === "desc") {
                if (sortkey === "stars")
                    return a.stars < b.stars;
                if (sortkey === "last_updated") {
                    return Date.parse(a.last_updated) < Date.parse(b.last_updated);
                }
                return a[sortkey] > b[sortkey];
            }
            else {
                if (sortkey === "stars")
                    return a.stars > b.stars;
                if (sortkey === "last_updated") {
                    return Date.parse(a.last_updated) > Date.parse(b.last_updated);
                }
                return a[sortkey] < b[sortkey];
            }
        }
        SetSortKey(ev) {
            const attr = ev.detail.item.getAttribute("key");
            if (attr.length === 0)
                return;
            this.sort = attr;
            localStorage.setItem("hacs-sort", this.sort);
        }
        DoSearch(ev) {
            this.search = ev.composedPath()[0].value;
            localStorage.setItem("hacs-search", this.search);
        }
        clearSearch() {
            this.search = "";
            localStorage.setItem("hacs-search", this.search);
        }
        render() {
            if (this.repositories === undefined)
                return html `
        <hacs-progressbar></hacs-progressbar>
      `;
            const builder = new OviewItemBuilder(this.hass, this.configuration, this.lovelaceconfig, this.status, this.route);
            var new_repositories = [];
            this.search = localStorage.getItem("hacs-search");
            this.sort = localStorage.getItem("hacs-sort");
            var repositories = this.repositories.filter(repository => {
                // Hide hidden repos from the store
                if (repository.hide)
                    return false;
                // Check contry restrictions
                if (this.configuration.country !== "ALL" &&
                    !this.hacs.isnullorempty(repository.country)) {
                    if (this.configuration.country !== repository.country)
                        return false;
                }
                // Check if repository category matches store
                if (repository.category === this.store) {
                    // Hide HACS from stores
                    if (repository.id === "172733314")
                        return false;
                    // Search filter
                    if (this.search !== "") {
                        if (repository.name.toLowerCase().includes(this.search.toLowerCase()))
                            return true;
                        if (repository.description
                            .toLowerCase()
                            .includes(this.search.toLowerCase()))
                            return true;
                        if (repository.full_name
                            .toLowerCase()
                            .includes(this.search.toLowerCase()))
                            return true;
                        if (String(repository.authors)
                            .toLowerCase()
                            .includes(this.search.toLowerCase()))
                            return true;
                        if (String(repository.topics)
                            .toLowerCase()
                            .includes(this.search.toLowerCase()))
                            return true;
                        return false;
                    }
                    // Is this new?
                    if (repository.new)
                        new_repositories.push(repository);
                    return true;
                }
                return false;
            });
            return html `
      <hacs-body>
        <div class="store-top">
          <paper-input
            class="search-bar padder"
            type="text"
            id="Search"
            @input=${this.DoSearch}
            placeholder="  ${this.hacs.localize("store.placeholder_search")}."
            autofocus
            .value=${this.search}
          >
            ${this.search.length > 0
            ? html `
                  <ha-icon
                    slot="suffix"
                    icon="mdi:close"
                    @click="${this.clearSearch}"
                  ></ha-icon>
                `
            : ""}
          </paper-input>
          <paper-dropdown-menu
            @iron-select="${this.SetSortKey}"
            class="sort padder"
            label="Sort"
          >
            <paper-listbox
              slot="dropdown-content"
              class="list"
              selected="${this.sort}"
              attr-for-selected="key"
              dir="rtl"
            >
              <paper-item class="listitem" key="last_updated-desc"
                >${this.hacs.localize("store.last_updated")}&nbsp;(${this.hacs.localize("store.descending")})</paper-item
              >
              <paper-item class="listitem" key="last_updated-asc"
                >${this.hacs.localize("store.last_updated")}&nbsp;(${this.hacs.localize("store.ascending")})</paper-item
              >
              <paper-item class="listitem" key="name-desc"
                >${this.hacs.localize("store.name")}&nbsp;(${this.hacs.localize("store.descending")})</paper-item
              >
              <paper-item class="listitem" key="name-asc"
                >${this.hacs.localize("store.name")}&nbsp;(${this.hacs.localize("store.ascending")})</paper-item
              >
              <paper-item class="listitem" key="stars-desc"
                >${this.hacs.localize("store.stars")}&nbsp;(${this.hacs.localize("store.descending")})</paper-item
              >
              <paper-item class="listitem" key="stars-asc"
                >${this.hacs.localize("store.stars")}&nbsp;(${this.hacs.localize("store.ascending")})</paper-item
              >
            </paper-listbox>
          </paper-dropdown-menu>
        </div>

        ${new_repositories.length !== 0
            ? html `
              <div class="card-group">
                <div class="leftspace grouptitle">
                  ${this.hacs.localize("store.new_repositories")}
                </div>
                ${new_repositories
                .sort((a, b) => (this.SortRepo(a, b) ? 1 : -1))
                .map(repository => {
                return builder.render(repository);
            })}
                <div class="card-group">
                  <hacs-button-clear-new
                    .hass=${this.hass}
                    .category=${this.store}
                  ></hacs-button-clear-new>
                </div>
              </div>
              <hr noshade />
            `
            : ""}

        <div class="card-group">
          ${repositories
            .sort((a, b) => (this.SortRepo(a, b) ? 1 : -1))
            .map(repository => {
            return builder.render(repository);
        })}
        </div>
      </hacs-body>
    `;
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        .loader {
          background-color: var(--primary-background-color);
          height: 100%;
          width: 100%;
        }
        ha-card {
          display: inline-block;
          cursor: pointer;
        }
        .padder {
          padding-left: 8px;
          padding-right: 8px;
        }
        .search-bar {
          display: block;
          width: 60%;
          background-color: var(--primary-background-color);
          color: var(--primary-text-color);
          line-height: 32px;
          border-color: var(--dark-primary-color);
          border-width: inherit;
          border-bottom-width: thin;
          border-radius: var(--ha-card-border-radius);
        }

        .sort {
          display: block;
          width: 30%;
          margin-left: 10%;
          background-color: var(--primary-background-color);
          color: var(--primary-text-color);
          line-height: 32px;
          border-color: var(--dark-primary-color);
          border-width: inherit;
          border-bottom-width: thin;
          border-radius: var(--ha-card-border-radius);
        }

        .store-top {
          display: flex;
          margin-top: -12px;
          max-width: 100%;
        }
        .card-content {
          width: calc(100% - 32px) !important;
        }
        paper-item.listitem {
          display: flex;
          background-color: var(
            --paper-listbox-background-color,
            var(--primary-background-color)
          );
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], HacsStore.prototype, "repositories", void 0);
    __decorate([
        property()
    ], HacsStore.prototype, "configuration", void 0);
    __decorate([
        property()
    ], HacsStore.prototype, "hacs", void 0);
    __decorate([
        property()
    ], HacsStore.prototype, "hass", void 0);
    __decorate([
        property()
    ], HacsStore.prototype, "lovelaceconfig", void 0);
    __decorate([
        property()
    ], HacsStore.prototype, "route", void 0);
    __decorate([
        property()
    ], HacsStore.prototype, "status", void 0);
    __decorate([
        property()
    ], HacsStore.prototype, "store", void 0);
    __decorate([
        property()
    ], HacsStore.prototype, "search", void 0);
    __decorate([
        property()
    ], HacsStore.prototype, "sort", void 0);
    HacsStore = __decorate([
        customElement("hacs-store")
    ], HacsStore);

    var sweetalert_min = createCommonjsModule(function (module, exports) {
    !function(t,e){module.exports=e();}(commonjsGlobal,function(){return function(t){function e(o){if(n[o])return n[o].exports;var r=n[o]={i:o,l:!1,exports:{}};return t[o].call(r.exports,r,r.exports,e),r.l=!0,r.exports}var n={};return e.m=t,e.c=n,e.d=function(t,n,o){e.o(t,n)||Object.defineProperty(t,n,{configurable:!1,enumerable:!0,get:o});},e.n=function(t){var n=t&&t.__esModule?function(){return t.default}:function(){return t};return e.d(n,"a",n),n},e.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},e.p="",e(e.s=8)}([function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o="swal-button";e.CLASS_NAMES={MODAL:"swal-modal",OVERLAY:"swal-overlay",SHOW_MODAL:"swal-overlay--show-modal",MODAL_TITLE:"swal-title",MODAL_TEXT:"swal-text",ICON:"swal-icon",ICON_CUSTOM:"swal-icon--custom",CONTENT:"swal-content",FOOTER:"swal-footer",BUTTON_CONTAINER:"swal-button-container",BUTTON:o,CONFIRM_BUTTON:o+"--confirm",CANCEL_BUTTON:o+"--cancel",DANGER_BUTTON:o+"--danger",BUTTON_LOADING:o+"--loading",BUTTON_LOADER:o+"__loader"},e.default=e.CLASS_NAMES;},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0}),e.getNode=function(t){var e="."+t;return document.querySelector(e)},e.stringToNode=function(t){var e=document.createElement("div");return e.innerHTML=t.trim(),e.firstChild},e.insertAfter=function(t,e){var n=e.nextSibling;e.parentNode.insertBefore(t,n);},e.removeNode=function(t){t.parentElement.removeChild(t);},e.throwErr=function(t){throw t=t.replace(/ +(?= )/g,""),"SweetAlert: "+(t=t.trim())},e.isPlainObject=function(t){if("[object Object]"!==Object.prototype.toString.call(t))return !1;var e=Object.getPrototypeOf(t);return null===e||e===Object.prototype},e.ordinalSuffixOf=function(t){var e=t%10,n=t%100;return 1===e&&11!==n?t+"st":2===e&&12!==n?t+"nd":3===e&&13!==n?t+"rd":t+"th"};},function(t,e,n){function o(t){for(var n in t)e.hasOwnProperty(n)||(e[n]=t[n]);}Object.defineProperty(e,"__esModule",{value:!0}),o(n(25));var r=n(26);e.overlayMarkup=r.default,o(n(27)),o(n(28)),o(n(29));var i=n(0),a=i.default.MODAL_TITLE,s=i.default.MODAL_TEXT,c=i.default.ICON,l=i.default.FOOTER;e.iconMarkup='\n  <div class="'+c+'"></div>',e.titleMarkup='\n  <div class="'+a+'"></div>\n',e.textMarkup='\n  <div class="'+s+'"></div>',e.footerMarkup='\n  <div class="'+l+'"></div>\n';},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(1);e.CONFIRM_KEY="confirm",e.CANCEL_KEY="cancel";var r={visible:!0,text:null,value:null,className:"",closeModal:!0},i=Object.assign({},r,{visible:!1,text:"Cancel",value:null}),a=Object.assign({},r,{text:"OK",value:!0});e.defaultButtonList={cancel:i,confirm:a};var s=function(t){switch(t){case e.CONFIRM_KEY:return a;case e.CANCEL_KEY:return i;default:var n=t.charAt(0).toUpperCase()+t.slice(1);return Object.assign({},r,{text:n,value:t})}},c=function(t,e){var n=s(t);return !0===e?Object.assign({},n,{visible:!0}):"string"==typeof e?Object.assign({},n,{visible:!0,text:e}):o.isPlainObject(e)?Object.assign({visible:!0},n,e):Object.assign({},n,{visible:!1})},l=function(t){for(var e={},n=0,o=Object.keys(t);n<o.length;n++){var r=o[n],a=t[r],s=c(r,a);e[r]=s;}return e.cancel||(e.cancel=i),e},u=function(t){var n={};switch(t.length){case 1:n[e.CANCEL_KEY]=Object.assign({},i,{visible:!1});break;case 2:n[e.CANCEL_KEY]=c(e.CANCEL_KEY,t[0]),n[e.CONFIRM_KEY]=c(e.CONFIRM_KEY,t[1]);break;default:o.throwErr("Invalid number of 'buttons' in array ("+t.length+").\n      If you want more than 2 buttons, you need to use an object!");}return n};e.getButtonListOpts=function(t){var n=e.defaultButtonList;return "string"==typeof t?n[e.CONFIRM_KEY]=c(e.CONFIRM_KEY,t):Array.isArray(t)?n=u(t):o.isPlainObject(t)?n=l(t):!0===t?n=u([!0,!0]):!1===t?n=u([!1,!1]):void 0===t&&(n=e.defaultButtonList),n};},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(1),r=n(2),i=n(0),a=i.default.MODAL,s=i.default.OVERLAY,c=n(30),l=n(31),u=n(32),f=n(33);e.injectElIntoModal=function(t){var e=o.getNode(a),n=o.stringToNode(t);return e.appendChild(n),n};var d=function(t){t.className=a,t.textContent="";},p=function(t,e){d(t);var n=e.className;n&&t.classList.add(n);};e.initModalContent=function(t){var e=o.getNode(a);p(e,t),c.default(t.icon),l.initTitle(t.title),l.initText(t.text),f.default(t.content),u.default(t.buttons,t.dangerMode);};var m=function(){var t=o.getNode(s),e=o.stringToNode(r.modalMarkup);t.appendChild(e);};e.default=m;},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(3),r={isOpen:!1,promise:null,actions:{},timer:null},i=Object.assign({},r);e.resetState=function(){i=Object.assign({},r);},e.setActionValue=function(t){if("string"==typeof t)return a(o.CONFIRM_KEY,t);for(var e in t)a(e,t[e]);};var a=function(t,e){i.actions[t]||(i.actions[t]={}),Object.assign(i.actions[t],{value:e});};e.setActionOptionsFor=function(t,e){var n=(void 0===e?{}:e).closeModal,o=void 0===n||n;Object.assign(i.actions[t],{closeModal:o});},e.default=i;},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(1),r=n(3),i=n(0),a=i.default.OVERLAY,s=i.default.SHOW_MODAL,c=i.default.BUTTON,l=i.default.BUTTON_LOADING,u=n(5);e.openModal=function(){o.getNode(a).classList.add(s),u.default.isOpen=!0;};var f=function(){o.getNode(a).classList.remove(s),u.default.isOpen=!1;};e.onAction=function(t){void 0===t&&(t=r.CANCEL_KEY);var e=u.default.actions[t],n=e.value;if(!1===e.closeModal){var i=c+"--"+t;o.getNode(i).classList.add(l);}else f();u.default.promise.resolve(n);},e.getState=function(){var t=Object.assign({},u.default);return delete t.promise,delete t.timer,t},e.stopLoading=function(){for(var t=document.querySelectorAll("."+c),e=0;e<t.length;e++){t[e].classList.remove(l);}};},function(t,e){var n;n=function(){return this}();try{n=n||Function("return this")()||(0,eval)("this");}catch(t){"object"==typeof window&&(n=window);}t.exports=n;},function(t,e,n){(function(e){t.exports=e.sweetAlert=n(9);}).call(e,n(7));},function(t,e,n){(function(e){t.exports=e.swal=n(10);}).call(e,n(7));},function(t,e,n){"undefined"!=typeof window&&n(11),n(16);var o=n(23).default;t.exports=o;},function(t,e,n){var o=n(12);"string"==typeof o&&(o=[[t.i,o,""]]);var r={insertAt:"top"};r.transform=void 0;n(14)(o,r);o.locals&&(t.exports=o.locals);},function(t,e,n){e=t.exports=n(13)(void 0),e.push([t.i,'.swal-icon--error{border-color:#f27474;-webkit-animation:animateErrorIcon .5s;animation:animateErrorIcon .5s}.swal-icon--error__x-mark{position:relative;display:block;-webkit-animation:animateXMark .5s;animation:animateXMark .5s}.swal-icon--error__line{position:absolute;height:5px;width:47px;background-color:#f27474;display:block;top:37px;border-radius:2px}.swal-icon--error__line--left{-webkit-transform:rotate(45deg);transform:rotate(45deg);left:17px}.swal-icon--error__line--right{-webkit-transform:rotate(-45deg);transform:rotate(-45deg);right:16px}@-webkit-keyframes animateErrorIcon{0%{-webkit-transform:rotateX(100deg);transform:rotateX(100deg);opacity:0}to{-webkit-transform:rotateX(0deg);transform:rotateX(0deg);opacity:1}}@keyframes animateErrorIcon{0%{-webkit-transform:rotateX(100deg);transform:rotateX(100deg);opacity:0}to{-webkit-transform:rotateX(0deg);transform:rotateX(0deg);opacity:1}}@-webkit-keyframes animateXMark{0%{-webkit-transform:scale(.4);transform:scale(.4);margin-top:26px;opacity:0}50%{-webkit-transform:scale(.4);transform:scale(.4);margin-top:26px;opacity:0}80%{-webkit-transform:scale(1.15);transform:scale(1.15);margin-top:-6px}to{-webkit-transform:scale(1);transform:scale(1);margin-top:0;opacity:1}}@keyframes animateXMark{0%{-webkit-transform:scale(.4);transform:scale(.4);margin-top:26px;opacity:0}50%{-webkit-transform:scale(.4);transform:scale(.4);margin-top:26px;opacity:0}80%{-webkit-transform:scale(1.15);transform:scale(1.15);margin-top:-6px}to{-webkit-transform:scale(1);transform:scale(1);margin-top:0;opacity:1}}.swal-icon--warning{border-color:#f8bb86;-webkit-animation:pulseWarning .75s infinite alternate;animation:pulseWarning .75s infinite alternate}.swal-icon--warning__body{width:5px;height:47px;top:10px;border-radius:2px;margin-left:-2px}.swal-icon--warning__body,.swal-icon--warning__dot{position:absolute;left:50%;background-color:#f8bb86}.swal-icon--warning__dot{width:7px;height:7px;border-radius:50%;margin-left:-4px;bottom:-11px}@-webkit-keyframes pulseWarning{0%{border-color:#f8d486}to{border-color:#f8bb86}}@keyframes pulseWarning{0%{border-color:#f8d486}to{border-color:#f8bb86}}.swal-icon--success{border-color:#a5dc86}.swal-icon--success:after,.swal-icon--success:before{content:"";border-radius:50%;position:absolute;width:60px;height:120px;background:#fff;-webkit-transform:rotate(45deg);transform:rotate(45deg)}.swal-icon--success:before{border-radius:120px 0 0 120px;top:-7px;left:-33px;-webkit-transform:rotate(-45deg);transform:rotate(-45deg);-webkit-transform-origin:60px 60px;transform-origin:60px 60px}.swal-icon--success:after{border-radius:0 120px 120px 0;top:-11px;left:30px;-webkit-transform:rotate(-45deg);transform:rotate(-45deg);-webkit-transform-origin:0 60px;transform-origin:0 60px;-webkit-animation:rotatePlaceholder 4.25s ease-in;animation:rotatePlaceholder 4.25s ease-in}.swal-icon--success__ring{width:80px;height:80px;border:4px solid hsla(98,55%,69%,.2);border-radius:50%;box-sizing:content-box;position:absolute;left:-4px;top:-4px;z-index:2}.swal-icon--success__hide-corners{width:5px;height:90px;background-color:#fff;padding:1px;position:absolute;left:28px;top:8px;z-index:1;-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}.swal-icon--success__line{height:5px;background-color:#a5dc86;display:block;border-radius:2px;position:absolute;z-index:2}.swal-icon--success__line--tip{width:25px;left:14px;top:46px;-webkit-transform:rotate(45deg);transform:rotate(45deg);-webkit-animation:animateSuccessTip .75s;animation:animateSuccessTip .75s}.swal-icon--success__line--long{width:47px;right:8px;top:38px;-webkit-transform:rotate(-45deg);transform:rotate(-45deg);-webkit-animation:animateSuccessLong .75s;animation:animateSuccessLong .75s}@-webkit-keyframes rotatePlaceholder{0%{-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}5%{-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}12%{-webkit-transform:rotate(-405deg);transform:rotate(-405deg)}to{-webkit-transform:rotate(-405deg);transform:rotate(-405deg)}}@keyframes rotatePlaceholder{0%{-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}5%{-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}12%{-webkit-transform:rotate(-405deg);transform:rotate(-405deg)}to{-webkit-transform:rotate(-405deg);transform:rotate(-405deg)}}@-webkit-keyframes animateSuccessTip{0%{width:0;left:1px;top:19px}54%{width:0;left:1px;top:19px}70%{width:50px;left:-8px;top:37px}84%{width:17px;left:21px;top:48px}to{width:25px;left:14px;top:45px}}@keyframes animateSuccessTip{0%{width:0;left:1px;top:19px}54%{width:0;left:1px;top:19px}70%{width:50px;left:-8px;top:37px}84%{width:17px;left:21px;top:48px}to{width:25px;left:14px;top:45px}}@-webkit-keyframes animateSuccessLong{0%{width:0;right:46px;top:54px}65%{width:0;right:46px;top:54px}84%{width:55px;right:0;top:35px}to{width:47px;right:8px;top:38px}}@keyframes animateSuccessLong{0%{width:0;right:46px;top:54px}65%{width:0;right:46px;top:54px}84%{width:55px;right:0;top:35px}to{width:47px;right:8px;top:38px}}.swal-icon--info{border-color:#c9dae1}.swal-icon--info:before{width:5px;height:29px;bottom:17px;border-radius:2px;margin-left:-2px}.swal-icon--info:after,.swal-icon--info:before{content:"";position:absolute;left:50%;background-color:#c9dae1}.swal-icon--info:after{width:7px;height:7px;border-radius:50%;margin-left:-3px;top:19px}.swal-icon{width:80px;height:80px;border-width:4px;border-style:solid;border-radius:50%;padding:0;position:relative;box-sizing:content-box;margin:20px auto}.swal-icon:first-child{margin-top:32px}.swal-icon--custom{width:auto;height:auto;max-width:100%;border:none;border-radius:0}.swal-icon img{max-width:100%;max-height:100%}.swal-title{color:rgba(0,0,0,.65);font-weight:600;text-transform:none;position:relative;display:block;padding:13px 16px;font-size:27px;line-height:normal;text-align:center;margin-bottom:0}.swal-title:first-child{margin-top:26px}.swal-title:not(:first-child){padding-bottom:0}.swal-title:not(:last-child){margin-bottom:13px}.swal-text{font-size:16px;position:relative;float:none;line-height:normal;vertical-align:top;text-align:left;display:inline-block;margin:0;padding:0 10px;font-weight:400;color:rgba(0,0,0,.64);max-width:calc(100% - 20px);overflow-wrap:break-word;box-sizing:border-box}.swal-text:first-child{margin-top:45px}.swal-text:last-child{margin-bottom:45px}.swal-footer{text-align:right;padding-top:13px;margin-top:13px;padding:13px 16px;border-radius:inherit;border-top-left-radius:0;border-top-right-radius:0}.swal-button-container{margin:5px;display:inline-block;position:relative}.swal-button{background-color:#7cd1f9;color:#fff;border:none;box-shadow:none;border-radius:5px;font-weight:600;font-size:14px;padding:10px 24px;margin:0;cursor:pointer}.swal-button:not([disabled]):hover{background-color:#78cbf2}.swal-button:active{background-color:#70bce0}.swal-button:focus{outline:none;box-shadow:0 0 0 1px #fff,0 0 0 3px rgba(43,114,165,.29)}.swal-button[disabled]{opacity:.5;cursor:default}.swal-button::-moz-focus-inner{border:0}.swal-button--cancel{color:#555;background-color:#efefef}.swal-button--cancel:not([disabled]):hover{background-color:#e8e8e8}.swal-button--cancel:active{background-color:#d7d7d7}.swal-button--cancel:focus{box-shadow:0 0 0 1px #fff,0 0 0 3px rgba(116,136,150,.29)}.swal-button--danger{background-color:#e64942}.swal-button--danger:not([disabled]):hover{background-color:#df4740}.swal-button--danger:active{background-color:#cf423b}.swal-button--danger:focus{box-shadow:0 0 0 1px #fff,0 0 0 3px rgba(165,43,43,.29)}.swal-content{padding:0 20px;margin-top:20px;font-size:medium}.swal-content:last-child{margin-bottom:20px}.swal-content__input,.swal-content__textarea{-webkit-appearance:none;background-color:#fff;border:none;font-size:14px;display:block;box-sizing:border-box;width:100%;border:1px solid rgba(0,0,0,.14);padding:10px 13px;border-radius:2px;transition:border-color .2s}.swal-content__input:focus,.swal-content__textarea:focus{outline:none;border-color:#6db8ff}.swal-content__textarea{resize:vertical}.swal-button--loading{color:transparent}.swal-button--loading~.swal-button__loader{opacity:1}.swal-button__loader{position:absolute;height:auto;width:43px;z-index:2;left:50%;top:50%;-webkit-transform:translateX(-50%) translateY(-50%);transform:translateX(-50%) translateY(-50%);text-align:center;pointer-events:none;opacity:0}.swal-button__loader div{display:inline-block;float:none;vertical-align:baseline;width:9px;height:9px;padding:0;border:none;margin:2px;opacity:.4;border-radius:7px;background-color:hsla(0,0%,100%,.9);transition:background .2s;-webkit-animation:swal-loading-anim 1s infinite;animation:swal-loading-anim 1s infinite}.swal-button__loader div:nth-child(3n+2){-webkit-animation-delay:.15s;animation-delay:.15s}.swal-button__loader div:nth-child(3n+3){-webkit-animation-delay:.3s;animation-delay:.3s}@-webkit-keyframes swal-loading-anim{0%{opacity:.4}20%{opacity:.4}50%{opacity:1}to{opacity:.4}}@keyframes swal-loading-anim{0%{opacity:.4}20%{opacity:.4}50%{opacity:1}to{opacity:.4}}.swal-overlay{position:fixed;top:0;bottom:0;left:0;right:0;text-align:center;font-size:0;overflow-y:auto;background-color:rgba(0,0,0,.4);z-index:10000;pointer-events:none;opacity:0;transition:opacity .3s}.swal-overlay:before{content:" ";display:inline-block;vertical-align:middle;height:100%}.swal-overlay--show-modal{opacity:1;pointer-events:auto}.swal-overlay--show-modal .swal-modal{opacity:1;pointer-events:auto;box-sizing:border-box;-webkit-animation:showSweetAlert .3s;animation:showSweetAlert .3s;will-change:transform}.swal-modal{width:478px;opacity:0;pointer-events:none;background-color:#fff;text-align:center;border-radius:5px;position:static;margin:20px auto;display:inline-block;vertical-align:middle;-webkit-transform:scale(1);transform:scale(1);-webkit-transform-origin:50% 50%;transform-origin:50% 50%;z-index:10001;transition:opacity .2s,-webkit-transform .3s;transition:transform .3s,opacity .2s;transition:transform .3s,opacity .2s,-webkit-transform .3s}@media (max-width:500px){.swal-modal{width:calc(100% - 20px)}}@-webkit-keyframes showSweetAlert{0%{-webkit-transform:scale(1);transform:scale(1)}1%{-webkit-transform:scale(.5);transform:scale(.5)}45%{-webkit-transform:scale(1.05);transform:scale(1.05)}80%{-webkit-transform:scale(.95);transform:scale(.95)}to{-webkit-transform:scale(1);transform:scale(1)}}@keyframes showSweetAlert{0%{-webkit-transform:scale(1);transform:scale(1)}1%{-webkit-transform:scale(.5);transform:scale(.5)}45%{-webkit-transform:scale(1.05);transform:scale(1.05)}80%{-webkit-transform:scale(.95);transform:scale(.95)}to{-webkit-transform:scale(1);transform:scale(1)}}',""]);},function(t,e){function n(t,e){var n=t[1]||"",r=t[3];if(!r)return n;if(e&&"function"==typeof btoa){var i=o(r);return [n].concat(r.sources.map(function(t){return "/*# sourceURL="+r.sourceRoot+t+" */"})).concat([i]).join("\n")}return [n].join("\n")}function o(t){return "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,"+btoa(unescape(encodeURIComponent(JSON.stringify(t))))+" */"}t.exports=function(t){var e=[];return e.toString=function(){return this.map(function(e){var o=n(e,t);return e[2]?"@media "+e[2]+"{"+o+"}":o}).join("")},e.i=function(t,n){"string"==typeof t&&(t=[[null,t,""]]);for(var o={},r=0;r<this.length;r++){var i=this[r][0];"number"==typeof i&&(o[i]=!0);}for(r=0;r<t.length;r++){var a=t[r];"number"==typeof a[0]&&o[a[0]]||(n&&!a[2]?a[2]=n:n&&(a[2]="("+a[2]+") and ("+n+")"),e.push(a));}},e};},function(t,e,n){function o(t,e){for(var n=0;n<t.length;n++){var o=t[n],r=m[o.id];if(r){r.refs++;for(var i=0;i<r.parts.length;i++)r.parts[i](o.parts[i]);for(;i<o.parts.length;i++)r.parts.push(u(o.parts[i],e));}else{for(var a=[],i=0;i<o.parts.length;i++)a.push(u(o.parts[i],e));m[o.id]={id:o.id,refs:1,parts:a};}}}function r(t,e){for(var n=[],o={},r=0;r<t.length;r++){var i=t[r],a=e.base?i[0]+e.base:i[0],s=i[1],c=i[2],l=i[3],u={css:s,media:c,sourceMap:l};o[a]?o[a].parts.push(u):n.push(o[a]={id:a,parts:[u]});}return n}function i(t,e){var n=v(t.insertInto);if(!n)throw new Error("Couldn't find a style target. This probably means that the value for the 'insertInto' parameter is invalid.");var o=w[w.length-1];if("top"===t.insertAt)o?o.nextSibling?n.insertBefore(e,o.nextSibling):n.appendChild(e):n.insertBefore(e,n.firstChild),w.push(e);else{if("bottom"!==t.insertAt)throw new Error("Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.");n.appendChild(e);}}function a(t){if(null===t.parentNode)return !1;t.parentNode.removeChild(t);var e=w.indexOf(t);e>=0&&w.splice(e,1);}function s(t){var e=document.createElement("style");return t.attrs.type="text/css",l(e,t.attrs),i(t,e),e}function c(t){var e=document.createElement("link");return t.attrs.type="text/css",t.attrs.rel="stylesheet",l(e,t.attrs),i(t,e),e}function l(t,e){Object.keys(e).forEach(function(n){t.setAttribute(n,e[n]);});}function u(t,e){var n,o,r,i;if(e.transform&&t.css){if(!(i=e.transform(t.css)))return function(){};t.css=i;}if(e.singleton){var l=h++;n=g||(g=s(e)),o=f.bind(null,n,l,!1),r=f.bind(null,n,l,!0);}else t.sourceMap&&"function"==typeof URL&&"function"==typeof URL.createObjectURL&&"function"==typeof URL.revokeObjectURL&&"function"==typeof Blob&&"function"==typeof btoa?(n=c(e),o=p.bind(null,n,e),r=function(){a(n),n.href&&URL.revokeObjectURL(n.href);}):(n=s(e),o=d.bind(null,n),r=function(){a(n);});return o(t),function(e){if(e){if(e.css===t.css&&e.media===t.media&&e.sourceMap===t.sourceMap)return;o(t=e);}else r();}}function f(t,e,n,o){var r=n?"":o.css;if(t.styleSheet)t.styleSheet.cssText=x(e,r);else{var i=document.createTextNode(r),a=t.childNodes;a[e]&&t.removeChild(a[e]),a.length?t.insertBefore(i,a[e]):t.appendChild(i);}}function d(t,e){var n=e.css,o=e.media;if(o&&t.setAttribute("media",o),t.styleSheet)t.styleSheet.cssText=n;else{for(;t.firstChild;)t.removeChild(t.firstChild);t.appendChild(document.createTextNode(n));}}function p(t,e,n){var o=n.css,r=n.sourceMap,i=void 0===e.convertToAbsoluteUrls&&r;(e.convertToAbsoluteUrls||i)&&(o=y(o)),r&&(o+="\n/*# sourceMappingURL=data:application/json;base64,"+btoa(unescape(encodeURIComponent(JSON.stringify(r))))+" */");var a=new Blob([o],{type:"text/css"}),s=t.href;t.href=URL.createObjectURL(a),s&&URL.revokeObjectURL(s);}var m={},b=function(t){var e;return function(){return void 0===e&&(e=t.apply(this,arguments)),e}}(function(){return window&&document&&document.all&&!window.atob}),v=function(t){var e={};return function(n){return void 0===e[n]&&(e[n]=t.call(this,n)),e[n]}}(function(t){return document.querySelector(t)}),g=null,h=0,w=[],y=n(15);t.exports=function(t,e){if("undefined"!=typeof DEBUG&&DEBUG&&"object"!=typeof document)throw new Error("The style-loader cannot be used in a non-browser environment");e=e||{},e.attrs="object"==typeof e.attrs?e.attrs:{},e.singleton||(e.singleton=b()),e.insertInto||(e.insertInto="head"),e.insertAt||(e.insertAt="bottom");var n=r(t,e);return o(n,e),function(t){for(var i=[],a=0;a<n.length;a++){var s=n[a],c=m[s.id];c.refs--,i.push(c);}if(t){o(r(t,e),e);}for(var a=0;a<i.length;a++){var c=i[a];if(0===c.refs){for(var l=0;l<c.parts.length;l++)c.parts[l]();delete m[c.id];}}}};var x=function(){var t=[];return function(e,n){return t[e]=n,t.filter(Boolean).join("\n")}}();},function(t,e){t.exports=function(t){var e="undefined"!=typeof window&&window.location;if(!e)throw new Error("fixUrls requires window.location");if(!t||"string"!=typeof t)return t;var n=e.protocol+"//"+e.host,o=n+e.pathname.replace(/\/[^\/]*$/,"/");return t.replace(/url\s*\(((?:[^)(]|\((?:[^)(]+|\([^)(]*\))*\))*)\)/gi,function(t,e){var r=e.trim().replace(/^"(.*)"$/,function(t,e){return e}).replace(/^'(.*)'$/,function(t,e){return e});if(/^(#|data:|http:\/\/|https:\/\/|file:\/\/\/)/i.test(r))return t;var i;return i=0===r.indexOf("//")?r:0===r.indexOf("/")?n+r:o+r.replace(/^\.\//,""),"url("+JSON.stringify(i)+")"})};},function(t,e,n){var o=n(17);"undefined"==typeof window||window.Promise||(window.Promise=o),n(21),String.prototype.includes||(String.prototype.includes=function(t,e){return "number"!=typeof e&&(e=0),!(e+t.length>this.length)&&-1!==this.indexOf(t,e)}),Array.prototype.includes||Object.defineProperty(Array.prototype,"includes",{value:function(t,e){if(null==this)throw new TypeError('"this" is null or not defined');var n=Object(this),o=n.length>>>0;if(0===o)return !1;for(var r=0|e,i=Math.max(r>=0?r:o-Math.abs(r),0);i<o;){if(function(t,e){return t===e||"number"==typeof t&&"number"==typeof e&&isNaN(t)&&isNaN(e)}(n[i],t))return !0;i++;}return !1}}),"undefined"!=typeof window&&function(t){t.forEach(function(t){t.hasOwnProperty("remove")||Object.defineProperty(t,"remove",{configurable:!0,enumerable:!0,writable:!0,value:function(){this.parentNode.removeChild(this);}});});}([Element.prototype,CharacterData.prototype,DocumentType.prototype]);},function(t,e,n){(function(e){!function(n){function o(){}function r(t,e){return function(){t.apply(e,arguments);}}function i(t){if("object"!=typeof this)throw new TypeError("Promises must be constructed via new");if("function"!=typeof t)throw new TypeError("not a function");this._state=0,this._handled=!1,this._value=void 0,this._deferreds=[],f(t,this);}function a(t,e){for(;3===t._state;)t=t._value;if(0===t._state)return void t._deferreds.push(e);t._handled=!0,i._immediateFn(function(){var n=1===t._state?e.onFulfilled:e.onRejected;if(null===n)return void(1===t._state?s:c)(e.promise,t._value);var o;try{o=n(t._value);}catch(t){return void c(e.promise,t)}s(e.promise,o);});}function s(t,e){try{if(e===t)throw new TypeError("A promise cannot be resolved with itself.");if(e&&("object"==typeof e||"function"==typeof e)){var n=e.then;if(e instanceof i)return t._state=3,t._value=e,void l(t);if("function"==typeof n)return void f(r(n,e),t)}t._state=1,t._value=e,l(t);}catch(e){c(t,e);}}function c(t,e){t._state=2,t._value=e,l(t);}function l(t){2===t._state&&0===t._deferreds.length&&i._immediateFn(function(){t._handled||i._unhandledRejectionFn(t._value);});for(var e=0,n=t._deferreds.length;e<n;e++)a(t,t._deferreds[e]);t._deferreds=null;}function u(t,e,n){this.onFulfilled="function"==typeof t?t:null,this.onRejected="function"==typeof e?e:null,this.promise=n;}function f(t,e){var n=!1;try{t(function(t){n||(n=!0,s(e,t));},function(t){n||(n=!0,c(e,t));});}catch(t){if(n)return;n=!0,c(e,t);}}var d=setTimeout;i.prototype.catch=function(t){return this.then(null,t)},i.prototype.then=function(t,e){var n=new this.constructor(o);return a(this,new u(t,e,n)),n},i.all=function(t){var e=Array.prototype.slice.call(t);return new i(function(t,n){function o(i,a){try{if(a&&("object"==typeof a||"function"==typeof a)){var s=a.then;if("function"==typeof s)return void s.call(a,function(t){o(i,t);},n)}e[i]=a,0==--r&&t(e);}catch(t){n(t);}}if(0===e.length)return t([]);for(var r=e.length,i=0;i<e.length;i++)o(i,e[i]);})},i.resolve=function(t){return t&&"object"==typeof t&&t.constructor===i?t:new i(function(e){e(t);})},i.reject=function(t){return new i(function(e,n){n(t);})},i.race=function(t){return new i(function(e,n){for(var o=0,r=t.length;o<r;o++)t[o].then(e,n);})},i._immediateFn="function"==typeof e&&function(t){e(t);}||function(t){d(t,0);},i._unhandledRejectionFn=function(t){"undefined"!=typeof console&&console&&console.warn("Possible Unhandled Promise Rejection:",t);},i._setImmediateFn=function(t){i._immediateFn=t;},i._setUnhandledRejectionFn=function(t){i._unhandledRejectionFn=t;},void 0!==t&&t.exports?t.exports=i:n.Promise||(n.Promise=i);}(this);}).call(e,n(18).setImmediate);},function(t,e,n){function o(t,e){this._id=t,this._clearFn=e;}var r=Function.prototype.apply;e.setTimeout=function(){return new o(r.call(setTimeout,window,arguments),clearTimeout)},e.setInterval=function(){return new o(r.call(setInterval,window,arguments),clearInterval)},e.clearTimeout=e.clearInterval=function(t){t&&t.close();},o.prototype.unref=o.prototype.ref=function(){},o.prototype.close=function(){this._clearFn.call(window,this._id);},e.enroll=function(t,e){clearTimeout(t._idleTimeoutId),t._idleTimeout=e;},e.unenroll=function(t){clearTimeout(t._idleTimeoutId),t._idleTimeout=-1;},e._unrefActive=e.active=function(t){clearTimeout(t._idleTimeoutId);var e=t._idleTimeout;e>=0&&(t._idleTimeoutId=setTimeout(function(){t._onTimeout&&t._onTimeout();},e));},n(19),e.setImmediate=setImmediate,e.clearImmediate=clearImmediate;},function(t,e,n){(function(t,e){!function(t,n){function o(t){"function"!=typeof t&&(t=new Function(""+t));for(var e=new Array(arguments.length-1),n=0;n<e.length;n++)e[n]=arguments[n+1];var o={callback:t,args:e};return l[c]=o,s(c),c++}function r(t){delete l[t];}function i(t){var e=t.callback,o=t.args;switch(o.length){case 0:e();break;case 1:e(o[0]);break;case 2:e(o[0],o[1]);break;case 3:e(o[0],o[1],o[2]);break;default:e.apply(n,o);}}function a(t){if(u)setTimeout(a,0,t);else{var e=l[t];if(e){u=!0;try{i(e);}finally{r(t),u=!1;}}}}if(!t.setImmediate){var s,c=1,l={},u=!1,f=t.document,d=Object.getPrototypeOf&&Object.getPrototypeOf(t);d=d&&d.setTimeout?d:t,"[object process]"==={}.toString.call(t.process)?function(){s=function(t){e.nextTick(function(){a(t);});};}():function(){if(t.postMessage&&!t.importScripts){var e=!0,n=t.onmessage;return t.onmessage=function(){e=!1;},t.postMessage("","*"),t.onmessage=n,e}}()?function(){var e="setImmediate$"+Math.random()+"$",n=function(n){n.source===t&&"string"==typeof n.data&&0===n.data.indexOf(e)&&a(+n.data.slice(e.length));};t.addEventListener?t.addEventListener("message",n,!1):t.attachEvent("onmessage",n),s=function(n){t.postMessage(e+n,"*");};}():t.MessageChannel?function(){var t=new MessageChannel;t.port1.onmessage=function(t){a(t.data);},s=function(e){t.port2.postMessage(e);};}():f&&"onreadystatechange"in f.createElement("script")?function(){var t=f.documentElement;s=function(e){var n=f.createElement("script");n.onreadystatechange=function(){a(e),n.onreadystatechange=null,t.removeChild(n),n=null;},t.appendChild(n);};}():function(){s=function(t){setTimeout(a,0,t);};}(),d.setImmediate=o,d.clearImmediate=r;}}("undefined"==typeof self?void 0===t?this:t:self);}).call(e,n(7),n(20));},function(t,e){function n(){throw new Error("setTimeout has not been defined")}function o(){throw new Error("clearTimeout has not been defined")}function r(t){if(u===setTimeout)return setTimeout(t,0);if((u===n||!u)&&setTimeout)return u=setTimeout,setTimeout(t,0);try{return u(t,0)}catch(e){try{return u.call(null,t,0)}catch(e){return u.call(this,t,0)}}}function i(t){if(f===clearTimeout)return clearTimeout(t);if((f===o||!f)&&clearTimeout)return f=clearTimeout,clearTimeout(t);try{return f(t)}catch(e){try{return f.call(null,t)}catch(e){return f.call(this,t)}}}function a(){b&&p&&(b=!1,p.length?m=p.concat(m):v=-1,m.length&&s());}function s(){if(!b){var t=r(a);b=!0;for(var e=m.length;e;){for(p=m,m=[];++v<e;)p&&p[v].run();v=-1,e=m.length;}p=null,b=!1,i(t);}}function c(t,e){this.fun=t,this.array=e;}function l(){}var u,f,d=t.exports={};!function(){try{u="function"==typeof setTimeout?setTimeout:n;}catch(t){u=n;}try{f="function"==typeof clearTimeout?clearTimeout:o;}catch(t){f=o;}}();var p,m=[],b=!1,v=-1;d.nextTick=function(t){var e=new Array(arguments.length-1);if(arguments.length>1)for(var n=1;n<arguments.length;n++)e[n-1]=arguments[n];m.push(new c(t,e)),1!==m.length||b||r(s);},c.prototype.run=function(){this.fun.apply(null,this.array);},d.title="browser",d.browser=!0,d.env={},d.argv=[],d.version="",d.versions={},d.on=l,d.addListener=l,d.once=l,d.off=l,d.removeListener=l,d.removeAllListeners=l,d.emit=l,d.prependListener=l,d.prependOnceListener=l,d.listeners=function(t){return []},d.binding=function(t){throw new Error("process.binding is not supported")},d.cwd=function(){return "/"},d.chdir=function(t){throw new Error("process.chdir is not supported")},d.umask=function(){return 0};},function(t,e,n){n(22).polyfill();},function(t,e,n){function o(t,e){if(void 0===t||null===t)throw new TypeError("Cannot convert first argument to object");for(var n=Object(t),o=1;o<arguments.length;o++){var r=arguments[o];if(void 0!==r&&null!==r)for(var i=Object.keys(Object(r)),a=0,s=i.length;a<s;a++){var c=i[a],l=Object.getOwnPropertyDescriptor(r,c);void 0!==l&&l.enumerable&&(n[c]=r[c]);}}return n}function r(){Object.assign||Object.defineProperty(Object,"assign",{enumerable:!1,configurable:!0,writable:!0,value:o});}t.exports={assign:o,polyfill:r};},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(24),r=n(6),i=n(5),a=n(36),s=function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];if("undefined"!=typeof window){var n=a.getOpts.apply(void 0,t);return new Promise(function(t,e){i.default.promise={resolve:t,reject:e},o.default(n),setTimeout(function(){r.openModal();});})}};s.close=r.onAction,s.getState=r.getState,s.setActionValue=i.setActionValue,s.stopLoading=r.stopLoading,s.setDefaults=a.setDefaults,e.default=s;},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(1),r=n(0),i=r.default.MODAL,a=n(4),s=n(34),c=n(35),l=n(1);e.init=function(t){o.getNode(i)||(document.body||l.throwErr("You can only use SweetAlert AFTER the DOM has loaded!"),s.default(),a.default()),a.initModalContent(t),c.default(t);},e.default=e.init;},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(0),r=o.default.MODAL;e.modalMarkup='\n  <div class="'+r+'" role="dialog" aria-modal="true"></div>',e.default=e.modalMarkup;},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(0),r=o.default.OVERLAY,i='<div \n    class="'+r+'"\n    tabIndex="-1">\n  </div>';e.default=i;},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(0),r=o.default.ICON;e.errorIconMarkup=function(){var t=r+"--error",e=t+"__line";return '\n    <div class="'+t+'__x-mark">\n      <span class="'+e+" "+e+'--left"></span>\n      <span class="'+e+" "+e+'--right"></span>\n    </div>\n  '},e.warningIconMarkup=function(){var t=r+"--warning";return '\n    <span class="'+t+'__body">\n      <span class="'+t+'__dot"></span>\n    </span>\n  '},e.successIconMarkup=function(){var t=r+"--success";return '\n    <span class="'+t+"__line "+t+'__line--long"></span>\n    <span class="'+t+"__line "+t+'__line--tip"></span>\n\n    <div class="'+t+'__ring"></div>\n    <div class="'+t+'__hide-corners"></div>\n  '};},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(0),r=o.default.CONTENT;e.contentMarkup='\n  <div class="'+r+'">\n\n  </div>\n';},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(0),r=o.default.BUTTON_CONTAINER,i=o.default.BUTTON,a=o.default.BUTTON_LOADER;e.buttonMarkup='\n  <div class="'+r+'">\n\n    <button\n      class="'+i+'"\n    ></button>\n\n    <div class="'+a+'">\n      <div></div>\n      <div></div>\n      <div></div>\n    </div>\n\n  </div>\n';},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(4),r=n(2),i=n(0),a=i.default.ICON,s=i.default.ICON_CUSTOM,c=["error","warning","success","info"],l={error:r.errorIconMarkup(),warning:r.warningIconMarkup(),success:r.successIconMarkup()},u=function(t,e){var n=a+"--"+t;e.classList.add(n);var o=l[t];o&&(e.innerHTML=o);},f=function(t,e){e.classList.add(s);var n=document.createElement("img");n.src=t,e.appendChild(n);},d=function(t){if(t){var e=o.injectElIntoModal(r.iconMarkup);c.includes(t)?u(t,e):f(t,e);}};e.default=d;},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(2),r=n(4),i=function(t){navigator.userAgent.includes("AppleWebKit")&&(t.style.display="none",t.offsetHeight,t.style.display="");};e.initTitle=function(t){if(t){var e=r.injectElIntoModal(o.titleMarkup);e.textContent=t,i(e);}},e.initText=function(t){if(t){var e=document.createDocumentFragment();t.split("\n").forEach(function(t,n,o){e.appendChild(document.createTextNode(t)),n<o.length-1&&e.appendChild(document.createElement("br"));});var n=r.injectElIntoModal(o.textMarkup);n.appendChild(e),i(n);}};},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(1),r=n(4),i=n(0),a=i.default.BUTTON,s=i.default.DANGER_BUTTON,c=n(3),l=n(2),u=n(6),f=n(5),d=function(t,e,n){var r=e.text,i=e.value,d=e.className,p=e.closeModal,m=o.stringToNode(l.buttonMarkup),b=m.querySelector("."+a),v=a+"--"+t;if(b.classList.add(v),d){(Array.isArray(d)?d:d.split(" ")).filter(function(t){return t.length>0}).forEach(function(t){b.classList.add(t);});}n&&t===c.CONFIRM_KEY&&b.classList.add(s),b.textContent=r;var g={};return g[t]=i,f.setActionValue(g),f.setActionOptionsFor(t,{closeModal:p}),b.addEventListener("click",function(){return u.onAction(t)}),m},p=function(t,e){var n=r.injectElIntoModal(l.footerMarkup);for(var o in t){var i=t[o],a=d(o,i,e);i.visible&&n.appendChild(a);}0===n.children.length&&n.remove();};e.default=p;},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(3),r=n(4),i=n(2),a=n(5),s=n(6),c=n(0),l=c.default.CONTENT,u=function(t){t.addEventListener("input",function(t){var e=t.target,n=e.value;a.setActionValue(n);}),t.addEventListener("keyup",function(t){if("Enter"===t.key)return s.onAction(o.CONFIRM_KEY)}),setTimeout(function(){t.focus(),a.setActionValue("");},0);},f=function(t,e,n){var o=document.createElement(e),r=l+"__"+e;o.classList.add(r);for(var i in n){var a=n[i];o[i]=a;}"input"===e&&u(o),t.appendChild(o);},d=function(t){if(t){var e=r.injectElIntoModal(i.contentMarkup),n=t.element,o=t.attributes;"string"==typeof n?f(e,n,o):e.appendChild(n);}};e.default=d;},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(1),r=n(2),i=function(){var t=o.stringToNode(r.overlayMarkup);document.body.appendChild(t);};e.default=i;},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(5),r=n(6),i=n(1),a=n(3),s=n(0),c=s.default.MODAL,l=s.default.BUTTON,u=s.default.OVERLAY,f=function(t){t.preventDefault(),v();},d=function(t){t.preventDefault(),g();},p=function(t){if(o.default.isOpen)switch(t.key){case"Escape":return r.onAction(a.CANCEL_KEY)}},m=function(t){if(o.default.isOpen)switch(t.key){case"Tab":return f(t)}},b=function(t){if(o.default.isOpen)return "Tab"===t.key&&t.shiftKey?d(t):void 0},v=function(){var t=i.getNode(l);t&&(t.tabIndex=0,t.focus());},g=function(){var t=i.getNode(c),e=t.querySelectorAll("."+l),n=e.length-1,o=e[n];o&&o.focus();},h=function(t){t[t.length-1].addEventListener("keydown",m);},w=function(t){t[0].addEventListener("keydown",b);},y=function(){var t=i.getNode(c),e=t.querySelectorAll("."+l);e.length&&(h(e),w(e));},x=function(t){if(i.getNode(u)===t.target)return r.onAction(a.CANCEL_KEY)},_=function(t){var e=i.getNode(u);e.removeEventListener("click",x),t&&e.addEventListener("click",x);},k=function(t){o.default.timer&&clearTimeout(o.default.timer),t&&(o.default.timer=window.setTimeout(function(){return r.onAction(a.CANCEL_KEY)},t));},O=function(t){t.closeOnEsc?document.addEventListener("keyup",p):document.removeEventListener("keyup",p),t.dangerMode?v():g(),y(),_(t.closeOnClickOutside),k(t.timer);};e.default=O;},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(1),r=n(3),i=n(37),a=n(38),s={title:null,text:null,icon:null,buttons:r.defaultButtonList,content:null,className:null,closeOnClickOutside:!0,closeOnEsc:!0,dangerMode:!1,timer:null},c=Object.assign({},s);e.setDefaults=function(t){c=Object.assign({},s,t);};var l=function(t){var e=t&&t.button,n=t&&t.buttons;return void 0!==e&&void 0!==n&&o.throwErr("Cannot set both 'button' and 'buttons' options!"),void 0!==e?{confirm:e}:n},u=function(t){return o.ordinalSuffixOf(t+1)},f=function(t,e){o.throwErr(u(e)+" argument ('"+t+"') is invalid");},d=function(t,e){var n=t+1,r=e[n];o.isPlainObject(r)||void 0===r||o.throwErr("Expected "+u(n)+" argument ('"+r+"') to be a plain object");},p=function(t,e){var n=t+1,r=e[n];void 0!==r&&o.throwErr("Unexpected "+u(n)+" argument ("+r+")");},m=function(t,e,n,r){var i=typeof e,a="string"===i,s=e instanceof Element;if(a){if(0===n)return {text:e};if(1===n)return {text:e,title:r[0]};if(2===n)return d(n,r),{icon:e};f(e,n);}else{if(s&&0===n)return d(n,r),{content:e};if(o.isPlainObject(e))return p(n,r),e;f(e,n);}};e.getOpts=function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];var n={};t.forEach(function(e,o){var r=m(0,e,o,t);Object.assign(n,r);});var o=l(n);n.buttons=r.getButtonListOpts(o),delete n.button,n.content=i.getContentOpts(n.content);var u=Object.assign({},s,c,n);return Object.keys(u).forEach(function(t){a.DEPRECATED_OPTS[t]&&a.logDeprecation(t);}),u};},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0});var o=n(1),r={element:"input",attributes:{placeholder:""}};e.getContentOpts=function(t){var e={};return o.isPlainObject(t)?Object.assign(e,t):t instanceof Element?{element:t}:"input"===t?r:null};},function(t,e,n){Object.defineProperty(e,"__esModule",{value:!0}),e.logDeprecation=function(t){var n=e.DEPRECATED_OPTS[t],o=n.onlyRename,r=n.replacement,i=n.subOption,a=n.link,s=o?"renamed":"deprecated",c='SweetAlert warning: "'+t+'" option has been '+s+".";if(r){c+=" Please use"+(i?' "'+i+'" in ':" ")+'"'+r+'" instead.';}var l="https://sweetalert.js.org";c+=a?" More details: "+l+a:" More details: "+l+"/guides/#upgrading-from-1x",console.warn(c);},e.DEPRECATED_OPTS={type:{replacement:"icon",link:"/docs/#icon"},imageUrl:{replacement:"icon",link:"/docs/#icon"},customClass:{replacement:"className",onlyRename:!0,link:"/docs/#classname"},imageSize:{},showCancelButton:{replacement:"buttons",link:"/docs/#buttons"},showConfirmButton:{replacement:"button",link:"/docs/#button"},confirmButtonText:{replacement:"button",link:"/docs/#button"},confirmButtonColor:{},cancelButtonText:{replacement:"buttons",link:"/docs/#buttons"},closeOnConfirm:{replacement:"button",subOption:"closeModal",link:"/docs/#button"},closeOnCancel:{replacement:"buttons",subOption:"closeModal",link:"/docs/#buttons"},showLoaderOnConfirm:{replacement:"buttons"},animation:{},inputType:{replacement:"content",link:"/docs/#content"},inputValue:{replacement:"content",link:"/docs/#content"},inputPlaceholder:{replacement:"content",link:"/docs/#content"},html:{replacement:"content",link:"/docs/#content"},allowEscapeKey:{replacement:"closeOnEsc",onlyRename:!0,link:"/docs/#closeonesc"},allowClickOutside:{replacement:"closeOnClickOutside",onlyRename:!0,link:"/docs/#closeonclickoutside"}};}])});
    });

    var swal = unwrapExports(sweetalert_min);
    var sweetalert_min_1 = sweetalert_min.swal;

    class HacsRepositoryButton extends LitElement {
        static get styles() {
            return HacsStyle;
        }
    }
    __decorate([
        property()
    ], HacsRepositoryButton.prototype, "hass", void 0);
    __decorate([
        property()
    ], HacsRepositoryButton.prototype, "repository", void 0);
    __decorate([
        property()
    ], HacsRepositoryButton.prototype, "status", void 0);

    let HacsButtonAddToLovelace = class HacsButtonAddToLovelace extends HacsRepositoryButton {
        constructor() {
            super(...arguments);
            this.logger = new Logger("add_to_lovelace");
        }
        render() {
            if (!this.repository.installed)
                return html ``;
            if (this.repository.javascript_type === null)
                return html ``;
            return html `
      <mwc-button @click=${this.RepositoryAddToLovelace}>
        Add to Lovelace
      </mwc-button>
    `;
        }
        RepositoryAddToLovelace() {
            swal(localize("confirm.add_to_lovelace"), {
                buttons: [localize("confirm.no"), localize("confirm.yes")]
            }).then(value => {
                if (value !== null) {
                    this.hass.connection
                        .sendMessagePromise({
                        type: "lovelace/config",
                        force: false
                    })
                        .then(resp => {
                        var currentConfig = resp;
                        const cardConfig = {
                            type: this.repository.javascript_type,
                            url: `/community_plugin/${this.repository.full_name.split("/")[1]}/${this.repository.file_name}`
                        };
                        if (currentConfig.resources)
                            currentConfig.resources.push(cardConfig);
                        else
                            currentConfig.resources = [cardConfig];
                        this.hass.callWS({
                            type: "lovelace/config/save",
                            config: currentConfig
                        });
                    }, err => {
                        this.logger.error(err);
                    });
                }
            });
        }
    };
    HacsButtonAddToLovelace = __decorate([
        customElement("hacs-button-add-to-lovelace")
    ], HacsButtonAddToLovelace);

    let HacsButtonChangelog = class HacsButtonChangelog extends HacsRepositoryButton {
        render() {
            if (!this.repository.pending_upgrade)
                return html ``;
            var URL = `https://github.com/${this.repository.full_name}/releases`;
            if (this.repository.version_or_commit === "commit") {
                URL = `https://github.com/${this.repository.full_name}/compare/${this.repository.installed_version}...${this.repository.available_version}`;
            }
            return html `
      <a href="${String(URL)}" rel="noreferrer" target="_blank">
        <mwc-button>
          ${localize(`repository.changelog`)}
        </mwc-button>
      </a>
    `;
        }
        RepositoryInstall() {
            RepositoryWebSocketAction(this.hass, this.repository.id, "set_state", "installing");
            RepositoryWebSocketAction(this.hass, this.repository.id, "uninstall");
        }
    };
    HacsButtonChangelog = __decorate([
        customElement("hacs-button-changelog")
    ], HacsButtonChangelog);

    let HacsButtonClearNew = class HacsButtonClearNew extends HacsRepositoryButton {
        render() {
            return html `
      <mwc-button @click=${this.ExecuteAction}>
        ${localize(`store.clear_new`)}
      </mwc-button>
    `;
        }
        ExecuteAction() {
            var message = {
                type: "hacs/settings",
                action: "clear_new",
                category: this.category
            };
            this.hass.connection.sendMessage(message);
        }
    };
    __decorate([
        property()
    ], HacsButtonClearNew.prototype, "category", void 0);
    HacsButtonClearNew = __decorate([
        customElement("hacs-button-clear-new")
    ], HacsButtonClearNew);

    let HacsButtonGoToIntegrations = class HacsButtonGoToIntegrations extends HacsRepositoryButton {
        render() {
            return html `
      <mwc-button @click=${this.GoToIntegrations}>
        ${this.hacs.localize("repository.goto_integrations")}
      </mwc-button>
    `;
        }
        GoToIntegrations() {
            this.dispatchEvent(new CustomEvent("hacs-location-change", {
                detail: { value: "/config/integrations/dashboard", force: true },
                bubbles: true,
                composed: true
            }));
        }
    };
    __decorate([
        property()
    ], HacsButtonGoToIntegrations.prototype, "hacs", void 0);
    HacsButtonGoToIntegrations = __decorate([
        customElement("hacs-button-goto-integrations")
    ], HacsButtonGoToIntegrations);

    let HacsButtonMainAction = class HacsButtonMainAction extends HacsRepositoryButton {
        constructor() {
            super(...arguments);
            this.pathExists = false;
            this.logger = new Logger("main_action");
        }
        firstUpdated() {
            let path = this.repository.local_path;
            if (this.repository.category === "theme") {
                path = `${path}/${this.repository.file_name}`;
            }
            this.hass.connection
                .sendMessagePromise({
                type: "hacs/check_path",
                path: path
            })
                .then(resp => {
                this.pathExists = resp["exist"];
            }, err => {
                this.logger.error("(hacs/check_path) Message failed!");
                this.logger.error(err);
            });
        }
        render() {
            const label = localize(`repository.${this.repository.main_action.toLowerCase()}`);
            if (this.status.background_task) {
                return html `
        <mwc-button
          class="disabled-button"
          title="${localize("confirm.bg_task")}"
          @click=${this.disabledAction}
        >
          ${label}
        </mwc-button>
      `;
            }
            return html `
      <mwc-button @click=${this.RepositoryInstall}>
        ${this.repository.state == "installing"
            ? html `
              <paper-spinner active></paper-spinner>
            `
            : html `
              ${label}
            `}
      </mwc-button>
    `;
        }
        disabledAction() {
            swal(localize("confirm.bg_task"));
        }
        RepositoryInstall() {
            if (this.pathExists && !this.repository.installed) {
                let path = this.repository.local_path;
                if (this.repository.category === "theme") {
                    path = `${path}/${this.repository.file_name}`;
                }
                swal(localize("confirm.exist", "{item}", path) +
                    "\n" +
                    localize("confirm.overwrite") +
                    "\n" +
                    localize("confirm.continue"), {
                    buttons: [localize("confirm.no"), localize("confirm.yes")]
                }).then(value => {
                    if (value !== null) {
                        this.ExecuteAction();
                    }
                });
            }
            else
                this.ExecuteAction();
        }
        ExecuteAction() {
            RepositoryWebSocketAction(this.hass, this.repository.id, "set_state", "installing");
            RepositoryWebSocketAction(this.hass, this.repository.id, "install");
        }
    };
    __decorate([
        property()
    ], HacsButtonMainAction.prototype, "pathExists", void 0);
    HacsButtonMainAction = __decorate([
        customElement("hacs-button-main-action")
    ], HacsButtonMainAction);

    let HacsButtonOpenPlugin = class HacsButtonOpenPlugin extends HacsRepositoryButton {
        render() {
            if (this.repository.category != "plugin")
                return html ``;
            if (!this.repository.installed)
                return html ``;
            const path = this.repository.local_path.split("/");
            return html `
      <a
        href="/community_plugin/${path.pop()}/${this.repository.file_name}"
        target="_blank"
      >
        <mwc-button>
          ${localize(`repository.open_plugin`)}
        </mwc-button>
      </a>
    `;
        }
    };
    HacsButtonOpenPlugin = __decorate([
        customElement("hacs-button-open-plugin")
    ], HacsButtonOpenPlugin);

    let HacsButtonOpenRepository = class HacsButtonOpenRepository extends HacsRepositoryButton {
        render() {
            return html `
      <a
        href="https://github.com/${this.repository.full_name}"
        rel="noreferrer"
        target="_blank"
      >
        <mwc-button>
          ${localize(`repository.repository`)}
        </mwc-button>
      </a>
    `;
        }
    };
    HacsButtonOpenRepository = __decorate([
        customElement("hacs-button-open-repository")
    ], HacsButtonOpenRepository);

    let HacsButtonRestartHomeAssistant = class HacsButtonRestartHomeAssistant extends HacsRepositoryButton {
        render() {
            return html `
      <mwc-button @click=${this.RestartHomeAssistant}>
        ${this.hacs.localize("repository.restart_home_assistant")}
      </mwc-button>
    `;
        }
        static get styles() {
            return [
                css `
        mwc-button {
          --mdc-theme-primary: var(--google-red-500);
        }
      `
            ];
        }
        RestartHomeAssistant() {
            swal(this.hacs.localize("confirm.restart_home_assistant"), {
                buttons: [
                    this.hacs.localize("confirm.no"),
                    this.hacs.localize("confirm.yes")
                ]
            }).then(value => {
                if (value !== null) {
                    this.hass.callService("homeassistant", "restart");
                    swal(this.hacs.localize("confirm.home_assistant_is_restarting"));
                }
            });
        }
    };
    __decorate([
        property()
    ], HacsButtonRestartHomeAssistant.prototype, "hacs", void 0);
    __decorate([
        property()
    ], HacsButtonRestartHomeAssistant.prototype, "route", void 0);
    HacsButtonRestartHomeAssistant = __decorate([
        customElement("hacs-button-restart-home-assistant")
    ], HacsButtonRestartHomeAssistant);

    let HacsButtonUninstall = class HacsButtonUninstall extends HacsRepositoryButton {
        render() {
            if (!this.repository.installed)
                return html ``;
            const label = localize("repository.uninstall");
            if (this.status.background_task) {
                return html `
        <mwc-button
          class="disabled-button"
          title="${localize("confirm.bg_task")}"
          @click=${this.disabledAction}
        >
          ${label}
        </mwc-button>
      `;
            }
            return html `
        <mwc-button @click=${this.RepositoryUnInstall}">
            ${this.repository.state == "uninstalling"
            ? html `
                    <paper-spinner active></paper-spinner>
                  `
            : html `
                    ${label}
                  `}
        </mwc-button>
        `;
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        mwc-button {
          --mdc-theme-primary: var(--google-red-500);
        }
      `
            ];
        }
        disabledAction() {
            swal(localize("confirm.bg_task"));
        }
        RepositoryUnInstall() {
            swal(localize("confirm.uninstall", "{item}", this.repository.name), {
                buttons: [localize("confirm.no"), localize("confirm.yes")]
            }).then(value => {
                if (value !== null) {
                    this.ExecuteAction();
                }
            });
        }
        ExecuteAction() {
            RepositoryWebSocketAction(this.hass, this.repository.id, "set_state", "uninstalling");
            if (this.repository.category === "plugin" &&
                this.status.lovelace_mode === "storage") {
                this.RepositoryRemoveFromLovelace();
            }
            RepositoryWebSocketAction(this.hass, this.repository.id, "uninstall");
        }
        RepositoryRemoveFromLovelace() {
            this.hass.connection
                .sendMessagePromise({
                type: "lovelace/config",
                force: false
            })
                .then(resp => {
                const currentConfig = resp;
                const url = `/community_plugin/${this.repository.full_name.split("/")[1]}/${this.repository.file_name}`;
                if (currentConfig.resources) {
                    const resources = currentConfig.resources.filter((element) => {
                        if (element.url === url) {
                            return false;
                        }
                        else
                            return true;
                    });
                    currentConfig.resources = resources;
                    this.hass.callWS({
                        type: "lovelace/config/save",
                        config: currentConfig
                    });
                }
            });
        }
    };
    HacsButtonUninstall = __decorate([
        customElement("hacs-button-uninstall")
    ], HacsButtonUninstall);

    let HacsRepositoryBanner = class HacsRepositoryBanner extends LitElement {
        static get styles() {
            return [
                HacsStyle,
                css `
        ha-card {
          width: 90%;
          margin-left: 5%;
        }
        ha-card.alert {
          background-color: var(
            --hacs-status-pending-restart,
            var(--google-red-500)
          );
          color: var(--text-primary-color);
        }
        ha-card.warning {
          background-color: var(--hacs-status-pending-update);
          color: var(--primary-text-color);
        }
        ha-card.info {
          background-color: var(--primary-background-color);
          color: var(--primary-text-color);
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], HacsRepositoryBanner.prototype, "hacs", void 0);
    __decorate([
        property()
    ], HacsRepositoryBanner.prototype, "configuration", void 0);
    __decorate([
        property()
    ], HacsRepositoryBanner.prototype, "hass", void 0);
    __decorate([
        property()
    ], HacsRepositoryBanner.prototype, "lovelaceconfig", void 0);
    __decorate([
        property()
    ], HacsRepositoryBanner.prototype, "repository", void 0);
    __decorate([
        property()
    ], HacsRepositoryBanner.prototype, "route", void 0);
    __decorate([
        property()
    ], HacsRepositoryBanner.prototype, "status", void 0);
    HacsRepositoryBanner = __decorate([
        customElement("hacs-repository-banner")
    ], HacsRepositoryBanner);

    let RepositoryBannerIntegrationFirstInstall = class RepositoryBannerIntegrationFirstInstall extends HacsRepositoryBanner {
        render() {
            const title = this.hacs.localize("repository_banner.restart_pending");
            return html `
      <ha-card class="info" .header="${title}">
        <div class="card-content">
          ${this.hacs.localize("repository_banner.restart")}
          </br></br>
          ${this.hacs.localize("repository_banner.restart")}
          ${this.hacs.localize("repository_banner.config_flow")}
          </br>
          ${this.hacs.localize("repository_banner.no_restart_required")} 🎉
        </div>
        <div class="card-actions">
          <hacs-button-restart-home-assistant
            .hacs=${this.hacs}
            .hass=${this.hass}
            .route=${this.route}
          ></hacs-button-restart-home-assistant>
          <hacs-button-goto-integrations
            .hacs=${this.hacs}
            .route=${this.route}
          ></hacs-button-goto-integrations>
        </div>
      </ha-card>
    `;
        }
    };
    RepositoryBannerIntegrationFirstInstall = __decorate([
        customElement("hacs-repository-banner-integration-first-install")
    ], RepositoryBannerIntegrationFirstInstall);

    let RepositoryBannerIntegrationPendingRestart = class RepositoryBannerIntegrationPendingRestart extends HacsRepositoryBanner {
        render() {
            const title = this.hacs.localize("repository_banner.restart_pending");
            return html `
      <ha-card class="info" .header="${title}">
        <div class="card-content">
          ${this.hacs.localize("repository_banner.restart")}
        </div>
        <div class="card-actions">
          <hacs-button-restart-home-assistant
            .hacs=${this.hacs}
            .hass=${this.hass}
            .repository=${this.repository}
            .route=${this.route}
          ></hacs-button-restart-home-assistant>
        </div>
      </ha-card>
    `;
        }
    };
    RepositoryBannerIntegrationPendingRestart = __decorate([
        customElement("hacs-repository-banner-integration-pending-restart")
    ], RepositoryBannerIntegrationPendingRestart);

    let RepositoryBannerPluginNotLoaded = class RepositoryBannerPluginNotLoaded extends HacsRepositoryBanner {
        render() {
            const title = this.hacs.localize("repository_banner.not_loaded");
            const loaded = AddedToLovelace(this.repository, this.lovelaceconfig, this.status);
            if (loaded)
                return html ``;
            return html `
      <ha-card class="info" .header="${title}">
        <div class="card-content">
          ${this.hacs.localize("repository_banner.plugin_not_loaded")}
        </div>
        <div class="card-actions">
          <hacs-button-add-to-lovelace
            .hacs=${this.hacs}
            .hass=${this.hass}
            .repository=${this.repository}
            .route=${this.route}
          ></hacs-button-add-to-lovelace>
        </div>
      </ha-card>
    `;
        }
    };
    RepositoryBannerPluginNotLoaded = __decorate([
        customElement("hacs-repository-banner-plugin-not-loaded")
    ], RepositoryBannerPluginNotLoaded);

    let HacsBody = class HacsBody extends LitElement {
        render() {
            return html `
      <div class="hacs-body">
        <slot></slot>
      </div>
    `;
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        .hacs-body {
          width: 95%;
          margin-left: 2.5%;
          margin-top: 2.5%;
          margin-bottom: 2.5%;
        }
      `
            ];
        }
    };
    HacsBody = __decorate([
        customElement("hacs-body")
    ], HacsBody);

    let HacsLink = class HacsLink extends LitElement {
        constructor() {
            super(...arguments);
            this.ext = true;
        }
        render() {
            return html `
      <a
        href="${this.url}"
        target="${this.ext ? "_blank" : "_self"}"
        rel="${this.ext ? "noreferrer" : ""}"
      >
        <slot></slot>
      </a>
    `;
        }
        static get styles() {
            return [
                css `
        a {
          color: var(--link-text-color, var(--accent-color));
          text-decoration: none;
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], HacsLink.prototype, "url", void 0);
    __decorate([
        property()
    ], HacsLink.prototype, "ext", void 0);
    HacsLink = __decorate([
        customElement("hacs-link")
    ], HacsLink);

    let HacsProgressbar = class HacsProgressbar extends LitElement {
        constructor() {
            super(...arguments);
            this.active = true;
        }
        render() {
            if (!this.active)
                return html ``;
            return html `
      <paper-progress indeterminate></paper-progress>
    `;
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        paper-progress {
          width: 100%;
          --paper-progress-active-color: var(--accent-color);
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], HacsProgressbar.prototype, "active", void 0);
    HacsProgressbar = __decorate([
        customElement("hacs-progressbar")
    ], HacsProgressbar);

    function AboutHacs(hacs, repositories, configuration) {
        const content = document.createElement("div");
        content.style.color = `var(--primary-text-color)`;
        content.innerHTML = hacs.markdown(`
### HACS (Home Assistant Community Store)

**Integration ${hacs.localize("common.version").toLowerCase()}:**| ${configuration.version}
-- | --
**Frontend ${hacs
        .localize("common.version")
        .toLowerCase()}:** | ${version}
**${hacs.localize("common.repositories")}:** | ${repositories.length || 0}
  `);
        return content;
    }

    let HacsMenu = class HacsMenu extends LitElement {
        render() {
            return html `
      <paper-menu-button
        horizontal-align="right"
        role="group"
        aria-haspopup="true"
        vertical-align="top"
        aria-disabled="false"
      >
        <paper-icon-button
          icon="hass:dots-vertical"
          slot="dropdown-trigger"
          role="button"
        ></paper-icon-button>
        <paper-listbox
          slot="dropdown-content"
          role="listbox"
          tabindex="0"
          dir="rtl"
        >
          <paper-item @click=${this.openHelp}
            >${this.hacs.localize("common.documentation")}
          </paper-item>

          <paper-item @click=${this.ReloadData}>
            ${this.hacs.localize("settings.reload_data")}
          </paper-item>

          <paper-item @click=${this.ReloadWindow}>
            ${this.hacs.localize("settings.reload_window")}
          </paper-item>

          ${this.location.includes("installed")
            ? html `
                <paper-item @click=${this.UpgradeAll} class="uninstall-button">
                  ${this.hacs.localize("settings.upgrade_all")}
                </paper-item>
              `
            : ""}

          <a href="https://github.com/hacs" target="_blank" rel="noreferrer">
            <paper-item>
              ${this.hacs.localize(`settings.hacs_repo`)}
            </paper-item>
          </a>

          <a
            href="https://hacs.xyz/docs/issues"
            target="_blank"
            rel="noreferrer"
          >
            <paper-item>
              ${this.hacs.localize(`repository.open_issue`)}
            </paper-item>
          </a>
          ${!this.location.includes("settings") &&
            !this.location.includes("repository")
            ? html `
                <paper-item>
                  <ha-switch
                    .checked=${this.configuration.frontend_mode === "Table"}
                    @change=${this.SetFeStyle}
                    ><div class="switch-text">Table</div></ha-switch
                  >
                </paper-item>
                <paper-item>
                  <ha-switch
                    .checked=${this.configuration.frontend_compact}
                    @change=${this.SetFeCompact}
                    ><div class="switch-text">Compact</div>
                  </ha-switch>
                </paper-item>
              `
            : ""}

          <paper-item @click=${this.openAbout}
            >${this.hacs.localize("common.about")}
          </paper-item>
        </paper-listbox>
      </paper-menu-button>
    `;
        }
        disabledAction() {
            swal(this.hacs.localize("confirm.bg_task"));
        }
        SetFeStyle() {
            this.hass.connection.sendMessage({
                type: "hacs/settings",
                action: `set_fe_${this.configuration.frontend_mode !== "Table" ? "table" : "grid"}`
            });
        }
        SetFeCompact() {
            this.hass.connection.sendMessage({
                type: "hacs/settings",
                action: `set_fe_compact_${String(this.configuration.frontend_compact).toLocaleLowerCase()}`
            });
        }
        ReloadWindow() {
            this.dispatchEvent(new CustomEvent("hacs-force-reload", {
                detail: { force: true },
                bubbles: true,
                composed: true
            }));
        }
        ReloadData() {
            if (this.status.background_task) {
                this.disabledAction();
                return;
            }
            swal(`${this.hacs.localize(`confirm.reload_data`)}\n${this.hacs.localize("confirm.continue")}`, {
                buttons: [
                    this.hacs.localize("confirm.no"),
                    this.hacs.localize("confirm.yes")
                ]
            }).then(value => {
                if (value !== null) {
                    this.hass.connection.sendMessage({
                        type: "hacs/settings",
                        action: "reload_data"
                    });
                }
            });
        }
        UpgradeAll() {
            if (this.status.background_task) {
                this.disabledAction();
                return;
            }
            var elements = [];
            this.repositories.forEach(element => {
                if (element.pending_upgrade)
                    elements.push(element);
            });
            if (elements.length > 0) {
                var msg = this.hacs.localize(`confirm.upgrade_all`) + "\n\n";
                elements.forEach(element => {
                    msg += `${element.name}: ${element.installed_version} -> ${element.available_version}\n`;
                });
                msg += `\n${this.hacs.localize("confirm.continue")}`;
                swal(msg, {
                    buttons: [
                        this.hacs.localize("confirm.no"),
                        this.hacs.localize("confirm.yes")
                    ]
                }).then(value => {
                    if (value !== null) {
                        this.hass.connection.sendMessage({
                            type: "hacs/settings",
                            action: "upgrade_all"
                        });
                    }
                });
            }
            else {
                swal(this.hacs.localize(`confirm.no_upgrades`), {
                    buttons: [this.hacs.localize("confirm.ok")]
                });
            }
        }
        openAbout() {
            swal({
                buttons: [false],
                content: AboutHacs(this.hacs, this.repositories, this.configuration)
            });
        }
        openHelp() {
            const base = "https://hacs.xyz/docs/navigation/";
            const fallback = "https://hacs.xyz/docs/basic/getting_started/";
            var location = window.location.pathname.split("/")[2];
            if (this.hacs.isnullorempty(location)) {
                window.open(fallback, "Documentation", "noreferrer");
                return;
            }
            if (["integration", "plugin", "appdaemon", "python_script", "theme"].includes(location))
                location = "stores";
            window.open(`${base}${location}`, "Documentation", "noreferrer");
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        paper-listbox {
          top: 0px;
          overflow: hidden;
        }
        a {
          color: var(--primary-text-color);
        }
        ha-icon {
          cursor: pointer;
          float: right;
        }
        ha-switch {
          right: -24px;
        }
        .switch-text {
          margin-right: 8px;
        }
        .dropdown-content {
          overflow: hidden;
          right: 0;
          top: 0;
        }
        .extended {
          display: block !important;
        }
        paper-item {
          display: flex;
          font-size: 14px;
          background-color: var(
            --paper-listbox-background-color,
            var(--primary-background-color)
          );
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], HacsMenu.prototype, "location", void 0);
    __decorate([
        property()
    ], HacsMenu.prototype, "hacs", void 0);
    __decorate([
        property()
    ], HacsMenu.prototype, "hass", void 0);
    __decorate([
        property()
    ], HacsMenu.prototype, "configuration", void 0);
    __decorate([
        property()
    ], HacsMenu.prototype, "status", void 0);
    __decorate([
        property()
    ], HacsMenu.prototype, "repositories", void 0);
    HacsMenu = __decorate([
        customElement("hacs-menu")
    ], HacsMenu);

    let CustomRepositories = class CustomRepositories extends LitElement {
        constructor() {
            super(...arguments);
            this.background_task = true;
        }
        update(changedProperties) {
            super.update(changedProperties);
            if (this.hacs.configuration.debug)
                this.hacs.logger.info(changedProperties);
        }
        shouldUpdate(changedProperties) {
            changedProperties.forEach((_oldValue, propName) => {
                if (propName === "hacs") {
                    this.background_task = this.hacs.status.background_task;
                    const customrepositories = this.getCustomRepositories();
                    if (!this.custom || this.custom.length !== customrepositories.length) {
                        this.custom = customrepositories;
                    }
                }
            });
            return (changedProperties.has("custom") ||
                changedProperties.has("background_task"));
        }
        getCustomRepositories() {
            return this.hacs.repositories
                .sort((a, b) => (a.full_name > b.full_name ? 1 : -1))
                .filter(repo => {
                if (repo.custom)
                    return true;
                else
                    return false;
            });
        }
        Delete(ev) {
            let RepoID;
            let RepoFullName;
            ev.composedPath().forEach((item) => {
                if (item.RepoID) {
                    RepoID = item.RepoID;
                    RepoFullName = item.RepoFullName;
                }
            });
            swal(this.hacs.localize("confirm.delete", "{item}", RepoFullName), {
                buttons: [
                    this.hacs.localize("confirm.no"),
                    this.hacs.localize("confirm.yes")
                ]
            }).then(value => {
                if (!this.hacs.isnullorempty(value)) {
                    this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                        detail: { repo: RepoID, action: "delete" },
                        bubbles: true,
                        composed: true
                    }));
                }
            });
        }
        DeleteInstalled(ev) {
            let RepoFullName;
            ev.composedPath().forEach((item) => {
                if (item.RepoFullName) {
                    RepoFullName = item.RepoFullName;
                }
            });
            swal(this.hacs.localize("confirm.delete_installed", "{item}", RepoFullName));
        }
        Save(ev) {
            var selected = ev.composedPath()[2].children[1].selectedItem;
            if (selected === undefined) {
                swal(this.hacs.localize("settings.missing_category"));
                return;
            }
            var category = selected.category;
            var repo = ev.composedPath()[2].children[0].value;
            this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                detail: { repo: repo, action: "add", data: category },
                bubbles: true,
                composed: true
            }));
            swal(this.hacs.localize("settings.adding_new_repo", "{repo}", repo) +
                "\n" +
                this.hacs.localize("settings.adding_new_repo_category", "{category}", category));
        }
        ShowRepository(ev) {
            let RepoID;
            ev.composedPath().forEach((item) => {
                if (item.RepoID) {
                    RepoID = item.RepoID;
                }
            });
            this.dispatchEvent(new CustomEvent("hacs-location-change", {
                detail: { value: `repository/${RepoID}` },
                bubbles: true,
                composed: true
            }));
        }
        render() {
            if (this.hacs.repositories === undefined) {
                this.dispatchEvent(new CustomEvent("hacs-recreate", { bubbles: true, composed: true }));
                return html ``;
            }
            return html `
      <ha-card header="${this.hacs.localize("settings.custom_repositories")}">
        <div class="card-content">
          <div class="custom-repositories-list">
            ${this.background_task
            ? html `
                  <i class="addition"
                    >${this.hacs.localize("settings.bg_task_custom")}</i
                  >
                `
            : html `
                  ${this.custom &&
                this.custom.map(repo => html `
                          <div
                            class="row"
                            .RepoID=${repo.id}
                            .RepoFullName=${repo.full_name}
                          >
                            <paper-item class="customlistitem">
                              <div
                                @click=${this.ShowRepository}
                                class="link flexy"
                                title="${this.hacs.localize("settings.open_repository")}"
                              >
                                <div class="MobileHide">
                                  [${repo.category}]&nbsp;
                                </div>
                                ${repo.full_name}
                              </div>
                              ${repo.installed
                    ? html `
                                    <ha-icon
                                      title="${this.hacs.localize("settings.delete")}"
                                      class="listicon disabled"
                                      icon="mdi:delete"
                                      @click=${this.DeleteInstalled}
                                    ></ha-icon>
                                  `
                    : html `
                                    <ha-icon
                                      title="${this.hacs.localize("settings.delete")}"
                                      class="listicon"
                                      icon="mdi:delete"
                                      @click=${this.Delete}
                                    ></ha-icon>
                                  `}
                            </paper-item>
                          </div>
                        `)}
                `}
          </div>
        </div>
        ${this.hacs.status.background_task
            ? ""
            : html `
              <div class="card-actions">
                <paper-input
                  class="inputfield MobileGrid"
                  placeholder=${this.hacs.localize("settings.add_custom_repository")}
                  type="text"
                ></paper-input>
                <paper-dropdown-menu
                  class="category MobileGrid"
                  label="${this.hacs.localize(`settings.category`)}"
                >
                  <paper-listbox slot="dropdown-content" selected="-1">
                    ${this.hacs.configuration.categories.map(category => html `
                        <paper-item class="categoryitem" .category=${category}>
                          ${this.hacs.localize(`common.${category}`)}
                        </paper-item>
                      `)}
                  </paper-listbox>
                </paper-dropdown-menu>

                <div class="save">
                  <ha-icon
                    title="${this.hacs.localize("settings.save")}"
                    icon="mdi:content-save"
                    class="saveicon MobileGrid"
                    @click=${this.Save}
                  >
                  </ha-icon>
                </div>
              </div>
            `}
      </ha-card>
    `;
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        .inputfield {
          width: 60%;
        }
        .category {
          position: absolute;
          width: 30%;
          right: 54px;
          bottom: 5px;
        }
        .saveicon {
          color: var(--hacs-badge-color, --accent-color);
          position: absolute;
          right: 0;
          bottom: 24px;
          cursor: pointer;
        }
        .listicon {
          color: var(--hacs-badge-color, --accent-color);
          right: 0px;
          position: absolute;
          cursor: pointer;
        }
        .loading {
          position: absolute;
          right: 10px;
          bottom: 22px;
        }

        @media screen and (max-width: 600px) and (min-width: 0) {
          .saveicon {
            height: 64px;
          }
          .save {
            padding-bottom: 64px;
          }
        }
        paper-item.categoryitem {
          display: flex;
          background-color: var(
            --paper-listbox-background-color,
            var(--primary-background-color)
          );
        }

        paper-item.customlistitem {
          display: flex;
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], CustomRepositories.prototype, "hacs", void 0);
    __decorate([
        property()
    ], CustomRepositories.prototype, "route", void 0);
    __decorate([
        property()
    ], CustomRepositories.prototype, "background_task", void 0);
    __decorate([
        property()
    ], CustomRepositories.prototype, "custom", void 0);
    CustomRepositories = __decorate([
        customElement("hacs-custom-repositories")
    ], CustomRepositories);

    let HacsCritical = class HacsCritical extends LitElement {
        async Acknowledge(ev) {
            var repository = ev.composedPath()[3].repository;
            const resp = await this.hass.connection.sendMessagePromise({
                type: "hacs/critical",
                repository: repository
            });
            this.critical = resp.data;
        }
        render() {
            if (this.critical === undefined)
                return html ``;
            var _critical = [];
            this.critical.forEach(element => {
                if (!element.acknowledged)
                    _critical.push(element);
            });
            return html `
      ${_critical.map(repo => html `
            <ha-card header="Critical Issue!" class="alert">
                <div class="card-content">
                    The repository "${repo.repository}" has been flagged as a critical repository.</br>
                    The repository has now been uninstalled and removed.</br>
                    For information about how and why these are handled, see
                    <a href="https://hacs.xyz/docs/developer/maintainer#critical-repositories">
                        https://hacs.xyz/docs/developer/maintainer#critical-repositories
                    </a></br>
                    As a result of this Home Assistant was also restarted.</br></br>

                    <b>Reason: </b>${repo.reason}
                </div>
                <div class="card-actions">
                    <mwc-button @click=${this.Acknowledge} .repository=${repo.repository}>
                        Acknowledge
                    </mwc-button>
                    <a href="${repo.link}" rel='noreferrer' target="_blank">
                        <mwc-button>
                            More information about this incident
                        </mwc-button>
                    </a>
                </div>
            </ha-card>`)}
    `;
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        ha-card {
          width: 90%;
          margin-left: 5%;
        }
        .alert {
          background-color: var(
            --hacs-status-pending-restart,
            var(--google-red-500)
          );
          color: var(--text-primary-color);
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], HacsCritical.prototype, "critical", void 0);
    __decorate([
        property()
    ], HacsCritical.prototype, "hass", void 0);
    HacsCritical = __decorate([
        customElement("hacs-critical")
    ], HacsCritical);

    let HacsError = class HacsError extends LitElement {
        constructor() {
            super(...arguments);
            this.error = undefined;
        }
        clearError() {
            this.error = undefined;
        }
        firstUpdated() {
            this.hass.connection.subscribeEvents(msg => (this.error = msg.data), "hacs/error");
        }
        render() {
            if (this.error === undefined)
                return html ``;
            var message = this.error.message;
            var additional = "";
            if (this.error.action === "add_repository") {
                additional =
                    "Could not add this repository, make sure it is compliant with HACS.";
            }
            return html `
            <ha-card header="An error ocoured while prosessing" class="alert">
                <div class="card-content">
                  ${this.error.exception !== undefined
            ? html `
                          <b>Exception: </b> ${this.error.exception} </br>
                        `
            : ""}
                  ${this.error.exception !== undefined
            ? html `
                          <b>Message: </b>
                        `
            : ""}${this.error.message} </br>
                    ${additional}
                </div>
            <div class="card-actions">
                <mwc-button @click=${this.clearError}>
                    Acknowledge
                </mwc-button>
            ${this.error.action === "add_repository"
            ? html `
                    <a
                      href="https://hacs.xyz/docs/publish/start"
                      rel="noreferrer"
                      target="_blank"
                    >
                      <mwc-button>
                        Documentation
                      </mwc-button>
                    </a>
                  `
            : ""}
            </div>
            </ha-card>
            `;
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        ha-card {
          width: 90%;
          margin-left: 5%;
        }
        .alert {
          background-color: var(
            --hacs-status-pending-restart,
            var(--google-red-500)
          );
          color: var(--text-primary-color);
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], HacsError.prototype, "hass", void 0);
    __decorate([
        property()
    ], HacsError.prototype, "error", void 0);
    HacsError = __decorate([
        customElement("hacs-error")
    ], HacsError);

    const step = html `
  <h1>
    Welcome to HACS!👋
  </h1>
  <hr />
  <p>
    Congratulations, you have successfully installed HACS! 🎉 </br> This onboarding
    process will hopefully help you to understand what HACS is and what it does.
  </p>
  <p>To start off here are a few useful links:</p>
  <li><hacs-link url="https://hacs.xyz/">HACS Documentation</hacs-link></li>
  <li><hacs-link url="https://github.com/hacs">HACS @ GitHub</hacs-link></li>
  <li><hacs-link url="https://discord.gg/apgchf8">HACS @ Discord</hacs-link></li>
  </br>
  <p><b>NB!: You will only see this onboarding once, so take your time to read it all.</b></p>
`;

    const step$1 = html `
  <h1>
    Introduction
  </h1>
  <hr />
  <p>
    HACS, in short, is really just a glorified downloader, but no one wants
    that so....
  </p>
  <p>
    HACS works as a distribution platform for extensions to Home Assistant that
    are not part of Home Assistant core.
  </p>
  <p>
    Extensions, or "categories", in this context are:
  </p>
  <li>Custom integrations (custom_components)</li>
  <li>
    <hacs-link url="https://www.home-assistant.io/lovelace"
      >Plugins (Lovelace elements)</hacs-link
    >
  </li>
  <li>
    <hacs-link url="https://appdaemon.readthedocs.io/en/latest/"
      >AppDaemon apps</hacs-link
    >
  </li>
  <li>
    <hacs-link url="https://www.home-assistant.io/integrations/python_script/"
      >python scripts</hacs-link
    >
  </li>
  <li>
    <hacs-link
      url="https://www.home-assistant.io/integrations/frontend/#defining-themes"
      >Themes</hacs-link
    >
  </li>
  <p>
    Having HACS as a distribution platform allows the developer(s)/author(s) of
    these extensions to reach a broader audience and allows for fast deployment
    of new versions.
  </p>
  <p>
  That's fine for developers/authors, but how about users?</br>
  The nice part for users is that most of the custom extensions for Home Assistant now are in HACS, which makes it super easy to find, install, and upgrade.
  </p>
`;

    const step$2 = html `
  <h1>
    Background tasks
  </h1>
  <hr />
  <p>
    If you see this progressbar it means that HACS is working with something in
    the background. Upgrade and uninstall are disabled while this is running.
  </p>
  <hacs-progressbar .active=${true}></hacs-progressbar>
  <p>This is just an example, you can click "Continue" now.</p>
`;

    const step$3 = html `
  <h1>
    First startup
  </h1>
  <hr />
  <p>
    The first time you start Home Assistant with HACS enabled it needs to get information about every repository it knows.</br> It is important that you let it finish this process before you restart Home Assistant, if you restart before it's finished it will need to start over.
  </p>
  <p>When it's done you will no longer see the progressbar.</p>
  <hacs-progressbar .active=${true}></hacs-progressbar>
  <p>This process can take several minutes depending on your system and network.</p>
  <p>Again this progressbar is just an example, you can click "Continue" now.</p>
`;

    const step$4 = html `
  <h1>
    Automation
  </h1>
  <hr />
  <p>
    Automation is at the core of Home Assistant, and parts of HACS may also be
    automated.
  </p>
  <p>Some examples on what can be automated:</p>
  <li>
    <hacs-link
      url="https://hacs.xyz/docs/basic/automation#new-repositories-added"
      >New repository was added to HACS</hacs-link
    >
  </li>
  <li>
    <hacs-link url="https://hacs.xyz/docs/basic/automation#updates-pending"
      >Update pending in HACS</hacs-link
    >
  </li>
`;

    const step$5 = html `
  <h1>
    🚨 Warning
  </h1>
  <hr />
  <p>
  Everything you find in HACS is <b>not</b> tested by Home Assistant, that includes HACS itself.
  </br></br>
  Custom extentions can cause harm to your system and/or contain bugs.</b>
  If you have issues with a custom extension you found in HACS, report it to the author of <i>that</i> custom extension.</b></br>
  You can easily get to the issue tracker of anything you find in HACS with the menu (located at the top right) on every repository you find inside HACS.
  </br></br>
  The HACS and Home Assistant teams do not support <i>anything</i> you find here.
  </p>
`;

    const step$6 = html `
  <h1>
    Last words
  </h1>
  <hr />
  <p>
    HACS is mainly developed/maintained by a single person (<hacs-link
      url="https://github.com/ludeeus"
      >@ludeeus</hacs-link
    >), because of this it can take some time before issues are looked at and
    pull requests are reviewed.
  </p>
  <p>
    While you have read through this onboarding section, HACS has started to get
    information about the repositories it knows, so you will already now see
    items in under the store pages.
  </p>
  <p>
    If you have issues/suggestions regarding HACS, report them here: 
    <hacs-link url="https://hacs.xyz/docs/issues">GitHub</hacs-link>
  </p>
  <p>
    If you have questions regarding HACS please join the
    <hacs-link url="https://discord.gg/apgchf8">Discord server</hacs-link>
  </p>

  </br>
  <p>If you find this custom integration useful please consider supporting me(<hacs-link
      url="https://github.com/ludeeus"
      >@ludeeus</hacs-link
    >)
    <hacs-link url="https://github.com/sponsors/ludeeus">by sponsoring me on GitHub❤️</hacs-link>
    or
    <hacs-link url="https://buymeacoffee.com/ludeeus">buying me ☕️/🍺</hacs-link>
    </p>
`;

    let HacsOnboarding = class HacsOnboarding extends LitElement {
        constructor() {
            super(...arguments);
            this.step = 0;
        }
        NextStep() {
            this.step += 1;
            if (this.step === 7) {
                this.dispatchEvent(new CustomEvent("hacs-onboarding-done", {
                    bubbles: true,
                    composed: true
                }));
            }
        }
        render() {
            return html `
      <app-header-layout has-scrolling-region>
        <app-header slot="header" fixed>
          <app-toolbar>
            <ha-menu-button
              .hass="${this.hass}"
              .narrow="${this.narrow}"
            ></ha-menu-button>
            <div main-title>
              Home Assistant Community Store
            </div>
          </app-toolbar>
        </app-header>
        <hacs-body>
          <ha-card>
            <div class="card-content">
              ${this.step === 0
            ? step
            : this.step === 1
                ? step$1
                : this.step === 2
                    ? step$2
                    : this.step === 3
                        ? step$3
                        : this.step === 4
                            ? step$4
                            : this.step === 5
                                ? step$5
                                : this.step === 6
                                    ? step$6
                                    : ""}
            </div>
            <div class="card-actions">
              <mwc-button
                raised
                title="${this.hacs.localize("common.continue")}"
                @click=${this.NextStep}
              >
                ${this.hacs.localize("common.continue")}
              </mwc-button>
            </div>
          </ha-card>
        </hacs-body>
      </app-header-layout>
    `;
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        mwc-button {
          display: grid;
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], HacsOnboarding.prototype, "narrow", void 0);
    __decorate([
        property()
    ], HacsOnboarding.prototype, "hacs", void 0);
    __decorate([
        property()
    ], HacsOnboarding.prototype, "hass", void 0);
    __decorate([
        property()
    ], HacsOnboarding.prototype, "step", void 0);
    HacsOnboarding = __decorate([
        customElement("hacs-onboarding")
    ], HacsOnboarding);

    let HacsRepositoryMenu = class HacsRepositoryMenu extends LitElement {
        render() {
            return html `
      <paper-menu-button
        no-animations
        horizontal-align="right"
        role="group"
        aria-haspopup="true"
        vertical-align="top"
        aria-disabled="false"
      >
        <paper-icon-button
          icon="hass:dots-vertical"
          slot="dropdown-trigger"
          role="button"
        ></paper-icon-button>
        <paper-listbox
          slot="dropdown-content"
          role="listbox"
          tabindex="0"
          dir="rtl"
        >
          <paper-item @click=${this.RepositoryReload}>
            ${localize(`repository.update_information`)}
          </paper-item>

          ${this.repository.version_or_commit === "version"
            ? html `
                <paper-item @click=${this.RepositoryBeta}>
                  ${this.repository.beta
                ? localize(`repository.hide_beta`)
                : localize(`repository.show_beta`)}
                </paper-item>
              `
            : ""}
          ${!this.repository.custom && !this.repository.installed
            ? html `
                <paper-item @click=${this.RepositoryHide}>
                  ${localize(`repository.hide`)}
                </paper-item>
              `
            : ""}

          <a
            href="https://github.com/${this.repository.full_name}"
            rel="noreferrer"
            target="_blank"
          >
            <paper-item>
              ${localize(`repository.open_issue`)}
            </paper-item>
          </a>

          <a
            href="https://github.com/hacs/default/issues/new?assignees=ludeeus&labels=flag&template=flag.md&title=${this
            .repository.full_name}"
            rel="noreferrer"
            target="_blank"
          >
            <paper-item>
              ${localize(`repository.flag_this`)}
            </paper-item>
          </a>
        </paper-listbox>
      </paper-menu-button>
    `;
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        paper-dropdown-menu {
          width: 250px;
          margin-top: -24px;
        }
        paper-menu-button {
          float: right;
          top: -68px;
        }
        paper-item {
          color: var(--primary-text-color);
          display: flex;
          background-color: var(
            --paper-listbox-background-color,
            var(--primary-background-color)
          );
        }
      `
            ];
        }
        RepositoryReload() {
            this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                detail: {
                    repo: this.repository.id,
                    action: "set_state",
                    data: "other"
                },
                bubbles: true,
                composed: true
            }));
            this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                detail: { repo: this.repository.id, action: "update" },
                bubbles: true,
                composed: true
            }));
        }
        RepositoryBeta() {
            this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                detail: {
                    repo: this.repository.id,
                    action: "set_state",
                    data: "other"
                },
                bubbles: true,
                composed: true
            }));
            if (this.repository.beta) {
                this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                    detail: { repo: this.repository.id, action: "hide_beta" },
                    bubbles: true,
                    composed: true
                }));
            }
            else {
                this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                    detail: { repo: this.repository.id, action: "show_beta" },
                    bubbles: true,
                    composed: true
                }));
            }
        }
        RepositoryHide() {
            this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                detail: {
                    repo: this.repository.id,
                    action: "set_state",
                    data: "other"
                },
                bubbles: true,
                composed: true
            }));
            if (this.repository.hide) {
                this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                    detail: { repo: this.repository.id, action: "unhide" },
                    bubbles: true,
                    composed: true
                }));
            }
            else {
                this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                    detail: { repo: this.repository.id, action: "hide" },
                    bubbles: true,
                    composed: true
                }));
            }
            this.dispatchEvent(new CustomEvent("hacs-location-change", {
                detail: { value: this.repository.category },
                bubbles: true,
                composed: true
            }));
        }
    };
    __decorate([
        property()
    ], HacsRepositoryMenu.prototype, "hass", void 0);
    __decorate([
        property()
    ], HacsRepositoryMenu.prototype, "repository", void 0);
    __decorate([
        property()
    ], HacsRepositoryMenu.prototype, "route", void 0);
    HacsRepositoryMenu = __decorate([
        customElement("hacs-repository-menu")
    ], HacsRepositoryMenu);

    let HiddenRepositories = class HiddenRepositories extends LitElement {
        UnHide(ev) {
            var repo = ev.composedPath()[4].repoID;
            this.dispatchEvent(new CustomEvent("hacs-repository-action", {
                detail: { repo: repo, action: "unhide" },
                bubbles: true,
                composed: true
            }));
        }
        render() {
            if (this.hacs.repositories === undefined) {
                this.dispatchEvent(new CustomEvent("hacs-recreate", { bubbles: true, composed: true }));
                return html ``;
            }
            this._hidden = this.hacs.repositories.filter(function (repo) {
                return repo.hide;
            });
            if (this._hidden.length === 0)
                return html ``;
            return html `
      <ha-card
        header="${this.hacs
            .localize("settings.hidden_repositories")
            .toUpperCase()}"
      >
        <div class="card-content">
          <div class="custom-repositories-list">
            ${this._hidden
            .sort((a, b) => (a.full_name > b.full_name ? 1 : -1))
            .map(repo => html `
                    <div class="row" .repoID=${repo.id}>
                      <paper-item>
                        <ha-icon
                          title="${this.hacs.localize("settings.unhide")}"
                          class="listicon"
                          icon="mdi:restore"
                          @click=${this.UnHide}
                        ></ha-icon>
                        ${repo.full_name}
                      </paper-item>
                    </div>
                  `)}
          </div>
        </div>
      </ha-card>
    `;
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        paper-item {
          display: flex;
        }
        .listicon {
          color: var(--hacs-badge-color, --accent-color);
          left: 0px;
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], HiddenRepositories.prototype, "_hidden", void 0);
    __decorate([
        property()
    ], HiddenRepositories.prototype, "hacs", void 0);
    HiddenRepositories = __decorate([
        customElement("hacs-hidden-repositories")
    ], HiddenRepositories);

    let LoveLaceHint = class LoveLaceHint extends LitElement {
        render() {
            const pluginpath = `${this.repository.full_name.split("/")[1]}/${this.repository.file_name}`;
            const plugintype = `${this.repository.javascript_type !== undefined
            ? this.repository.javascript_type
            : localize(`repository.lovelace_no_js_type`)}`;
            return html `
      <div class="lovelace-hint markdown-body">
        <p class="example-title">
          ${localize(`repository.lovelace_instruction`)}:
        </p>
        <pre id="LovelaceExample" class="yaml">
  - url: /community_plugin/${pluginpath}
    type: ${plugintype}</pre
        >

        <paper-icon-button
          title="${localize(`repository.lovelace_copy_example`)}"
          icon="mdi:content-copy"
          id="CopyLLExample"
          @click="${this.CopyToLovelaceExampleToClipboard}"
          role="button"
        ></paper-icon-button>
      </div>
    `;
        }
        CopyToLovelaceExampleToClipboard() {
            navigator.clipboard.writeText(this.hint.innerText);
        }
        static get styles() {
            return [
                HacsStyle,
                GFM,
                css `
        .example-title {
          margin-block-end: 0em;
        }
        .yaml {
          display: inline-flex;
          width: calc(100% - 46px);
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], LoveLaceHint.prototype, "configuration", void 0);
    __decorate([
        property()
    ], LoveLaceHint.prototype, "hass", void 0);
    __decorate([
        property()
    ], LoveLaceHint.prototype, "repository", void 0);
    __decorate([
        query("#LovelaceExample")
    ], LoveLaceHint.prototype, "hint", void 0);
    LoveLaceHint = __decorate([
        customElement("hacs-lovelace-hint")
    ], LoveLaceHint);

    let Authors = class Authors extends LitElement {
        render() {
            if (String(this.authors.length) === "0")
                return html ``;
            let authors = [];
            const seperateElement = document.createElement("div");
            seperateElement.className = "seperator";
            seperateElement.innerText = ",";
            this.authors.forEach(author => {
                const authorElement = document.createElement("a");
                authorElement.href = `https://github.com/${author.replace("@", "")}`;
                authorElement.target = "_blank";
                authorElement.className = "author";
                authorElement.innerText = author.replace("@", "");
                authors.push(authorElement);
                authors.push(seperateElement);
            });
            authors.pop();
            return html `
      <div>
        <p>
        <div class="authors">
          <b>${localize("repository.authors")}: </b>
          ${authors}
          </div>
        </p>
      </div>
    `;
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        .author {
          color: var(--link-text-color, var(--accent-color));
          margin-left: 4px;
        }
        .authors {
          display: flex;
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], Authors.prototype, "hass", void 0);
    __decorate([
        property()
    ], Authors.prototype, "authors", void 0);
    Authors = __decorate([
        customElement("hacs-authors")
    ], Authors);

    let RepositoryBannerNote = class RepositoryBannerNote extends LitElement {
        render() {
            if (!this.repository.installed)
                return html ``;
            let banner;
            if (this.repository.category === "integration") {
                if (this.repository.first_install && this.repository.config_flow) {
                    banner = document.createElement("hacs-repository-banner-integration-first-install");
                    banner.hacs = this.hacs;
                    banner.hass = this.hass;
                    banner.repository = this.repository;
                    banner.route = this.route;
                    return html `
          ${banner}
        `;
                }
                else if (this.repository.status === "pending-restart") {
                    banner = document.createElement("hacs-repository-banner-integration-pending-restart");
                    banner.hacs = this.hacs;
                    banner.hass = this.hass;
                    banner.repository = this.repository;
                    banner.route = this.route;
                    return html `
          ${banner}
        `;
                }
            }
            if (this.repository.category === "plugin") {
                if (this.lovelaceconfig !== undefined && !this.status.background_task) {
                    banner = document.createElement("hacs-repository-banner-plugin-not-loaded");
                    banner.hacs = this.hacs;
                    banner.hass = this.hass;
                    banner.configuration = this.configuration;
                    banner.lovelaceconfig = this.lovelaceconfig;
                    banner.status = this.status;
                    banner.repository = this.repository;
                    return html `
          ${banner}
        `;
                }
            }
            return html ``;
        }
    };
    __decorate([
        property()
    ], RepositoryBannerNote.prototype, "hacs", void 0);
    __decorate([
        property()
    ], RepositoryBannerNote.prototype, "configuration", void 0);
    __decorate([
        property()
    ], RepositoryBannerNote.prototype, "hass", void 0);
    __decorate([
        property()
    ], RepositoryBannerNote.prototype, "lovelaceconfig", void 0);
    __decorate([
        property()
    ], RepositoryBannerNote.prototype, "repository", void 0);
    __decorate([
        property()
    ], RepositoryBannerNote.prototype, "route", void 0);
    __decorate([
        property()
    ], RepositoryBannerNote.prototype, "status", void 0);
    RepositoryBannerNote = __decorate([
        customElement("hacs-repository-banner-note")
    ], RepositoryBannerNote);

    let RepositoryNote = class RepositoryNote extends LitElement {
        render() {
            let path = this.repository.local_path;
            if (this.repository.category === "theme") {
                path = `${path}/${this.repository.file_name}`;
            }
            const Note = document.createElement("div");
            Note.className = "repository-note";
            const p = document.createElement("p");
            p.innerText = `${localize(`repository.note_installed`)} '${path}'`;
            if (["appdaemon", "integration", "plugin"].includes(this.repository.category)) {
                p.innerText += `, ${localize(`repository.note_${this.repository.category}`)}.`;
            }
            Note.appendChild(p);
            if (this.repository.category === "plugin") {
                const LLHint = document.createElement("hacs-lovelace-hint");
                LLHint.hass = this.hass;
                LLHint.configuration = this.configuration;
                LLHint.repository = this.repository;
                Note.appendChild(LLHint);
            }
            return html `
      ${Note}
    `;
        }
        static get styles() {
            return [
                HacsStyle,
                css `
        .repository-note {
          border-top: 1px solid var(--primary-text-color);
        }
        p {
          font-style: italic;
        }
      `
            ];
        }
    };
    __decorate([
        property()
    ], RepositoryNote.prototype, "configuration", void 0);
    __decorate([
        property()
    ], RepositoryNote.prototype, "hass", void 0);
    __decorate([
        property()
    ], RepositoryNote.prototype, "repository", void 0);
    RepositoryNote = __decorate([
        customElement("hacs-repository-note")
    ], RepositoryNote);

    let HacsFrontend = class HacsFrontend extends LitElement {
        setModalCSS() {
            if (document.getElementById("modal-style"))
                return;
            var element = document.body;
            var style = document.createElement("style");
            style.id = "modal-style";
            style.innerHTML = `
      .swal-modal {
          background-color: var(--primary-background-color) !important;
          text-align: left;
      }
      .swal-text {
          color: var(--primary-text-color) !important;
      }
      .swal-button {
          background-color: var(--primary-color) !important;
          color: var(--primary-text-color) !important;
      }
      .swal-text:first-child {
        margin: 16px 0px 0px 8px;
      }`;
            element.appendChild(style);
        }
        render() {
            this.setModalCSS();
            return html `
      <hacs-frontendbase
        .hass=${this.hass}
        .route=${this.route}
        .narrow=${this.narrow}
      >
      </hacs-frontendbase>
    `;
        }
    };
    __decorate([
        property()
    ], HacsFrontend.prototype, "narrow", void 0);
    __decorate([
        property()
    ], HacsFrontend.prototype, "hass", void 0);
    __decorate([
        property()
    ], HacsFrontend.prototype, "route", void 0);
    HacsFrontend = __decorate([
        customElement("hacs-frontend")
    ], HacsFrontend);

}());
