{"version":3,"file":"decode.mjs","sources":["../../../../node_modules/entities/dist/decode.js"],"sourcesContent":["import { replaceCodePoint } from \"./decode-codepoint.js\";\nimport { htmlDecodeTree } from \"./generated/decode-data-html.js\";\nimport { xmlDecodeTree } from \"./generated/decode-data-xml.js\";\nimport { BinTrieFlags } from \"./internal/bin-trie-flags.js\";\nvar CharCodes;\n(function (CharCodes) {\n    CharCodes[CharCodes[\"NUM\"] = 35] = \"NUM\";\n    CharCodes[CharCodes[\"SEMI\"] = 59] = \"SEMI\";\n    CharCodes[CharCodes[\"EQUALS\"] = 61] = \"EQUALS\";\n    CharCodes[CharCodes[\"ZERO\"] = 48] = \"ZERO\";\n    CharCodes[CharCodes[\"NINE\"] = 57] = \"NINE\";\n    CharCodes[CharCodes[\"LOWER_A\"] = 97] = \"LOWER_A\";\n    CharCodes[CharCodes[\"LOWER_F\"] = 102] = \"LOWER_F\";\n    CharCodes[CharCodes[\"LOWER_X\"] = 120] = \"LOWER_X\";\n    CharCodes[CharCodes[\"LOWER_Z\"] = 122] = \"LOWER_Z\";\n    CharCodes[CharCodes[\"UPPER_A\"] = 65] = \"UPPER_A\";\n    CharCodes[CharCodes[\"UPPER_F\"] = 70] = \"UPPER_F\";\n    CharCodes[CharCodes[\"UPPER_Z\"] = 90] = \"UPPER_Z\";\n})(CharCodes || (CharCodes = {}));\n/** Bit that needs to be set to convert an upper case ASCII character to lower case */\nconst TO_LOWER_BIT = 0b10_0000;\nfunction isNumber(code) {\n    return code >= CharCodes.ZERO && code <= CharCodes.NINE;\n}\nfunction isHexadecimalCharacter(code) {\n    return ((code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_F) ||\n        (code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_F));\n}\nfunction isAsciiAlphaNumeric(code) {\n    return ((code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_Z) ||\n        (code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_Z) ||\n        isNumber(code));\n}\n/**\n * Checks if the given character is a valid end character for an entity in an attribute.\n *\n * Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.\n * See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state\n * @param code Code point to decode.\n */\nfunction isEntityInAttributeInvalidEnd(code) {\n    return code === CharCodes.EQUALS || isAsciiAlphaNumeric(code);\n}\nvar EntityDecoderState;\n(function (EntityDecoderState) {\n    EntityDecoderState[EntityDecoderState[\"EntityStart\"] = 0] = \"EntityStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericStart\"] = 1] = \"NumericStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericDecimal\"] = 2] = \"NumericDecimal\";\n    EntityDecoderState[EntityDecoderState[\"NumericHex\"] = 3] = \"NumericHex\";\n    EntityDecoderState[EntityDecoderState[\"NamedEntity\"] = 4] = \"NamedEntity\";\n})(EntityDecoderState || (EntityDecoderState = {}));\n/**\n * Decoding mode for named entities.\n */\nexport var DecodingMode;\n(function (DecodingMode) {\n    /** Entities in text nodes that can end with any character. */\n    DecodingMode[DecodingMode[\"Legacy\"] = 0] = \"Legacy\";\n    /** Only allow entities terminated with a semicolon. */\n    DecodingMode[DecodingMode[\"Strict\"] = 1] = \"Strict\";\n    /** Entities in attributes have limitations on ending characters. */\n    DecodingMode[DecodingMode[\"Attribute\"] = 2] = \"Attribute\";\n})(DecodingMode || (DecodingMode = {}));\n/**\n * Token decoder with support of writing partial entities.\n */\nexport class EntityDecoder {\n    decodeTree;\n    emitCodePoint;\n    errors;\n    constructor(\n    /** The tree used to decode entities. */\n    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: False positive\n    decodeTree, \n    /**\n     * The function that is called when a codepoint is decoded.\n     *\n     * For multi-byte named entities, this will be called multiple times,\n     * with the second codepoint, and the same `consumed` value.\n     * @param codepoint The decoded codepoint.\n     * @param consumed The number of bytes consumed by the decoder.\n     */\n    emitCodePoint, \n    /** An object that is used to produce errors. */\n    errors) {\n        this.decodeTree = decodeTree;\n        this.emitCodePoint = emitCodePoint;\n        this.errors = errors;\n    }\n    /** The current state of the decoder. */\n    state = EntityDecoderState.EntityStart;\n    /** Characters that were consumed while parsing an entity. */\n    consumed = 1;\n    /**\n     * The result of the entity.\n     *\n     * Either the result index of a numeric entity, or the codepoint of a\n     * numeric entity.\n     */\n    result = 0;\n    /** The current index in the decode tree. */\n    treeIndex = 0;\n    /** The number of characters that were consumed in excess. */\n    excess = 1;\n    /** The mode in which the decoder is operating. */\n    decodeMode = DecodingMode.Strict;\n    /** The number of characters that have been consumed in the current run. */\n    runConsumed = 0;\n    /**\n     * Resets the instance to make it reusable.\n     * @param decodeMode Entity decoding mode to use.\n     */\n    startEntity(decodeMode) {\n        this.decodeMode = decodeMode;\n        this.state = EntityDecoderState.EntityStart;\n        this.result = 0;\n        this.treeIndex = 0;\n        this.excess = 1;\n        this.consumed = 1;\n        this.runConsumed = 0;\n    }\n    /**\n     * Write an entity to the decoder. This can be called multiple times with partial entities.\n     * If the entity is incomplete, the decoder will return -1.\n     *\n     * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the\n     * entity is incomplete, and resume when the next string is written.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    write(input, offset) {\n        switch (this.state) {\n            case EntityDecoderState.EntityStart: {\n                if (input.charCodeAt(offset) === CharCodes.NUM) {\n                    this.state = EntityDecoderState.NumericStart;\n                    this.consumed += 1;\n                    return this.stateNumericStart(input, offset + 1);\n                }\n                this.state = EntityDecoderState.NamedEntity;\n                return this.stateNamedEntity(input, offset);\n            }\n            case EntityDecoderState.NumericStart: {\n                return this.stateNumericStart(input, offset);\n            }\n            case EntityDecoderState.NumericDecimal: {\n                return this.stateNumericDecimal(input, offset);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.stateNumericHex(input, offset);\n            }\n            case EntityDecoderState.NamedEntity: {\n                return this.stateNamedEntity(input, offset);\n            }\n        }\n    }\n    /**\n     * Switches between the numeric decimal and hexadecimal states.\n     *\n     * Equivalent to the `Numeric character reference state` in the HTML spec.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericStart(input, offset) {\n        if (offset >= input.length) {\n            return -1;\n        }\n        if ((input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {\n            this.state = EntityDecoderState.NumericHex;\n            this.consumed += 1;\n            return this.stateNumericHex(input, offset + 1);\n        }\n        this.state = EntityDecoderState.NumericDecimal;\n        return this.stateNumericDecimal(input, offset);\n    }\n    /**\n     * Parses a hexadecimal numeric entity.\n     *\n     * Equivalent to the `Hexademical character reference state` in the HTML spec.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericHex(input, offset) {\n        while (offset < input.length) {\n            const char = input.charCodeAt(offset);\n            if (isNumber(char) || isHexadecimalCharacter(char)) {\n                // Convert hex digit to value (0-15); 'a'/'A' -> 10.\n                const digit = char <= CharCodes.NINE\n                    ? char - CharCodes.ZERO\n                    : (char | TO_LOWER_BIT) - CharCodes.LOWER_A + 10;\n                this.result = this.result * 16 + digit;\n                this.consumed++;\n                offset++;\n            }\n            else {\n                return this.emitNumericEntity(char, 3);\n            }\n        }\n        return -1; // Incomplete entity\n    }\n    /**\n     * Parses a decimal numeric entity.\n     *\n     * Equivalent to the `Decimal character reference state` in the HTML spec.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericDecimal(input, offset) {\n        while (offset < input.length) {\n            const char = input.charCodeAt(offset);\n            if (isNumber(char)) {\n                this.result = this.result * 10 + (char - CharCodes.ZERO);\n                this.consumed++;\n                offset++;\n            }\n            else {\n                return this.emitNumericEntity(char, 2);\n            }\n        }\n        return -1; // Incomplete entity\n    }\n    /**\n     * Validate and emit a numeric entity.\n     *\n     * Implements the logic from the `Hexademical character reference start\n     * state` and `Numeric character reference end state` in the HTML spec.\n     * @param lastCp The last code point of the entity. Used to see if the\n     *               entity was terminated with a semicolon.\n     * @param expectedLength The minimum number of characters that should be\n     *                       consumed. Used to validate that at least one digit\n     *                       was consumed.\n     * @returns The number of characters that were consumed.\n     */\n    emitNumericEntity(lastCp, expectedLength) {\n        // Ensure we consumed at least one digit.\n        if (this.consumed <= expectedLength) {\n            this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);\n            return 0;\n        }\n        // Figure out if this is a legit end of the entity\n        if (lastCp === CharCodes.SEMI) {\n            this.consumed += 1;\n        }\n        else if (this.decodeMode === DecodingMode.Strict) {\n            return 0;\n        }\n        this.emitCodePoint(replaceCodePoint(this.result), this.consumed);\n        if (this.errors) {\n            if (lastCp !== CharCodes.SEMI) {\n                this.errors.missingSemicolonAfterCharacterReference();\n            }\n            this.errors.validateNumericCharacterReference(this.result);\n        }\n        return this.consumed;\n    }\n    /**\n     * Parses a named entity.\n     *\n     * Equivalent to the `Named character reference state` in the HTML spec.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNamedEntity(input, offset) {\n        const { decodeTree } = this;\n        let current = decodeTree[this.treeIndex];\n        // The length is the number of bytes of the value, including the current byte.\n        let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;\n        while (offset < input.length) {\n            // Handle compact runs (possibly inline): valueLength == 0 and SEMI_REQUIRED bit set.\n            if (valueLength === 0 && (current & BinTrieFlags.FLAG13) !== 0) {\n                const runLength = (current & BinTrieFlags.BRANCH_LENGTH) >> 7; /* 2..63 */\n                // If we are starting a run, check the first char.\n                if (this.runConsumed === 0) {\n                    const firstChar = current & BinTrieFlags.JUMP_TABLE;\n                    if (input.charCodeAt(offset) !== firstChar) {\n                        return this.result === 0\n                            ? 0\n                            : this.emitNotTerminatedNamedEntity();\n                    }\n                    offset++;\n                    this.excess++;\n                    this.runConsumed++;\n                }\n                // Check remaining characters in the run.\n                while (this.runConsumed < runLength) {\n                    if (offset >= input.length) {\n                        return -1;\n                    }\n                    const charIndexInPacked = this.runConsumed - 1;\n                    const packedWord = decodeTree[this.treeIndex + 1 + (charIndexInPacked >> 1)];\n                    const expectedChar = charIndexInPacked % 2 === 0\n                        ? packedWord & 0xff\n                        : (packedWord >> 8) & 0xff;\n                    if (input.charCodeAt(offset) !== expectedChar) {\n                        this.runConsumed = 0;\n                        return this.result === 0\n                            ? 0\n                            : this.emitNotTerminatedNamedEntity();\n                    }\n                    offset++;\n                    this.excess++;\n                    this.runConsumed++;\n                }\n                this.runConsumed = 0;\n                this.treeIndex += 1 + (runLength >> 1);\n                current = decodeTree[this.treeIndex];\n                valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;\n            }\n            if (offset >= input.length)\n                break;\n            const char = input.charCodeAt(offset);\n            /*\n             * Implicit semicolon handling for nodes that require a semicolon but\n             * don't have an explicit ';' branch stored in the trie. If we have\n             * a value on the current node, it requires a semicolon, and the\n             * current input character is a semicolon, emit the entity using the\n             * current node (without descending further).\n             */\n            if (char === CharCodes.SEMI &&\n                valueLength !== 0 &&\n                (current & BinTrieFlags.FLAG13) !== 0) {\n                return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);\n            }\n            this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);\n            if (this.treeIndex < 0) {\n                return this.result === 0 ||\n                    // If we are parsing an attribute\n                    (this.decodeMode === DecodingMode.Attribute &&\n                        // We shouldn't have consumed any characters after the entity,\n                        (valueLength === 0 ||\n                            // And there should be no invalid characters.\n                            isEntityInAttributeInvalidEnd(char)))\n                    ? 0\n                    : this.emitNotTerminatedNamedEntity();\n            }\n            current = decodeTree[this.treeIndex];\n            valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;\n            // If the branch is a value, store it and continue\n            if (valueLength !== 0) {\n                // If the entity is terminated by a semicolon, we are done.\n                if (char === CharCodes.SEMI) {\n                    return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);\n                }\n                // If we encounter a non-terminated (legacy) entity while parsing strictly, then ignore it.\n                if (this.decodeMode !== DecodingMode.Strict &&\n                    (current & BinTrieFlags.FLAG13) === 0) {\n                    this.result = this.treeIndex;\n                    this.consumed += this.excess;\n                    this.excess = 0;\n                }\n            }\n            // Increment offset & excess for next iteration\n            offset++;\n            this.excess++;\n        }\n        return -1;\n    }\n    /**\n     * Emit a named entity that was not terminated with a semicolon.\n     * @returns The number of characters consumed.\n     */\n    emitNotTerminatedNamedEntity() {\n        const { result, decodeTree } = this;\n        const valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;\n        this.emitNamedEntityData(result, valueLength, this.consumed);\n        this.errors?.missingSemicolonAfterCharacterReference();\n        return this.consumed;\n    }\n    /**\n     * Emit a named entity.\n     * @param result The index of the entity in the decode tree.\n     * @param valueLength The number of bytes in the entity.\n     * @param consumed The number of characters consumed.\n     * @returns The number of characters consumed.\n     */\n    emitNamedEntityData(result, valueLength, consumed) {\n        const { decodeTree } = this;\n        this.emitCodePoint(valueLength === 1\n            ? decodeTree[result] &\n                ~(BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)\n            : decodeTree[result + 1], consumed);\n        if (valueLength === 3) {\n            // For multi-byte values, we need to emit the second byte.\n            this.emitCodePoint(decodeTree[result + 2], consumed);\n        }\n        return consumed;\n    }\n    /**\n     * Signal to the parser that the end of the input was reached.\n     *\n     * Remaining data will be emitted and relevant errors will be produced.\n     * @returns The number of characters consumed.\n     */\n    end() {\n        switch (this.state) {\n            case EntityDecoderState.NamedEntity: {\n                // Emit a named entity if we have one.\n                return this.result !== 0 &&\n                    (this.decodeMode !== DecodingMode.Attribute ||\n                        this.result === this.treeIndex)\n                    ? this.emitNotTerminatedNamedEntity()\n                    : 0;\n            }\n            // Otherwise, emit a numeric entity if we have one.\n            case EntityDecoderState.NumericDecimal: {\n                return this.emitNumericEntity(0, 2);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.emitNumericEntity(0, 3);\n            }\n            case EntityDecoderState.NumericStart: {\n                this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);\n                return 0;\n            }\n            case EntityDecoderState.EntityStart: {\n                // Return 0 if we have no entity.\n                return 0;\n            }\n        }\n    }\n}\n/**\n * Creates a function that decodes entities in a string.\n * @param decodeTree The decode tree.\n * @returns A function that decodes entities in a string.\n */\nfunction getDecoder(decodeTree) {\n    let returnValue = \"\";\n    const decoder = new EntityDecoder(decodeTree, (data) => (returnValue += String.fromCodePoint(data)));\n    return function decodeWithTrie(input, decodeMode) {\n        let lastIndex = 0;\n        let offset = 0;\n        while ((offset = input.indexOf(\"&\", offset)) >= 0) {\n            returnValue += input.slice(lastIndex, offset);\n            decoder.startEntity(decodeMode);\n            const length = decoder.write(input, \n            // Skip the \"&\"\n            offset + 1);\n            if (length < 0) {\n                lastIndex = offset + decoder.end();\n                break;\n            }\n            lastIndex = offset + length;\n            // If `length` is 0, skip the current `&` and continue.\n            offset = length === 0 ? lastIndex + 1 : lastIndex;\n        }\n        const result = returnValue + input.slice(lastIndex);\n        // Make sure we don't keep a reference to the final string.\n        returnValue = \"\";\n        return result;\n    };\n}\n/**\n * Determines the branch of the current node that is taken given the current\n * character. This function is used to traverse the trie.\n * @param decodeTree The trie.\n * @param current The current node.\n * @param nodeIndex Index immediately after the current node header.\n * @param char The current character.\n * @returns The index of the next node, or -1 if no branch is taken.\n */\nexport function determineBranch(decodeTree, current, nodeIndex, char) {\n    const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n    const jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n    // Case 1: Single branch encoded in jump offset\n    if (branchCount === 0) {\n        return jumpOffset !== 0 && char === jumpOffset ? nodeIndex : -1;\n    }\n    // Case 2: Multiple branches encoded in jump table\n    if (jumpOffset) {\n        const value = char - jumpOffset;\n        return value < 0 || value >= branchCount\n            ? -1\n            : decodeTree[nodeIndex + value] - 1;\n    }\n    // Case 3: Multiple branches encoded in packed dictionary (two keys per uint16)\n    const packedKeySlots = (branchCount + 1) >> 1;\n    /*\n     * Treat packed keys as a virtual sorted array of length `branchCount`.\n     * Key(i) = low byte for even i, high byte for odd i in slot i>>1.\n     */\n    let lo = 0;\n    let hi = branchCount - 1;\n    while (lo <= hi) {\n        const mid = (lo + hi) >>> 1;\n        const slot = mid >> 1;\n        const packed = decodeTree[nodeIndex + slot];\n        const midKey = (packed >> ((mid & 1) * 8)) & 0xff;\n        if (midKey < char) {\n            lo = mid + 1;\n        }\n        else if (midKey > char) {\n            hi = mid - 1;\n        }\n        else {\n            return decodeTree[nodeIndex + packedKeySlots + mid];\n        }\n    }\n    return -1;\n}\nconst htmlDecoder = /* #__PURE__ */ getDecoder(htmlDecodeTree);\nconst xmlDecoder = /* #__PURE__ */ getDecoder(xmlDecodeTree);\n/**\n * Decodes an HTML string.\n * @param htmlString The string to decode.\n * @param mode The decoding mode.\n * @returns The decoded string.\n */\nexport function decodeHTML(htmlString, mode = DecodingMode.Legacy) {\n    return htmlDecoder(htmlString, mode);\n}\n/**\n * Decodes an HTML string in an attribute.\n * @param htmlAttribute The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLAttribute(htmlAttribute) {\n    return htmlDecoder(htmlAttribute, DecodingMode.Attribute);\n}\n/**\n * Decodes an HTML string, requiring all entities to be terminated by a semicolon.\n * @param htmlString The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLStrict(htmlString) {\n    return htmlDecoder(htmlString, DecodingMode.Strict);\n}\n/**\n * Decodes an XML string, requiring all entities to be terminated by a semicolon.\n * @param xmlString The string to decode.\n * @returns The decoded string.\n */\nexport function decodeXML(xmlString) {\n    return xmlDecoder(xmlString, DecodingMode.Strict);\n}\nexport { replaceCodePoint } from \"./decode-codepoint.js\";\n// Re-export for use by eg. htmlparser2\nexport { htmlDecodeTree } from \"./generated/decode-data-html.js\";\nexport { xmlDecodeTree } from \"./generated/decode-data-xml.js\";\n//# sourceMappingURL=decode.js.map"],"names":[],"mappings":";;;AAIA,IAAI,SAAS;AACb,CAAC,UAAU,SAAS,EAAE;AACtB,IAAI,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,GAAG,KAAK;AAC5C,IAAI,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,MAAM;AAC9C,IAAI,SAAS,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,QAAQ;AAClD,IAAI,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,MAAM;AAC9C,IAAI,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,MAAM;AAC9C,IAAI,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,SAAS;AACpD,IAAI,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC,GAAG,SAAS;AACrD,IAAI,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC,GAAG,SAAS;AACrD,IAAI,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC,GAAG,SAAS;AACrD,IAAI,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,SAAS;AACpD,IAAI,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,SAAS;AACpD,IAAI,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,SAAS;AACpD,CAAC,EAAE,SAAS,KAAK,SAAS,GAAG,EAAE,CAAC,CAAC;AACjC;AACA,MAAM,YAAY,GAAG,SAAS;AAC9B,SAAS,QAAQ,CAAC,IAAI,EAAE;AACxB,IAAI,OAAO,IAAI,IAAI,SAAS,CAAC,IAAI,IAAI,IAAI,IAAI,SAAS,CAAC,IAAI;AAC3D;AACA,SAAS,sBAAsB,CAAC,IAAI,EAAE;AACtC,IAAI,QAAQ,CAAC,IAAI,IAAI,SAAS,CAAC,OAAO,IAAI,IAAI,IAAI,SAAS,CAAC,OAAO;AACnE,SAAS,IAAI,IAAI,SAAS,CAAC,OAAO,IAAI,IAAI,IAAI,SAAS,CAAC,OAAO,CAAC;AAChE;AACA,SAAS,mBAAmB,CAAC,IAAI,EAAE;AACnC,IAAI,QAAQ,CAAC,IAAI,IAAI,SAAS,CAAC,OAAO,IAAI,IAAI,IAAI,SAAS,CAAC,OAAO;AACnE,SAAS,IAAI,IAAI,SAAS,CAAC,OAAO,IAAI,IAAI,IAAI,SAAS,CAAC,OAAO,CAAC;AAChE,QAAQ,QAAQ,CAAC,IAAI,CAAC;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,6BAA6B,CAAC,IAAI,EAAE;AAC7C,IAAI,OAAO,IAAI,KAAK,SAAS,CAAC,MAAM,IAAI,mBAAmB,CAAC,IAAI,CAAC;AACjE;AACA,IAAI,kBAAkB;AACtB,CAAC,UAAU,kBAAkB,EAAE;AAC/B,IAAI,kBAAkB,CAAC,kBAAkB,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,GAAG,aAAa;AAC7E,IAAI,kBAAkB,CAAC,kBAAkB,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,GAAG,cAAc;AAC/E,IAAI,kBAAkB,CAAC,kBAAkB,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,GAAG,gBAAgB;AACnF,IAAI,kBAAkB,CAAC,kBAAkB,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,GAAG,YAAY;AAC3E,IAAI,kBAAkB,CAAC,kBAAkB,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,GAAG,aAAa;AAC7E,CAAC,EAAE,kBAAkB,KAAK,kBAAkB,GAAG,EAAE,CAAC,CAAC;AACnD;AACA;AACA;AACU,IAAC;AACX,CAAC,UAAU,YAAY,EAAE;AACzB;AACA,IAAI,YAAY,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,QAAQ;AACvD;AACA,IAAI,YAAY,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,QAAQ;AACvD;AACA,IAAI,YAAY,CAAC,YAAY,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,WAAW;AAC7D,CAAC,EAAE,YAAY,KAAK,YAAY,GAAG,EAAE,CAAC,CAAC;AACvC;AACA;AACA;AACO,MAAM,aAAa,CAAC;AAC3B,IAAI,UAAU;AACd,IAAI,aAAa;AACjB,IAAI,MAAM;AACV,IAAI,WAAW;AACf;AACA;AACA,IAAI,UAAU;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,aAAa;AACjB;AACA,IAAI,MAAM,EAAE;AACZ,QAAQ,IAAI,CAAC,UAAU,GAAG,UAAU;AACpC,QAAQ,IAAI,CAAC,aAAa,GAAG,aAAa;AAC1C,QAAQ,IAAI,CAAC,MAAM,GAAG,MAAM;AAC5B,IAAI;AACJ;AACA,IAAI,KAAK,GAAG,kBAAkB,CAAC,WAAW;AAC1C;AACA,IAAI,QAAQ,GAAG,CAAC;AAChB;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,MAAM,GAAG,CAAC;AACd;AACA,IAAI,SAAS,GAAG,CAAC;AACjB;AACA,IAAI,MAAM,GAAG,CAAC;AACd;AACA,IAAI,UAAU,GAAG,YAAY,CAAC,MAAM;AACpC;AACA,IAAI,WAAW,GAAG,CAAC;AACnB;AACA;AACA;AACA;AACA,IAAI,WAAW,CAAC,UAAU,EAAE;AAC5B,QAAQ,IAAI,CAAC,UAAU,GAAG,UAAU;AACpC,QAAQ,IAAI,CAAC,KAAK,GAAG,kBAAkB,CAAC,WAAW;AACnD,QAAQ,IAAI,CAAC,MAAM,GAAG,CAAC;AACvB,QAAQ,IAAI,CAAC,SAAS,GAAG,CAAC;AAC1B,QAAQ,IAAI,CAAC,MAAM,GAAG,CAAC;AACvB,QAAQ,IAAI,CAAC,QAAQ,GAAG,CAAC;AACzB,QAAQ,IAAI,CAAC,WAAW,GAAG,CAAC;AAC5B,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE;AACzB,QAAQ,QAAQ,IAAI,CAAC,KAAK;AAC1B,YAAY,KAAK,kBAAkB,CAAC,WAAW,EAAE;AACjD,gBAAgB,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,SAAS,CAAC,GAAG,EAAE;AAChE,oBAAoB,IAAI,CAAC,KAAK,GAAG,kBAAkB,CAAC,YAAY;AAChE,oBAAoB,IAAI,CAAC,QAAQ,IAAI,CAAC;AACtC,oBAAoB,OAAO,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC;AACpE,gBAAgB;AAChB,gBAAgB,IAAI,CAAC,KAAK,GAAG,kBAAkB,CAAC,WAAW;AAC3D,gBAAgB,OAAO,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC;AAC3D,YAAY;AACZ,YAAY,KAAK,kBAAkB,CAAC,YAAY,EAAE;AAClD,gBAAgB,OAAO,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC;AAC5D,YAAY;AACZ,YAAY,KAAK,kBAAkB,CAAC,cAAc,EAAE;AACpD,gBAAgB,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC;AAC9D,YAAY;AACZ,YAAY,KAAK,kBAAkB,CAAC,UAAU,EAAE;AAChD,gBAAgB,OAAO,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC;AAC1D,YAAY;AACZ,YAAY,KAAK,kBAAkB,CAAC,WAAW,EAAE;AACjD,gBAAgB,OAAO,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC;AAC3D,YAAY;AACZ;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE;AACrC,QAAQ,IAAI,MAAM,IAAI,KAAK,CAAC,MAAM,EAAE;AACpC,YAAY,OAAO,EAAE;AACrB,QAAQ;AACR,QAAQ,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,YAAY,MAAM,SAAS,CAAC,OAAO,EAAE;AAC7E,YAAY,IAAI,CAAC,KAAK,GAAG,kBAAkB,CAAC,UAAU;AACtD,YAAY,IAAI,CAAC,QAAQ,IAAI,CAAC;AAC9B,YAAY,OAAO,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC;AAC1D,QAAQ;AACR,QAAQ,IAAI,CAAC,KAAK,GAAG,kBAAkB,CAAC,cAAc;AACtD,QAAQ,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC;AACtD,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;AACnC,QAAQ,OAAO,MAAM,GAAG,KAAK,CAAC,MAAM,EAAE;AACtC,YAAY,MAAM,IAAI,GAAG,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC;AACjD,YAAY,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,sBAAsB,CAAC,IAAI,CAAC,EAAE;AAChE;AACA,gBAAgB,MAAM,KAAK,GAAG,IAAI,IAAI,SAAS,CAAC;AAChD,sBAAsB,IAAI,GAAG,SAAS,CAAC;AACvC,sBAAsB,CAAC,IAAI,GAAG,YAAY,IAAI,SAAS,CAAC,OAAO,GAAG,EAAE;AACpE,gBAAgB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,GAAG,EAAE,GAAG,KAAK;AACtD,gBAAgB,IAAI,CAAC,QAAQ,EAAE;AAC/B,gBAAgB,MAAM,EAAE;AACxB,YAAY;AACZ,iBAAiB;AACjB,gBAAgB,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC,CAAC;AACtD,YAAY;AACZ,QAAQ;AACR,QAAQ,OAAO,EAAE,CAAC;AAClB,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE;AACvC,QAAQ,OAAO,MAAM,GAAG,KAAK,CAAC,MAAM,EAAE;AACtC,YAAY,MAAM,IAAI,GAAG,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC;AACjD,YAAY,IAAI,QAAQ,CAAC,IAAI,CAAC,EAAE;AAChC,gBAAgB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,GAAG,EAAE,IAAI,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC;AACxE,gBAAgB,IAAI,CAAC,QAAQ,EAAE;AAC/B,gBAAgB,MAAM,EAAE;AACxB,YAAY;AACZ,iBAAiB;AACjB,gBAAgB,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC,CAAC;AACtD,YAAY;AACZ,QAAQ;AACR,QAAQ,OAAO,EAAE,CAAC;AAClB,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,iBAAiB,CAAC,MAAM,EAAE,cAAc,EAAE;AAC9C;AACA,QAAQ,IAAI,IAAI,CAAC,QAAQ,IAAI,cAAc,EAAE;AAC7C,YAAY,IAAI,CAAC,MAAM,EAAE,0CAA0C,CAAC,IAAI,CAAC,QAAQ,CAAC;AAClF,YAAY,OAAO,CAAC;AACpB,QAAQ;AACR;AACA,QAAQ,IAAI,MAAM,KAAK,SAAS,CAAC,IAAI,EAAE;AACvC,YAAY,IAAI,CAAC,QAAQ,IAAI,CAAC;AAC9B,QAAQ;AACR,aAAa,IAAI,IAAI,CAAC,UAAU,KAAK,YAAY,CAAC,MAAM,EAAE;AAC1D,YAAY,OAAO,CAAC;AACpB,QAAQ;AACR,QAAQ,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC;AACxE,QAAQ,IAAI,IAAI,CAAC,MAAM,EAAE;AACzB,YAAY,IAAI,MAAM,KAAK,SAAS,CAAC,IAAI,EAAE;AAC3C,gBAAgB,IAAI,CAAC,MAAM,CAAC,uCAAuC,EAAE;AACrE,YAAY;AACZ,YAAY,IAAI,CAAC,MAAM,CAAC,iCAAiC,CAAC,IAAI,CAAC,MAAM,CAAC;AACtE,QAAQ;AACR,QAAQ,OAAO,IAAI,CAAC,QAAQ;AAC5B,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE;AACpC,QAAQ,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI;AACnC,QAAQ,IAAI,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC;AAChD;AACA,QAAQ,IAAI,WAAW,GAAG,CAAC,OAAO,GAAG,YAAY,CAAC,YAAY,KAAK,EAAE;AACrE,QAAQ,OAAO,MAAM,GAAG,KAAK,CAAC,MAAM,EAAE;AACtC;AACA,YAAY,IAAI,WAAW,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,YAAY,CAAC,MAAM,MAAM,CAAC,EAAE;AAC5E,gBAAgB,MAAM,SAAS,GAAG,CAAC,OAAO,GAAG,YAAY,CAAC,aAAa,KAAK,CAAC,CAAC;AAC9E;AACA,gBAAgB,IAAI,IAAI,CAAC,WAAW,KAAK,CAAC,EAAE;AAC5C,oBAAoB,MAAM,SAAS,GAAG,OAAO,GAAG,YAAY,CAAC,UAAU;AACvE,oBAAoB,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,SAAS,EAAE;AAChE,wBAAwB,OAAO,IAAI,CAAC,MAAM,KAAK;AAC/C,8BAA8B;AAC9B,8BAA8B,IAAI,CAAC,4BAA4B,EAAE;AACjE,oBAAoB;AACpB,oBAAoB,MAAM,EAAE;AAC5B,oBAAoB,IAAI,CAAC,MAAM,EAAE;AACjC,oBAAoB,IAAI,CAAC,WAAW,EAAE;AACtC,gBAAgB;AAChB;AACA,gBAAgB,OAAO,IAAI,CAAC,WAAW,GAAG,SAAS,EAAE;AACrD,oBAAoB,IAAI,MAAM,IAAI,KAAK,CAAC,MAAM,EAAE;AAChD,wBAAwB,OAAO,EAAE;AACjC,oBAAoB;AACpB,oBAAoB,MAAM,iBAAiB,GAAG,IAAI,CAAC,WAAW,GAAG,CAAC;AAClE,oBAAoB,MAAM,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,iBAAiB,IAAI,CAAC,CAAC,CAAC;AAChG,oBAAoB,MAAM,YAAY,GAAG,iBAAiB,GAAG,CAAC,KAAK;AACnE,0BAA0B,UAAU,GAAG;AACvC,0BAA0B,CAAC,UAAU,IAAI,CAAC,IAAI,IAAI;AAClD,oBAAoB,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,YAAY,EAAE;AACnE,wBAAwB,IAAI,CAAC,WAAW,GAAG,CAAC;AAC5C,wBAAwB,OAAO,IAAI,CAAC,MAAM,KAAK;AAC/C,8BAA8B;AAC9B,8BAA8B,IAAI,CAAC,4BAA4B,EAAE;AACjE,oBAAoB;AACpB,oBAAoB,MAAM,EAAE;AAC5B,oBAAoB,IAAI,CAAC,MAAM,EAAE;AACjC,oBAAoB,IAAI,CAAC,WAAW,EAAE;AACtC,gBAAgB;AAChB,gBAAgB,IAAI,CAAC,WAAW,GAAG,CAAC;AACpC,gBAAgB,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,SAAS,IAAI,CAAC,CAAC;AACtD,gBAAgB,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC;AACpD,gBAAgB,WAAW,GAAG,CAAC,OAAO,GAAG,YAAY,CAAC,YAAY,KAAK,EAAE;AACzE,YAAY;AACZ,YAAY,IAAI,MAAM,IAAI,KAAK,CAAC,MAAM;AACtC,gBAAgB;AAChB,YAAY,MAAM,IAAI,GAAG,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAI,IAAI,KAAK,SAAS,CAAC,IAAI;AACvC,gBAAgB,WAAW,KAAK,CAAC;AACjC,gBAAgB,CAAC,OAAO,GAAG,YAAY,CAAC,MAAM,MAAM,CAAC,EAAE;AACvD,gBAAgB,OAAO,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,EAAE,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC;AACzG,YAAY;AACZ,YAAY,IAAI,CAAC,SAAS,GAAG,eAAe,CAAC,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,WAAW,CAAC,EAAE,IAAI,CAAC;AAClH,YAAY,IAAI,IAAI,CAAC,SAAS,GAAG,CAAC,EAAE;AACpC,gBAAgB,OAAO,IAAI,CAAC,MAAM,KAAK,CAAC;AACxC;AACA,qBAAqB,IAAI,CAAC,UAAU,KAAK,YAAY,CAAC,SAAS;AAC/D;AACA,yBAAyB,WAAW,KAAK,CAAC;AAC1C;AACA,4BAA4B,6BAA6B,CAAC,IAAI,CAAC,CAAC;AAChE,sBAAsB;AACtB,sBAAsB,IAAI,CAAC,4BAA4B,EAAE;AACzD,YAAY;AACZ,YAAY,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC;AAChD,YAAY,WAAW,GAAG,CAAC,OAAO,GAAG,YAAY,CAAC,YAAY,KAAK,EAAE;AACrE;AACA,YAAY,IAAI,WAAW,KAAK,CAAC,EAAE;AACnC;AACA,gBAAgB,IAAI,IAAI,KAAK,SAAS,CAAC,IAAI,EAAE;AAC7C,oBAAoB,OAAO,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,EAAE,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC;AAC7G,gBAAgB;AAChB;AACA,gBAAgB,IAAI,IAAI,CAAC,UAAU,KAAK,YAAY,CAAC,MAAM;AAC3D,oBAAoB,CAAC,OAAO,GAAG,YAAY,CAAC,MAAM,MAAM,CAAC,EAAE;AAC3D,oBAAoB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS;AAChD,oBAAoB,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM;AAChD,oBAAoB,IAAI,CAAC,MAAM,GAAG,CAAC;AACnC,gBAAgB;AAChB,YAAY;AACZ;AACA,YAAY,MAAM,EAAE;AACpB,YAAY,IAAI,CAAC,MAAM,EAAE;AACzB,QAAQ;AACR,QAAQ,OAAO,EAAE;AACjB,IAAI;AACJ;AACA;AACA;AACA;AACA,IAAI,4BAA4B,GAAG;AACnC,QAAQ,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI;AAC3C,QAAQ,MAAM,WAAW,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,YAAY,KAAK,EAAE;AAClF,QAAQ,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC;AACpE,QAAQ,IAAI,CAAC,MAAM,EAAE,uCAAuC,EAAE;AAC9D,QAAQ,OAAO,IAAI,CAAC,QAAQ;AAC5B,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,mBAAmB,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE;AACvD,QAAQ,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI;AACnC,QAAQ,IAAI,CAAC,aAAa,CAAC,WAAW,KAAK;AAC3C,cAAc,UAAU,CAAC,MAAM,CAAC;AAChC,gBAAgB,EAAE,YAAY,CAAC,YAAY,GAAG,YAAY,CAAC,MAAM;AACjE,cAAc,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC;AAC/C,QAAQ,IAAI,WAAW,KAAK,CAAC,EAAE;AAC/B;AACA,YAAY,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC;AAChE,QAAQ;AACR,QAAQ,OAAO,QAAQ;AACvB,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,GAAG,GAAG;AACV,QAAQ,QAAQ,IAAI,CAAC,KAAK;AAC1B,YAAY,KAAK,kBAAkB,CAAC,WAAW,EAAE;AACjD;AACA,gBAAgB,OAAO,IAAI,CAAC,MAAM,KAAK,CAAC;AACxC,qBAAqB,IAAI,CAAC,UAAU,KAAK,YAAY,CAAC,SAAS;AAC/D,wBAAwB,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,SAAS;AACtD,sBAAsB,IAAI,CAAC,4BAA4B;AACvD,sBAAsB,CAAC;AACvB,YAAY;AACZ;AACA,YAAY,KAAK,kBAAkB,CAAC,cAAc,EAAE;AACpD,gBAAgB,OAAO,IAAI,CAAC,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC;AACnD,YAAY;AACZ,YAAY,KAAK,kBAAkB,CAAC,UAAU,EAAE;AAChD,gBAAgB,OAAO,IAAI,CAAC,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC;AACnD,YAAY;AACZ,YAAY,KAAK,kBAAkB,CAAC,YAAY,EAAE;AAClD,gBAAgB,IAAI,CAAC,MAAM,EAAE,0CAA0C,CAAC,IAAI,CAAC,QAAQ,CAAC;AACtF,gBAAgB,OAAO,CAAC;AACxB,YAAY;AACZ,YAAY,KAAK,kBAAkB,CAAC,WAAW,EAAE;AACjD;AACA,gBAAgB,OAAO,CAAC;AACxB,YAAY;AACZ;AACA,IAAI;AACJ;AAgCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,eAAe,CAAC,UAAU,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE;AACtE,IAAI,MAAM,WAAW,GAAG,CAAC,OAAO,GAAG,YAAY,CAAC,aAAa,KAAK,CAAC;AACnE,IAAI,MAAM,UAAU,GAAG,OAAO,GAAG,YAAY,CAAC,UAAU;AACxD;AACA,IAAI,IAAI,WAAW,KAAK,CAAC,EAAE;AAC3B,QAAQ,OAAO,UAAU,KAAK,CAAC,IAAI,IAAI,KAAK,UAAU,GAAG,SAAS,GAAG,EAAE;AACvE,IAAI;AACJ;AACA,IAAI,IAAI,UAAU,EAAE;AACpB,QAAQ,MAAM,KAAK,GAAG,IAAI,GAAG,UAAU;AACvC,QAAQ,OAAO,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI;AACrC,cAAc;AACd,cAAc,UAAU,CAAC,SAAS,GAAG,KAAK,CAAC,GAAG,CAAC;AAC/C,IAAI;AACJ;AACA,IAAI,MAAM,cAAc,GAAG,CAAC,WAAW,GAAG,CAAC,KAAK,CAAC;AACjD;AACA;AACA;AACA;AACA,IAAI,IAAI,EAAE,GAAG,CAAC;AACd,IAAI,IAAI,EAAE,GAAG,WAAW,GAAG,CAAC;AAC5B,IAAI,OAAO,EAAE,IAAI,EAAE,EAAE;AACrB,QAAQ,MAAM,GAAG,GAAG,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC;AACnC,QAAQ,MAAM,IAAI,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,MAAM,MAAM,GAAG,UAAU,CAAC,SAAS,GAAG,IAAI,CAAC;AACnD,QAAQ,MAAM,MAAM,GAAG,CAAC,MAAM,KAAK,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI;AACzD,QAAQ,IAAI,MAAM,GAAG,IAAI,EAAE;AAC3B,YAAY,EAAE,GAAG,GAAG,GAAG,CAAC;AACxB,QAAQ;AACR,aAAa,IAAI,MAAM,GAAG,IAAI,EAAE;AAChC,YAAY,EAAE,GAAG,GAAG,GAAG,CAAC;AACxB,QAAQ;AACR,aAAa;AACb,YAAY,OAAO,UAAU,CAAC,SAAS,GAAG,cAAc,GAAG,GAAG,CAAC;AAC/D,QAAQ;AACR,IAAI;AACJ,IAAI,OAAO,EAAE;AACb;;;;","x_google_ignoreList":[0]}