{"version":3,"file":"4684-bundle.js?1738747637004","mappings":"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,KAATA,IAAe,QAAWA,IAC3CilB,EAAQK,QAAQtlB,GACTm3B,IAGL,QAAmBn3B,IACrBitB,EAAciK,EACPP,EAAa32B,KAGlB,QAAcA,IAChBilB,EAAQK,QAAQtlB,GACTk3B,GAGF1pB,EAAIxN,EACb,CAGA,SAASm3B,EAAqBn3B,GAC5B,OACW,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,IACA,QAAkBA,IAElBilB,EAAQK,QAAQtlB,GACTm3B,GAGFC,EAA0Bp3B,EACnC,CAGA,SAASo3B,EAA0Bp3B,GACjC,OAAa,KAATA,GACFilB,EAAQK,QAAQtlB,GACTq3B,IAGL,QAAmBr3B,IACrBitB,EAAcmK,EACPT,EAAa32B,KAGlB,QAAcA,IAChBilB,EAAQK,QAAQtlB,GACTo3B,GAGFF,EAAel3B,EACxB,CAGA,SAASq3B,EAA4Br3B,GACnC,OACW,OAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,EAEOooB,EAAIpoB,GAGA,KAATA,GAAwB,KAATA,GACjBilB,EAAQK,QAAQtlB,GAChBguB,EAAShuB,EACFs3B,IAGL,QAAmBt3B,IACrBitB,EAAcoK,EACPV,EAAa32B,KAGlB,QAAcA,IAChBilB,EAAQK,QAAQtlB,GACTq3B,IAGTpS,EAAQK,QAAQtlB,GAChBguB,OAAS59B,EACFmnC,EACT,CAGA,SAASD,EAA4Bt3B,GACnC,OAAIA,IAASguB,GACX/I,EAAQK,QAAQtlB,GACTw3B,GAGI,OAATx3B,EACKooB,EAAIpoB,IAGT,QAAmBA,IACrBitB,EAAcqK,EACPX,EAAa32B,KAGtBilB,EAAQK,QAAQtlB,GACTs3B,EACT,CAGA,SAASE,EAAiCx3B,GACxC,OAAa,KAATA,GAAwB,KAATA,IAAe,QAA0BA,GACnDk3B,EAAel3B,GAGjBooB,EAAIpoB,EACb,CAGA,SAASu3B,EAA8Bv3B,GACrC,OACW,OAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,GACS,KAATA,EAEOooB,EAAIpoB,GAGA,KAATA,IAAe,QAA0BA,GACpCk3B,EAAel3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","sources":["webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/HandshakeProtocol.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/HubConnection.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/Subject.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/DefaultReconnectPolicy.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/Errors.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/HttpClient.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/ITransport.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/FetchHttpClient.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/XhrHttpClient.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/DefaultHttpClient.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/HeaderNames.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/AbortController.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/LongPollingTransport.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/ServerSentEventsTransport.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/WebSocketTransport.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/HttpConnection.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/JsonHubProtocol.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/HubConnectionBuilder.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/IHubProtocol.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/ILogger.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/Loggers.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/TextMessageFormat.js","webpack://klubble.app.client/../../../node_modules/@microsoft/signalr/dist/esm/Utils.js","webpack://klubble.app.client/../../../node_modules/ieee754/index.js","webpack://klubble.app.client/../../../node_modules/inherits/inherits_browser.js","webpack://klubble.app.client/../../../node_modules/inline-style-parser/index.js","webpack://klubble.app.client/../../../node_modules/json2mq/index.js","webpack://klubble.app.client/../../../node_modules/lodash.debounce/index.js","webpack://klubble.app.client/../../../node_modules/lodash/_Hash.js","webpack://klubble.app.client/../../../node_modules/lodash/_ListCache.js","webpack://klubble.app.client/../../../node_modules/lodash/_Map.js","webpack://klubble.app.client/../../../node_modules/lodash/_MapCache.js","webpack://klubble.app.client/../../../node_modules/lodash/_Stack.js","webpack://klubble.app.client/../../../node_modules/lodash/_Symbol.js","webpack://klubble.app.client/../../../node_modules/lodash/_Uint8Array.js","webpack://klubble.app.client/../../../node_modules/lodash/_apply.js","webpack://klubble.app.client/../../../node_modules/lodash/_arrayLikeKeys.js","webpack://klubble.app.client/../../../node_modules/lodash/_assignMergeValue.js","webpack://klubble.app.client/../../../node_modules/lodash/_assignValue.js","webpack://klubble.app.client/../../../node_modules/lodash/_assocIndexOf.js","webpack://klubble.app.client/../../../node_modules/lodash/_baseAssignValue.js","webpack://klubble.app.client/../../../node_modules/lodash/_baseCreate.js","webpack://klubble.app.client/../../../node_modules/lodash/_baseFor.js","webpack://klubble.app.client/../../../node_modules/lodash/_baseGetTag.js","webpack://klubble.app.client/../../../node_modules/lodash/_baseIsArguments.js","webpack://klubble.app.client/../../../node_modules/lodash/_baseIsNative.js","webpack://klubble.app.client/../../../node_modules/lodash/_baseIsTypedArray.js","webpack://klubble.app.client/../../../node_modules/lodash/_baseKeysIn.js","webpack://klubble.app.client/../../../node_modules/lodash/_baseMerge.js","webpack://klubble.app.client/../../../node_modules/lodash/_baseMergeDeep.js","webpack://klubble.app.client/../../../node_modules/lodash/_baseRest.js","webpack://klubble.app.client/../../../node_modules/lodash/_baseSetToString.js","webpack://klubble.app.client/../../../node_modules/lodash/_baseTimes.js","webpack://klubble.app.client/../../../node_modules/lodash/_baseUnary.js","webpack://klubble.app.client/../../../node_modules/lodash/_cloneArrayBuffer.js","webpack://klubble.app.client/../../../node_modules/lodash/_cloneBuffer.js","webpack://klubble.app.client/../../../node_modules/lodash/_cloneTypedArray.js","webpack://klubble.app.client/../../../node_modules/lodash/_copyArray.js","webpack://klubble.app.client/../../../node_modules/lodash/_copyObject.js","webpack://klubble.app.client/../../../node_modules/lodash/_coreJsData.js","webpack://klubble.app.client/../../../node_modules/lodash/_createAssigner.js","webpack://klubble.app.client/../../../node_modules/lodash/_createBaseFor.js","webpack://klubble.app.client/../../../node_modules/lodash/_defineProperty.js","webpack://klubble.app.client/../../../node_modules/lodash/_freeGlobal.js","webpack://klubble.app.client/../../../node_modules/lodash/_getMapData.js","webpack://klubble.app.client/../../../node_modules/lodash/_getNative.js","webpack://klubble.app.client/../../../node_modules/lodash/_getPrototype.js","webpack://klubble.app.client/../../../node_modules/lodash/_getRawTag.js","webpack://klubble.app.client/../../../node_modules/lodash/_getValue.js","webpack://klubble.app.client/../../../node_modules/lodash/_hashClear.js","webpack://klubble.app.client/../../../node_modules/lodash/_hashDelete.js","webpack://klubble.app.client/../../../node_modules/lodash/_hashGet.js","webpack://klubble.app.client/../../../node_modules/lodash/_hashHas.js","webpack://klubble.app.client/../../../node_modules/lodash/_hashSet.js","webpack://klubble.app.client/../../../node_modules/lodash/_initCloneObject.js","webpack://klubble.app.client/../../../node_modules/lodash/_isIndex.js","webpack://klubble.app.client/../../../node_modules/lodash/_isIterateeCall.js","webpack://klubble.app.client/../../../node_modules/lodash/_isKeyable.js","webpack://klubble.app.client/../../../node_modules/lodash/_isMasked.js","webpack://klubble.app.client/../../../node_modules/lodash/_isPrototype.js","webpack://klubble.app.client/../../../node_modules/lodash/_listCacheClear.js","webpack://klubble.app.client/../../../node_modules/lodash/_listCacheDelete.js","webpack://klubble.app.client/../../../node_modules/lodash/_listCacheGet.js","webpack://klubble.app.client/../../../node_modules/lodash/_listCacheHas.js","webpack://klubble.app.client/../../../node_modules/lodash/_listCacheSet.js","webpack://klubble.app.client/../../../node_modules/lodash/_mapCacheClear.js","webpack://klubble.app.client/../../../node_modules/lodash/_mapCacheDelete.js","webpack://klubble.app.client/../../../node_modules/lodash/_mapCacheGet.js","webpack://klubble.app.client/../../../node_modules/lodash/_mapCacheHas.js","webpack://klubble.app.client/../../../node_modules/lodash/_mapCacheSet.js","webpack://klubble.app.client/../../../node_modules/lodash/_nativeCreate.js","webpack://klubble.app.client/../../../node_modules/lodash/_nativeKeysIn.js","webpack://klubble.app.client/../../../node_modules/lodash/_nodeUtil.js","webpack://klubble.app.client/../../../node_modules/lodash/_objectToString.js","webpack://klubble.app.client/../../../node_modules/lodash/_overArg.js","webpack://klubble.app.client/../../../node_modules/lodash/_overRest.js","webpack://klubble.app.client/../../../node_modules/lodash/_root.js","webpack://klubble.app.client/../../../node_modules/lodash/_safeGet.js","webpack://klubble.app.client/../../../node_modules/lodash/_setToString.js","webpack://klubble.app.client/../../../node_modules/lodash/_shortOut.js","webpack://klubble.app.client/../../../node_modules/lodash/_stackClear.js","webpack://klubble.app.client/../../../node_modules/lodash/_stackDelete.js","webpack://klubble.app.client/../../../node_modules/lodash/_stackGet.js","webpack://klubble.app.client/../../../node_modules/lodash/_stackHas.js","webpack://klubble.app.client/../../../node_modules/lodash/_stackSet.js","webpack://klubble.app.client/../../../node_modules/lodash/_toSource.js","webpack://klubble.app.client/../../../node_modules/lodash/constant.js","webpack://klubble.app.client/../../../node_modules/lodash/eq.js","webpack://klubble.app.client/../../../node_modules/lodash/identity.js","webpack://klubble.app.client/../../../node_modules/lodash/isArguments.js","webpack://klubble.app.client/../../../node_modules/lodash/isArray.js","webpack://klubble.app.client/../../../node_modules/lodash/isArrayLike.js","webpack://klubble.app.client/../../../node_modules/lodash/isArrayLikeObject.js","webpack://klubble.app.client/../../../node_modules/lodash/isBuffer.js","webpack://klubble.app.client/../../../node_modules/lodash/isFunction.js","webpack://klubble.app.client/../../../node_modules/lodash/isLength.js","webpack://klubble.app.client/../../../node_modules/lodash/isObject.js","webpack://klubble.app.client/../../../node_modules/lodash/isObjectLike.js","webpack://klubble.app.client/../../../node_modules/lodash/isPlainObject.js","webpack://klubble.app.client/../../../node_modules/lodash/isTypedArray.js","webpack://klubble.app.client/../../../node_modules/lodash/keysIn.js","webpack://klubble.app.client/../../../node_modules/lodash/merge.js","webpack://klubble.app.client/../../../node_modules/lodash/stubFalse.js","webpack://klubble.app.client/../../../node_modules/lodash/toPlainObject.js","webpack://klubble.app.client/../../../node_modules/mini-create-react-context/dist/esm/index.js","webpack://klubble.app.client/../../../node_modules/immer/dist/immer.esm.mjs","webpack://klubble.app.client/../../../node_modules/is-plain-obj/index.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-string/lib/index.js","webpack://klubble.app.client/../../../node_modules/micromark-util-chunked/index.js","webpack://klubble.app.client/../../../node_modules/micromark-util-combine-extensions/index.js","webpack://klubble.app.client/../../../node_modules/micromark-factory-space/index.js","webpack://klubble.app.client/../../../node_modules/micromark/lib/initialize/content.js","webpack://klubble.app.client/../../../node_modules/micromark/lib/initialize/document.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/blank-line.js","webpack://klubble.app.client/../../../node_modules/micromark-util-subtokenize/index.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/content.js","webpack://klubble.app.client/../../../node_modules/micromark/lib/initialize/flow.js","webpack://klubble.app.client/../../../node_modules/micromark/lib/initialize/text.js","webpack://klubble.app.client/../../../node_modules/micromark-util-resolve-all/index.js","webpack://klubble.app.client/../../../node_modules/micromark/lib/create-tokenizer.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/thematic-break.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/list.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/block-quote.js","webpack://klubble.app.client/../../../node_modules/micromark-factory-destination/index.js","webpack://klubble.app.client/../../../node_modules/micromark-factory-label/index.js","webpack://klubble.app.client/../../../node_modules/micromark-factory-title/index.js","webpack://klubble.app.client/../../../node_modules/micromark-factory-whitespace/index.js","webpack://klubble.app.client/../../../node_modules/micromark-util-normalize-identifier/index.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/definition.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/code-indented.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/heading-atx.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/setext-underline.js","webpack://klubble.app.client/../../../node_modules/micromark-util-html-tag-name/index.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/html-flow.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/code-fenced.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/character-reference.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/character-escape.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/line-ending.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/label-end.js","webpack://klubble.app.client/../../../node_modules/micromark-util-classify-character/index.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/attention.js","webpack://klubble.app.client/../../../node_modules/micromark/lib/constructs.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/label-start-image.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/autolink.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/html-text.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/label-start-link.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/hard-break-escape.js","webpack://klubble.app.client/../../../node_modules/micromark-core-commonmark/lib/code-text.js","webpack://klubble.app.client/../../../node_modules/micromark/lib/preprocess.js","webpack://klubble.app.client/../../../node_modules/micromark-util-decode-numeric-character-reference/index.js","webpack://klubble.app.client/../../../node_modules/micromark-util-decode-string/index.js","webpack://klubble.app.client/../../../node_modules/mdast-util-from-markdown/lib/index.js","webpack://klubble.app.client/../../../node_modules/micromark/lib/postprocess.js","webpack://klubble.app.client/../../../node_modules/micromark/lib/parse.js","webpack://klubble.app.client/../../../node_modules/micromark-util-sanitize-uri/index.js","webpack://klubble.app.client/../../../node_modules/mdast-util-definitions/lib/index.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/revert.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/list-item.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/index.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/break.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/code.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/delete.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/footnote.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/heading.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/html.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/image.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/link.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/list.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/root.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/strong.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/table.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/table-cell.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/table-row.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/text.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/state.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/index.js","webpack://klubble.app.client/../../../node_modules/mdast-util-to-hast/lib/footer.js","webpack://klubble.app.client/../../../node_modules/micromark-util-character/lib/unicode-punctuation-regex.js","webpack://klubble.app.client/../../../node_modules/micromark-util-character/index.js"],"sourcesContent":["// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { TextMessageFormat } from \"./TextMessageFormat\";\r\nimport { isArrayBuffer } from \"./Utils\";\r\n/** @private */\r\nexport class HandshakeProtocol {\r\n    // Handshake request is always JSON\r\n    writeHandshakeRequest(handshakeRequest) {\r\n        return TextMessageFormat.write(JSON.stringify(handshakeRequest));\r\n    }\r\n    parseHandshakeResponse(data) {\r\n        let messageData;\r\n        let remainingData;\r\n        if (isArrayBuffer(data)) {\r\n            // Format is binary but still need to read JSON text from handshake response\r\n            const binaryData = new Uint8Array(data);\r\n            const separatorIndex = binaryData.indexOf(TextMessageFormat.RecordSeparatorCode);\r\n            if (separatorIndex === -1) {\r\n                throw new Error(\"Message is incomplete.\");\r\n            }\r\n            // content before separator is handshake response\r\n            // optional content after is additional messages\r\n            const responseLength = separatorIndex + 1;\r\n            messageData = String.fromCharCode.apply(null, Array.prototype.slice.call(binaryData.slice(0, responseLength)));\r\n            remainingData = (binaryData.byteLength > responseLength) ? binaryData.slice(responseLength).buffer : null;\r\n        }\r\n        else {\r\n            const textData = data;\r\n            const separatorIndex = textData.indexOf(TextMessageFormat.RecordSeparator);\r\n            if (separatorIndex === -1) {\r\n                throw new Error(\"Message is incomplete.\");\r\n            }\r\n            // content before separator is handshake response\r\n            // optional content after is additional messages\r\n            const responseLength = separatorIndex + 1;\r\n            messageData = textData.substring(0, responseLength);\r\n            remainingData = (textData.length > responseLength) ? textData.substring(responseLength) : null;\r\n        }\r\n        // At this point we should have just the single handshake message\r\n        const messages = TextMessageFormat.parse(messageData);\r\n        const response = JSON.parse(messages[0]);\r\n        if (response.type) {\r\n            throw new Error(\"Expected a handshake response from the server.\");\r\n        }\r\n        const responseMessage = response;\r\n        // multiple messages could have arrived with handshake\r\n        // return additional data to be parsed as usual, or null if all parsed\r\n        return [remainingData, responseMessage];\r\n    }\r\n}\r\n//# sourceMappingURL=HandshakeProtocol.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { HandshakeProtocol } from \"./HandshakeProtocol\";\r\nimport { MessageType } from \"./IHubProtocol\";\r\nimport { LogLevel } from \"./ILogger\";\r\nimport { Subject } from \"./Subject\";\r\nimport { Arg, getErrorString, Platform } from \"./Utils\";\r\nconst DEFAULT_TIMEOUT_IN_MS = 30 * 1000;\r\nconst DEFAULT_PING_INTERVAL_IN_MS = 15 * 1000;\r\n/** Describes the current state of the {@link HubConnection} to the server. */\r\nexport var HubConnectionState;\r\n(function (HubConnectionState) {\r\n    /** The hub connection is disconnected. */\r\n    HubConnectionState[\"Disconnected\"] = \"Disconnected\";\r\n    /** The hub connection is connecting. */\r\n    HubConnectionState[\"Connecting\"] = \"Connecting\";\r\n    /** The hub connection is connected. */\r\n    HubConnectionState[\"Connected\"] = \"Connected\";\r\n    /** The hub connection is disconnecting. */\r\n    HubConnectionState[\"Disconnecting\"] = \"Disconnecting\";\r\n    /** The hub connection is reconnecting. */\r\n    HubConnectionState[\"Reconnecting\"] = \"Reconnecting\";\r\n})(HubConnectionState || (HubConnectionState = {}));\r\n/** Represents a connection to a SignalR Hub. */\r\nexport class HubConnection {\r\n    constructor(connection, logger, protocol, reconnectPolicy) {\r\n        this._nextKeepAlive = 0;\r\n        this._freezeEventListener = () => {\r\n            this._logger.log(LogLevel.Warning, \"The page is being frozen, this will likely lead to the connection being closed and messages being lost. For more information see the docs at https://docs.microsoft.com/aspnet/core/signalr/javascript-client#bsleep\");\r\n        };\r\n        Arg.isRequired(connection, \"connection\");\r\n        Arg.isRequired(logger, \"logger\");\r\n        Arg.isRequired(protocol, \"protocol\");\r\n        this.serverTimeoutInMilliseconds = DEFAULT_TIMEOUT_IN_MS;\r\n        this.keepAliveIntervalInMilliseconds = DEFAULT_PING_INTERVAL_IN_MS;\r\n        this._logger = logger;\r\n        this._protocol = protocol;\r\n        this.connection = connection;\r\n        this._reconnectPolicy = reconnectPolicy;\r\n        this._handshakeProtocol = new HandshakeProtocol();\r\n        this.connection.onreceive = (data) => this._processIncomingData(data);\r\n        this.connection.onclose = (error) => this._connectionClosed(error);\r\n        this._callbacks = {};\r\n        this._methods = {};\r\n        this._closedCallbacks = [];\r\n        this._reconnectingCallbacks = [];\r\n        this._reconnectedCallbacks = [];\r\n        this._invocationId = 0;\r\n        this._receivedHandshakeResponse = false;\r\n        this._connectionState = HubConnectionState.Disconnected;\r\n        this._connectionStarted = false;\r\n        this._cachedPingMessage = this._protocol.writeMessage({ type: MessageType.Ping });\r\n    }\r\n    /** @internal */\r\n    // Using a public static factory method means we can have a private constructor and an _internal_\r\n    // create method that can be used by HubConnectionBuilder. An \"internal\" constructor would just\r\n    // be stripped away and the '.d.ts' file would have no constructor, which is interpreted as a\r\n    // public parameter-less constructor.\r\n    static create(connection, logger, protocol, reconnectPolicy) {\r\n        return new HubConnection(connection, logger, protocol, reconnectPolicy);\r\n    }\r\n    /** Indicates the state of the {@link HubConnection} to the server. */\r\n    get state() {\r\n        return this._connectionState;\r\n    }\r\n    /** Represents the connection id of the {@link HubConnection} on the server. The connection id will be null when the connection is either\r\n     *  in the disconnected state or if the negotiation step was skipped.\r\n     */\r\n    get connectionId() {\r\n        return this.connection ? (this.connection.connectionId || null) : null;\r\n    }\r\n    /** Indicates the url of the {@link HubConnection} to the server. */\r\n    get baseUrl() {\r\n        return this.connection.baseUrl || \"\";\r\n    }\r\n    /**\r\n     * Sets a new url for the HubConnection. Note that the url can only be changed when the connection is in either the Disconnected or\r\n     * Reconnecting states.\r\n     * @param {string} url The url to connect to.\r\n     */\r\n    set baseUrl(url) {\r\n        if (this._connectionState !== HubConnectionState.Disconnected && this._connectionState !== HubConnectionState.Reconnecting) {\r\n            throw new Error(\"The HubConnection must be in the Disconnected or Reconnecting state to change the url.\");\r\n        }\r\n        if (!url) {\r\n            throw new Error(\"The HubConnection url must be a valid url.\");\r\n        }\r\n        this.connection.baseUrl = url;\r\n    }\r\n    /** Starts the connection.\r\n     *\r\n     * @returns {Promise<void>} A Promise that resolves when the connection has been successfully established, or rejects with an error.\r\n     */\r\n    start() {\r\n        this._startPromise = this._startWithStateTransitions();\r\n        return this._startPromise;\r\n    }\r\n    async _startWithStateTransitions() {\r\n        if (this._connectionState !== HubConnectionState.Disconnected) {\r\n            return Promise.reject(new Error(\"Cannot start a HubConnection that is not in the 'Disconnected' state.\"));\r\n        }\r\n        this._connectionState = HubConnectionState.Connecting;\r\n        this._logger.log(LogLevel.Debug, \"Starting HubConnection.\");\r\n        try {\r\n            await this._startInternal();\r\n            if (Platform.isBrowser) {\r\n                // Log when the browser freezes the tab so users know why their connection unexpectedly stopped working\r\n                window.document.addEventListener(\"freeze\", this._freezeEventListener);\r\n            }\r\n            this._connectionState = HubConnectionState.Connected;\r\n            this._connectionStarted = true;\r\n            this._logger.log(LogLevel.Debug, \"HubConnection connected successfully.\");\r\n        }\r\n        catch (e) {\r\n            this._connectionState = HubConnectionState.Disconnected;\r\n            this._logger.log(LogLevel.Debug, `HubConnection failed to start successfully because of error '${e}'.`);\r\n            return Promise.reject(e);\r\n        }\r\n    }\r\n    async _startInternal() {\r\n        this._stopDuringStartError = undefined;\r\n        this._receivedHandshakeResponse = false;\r\n        // Set up the promise before any connection is (re)started otherwise it could race with received messages\r\n        const handshakePromise = new Promise((resolve, reject) => {\r\n            this._handshakeResolver = resolve;\r\n            this._handshakeRejecter = reject;\r\n        });\r\n        await this.connection.start(this._protocol.transferFormat);\r\n        try {\r\n            const handshakeRequest = {\r\n                protocol: this._protocol.name,\r\n                version: this._protocol.version,\r\n            };\r\n            this._logger.log(LogLevel.Debug, \"Sending handshake request.\");\r\n            await this._sendMessage(this._handshakeProtocol.writeHandshakeRequest(handshakeRequest));\r\n            this._logger.log(LogLevel.Information, `Using HubProtocol '${this._protocol.name}'.`);\r\n            // defensively cleanup timeout in case we receive a message from the server before we finish start\r\n            this._cleanupTimeout();\r\n            this._resetTimeoutPeriod();\r\n            this._resetKeepAliveInterval();\r\n            await handshakePromise;\r\n            // It's important to check the stopDuringStartError instead of just relying on the handshakePromise\r\n            // being rejected on close, because this continuation can run after both the handshake completed successfully\r\n            // and the connection was closed.\r\n            if (this._stopDuringStartError) {\r\n                // It's important to throw instead of returning a rejected promise, because we don't want to allow any state\r\n                // transitions to occur between now and the calling code observing the exceptions. Returning a rejected promise\r\n                // will cause the calling continuation to get scheduled to run later.\r\n                // eslint-disable-next-line @typescript-eslint/no-throw-literal\r\n                throw this._stopDuringStartError;\r\n            }\r\n        }\r\n        catch (e) {\r\n            this._logger.log(LogLevel.Debug, `Hub handshake failed with error '${e}' during start(). Stopping HubConnection.`);\r\n            this._cleanupTimeout();\r\n            this._cleanupPingTimer();\r\n            // HttpConnection.stop() should not complete until after the onclose callback is invoked.\r\n            // This will transition the HubConnection to the disconnected state before HttpConnection.stop() completes.\r\n            await this.connection.stop(e);\r\n            throw e;\r\n        }\r\n    }\r\n    /** Stops the connection.\r\n     *\r\n     * @returns {Promise<void>} A Promise that resolves when the connection has been successfully terminated, or rejects with an error.\r\n     */\r\n    async stop() {\r\n        // Capture the start promise before the connection might be restarted in an onclose callback.\r\n        const startPromise = this._startPromise;\r\n        this._stopPromise = this._stopInternal();\r\n        await this._stopPromise;\r\n        try {\r\n            // Awaiting undefined continues immediately\r\n            await startPromise;\r\n        }\r\n        catch (e) {\r\n            // This exception is returned to the user as a rejected Promise from the start method.\r\n        }\r\n    }\r\n    _stopInternal(error) {\r\n        if (this._connectionState === HubConnectionState.Disconnected) {\r\n            this._logger.log(LogLevel.Debug, `Call to HubConnection.stop(${error}) ignored because it is already in the disconnected state.`);\r\n            return Promise.resolve();\r\n        }\r\n        if (this._connectionState === HubConnectionState.Disconnecting) {\r\n            this._logger.log(LogLevel.Debug, `Call to HttpConnection.stop(${error}) ignored because the connection is already in the disconnecting state.`);\r\n            return this._stopPromise;\r\n        }\r\n        this._connectionState = HubConnectionState.Disconnecting;\r\n        this._logger.log(LogLevel.Debug, \"Stopping HubConnection.\");\r\n        if (this._reconnectDelayHandle) {\r\n            // We're in a reconnect delay which means the underlying connection is currently already stopped.\r\n            // Just clear the handle to stop the reconnect loop (which no one is waiting on thankfully) and\r\n            // fire the onclose callbacks.\r\n            this._logger.log(LogLevel.Debug, \"Connection stopped during reconnect delay. Done reconnecting.\");\r\n            clearTimeout(this._reconnectDelayHandle);\r\n            this._reconnectDelayHandle = undefined;\r\n            this._completeClose();\r\n            return Promise.resolve();\r\n        }\r\n        this._cleanupTimeout();\r\n        this._cleanupPingTimer();\r\n        this._stopDuringStartError = error || new Error(\"The connection was stopped before the hub handshake could complete.\");\r\n        // HttpConnection.stop() should not complete until after either HttpConnection.start() fails\r\n        // or the onclose callback is invoked. The onclose callback will transition the HubConnection\r\n        // to the disconnected state if need be before HttpConnection.stop() completes.\r\n        return this.connection.stop(error);\r\n    }\r\n    /** Invokes a streaming hub method on the server using the specified name and arguments.\r\n     *\r\n     * @typeparam T The type of the items returned by the server.\r\n     * @param {string} methodName The name of the server method to invoke.\r\n     * @param {any[]} args The arguments used to invoke the server method.\r\n     * @returns {IStreamResult<T>} An object that yields results from the server as they are received.\r\n     */\r\n    stream(methodName, ...args) {\r\n        const [streams, streamIds] = this._replaceStreamingParams(args);\r\n        const invocationDescriptor = this._createStreamInvocation(methodName, args, streamIds);\r\n        // eslint-disable-next-line prefer-const\r\n        let promiseQueue;\r\n        const subject = new Subject();\r\n        subject.cancelCallback = () => {\r\n            const cancelInvocation = this._createCancelInvocation(invocationDescriptor.invocationId);\r\n            delete this._callbacks[invocationDescriptor.invocationId];\r\n            return promiseQueue.then(() => {\r\n                return this._sendWithProtocol(cancelInvocation);\r\n            });\r\n        };\r\n        this._callbacks[invocationDescriptor.invocationId] = (invocationEvent, error) => {\r\n            if (error) {\r\n                subject.error(error);\r\n                return;\r\n            }\r\n            else if (invocationEvent) {\r\n                // invocationEvent will not be null when an error is not passed to the callback\r\n                if (invocationEvent.type === MessageType.Completion) {\r\n                    if (invocationEvent.error) {\r\n                        subject.error(new Error(invocationEvent.error));\r\n                    }\r\n                    else {\r\n                        subject.complete();\r\n                    }\r\n                }\r\n                else {\r\n                    subject.next((invocationEvent.item));\r\n                }\r\n            }\r\n        };\r\n        promiseQueue = this._sendWithProtocol(invocationDescriptor)\r\n            .catch((e) => {\r\n            subject.error(e);\r\n            delete this._callbacks[invocationDescriptor.invocationId];\r\n        });\r\n        this._launchStreams(streams, promiseQueue);\r\n        return subject;\r\n    }\r\n    _sendMessage(message) {\r\n        this._resetKeepAliveInterval();\r\n        return this.connection.send(message);\r\n    }\r\n    /**\r\n     * Sends a js object to the server.\r\n     * @param message The js object to serialize and send.\r\n     */\r\n    _sendWithProtocol(message) {\r\n        return this._sendMessage(this._protocol.writeMessage(message));\r\n    }\r\n    /** Invokes a hub method on the server using the specified name and arguments. Does not wait for a response from the receiver.\r\n     *\r\n     * The Promise returned by this method resolves when the client has sent the invocation to the server. The server may still\r\n     * be processing the invocation.\r\n     *\r\n     * @param {string} methodName The name of the server method to invoke.\r\n     * @param {any[]} args The arguments used to invoke the server method.\r\n     * @returns {Promise<void>} A Promise that resolves when the invocation has been successfully sent, or rejects with an error.\r\n     */\r\n    send(methodName, ...args) {\r\n        const [streams, streamIds] = this._replaceStreamingParams(args);\r\n        const sendPromise = this._sendWithProtocol(this._createInvocation(methodName, args, true, streamIds));\r\n        this._launchStreams(streams, sendPromise);\r\n        return sendPromise;\r\n    }\r\n    /** Invokes a hub method on the server using the specified name and arguments.\r\n     *\r\n     * The Promise returned by this method resolves when the server indicates it has finished invoking the method. When the promise\r\n     * resolves, the server has finished invoking the method. If the server method returns a result, it is produced as the result of\r\n     * resolving the Promise.\r\n     *\r\n     * @typeparam T The expected return type.\r\n     * @param {string} methodName The name of the server method to invoke.\r\n     * @param {any[]} args The arguments used to invoke the server method.\r\n     * @returns {Promise<T>} A Promise that resolves with the result of the server method (if any), or rejects with an error.\r\n     */\r\n    invoke(methodName, ...args) {\r\n        const [streams, streamIds] = this._replaceStreamingParams(args);\r\n        const invocationDescriptor = this._createInvocation(methodName, args, false, streamIds);\r\n        const p = new Promise((resolve, reject) => {\r\n            // invocationId will always have a value for a non-blocking invocation\r\n            this._callbacks[invocationDescriptor.invocationId] = (invocationEvent, error) => {\r\n                if (error) {\r\n                    reject(error);\r\n                    return;\r\n                }\r\n                else if (invocationEvent) {\r\n                    // invocationEvent will not be null when an error is not passed to the callback\r\n                    if (invocationEvent.type === MessageType.Completion) {\r\n                        if (invocationEvent.error) {\r\n                            reject(new Error(invocationEvent.error));\r\n                        }\r\n                        else {\r\n                            resolve(invocationEvent.result);\r\n                        }\r\n                    }\r\n                    else {\r\n                        reject(new Error(`Unexpected message type: ${invocationEvent.type}`));\r\n                    }\r\n                }\r\n            };\r\n            const promiseQueue = this._sendWithProtocol(invocationDescriptor)\r\n                .catch((e) => {\r\n                reject(e);\r\n                // invocationId will always have a value for a non-blocking invocation\r\n                delete this._callbacks[invocationDescriptor.invocationId];\r\n            });\r\n            this._launchStreams(streams, promiseQueue);\r\n        });\r\n        return p;\r\n    }\r\n    /** Registers a handler that will be invoked when the hub method with the specified method name is invoked.\r\n     *\r\n     * @param {string} methodName The name of the hub method to define.\r\n     * @param {Function} newMethod The handler that will be raised when the hub method is invoked.\r\n     */\r\n    on(methodName, newMethod) {\r\n        if (!methodName || !newMethod) {\r\n            return;\r\n        }\r\n        methodName = methodName.toLowerCase();\r\n        if (!this._methods[methodName]) {\r\n            this._methods[methodName] = [];\r\n        }\r\n        // Preventing adding the same handler multiple times.\r\n        if (this._methods[methodName].indexOf(newMethod) !== -1) {\r\n            return;\r\n        }\r\n        this._methods[methodName].push(newMethod);\r\n    }\r\n    off(methodName, method) {\r\n        if (!methodName) {\r\n            return;\r\n        }\r\n        methodName = methodName.toLowerCase();\r\n        const handlers = this._methods[methodName];\r\n        if (!handlers) {\r\n            return;\r\n        }\r\n        if (method) {\r\n            const removeIdx = handlers.indexOf(method);\r\n            if (removeIdx !== -1) {\r\n                handlers.splice(removeIdx, 1);\r\n                if (handlers.length === 0) {\r\n                    delete this._methods[methodName];\r\n                }\r\n            }\r\n        }\r\n        else {\r\n            delete this._methods[methodName];\r\n        }\r\n    }\r\n    /** Registers a handler that will be invoked when the connection is closed.\r\n     *\r\n     * @param {Function} callback The handler that will be invoked when the connection is closed. Optionally receives a single argument containing the error that caused the connection to close (if any).\r\n     */\r\n    onclose(callback) {\r\n        if (callback) {\r\n            this._closedCallbacks.push(callback);\r\n        }\r\n    }\r\n    /** Registers a handler that will be invoked when the connection starts reconnecting.\r\n     *\r\n     * @param {Function} callback The handler that will be invoked when the connection starts reconnecting. Optionally receives a single argument containing the error that caused the connection to start reconnecting (if any).\r\n     */\r\n    onreconnecting(callback) {\r\n        if (callback) {\r\n            this._reconnectingCallbacks.push(callback);\r\n        }\r\n    }\r\n    /** Registers a handler that will be invoked when the connection successfully reconnects.\r\n     *\r\n     * @param {Function} callback The handler that will be invoked when the connection successfully reconnects.\r\n     */\r\n    onreconnected(callback) {\r\n        if (callback) {\r\n            this._reconnectedCallbacks.push(callback);\r\n        }\r\n    }\r\n    _processIncomingData(data) {\r\n        this._cleanupTimeout();\r\n        if (!this._receivedHandshakeResponse) {\r\n            data = this._processHandshakeResponse(data);\r\n            this._receivedHandshakeResponse = true;\r\n        }\r\n        // Data may have all been read when processing handshake response\r\n        if (data) {\r\n            // Parse the messages\r\n            const messages = this._protocol.parseMessages(data, this._logger);\r\n            for (const message of messages) {\r\n                switch (message.type) {\r\n                    case MessageType.Invocation:\r\n                        this._invokeClientMethod(message);\r\n                        break;\r\n                    case MessageType.StreamItem:\r\n                    case MessageType.Completion: {\r\n                        const callback = this._callbacks[message.invocationId];\r\n                        if (callback) {\r\n                            if (message.type === MessageType.Completion) {\r\n                                delete this._callbacks[message.invocationId];\r\n                            }\r\n                            try {\r\n                                callback(message);\r\n                            }\r\n                            catch (e) {\r\n                                this._logger.log(LogLevel.Error, `Stream callback threw error: ${getErrorString(e)}`);\r\n                            }\r\n                        }\r\n                        break;\r\n                    }\r\n                    case MessageType.Ping:\r\n                        // Don't care about pings\r\n                        break;\r\n                    case MessageType.Close: {\r\n                        this._logger.log(LogLevel.Information, \"Close message received from server.\");\r\n                        const error = message.error ? new Error(\"Server returned an error on close: \" + message.error) : undefined;\r\n                        if (message.allowReconnect === true) {\r\n                            // It feels wrong not to await connection.stop() here, but processIncomingData is called as part of an onreceive callback which is not async,\r\n                            // this is already the behavior for serverTimeout(), and HttpConnection.Stop() should catch and log all possible exceptions.\r\n                            // eslint-disable-next-line @typescript-eslint/no-floating-promises\r\n                            this.connection.stop(error);\r\n                        }\r\n                        else {\r\n                            // We cannot await stopInternal() here, but subsequent calls to stop() will await this if stopInternal() is still ongoing.\r\n                            this._stopPromise = this._stopInternal(error);\r\n                        }\r\n                        break;\r\n                    }\r\n                    default:\r\n                        this._logger.log(LogLevel.Warning, `Invalid message type: ${message.type}.`);\r\n                        break;\r\n                }\r\n            }\r\n        }\r\n        this._resetTimeoutPeriod();\r\n    }\r\n    _processHandshakeResponse(data) {\r\n        let responseMessage;\r\n        let remainingData;\r\n        try {\r\n            [remainingData, responseMessage] = this._handshakeProtocol.parseHandshakeResponse(data);\r\n        }\r\n        catch (e) {\r\n            const message = \"Error parsing handshake response: \" + e;\r\n            this._logger.log(LogLevel.Error, message);\r\n            const error = new Error(message);\r\n            this._handshakeRejecter(error);\r\n            throw error;\r\n        }\r\n        if (responseMessage.error) {\r\n            const message = \"Server returned handshake error: \" + responseMessage.error;\r\n            this._logger.log(LogLevel.Error, message);\r\n            const error = new Error(message);\r\n            this._handshakeRejecter(error);\r\n            throw error;\r\n        }\r\n        else {\r\n            this._logger.log(LogLevel.Debug, \"Server handshake complete.\");\r\n        }\r\n        this._handshakeResolver();\r\n        return remainingData;\r\n    }\r\n    _resetKeepAliveInterval() {\r\n        if (this.connection.features.inherentKeepAlive) {\r\n            return;\r\n        }\r\n        // Set the time we want the next keep alive to be sent\r\n        // Timer will be setup on next message receive\r\n        this._nextKeepAlive = new Date().getTime() + this.keepAliveIntervalInMilliseconds;\r\n        this._cleanupPingTimer();\r\n    }\r\n    _resetTimeoutPeriod() {\r\n        if (!this.connection.features || !this.connection.features.inherentKeepAlive) {\r\n            // Set the timeout timer\r\n            this._timeoutHandle = setTimeout(() => this.serverTimeout(), this.serverTimeoutInMilliseconds);\r\n            // Set keepAlive timer if there isn't one\r\n            if (this._pingServerHandle === undefined) {\r\n                let nextPing = this._nextKeepAlive - new Date().getTime();\r\n                if (nextPing < 0) {\r\n                    nextPing = 0;\r\n                }\r\n                // The timer needs to be set from a networking callback to avoid Chrome timer throttling from causing timers to run once a minute\r\n                this._pingServerHandle = setTimeout(async () => {\r\n                    if (this._connectionState === HubConnectionState.Connected) {\r\n                        try {\r\n                            await this._sendMessage(this._cachedPingMessage);\r\n                        }\r\n                        catch {\r\n                            // We don't care about the error. It should be seen elsewhere in the client.\r\n                            // The connection is probably in a bad or closed state now, cleanup the timer so it stops triggering\r\n                            this._cleanupPingTimer();\r\n                        }\r\n                    }\r\n                }, nextPing);\r\n            }\r\n        }\r\n    }\r\n    // eslint-disable-next-line @typescript-eslint/naming-convention\r\n    serverTimeout() {\r\n        // The server hasn't talked to us in a while. It doesn't like us anymore ... :(\r\n        // Terminate the connection, but we don't need to wait on the promise. This could trigger reconnecting.\r\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\r\n        this.connection.stop(new Error(\"Server timeout elapsed without receiving a message from the server.\"));\r\n    }\r\n    _invokeClientMethod(invocationMessage) {\r\n        const methods = this._methods[invocationMessage.target.toLowerCase()];\r\n        if (methods) {\r\n            try {\r\n                methods.forEach((m) => m.apply(this, invocationMessage.arguments));\r\n            }\r\n            catch (e) {\r\n                this._logger.log(LogLevel.Error, `A callback for the method ${invocationMessage.target.toLowerCase()} threw error '${e}'.`);\r\n            }\r\n            if (invocationMessage.invocationId) {\r\n                // This is not supported in v1. So we return an error to avoid blocking the server waiting for the response.\r\n                const message = \"Server requested a response, which is not supported in this version of the client.\";\r\n                this._logger.log(LogLevel.Error, message);\r\n                // We don't want to wait on the stop itself.\r\n                this._stopPromise = this._stopInternal(new Error(message));\r\n            }\r\n        }\r\n        else {\r\n            this._logger.log(LogLevel.Warning, `No client method with the name '${invocationMessage.target}' found.`);\r\n        }\r\n    }\r\n    _connectionClosed(error) {\r\n        this._logger.log(LogLevel.Debug, `HubConnection.connectionClosed(${error}) called while in state ${this._connectionState}.`);\r\n        // Triggering this.handshakeRejecter is insufficient because it could already be resolved without the continuation having run yet.\r\n        this._stopDuringStartError = this._stopDuringStartError || error || new Error(\"The underlying connection was closed before the hub handshake could complete.\");\r\n        // If the handshake is in progress, start will be waiting for the handshake promise, so we complete it.\r\n        // If it has already completed, this should just noop.\r\n        if (this._handshakeResolver) {\r\n            this._handshakeResolver();\r\n        }\r\n        this._cancelCallbacksWithError(error || new Error(\"Invocation canceled due to the underlying connection being closed.\"));\r\n        this._cleanupTimeout();\r\n        this._cleanupPingTimer();\r\n        if (this._connectionState === HubConnectionState.Disconnecting) {\r\n            this._completeClose(error);\r\n        }\r\n        else if (this._connectionState === HubConnectionState.Connected && this._reconnectPolicy) {\r\n            // eslint-disable-next-line @typescript-eslint/no-floating-promises\r\n            this._reconnect(error);\r\n        }\r\n        else if (this._connectionState === HubConnectionState.Connected) {\r\n            this._completeClose(error);\r\n        }\r\n        // If none of the above if conditions were true were called the HubConnection must be in either:\r\n        // 1. The Connecting state in which case the handshakeResolver will complete it and stopDuringStartError will fail it.\r\n        // 2. The Reconnecting state in which case the handshakeResolver will complete it and stopDuringStartError will fail the current reconnect attempt\r\n        //    and potentially continue the reconnect() loop.\r\n        // 3. The Disconnected state in which case we're already done.\r\n    }\r\n    _completeClose(error) {\r\n        if (this._connectionStarted) {\r\n            this._connectionState = HubConnectionState.Disconnected;\r\n            this._connectionStarted = false;\r\n            if (Platform.isBrowser) {\r\n                window.document.removeEventListener(\"freeze\", this._freezeEventListener);\r\n            }\r\n            try {\r\n                this._closedCallbacks.forEach((c) => c.apply(this, [error]));\r\n            }\r\n            catch (e) {\r\n                this._logger.log(LogLevel.Error, `An onclose callback called with error '${error}' threw error '${e}'.`);\r\n            }\r\n        }\r\n    }\r\n    async _reconnect(error) {\r\n        const reconnectStartTime = Date.now();\r\n        let previousReconnectAttempts = 0;\r\n        let retryError = error !== undefined ? error : new Error(\"Attempting to reconnect due to a unknown error.\");\r\n        let nextRetryDelay = this._getNextRetryDelay(previousReconnectAttempts++, 0, retryError);\r\n        if (nextRetryDelay === null) {\r\n            this._logger.log(LogLevel.Debug, \"Connection not reconnecting because the IRetryPolicy returned null on the first reconnect attempt.\");\r\n            this._completeClose(error);\r\n            return;\r\n        }\r\n        this._connectionState = HubConnectionState.Reconnecting;\r\n        if (error) {\r\n            this._logger.log(LogLevel.Information, `Connection reconnecting because of error '${error}'.`);\r\n        }\r\n        else {\r\n            this._logger.log(LogLevel.Information, \"Connection reconnecting.\");\r\n        }\r\n        if (this._reconnectingCallbacks.length !== 0) {\r\n            try {\r\n                this._reconnectingCallbacks.forEach((c) => c.apply(this, [error]));\r\n            }\r\n            catch (e) {\r\n                this._logger.log(LogLevel.Error, `An onreconnecting callback called with error '${error}' threw error '${e}'.`);\r\n            }\r\n            // Exit early if an onreconnecting callback called connection.stop().\r\n            if (this._connectionState !== HubConnectionState.Reconnecting) {\r\n                this._logger.log(LogLevel.Debug, \"Connection left the reconnecting state in onreconnecting callback. Done reconnecting.\");\r\n                return;\r\n            }\r\n        }\r\n        while (nextRetryDelay !== null) {\r\n            this._logger.log(LogLevel.Information, `Reconnect attempt number ${previousReconnectAttempts} will start in ${nextRetryDelay} ms.`);\r\n            await new Promise((resolve) => {\r\n                this._reconnectDelayHandle = setTimeout(resolve, nextRetryDelay);\r\n            });\r\n            this._reconnectDelayHandle = undefined;\r\n            if (this._connectionState !== HubConnectionState.Reconnecting) {\r\n                this._logger.log(LogLevel.Debug, \"Connection left the reconnecting state during reconnect delay. Done reconnecting.\");\r\n                return;\r\n            }\r\n            try {\r\n                await this._startInternal();\r\n                this._connectionState = HubConnectionState.Connected;\r\n                this._logger.log(LogLevel.Information, \"HubConnection reconnected successfully.\");\r\n                if (this._reconnectedCallbacks.length !== 0) {\r\n                    try {\r\n                        this._reconnectedCallbacks.forEach((c) => c.apply(this, [this.connection.connectionId]));\r\n                    }\r\n                    catch (e) {\r\n                        this._logger.log(LogLevel.Error, `An onreconnected callback called with connectionId '${this.connection.connectionId}; threw error '${e}'.`);\r\n                    }\r\n                }\r\n                return;\r\n            }\r\n            catch (e) {\r\n                this._logger.log(LogLevel.Information, `Reconnect attempt failed because of error '${e}'.`);\r\n                if (this._connectionState !== HubConnectionState.Reconnecting) {\r\n                    this._logger.log(LogLevel.Debug, `Connection moved to the '${this._connectionState}' from the reconnecting state during reconnect attempt. Done reconnecting.`);\r\n                    // The TypeScript compiler thinks that connectionState must be Connected here. The TypeScript compiler is wrong.\r\n                    if (this._connectionState === HubConnectionState.Disconnecting) {\r\n                        this._completeClose();\r\n                    }\r\n                    return;\r\n                }\r\n                retryError = e instanceof Error ? e : new Error(e.toString());\r\n                nextRetryDelay = this._getNextRetryDelay(previousReconnectAttempts++, Date.now() - reconnectStartTime, retryError);\r\n            }\r\n        }\r\n        this._logger.log(LogLevel.Information, `Reconnect retries have been exhausted after ${Date.now() - reconnectStartTime} ms and ${previousReconnectAttempts} failed attempts. Connection disconnecting.`);\r\n        this._completeClose();\r\n    }\r\n    _getNextRetryDelay(previousRetryCount, elapsedMilliseconds, retryReason) {\r\n        try {\r\n            return this._reconnectPolicy.nextRetryDelayInMilliseconds({\r\n                elapsedMilliseconds,\r\n                previousRetryCount,\r\n                retryReason,\r\n            });\r\n        }\r\n        catch (e) {\r\n            this._logger.log(LogLevel.Error, `IRetryPolicy.nextRetryDelayInMilliseconds(${previousRetryCount}, ${elapsedMilliseconds}) threw error '${e}'.`);\r\n            return null;\r\n        }\r\n    }\r\n    _cancelCallbacksWithError(error) {\r\n        const callbacks = this._callbacks;\r\n        this._callbacks = {};\r\n        Object.keys(callbacks)\r\n            .forEach((key) => {\r\n            const callback = callbacks[key];\r\n            try {\r\n                callback(null, error);\r\n            }\r\n            catch (e) {\r\n                this._logger.log(LogLevel.Error, `Stream 'error' callback called with '${error}' threw error: ${getErrorString(e)}`);\r\n            }\r\n        });\r\n    }\r\n    _cleanupPingTimer() {\r\n        if (this._pingServerHandle) {\r\n            clearTimeout(this._pingServerHandle);\r\n            this._pingServerHandle = undefined;\r\n        }\r\n    }\r\n    _cleanupTimeout() {\r\n        if (this._timeoutHandle) {\r\n            clearTimeout(this._timeoutHandle);\r\n        }\r\n    }\r\n    _createInvocation(methodName, args, nonblocking, streamIds) {\r\n        if (nonblocking) {\r\n            if (streamIds.length !== 0) {\r\n                return {\r\n                    arguments: args,\r\n                    streamIds,\r\n                    target: methodName,\r\n                    type: MessageType.Invocation,\r\n                };\r\n            }\r\n            else {\r\n                return {\r\n                    arguments: args,\r\n                    target: methodName,\r\n                    type: MessageType.Invocation,\r\n                };\r\n            }\r\n        }\r\n        else {\r\n            const invocationId = this._invocationId;\r\n            this._invocationId++;\r\n            if (streamIds.length !== 0) {\r\n                return {\r\n                    arguments: args,\r\n                    invocationId: invocationId.toString(),\r\n                    streamIds,\r\n                    target: methodName,\r\n                    type: MessageType.Invocation,\r\n                };\r\n            }\r\n            else {\r\n                return {\r\n                    arguments: args,\r\n                    invocationId: invocationId.toString(),\r\n                    target: methodName,\r\n                    type: MessageType.Invocation,\r\n                };\r\n            }\r\n        }\r\n    }\r\n    _launchStreams(streams, promiseQueue) {\r\n        if (streams.length === 0) {\r\n            return;\r\n        }\r\n        // Synchronize stream data so they arrive in-order on the server\r\n        if (!promiseQueue) {\r\n            promiseQueue = Promise.resolve();\r\n        }\r\n        // We want to iterate over the keys, since the keys are the stream ids\r\n        // eslint-disable-next-line guard-for-in\r\n        for (const streamId in streams) {\r\n            streams[streamId].subscribe({\r\n                complete: () => {\r\n                    promiseQueue = promiseQueue.then(() => this._sendWithProtocol(this._createCompletionMessage(streamId)));\r\n                },\r\n                error: (err) => {\r\n                    let message;\r\n                    if (err instanceof Error) {\r\n                        message = err.message;\r\n                    }\r\n                    else if (err && err.toString) {\r\n                        message = err.toString();\r\n                    }\r\n                    else {\r\n                        message = \"Unknown error\";\r\n                    }\r\n                    promiseQueue = promiseQueue.then(() => this._sendWithProtocol(this._createCompletionMessage(streamId, message)));\r\n                },\r\n                next: (item) => {\r\n                    promiseQueue = promiseQueue.then(() => this._sendWithProtocol(this._createStreamItemMessage(streamId, item)));\r\n                },\r\n            });\r\n        }\r\n    }\r\n    _replaceStreamingParams(args) {\r\n        const streams = [];\r\n        const streamIds = [];\r\n        for (let i = 0; i < args.length; i++) {\r\n            const argument = args[i];\r\n            if (this._isObservable(argument)) {\r\n                const streamId = this._invocationId;\r\n                this._invocationId++;\r\n                // Store the stream for later use\r\n                streams[streamId] = argument;\r\n                streamIds.push(streamId.toString());\r\n                // remove stream from args\r\n                args.splice(i, 1);\r\n            }\r\n        }\r\n        return [streams, streamIds];\r\n    }\r\n    _isObservable(arg) {\r\n        // This allows other stream implementations to just work (like rxjs)\r\n        return arg && arg.subscribe && typeof arg.subscribe === \"function\";\r\n    }\r\n    _createStreamInvocation(methodName, args, streamIds) {\r\n        const invocationId = this._invocationId;\r\n        this._invocationId++;\r\n        if (streamIds.length !== 0) {\r\n            return {\r\n                arguments: args,\r\n                invocationId: invocationId.toString(),\r\n                streamIds,\r\n                target: methodName,\r\n                type: MessageType.StreamInvocation,\r\n            };\r\n        }\r\n        else {\r\n            return {\r\n                arguments: args,\r\n                invocationId: invocationId.toString(),\r\n                target: methodName,\r\n                type: MessageType.StreamInvocation,\r\n            };\r\n        }\r\n    }\r\n    _createCancelInvocation(id) {\r\n        return {\r\n            invocationId: id,\r\n            type: MessageType.CancelInvocation,\r\n        };\r\n    }\r\n    _createStreamItemMessage(id, item) {\r\n        return {\r\n            invocationId: id,\r\n            item,\r\n            type: MessageType.StreamItem,\r\n        };\r\n    }\r\n    _createCompletionMessage(id, error, result) {\r\n        if (error) {\r\n            return {\r\n                error,\r\n                invocationId: id,\r\n                type: MessageType.Completion,\r\n            };\r\n        }\r\n        return {\r\n            invocationId: id,\r\n            result,\r\n            type: MessageType.Completion,\r\n        };\r\n    }\r\n}\r\n//# sourceMappingURL=HubConnection.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { SubjectSubscription } from \"./Utils\";\r\n/** Stream implementation to stream items to the server. */\r\nexport class Subject {\r\n    constructor() {\r\n        this.observers = [];\r\n    }\r\n    next(item) {\r\n        for (const observer of this.observers) {\r\n            observer.next(item);\r\n        }\r\n    }\r\n    error(err) {\r\n        for (const observer of this.observers) {\r\n            if (observer.error) {\r\n                observer.error(err);\r\n            }\r\n        }\r\n    }\r\n    complete() {\r\n        for (const observer of this.observers) {\r\n            if (observer.complete) {\r\n                observer.complete();\r\n            }\r\n        }\r\n    }\r\n    subscribe(observer) {\r\n        this.observers.push(observer);\r\n        return new SubjectSubscription(this, observer);\r\n    }\r\n}\r\n//# sourceMappingURL=Subject.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n// 0, 2, 10, 30 second delays before reconnect attempts.\r\nconst DEFAULT_RETRY_DELAYS_IN_MILLISECONDS = [0, 2000, 10000, 30000, null];\r\n/** @private */\r\nexport class DefaultReconnectPolicy {\r\n    constructor(retryDelays) {\r\n        this._retryDelays = retryDelays !== undefined ? [...retryDelays, null] : DEFAULT_RETRY_DELAYS_IN_MILLISECONDS;\r\n    }\r\n    nextRetryDelayInMilliseconds(retryContext) {\r\n        return this._retryDelays[retryContext.previousRetryCount];\r\n    }\r\n}\r\n//# sourceMappingURL=DefaultReconnectPolicy.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n/** Error thrown when an HTTP request fails. */\r\nexport class HttpError extends Error {\r\n    /** Constructs a new instance of {@link @microsoft/signalr.HttpError}.\r\n     *\r\n     * @param {string} errorMessage A descriptive error message.\r\n     * @param {number} statusCode The HTTP status code represented by this error.\r\n     */\r\n    constructor(errorMessage, statusCode) {\r\n        const trueProto = new.target.prototype;\r\n        super(`${errorMessage}: Status code '${statusCode}'`);\r\n        this.statusCode = statusCode;\r\n        // Workaround issue in Typescript compiler\r\n        // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200\r\n        this.__proto__ = trueProto;\r\n    }\r\n}\r\n/** Error thrown when a timeout elapses. */\r\nexport class TimeoutError extends Error {\r\n    /** Constructs a new instance of {@link @microsoft/signalr.TimeoutError}.\r\n     *\r\n     * @param {string} errorMessage A descriptive error message.\r\n     */\r\n    constructor(errorMessage = \"A timeout occurred.\") {\r\n        const trueProto = new.target.prototype;\r\n        super(errorMessage);\r\n        // Workaround issue in Typescript compiler\r\n        // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200\r\n        this.__proto__ = trueProto;\r\n    }\r\n}\r\n/** Error thrown when an action is aborted. */\r\nexport class AbortError extends Error {\r\n    /** Constructs a new instance of {@link AbortError}.\r\n     *\r\n     * @param {string} errorMessage A descriptive error message.\r\n     */\r\n    constructor(errorMessage = \"An abort occurred.\") {\r\n        const trueProto = new.target.prototype;\r\n        super(errorMessage);\r\n        // Workaround issue in Typescript compiler\r\n        // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200\r\n        this.__proto__ = trueProto;\r\n    }\r\n}\r\n/** Error thrown when the selected transport is unsupported by the browser. */\r\n/** @private */\r\nexport class UnsupportedTransportError extends Error {\r\n    /** Constructs a new instance of {@link @microsoft/signalr.UnsupportedTransportError}.\r\n     *\r\n     * @param {string} message A descriptive error message.\r\n     * @param {HttpTransportType} transport The {@link @microsoft/signalr.HttpTransportType} this error occured on.\r\n     */\r\n    constructor(message, transport) {\r\n        const trueProto = new.target.prototype;\r\n        super(message);\r\n        this.transport = transport;\r\n        this.errorType = 'UnsupportedTransportError';\r\n        // Workaround issue in Typescript compiler\r\n        // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200\r\n        this.__proto__ = trueProto;\r\n    }\r\n}\r\n/** Error thrown when the selected transport is disabled by the browser. */\r\n/** @private */\r\nexport class DisabledTransportError extends Error {\r\n    /** Constructs a new instance of {@link @microsoft/signalr.DisabledTransportError}.\r\n     *\r\n     * @param {string} message A descriptive error message.\r\n     * @param {HttpTransportType} transport The {@link @microsoft/signalr.HttpTransportType} this error occured on.\r\n     */\r\n    constructor(message, transport) {\r\n        const trueProto = new.target.prototype;\r\n        super(message);\r\n        this.transport = transport;\r\n        this.errorType = 'DisabledTransportError';\r\n        // Workaround issue in Typescript compiler\r\n        // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200\r\n        this.__proto__ = trueProto;\r\n    }\r\n}\r\n/** Error thrown when the selected transport cannot be started. */\r\n/** @private */\r\nexport class FailedToStartTransportError extends Error {\r\n    /** Constructs a new instance of {@link @microsoft/signalr.FailedToStartTransportError}.\r\n     *\r\n     * @param {string} message A descriptive error message.\r\n     * @param {HttpTransportType} transport The {@link @microsoft/signalr.HttpTransportType} this error occured on.\r\n     */\r\n    constructor(message, transport) {\r\n        const trueProto = new.target.prototype;\r\n        super(message);\r\n        this.transport = transport;\r\n        this.errorType = 'FailedToStartTransportError';\r\n        // Workaround issue in Typescript compiler\r\n        // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200\r\n        this.__proto__ = trueProto;\r\n    }\r\n}\r\n/** Error thrown when the negotiation with the server failed to complete. */\r\n/** @private */\r\nexport class FailedToNegotiateWithServerError extends Error {\r\n    /** Constructs a new instance of {@link @microsoft/signalr.FailedToNegotiateWithServerError}.\r\n     *\r\n     * @param {string} message A descriptive error message.\r\n     */\r\n    constructor(message) {\r\n        const trueProto = new.target.prototype;\r\n        super(message);\r\n        this.errorType = 'FailedToNegotiateWithServerError';\r\n        // Workaround issue in Typescript compiler\r\n        // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200\r\n        this.__proto__ = trueProto;\r\n    }\r\n}\r\n/** Error thrown when multiple errors have occured. */\r\n/** @private */\r\nexport class AggregateErrors extends Error {\r\n    /** Constructs a new instance of {@link @microsoft/signalr.AggregateErrors}.\r\n     *\r\n     * @param {string} message A descriptive error message.\r\n     * @param {Error[]} innerErrors The collection of errors this error is aggregating.\r\n     */\r\n    constructor(message, innerErrors) {\r\n        const trueProto = new.target.prototype;\r\n        super(message);\r\n        this.innerErrors = innerErrors;\r\n        // Workaround issue in Typescript compiler\r\n        // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200\r\n        this.__proto__ = trueProto;\r\n    }\r\n}\r\n//# sourceMappingURL=Errors.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n/** Represents an HTTP response. */\r\nexport class HttpResponse {\r\n    constructor(statusCode, statusText, content) {\r\n        this.statusCode = statusCode;\r\n        this.statusText = statusText;\r\n        this.content = content;\r\n    }\r\n}\r\n/** Abstraction over an HTTP client.\r\n *\r\n * This class provides an abstraction over an HTTP client so that a different implementation can be provided on different platforms.\r\n */\r\nexport class HttpClient {\r\n    get(url, options) {\r\n        return this.send({\r\n            ...options,\r\n            method: \"GET\",\r\n            url,\r\n        });\r\n    }\r\n    post(url, options) {\r\n        return this.send({\r\n            ...options,\r\n            method: \"POST\",\r\n            url,\r\n        });\r\n    }\r\n    delete(url, options) {\r\n        return this.send({\r\n            ...options,\r\n            method: \"DELETE\",\r\n            url,\r\n        });\r\n    }\r\n    /** Gets all cookies that apply to the specified URL.\r\n     *\r\n     * @param url The URL that the cookies are valid for.\r\n     * @returns {string} A string containing all the key-value cookie pairs for the specified URL.\r\n     */\r\n    // @ts-ignore\r\n    getCookieString(url) {\r\n        return \"\";\r\n    }\r\n}\r\n//# sourceMappingURL=HttpClient.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n// This will be treated as a bit flag in the future, so we keep it using power-of-two values.\r\n/** Specifies a specific HTTP transport type. */\r\nexport var HttpTransportType;\r\n(function (HttpTransportType) {\r\n    /** Specifies no transport preference. */\r\n    HttpTransportType[HttpTransportType[\"None\"] = 0] = \"None\";\r\n    /** Specifies the WebSockets transport. */\r\n    HttpTransportType[HttpTransportType[\"WebSockets\"] = 1] = \"WebSockets\";\r\n    /** Specifies the Server-Sent Events transport. */\r\n    HttpTransportType[HttpTransportType[\"ServerSentEvents\"] = 2] = \"ServerSentEvents\";\r\n    /** Specifies the Long Polling transport. */\r\n    HttpTransportType[HttpTransportType[\"LongPolling\"] = 4] = \"LongPolling\";\r\n})(HttpTransportType || (HttpTransportType = {}));\r\n/** Specifies the transfer format for a connection. */\r\nexport var TransferFormat;\r\n(function (TransferFormat) {\r\n    /** Specifies that only text data will be transmitted over the connection. */\r\n    TransferFormat[TransferFormat[\"Text\"] = 1] = \"Text\";\r\n    /** Specifies that binary data will be transmitted over the connection. */\r\n    TransferFormat[TransferFormat[\"Binary\"] = 2] = \"Binary\";\r\n})(TransferFormat || (TransferFormat = {}));\r\n//# sourceMappingURL=ITransport.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { AbortError, HttpError, TimeoutError } from \"./Errors\";\r\nimport { HttpClient, HttpResponse } from \"./HttpClient\";\r\nimport { LogLevel } from \"./ILogger\";\r\nimport { Platform, getGlobalThis } from \"./Utils\";\r\nexport class FetchHttpClient extends HttpClient {\r\n    constructor(logger) {\r\n        super();\r\n        this._logger = logger;\r\n        if (typeof fetch === \"undefined\") {\r\n            // In order to ignore the dynamic require in webpack builds we need to do this magic\r\n            // @ts-ignore: TS doesn't know about these names\r\n            const requireFunc = typeof __webpack_require__ === \"function\" ? __non_webpack_require__ : require;\r\n            // Cookies aren't automatically handled in Node so we need to add a CookieJar to preserve cookies across requests\r\n            this._jar = new (requireFunc(\"tough-cookie\")).CookieJar();\r\n            this._fetchType = requireFunc(\"node-fetch\");\r\n            // node-fetch doesn't have a nice API for getting and setting cookies\r\n            // fetch-cookie will wrap a fetch implementation with a default CookieJar or a provided one\r\n            this._fetchType = requireFunc(\"fetch-cookie\")(this._fetchType, this._jar);\r\n        }\r\n        else {\r\n            this._fetchType = fetch.bind(getGlobalThis());\r\n        }\r\n        if (typeof AbortController === \"undefined\") {\r\n            // In order to ignore the dynamic require in webpack builds we need to do this magic\r\n            // @ts-ignore: TS doesn't know about these names\r\n            const requireFunc = typeof __webpack_require__ === \"function\" ? __non_webpack_require__ : require;\r\n            // Node needs EventListener methods on AbortController which our custom polyfill doesn't provide\r\n            this._abortControllerType = requireFunc(\"abort-controller\");\r\n        }\r\n        else {\r\n            this._abortControllerType = AbortController;\r\n        }\r\n    }\r\n    /** @inheritDoc */\r\n    async send(request) {\r\n        // Check that abort was not signaled before calling send\r\n        if (request.abortSignal && request.abortSignal.aborted) {\r\n            throw new AbortError();\r\n        }\r\n        if (!request.method) {\r\n            throw new Error(\"No method defined.\");\r\n        }\r\n        if (!request.url) {\r\n            throw new Error(\"No url defined.\");\r\n        }\r\n        const abortController = new this._abortControllerType();\r\n        let error;\r\n        // Hook our abortSignal into the abort controller\r\n        if (request.abortSignal) {\r\n            request.abortSignal.onabort = () => {\r\n                abortController.abort();\r\n                error = new AbortError();\r\n            };\r\n        }\r\n        // If a timeout has been passed in, setup a timeout to call abort\r\n        // Type needs to be any to fit window.setTimeout and NodeJS.setTimeout\r\n        let timeoutId = null;\r\n        if (request.timeout) {\r\n            const msTimeout = request.timeout;\r\n            timeoutId = setTimeout(() => {\r\n                abortController.abort();\r\n                this._logger.log(LogLevel.Warning, `Timeout from HTTP request.`);\r\n                error = new TimeoutError();\r\n            }, msTimeout);\r\n        }\r\n        let response;\r\n        try {\r\n            response = await this._fetchType(request.url, {\r\n                body: request.content,\r\n                cache: \"no-cache\",\r\n                credentials: request.withCredentials === true ? \"include\" : \"same-origin\",\r\n                headers: {\r\n                    \"Content-Type\": \"text/plain;charset=UTF-8\",\r\n                    \"X-Requested-With\": \"XMLHttpRequest\",\r\n                    ...request.headers,\r\n                },\r\n                method: request.method,\r\n                mode: \"cors\",\r\n                redirect: \"follow\",\r\n                signal: abortController.signal,\r\n            });\r\n        }\r\n        catch (e) {\r\n            if (error) {\r\n                throw error;\r\n            }\r\n            this._logger.log(LogLevel.Warning, `Error from HTTP request. ${e}.`);\r\n            throw e;\r\n        }\r\n        finally {\r\n            if (timeoutId) {\r\n                clearTimeout(timeoutId);\r\n            }\r\n            if (request.abortSignal) {\r\n                request.abortSignal.onabort = null;\r\n            }\r\n        }\r\n        if (!response.ok) {\r\n            const errorMessage = await deserializeContent(response, \"text\");\r\n            throw new HttpError(errorMessage || response.statusText, response.status);\r\n        }\r\n        const content = deserializeContent(response, request.responseType);\r\n        const payload = await content;\r\n        return new HttpResponse(response.status, response.statusText, payload);\r\n    }\r\n    getCookieString(url) {\r\n        let cookies = \"\";\r\n        if (Platform.isNode && this._jar) {\r\n            // @ts-ignore: unused variable\r\n            this._jar.getCookies(url, (e, c) => cookies = c.join(\"; \"));\r\n        }\r\n        return cookies;\r\n    }\r\n}\r\nfunction deserializeContent(response, responseType) {\r\n    let content;\r\n    switch (responseType) {\r\n        case \"arraybuffer\":\r\n            content = response.arrayBuffer();\r\n            break;\r\n        case \"text\":\r\n            content = response.text();\r\n            break;\r\n        case \"blob\":\r\n        case \"document\":\r\n        case \"json\":\r\n            throw new Error(`${responseType} is not supported.`);\r\n        default:\r\n            content = response.text();\r\n            break;\r\n    }\r\n    return content;\r\n}\r\n//# sourceMappingURL=FetchHttpClient.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { AbortError, HttpError, TimeoutError } from \"./Errors\";\r\nimport { HttpClient, HttpResponse } from \"./HttpClient\";\r\nimport { LogLevel } from \"./ILogger\";\r\nexport class XhrHttpClient extends HttpClient {\r\n    constructor(logger) {\r\n        super();\r\n        this._logger = logger;\r\n    }\r\n    /** @inheritDoc */\r\n    send(request) {\r\n        // Check that abort was not signaled before calling send\r\n        if (request.abortSignal && request.abortSignal.aborted) {\r\n            return Promise.reject(new AbortError());\r\n        }\r\n        if (!request.method) {\r\n            return Promise.reject(new Error(\"No method defined.\"));\r\n        }\r\n        if (!request.url) {\r\n            return Promise.reject(new Error(\"No url defined.\"));\r\n        }\r\n        return new Promise((resolve, reject) => {\r\n            const xhr = new XMLHttpRequest();\r\n            xhr.open(request.method, request.url, true);\r\n            xhr.withCredentials = request.withCredentials === undefined ? true : request.withCredentials;\r\n            xhr.setRequestHeader(\"X-Requested-With\", \"XMLHttpRequest\");\r\n            // Explicitly setting the Content-Type header for React Native on Android platform.\r\n            xhr.setRequestHeader(\"Content-Type\", \"text/plain;charset=UTF-8\");\r\n            const headers = request.headers;\r\n            if (headers) {\r\n                Object.keys(headers)\r\n                    .forEach((header) => {\r\n                    xhr.setRequestHeader(header, headers[header]);\r\n                });\r\n            }\r\n            if (request.responseType) {\r\n                xhr.responseType = request.responseType;\r\n            }\r\n            if (request.abortSignal) {\r\n                request.abortSignal.onabort = () => {\r\n                    xhr.abort();\r\n                    reject(new AbortError());\r\n                };\r\n            }\r\n            if (request.timeout) {\r\n                xhr.timeout = request.timeout;\r\n            }\r\n            xhr.onload = () => {\r\n                if (request.abortSignal) {\r\n                    request.abortSignal.onabort = null;\r\n                }\r\n                if (xhr.status >= 200 && xhr.status < 300) {\r\n                    resolve(new HttpResponse(xhr.status, xhr.statusText, xhr.response || xhr.responseText));\r\n                }\r\n                else {\r\n                    reject(new HttpError(xhr.response || xhr.responseText || xhr.statusText, xhr.status));\r\n                }\r\n            };\r\n            xhr.onerror = () => {\r\n                this._logger.log(LogLevel.Warning, `Error from HTTP request. ${xhr.status}: ${xhr.statusText}.`);\r\n                reject(new HttpError(xhr.statusText, xhr.status));\r\n            };\r\n            xhr.ontimeout = () => {\r\n                this._logger.log(LogLevel.Warning, `Timeout from HTTP request.`);\r\n                reject(new TimeoutError());\r\n            };\r\n            xhr.send(request.content || \"\");\r\n        });\r\n    }\r\n}\r\n//# sourceMappingURL=XhrHttpClient.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { AbortError } from \"./Errors\";\r\nimport { FetchHttpClient } from \"./FetchHttpClient\";\r\nimport { HttpClient } from \"./HttpClient\";\r\nimport { Platform } from \"./Utils\";\r\nimport { XhrHttpClient } from \"./XhrHttpClient\";\r\n/** Default implementation of {@link @microsoft/signalr.HttpClient}. */\r\nexport class DefaultHttpClient extends HttpClient {\r\n    /** Creates a new instance of the {@link @microsoft/signalr.DefaultHttpClient}, using the provided {@link @microsoft/signalr.ILogger} to log messages. */\r\n    constructor(logger) {\r\n        super();\r\n        if (typeof fetch !== \"undefined\" || Platform.isNode) {\r\n            this._httpClient = new FetchHttpClient(logger);\r\n        }\r\n        else if (typeof XMLHttpRequest !== \"undefined\") {\r\n            this._httpClient = new XhrHttpClient(logger);\r\n        }\r\n        else {\r\n            throw new Error(\"No usable HttpClient found.\");\r\n        }\r\n    }\r\n    /** @inheritDoc */\r\n    send(request) {\r\n        // Check that abort was not signaled before calling send\r\n        if (request.abortSignal && request.abortSignal.aborted) {\r\n            return Promise.reject(new AbortError());\r\n        }\r\n        if (!request.method) {\r\n            return Promise.reject(new Error(\"No method defined.\"));\r\n        }\r\n        if (!request.url) {\r\n            return Promise.reject(new Error(\"No url defined.\"));\r\n        }\r\n        return this._httpClient.send(request);\r\n    }\r\n    getCookieString(url) {\r\n        return this._httpClient.getCookieString(url);\r\n    }\r\n}\r\n//# sourceMappingURL=DefaultHttpClient.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nexport class HeaderNames {\r\n}\r\nHeaderNames.Authorization = \"Authorization\";\r\nHeaderNames.Cookie = \"Cookie\";\r\n//# sourceMappingURL=HeaderNames.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n// Rough polyfill of https://developer.mozilla.org/en-US/docs/Web/API/AbortController\r\n// We don't actually ever use the API being polyfilled, we always use the polyfill because\r\n// it's a very new API right now.\r\n// Not exported from index.\r\n/** @private */\r\nexport class AbortController {\r\n    constructor() {\r\n        this._isAborted = false;\r\n        this.onabort = null;\r\n    }\r\n    abort() {\r\n        if (!this._isAborted) {\r\n            this._isAborted = true;\r\n            if (this.onabort) {\r\n                this.onabort();\r\n            }\r\n        }\r\n    }\r\n    get signal() {\r\n        return this;\r\n    }\r\n    get aborted() {\r\n        return this._isAborted;\r\n    }\r\n}\r\n//# sourceMappingURL=AbortController.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { AbortController } from \"./AbortController\";\r\nimport { HttpError, TimeoutError } from \"./Errors\";\r\nimport { HeaderNames } from \"./HeaderNames\";\r\nimport { LogLevel } from \"./ILogger\";\r\nimport { TransferFormat } from \"./ITransport\";\r\nimport { Arg, getDataDetail, getUserAgentHeader, sendMessage } from \"./Utils\";\r\n// Not exported from 'index', this type is internal.\r\n/** @private */\r\nexport class LongPollingTransport {\r\n    constructor(httpClient, accessTokenFactory, logger, options) {\r\n        this._httpClient = httpClient;\r\n        this._accessTokenFactory = accessTokenFactory;\r\n        this._logger = logger;\r\n        this._pollAbort = new AbortController();\r\n        this._options = options;\r\n        this._running = false;\r\n        this.onreceive = null;\r\n        this.onclose = null;\r\n    }\r\n    // This is an internal type, not exported from 'index' so this is really just internal.\r\n    get pollAborted() {\r\n        return this._pollAbort.aborted;\r\n    }\r\n    async connect(url, transferFormat) {\r\n        Arg.isRequired(url, \"url\");\r\n        Arg.isRequired(transferFormat, \"transferFormat\");\r\n        Arg.isIn(transferFormat, TransferFormat, \"transferFormat\");\r\n        this._url = url;\r\n        this._logger.log(LogLevel.Trace, \"(LongPolling transport) Connecting.\");\r\n        // Allow binary format on Node and Browsers that support binary content (indicated by the presence of responseType property)\r\n        if (transferFormat === TransferFormat.Binary &&\r\n            (typeof XMLHttpRequest !== \"undefined\" && typeof new XMLHttpRequest().responseType !== \"string\")) {\r\n            throw new Error(\"Binary protocols over XmlHttpRequest not implementing advanced features are not supported.\");\r\n        }\r\n        const [name, value] = getUserAgentHeader();\r\n        const headers = { [name]: value, ...this._options.headers };\r\n        const pollOptions = {\r\n            abortSignal: this._pollAbort.signal,\r\n            headers,\r\n            timeout: 100000,\r\n            withCredentials: this._options.withCredentials,\r\n        };\r\n        if (transferFormat === TransferFormat.Binary) {\r\n            pollOptions.responseType = \"arraybuffer\";\r\n        }\r\n        const token = await this._getAccessToken();\r\n        this._updateHeaderToken(pollOptions, token);\r\n        // Make initial long polling request\r\n        // Server uses first long polling request to finish initializing connection and it returns without data\r\n        const pollUrl = `${url}&_=${Date.now()}`;\r\n        this._logger.log(LogLevel.Trace, `(LongPolling transport) polling: ${pollUrl}.`);\r\n        const response = await this._httpClient.get(pollUrl, pollOptions);\r\n        if (response.statusCode !== 200) {\r\n            this._logger.log(LogLevel.Error, `(LongPolling transport) Unexpected response code: ${response.statusCode}.`);\r\n            // Mark running as false so that the poll immediately ends and runs the close logic\r\n            this._closeError = new HttpError(response.statusText || \"\", response.statusCode);\r\n            this._running = false;\r\n        }\r\n        else {\r\n            this._running = true;\r\n        }\r\n        this._receiving = this._poll(this._url, pollOptions);\r\n    }\r\n    async _getAccessToken() {\r\n        if (this._accessTokenFactory) {\r\n            return await this._accessTokenFactory();\r\n        }\r\n        return null;\r\n    }\r\n    _updateHeaderToken(request, token) {\r\n        if (!request.headers) {\r\n            request.headers = {};\r\n        }\r\n        if (token) {\r\n            request.headers[HeaderNames.Authorization] = `Bearer ${token}`;\r\n            return;\r\n        }\r\n        if (request.headers[HeaderNames.Authorization]) {\r\n            delete request.headers[HeaderNames.Authorization];\r\n        }\r\n    }\r\n    async _poll(url, pollOptions) {\r\n        try {\r\n            while (this._running) {\r\n                // We have to get the access token on each poll, in case it changes\r\n                const token = await this._getAccessToken();\r\n                this._updateHeaderToken(pollOptions, token);\r\n                try {\r\n                    const pollUrl = `${url}&_=${Date.now()}`;\r\n                    this._logger.log(LogLevel.Trace, `(LongPolling transport) polling: ${pollUrl}.`);\r\n                    const response = await this._httpClient.get(pollUrl, pollOptions);\r\n                    if (response.statusCode === 204) {\r\n                        this._logger.log(LogLevel.Information, \"(LongPolling transport) Poll terminated by server.\");\r\n                        this._running = false;\r\n                    }\r\n                    else if (response.statusCode !== 200) {\r\n                        this._logger.log(LogLevel.Error, `(LongPolling transport) Unexpected response code: ${response.statusCode}.`);\r\n                        // Unexpected status code\r\n                        this._closeError = new HttpError(response.statusText || \"\", response.statusCode);\r\n                        this._running = false;\r\n                    }\r\n                    else {\r\n                        // Process the response\r\n                        if (response.content) {\r\n                            this._logger.log(LogLevel.Trace, `(LongPolling transport) data received. ${getDataDetail(response.content, this._options.logMessageContent)}.`);\r\n                            if (this.onreceive) {\r\n                                this.onreceive(response.content);\r\n                            }\r\n                        }\r\n                        else {\r\n                            // This is another way timeout manifest.\r\n                            this._logger.log(LogLevel.Trace, \"(LongPolling transport) Poll timed out, reissuing.\");\r\n                        }\r\n                    }\r\n                }\r\n                catch (e) {\r\n                    if (!this._running) {\r\n                        // Log but disregard errors that occur after stopping\r\n                        this._logger.log(LogLevel.Trace, `(LongPolling transport) Poll errored after shutdown: ${e.message}`);\r\n                    }\r\n                    else {\r\n                        if (e instanceof TimeoutError) {\r\n                            // Ignore timeouts and reissue the poll.\r\n                            this._logger.log(LogLevel.Trace, \"(LongPolling transport) Poll timed out, reissuing.\");\r\n                        }\r\n                        else {\r\n                            // Close the connection with the error as the result.\r\n                            this._closeError = e;\r\n                            this._running = false;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        finally {\r\n            this._logger.log(LogLevel.Trace, \"(LongPolling transport) Polling complete.\");\r\n            // We will reach here with pollAborted==false when the server returned a response causing the transport to stop.\r\n            // If pollAborted==true then client initiated the stop and the stop method will raise the close event after DELETE is sent.\r\n            if (!this.pollAborted) {\r\n                this._raiseOnClose();\r\n            }\r\n        }\r\n    }\r\n    async send(data) {\r\n        if (!this._running) {\r\n            return Promise.reject(new Error(\"Cannot send until the transport is connected\"));\r\n        }\r\n        return sendMessage(this._logger, \"LongPolling\", this._httpClient, this._url, this._accessTokenFactory, data, this._options);\r\n    }\r\n    async stop() {\r\n        this._logger.log(LogLevel.Trace, \"(LongPolling transport) Stopping polling.\");\r\n        // Tell receiving loop to stop, abort any current request, and then wait for it to finish\r\n        this._running = false;\r\n        this._pollAbort.abort();\r\n        try {\r\n            await this._receiving;\r\n            // Send DELETE to clean up long polling on the server\r\n            this._logger.log(LogLevel.Trace, `(LongPolling transport) sending DELETE request to ${this._url}.`);\r\n            const headers = {};\r\n            const [name, value] = getUserAgentHeader();\r\n            headers[name] = value;\r\n            const deleteOptions = {\r\n                headers: { ...headers, ...this._options.headers },\r\n                timeout: this._options.timeout,\r\n                withCredentials: this._options.withCredentials,\r\n            };\r\n            const token = await this._getAccessToken();\r\n            this._updateHeaderToken(deleteOptions, token);\r\n            await this._httpClient.delete(this._url, deleteOptions);\r\n            this._logger.log(LogLevel.Trace, \"(LongPolling transport) DELETE request sent.\");\r\n        }\r\n        finally {\r\n            this._logger.log(LogLevel.Trace, \"(LongPolling transport) Stop finished.\");\r\n            // Raise close event here instead of in polling\r\n            // It needs to happen after the DELETE request is sent\r\n            this._raiseOnClose();\r\n        }\r\n    }\r\n    _raiseOnClose() {\r\n        if (this.onclose) {\r\n            let logMessage = \"(LongPolling transport) Firing onclose event.\";\r\n            if (this._closeError) {\r\n                logMessage += \" Error: \" + this._closeError;\r\n            }\r\n            this._logger.log(LogLevel.Trace, logMessage);\r\n            this.onclose(this._closeError);\r\n        }\r\n    }\r\n}\r\n//# sourceMappingURL=LongPollingTransport.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { LogLevel } from \"./ILogger\";\r\nimport { TransferFormat } from \"./ITransport\";\r\nimport { Arg, getDataDetail, getUserAgentHeader, Platform, sendMessage } from \"./Utils\";\r\n/** @private */\r\nexport class ServerSentEventsTransport {\r\n    constructor(httpClient, accessTokenFactory, logger, options) {\r\n        this._httpClient = httpClient;\r\n        this._accessTokenFactory = accessTokenFactory;\r\n        this._logger = logger;\r\n        this._options = options;\r\n        this.onreceive = null;\r\n        this.onclose = null;\r\n    }\r\n    async connect(url, transferFormat) {\r\n        Arg.isRequired(url, \"url\");\r\n        Arg.isRequired(transferFormat, \"transferFormat\");\r\n        Arg.isIn(transferFormat, TransferFormat, \"transferFormat\");\r\n        this._logger.log(LogLevel.Trace, \"(SSE transport) Connecting.\");\r\n        // set url before accessTokenFactory because this.url is only for send and we set the auth header instead of the query string for send\r\n        this._url = url;\r\n        if (this._accessTokenFactory) {\r\n            const token = await this._accessTokenFactory();\r\n            if (token) {\r\n                url += (url.indexOf(\"?\") < 0 ? \"?\" : \"&\") + `access_token=${encodeURIComponent(token)}`;\r\n            }\r\n        }\r\n        return new Promise((resolve, reject) => {\r\n            let opened = false;\r\n            if (transferFormat !== TransferFormat.Text) {\r\n                reject(new Error(\"The Server-Sent Events transport only supports the 'Text' transfer format\"));\r\n                return;\r\n            }\r\n            let eventSource;\r\n            if (Platform.isBrowser || Platform.isWebWorker) {\r\n                eventSource = new this._options.EventSource(url, { withCredentials: this._options.withCredentials });\r\n            }\r\n            else {\r\n                // Non-browser passes cookies via the dictionary\r\n                const cookies = this._httpClient.getCookieString(url);\r\n                const headers = {};\r\n                headers.Cookie = cookies;\r\n                const [name, value] = getUserAgentHeader();\r\n                headers[name] = value;\r\n                eventSource = new this._options.EventSource(url, { withCredentials: this._options.withCredentials, headers: { ...headers, ...this._options.headers } });\r\n            }\r\n            try {\r\n                eventSource.onmessage = (e) => {\r\n                    if (this.onreceive) {\r\n                        try {\r\n                            this._logger.log(LogLevel.Trace, `(SSE transport) data received. ${getDataDetail(e.data, this._options.logMessageContent)}.`);\r\n                            this.onreceive(e.data);\r\n                        }\r\n                        catch (error) {\r\n                            this._close(error);\r\n                            return;\r\n                        }\r\n                    }\r\n                };\r\n                // @ts-ignore: not using event on purpose\r\n                eventSource.onerror = (e) => {\r\n                    // EventSource doesn't give any useful information about server side closes.\r\n                    if (opened) {\r\n                        this._close();\r\n                    }\r\n                    else {\r\n                        reject(new Error(\"EventSource failed to connect. The connection could not be found on the server,\"\r\n                            + \" either the connection ID is not present on the server, or a proxy is refusing/buffering the connection.\"\r\n                            + \" If you have multiple servers check that sticky sessions are enabled.\"));\r\n                    }\r\n                };\r\n                eventSource.onopen = () => {\r\n                    this._logger.log(LogLevel.Information, `SSE connected to ${this._url}`);\r\n                    this._eventSource = eventSource;\r\n                    opened = true;\r\n                    resolve();\r\n                };\r\n            }\r\n            catch (e) {\r\n                reject(e);\r\n                return;\r\n            }\r\n        });\r\n    }\r\n    async send(data) {\r\n        if (!this._eventSource) {\r\n            return Promise.reject(new Error(\"Cannot send until the transport is connected\"));\r\n        }\r\n        return sendMessage(this._logger, \"SSE\", this._httpClient, this._url, this._accessTokenFactory, data, this._options);\r\n    }\r\n    stop() {\r\n        this._close();\r\n        return Promise.resolve();\r\n    }\r\n    _close(e) {\r\n        if (this._eventSource) {\r\n            this._eventSource.close();\r\n            this._eventSource = undefined;\r\n            if (this.onclose) {\r\n                this.onclose(e);\r\n            }\r\n        }\r\n    }\r\n}\r\n//# sourceMappingURL=ServerSentEventsTransport.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { HeaderNames } from \"./HeaderNames\";\r\nimport { LogLevel } from \"./ILogger\";\r\nimport { TransferFormat } from \"./ITransport\";\r\nimport { Arg, getDataDetail, getUserAgentHeader, Platform } from \"./Utils\";\r\n/** @private */\r\nexport class WebSocketTransport {\r\n    constructor(httpClient, accessTokenFactory, logger, logMessageContent, webSocketConstructor, headers) {\r\n        this._logger = logger;\r\n        this._accessTokenFactory = accessTokenFactory;\r\n        this._logMessageContent = logMessageContent;\r\n        this._webSocketConstructor = webSocketConstructor;\r\n        this._httpClient = httpClient;\r\n        this.onreceive = null;\r\n        this.onclose = null;\r\n        this._headers = headers;\r\n    }\r\n    async connect(url, transferFormat) {\r\n        Arg.isRequired(url, \"url\");\r\n        Arg.isRequired(transferFormat, \"transferFormat\");\r\n        Arg.isIn(transferFormat, TransferFormat, \"transferFormat\");\r\n        this._logger.log(LogLevel.Trace, \"(WebSockets transport) Connecting.\");\r\n        if (this._accessTokenFactory) {\r\n            const token = await this._accessTokenFactory();\r\n            if (token) {\r\n                url += (url.indexOf(\"?\") < 0 ? \"?\" : \"&\") + `access_token=${encodeURIComponent(token)}`;\r\n            }\r\n        }\r\n        return new Promise((resolve, reject) => {\r\n            url = url.replace(/^http/, \"ws\");\r\n            let webSocket;\r\n            const cookies = this._httpClient.getCookieString(url);\r\n            let opened = false;\r\n            if (Platform.isNode) {\r\n                const headers = {};\r\n                const [name, value] = getUserAgentHeader();\r\n                headers[name] = value;\r\n                if (cookies) {\r\n                    headers[HeaderNames.Cookie] = `${cookies}`;\r\n                }\r\n                // Only pass headers when in non-browser environments\r\n                webSocket = new this._webSocketConstructor(url, undefined, {\r\n                    headers: { ...headers, ...this._headers },\r\n                });\r\n            }\r\n            if (!webSocket) {\r\n                // Chrome is not happy with passing 'undefined' as protocol\r\n                webSocket = new this._webSocketConstructor(url);\r\n            }\r\n            if (transferFormat === TransferFormat.Binary) {\r\n                webSocket.binaryType = \"arraybuffer\";\r\n            }\r\n            webSocket.onopen = (_event) => {\r\n                this._logger.log(LogLevel.Information, `WebSocket connected to ${url}.`);\r\n                this._webSocket = webSocket;\r\n                opened = true;\r\n                resolve();\r\n            };\r\n            webSocket.onerror = (event) => {\r\n                let error = null;\r\n                // ErrorEvent is a browser only type we need to check if the type exists before using it\r\n                if (typeof ErrorEvent !== \"undefined\" && event instanceof ErrorEvent) {\r\n                    error = event.error;\r\n                }\r\n                else {\r\n                    error = \"There was an error with the transport\";\r\n                }\r\n                this._logger.log(LogLevel.Information, `(WebSockets transport) ${error}.`);\r\n            };\r\n            webSocket.onmessage = (message) => {\r\n                this._logger.log(LogLevel.Trace, `(WebSockets transport) data received. ${getDataDetail(message.data, this._logMessageContent)}.`);\r\n                if (this.onreceive) {\r\n                    try {\r\n                        this.onreceive(message.data);\r\n                    }\r\n                    catch (error) {\r\n                        this._close(error);\r\n                        return;\r\n                    }\r\n                }\r\n            };\r\n            webSocket.onclose = (event) => {\r\n                // Don't call close handler if connection was never established\r\n                // We'll reject the connect call instead\r\n                if (opened) {\r\n                    this._close(event);\r\n                }\r\n                else {\r\n                    let error = null;\r\n                    // ErrorEvent is a browser only type we need to check if the type exists before using it\r\n                    if (typeof ErrorEvent !== \"undefined\" && event instanceof ErrorEvent) {\r\n                        error = event.error;\r\n                    }\r\n                    else {\r\n                        error = \"WebSocket failed to connect. The connection could not be found on the server,\"\r\n                            + \" either the endpoint may not be a SignalR endpoint,\"\r\n                            + \" the connection ID is not present on the server, or there is a proxy blocking WebSockets.\"\r\n                            + \" If you have multiple servers check that sticky sessions are enabled.\";\r\n                    }\r\n                    reject(new Error(error));\r\n                }\r\n            };\r\n        });\r\n    }\r\n    send(data) {\r\n        if (this._webSocket && this._webSocket.readyState === this._webSocketConstructor.OPEN) {\r\n            this._logger.log(LogLevel.Trace, `(WebSockets transport) sending data. ${getDataDetail(data, this._logMessageContent)}.`);\r\n            this._webSocket.send(data);\r\n            return Promise.resolve();\r\n        }\r\n        return Promise.reject(\"WebSocket is not in the OPEN state\");\r\n    }\r\n    stop() {\r\n        if (this._webSocket) {\r\n            // Manually invoke onclose callback inline so we know the HttpConnection was closed properly before returning\r\n            // This also solves an issue where websocket.onclose could take 18+ seconds to trigger during network disconnects\r\n            this._close(undefined);\r\n        }\r\n        return Promise.resolve();\r\n    }\r\n    _close(event) {\r\n        // webSocket will be null if the transport did not start successfully\r\n        if (this._webSocket) {\r\n            // Clear websocket handlers because we are considering the socket closed now\r\n            this._webSocket.onclose = () => { };\r\n            this._webSocket.onmessage = () => { };\r\n            this._webSocket.onerror = () => { };\r\n            this._webSocket.close();\r\n            this._webSocket = undefined;\r\n        }\r\n        this._logger.log(LogLevel.Trace, \"(WebSockets transport) socket closed.\");\r\n        if (this.onclose) {\r\n            if (this._isCloseEvent(event) && (event.wasClean === false || event.code !== 1000)) {\r\n                this.onclose(new Error(`WebSocket closed with status code: ${event.code} (${event.reason || \"no reason given\"}).`));\r\n            }\r\n            else if (event instanceof Error) {\r\n                this.onclose(event);\r\n            }\r\n            else {\r\n                this.onclose();\r\n            }\r\n        }\r\n    }\r\n    _isCloseEvent(event) {\r\n        return event && typeof event.wasClean === \"boolean\" && typeof event.code === \"number\";\r\n    }\r\n}\r\n//# sourceMappingURL=WebSocketTransport.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { DefaultHttpClient } from \"./DefaultHttpClient\";\r\nimport { AggregateErrors, DisabledTransportError, FailedToNegotiateWithServerError, FailedToStartTransportError, HttpError, UnsupportedTransportError } from \"./Errors\";\r\nimport { HeaderNames } from \"./HeaderNames\";\r\nimport { LogLevel } from \"./ILogger\";\r\nimport { HttpTransportType, TransferFormat } from \"./ITransport\";\r\nimport { LongPollingTransport } from \"./LongPollingTransport\";\r\nimport { ServerSentEventsTransport } from \"./ServerSentEventsTransport\";\r\nimport { Arg, createLogger, getUserAgentHeader, Platform } from \"./Utils\";\r\nimport { WebSocketTransport } from \"./WebSocketTransport\";\r\nconst MAX_REDIRECTS = 100;\r\n/** @private */\r\nexport class HttpConnection {\r\n    constructor(url, options = {}) {\r\n        this._stopPromiseResolver = () => { };\r\n        this.features = {};\r\n        this._negotiateVersion = 1;\r\n        Arg.isRequired(url, \"url\");\r\n        this._logger = createLogger(options.logger);\r\n        this.baseUrl = this._resolveUrl(url);\r\n        options = options || {};\r\n        options.logMessageContent = options.logMessageContent === undefined ? false : options.logMessageContent;\r\n        if (typeof options.withCredentials === \"boolean\" || options.withCredentials === undefined) {\r\n            options.withCredentials = options.withCredentials === undefined ? true : options.withCredentials;\r\n        }\r\n        else {\r\n            throw new Error(\"withCredentials option was not a 'boolean' or 'undefined' value\");\r\n        }\r\n        options.timeout = options.timeout === undefined ? 100 * 1000 : options.timeout;\r\n        let webSocketModule = null;\r\n        let eventSourceModule = null;\r\n        if (Platform.isNode && typeof require !== \"undefined\") {\r\n            // In order to ignore the dynamic require in webpack builds we need to do this magic\r\n            // @ts-ignore: TS doesn't know about these names\r\n            const requireFunc = typeof __webpack_require__ === \"function\" ? __non_webpack_require__ : require;\r\n            webSocketModule = requireFunc(\"ws\");\r\n            eventSourceModule = requireFunc(\"eventsource\");\r\n        }\r\n        if (!Platform.isNode && typeof WebSocket !== \"undefined\" && !options.WebSocket) {\r\n            options.WebSocket = WebSocket;\r\n        }\r\n        else if (Platform.isNode && !options.WebSocket) {\r\n            if (webSocketModule) {\r\n                options.WebSocket = webSocketModule;\r\n            }\r\n        }\r\n        if (!Platform.isNode && typeof EventSource !== \"undefined\" && !options.EventSource) {\r\n            options.EventSource = EventSource;\r\n        }\r\n        else if (Platform.isNode && !options.EventSource) {\r\n            if (typeof eventSourceModule !== \"undefined\") {\r\n                options.EventSource = eventSourceModule;\r\n            }\r\n        }\r\n        this._httpClient = options.httpClient || new DefaultHttpClient(this._logger);\r\n        this._connectionState = \"Disconnected\" /* Disconnected */;\r\n        this._connectionStarted = false;\r\n        this._options = options;\r\n        this.onreceive = null;\r\n        this.onclose = null;\r\n    }\r\n    async start(transferFormat) {\r\n        transferFormat = transferFormat || TransferFormat.Binary;\r\n        Arg.isIn(transferFormat, TransferFormat, \"transferFormat\");\r\n        this._logger.log(LogLevel.Debug, `Starting connection with transfer format '${TransferFormat[transferFormat]}'.`);\r\n        if (this._connectionState !== \"Disconnected\" /* Disconnected */) {\r\n            return Promise.reject(new Error(\"Cannot start an HttpConnection that is not in the 'Disconnected' state.\"));\r\n        }\r\n        this._connectionState = \"Connecting\" /* Connecting */;\r\n        this._startInternalPromise = this._startInternal(transferFormat);\r\n        await this._startInternalPromise;\r\n        // The TypeScript compiler thinks that connectionState must be Connecting here. The TypeScript compiler is wrong.\r\n        if (this._connectionState === \"Disconnecting\" /* Disconnecting */) {\r\n            // stop() was called and transitioned the client into the Disconnecting state.\r\n            const message = \"Failed to start the HttpConnection before stop() was called.\";\r\n            this._logger.log(LogLevel.Error, message);\r\n            // We cannot await stopPromise inside startInternal since stopInternal awaits the startInternalPromise.\r\n            await this._stopPromise;\r\n            return Promise.reject(new Error(message));\r\n        }\r\n        else if (this._connectionState !== \"Connected\" /* Connected */) {\r\n            // stop() was called and transitioned the client into the Disconnecting state.\r\n            const message = \"HttpConnection.startInternal completed gracefully but didn't enter the connection into the connected state!\";\r\n            this._logger.log(LogLevel.Error, message);\r\n            return Promise.reject(new Error(message));\r\n        }\r\n        this._connectionStarted = true;\r\n    }\r\n    send(data) {\r\n        if (this._connectionState !== \"Connected\" /* Connected */) {\r\n            return Promise.reject(new Error(\"Cannot send data if the connection is not in the 'Connected' State.\"));\r\n        }\r\n        if (!this._sendQueue) {\r\n            this._sendQueue = new TransportSendQueue(this.transport);\r\n        }\r\n        // Transport will not be null if state is connected\r\n        return this._sendQueue.send(data);\r\n    }\r\n    async stop(error) {\r\n        if (this._connectionState === \"Disconnected\" /* Disconnected */) {\r\n            this._logger.log(LogLevel.Debug, `Call to HttpConnection.stop(${error}) ignored because the connection is already in the disconnected state.`);\r\n            return Promise.resolve();\r\n        }\r\n        if (this._connectionState === \"Disconnecting\" /* Disconnecting */) {\r\n            this._logger.log(LogLevel.Debug, `Call to HttpConnection.stop(${error}) ignored because the connection is already in the disconnecting state.`);\r\n            return this._stopPromise;\r\n        }\r\n        this._connectionState = \"Disconnecting\" /* Disconnecting */;\r\n        this._stopPromise = new Promise((resolve) => {\r\n            // Don't complete stop() until stopConnection() completes.\r\n            this._stopPromiseResolver = resolve;\r\n        });\r\n        // stopInternal should never throw so just observe it.\r\n        await this._stopInternal(error);\r\n        await this._stopPromise;\r\n    }\r\n    async _stopInternal(error) {\r\n        // Set error as soon as possible otherwise there is a race between\r\n        // the transport closing and providing an error and the error from a close message\r\n        // We would prefer the close message error.\r\n        this._stopError = error;\r\n        try {\r\n            await this._startInternalPromise;\r\n        }\r\n        catch (e) {\r\n            // This exception is returned to the user as a rejected Promise from the start method.\r\n        }\r\n        // The transport's onclose will trigger stopConnection which will run our onclose event.\r\n        // The transport should always be set if currently connected. If it wasn't set, it's likely because\r\n        // stop was called during start() and start() failed.\r\n        if (this.transport) {\r\n            try {\r\n                await this.transport.stop();\r\n            }\r\n            catch (e) {\r\n                this._logger.log(LogLevel.Error, `HttpConnection.transport.stop() threw error '${e}'.`);\r\n                this._stopConnection();\r\n            }\r\n            this.transport = undefined;\r\n        }\r\n        else {\r\n            this._logger.log(LogLevel.Debug, \"HttpConnection.transport is undefined in HttpConnection.stop() because start() failed.\");\r\n        }\r\n    }\r\n    async _startInternal(transferFormat) {\r\n        // Store the original base url and the access token factory since they may change\r\n        // as part of negotiating\r\n        let url = this.baseUrl;\r\n        this._accessTokenFactory = this._options.accessTokenFactory;\r\n        try {\r\n            if (this._options.skipNegotiation) {\r\n                if (this._options.transport === HttpTransportType.WebSockets) {\r\n                    // No need to add a connection ID in this case\r\n                    this.transport = this._constructTransport(HttpTransportType.WebSockets);\r\n                    // We should just call connect directly in this case.\r\n                    // No fallback or negotiate in this case.\r\n                    await this._startTransport(url, transferFormat);\r\n                }\r\n                else {\r\n                    throw new Error(\"Negotiation can only be skipped when using the WebSocket transport directly.\");\r\n                }\r\n            }\r\n            else {\r\n                let negotiateResponse = null;\r\n                let redirects = 0;\r\n                do {\r\n                    negotiateResponse = await this._getNegotiationResponse(url);\r\n                    // the user tries to stop the connection when it is being started\r\n                    if (this._connectionState === \"Disconnecting\" /* Disconnecting */ || this._connectionState === \"Disconnected\" /* Disconnected */) {\r\n                        throw new Error(\"The connection was stopped during negotiation.\");\r\n                    }\r\n                    if (negotiateResponse.error) {\r\n                        throw new Error(negotiateResponse.error);\r\n                    }\r\n                    if (negotiateResponse.ProtocolVersion) {\r\n                        throw new Error(\"Detected a connection attempt to an ASP.NET SignalR Server. This client only supports connecting to an ASP.NET Core SignalR Server. See https://aka.ms/signalr-core-differences for details.\");\r\n                    }\r\n                    if (negotiateResponse.url) {\r\n                        url = negotiateResponse.url;\r\n                    }\r\n                    if (negotiateResponse.accessToken) {\r\n                        // Replace the current access token factory with one that uses\r\n                        // the returned access token\r\n                        const accessToken = negotiateResponse.accessToken;\r\n                        this._accessTokenFactory = () => accessToken;\r\n                    }\r\n                    redirects++;\r\n                } while (negotiateResponse.url && redirects < MAX_REDIRECTS);\r\n                if (redirects === MAX_REDIRECTS && negotiateResponse.url) {\r\n                    throw new Error(\"Negotiate redirection limit exceeded.\");\r\n                }\r\n                await this._createTransport(url, this._options.transport, negotiateResponse, transferFormat);\r\n            }\r\n            if (this.transport instanceof LongPollingTransport) {\r\n                this.features.inherentKeepAlive = true;\r\n            }\r\n            if (this._connectionState === \"Connecting\" /* Connecting */) {\r\n                // Ensure the connection transitions to the connected state prior to completing this.startInternalPromise.\r\n                // start() will handle the case when stop was called and startInternal exits still in the disconnecting state.\r\n                this._logger.log(LogLevel.Debug, \"The HttpConnection connected successfully.\");\r\n                this._connectionState = \"Connected\" /* Connected */;\r\n            }\r\n            // stop() is waiting on us via this.startInternalPromise so keep this.transport around so it can clean up.\r\n            // This is the only case startInternal can exit in neither the connected nor disconnected state because stopConnection()\r\n            // will transition to the disconnected state. start() will wait for the transition using the stopPromise.\r\n        }\r\n        catch (e) {\r\n            this._logger.log(LogLevel.Error, \"Failed to start the connection: \" + e);\r\n            this._connectionState = \"Disconnected\" /* Disconnected */;\r\n            this.transport = undefined;\r\n            // if start fails, any active calls to stop assume that start will complete the stop promise\r\n            this._stopPromiseResolver();\r\n            return Promise.reject(e);\r\n        }\r\n    }\r\n    async _getNegotiationResponse(url) {\r\n        const headers = {};\r\n        if (this._accessTokenFactory) {\r\n            const token = await this._accessTokenFactory();\r\n            if (token) {\r\n                headers[HeaderNames.Authorization] = `Bearer ${token}`;\r\n            }\r\n        }\r\n        const [name, value] = getUserAgentHeader();\r\n        headers[name] = value;\r\n        const negotiateUrl = this._resolveNegotiateUrl(url);\r\n        this._logger.log(LogLevel.Debug, `Sending negotiation request: ${negotiateUrl}.`);\r\n        try {\r\n            const response = await this._httpClient.post(negotiateUrl, {\r\n                content: \"\",\r\n                headers: { ...headers, ...this._options.headers },\r\n                timeout: this._options.timeout,\r\n                withCredentials: this._options.withCredentials,\r\n            });\r\n            if (response.statusCode !== 200) {\r\n                return Promise.reject(new Error(`Unexpected status code returned from negotiate '${response.statusCode}'`));\r\n            }\r\n            const negotiateResponse = JSON.parse(response.content);\r\n            if (!negotiateResponse.negotiateVersion || negotiateResponse.negotiateVersion < 1) {\r\n                // Negotiate version 0 doesn't use connectionToken\r\n                // So we set it equal to connectionId so all our logic can use connectionToken without being aware of the negotiate version\r\n                negotiateResponse.connectionToken = negotiateResponse.connectionId;\r\n            }\r\n            return negotiateResponse;\r\n        }\r\n        catch (e) {\r\n            let errorMessage = \"Failed to complete negotiation with the server: \" + e;\r\n            if (e instanceof HttpError) {\r\n                if (e.statusCode === 404) {\r\n                    errorMessage = errorMessage + \" Either this is not a SignalR endpoint or there is a proxy blocking the connection.\";\r\n                }\r\n            }\r\n            this._logger.log(LogLevel.Error, errorMessage);\r\n            return Promise.reject(new FailedToNegotiateWithServerError(errorMessage));\r\n        }\r\n    }\r\n    _createConnectUrl(url, connectionToken) {\r\n        if (!connectionToken) {\r\n            return url;\r\n        }\r\n        return url + (url.indexOf(\"?\") === -1 ? \"?\" : \"&\") + `id=${connectionToken}`;\r\n    }\r\n    async _createTransport(url, requestedTransport, negotiateResponse, requestedTransferFormat) {\r\n        let connectUrl = this._createConnectUrl(url, negotiateResponse.connectionToken);\r\n        if (this._isITransport(requestedTransport)) {\r\n            this._logger.log(LogLevel.Debug, \"Connection was provided an instance of ITransport, using that directly.\");\r\n            this.transport = requestedTransport;\r\n            await this._startTransport(connectUrl, requestedTransferFormat);\r\n            this.connectionId = negotiateResponse.connectionId;\r\n            return;\r\n        }\r\n        const transportExceptions = [];\r\n        const transports = negotiateResponse.availableTransports || [];\r\n        let negotiate = negotiateResponse;\r\n        for (const endpoint of transports) {\r\n            const transportOrError = this._resolveTransportOrError(endpoint, requestedTransport, requestedTransferFormat);\r\n            if (transportOrError instanceof Error) {\r\n                // Store the error and continue, we don't want to cause a re-negotiate in these cases\r\n                transportExceptions.push(`${endpoint.transport} failed:`);\r\n                transportExceptions.push(transportOrError);\r\n            }\r\n            else if (this._isITransport(transportOrError)) {\r\n                this.transport = transportOrError;\r\n                if (!negotiate) {\r\n                    try {\r\n                        negotiate = await this._getNegotiationResponse(url);\r\n                    }\r\n                    catch (ex) {\r\n                        return Promise.reject(ex);\r\n                    }\r\n                    connectUrl = this._createConnectUrl(url, negotiate.connectionToken);\r\n                }\r\n                try {\r\n                    await this._startTransport(connectUrl, requestedTransferFormat);\r\n                    this.connectionId = negotiate.connectionId;\r\n                    return;\r\n                }\r\n                catch (ex) {\r\n                    this._logger.log(LogLevel.Error, `Failed to start the transport '${endpoint.transport}': ${ex}`);\r\n                    negotiate = undefined;\r\n                    transportExceptions.push(new FailedToStartTransportError(`${endpoint.transport} failed: ${ex}`, HttpTransportType[endpoint.transport]));\r\n                    if (this._connectionState !== \"Connecting\" /* Connecting */) {\r\n                        const message = \"Failed to select transport before stop() was called.\";\r\n                        this._logger.log(LogLevel.Debug, message);\r\n                        return Promise.reject(new Error(message));\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        if (transportExceptions.length > 0) {\r\n            return Promise.reject(new AggregateErrors(`Unable to connect to the server with any of the available transports. ${transportExceptions.join(\" \")}`, transportExceptions));\r\n        }\r\n        return Promise.reject(new Error(\"None of the transports supported by the client are supported by the server.\"));\r\n    }\r\n    _constructTransport(transport) {\r\n        switch (transport) {\r\n            case HttpTransportType.WebSockets:\r\n                if (!this._options.WebSocket) {\r\n                    throw new Error(\"'WebSocket' is not supported in your environment.\");\r\n                }\r\n                return new WebSocketTransport(this._httpClient, this._accessTokenFactory, this._logger, this._options.logMessageContent, this._options.WebSocket, this._options.headers || {});\r\n            case HttpTransportType.ServerSentEvents:\r\n                if (!this._options.EventSource) {\r\n                    throw new Error(\"'EventSource' is not supported in your environment.\");\r\n                }\r\n                return new ServerSentEventsTransport(this._httpClient, this._accessTokenFactory, this._logger, this._options);\r\n            case HttpTransportType.LongPolling:\r\n                return new LongPollingTransport(this._httpClient, this._accessTokenFactory, this._logger, this._options);\r\n            default:\r\n                throw new Error(`Unknown transport: ${transport}.`);\r\n        }\r\n    }\r\n    _startTransport(url, transferFormat) {\r\n        this.transport.onreceive = this.onreceive;\r\n        this.transport.onclose = (e) => this._stopConnection(e);\r\n        return this.transport.connect(url, transferFormat);\r\n    }\r\n    _resolveTransportOrError(endpoint, requestedTransport, requestedTransferFormat) {\r\n        const transport = HttpTransportType[endpoint.transport];\r\n        if (transport === null || transport === undefined) {\r\n            this._logger.log(LogLevel.Debug, `Skipping transport '${endpoint.transport}' because it is not supported by this client.`);\r\n            return new Error(`Skipping transport '${endpoint.transport}' because it is not supported by this client.`);\r\n        }\r\n        else {\r\n            if (transportMatches(requestedTransport, transport)) {\r\n                const transferFormats = endpoint.transferFormats.map((s) => TransferFormat[s]);\r\n                if (transferFormats.indexOf(requestedTransferFormat) >= 0) {\r\n                    if ((transport === HttpTransportType.WebSockets && !this._options.WebSocket) ||\r\n                        (transport === HttpTransportType.ServerSentEvents && !this._options.EventSource)) {\r\n                        this._logger.log(LogLevel.Debug, `Skipping transport '${HttpTransportType[transport]}' because it is not supported in your environment.'`);\r\n                        return new UnsupportedTransportError(`'${HttpTransportType[transport]}' is not supported in your environment.`, transport);\r\n                    }\r\n                    else {\r\n                        this._logger.log(LogLevel.Debug, `Selecting transport '${HttpTransportType[transport]}'.`);\r\n                        try {\r\n                            return this._constructTransport(transport);\r\n                        }\r\n                        catch (ex) {\r\n                            return ex;\r\n                        }\r\n                    }\r\n                }\r\n                else {\r\n                    this._logger.log(LogLevel.Debug, `Skipping transport '${HttpTransportType[transport]}' because it does not support the requested transfer format '${TransferFormat[requestedTransferFormat]}'.`);\r\n                    return new Error(`'${HttpTransportType[transport]}' does not support ${TransferFormat[requestedTransferFormat]}.`);\r\n                }\r\n            }\r\n            else {\r\n                this._logger.log(LogLevel.Debug, `Skipping transport '${HttpTransportType[transport]}' because it was disabled by the client.`);\r\n                return new DisabledTransportError(`'${HttpTransportType[transport]}' is disabled by the client.`, transport);\r\n            }\r\n        }\r\n    }\r\n    _isITransport(transport) {\r\n        return transport && typeof (transport) === \"object\" && \"connect\" in transport;\r\n    }\r\n    _stopConnection(error) {\r\n        this._logger.log(LogLevel.Debug, `HttpConnection.stopConnection(${error}) called while in state ${this._connectionState}.`);\r\n        this.transport = undefined;\r\n        // If we have a stopError, it takes precedence over the error from the transport\r\n        error = this._stopError || error;\r\n        this._stopError = undefined;\r\n        if (this._connectionState === \"Disconnected\" /* Disconnected */) {\r\n            this._logger.log(LogLevel.Debug, `Call to HttpConnection.stopConnection(${error}) was ignored because the connection is already in the disconnected state.`);\r\n            return;\r\n        }\r\n        if (this._connectionState === \"Connecting\" /* Connecting */) {\r\n            this._logger.log(LogLevel.Warning, `Call to HttpConnection.stopConnection(${error}) was ignored because the connection is still in the connecting state.`);\r\n            throw new Error(`HttpConnection.stopConnection(${error}) was called while the connection is still in the connecting state.`);\r\n        }\r\n        if (this._connectionState === \"Disconnecting\" /* Disconnecting */) {\r\n            // A call to stop() induced this call to stopConnection and needs to be completed.\r\n            // Any stop() awaiters will be scheduled to continue after the onclose callback fires.\r\n            this._stopPromiseResolver();\r\n        }\r\n        if (error) {\r\n            this._logger.log(LogLevel.Error, `Connection disconnected with error '${error}'.`);\r\n        }\r\n        else {\r\n            this._logger.log(LogLevel.Information, \"Connection disconnected.\");\r\n        }\r\n        if (this._sendQueue) {\r\n            this._sendQueue.stop().catch((e) => {\r\n                this._logger.log(LogLevel.Error, `TransportSendQueue.stop() threw error '${e}'.`);\r\n            });\r\n            this._sendQueue = undefined;\r\n        }\r\n        this.connectionId = undefined;\r\n        this._connectionState = \"Disconnected\" /* Disconnected */;\r\n        if (this._connectionStarted) {\r\n            this._connectionStarted = false;\r\n            try {\r\n                if (this.onclose) {\r\n                    this.onclose(error);\r\n                }\r\n            }\r\n            catch (e) {\r\n                this._logger.log(LogLevel.Error, `HttpConnection.onclose(${error}) threw error '${e}'.`);\r\n            }\r\n        }\r\n    }\r\n    _resolveUrl(url) {\r\n        // startsWith is not supported in IE\r\n        if (url.lastIndexOf(\"https://\", 0) === 0 || url.lastIndexOf(\"http://\", 0) === 0) {\r\n            return url;\r\n        }\r\n        if (!Platform.isBrowser) {\r\n            throw new Error(`Cannot resolve '${url}'.`);\r\n        }\r\n        // Setting the url to the href propery of an anchor tag handles normalization\r\n        // for us. There are 3 main cases.\r\n        // 1. Relative path normalization e.g \"b\" -> \"http://localhost:5000/a/b\"\r\n        // 2. Absolute path normalization e.g \"/a/b\" -> \"http://localhost:5000/a/b\"\r\n        // 3. Networkpath reference normalization e.g \"//localhost:5000/a/b\" -> \"http://localhost:5000/a/b\"\r\n        const aTag = window.document.createElement(\"a\");\r\n        aTag.href = url;\r\n        this._logger.log(LogLevel.Information, `Normalizing '${url}' to '${aTag.href}'.`);\r\n        return aTag.href;\r\n    }\r\n    _resolveNegotiateUrl(url) {\r\n        const index = url.indexOf(\"?\");\r\n        let negotiateUrl = url.substring(0, index === -1 ? url.length : index);\r\n        if (negotiateUrl[negotiateUrl.length - 1] !== \"/\") {\r\n            negotiateUrl += \"/\";\r\n        }\r\n        negotiateUrl += \"negotiate\";\r\n        negotiateUrl += index === -1 ? \"\" : url.substring(index);\r\n        if (negotiateUrl.indexOf(\"negotiateVersion\") === -1) {\r\n            negotiateUrl += index === -1 ? \"?\" : \"&\";\r\n            negotiateUrl += \"negotiateVersion=\" + this._negotiateVersion;\r\n        }\r\n        return negotiateUrl;\r\n    }\r\n}\r\nfunction transportMatches(requestedTransport, actualTransport) {\r\n    return !requestedTransport || ((actualTransport & requestedTransport) !== 0);\r\n}\r\n/** @private */\r\nexport class TransportSendQueue {\r\n    constructor(_transport) {\r\n        this._transport = _transport;\r\n        this._buffer = [];\r\n        this._executing = true;\r\n        this._sendBufferedData = new PromiseSource();\r\n        this._transportResult = new PromiseSource();\r\n        this._sendLoopPromise = this._sendLoop();\r\n    }\r\n    send(data) {\r\n        this._bufferData(data);\r\n        if (!this._transportResult) {\r\n            this._transportResult = new PromiseSource();\r\n        }\r\n        return this._transportResult.promise;\r\n    }\r\n    stop() {\r\n        this._executing = false;\r\n        this._sendBufferedData.resolve();\r\n        return this._sendLoopPromise;\r\n    }\r\n    _bufferData(data) {\r\n        if (this._buffer.length && typeof (this._buffer[0]) !== typeof (data)) {\r\n            throw new Error(`Expected data to be of type ${typeof (this._buffer)} but was of type ${typeof (data)}`);\r\n        }\r\n        this._buffer.push(data);\r\n        this._sendBufferedData.resolve();\r\n    }\r\n    async _sendLoop() {\r\n        while (true) {\r\n            await this._sendBufferedData.promise;\r\n            if (!this._executing) {\r\n                if (this._transportResult) {\r\n                    this._transportResult.reject(\"Connection stopped.\");\r\n                }\r\n                break;\r\n            }\r\n            this._sendBufferedData = new PromiseSource();\r\n            const transportResult = this._transportResult;\r\n            this._transportResult = undefined;\r\n            const data = typeof (this._buffer[0]) === \"string\" ?\r\n                this._buffer.join(\"\") :\r\n                TransportSendQueue._concatBuffers(this._buffer);\r\n            this._buffer.length = 0;\r\n            try {\r\n                await this._transport.send(data);\r\n                transportResult.resolve();\r\n            }\r\n            catch (error) {\r\n                transportResult.reject(error);\r\n            }\r\n        }\r\n    }\r\n    static _concatBuffers(arrayBuffers) {\r\n        const totalLength = arrayBuffers.map((b) => b.byteLength).reduce((a, b) => a + b);\r\n        const result = new Uint8Array(totalLength);\r\n        let offset = 0;\r\n        for (const item of arrayBuffers) {\r\n            result.set(new Uint8Array(item), offset);\r\n            offset += item.byteLength;\r\n        }\r\n        return result.buffer;\r\n    }\r\n}\r\nclass PromiseSource {\r\n    constructor() {\r\n        this.promise = new Promise((resolve, reject) => [this._resolver, this._rejecter] = [resolve, reject]);\r\n    }\r\n    resolve() {\r\n        this._resolver();\r\n    }\r\n    reject(reason) {\r\n        this._rejecter(reason);\r\n    }\r\n}\r\n//# sourceMappingURL=HttpConnection.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { MessageType } from \"./IHubProtocol\";\r\nimport { LogLevel } from \"./ILogger\";\r\nimport { TransferFormat } from \"./ITransport\";\r\nimport { NullLogger } from \"./Loggers\";\r\nimport { TextMessageFormat } from \"./TextMessageFormat\";\r\nconst JSON_HUB_PROTOCOL_NAME = \"json\";\r\n/** Implements the JSON Hub Protocol. */\r\nexport class JsonHubProtocol {\r\n    constructor() {\r\n        /** @inheritDoc */\r\n        this.name = JSON_HUB_PROTOCOL_NAME;\r\n        /** @inheritDoc */\r\n        this.version = 1;\r\n        /** @inheritDoc */\r\n        this.transferFormat = TransferFormat.Text;\r\n    }\r\n    /** Creates an array of {@link @microsoft/signalr.HubMessage} objects from the specified serialized representation.\r\n     *\r\n     * @param {string} input A string containing the serialized representation.\r\n     * @param {ILogger} logger A logger that will be used to log messages that occur during parsing.\r\n     */\r\n    parseMessages(input, logger) {\r\n        // The interface does allow \"ArrayBuffer\" to be passed in, but this implementation does not. So let's throw a useful error.\r\n        if (typeof input !== \"string\") {\r\n            throw new Error(\"Invalid input for JSON hub protocol. Expected a string.\");\r\n        }\r\n        if (!input) {\r\n            return [];\r\n        }\r\n        if (logger === null) {\r\n            logger = NullLogger.instance;\r\n        }\r\n        // Parse the messages\r\n        const messages = TextMessageFormat.parse(input);\r\n        const hubMessages = [];\r\n        for (const message of messages) {\r\n            const parsedMessage = JSON.parse(message);\r\n            if (typeof parsedMessage.type !== \"number\") {\r\n                throw new Error(\"Invalid payload.\");\r\n            }\r\n            switch (parsedMessage.type) {\r\n                case MessageType.Invocation:\r\n                    this._isInvocationMessage(parsedMessage);\r\n                    break;\r\n                case MessageType.StreamItem:\r\n                    this._isStreamItemMessage(parsedMessage);\r\n                    break;\r\n                case MessageType.Completion:\r\n                    this._isCompletionMessage(parsedMessage);\r\n                    break;\r\n                case MessageType.Ping:\r\n                    // Single value, no need to validate\r\n                    break;\r\n                case MessageType.Close:\r\n                    // All optional values, no need to validate\r\n                    break;\r\n                default:\r\n                    // Future protocol changes can add message types, old clients can ignore them\r\n                    logger.log(LogLevel.Information, \"Unknown message type '\" + parsedMessage.type + \"' ignored.\");\r\n                    continue;\r\n            }\r\n            hubMessages.push(parsedMessage);\r\n        }\r\n        return hubMessages;\r\n    }\r\n    /** Writes the specified {@link @microsoft/signalr.HubMessage} to a string and returns it.\r\n     *\r\n     * @param {HubMessage} message The message to write.\r\n     * @returns {string} A string containing the serialized representation of the message.\r\n     */\r\n    writeMessage(message) {\r\n        return TextMessageFormat.write(JSON.stringify(message));\r\n    }\r\n    _isInvocationMessage(message) {\r\n        this._assertNotEmptyString(message.target, \"Invalid payload for Invocation message.\");\r\n        if (message.invocationId !== undefined) {\r\n            this._assertNotEmptyString(message.invocationId, \"Invalid payload for Invocation message.\");\r\n        }\r\n    }\r\n    _isStreamItemMessage(message) {\r\n        this._assertNotEmptyString(message.invocationId, \"Invalid payload for StreamItem message.\");\r\n        if (message.item === undefined) {\r\n            throw new Error(\"Invalid payload for StreamItem message.\");\r\n        }\r\n    }\r\n    _isCompletionMessage(message) {\r\n        if (message.result && message.error) {\r\n            throw new Error(\"Invalid payload for Completion message.\");\r\n        }\r\n        if (!message.result && message.error) {\r\n            this._assertNotEmptyString(message.error, \"Invalid payload for Completion message.\");\r\n        }\r\n        this._assertNotEmptyString(message.invocationId, \"Invalid payload for Completion message.\");\r\n    }\r\n    _assertNotEmptyString(value, errorMessage) {\r\n        if (typeof value !== \"string\" || value === \"\") {\r\n            throw new Error(errorMessage);\r\n        }\r\n    }\r\n}\r\n//# sourceMappingURL=JsonHubProtocol.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { DefaultReconnectPolicy } from \"./DefaultReconnectPolicy\";\r\nimport { HttpConnection } from \"./HttpConnection\";\r\nimport { HubConnection } from \"./HubConnection\";\r\nimport { LogLevel } from \"./ILogger\";\r\nimport { JsonHubProtocol } from \"./JsonHubProtocol\";\r\nimport { NullLogger } from \"./Loggers\";\r\nimport { Arg, ConsoleLogger } from \"./Utils\";\r\nconst LogLevelNameMapping = {\r\n    trace: LogLevel.Trace,\r\n    debug: LogLevel.Debug,\r\n    info: LogLevel.Information,\r\n    information: LogLevel.Information,\r\n    warn: LogLevel.Warning,\r\n    warning: LogLevel.Warning,\r\n    error: LogLevel.Error,\r\n    critical: LogLevel.Critical,\r\n    none: LogLevel.None,\r\n};\r\nfunction parseLogLevel(name) {\r\n    // Case-insensitive matching via lower-casing\r\n    // Yes, I know case-folding is a complicated problem in Unicode, but we only support\r\n    // the ASCII strings defined in LogLevelNameMapping anyway, so it's fine -anurse.\r\n    const mapping = LogLevelNameMapping[name.toLowerCase()];\r\n    if (typeof mapping !== \"undefined\") {\r\n        return mapping;\r\n    }\r\n    else {\r\n        throw new Error(`Unknown log level: ${name}`);\r\n    }\r\n}\r\n/** A builder for configuring {@link @microsoft/signalr.HubConnection} instances. */\r\nexport class HubConnectionBuilder {\r\n    configureLogging(logging) {\r\n        Arg.isRequired(logging, \"logging\");\r\n        if (isLogger(logging)) {\r\n            this.logger = logging;\r\n        }\r\n        else if (typeof logging === \"string\") {\r\n            const logLevel = parseLogLevel(logging);\r\n            this.logger = new ConsoleLogger(logLevel);\r\n        }\r\n        else {\r\n            this.logger = new ConsoleLogger(logging);\r\n        }\r\n        return this;\r\n    }\r\n    withUrl(url, transportTypeOrOptions) {\r\n        Arg.isRequired(url, \"url\");\r\n        Arg.isNotEmpty(url, \"url\");\r\n        this.url = url;\r\n        // Flow-typing knows where it's at. Since HttpTransportType is a number and IHttpConnectionOptions is guaranteed\r\n        // to be an object, we know (as does TypeScript) this comparison is all we need to figure out which overload was called.\r\n        if (typeof transportTypeOrOptions === \"object\") {\r\n            this.httpConnectionOptions = { ...this.httpConnectionOptions, ...transportTypeOrOptions };\r\n        }\r\n        else {\r\n            this.httpConnectionOptions = {\r\n                ...this.httpConnectionOptions,\r\n                transport: transportTypeOrOptions,\r\n            };\r\n        }\r\n        return this;\r\n    }\r\n    /** Configures the {@link @microsoft/signalr.HubConnection} to use the specified Hub Protocol.\r\n     *\r\n     * @param {IHubProtocol} protocol The {@link @microsoft/signalr.IHubProtocol} implementation to use.\r\n     */\r\n    withHubProtocol(protocol) {\r\n        Arg.isRequired(protocol, \"protocol\");\r\n        this.protocol = protocol;\r\n        return this;\r\n    }\r\n    withAutomaticReconnect(retryDelaysOrReconnectPolicy) {\r\n        if (this.reconnectPolicy) {\r\n            throw new Error(\"A reconnectPolicy has already been set.\");\r\n        }\r\n        if (!retryDelaysOrReconnectPolicy) {\r\n            this.reconnectPolicy = new DefaultReconnectPolicy();\r\n        }\r\n        else if (Array.isArray(retryDelaysOrReconnectPolicy)) {\r\n            this.reconnectPolicy = new DefaultReconnectPolicy(retryDelaysOrReconnectPolicy);\r\n        }\r\n        else {\r\n            this.reconnectPolicy = retryDelaysOrReconnectPolicy;\r\n        }\r\n        return this;\r\n    }\r\n    /** Creates a {@link @microsoft/signalr.HubConnection} from the configuration options specified in this builder.\r\n     *\r\n     * @returns {HubConnection} The configured {@link @microsoft/signalr.HubConnection}.\r\n     */\r\n    build() {\r\n        // If httpConnectionOptions has a logger, use it. Otherwise, override it with the one\r\n        // provided to configureLogger\r\n        const httpConnectionOptions = this.httpConnectionOptions || {};\r\n        // If it's 'null', the user **explicitly** asked for null, don't mess with it.\r\n        if (httpConnectionOptions.logger === undefined) {\r\n            // If our logger is undefined or null, that's OK, the HttpConnection constructor will handle it.\r\n            httpConnectionOptions.logger = this.logger;\r\n        }\r\n        // Now create the connection\r\n        if (!this.url) {\r\n            throw new Error(\"The 'HubConnectionBuilder.withUrl' method must be called before building the connection.\");\r\n        }\r\n        const connection = new HttpConnection(this.url, httpConnectionOptions);\r\n        return HubConnection.create(connection, this.logger || NullLogger.instance, this.protocol || new JsonHubProtocol(), this.reconnectPolicy);\r\n    }\r\n}\r\nfunction isLogger(logger) {\r\n    return logger.log !== undefined;\r\n}\r\n//# sourceMappingURL=HubConnectionBuilder.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n/** Defines the type of a Hub Message. */\r\nexport var MessageType;\r\n(function (MessageType) {\r\n    /** Indicates the message is an Invocation message and implements the {@link @microsoft/signalr.InvocationMessage} interface. */\r\n    MessageType[MessageType[\"Invocation\"] = 1] = \"Invocation\";\r\n    /** Indicates the message is a StreamItem message and implements the {@link @microsoft/signalr.StreamItemMessage} interface. */\r\n    MessageType[MessageType[\"StreamItem\"] = 2] = \"StreamItem\";\r\n    /** Indicates the message is a Completion message and implements the {@link @microsoft/signalr.CompletionMessage} interface. */\r\n    MessageType[MessageType[\"Completion\"] = 3] = \"Completion\";\r\n    /** Indicates the message is a Stream Invocation message and implements the {@link @microsoft/signalr.StreamInvocationMessage} interface. */\r\n    MessageType[MessageType[\"StreamInvocation\"] = 4] = \"StreamInvocation\";\r\n    /** Indicates the message is a Cancel Invocation message and implements the {@link @microsoft/signalr.CancelInvocationMessage} interface. */\r\n    MessageType[MessageType[\"CancelInvocation\"] = 5] = \"CancelInvocation\";\r\n    /** Indicates the message is a Ping message and implements the {@link @microsoft/signalr.PingMessage} interface. */\r\n    MessageType[MessageType[\"Ping\"] = 6] = \"Ping\";\r\n    /** Indicates the message is a Close message and implements the {@link @microsoft/signalr.CloseMessage} interface. */\r\n    MessageType[MessageType[\"Close\"] = 7] = \"Close\";\r\n})(MessageType || (MessageType = {}));\r\n//# sourceMappingURL=IHubProtocol.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n// These values are designed to match the ASP.NET Log Levels since that's the pattern we're emulating here.\r\n/** Indicates the severity of a log message.\r\n *\r\n * Log Levels are ordered in increasing severity. So `Debug` is more severe than `Trace`, etc.\r\n */\r\nexport var LogLevel;\r\n(function (LogLevel) {\r\n    /** Log level for very low severity diagnostic messages. */\r\n    LogLevel[LogLevel[\"Trace\"] = 0] = \"Trace\";\r\n    /** Log level for low severity diagnostic messages. */\r\n    LogLevel[LogLevel[\"Debug\"] = 1] = \"Debug\";\r\n    /** Log level for informational diagnostic messages. */\r\n    LogLevel[LogLevel[\"Information\"] = 2] = \"Information\";\r\n    /** Log level for diagnostic messages that indicate a non-fatal problem. */\r\n    LogLevel[LogLevel[\"Warning\"] = 3] = \"Warning\";\r\n    /** Log level for diagnostic messages that indicate a failure in the current operation. */\r\n    LogLevel[LogLevel[\"Error\"] = 4] = \"Error\";\r\n    /** Log level for diagnostic messages that indicate a failure that will terminate the entire application. */\r\n    LogLevel[LogLevel[\"Critical\"] = 5] = \"Critical\";\r\n    /** The highest possible log level. Used when configuring logging to indicate that no log messages should be emitted. */\r\n    LogLevel[LogLevel[\"None\"] = 6] = \"None\";\r\n})(LogLevel || (LogLevel = {}));\r\n//# sourceMappingURL=ILogger.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n/** A logger that does nothing when log messages are sent to it. */\r\nexport class NullLogger {\r\n    constructor() { }\r\n    /** @inheritDoc */\r\n    // eslint-disable-next-line\r\n    log(_logLevel, _message) {\r\n    }\r\n}\r\n/** The singleton instance of the {@link @microsoft/signalr.NullLogger}. */\r\nNullLogger.instance = new NullLogger();\r\n//# sourceMappingURL=Loggers.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\n// Not exported from index\r\n/** @private */\r\nexport class TextMessageFormat {\r\n    static write(output) {\r\n        return `${output}${TextMessageFormat.RecordSeparator}`;\r\n    }\r\n    static parse(input) {\r\n        if (input[input.length - 1] !== TextMessageFormat.RecordSeparator) {\r\n            throw new Error(\"Message is incomplete.\");\r\n        }\r\n        const messages = input.split(TextMessageFormat.RecordSeparator);\r\n        messages.pop();\r\n        return messages;\r\n    }\r\n}\r\nTextMessageFormat.RecordSeparatorCode = 0x1e;\r\nTextMessageFormat.RecordSeparator = String.fromCharCode(TextMessageFormat.RecordSeparatorCode);\r\n//# sourceMappingURL=TextMessageFormat.js.map","// Licensed to the .NET Foundation under one or more agreements.\r\n// The .NET Foundation licenses this file to you under the MIT license.\r\nimport { LogLevel } from \"./ILogger\";\r\nimport { NullLogger } from \"./Loggers\";\r\n// Version token that will be replaced by the prepack command\r\n/** The version of the SignalR client. */\r\nexport const VERSION = \"6.0.15\";\r\n/** @private */\r\nexport class Arg {\r\n    static isRequired(val, name) {\r\n        if (val === null || val === undefined) {\r\n            throw new Error(`The '${name}' argument is required.`);\r\n        }\r\n    }\r\n    static isNotEmpty(val, name) {\r\n        if (!val || val.match(/^\\s*$/)) {\r\n            throw new Error(`The '${name}' argument should not be empty.`);\r\n        }\r\n    }\r\n    static isIn(val, values, name) {\r\n        // TypeScript enums have keys for **both** the name and the value of each enum member on the type itself.\r\n        if (!(val in values)) {\r\n            throw new Error(`Unknown ${name} value: ${val}.`);\r\n        }\r\n    }\r\n}\r\n/** @private */\r\nexport class Platform {\r\n    // react-native has a window but no document so we should check both\r\n    static get isBrowser() {\r\n        return typeof window === \"object\" && typeof window.document === \"object\";\r\n    }\r\n    // WebWorkers don't have a window object so the isBrowser check would fail\r\n    static get isWebWorker() {\r\n        return typeof self === \"object\" && \"importScripts\" in self;\r\n    }\r\n    // react-native has a window but no document\r\n    static get isReactNative() {\r\n        return typeof window === \"object\" && typeof window.document === \"undefined\";\r\n    }\r\n    // Node apps shouldn't have a window object, but WebWorkers don't either\r\n    // so we need to check for both WebWorker and window\r\n    static get isNode() {\r\n        return !this.isBrowser && !this.isWebWorker && !this.isReactNative;\r\n    }\r\n}\r\n/** @private */\r\nexport function getDataDetail(data, includeContent) {\r\n    let detail = \"\";\r\n    if (isArrayBuffer(data)) {\r\n        detail = `Binary data of length ${data.byteLength}`;\r\n        if (includeContent) {\r\n            detail += `. Content: '${formatArrayBuffer(data)}'`;\r\n        }\r\n    }\r\n    else if (typeof data === \"string\") {\r\n        detail = `String data of length ${data.length}`;\r\n        if (includeContent) {\r\n            detail += `. Content: '${data}'`;\r\n        }\r\n    }\r\n    return detail;\r\n}\r\n/** @private */\r\nexport function formatArrayBuffer(data) {\r\n    const view = new Uint8Array(data);\r\n    // Uint8Array.map only supports returning another Uint8Array?\r\n    let str = \"\";\r\n    view.forEach((num) => {\r\n        const pad = num < 16 ? \"0\" : \"\";\r\n        str += `0x${pad}${num.toString(16)} `;\r\n    });\r\n    // Trim of trailing space.\r\n    return str.substr(0, str.length - 1);\r\n}\r\n// Also in signalr-protocol-msgpack/Utils.ts\r\n/** @private */\r\nexport function isArrayBuffer(val) {\r\n    return val && typeof ArrayBuffer !== \"undefined\" &&\r\n        (val instanceof ArrayBuffer ||\r\n            // Sometimes we get an ArrayBuffer that doesn't satisfy instanceof\r\n            (val.constructor && val.constructor.name === \"ArrayBuffer\"));\r\n}\r\n/** @private */\r\nexport async function sendMessage(logger, transportName, httpClient, url, accessTokenFactory, content, options) {\r\n    let headers = {};\r\n    if (accessTokenFactory) {\r\n        const token = await accessTokenFactory();\r\n        if (token) {\r\n            headers = {\r\n                [\"Authorization\"]: `Bearer ${token}`,\r\n            };\r\n        }\r\n    }\r\n    const [name, value] = getUserAgentHeader();\r\n    headers[name] = value;\r\n    logger.log(LogLevel.Trace, `(${transportName} transport) sending data. ${getDataDetail(content, options.logMessageContent)}.`);\r\n    const responseType = isArrayBuffer(content) ? \"arraybuffer\" : \"text\";\r\n    const response = await httpClient.post(url, {\r\n        content,\r\n        headers: { ...headers, ...options.headers },\r\n        responseType,\r\n        timeout: options.timeout,\r\n        withCredentials: options.withCredentials,\r\n    });\r\n    logger.log(LogLevel.Trace, `(${transportName} transport) request complete. Response status: ${response.statusCode}.`);\r\n}\r\n/** @private */\r\nexport function createLogger(logger) {\r\n    if (logger === undefined) {\r\n        return new ConsoleLogger(LogLevel.Information);\r\n    }\r\n    if (logger === null) {\r\n        return NullLogger.instance;\r\n    }\r\n    if (logger.log !== undefined) {\r\n        return logger;\r\n    }\r\n    return new ConsoleLogger(logger);\r\n}\r\n/** @private */\r\nexport class SubjectSubscription {\r\n    constructor(subject, observer) {\r\n        this._subject = subject;\r\n        this._observer = observer;\r\n    }\r\n    dispose() {\r\n        const index = this._subject.observers.indexOf(this._observer);\r\n        if (index > -1) {\r\n            this._subject.observers.splice(index, 1);\r\n        }\r\n        if (this._subject.observers.length === 0 && this._subject.cancelCallback) {\r\n            this._subject.cancelCallback().catch((_) => { });\r\n        }\r\n    }\r\n}\r\n/** @private */\r\nexport class ConsoleLogger {\r\n    constructor(minimumLogLevel) {\r\n        this._minLevel = minimumLogLevel;\r\n        this.out = console;\r\n    }\r\n    log(logLevel, message) {\r\n        if (logLevel >= this._minLevel) {\r\n            const msg = `[${new Date().toISOString()}] ${LogLevel[logLevel]}: ${message}`;\r\n            switch (logLevel) {\r\n                case LogLevel.Critical:\r\n                case LogLevel.Error:\r\n                    this.out.error(msg);\r\n                    break;\r\n                case LogLevel.Warning:\r\n                    this.out.warn(msg);\r\n                    break;\r\n                case LogLevel.Information:\r\n                    this.out.info(msg);\r\n                    break;\r\n                default:\r\n                    // console.debug only goes to attached debuggers in Node, so we use console.log for Trace and Debug\r\n                    this.out.log(msg);\r\n                    break;\r\n            }\r\n        }\r\n    }\r\n}\r\n/** @private */\r\nexport function getUserAgentHeader() {\r\n    let userAgentHeaderName = \"X-SignalR-User-Agent\";\r\n    if (Platform.isNode) {\r\n        userAgentHeaderName = \"User-Agent\";\r\n    }\r\n    return [userAgentHeaderName, constructUserAgent(VERSION, getOsName(), getRuntime(), getRuntimeVersion())];\r\n}\r\n/** @private */\r\nexport function constructUserAgent(version, os, runtime, runtimeVersion) {\r\n    // Microsoft SignalR/[Version] ([Detailed Version]; [Operating System]; [Runtime]; [Runtime Version])\r\n    let userAgent = \"Microsoft SignalR/\";\r\n    const majorAndMinor = version.split(\".\");\r\n    userAgent += `${majorAndMinor[0]}.${majorAndMinor[1]}`;\r\n    userAgent += ` (${version}; `;\r\n    if (os && os !== \"\") {\r\n        userAgent += `${os}; `;\r\n    }\r\n    else {\r\n        userAgent += \"Unknown OS; \";\r\n    }\r\n    userAgent += `${runtime}`;\r\n    if (runtimeVersion) {\r\n        userAgent += `; ${runtimeVersion}`;\r\n    }\r\n    else {\r\n        userAgent += \"; Unknown Runtime Version\";\r\n    }\r\n    userAgent += \")\";\r\n    return userAgent;\r\n}\r\n// eslint-disable-next-line spaced-comment\r\n/*#__PURE__*/ function getOsName() {\r\n    if (Platform.isNode) {\r\n        switch (process.platform) {\r\n            case \"win32\":\r\n                return \"Windows NT\";\r\n            case \"darwin\":\r\n                return \"macOS\";\r\n            case \"linux\":\r\n                return \"Linux\";\r\n            default:\r\n                return process.platform;\r\n        }\r\n    }\r\n    else {\r\n        return \"\";\r\n    }\r\n}\r\n// eslint-disable-next-line spaced-comment\r\n/*#__PURE__*/ function getRuntimeVersion() {\r\n    if (Platform.isNode) {\r\n        return process.versions.node;\r\n    }\r\n    return undefined;\r\n}\r\nfunction getRuntime() {\r\n    if (Platform.isNode) {\r\n        return \"NodeJS\";\r\n    }\r\n    else {\r\n        return \"Browser\";\r\n    }\r\n}\r\n/** @private */\r\nexport function getErrorString(e) {\r\n    if (e.stack) {\r\n        return e.stack;\r\n    }\r\n    else if (e.message) {\r\n        return e.message;\r\n    }\r\n    return `${e}`;\r\n}\r\n/** @private */\r\nexport function getGlobalThis() {\r\n    // globalThis is semi-new and not available in Node until v12\r\n    if (typeof globalThis !== \"undefined\") {\r\n        return globalThis;\r\n    }\r\n    if (typeof self !== \"undefined\") {\r\n        return self;\r\n    }\r\n    if (typeof window !== \"undefined\") {\r\n        return window;\r\n    }\r\n    if (typeof global !== \"undefined\") {\r\n        return global;\r\n    }\r\n    throw new Error(\"could not find global\");\r\n}\r\n//# sourceMappingURL=Utils.js.map","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","// http://www.w3.org/TR/CSS21/grammar.html\n// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027\nvar COMMENT_REGEX = /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//g;\n\nvar NEWLINE_REGEX = /\\n/g;\nvar WHITESPACE_REGEX = /^\\s*/;\n\n// declaration\nvar PROPERTY_REGEX = /^(\\*?[-#/*\\\\\\w]+(\\[[0-9a-z_-]+\\])?)\\s*/;\nvar COLON_REGEX = /^:\\s*/;\nvar VALUE_REGEX = /^((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^)]*?\\)|[^};])+)/;\nvar SEMICOLON_REGEX = /^[;\\s]*/;\n\n// https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim#Polyfill\nvar TRIM_REGEX = /^\\s+|\\s+$/g;\n\n// strings\nvar NEWLINE = '\\n';\nvar FORWARD_SLASH = '/';\nvar ASTERISK = '*';\nvar EMPTY_STRING = '';\n\n// types\nvar TYPE_COMMENT = 'comment';\nvar TYPE_DECLARATION = 'declaration';\n\n/**\n * @param {String} style\n * @param {Object} [options]\n * @return {Object[]}\n * @throws {TypeError}\n * @throws {Error}\n */\nmodule.exports = function(style, options) {\n  if (typeof style !== 'string') {\n    throw new TypeError('First argument must be a string');\n  }\n\n  if (!style) return [];\n\n  options = options || {};\n\n  /**\n   * Positional.\n   */\n  var lineno = 1;\n  var column = 1;\n\n  /**\n   * Update lineno and column based on `str`.\n   *\n   * @param {String} str\n   */\n  function updatePosition(str) {\n    var lines = str.match(NEWLINE_REGEX);\n    if (lines) lineno += lines.length;\n    var i = str.lastIndexOf(NEWLINE);\n    column = ~i ? str.length - i : column + str.length;\n  }\n\n  /**\n   * Mark position and patch `node.position`.\n   *\n   * @return {Function}\n   */\n  function position() {\n    var start = { line: lineno, column: column };\n    return function(node) {\n      node.position = new Position(start);\n      whitespace();\n      return node;\n    };\n  }\n\n  /**\n   * Store position information for a node.\n   *\n   * @constructor\n   * @property {Object} start\n   * @property {Object} end\n   * @property {undefined|String} source\n   */\n  function Position(start) {\n    this.start = start;\n    this.end = { line: lineno, column: column };\n    this.source = options.source;\n  }\n\n  /**\n   * Non-enumerable source string.\n   */\n  Position.prototype.content = style;\n\n  var errorsList = [];\n\n  /**\n   * Error `msg`.\n   *\n   * @param {String} msg\n   * @throws {Error}\n   */\n  function error(msg) {\n    var err = new Error(\n      options.source + ':' + lineno + ':' + column + ': ' + msg\n    );\n    err.reason = msg;\n    err.filename = options.source;\n    err.line = lineno;\n    err.column = column;\n    err.source = style;\n\n    if (options.silent) {\n      errorsList.push(err);\n    } else {\n      throw err;\n    }\n  }\n\n  /**\n   * Match `re` and return captures.\n   *\n   * @param {RegExp} re\n   * @return {undefined|Array}\n   */\n  function match(re) {\n    var m = re.exec(style);\n    if (!m) return;\n    var str = m[0];\n    updatePosition(str);\n    style = style.slice(str.length);\n    return m;\n  }\n\n  /**\n   * Parse whitespace.\n   */\n  function whitespace() {\n    match(WHITESPACE_REGEX);\n  }\n\n  /**\n   * Parse comments.\n   *\n   * @param {Object[]} [rules]\n   * @return {Object[]}\n   */\n  function comments(rules) {\n    var c;\n    rules = rules || [];\n    while ((c = comment())) {\n      if (c !== false) {\n        rules.push(c);\n      }\n    }\n    return rules;\n  }\n\n  /**\n   * Parse comment.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n  function comment() {\n    var pos = position();\n    if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;\n\n    var i = 2;\n    while (\n      EMPTY_STRING != style.charAt(i) &&\n      (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))\n    ) {\n      ++i;\n    }\n    i += 2;\n\n    if (EMPTY_STRING === style.charAt(i - 1)) {\n      return error('End of comment missing');\n    }\n\n    var str = style.slice(2, i - 2);\n    column += 2;\n    updatePosition(str);\n    style = style.slice(i);\n    column += 2;\n\n    return pos({\n      type: TYPE_COMMENT,\n      comment: str\n    });\n  }\n\n  /**\n   * Parse declaration.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n  function declaration() {\n    var pos = position();\n\n    // prop\n    var prop = match(PROPERTY_REGEX);\n    if (!prop) return;\n    comment();\n\n    // :\n    if (!match(COLON_REGEX)) return error(\"property missing ':'\");\n\n    // val\n    var val = match(VALUE_REGEX);\n\n    var ret = pos({\n      type: TYPE_DECLARATION,\n      property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),\n      value: val\n        ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING))\n        : EMPTY_STRING\n    });\n\n    // ;\n    match(SEMICOLON_REGEX);\n\n    return ret;\n  }\n\n  /**\n   * Parse declarations.\n   *\n   * @return {Object[]}\n   */\n  function declarations() {\n    var decls = [];\n\n    comments(decls);\n\n    // declarations\n    var decl;\n    while ((decl = declaration())) {\n      if (decl !== false) {\n        decls.push(decl);\n        comments(decls);\n      }\n    }\n\n    return decls;\n  }\n\n  whitespace();\n  return declarations();\n};\n\n/**\n * Trim `str`.\n *\n * @param {String} str\n * @return {String}\n */\nfunction trim(str) {\n  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;\n}\n","var camel2hyphen = require('string-convert/camel2hyphen');\n\nvar isDimension = function (feature) {\n  var re = /[height|width]$/;\n  return re.test(feature);\n};\n\nvar obj2mq = function (obj) {\n  var mq = '';\n  var features = Object.keys(obj);\n  features.forEach(function (feature, index) {\n    var value = obj[feature];\n    feature = camel2hyphen(feature);\n    // Add px to dimension features\n    if (isDimension(feature) && typeof value === 'number') {\n      value = value + 'px';\n    }\n    if (value === true) {\n      mq += feature;\n    } else if (value === false) {\n      mq += 'not ' + feature;\n    } else {\n      mq += '(' + feature + ': ' + value + ')';\n    }\n    if (index < features.length-1) {\n      mq += ' and '\n    }\n  });\n  return mq;\n};\n\nvar json2mq = function (query) {\n  var mq = '';\n  if (typeof query === 'string') {\n    return query;\n  }\n  // Handling array of media queries\n  if (query instanceof Array) {\n    query.forEach(function (q, index) {\n      mq += obj2mq(q);\n      if (index < query.length-1) {\n        mq += ', '\n      }\n    });\n    return mq;\n  }\n  // Handling single media query\n  return obj2mq(query);\n};\n\nmodule.exports = json2mq;","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = debounce;\n","var hashClear = require('./_hashClear'),\n    hashDelete = require('./_hashDelete'),\n    hashGet = require('./_hashGet'),\n    hashHas = require('./_hashHas'),\n    hashSet = require('./_hashSet');\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nmodule.exports = Hash;\n","var listCacheClear = require('./_listCacheClear'),\n    listCacheDelete = require('./_listCacheDelete'),\n    listCacheGet = require('./_listCacheGet'),\n    listCacheHas = require('./_listCacheHas'),\n    listCacheSet = require('./_listCacheSet');\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nmodule.exports = ListCache;\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nmodule.exports = Map;\n","var mapCacheClear = require('./_mapCacheClear'),\n    mapCacheDelete = require('./_mapCacheDelete'),\n    mapCacheGet = require('./_mapCacheGet'),\n    mapCacheHas = require('./_mapCacheHas'),\n    mapCacheSet = require('./_mapCacheSet');\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nmodule.exports = MapCache;\n","var ListCache = require('./_ListCache'),\n    stackClear = require('./_stackClear'),\n    stackDelete = require('./_stackDelete'),\n    stackGet = require('./_stackGet'),\n    stackHas = require('./_stackHas'),\n    stackSet = require('./_stackSet');\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\nmodule.exports = Stack;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Uint8Array = root.Uint8Array;\n\nmodule.exports = Uint8Array;\n","/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\nmodule.exports = apply;\n","var baseTimes = require('./_baseTimes'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isIndex = require('./_isIndex'),\n    isTypedArray = require('./isTypedArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = arrayLikeKeys;\n","var baseAssignValue = require('./_baseAssignValue'),\n    eq = require('./eq');\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n  if ((value !== undefined && !eq(object[key], value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\nmodule.exports = assignMergeValue;\n","var baseAssignValue = require('./_baseAssignValue'),\n    eq = require('./eq');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\nmodule.exports = assignValue;\n","var eq = require('./eq');\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\nmodule.exports = assocIndexOf;\n","var defineProperty = require('./_defineProperty');\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && defineProperty) {\n    defineProperty(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n\nmodule.exports = baseAssignValue;\n","var isObject = require('./isObject');\n\n/** Built-in value references. */\nvar objectCreate = Object.create;\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(proto) {\n    if (!isObject(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object;\n    object.prototype = undefined;\n    return result;\n  };\n}());\n\nmodule.exports = baseCreate;\n","var createBaseFor = require('./_createBaseFor');\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\nmodule.exports = baseFor;\n","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nmodule.exports = baseIsArguments;\n","var isFunction = require('./isFunction'),\n    isMasked = require('./_isMasked'),\n    isObject = require('./isObject'),\n    toSource = require('./_toSource');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n","var baseGetTag = require('./_baseGetTag'),\n    isLength = require('./isLength'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) &&\n    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nmodule.exports = baseIsTypedArray;\n","var isObject = require('./isObject'),\n    isPrototype = require('./_isPrototype'),\n    nativeKeysIn = require('./_nativeKeysIn');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseKeysIn;\n","var Stack = require('./_Stack'),\n    assignMergeValue = require('./_assignMergeValue'),\n    baseFor = require('./_baseFor'),\n    baseMergeDeep = require('./_baseMergeDeep'),\n    isObject = require('./isObject'),\n    keysIn = require('./keysIn'),\n    safeGet = require('./_safeGet');\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n  if (object === source) {\n    return;\n  }\n  baseFor(source, function(srcValue, key) {\n    stack || (stack = new Stack);\n    if (isObject(srcValue)) {\n      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n    }\n    else {\n      var newValue = customizer\n        ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      if (newValue === undefined) {\n        newValue = srcValue;\n      }\n      assignMergeValue(object, key, newValue);\n    }\n  }, keysIn);\n}\n\nmodule.exports = baseMerge;\n","var assignMergeValue = require('./_assignMergeValue'),\n    cloneBuffer = require('./_cloneBuffer'),\n    cloneTypedArray = require('./_cloneTypedArray'),\n    copyArray = require('./_copyArray'),\n    initCloneObject = require('./_initCloneObject'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isArrayLikeObject = require('./isArrayLikeObject'),\n    isBuffer = require('./isBuffer'),\n    isFunction = require('./isFunction'),\n    isObject = require('./isObject'),\n    isPlainObject = require('./isPlainObject'),\n    isTypedArray = require('./isTypedArray'),\n    safeGet = require('./_safeGet'),\n    toPlainObject = require('./toPlainObject');\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n  var objValue = safeGet(object, key),\n      srcValue = safeGet(source, key),\n      stacked = stack.get(srcValue);\n\n  if (stacked) {\n    assignMergeValue(object, key, stacked);\n    return;\n  }\n  var newValue = customizer\n    ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n    : undefined;\n\n  var isCommon = newValue === undefined;\n\n  if (isCommon) {\n    var isArr = isArray(srcValue),\n        isBuff = !isArr && isBuffer(srcValue),\n        isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n    newValue = srcValue;\n    if (isArr || isBuff || isTyped) {\n      if (isArray(objValue)) {\n        newValue = objValue;\n      }\n      else if (isArrayLikeObject(objValue)) {\n        newValue = copyArray(objValue);\n      }\n      else if (isBuff) {\n        isCommon = false;\n        newValue = cloneBuffer(srcValue, true);\n      }\n      else if (isTyped) {\n        isCommon = false;\n        newValue = cloneTypedArray(srcValue, true);\n      }\n      else {\n        newValue = [];\n      }\n    }\n    else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n      newValue = objValue;\n      if (isArguments(objValue)) {\n        newValue = toPlainObject(objValue);\n      }\n      else if (!isObject(objValue) || isFunction(objValue)) {\n        newValue = initCloneObject(srcValue);\n      }\n    }\n    else {\n      isCommon = false;\n    }\n  }\n  if (isCommon) {\n    // Recursively merge objects and arrays (susceptible to call stack limits).\n    stack.set(srcValue, newValue);\n    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n    stack['delete'](srcValue);\n  }\n  assignMergeValue(object, key, newValue);\n}\n\nmodule.exports = baseMergeDeep;\n","var identity = require('./identity'),\n    overRest = require('./_overRest'),\n    setToString = require('./_setToString');\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  return setToString(overRest(func, start, identity), func + '');\n}\n\nmodule.exports = baseRest;\n","var constant = require('./constant'),\n    defineProperty = require('./_defineProperty'),\n    identity = require('./identity');\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n  return defineProperty(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant(string),\n    'writable': true\n  });\n};\n\nmodule.exports = baseSetToString;\n","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\nmodule.exports = baseTimes;\n","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\nmodule.exports = baseUnary;\n","var Uint8Array = require('./_Uint8Array');\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\nmodule.exports = cloneArrayBuffer;\n","var root = require('./_root');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\nmodule.exports = cloneBuffer;\n","var cloneArrayBuffer = require('./_cloneArrayBuffer');\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\nmodule.exports = cloneTypedArray;\n","/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\nmodule.exports = copyArray;\n","var assignValue = require('./_assignValue'),\n    baseAssignValue = require('./_baseAssignValue');\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      baseAssignValue(object, key, newValue);\n    } else {\n      assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\nmodule.exports = copyObject;\n","var root = require('./_root');\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n","var baseRest = require('./_baseRest'),\n    isIterateeCall = require('./_isIterateeCall');\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return baseRest(function(object, sources) {\n    var index = -1,\n        length = sources.length,\n        customizer = length > 1 ? sources[length - 1] : undefined,\n        guard = length > 2 ? sources[2] : undefined;\n\n    customizer = (assigner.length > 3 && typeof customizer == 'function')\n      ? (length--, customizer)\n      : undefined;\n\n    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    object = Object(object);\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, index, customizer);\n      }\n    }\n    return object;\n  });\n}\n\nmodule.exports = createAssigner;\n","/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n  return function(object, iteratee, keysFunc) {\n    var index = -1,\n        iterable = Object(object),\n        props = keysFunc(object),\n        length = props.length;\n\n    while (length--) {\n      var key = props[fromRight ? length : ++index];\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n    return object;\n  };\n}\n\nmodule.exports = createBaseFor;\n","var getNative = require('./_getNative');\n\nvar defineProperty = (function() {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\nmodule.exports = defineProperty;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var isKeyable = require('./_isKeyable');\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\nmodule.exports = getMapData;\n","var baseIsNative = require('./_baseIsNative'),\n    getValue = require('./_getValue');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n","var overArg = require('./_overArg');\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nmodule.exports = getPrototype;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n","var nativeCreate = require('./_nativeCreate');\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\nmodule.exports = hashClear;\n","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = hashDelete;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nmodule.exports = hashGet;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nmodule.exports = hashHas;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\nmodule.exports = hashSet;\n","var baseCreate = require('./_baseCreate'),\n    getPrototype = require('./_getPrototype'),\n    isPrototype = require('./_isPrototype');\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\n    : {};\n}\n\nmodule.exports = initCloneObject;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  var type = typeof value;\n  length = length == null ? MAX_SAFE_INTEGER : length;\n\n  return !!length &&\n    (type == 'number' ||\n      (type != 'symbol' && reIsUint.test(value))) &&\n        (value > -1 && value % 1 == 0 && value < length);\n}\n\nmodule.exports = isIndex;\n","var eq = require('./eq'),\n    isArrayLike = require('./isArrayLike'),\n    isIndex = require('./_isIndex'),\n    isObject = require('./isObject');\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number'\n        ? (isArrayLike(object) && isIndex(index, object.length))\n        : (type == 'string' && index in object)\n      ) {\n    return eq(object[index], value);\n  }\n  return false;\n}\n\nmodule.exports = isIterateeCall;\n","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\nmodule.exports = isKeyable;\n","var coreJsData = require('./_coreJsData');\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\nmodule.exports = isPrototype;\n","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\nmodule.exports = listCacheClear;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\nmodule.exports = listCacheDelete;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\nmodule.exports = listCacheGet;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\nmodule.exports = listCacheHas;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\nmodule.exports = listCacheSet;\n","var Hash = require('./_Hash'),\n    ListCache = require('./_ListCache'),\n    Map = require('./_Map');\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\nmodule.exports = mapCacheClear;\n","var getMapData = require('./_getMapData');\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = mapCacheDelete;\n","var getMapData = require('./_getMapData');\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\nmodule.exports = mapCacheGet;\n","var getMapData = require('./_getMapData');\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\nmodule.exports = mapCacheHas;\n","var getMapData = require('./_getMapData');\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\nmodule.exports = mapCacheSet;\n","var getNative = require('./_getNative');\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nmodule.exports = nativeCreate;\n","/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = nativeKeysIn;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    // Use `util.types` for Node.js 10+.\n    var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n    if (types) {\n      return types;\n    }\n\n    // Legacy `process.binding('util')` for Node.js < 10.\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\nmodule.exports = nodeUtil;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\nmodule.exports = overArg;\n","var apply = require('./_apply');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = transform(array);\n    return apply(func, this, otherArgs);\n  };\n}\n\nmodule.exports = overRest;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","/**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction safeGet(object, key) {\n  if (key === 'constructor' && typeof object[key] === 'function') {\n    return;\n  }\n\n  if (key == '__proto__') {\n    return;\n  }\n\n  return object[key];\n}\n\nmodule.exports = safeGet;\n","var baseSetToString = require('./_baseSetToString'),\n    shortOut = require('./_shortOut');\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\nmodule.exports = setToString;\n","/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n    HOT_SPAN = 16;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeNow = Date.now;\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n  var count = 0,\n      lastCalled = 0;\n\n  return function() {\n    var stamp = nativeNow(),\n        remaining = HOT_SPAN - (stamp - lastCalled);\n\n    lastCalled = stamp;\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n    return func.apply(undefined, arguments);\n  };\n}\n\nmodule.exports = shortOut;\n","var ListCache = require('./_ListCache');\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\n\nmodule.exports = stackClear;\n","/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\nmodule.exports = stackDelete;\n","/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\nmodule.exports = stackGet;\n","/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\nmodule.exports = stackHas;\n","var ListCache = require('./_ListCache'),\n    Map = require('./_Map'),\n    MapCache = require('./_MapCache');\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\nmodule.exports = stackSet;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\nmodule.exports = toSource;\n","/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\nmodule.exports = constant;\n","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\nmodule.exports = eq;\n","/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\nmodule.exports = identity;\n","var baseIsArguments = require('./_baseIsArguments'),\n    isObjectLike = require('./isObjectLike');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\nmodule.exports = isArguments;\n","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nmodule.exports = isArray;\n","var isFunction = require('./isFunction'),\n    isLength = require('./isLength');\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\nmodule.exports = isArrayLike;\n","var isArrayLike = require('./isArrayLike'),\n    isObjectLike = require('./isObjectLike');\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\nmodule.exports = isArrayLikeObject;\n","var root = require('./_root'),\n    stubFalse = require('./stubFalse');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nmodule.exports = isBuffer;\n","var baseGetTag = require('./_baseGetTag'),\n    isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nmodule.exports = isLength;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var baseGetTag = require('./_baseGetTag'),\n    getPrototype = require('./_getPrototype'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString.call(Ctor) == objectCtorString;\n}\n\nmodule.exports = isPlainObject;\n","var baseIsTypedArray = require('./_baseIsTypedArray'),\n    baseUnary = require('./_baseUnary'),\n    nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nmodule.exports = isTypedArray;\n","var arrayLikeKeys = require('./_arrayLikeKeys'),\n    baseKeysIn = require('./_baseKeysIn'),\n    isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\nmodule.exports = keysIn;\n","var baseMerge = require('./_baseMerge'),\n    createAssigner = require('./_createAssigner');\n\n/**\n * This method is like `_.assign` except that it recursively merges own and\n * inherited enumerable string keyed properties of source objects into the\n * destination object. Source properties that resolve to `undefined` are\n * skipped if a destination value exists. Array and plain object properties\n * are merged recursively. Other objects and value types are overridden by\n * assignment. Source objects are applied from left to right. Subsequent\n * sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {\n *   'a': [{ 'b': 2 }, { 'd': 4 }]\n * };\n *\n * var other = {\n *   'a': [{ 'c': 3 }, { 'e': 5 }]\n * };\n *\n * _.merge(object, other);\n * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n */\nvar merge = createAssigner(function(object, source, srcIndex) {\n  baseMerge(object, source, srcIndex);\n});\n\nmodule.exports = merge;\n","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = stubFalse;\n","var copyObject = require('./_copyObject'),\n    keysIn = require('./keysIn');\n\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n  return copyObject(value, keysIn(value));\n}\n\nmodule.exports = toPlainObject;\n","import React, { Component } from 'react';\nimport _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport PropTypes from 'prop-types';\nimport warning from 'tiny-warning';\n\nvar MAX_SIGNED_31_BIT_INT = 1073741823;\nvar commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : {};\n\nfunction getUniqueId() {\n  var key = '__global_unique_id__';\n  return commonjsGlobal[key] = (commonjsGlobal[key] || 0) + 1;\n}\n\nfunction objectIs(x, y) {\n  if (x === y) {\n    return x !== 0 || 1 / x === 1 / y;\n  } else {\n    return x !== x && y !== y;\n  }\n}\n\nfunction createEventEmitter(value) {\n  var handlers = [];\n  return {\n    on: function on(handler) {\n      handlers.push(handler);\n    },\n    off: function off(handler) {\n      handlers = handlers.filter(function (h) {\n        return h !== handler;\n      });\n    },\n    get: function get() {\n      return value;\n    },\n    set: function set(newValue, changedBits) {\n      value = newValue;\n      handlers.forEach(function (handler) {\n        return handler(value, changedBits);\n      });\n    }\n  };\n}\n\nfunction onlyChild(children) {\n  return Array.isArray(children) ? children[0] : children;\n}\n\nfunction createReactContext(defaultValue, calculateChangedBits) {\n  var _Provider$childContex, _Consumer$contextType;\n\n  var contextProp = '__create-react-context-' + getUniqueId() + '__';\n\n  var Provider = /*#__PURE__*/function (_Component) {\n    _inheritsLoose(Provider, _Component);\n\n    function Provider() {\n      var _this;\n\n      _this = _Component.apply(this, arguments) || this;\n      _this.emitter = createEventEmitter(_this.props.value);\n      return _this;\n    }\n\n    var _proto = Provider.prototype;\n\n    _proto.getChildContext = function getChildContext() {\n      var _ref;\n\n      return _ref = {}, _ref[contextProp] = this.emitter, _ref;\n    };\n\n    _proto.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n      if (this.props.value !== nextProps.value) {\n        var oldValue = this.props.value;\n        var newValue = nextProps.value;\n        var changedBits;\n\n        if (objectIs(oldValue, newValue)) {\n          changedBits = 0;\n        } else {\n          changedBits = typeof calculateChangedBits === 'function' ? calculateChangedBits(oldValue, newValue) : MAX_SIGNED_31_BIT_INT;\n\n          if (process.env.NODE_ENV !== 'production') {\n            warning((changedBits & MAX_SIGNED_31_BIT_INT) === changedBits, 'calculateChangedBits: Expected the return value to be a ' + '31-bit integer. Instead received: ' + changedBits);\n          }\n\n          changedBits |= 0;\n\n          if (changedBits !== 0) {\n            this.emitter.set(nextProps.value, changedBits);\n          }\n        }\n      }\n    };\n\n    _proto.render = function render() {\n      return this.props.children;\n    };\n\n    return Provider;\n  }(Component);\n\n  Provider.childContextTypes = (_Provider$childContex = {}, _Provider$childContex[contextProp] = PropTypes.object.isRequired, _Provider$childContex);\n\n  var Consumer = /*#__PURE__*/function (_Component2) {\n    _inheritsLoose(Consumer, _Component2);\n\n    function Consumer() {\n      var _this2;\n\n      _this2 = _Component2.apply(this, arguments) || this;\n      _this2.state = {\n        value: _this2.getValue()\n      };\n\n      _this2.onUpdate = function (newValue, changedBits) {\n        var observedBits = _this2.observedBits | 0;\n\n        if ((observedBits & changedBits) !== 0) {\n          _this2.setState({\n            value: _this2.getValue()\n          });\n        }\n      };\n\n      return _this2;\n    }\n\n    var _proto2 = Consumer.prototype;\n\n    _proto2.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n      var observedBits = nextProps.observedBits;\n      this.observedBits = observedBits === undefined || observedBits === null ? MAX_SIGNED_31_BIT_INT : observedBits;\n    };\n\n    _proto2.componentDidMount = function componentDidMount() {\n      if (this.context[contextProp]) {\n        this.context[contextProp].on(this.onUpdate);\n      }\n\n      var observedBits = this.props.observedBits;\n      this.observedBits = observedBits === undefined || observedBits === null ? MAX_SIGNED_31_BIT_INT : observedBits;\n    };\n\n    _proto2.componentWillUnmount = function componentWillUnmount() {\n      if (this.context[contextProp]) {\n        this.context[contextProp].off(this.onUpdate);\n      }\n    };\n\n    _proto2.getValue = function getValue() {\n      if (this.context[contextProp]) {\n        return this.context[contextProp].get();\n      } else {\n        return defaultValue;\n      }\n    };\n\n    _proto2.render = function render() {\n      return onlyChild(this.props.children)(this.state.value);\n    };\n\n    return Consumer;\n  }(Component);\n\n  Consumer.contextTypes = (_Consumer$contextType = {}, _Consumer$contextType[contextProp] = PropTypes.object, _Consumer$contextType);\n  return {\n    Provider: Provider,\n    Consumer: Consumer\n  };\n}\n\nvar index = React.createContext || createReactContext;\n\nexport default index;\n","function n(n){for(var r=arguments.length,t=Array(r>1?r-1:0),e=1;e<r;e++)t[e-1]=arguments[e];if(\"production\"!==process.env.NODE_ENV){var i=Y[n],o=i?\"function\"==typeof i?i.apply(null,t):i:\"unknown error nr: \"+n;throw Error(\"[Immer] \"+o)}throw Error(\"[Immer] minified error nr: \"+n+(t.length?\" \"+t.map((function(n){return\"'\"+n+\"'\"})).join(\",\"):\"\")+\". Find the full error at: https://bit.ly/3cXEKWf\")}function r(n){return!!n&&!!n[Q]}function t(n){var r;return!!n&&(function(n){if(!n||\"object\"!=typeof n)return!1;var r=Object.getPrototypeOf(n);if(null===r)return!0;var t=Object.hasOwnProperty.call(r,\"constructor\")&&r.constructor;return t===Object||\"function\"==typeof t&&Function.toString.call(t)===Z}(n)||Array.isArray(n)||!!n[L]||!!(null===(r=n.constructor)||void 0===r?void 0:r[L])||s(n)||v(n))}function e(t){return r(t)||n(23,t),t[Q].t}function i(n,r,t){void 0===t&&(t=!1),0===o(n)?(t?Object.keys:nn)(n).forEach((function(e){t&&\"symbol\"==typeof e||r(e,n[e],n)})):n.forEach((function(t,e){return r(e,t,n)}))}function o(n){var r=n[Q];return r?r.i>3?r.i-4:r.i:Array.isArray(n)?1:s(n)?2:v(n)?3:0}function u(n,r){return 2===o(n)?n.has(r):Object.prototype.hasOwnProperty.call(n,r)}function a(n,r){return 2===o(n)?n.get(r):n[r]}function f(n,r,t){var e=o(n);2===e?n.set(r,t):3===e?n.add(t):n[r]=t}function c(n,r){return n===r?0!==n||1/n==1/r:n!=n&&r!=r}function s(n){return X&&n instanceof Map}function v(n){return q&&n instanceof Set}function p(n){return n.o||n.t}function l(n){if(Array.isArray(n))return Array.prototype.slice.call(n);var r=rn(n);delete r[Q];for(var t=nn(r),e=0;e<t.length;e++){var i=t[e],o=r[i];!1===o.writable&&(o.writable=!0,o.configurable=!0),(o.get||o.set)&&(r[i]={configurable:!0,writable:!0,enumerable:o.enumerable,value:n[i]})}return Object.create(Object.getPrototypeOf(n),r)}function d(n,e){return void 0===e&&(e=!1),y(n)||r(n)||!t(n)||(o(n)>1&&(n.set=n.add=n.clear=n.delete=h),Object.freeze(n),e&&i(n,(function(n,r){return d(r,!0)}),!0)),n}function h(){n(2)}function y(n){return null==n||\"object\"!=typeof n||Object.isFrozen(n)}function b(r){var t=tn[r];return t||n(18,r),t}function m(n,r){tn[n]||(tn[n]=r)}function _(){return\"production\"===process.env.NODE_ENV||U||n(0),U}function j(n,r){r&&(b(\"Patches\"),n.u=[],n.s=[],n.v=r)}function g(n){O(n),n.p.forEach(S),n.p=null}function O(n){n===U&&(U=n.l)}function w(n){return U={p:[],l:U,h:n,m:!0,_:0}}function S(n){var r=n[Q];0===r.i||1===r.i?r.j():r.g=!0}function P(r,e){e._=e.p.length;var i=e.p[0],o=void 0!==r&&r!==i;return e.h.O||b(\"ES5\").S(e,r,o),o?(i[Q].P&&(g(e),n(4)),t(r)&&(r=M(e,r),e.l||x(e,r)),e.u&&b(\"Patches\").M(i[Q].t,r,e.u,e.s)):r=M(e,i,[]),g(e),e.u&&e.v(e.u,e.s),r!==H?r:void 0}function M(n,r,t){if(y(r))return r;var e=r[Q];if(!e)return i(r,(function(i,o){return A(n,e,r,i,o,t)}),!0),r;if(e.A!==n)return r;if(!e.P)return x(n,e.t,!0),e.t;if(!e.I){e.I=!0,e.A._--;var o=4===e.i||5===e.i?e.o=l(e.k):e.o,u=o,a=!1;3===e.i&&(u=new Set(o),o.clear(),a=!0),i(u,(function(r,i){return A(n,e,o,r,i,t,a)})),x(n,o,!1),t&&n.u&&b(\"Patches\").N(e,t,n.u,n.s)}return e.o}function A(e,i,o,a,c,s,v){if(\"production\"!==process.env.NODE_ENV&&c===o&&n(5),r(c)){var p=M(e,c,s&&i&&3!==i.i&&!u(i.R,a)?s.concat(a):void 0);if(f(o,a,p),!r(p))return;e.m=!1}else v&&o.add(c);if(t(c)&&!y(c)){if(!e.h.D&&e._<1)return;M(e,c),i&&i.A.l||x(e,c)}}function x(n,r,t){void 0===t&&(t=!1),!n.l&&n.h.D&&n.m&&d(r,t)}function z(n,r){var t=n[Q];return(t?p(t):n)[r]}function I(n,r){if(r in n)for(var t=Object.getPrototypeOf(n);t;){var e=Object.getOwnPropertyDescriptor(t,r);if(e)return e;t=Object.getPrototypeOf(t)}}function k(n){n.P||(n.P=!0,n.l&&k(n.l))}function E(n){n.o||(n.o=l(n.t))}function N(n,r,t){var e=s(r)?b(\"MapSet\").F(r,t):v(r)?b(\"MapSet\").T(r,t):n.O?function(n,r){var t=Array.isArray(n),e={i:t?1:0,A:r?r.A:_(),P:!1,I:!1,R:{},l:r,t:n,k:null,o:null,j:null,C:!1},i=e,o=en;t&&(i=[e],o=on);var u=Proxy.revocable(i,o),a=u.revoke,f=u.proxy;return e.k=f,e.j=a,f}(r,t):b(\"ES5\").J(r,t);return(t?t.A:_()).p.push(e),e}function R(e){return r(e)||n(22,e),function n(r){if(!t(r))return r;var e,u=r[Q],c=o(r);if(u){if(!u.P&&(u.i<4||!b(\"ES5\").K(u)))return u.t;u.I=!0,e=D(r,c),u.I=!1}else e=D(r,c);return i(e,(function(r,t){u&&a(u.t,r)===t||f(e,r,n(t))})),3===c?new Set(e):e}(e)}function D(n,r){switch(r){case 2:return new Map(n);case 3:return Array.from(n)}return l(n)}function F(){function t(n,r){var t=s[n];return t?t.enumerable=r:s[n]=t={configurable:!0,enumerable:r,get:function(){var r=this[Q];return\"production\"!==process.env.NODE_ENV&&f(r),en.get(r,n)},set:function(r){var t=this[Q];\"production\"!==process.env.NODE_ENV&&f(t),en.set(t,n,r)}},t}function e(n){for(var r=n.length-1;r>=0;r--){var t=n[r][Q];if(!t.P)switch(t.i){case 5:a(t)&&k(t);break;case 4:o(t)&&k(t)}}}function o(n){for(var r=n.t,t=n.k,e=nn(t),i=e.length-1;i>=0;i--){var o=e[i];if(o!==Q){var a=r[o];if(void 0===a&&!u(r,o))return!0;var f=t[o],s=f&&f[Q];if(s?s.t!==a:!c(f,a))return!0}}var v=!!r[Q];return e.length!==nn(r).length+(v?0:1)}function a(n){var r=n.k;if(r.length!==n.t.length)return!0;var t=Object.getOwnPropertyDescriptor(r,r.length-1);if(t&&!t.get)return!0;for(var e=0;e<r.length;e++)if(!r.hasOwnProperty(e))return!0;return!1}function f(r){r.g&&n(3,JSON.stringify(p(r)))}var s={};m(\"ES5\",{J:function(n,r){var e=Array.isArray(n),i=function(n,r){if(n){for(var e=Array(r.length),i=0;i<r.length;i++)Object.defineProperty(e,\"\"+i,t(i,!0));return e}var o=rn(r);delete o[Q];for(var u=nn(o),a=0;a<u.length;a++){var f=u[a];o[f]=t(f,n||!!o[f].enumerable)}return Object.create(Object.getPrototypeOf(r),o)}(e,n),o={i:e?5:4,A:r?r.A:_(),P:!1,I:!1,R:{},l:r,t:n,k:i,o:null,g:!1,C:!1};return Object.defineProperty(i,Q,{value:o,writable:!0}),i},S:function(n,t,o){o?r(t)&&t[Q].A===n&&e(n.p):(n.u&&function n(r){if(r&&\"object\"==typeof r){var t=r[Q];if(t){var e=t.t,o=t.k,f=t.R,c=t.i;if(4===c)i(o,(function(r){r!==Q&&(void 0!==e[r]||u(e,r)?f[r]||n(o[r]):(f[r]=!0,k(t)))})),i(e,(function(n){void 0!==o[n]||u(o,n)||(f[n]=!1,k(t))}));else if(5===c){if(a(t)&&(k(t),f.length=!0),o.length<e.length)for(var s=o.length;s<e.length;s++)f[s]=!1;else for(var v=e.length;v<o.length;v++)f[v]=!0;for(var p=Math.min(o.length,e.length),l=0;l<p;l++)o.hasOwnProperty(l)||(f[l]=!0),void 0===f[l]&&n(o[l])}}}}(n.p[0]),e(n.p))},K:function(n){return 4===n.i?o(n):a(n)}})}function T(){function e(n){if(!t(n))return n;if(Array.isArray(n))return n.map(e);if(s(n))return new Map(Array.from(n.entries()).map((function(n){return[n[0],e(n[1])]})));if(v(n))return new Set(Array.from(n).map(e));var r=Object.create(Object.getPrototypeOf(n));for(var i in n)r[i]=e(n[i]);return u(n,L)&&(r[L]=n[L]),r}function f(n){return r(n)?e(n):n}var c=\"add\";m(\"Patches\",{$:function(r,t){return t.forEach((function(t){for(var i=t.path,u=t.op,f=r,s=0;s<i.length-1;s++){var v=o(f),p=i[s];\"string\"!=typeof p&&\"number\"!=typeof p&&(p=\"\"+p),0!==v&&1!==v||\"__proto__\"!==p&&\"constructor\"!==p||n(24),\"function\"==typeof f&&\"prototype\"===p&&n(24),\"object\"!=typeof(f=a(f,p))&&n(15,i.join(\"/\"))}var l=o(f),d=e(t.value),h=i[i.length-1];switch(u){case\"replace\":switch(l){case 2:return f.set(h,d);case 3:n(16);default:return f[h]=d}case c:switch(l){case 1:return\"-\"===h?f.push(d):f.splice(h,0,d);case 2:return f.set(h,d);case 3:return f.add(d);default:return f[h]=d}case\"remove\":switch(l){case 1:return f.splice(h,1);case 2:return f.delete(h);case 3:return f.delete(t.value);default:return delete f[h]}default:n(17,u)}})),r},N:function(n,r,t,e){switch(n.i){case 0:case 4:case 2:return function(n,r,t,e){var o=n.t,s=n.o;i(n.R,(function(n,i){var v=a(o,n),p=a(s,n),l=i?u(o,n)?\"replace\":c:\"remove\";if(v!==p||\"replace\"!==l){var d=r.concat(n);t.push(\"remove\"===l?{op:l,path:d}:{op:l,path:d,value:p}),e.push(l===c?{op:\"remove\",path:d}:\"remove\"===l?{op:c,path:d,value:f(v)}:{op:\"replace\",path:d,value:f(v)})}}))}(n,r,t,e);case 5:case 1:return function(n,r,t,e){var i=n.t,o=n.R,u=n.o;if(u.length<i.length){var a=[u,i];i=a[0],u=a[1];var s=[e,t];t=s[0],e=s[1]}for(var v=0;v<i.length;v++)if(o[v]&&u[v]!==i[v]){var p=r.concat([v]);t.push({op:\"replace\",path:p,value:f(u[v])}),e.push({op:\"replace\",path:p,value:f(i[v])})}for(var l=i.length;l<u.length;l++){var d=r.concat([l]);t.push({op:c,path:d,value:f(u[l])})}i.length<u.length&&e.push({op:\"replace\",path:r.concat([\"length\"]),value:i.length})}(n,r,t,e);case 3:return function(n,r,t,e){var i=n.t,o=n.o,u=0;i.forEach((function(n){if(!o.has(n)){var i=r.concat([u]);t.push({op:\"remove\",path:i,value:n}),e.unshift({op:c,path:i,value:n})}u++})),u=0,o.forEach((function(n){if(!i.has(n)){var o=r.concat([u]);t.push({op:c,path:o,value:n}),e.unshift({op:\"remove\",path:o,value:n})}u++}))}(n,r,t,e)}},M:function(n,r,t,e){t.push({op:\"replace\",path:[],value:r===H?void 0:r}),e.push({op:\"replace\",path:[],value:n})}})}function C(){function r(n,r){function t(){this.constructor=n}a(n,r),n.prototype=(t.prototype=r.prototype,new t)}function e(n){n.o||(n.R=new Map,n.o=new Map(n.t))}function o(n){n.o||(n.o=new Set,n.t.forEach((function(r){if(t(r)){var e=N(n.A.h,r,n);n.p.set(r,e),n.o.add(e)}else n.o.add(r)})))}function u(r){r.g&&n(3,JSON.stringify(p(r)))}var a=function(n,r){return(a=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(n,r){n.__proto__=r}||function(n,r){for(var t in r)r.hasOwnProperty(t)&&(n[t]=r[t])})(n,r)},f=function(){function n(n,r){return this[Q]={i:2,l:r,A:r?r.A:_(),P:!1,I:!1,o:void 0,R:void 0,t:n,k:this,C:!1,g:!1},this}r(n,Map);var o=n.prototype;return Object.defineProperty(o,\"size\",{get:function(){return p(this[Q]).size}}),o.has=function(n){return p(this[Q]).has(n)},o.set=function(n,r){var t=this[Q];return u(t),p(t).has(n)&&p(t).get(n)===r||(e(t),k(t),t.R.set(n,!0),t.o.set(n,r),t.R.set(n,!0)),this},o.delete=function(n){if(!this.has(n))return!1;var r=this[Q];return u(r),e(r),k(r),r.t.has(n)?r.R.set(n,!1):r.R.delete(n),r.o.delete(n),!0},o.clear=function(){var n=this[Q];u(n),p(n).size&&(e(n),k(n),n.R=new Map,i(n.t,(function(r){n.R.set(r,!1)})),n.o.clear())},o.forEach=function(n,r){var t=this;p(this[Q]).forEach((function(e,i){n.call(r,t.get(i),i,t)}))},o.get=function(n){var r=this[Q];u(r);var i=p(r).get(n);if(r.I||!t(i))return i;if(i!==r.t.get(n))return i;var o=N(r.A.h,i,r);return e(r),r.o.set(n,o),o},o.keys=function(){return p(this[Q]).keys()},o.values=function(){var n,r=this,t=this.keys();return(n={})[V]=function(){return r.values()},n.next=function(){var n=t.next();return n.done?n:{done:!1,value:r.get(n.value)}},n},o.entries=function(){var n,r=this,t=this.keys();return(n={})[V]=function(){return r.entries()},n.next=function(){var n=t.next();if(n.done)return n;var e=r.get(n.value);return{done:!1,value:[n.value,e]}},n},o[V]=function(){return this.entries()},n}(),c=function(){function n(n,r){return this[Q]={i:3,l:r,A:r?r.A:_(),P:!1,I:!1,o:void 0,t:n,k:this,p:new Map,g:!1,C:!1},this}r(n,Set);var t=n.prototype;return Object.defineProperty(t,\"size\",{get:function(){return p(this[Q]).size}}),t.has=function(n){var r=this[Q];return u(r),r.o?!!r.o.has(n)||!(!r.p.has(n)||!r.o.has(r.p.get(n))):r.t.has(n)},t.add=function(n){var r=this[Q];return u(r),this.has(n)||(o(r),k(r),r.o.add(n)),this},t.delete=function(n){if(!this.has(n))return!1;var r=this[Q];return u(r),o(r),k(r),r.o.delete(n)||!!r.p.has(n)&&r.o.delete(r.p.get(n))},t.clear=function(){var n=this[Q];u(n),p(n).size&&(o(n),k(n),n.o.clear())},t.values=function(){var n=this[Q];return u(n),o(n),n.o.values()},t.entries=function(){var n=this[Q];return u(n),o(n),n.o.entries()},t.keys=function(){return this.values()},t[V]=function(){return this.values()},t.forEach=function(n,r){for(var t=this.values(),e=t.next();!e.done;)n.call(r,e.value,e.value,this),e=t.next()},n}();m(\"MapSet\",{F:function(n,r){return new f(n,r)},T:function(n,r){return new c(n,r)}})}function J(){F(),C(),T()}function K(n){return n}function $(n){return n}var G,U,W=\"undefined\"!=typeof Symbol&&\"symbol\"==typeof Symbol(\"x\"),X=\"undefined\"!=typeof Map,q=\"undefined\"!=typeof Set,B=\"undefined\"!=typeof Proxy&&void 0!==Proxy.revocable&&\"undefined\"!=typeof Reflect,H=W?Symbol.for(\"immer-nothing\"):((G={})[\"immer-nothing\"]=!0,G),L=W?Symbol.for(\"immer-draftable\"):\"__$immer_draftable\",Q=W?Symbol.for(\"immer-state\"):\"__$immer_state\",V=\"undefined\"!=typeof Symbol&&Symbol.iterator||\"@@iterator\",Y={0:\"Illegal state\",1:\"Immer drafts cannot have computed properties\",2:\"This object has been frozen and should not be mutated\",3:function(n){return\"Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? \"+n},4:\"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.\",5:\"Immer forbids circular references\",6:\"The first or second argument to `produce` must be a function\",7:\"The third argument to `produce` must be a function or undefined\",8:\"First argument to `createDraft` must be a plain object, an array, or an immerable object\",9:\"First argument to `finishDraft` must be a draft returned by `createDraft`\",10:\"The given draft is already finalized\",11:\"Object.defineProperty() cannot be used on an Immer draft\",12:\"Object.setPrototypeOf() cannot be used on an Immer draft\",13:\"Immer only supports deleting array indices\",14:\"Immer only supports setting array indices and the 'length' property\",15:function(n){return\"Cannot apply patch, path doesn't resolve: \"+n},16:'Sets cannot have \"replace\" patches.',17:function(n){return\"Unsupported patch operation: \"+n},18:function(n){return\"The plugin for '\"+n+\"' has not been loaded into Immer. To enable the plugin, import and call `enable\"+n+\"()` when initializing your application.\"},20:\"Cannot use proxies if Proxy, Proxy.revocable or Reflect are not available\",21:function(n){return\"produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '\"+n+\"'\"},22:function(n){return\"'current' expects a draft, got: \"+n},23:function(n){return\"'original' expects a draft, got: \"+n},24:\"Patching reserved attributes like __proto__, prototype and constructor is not allowed\"},Z=\"\"+Object.prototype.constructor,nn=\"undefined\"!=typeof Reflect&&Reflect.ownKeys?Reflect.ownKeys:void 0!==Object.getOwnPropertySymbols?function(n){return Object.getOwnPropertyNames(n).concat(Object.getOwnPropertySymbols(n))}:Object.getOwnPropertyNames,rn=Object.getOwnPropertyDescriptors||function(n){var r={};return nn(n).forEach((function(t){r[t]=Object.getOwnPropertyDescriptor(n,t)})),r},tn={},en={get:function(n,r){if(r===Q)return n;var e=p(n);if(!u(e,r))return function(n,r,t){var e,i=I(r,t);return i?\"value\"in i?i.value:null===(e=i.get)||void 0===e?void 0:e.call(n.k):void 0}(n,e,r);var i=e[r];return n.I||!t(i)?i:i===z(n.t,r)?(E(n),n.o[r]=N(n.A.h,i,n)):i},has:function(n,r){return r in p(n)},ownKeys:function(n){return Reflect.ownKeys(p(n))},set:function(n,r,t){var e=I(p(n),r);if(null==e?void 0:e.set)return e.set.call(n.k,t),!0;if(!n.P){var i=z(p(n),r),o=null==i?void 0:i[Q];if(o&&o.t===t)return n.o[r]=t,n.R[r]=!1,!0;if(c(t,i)&&(void 0!==t||u(n.t,r)))return!0;E(n),k(n)}return n.o[r]===t&&(void 0!==t||r in n.o)||Number.isNaN(t)&&Number.isNaN(n.o[r])||(n.o[r]=t,n.R[r]=!0),!0},deleteProperty:function(n,r){return void 0!==z(n.t,r)||r in n.t?(n.R[r]=!1,E(n),k(n)):delete n.R[r],n.o&&delete n.o[r],!0},getOwnPropertyDescriptor:function(n,r){var t=p(n),e=Reflect.getOwnPropertyDescriptor(t,r);return e?{writable:!0,configurable:1!==n.i||\"length\"!==r,enumerable:e.enumerable,value:t[r]}:e},defineProperty:function(){n(11)},getPrototypeOf:function(n){return Object.getPrototypeOf(n.t)},setPrototypeOf:function(){n(12)}},on={};i(en,(function(n,r){on[n]=function(){return arguments[0]=arguments[0][0],r.apply(this,arguments)}})),on.deleteProperty=function(r,t){return\"production\"!==process.env.NODE_ENV&&isNaN(parseInt(t))&&n(13),on.set.call(this,r,t,void 0)},on.set=function(r,t,e){return\"production\"!==process.env.NODE_ENV&&\"length\"!==t&&isNaN(parseInt(t))&&n(14),en.set.call(this,r[0],t,e,r[0])};var un=function(){function e(r){var e=this;this.O=B,this.D=!0,this.produce=function(r,i,o){if(\"function\"==typeof r&&\"function\"!=typeof i){var u=i;i=r;var a=e;return function(n){var r=this;void 0===n&&(n=u);for(var t=arguments.length,e=Array(t>1?t-1:0),o=1;o<t;o++)e[o-1]=arguments[o];return a.produce(n,(function(n){var t;return(t=i).call.apply(t,[r,n].concat(e))}))}}var f;if(\"function\"!=typeof i&&n(6),void 0!==o&&\"function\"!=typeof o&&n(7),t(r)){var c=w(e),s=N(e,r,void 0),v=!0;try{f=i(s),v=!1}finally{v?g(c):O(c)}return\"undefined\"!=typeof Promise&&f instanceof Promise?f.then((function(n){return j(c,o),P(n,c)}),(function(n){throw g(c),n})):(j(c,o),P(f,c))}if(!r||\"object\"!=typeof r){if(void 0===(f=i(r))&&(f=r),f===H&&(f=void 0),e.D&&d(f,!0),o){var p=[],l=[];b(\"Patches\").M(r,f,p,l),o(p,l)}return f}n(21,r)},this.produceWithPatches=function(n,r){if(\"function\"==typeof n)return function(r){for(var t=arguments.length,i=Array(t>1?t-1:0),o=1;o<t;o++)i[o-1]=arguments[o];return e.produceWithPatches(r,(function(r){return n.apply(void 0,[r].concat(i))}))};var t,i,o=e.produce(n,r,(function(n,r){t=n,i=r}));return\"undefined\"!=typeof Promise&&o instanceof Promise?o.then((function(n){return[n,t,i]})):[o,t,i]},\"boolean\"==typeof(null==r?void 0:r.useProxies)&&this.setUseProxies(r.useProxies),\"boolean\"==typeof(null==r?void 0:r.autoFreeze)&&this.setAutoFreeze(r.autoFreeze)}var i=e.prototype;return i.createDraft=function(e){t(e)||n(8),r(e)&&(e=R(e));var i=w(this),o=N(this,e,void 0);return o[Q].C=!0,O(i),o},i.finishDraft=function(r,t){var e=r&&r[Q];\"production\"!==process.env.NODE_ENV&&(e&&e.C||n(9),e.I&&n(10));var i=e.A;return j(i,t),P(void 0,i)},i.setAutoFreeze=function(n){this.D=n},i.setUseProxies=function(r){r&&!B&&n(20),this.O=r},i.applyPatches=function(n,t){var e;for(e=t.length-1;e>=0;e--){var i=t[e];if(0===i.path.length&&\"replace\"===i.op){n=i.value;break}}e>-1&&(t=t.slice(e+1));var o=b(\"Patches\").$;return r(n)?o(n,t):this.produce(n,(function(n){return o(n,t)}))},e}(),an=new un,fn=an.produce,cn=an.produceWithPatches.bind(an),sn=an.setAutoFreeze.bind(an),vn=an.setUseProxies.bind(an),pn=an.applyPatches.bind(an),ln=an.createDraft.bind(an),dn=an.finishDraft.bind(an);export default fn;export{un as Immer,pn as applyPatches,K as castDraft,$ as castImmutable,ln as createDraft,R as current,J as enableAllPlugins,F as enableES5,C as enableMapSet,T as enablePatches,dn as finishDraft,d as freeze,L as immerable,r as isDraft,t as isDraftable,H as nothing,e as original,fn as produce,cn as produceWithPatches,sn as setAutoFreeze,vn as setUseProxies};\n//# sourceMappingURL=immer.esm.js.map\n","export default function isPlainObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n","/**\n * @typedef {import('mdast').Root|import('mdast').Content} Node\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s.\n */\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} value\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const includeImageAlt = (options || {}).includeImageAlt\n  return one(\n    value,\n    typeof includeImageAlt === 'boolean' ? includeImageAlt : true\n  )\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt) {\n  return (\n    (node(value) &&\n      (('value' in value && value.value) ||\n        (includeImageAlt && 'alt' in value && value.alt) ||\n        ('children' in value && all(value.children, includeImageAlt)))) ||\n    (Array.isArray(value) && all(value, includeImageAlt)) ||\n    ''\n  )\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Node}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n","/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n * @param {T[]} list\n * @param {number} start\n * @param {number} remove\n * @param {T[]} items\n * @returns {void}\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length\n  let chunkStart = 0\n  /** @type {unknown[]} */\n\n  let parameters // Make start between zero and `end` (included).\n\n  if (start < 0) {\n    start = -start > end ? 0 : end + start\n  } else {\n    start = start > end ? end : start\n  }\n\n  remove = remove > 0 ? remove : 0 // No need to chunk the items if there’s only a couple (10k) items.\n\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove) // @ts-expect-error Hush, it’s fine.\n    ;[].splice.apply(list, parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) [].splice.apply(list, [start, remove]) // Insert the items in chunks to not cause stack overflows.\n\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0) // @ts-expect-error Hush, it’s fine.\n      ;[].splice.apply(list, parameters)\n      chunkStart += 10000\n      start += 10000\n    }\n  }\n}\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n * @param {T[]} list\n * @param {T[]} items\n * @returns {T[]}\n */\n\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items)\n    return list\n  }\n\n  return items\n}\n","/**\n * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine several syntax extensions into one.\n *\n * @param {Extension[]} extensions List of syntax extensions.\n * @returns {NormalizedExtension} A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all Extension to merge into.\n * @param {Extension} extension Extension to merge.\n * @returns {void}\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {string} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    for (code in right) {\n      if (!hasOwnProperty.call(left, code)) left[code] = []\n      const value = right[code]\n      constructs(\n        // @ts-expect-error Looks like a list.\n        left[code],\n        Array.isArray(value) ? value : value ? [value] : []\n      )\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {unknown[]} existing\n * @param {unknown[]} list\n * @returns {void}\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {unknown[]} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine several HTML extensions into one.\n *\n * @param {HtmlExtension[]} htmlExtensions List of HTML extensions.\n * @returns {HtmlExtension} A single combined extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all Extension to merge into.\n * @param {HtmlExtension} extension Extension to merge.\n * @returns {void}\n */\nfunction htmlExtension(all, extension) {\n  /** @type {string} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {string} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        left[type] = right[type]\n      }\n    }\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownSpace} from 'micromark-util-character'\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {string} type\n * @param {number} [max=Infinity]\n * @returns {State}\n */\n\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n\n    return ok(code)\n  }\n  /** @type {State} */\n\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n\n    effects.exit(type)\n    return ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n}\n/** @type {Initializer} */\n\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(\n    this.parser.constructs.contentInitial,\n    afterContentStartConstruct,\n    paragraphInitial\n  )\n  /** @type {Token} */\n\n  let previous\n  return contentStart\n  /** @type {State} */\n\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, contentStart, 'linePrefix')\n  }\n  /** @type {State} */\n\n  function paragraphInitial(code) {\n    effects.enter('paragraph')\n    return lineStart(code)\n  }\n  /** @type {State} */\n\n  function lineStart(code) {\n    const token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous\n    })\n\n    if (previous) {\n      previous.next = token\n    }\n\n    previous = token\n    return data(code)\n  }\n  /** @type {State} */\n\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText')\n      effects.exit('paragraph')\n      effects.consume(code)\n      return\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      effects.exit('chunkText')\n      return lineStart\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Point} Point\n */\n\n/**\n * @typedef {Record<string, unknown>} StackState\n * @typedef {[Construct, StackState]} StackItem\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n/** @type {InitialConstruct} */\n\nexport const document = {\n  tokenize: initializeDocument\n}\n/** @type {Construct} */\n\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n}\n/** @type {Initializer} */\n\nfunction initializeDocument(effects) {\n  const self = this\n  /** @type {Array<StackItem>} */\n\n  const stack = []\n  let continued = 0\n  /** @type {TokenizeContext|undefined} */\n\n  let childFlow\n  /** @type {Token|undefined} */\n\n  let childToken\n  /** @type {number} */\n\n  let lineStartOffset\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    // First we iterate through the open blocks, starting with the root\n    // document, and descending through last children down to the last open\n    // block.\n    // Each block imposes a condition that the line must satisfy if the block is\n    // to remain open.\n    // For example, a block quote requires a `>` character.\n    // A paragraph requires a non-blank line.\n    // In this phase we may match all or just some of the open blocks.\n    // But we cannot close unmatched blocks yet, because we may have a lazy\n    // continuation line.\n    if (continued < stack.length) {\n      const item = stack[continued]\n      self.containerState = item[1]\n      return effects.attempt(\n        item[0].continuation,\n        documentContinue,\n        checkNewContainers\n      )(code)\n    } // Done.\n\n    return checkNewContainers(code)\n  }\n  /** @type {State} */\n\n  function documentContinue(code) {\n    continued++ // Note: this field is called `_closeFlow` but it also closes containers.\n    // Perhaps a good idea to rename it but it’s already used in the wild by\n    // extensions.\n\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined\n\n      if (childFlow) {\n        closeFlow()\n      } // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {Point|undefined} */\n\n      let point // Find the flow chunk.\n\n      while (indexBeforeFlow--) {\n        if (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\n          point = self.events[indexBeforeFlow][1].end\n          break\n        }\n      }\n\n      exitContainers(continued) // Fix positions.\n\n      let index = indexBeforeExits\n\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      } // Inject the exits earlier (they’re still also at the end).\n\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      ) // Discard the duplicate exits.\n\n      self.events.length = index\n      return checkNewContainers(code)\n    }\n\n    return start(code)\n  }\n  /** @type {State} */\n\n  function checkNewContainers(code) {\n    // Next, after consuming the continuation markers for existing blocks, we\n    // look for new block starts (e.g. `>` for a block quote).\n    // If we encounter a new block start, we close any blocks unmatched in\n    // step 1 before creating the new block as a child of the last matched\n    // block.\n    if (continued === stack.length) {\n      // No need to `check` whether there’s a container, of `exitContainers`\n      // would be moot.\n      // We can instead immediately `attempt` to parse one.\n      if (!childFlow) {\n        return documentContinued(code)\n      } // If we have concrete content, such as block HTML or fenced code,\n      // we can’t have containers “pierce” into them, so we can immediately\n      // start.\n\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code)\n      } // If we do have flow, it could still be a blank line,\n      // but we’d be interrupting it w/ a new container if there’s a current\n      // construct.\n\n      self.interrupt = Boolean(\n        childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack\n      )\n    } // Check if there is a new container.\n\n    self.containerState = {}\n    return effects.check(\n      containerConstruct,\n      thereIsANewContainer,\n      thereIsNoNewContainer\n    )(code)\n  }\n  /** @type {State} */\n\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow()\n    exitContainers(continued)\n    return documentContinued(code)\n  }\n  /** @type {State} */\n\n  function thereIsNoNewContainer(code) {\n    self.parser.lazy[self.now().line] = continued !== stack.length\n    lineStartOffset = self.now().offset\n    return flowStart(code)\n  }\n  /** @type {State} */\n\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {}\n    return effects.attempt(\n      containerConstruct,\n      containerContinue,\n      flowStart\n    )(code)\n  }\n  /** @type {State} */\n\n  function containerContinue(code) {\n    continued++\n    stack.push([self.currentConstruct, self.containerState]) // Try another.\n\n    return documentContinued(code)\n  }\n  /** @type {State} */\n\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow()\n      exitContainers(0)\n      effects.consume(code)\n      return\n    }\n\n    childFlow = childFlow || self.parser.flow(self.now())\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    })\n    return flowContinue(code)\n  }\n  /** @type {State} */\n\n  function flowContinue(code) {\n    if (code === null) {\n      writeToChild(effects.exit('chunkFlow'), true)\n      exitContainers(0)\n      effects.consume(code)\n      return\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      writeToChild(effects.exit('chunkFlow')) // Get ready for the next line.\n\n      continued = 0\n      self.interrupt = undefined\n      return start\n    }\n\n    effects.consume(code)\n    return flowContinue\n  }\n  /**\n   * @param {Token} token\n   * @param {boolean} [eof]\n   * @returns {void}\n   */\n\n  function writeToChild(token, eof) {\n    const stream = self.sliceStream(token)\n    if (eof) stream.push(null)\n    token.previous = childToken\n    if (childToken) childToken.next = token\n    childToken = token\n    childFlow.defineSkip(token.start)\n    childFlow.write(stream) // Alright, so we just added a lazy line:\n    //\n    // ```markdown\n    // > a\n    // b.\n    //\n    // Or:\n    //\n    // > ~~~c\n    // d\n    //\n    // Or:\n    //\n    // > | e |\n    // f\n    // ```\n    //\n    // The construct in the second example (fenced code) does not accept lazy\n    // lines, so it marked itself as done at the end of its first line, and\n    // then the content construct parses `d`.\n    // Most constructs in markdown match on the first line: if the first line\n    // forms a construct, a non-lazy line can’t “unmake” it.\n    //\n    // The construct in the third example is potentially a GFM table, and\n    // those are *weird*.\n    // It *could* be a table, from the first line, if the following line\n    // matches a condition.\n    // In this case, that second line is lazy, which “unmakes” the first line\n    // and turns the whole into one content block.\n    //\n    // We’ve now parsed the non-lazy and the lazy line, and can figure out\n    // whether the lazy line started a new flow block.\n    // If it did, we exit the current containers between the two flow blocks.\n\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length\n\n      while (index--) {\n        if (\n          // The token starts before the line ending…\n          childFlow.events[index][1].start.offset < lineStartOffset && // …and either is not ended yet…\n          (!childFlow.events[index][1].end || // …or ends after it.\n            childFlow.events[index][1].end.offset > lineStartOffset)\n        ) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return\n        }\n      } // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {boolean|undefined} */\n\n      let seen\n      /** @type {Point|undefined} */\n\n      let point // Find the previous chunk (the one before the lazy line).\n\n      while (indexBeforeFlow--) {\n        if (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end\n            break\n          }\n\n          seen = true\n        }\n      }\n\n      exitContainers(continued) // Fix positions.\n\n      index = indexBeforeExits\n\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      } // Inject the exits earlier (they’re still also at the end).\n\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      ) // Discard the duplicate exits.\n\n      self.events.length = index\n    }\n  }\n  /**\n   * @param {number} size\n   * @returns {void}\n   */\n\n  function exitContainers(size) {\n    let index = stack.length // Exit open containers.\n\n    while (index-- > size) {\n      const entry = stack[index]\n      self.containerState = entry[1]\n      entry[0].exit.call(self, effects)\n    }\n\n    stack.length = size\n  }\n\n  function closeFlow() {\n    childFlow.write([null])\n    childToken = undefined\n    childFlow = undefined\n    self.containerState._closeFlow = undefined\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContainer(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(this.parser.constructs.document, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const blankLine = {\n  tokenize: tokenizeBlankLine,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix')\n  /** @type {State} */\n\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Event} Event\n */\nimport {splice} from 'micromark-util-chunked'\n\n/**\n * Tokenize subcontent.\n *\n * @param {Event[]} events\n * @returns {boolean}\n */\nexport function subtokenize(events) {\n  /** @type {Record<string, number>} */\n  const jumps = {}\n  let index = -1\n  /** @type {Event} */\n\n  let event\n  /** @type {number|undefined} */\n\n  let lineIndex\n  /** @type {number} */\n\n  let otherIndex\n  /** @type {Event} */\n\n  let otherEvent\n  /** @type {Event[]} */\n\n  let parameters\n  /** @type {Event[]} */\n\n  let subevents\n  /** @type {boolean|undefined} */\n\n  let more\n\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index]\n    }\n\n    event = events[index] // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n\n    if (\n      index &&\n      event[1].type === 'chunkFlow' &&\n      events[index - 1][1].type === 'listItemPrefix'\n    ) {\n      subevents = event[1]._tokenizer.events\n      otherIndex = 0\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'lineEndingBlank'\n      ) {\n        otherIndex += 2\n      }\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'content'\n      ) {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break\n          }\n\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true\n            otherIndex++\n          }\n        }\n      }\n    } // Enter.\n\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index))\n        index = jumps[index]\n        more = true\n      }\n    } // Exit.\n    else if (event[1]._container) {\n      otherIndex = index\n      lineIndex = undefined\n\n      while (otherIndex--) {\n        otherEvent = events[otherIndex]\n\n        if (\n          otherEvent[1].type === 'lineEnding' ||\n          otherEvent[1].type === 'lineEndingBlank'\n        ) {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank'\n            }\n\n            otherEvent[1].type = 'lineEnding'\n            lineIndex = otherIndex\n          }\n        } else {\n          break\n        }\n      }\n\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = Object.assign({}, events[lineIndex][1].start) // Switch container exit w/ line endings.\n\n        parameters = events.slice(lineIndex, index)\n        parameters.unshift(event)\n        splice(events, lineIndex, index - lineIndex + 1, parameters)\n      }\n    }\n  }\n\n  return !more\n}\n/**\n * Tokenize embedded tokens.\n *\n * @param {Event[]} events\n * @param {number} eventIndex\n * @returns {Record<string, number>}\n */\n\nfunction subcontent(events, eventIndex) {\n  const token = events[eventIndex][1]\n  const context = events[eventIndex][2]\n  let startPosition = eventIndex - 1\n  /** @type {number[]} */\n\n  const startPositions = []\n  const tokenizer =\n    token._tokenizer || context.parser[token.contentType](token.start)\n  const childEvents = tokenizer.events\n  /** @type {[number, number][]} */\n\n  const jumps = []\n  /** @type {Record<string, number>} */\n\n  const gaps = {}\n  /** @type {Chunk[]} */\n\n  let stream\n  /** @type {Token|undefined} */\n\n  let previous\n  let index = -1\n  /** @type {Token|undefined} */\n\n  let current = token\n  let adjust = 0\n  let start = 0\n  const breaks = [start] // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n\n  while (current) {\n    // Find the position of the event for this token.\n    while (events[++startPosition][1] !== current) {\n      // Empty.\n    }\n\n    startPositions.push(startPosition)\n\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current)\n\n      if (!current.next) {\n        stream.push(null)\n      }\n\n      if (previous) {\n        tokenizer.defineSkip(current.start)\n      }\n\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true\n      }\n\n      tokenizer.write(stream)\n\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined\n      }\n    } // Unravel the next token.\n\n    previous = current\n    current = current.next\n  } // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n\n  current = token\n\n  while (++index < childEvents.length) {\n    if (\n      // Find a void token that includes a break.\n      childEvents[index][0] === 'exit' &&\n      childEvents[index - 1][0] === 'enter' &&\n      childEvents[index][1].type === childEvents[index - 1][1].type &&\n      childEvents[index][1].start.line !== childEvents[index][1].end.line\n    ) {\n      start = index + 1\n      breaks.push(start) // Help GC.\n\n      current._tokenizer = undefined\n      current.previous = undefined\n      current = current.next\n    }\n  } // Help GC.\n\n  tokenizer.events = [] // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined\n    current.previous = undefined\n  } else {\n    breaks.pop()\n  } // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n\n  index = breaks.length\n\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1])\n    const start = startPositions.pop()\n    jumps.unshift([start, start + slice.length - 1])\n    splice(events, start, 2, slice)\n  }\n\n  index = -1\n\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]\n    adjust += jumps[index][1] - jumps[index][0] - 1\n  }\n\n  return gaps\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {subtokenize} from 'micromark-util-subtokenize'\n\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent\n}\n/** @type {Construct} */\n\nconst continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n}\n/**\n * Content is transparent: it’s parsed right now. That way, definitions are also\n * parsed right now: before text in paragraphs (specifically, media) are parsed.\n *\n * @type {Resolver}\n */\n\nfunction resolveContent(events) {\n  subtokenize(events)\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token} */\n  let previous\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('content')\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    })\n    return data(code)\n  }\n  /** @type {State} */\n\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.check(\n        continuationConstruct,\n        contentContinue,\n        contentEnd\n      )(code)\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n  /** @type {State} */\n\n  function contentEnd(code) {\n    effects.exit('chunkContent')\n    effects.exit('content')\n    return ok(code)\n  }\n  /** @type {State} */\n\n  function contentContinue(code) {\n    effects.consume(code)\n    effects.exit('chunkContent')\n    previous.next = effects.enter('chunkContent', {\n      contentType: 'content',\n      previous\n    })\n    previous = previous.next\n    return data\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this\n  return startLookahead\n  /** @type {State} */\n\n  function startLookahead(code) {\n    effects.exit('chunkContent')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, prefixed, 'linePrefix')\n  }\n  /** @type {State} */\n\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    const tail = self.events[self.events.length - 1]\n\n    if (\n      !self.parser.constructs.disable.null.includes('codeIndented') &&\n      tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n    ) {\n      return ok(code)\n    }\n\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {blankLine, content} from 'micromark-core-commonmark'\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n}\n/** @type {Initializer} */\n\nfunction initializeFlow(effects) {\n  const self = this\n  const initial = effects.attempt(\n    // Try to parse a blank line.\n    blankLine,\n    atBlankEnding, // Try to parse initial flow (essentially, only code).\n    effects.attempt(\n      this.parser.constructs.flowInitial,\n      afterConstruct,\n      factorySpace(\n        effects,\n        effects.attempt(\n          this.parser.constructs.flow,\n          afterConstruct,\n          effects.attempt(content, afterConstruct)\n        ),\n        'linePrefix'\n      )\n    )\n  )\n  return initial\n  /** @type {State} */\n\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    self.currentConstruct = undefined\n    return initial\n  }\n  /** @type {State} */\n\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    self.currentConstruct = undefined\n    return initial\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nexport const resolver = {\n  resolveAll: createResolver()\n}\nexport const string = initializeFactory('string')\nexport const text = initializeFactory('text')\n/**\n * @param {'string'|'text'} field\n * @returns {InitialConstruct}\n */\n\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(\n      field === 'text' ? resolveAllLineSuffixes : undefined\n    )\n  }\n  /** @type {Initializer} */\n\n  function initializeText(effects) {\n    const self = this\n    const constructs = this.parser.constructs[field]\n    const text = effects.attempt(constructs, start, notText)\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code)\n    }\n    /** @type {State} */\n\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code)\n        return\n      }\n\n      effects.enter('data')\n      effects.consume(code)\n      return data\n    }\n    /** @type {State} */\n\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data')\n        return text(code)\n      } // Data.\n\n      effects.consume(code)\n      return data\n    }\n    /**\n     * @param {Code} code\n     * @returns {boolean}\n     */\n\n    function atBreak(code) {\n      if (code === null) {\n        return true\n      }\n\n      const list = constructs[code]\n      let index = -1\n\n      if (list) {\n        while (++index < list.length) {\n          const item = list[index]\n\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true\n          }\n        }\n      }\n\n      return false\n    }\n  }\n}\n/**\n * @param {Resolver} [extraResolver]\n * @returns {Resolver}\n */\n\nfunction createResolver(extraResolver) {\n  return resolveAllText\n  /** @type {Resolver} */\n\n  function resolveAllText(events, context) {\n    let index = -1\n    /** @type {number|undefined} */\n\n    let enter // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === 'data') {\n          enter = index\n          index++\n        }\n      } else if (!events[index] || events[index][1].type !== 'data') {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end\n          events.splice(enter + 2, index - enter - 2)\n          index = enter + 2\n        }\n\n        enter = undefined\n      }\n    }\n\n    return extraResolver ? extraResolver(events, context) : events\n  }\n}\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\n\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0 // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if (\n      (eventIndex === events.length ||\n        events[eventIndex][1].type === 'lineEnding') &&\n      events[eventIndex - 1][1].type === 'data'\n    ) {\n      const data = events[eventIndex - 1][1]\n      const chunks = context.sliceStream(data)\n      let index = chunks.length\n      let bufferIndex = -1\n      let size = 0\n      /** @type {boolean|undefined} */\n\n      let tabs\n\n      while (index--) {\n        const chunk = chunks[index]\n\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length\n\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++\n            bufferIndex--\n          }\n\n          if (bufferIndex) break\n          bufferIndex = -1\n        } // Number\n        else if (chunk === -2) {\n          tabs = true\n          size++\n        } else if (chunk === -1) {\n          // Empty\n        } else {\n          // Replacement character, exit.\n          index++\n          break\n        }\n      }\n\n      if (size) {\n        const token = {\n          type:\n            eventIndex === events.length || tabs || size < 2\n              ? 'lineSuffix'\n              : 'hardBreakTrailing',\n          start: {\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size,\n            _index: data.start._index + index,\n            _bufferIndex: index\n              ? bufferIndex\n              : data.start._bufferIndex + bufferIndex\n          },\n          end: Object.assign({}, data.end)\n        }\n        data.end = Object.assign({}, token.start)\n\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token)\n        } else {\n          events.splice(\n            eventIndex,\n            0,\n            ['enter', token, context],\n            ['exit', token, context]\n          )\n          eventIndex += 2\n        }\n      }\n\n      eventIndex++\n    }\n  }\n\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {{resolveAll?: Resolver}[]} constructs\n * @param {Event[]} events\n * @param {TokenizeContext} context\n * @returns {Event[]}\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Resolver[]} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n */\n\n/**\n * @typedef Info\n * @property {() => void} restore\n * @property {number} from\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n * @param {Info} info\n * @returns {void}\n */\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n * @param {InitialConstruct} initialize\n * @param {Omit<Point, '_index'|'_bufferIndex'>} [from]\n * @returns {TokenizeContext}\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = Object.assign(\n    from\n      ? Object.assign({}, from)\n      : {\n          line: 1,\n          column: 1,\n          offset: 0\n        },\n    {\n      _index: 0,\n      _bufferIndex: -1\n    }\n  )\n  /** @type {Record<string, number>} */\n\n  const columnStart = {}\n  /** @type {Array<Construct>} */\n\n  const resolveAllConstructs = []\n  /** @type {Array<Chunk>} */\n\n  let chunks = []\n  /** @type {Array<Token>} */\n\n  let stack = []\n  /** @type {boolean|undefined} */\n\n  let consumed = true\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n\n  const effects = {\n    consume,\n    enter,\n    exit,\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  }\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n\n  const context = {\n    previous: null,\n    code: null,\n    containerState: {},\n    events: [],\n    parser,\n    sliceStream,\n    sliceSerialize,\n    now,\n    defineSkip,\n    write\n  }\n  /**\n   * The state function.\n   *\n   * @type {State|void}\n   */\n\n  let state = initialize.tokenize.call(context, effects)\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n\n  let expectedCode\n\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize)\n  }\n\n  return context\n  /** @type {TokenizeContext['write']} */\n\n  function write(slice) {\n    chunks = push(chunks, slice)\n    main() // Exit if we’re not done, resolve might change stuff.\n\n    if (chunks[chunks.length - 1] !== null) {\n      return []\n    }\n\n    addResult(initialize, 0) // Otherwise, resolve, and exit.\n\n    context.events = resolveAll(resolveAllConstructs, context.events, context)\n    return context.events\n  } //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs)\n  }\n  /** @type {TokenizeContext['sliceStream']} */\n\n  function sliceStream(token) {\n    return sliceChunks(chunks, token)\n  }\n  /** @type {TokenizeContext['now']} */\n\n  function now() {\n    return Object.assign({}, point)\n  }\n  /** @type {TokenizeContext['defineSkip']} */\n\n  function defineSkip(value) {\n    columnStart[value.line] = value.column\n    accountForPotentialSkip()\n  } //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {void}\n   */\n\n  function main() {\n    /** @type {number} */\n    let chunkIndex\n\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index] // If we’re in a buffer chunk, loop through it.\n\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index\n\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0\n        }\n\n        while (\n          point._index === chunkIndex &&\n          point._bufferIndex < chunk.length\n        ) {\n          go(chunk.charCodeAt(point._bufferIndex))\n        }\n      } else {\n        go(chunk)\n      }\n    }\n  }\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   * @returns {void}\n   */\n\n  function go(code) {\n    consumed = undefined\n    expectedCode = code\n    state = state(code)\n  }\n  /** @type {Effects['consume']} */\n\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++\n      point.column = 1\n      point.offset += code === -3 ? 2 : 1\n      accountForPotentialSkip()\n    } else if (code !== -1) {\n      point.column++\n      point.offset++\n    } // Not in a string chunk.\n\n    if (point._bufferIndex < 0) {\n      point._index++\n    } else {\n      point._bufferIndex++ // At end of string chunk.\n      // @ts-expect-error Points w/ non-negative `_bufferIndex` reference\n      // strings.\n\n      if (point._bufferIndex === chunks[point._index].length) {\n        point._bufferIndex = -1\n        point._index++\n      }\n    } // Expose the previous character.\n\n    context.previous = code // Mark as consumed.\n\n    consumed = true\n  }\n  /** @type {Effects['enter']} */\n\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {}\n    token.type = type\n    token.start = now()\n    context.events.push(['enter', token, context])\n    stack.push(token)\n    return token\n  }\n  /** @type {Effects['exit']} */\n\n  function exit(type) {\n    const token = stack.pop()\n    token.end = now()\n    context.events.push(['exit', token, context])\n    return token\n  }\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from)\n  }\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n\n  function onsuccessfulcheck(_, info) {\n    info.restore()\n  }\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   * @param {Record<string, unknown>} [fields]\n   */\n\n  function constructFactory(onreturn, fields) {\n    return hook\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Construct|Array<Construct>|ConstructRecord} constructs\n     * @param {State} returnState\n     * @param {State} [bogusState]\n     * @returns {State}\n     */\n\n    function hook(constructs, returnState, bogusState) {\n      /** @type {Array<Construct>} */\n      let listOfConstructs\n      /** @type {number} */\n\n      let constructIndex\n      /** @type {Construct} */\n\n      let currentConstruct\n      /** @type {Info} */\n\n      let info\n      return Array.isArray(constructs)\n        ? /* c8 ignore next 1 */\n          handleListOfConstructs(constructs)\n        : 'tokenize' in constructs // @ts-expect-error Looks like a construct.\n        ? handleListOfConstructs([constructs])\n        : handleMapOfConstructs(constructs)\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       * @returns {State}\n       */\n\n      function handleMapOfConstructs(map) {\n        return start\n        /** @type {State} */\n\n        function start(code) {\n          const def = code !== null && map[code]\n          const all = code !== null && map.null\n          const list = [\n            // To do: add more extension tests.\n\n            /* c8 ignore next 2 */\n            ...(Array.isArray(def) ? def : def ? [def] : []),\n            ...(Array.isArray(all) ? all : all ? [all] : [])\n          ]\n          return handleListOfConstructs(list)(code)\n        }\n      }\n      /**\n       * Handle a list of construct.\n       *\n       * @param {Array<Construct>} list\n       * @returns {State}\n       */\n\n      function handleListOfConstructs(list) {\n        listOfConstructs = list\n        constructIndex = 0\n\n        if (list.length === 0) {\n          return bogusState\n        }\n\n        return handleConstruct(list[constructIndex])\n      }\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       * @returns {State}\n       */\n\n      function handleConstruct(construct) {\n        return start\n        /** @type {State} */\n\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store()\n          currentConstruct = construct\n\n          if (!construct.partial) {\n            context.currentConstruct = construct\n          }\n\n          if (\n            construct.name &&\n            context.parser.constructs.disable.null.includes(construct.name)\n          ) {\n            return nok(code)\n          }\n\n          return construct.tokenize.call(\n            // If we do have fields, create an object w/ `context` as its\n            // prototype.\n            // This allows a “live binding”, which is needed for `interrupt`.\n            fields ? Object.assign(Object.create(context), fields) : context,\n            effects,\n            ok,\n            nok\n          )(code)\n        }\n      }\n      /** @type {State} */\n\n      function ok(code) {\n        consumed = true\n        onreturn(currentConstruct, info)\n        return returnState\n      }\n      /** @type {State} */\n\n      function nok(code) {\n        consumed = true\n        info.restore()\n\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex])\n        }\n\n        return bogusState\n      }\n    }\n  }\n  /**\n   * @param {Construct} construct\n   * @param {number} from\n   * @returns {void}\n   */\n\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct)\n    }\n\n    if (construct.resolve) {\n      splice(\n        context.events,\n        from,\n        context.events.length - from,\n        construct.resolve(context.events.slice(from), context)\n      )\n    }\n\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context)\n    }\n  }\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   */\n\n  function store() {\n    const startPoint = now()\n    const startPrevious = context.previous\n    const startCurrentConstruct = context.currentConstruct\n    const startEventsIndex = context.events.length\n    const startStack = Array.from(stack)\n    return {\n      restore,\n      from: startEventsIndex\n    }\n    /**\n     * Restore state.\n     *\n     * @returns {void}\n     */\n\n    function restore() {\n      point = startPoint\n      context.previous = startPrevious\n      context.currentConstruct = startCurrentConstruct\n      context.events.length = startEventsIndex\n      stack = startStack\n      accountForPotentialSkip()\n    }\n  }\n  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {void}\n   */\n\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line]\n      point.offset += columnStart[point.line] - 1\n    }\n  }\n}\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {Array<Chunk>} chunks\n * @param {Pick<Token, 'start'|'end'>} token\n * @returns {Array<Chunk>}\n */\n\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index\n  const startBufferIndex = token.start._bufferIndex\n  const endIndex = token.end._index\n  const endBufferIndex = token.end._bufferIndex\n  /** @type {Array<Chunk>} */\n\n  let view\n\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]\n  } else {\n    view = chunks.slice(startIndex, endIndex)\n\n    if (startBufferIndex > -1) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view[0] = view[0].slice(startBufferIndex)\n    }\n\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex))\n    }\n  }\n\n  return view\n}\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {Array<Chunk>} chunks\n * @param {boolean} [expandTabs=false]\n * @returns {string}\n */\n\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1\n  /** @type {Array<string>} */\n\n  const result = []\n  /** @type {boolean|undefined} */\n\n  let atTab\n\n  while (++index < chunks.length) {\n    const chunk = chunks[index]\n    /** @type {string} */\n\n    let value\n\n    if (typeof chunk === 'string') {\n      value = chunk\n    } else\n      switch (chunk) {\n        case -5: {\n          value = '\\r'\n          break\n        }\n\n        case -4: {\n          value = '\\n'\n          break\n        }\n\n        case -3: {\n          value = '\\r' + '\\n'\n          break\n        }\n\n        case -2: {\n          value = expandTabs ? ' ' : '\\t'\n          break\n        }\n\n        case -1: {\n          if (!expandTabs && atTab) continue\n          value = ' '\n          break\n        }\n\n        default: {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk)\n        }\n      }\n\n    atTab = chunk === -2\n    result.push(value)\n  }\n\n  return result.join('')\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('thematicBreak')\n    marker = code\n    return atBreak(code)\n  }\n  /** @type {State} */\n\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence')\n      return sequence(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code)\n    }\n\n    if (size < 3 || (code !== null && !markdownLineEnding(code))) {\n      return nok(code)\n    }\n\n    effects.exit('thematicBreak')\n    return ok(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      size++\n      return sequence\n    }\n\n    effects.exit('thematicBreakSequence')\n    return atBreak(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\n\n/**\n * @typedef {Record<string, unknown> & {marker: Code, type: string, size: number}} ListContainerState\n * @typedef {TokenizeContext & {containerState: ListContainerState}} TokenizeContextWithState\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {asciiDigit, markdownSpace} from 'micromark-util-character'\nimport {blankLine} from './blank-line.js'\nimport {thematicBreak} from './thematic-break.js'\n/** @type {Construct} */\n\nexport const list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n}\n/** @type {Construct} */\n\nconst listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n}\n/** @type {Construct} */\n\nconst indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this\n  const tail = self.events[self.events.length - 1]\n  let initialSize =\n    tail && tail[1].type === 'linePrefix'\n      ? tail[2].sliceSerialize(tail[1], true).length\n      : 0\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    const kind =\n      self.containerState.type ||\n      (code === 42 || code === 43 || code === 45\n        ? 'listUnordered'\n        : 'listOrdered')\n\n    if (\n      kind === 'listUnordered'\n        ? !self.containerState.marker || code === self.containerState.marker\n        : asciiDigit(code)\n    ) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind\n        effects.enter(kind, {\n          _container: true\n        })\n      }\n\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix')\n        return code === 42 || code === 45\n          ? effects.check(thematicBreak, nok, atMarker)(code)\n          : atMarker(code)\n      }\n\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix')\n        effects.enter('listItemValue')\n        return inside(code)\n      }\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code)\n      return inside\n    }\n\n    if (\n      (!self.interrupt || size < 2) &&\n      (self.containerState.marker\n        ? code === self.containerState.marker\n        : code === 41 || code === 46)\n    ) {\n      effects.exit('listItemValue')\n      return atMarker(code)\n    }\n\n    return nok(code)\n  }\n  /**\n   * @type {State}\n   **/\n\n  function atMarker(code) {\n    effects.enter('listItemMarker')\n    effects.consume(code)\n    effects.exit('listItemMarker')\n    self.containerState.marker = self.containerState.marker || code\n    return effects.check(\n      blankLine, // Can’t be empty when interrupting.\n      self.interrupt ? nok : onBlank,\n      effects.attempt(\n        listItemPrefixWhitespaceConstruct,\n        endOfPrefix,\n        otherPrefix\n      )\n    )\n  }\n  /** @type {State} */\n\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true\n    initialSize++\n    return endOfPrefix(code)\n  }\n  /** @type {State} */\n\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter('listItemPrefixWhitespace')\n      effects.consume(code)\n      effects.exit('listItemPrefixWhitespace')\n      return endOfPrefix\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function endOfPrefix(code) {\n    self.containerState.size =\n      initialSize +\n      self.sliceSerialize(effects.exit('listItemPrefix'), true).length\n    return ok(code)\n  }\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this\n  self.containerState._closeFlow = undefined\n  return effects.check(blankLine, onBlank, notBlank)\n  /** @type {State} */\n\n  function onBlank(code) {\n    self.containerState.furtherBlankLines =\n      self.containerState.furtherBlankLines ||\n      self.containerState.initialBlankLine // We have a blank line.\n    // Still, try to consume at most the items size.\n\n    return factorySpace(\n      effects,\n      ok,\n      'listItemIndent',\n      self.containerState.size + 1\n    )(code)\n  }\n  /** @type {State} */\n\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = undefined\n      self.containerState.initialBlankLine = undefined\n      return notInCurrentItem(code)\n    }\n\n    self.containerState.furtherBlankLines = undefined\n    self.containerState.initialBlankLine = undefined\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)\n  }\n  /** @type {State} */\n\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true // As we’re closing flow, we’re no longer interrupting.\n\n    self.interrupt = undefined\n    return factorySpace(\n      effects,\n      effects.attempt(list, ok, nok),\n      'linePrefix',\n      self.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )(code)\n  }\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemIndent',\n    self.containerState.size + 1\n  )\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'listItemIndent' &&\n      tail[2].sliceSerialize(tail[1], true).length === self.containerState.size\n      ? ok(code)\n      : nok(code)\n  }\n}\n/**\n * @type {Exiter}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type)\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemPrefixWhitespace',\n    self.parser.constructs.disable.null.includes('codeIndented')\n      ? undefined\n      : 4 + 1\n  )\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return !markdownSpace(code) &&\n      tail &&\n      tail[1].type === 'listItemPrefixWhitespace'\n      ? ok(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownSpace} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState\n\n      if (!state.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        })\n        state.open = true\n      }\n\n      effects.enter('blockQuotePrefix')\n      effects.enter('blockQuoteMarker')\n      effects.consume(code)\n      effects.exit('blockQuoteMarker')\n      return after\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter('blockQuotePrefixWhitespace')\n      effects.consume(code)\n      effects.exit('blockQuotePrefixWhitespace')\n      effects.exit('blockQuotePrefix')\n      return ok\n    }\n\n    effects.exit('blockQuotePrefix')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(blockQuote, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n  )\n}\n/** @type {Exiter} */\n\nfunction exit(effects) {\n  effects.exit('blockQuote')\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {\n  asciiControl,\n  markdownLineEndingOrSpace,\n  markdownLineEnding\n} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} literalType\n * @param {string} literalMarkerType\n * @param {string} rawType\n * @param {string} stringType\n * @param {number} [max=Infinity]\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryDestination(\n  effects,\n  ok,\n  nok,\n  type,\n  literalType,\n  literalMarkerType,\n  rawType,\n  stringType,\n  max\n) {\n  const limit = max || Number.POSITIVE_INFINITY\n  let balance = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type)\n      effects.enter(literalType)\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      return destinationEnclosedBefore\n    }\n\n    if (code === null || code === 41 || asciiControl(code)) {\n      return nok(code)\n    }\n\n    effects.enter(type)\n    effects.enter(rawType)\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationRaw(code)\n  }\n  /** @type {State} */\n\n  function destinationEnclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      effects.exit(literalType)\n      effects.exit(type)\n      return ok\n    }\n\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationEnclosed(code)\n  }\n  /** @type {State} */\n\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      return destinationEnclosedBefore(code)\n    }\n\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed\n  }\n  /** @type {State} */\n\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code)\n      return destinationEnclosed\n    }\n\n    return destinationEnclosed(code)\n  }\n  /** @type {State} */\n\n  function destinationRaw(code) {\n    if (code === 40) {\n      if (++balance > limit) return nok(code)\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === 41) {\n      if (!balance--) {\n        effects.exit('chunkString')\n        effects.exit(stringType)\n        effects.exit(rawType)\n        effects.exit(type)\n        return ok(code)\n      }\n\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      if (balance) return nok(code)\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      effects.exit(rawType)\n      effects.exit(type)\n      return ok(code)\n    }\n\n    if (asciiControl(code)) return nok(code)\n    effects.consume(code)\n    return code === 92 ? destinationRawEscape : destinationRaw\n  }\n  /** @type {State} */\n\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    return destinationRaw(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/**\n * @this {TokenizeContext}\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} markerType\n * @param {string} stringType\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this\n  let size = 0\n  /** @type {boolean} */\n\n  let data\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    effects.enter(stringType)\n    return atBreak\n  }\n  /** @type {State} */\n\n  function atBreak(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      (code === 93 && !data) ||\n      /* To do: remove in the future once we’ve switched from\n       * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n       * which doesn’t need this */\n\n      /* Hidden footnotes hook */\n\n      /* c8 ignore next 3 */\n      (code === 94 &&\n        !size &&\n        '_hiddenFootnoteSupport' in self.parser.constructs) ||\n      size > 999\n    ) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.exit(stringType)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return atBreak\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return label(code)\n  }\n  /** @type {State} */\n\n  function label(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      code === 93 ||\n      markdownLineEnding(code) ||\n      size++ > 999\n    ) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n\n    effects.consume(code)\n    data = data || !markdownSpace(code)\n    return code === 92 ? labelEscape : label\n  }\n  /** @type {State} */\n\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return label\n    }\n\n    return label(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} markerType\n * @param {string} stringType\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    marker = code === 40 ? 41 : code\n    return atFirstTitleBreak\n  }\n  /** @type {State} */\n\n  function atFirstTitleBreak(code) {\n    if (code === marker) {\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    effects.enter(stringType)\n    return atTitleBreak(code)\n  }\n  /** @type {State} */\n\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType)\n      return atFirstTitleBreak(marker)\n    }\n\n    if (code === null) {\n      return nok(code)\n    } // Note: blank lines can’t exist in content.\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, atTitleBreak, 'linePrefix')\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return title(code)\n  }\n  /** @type {State} */\n\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      return atTitleBreak(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? titleEscape : title\n  }\n  /** @type {State} */\n\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code)\n      return title\n    }\n\n    return title(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      seen = true\n      return start\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        start,\n        seen ? 'linePrefix' : 'lineSuffix'\n      )(code)\n    }\n\n    return ok(code)\n  }\n}\n","/**\n * Normalize an identifier (such as used in definitions).\n *\n * @param {string} value\n * @returns {string}\n */\nexport function normalizeIdentifier(value) {\n  return (\n    value // Collapse Markdown whitespace.\n      .replace(/[\\t\\n\\r ]+/g, ' ') // Trim.\n      .replace(/^ | $/g, '') // Some characters are considered “uppercase”, but if their lowercase\n      // counterpart is uppercased will result in a different uppercase\n      // character.\n      // Hence, to get that form, we perform both lower- and uppercase.\n      // Upper case makes sure keys will not interact with default prototypal\n      // methods: no method is uppercase.\n      .toLowerCase()\n      .toUpperCase()\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factoryDestination} from 'micromark-factory-destination'\nimport {factoryLabel} from 'micromark-factory-label'\nimport {factorySpace} from 'micromark-factory-space'\nimport {factoryTitle} from 'micromark-factory-title'\nimport {factoryWhitespace} from 'micromark-factory-whitespace'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n}\n/** @type {Construct} */\n\nconst titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this\n  /** @type {string} */\n\n  let identifier\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('definition')\n    return factoryLabel.call(\n      self,\n      effects,\n      labelAfter,\n      nok,\n      'definitionLabel',\n      'definitionLabelMarker',\n      'definitionLabelString'\n    )(code)\n  }\n  /** @type {State} */\n\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(\n      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n    )\n\n    if (code === 58) {\n      effects.enter('definitionMarker')\n      effects.consume(code)\n      effects.exit('definitionMarker') // Note: blank lines can’t exist in content.\n\n      return factoryWhitespace(\n        effects,\n        factoryDestination(\n          effects,\n          effects.attempt(\n            titleConstruct,\n            factorySpace(effects, after, 'whitespace'),\n            factorySpace(effects, after, 'whitespace')\n          ),\n          nok,\n          'definitionDestination',\n          'definitionDestinationLiteral',\n          'definitionDestinationLiteralMarker',\n          'definitionDestinationRaw',\n          'definitionDestinationString'\n        )\n      )\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition')\n\n      if (!self.parser.defined.includes(identifier)) {\n        self.parser.defined.push(identifier)\n      }\n\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeTitle(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, before)(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function before(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factorySpace(effects, after, 'whitespace'),\n        nok,\n        'definitionTitle',\n        'definitionTitleMarker',\n        'definitionTitleString'\n      )(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n}\n/** @type {Construct} */\n\nconst indentedContent = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeIndented')\n    return factorySpace(effects, afterStartPrefix, 'linePrefix', 4 + 1)(code)\n  }\n  /** @type {State} */\n\n  function afterStartPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? afterPrefix(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    if (code === null) {\n      return after(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContent, afterPrefix, after)(code)\n    }\n\n    effects.enter('codeFlowValue')\n    return content(code)\n  }\n  /** @type {State} */\n\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return afterPrefix(code)\n    }\n\n    effects.consume(code)\n    return content\n  }\n  /** @type {State} */\n\n  function after(code) {\n    effects.exit('codeIndented')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    // If this is a lazy line, it can’t be code.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return start\n    }\n\n    return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? ok(code)\n      : markdownLineEnding(code)\n      ? start(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n}\n/** @type {Resolver} */\n\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2\n  let contentStart = 3\n  /** @type {Token} */\n\n  let content\n  /** @type {Token} */\n\n  let text // Prefix whitespace, part of the opening.\n\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2\n  } // Suffix whitespace, part of the closing.\n\n  if (\n    contentEnd - 2 > contentStart &&\n    events[contentEnd][1].type === 'whitespace'\n  ) {\n    contentEnd -= 2\n  }\n\n  if (\n    events[contentEnd][1].type === 'atxHeadingSequence' &&\n    (contentStart === contentEnd - 1 ||\n      (contentEnd - 4 > contentStart &&\n        events[contentEnd - 2][1].type === 'whitespace'))\n  ) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4\n  }\n\n  if (contentEnd > contentStart) {\n    content = {\n      type: 'atxHeadingText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    }\n    text = {\n      type: 'chunkText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      // @ts-expect-error Constants are fine to assign.\n      contentType: 'text'\n    }\n    splice(events, contentStart, contentEnd - contentStart + 1, [\n      ['enter', content, context],\n      ['enter', text, context],\n      ['exit', text, context],\n      ['exit', content, context]\n    ])\n  }\n\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  const self = this\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('atxHeading')\n    effects.enter('atxHeadingSequence')\n    return fenceOpenInside(code)\n  }\n  /** @type {State} */\n\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code)\n      return fenceOpenInside\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence')\n      return self.interrupt ? ok(code) : headingBreak(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence')\n      return sequence(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading')\n      return ok(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code)\n    }\n\n    effects.enter('atxHeadingText')\n    return data(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code)\n      return sequence\n    }\n\n    effects.exit('atxHeadingSequence')\n    return headingBreak(code)\n  }\n  /** @type {State} */\n\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText')\n      return headingBreak(code)\n    }\n\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n}\n/** @type {Resolver} */\n\nfunction resolveToSetextUnderline(events, context) {\n  let index = events.length\n  /** @type {number|undefined} */\n\n  let content\n  /** @type {number|undefined} */\n\n  let text\n  /** @type {number|undefined} */\n\n  let definition // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index\n        break\n      }\n\n      if (events[index][1].type === 'paragraph') {\n        text = index\n      }\n    } // Exit\n    else {\n      if (events[index][1].type === 'content') {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1)\n      }\n\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index\n      }\n    }\n  }\n\n  const heading = {\n    type: 'setextHeading',\n    start: Object.assign({}, events[text][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  } // Change the paragraph to setext heading text.\n\n  events[text][1].type = 'setextHeadingText' // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context])\n    events.splice(definition + 1, 0, ['exit', events[content][1], context])\n    events[content][1].end = Object.assign({}, events[definition][1].end)\n  } else {\n    events[content][1] = heading\n  } // Add the heading exit at the end.\n\n  events.push(['exit', heading, context])\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  /** @type {boolean} */\n\n  let paragraph // Find an opening.\n\n  while (index--) {\n    // Skip enter/exit of line ending, line prefix, and content.\n    // We can now either have a definition or a paragraph.\n    if (\n      self.events[index][1].type !== 'lineEnding' &&\n      self.events[index][1].type !== 'linePrefix' &&\n      self.events[index][1].type !== 'content'\n    ) {\n      paragraph = self.events[index][1].type === 'paragraph'\n      break\n    }\n  }\n\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine')\n      effects.enter('setextHeadingLineSequence')\n      marker = code\n      return closingSequence(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return closingSequence\n    }\n\n    effects.exit('setextHeadingLineSequence')\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code)\n  }\n  /** @type {State} */\n\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * List of lowercase HTML tag names which when parsing HTML (flow), result\n * in more relaxed rules (condition 6): because they are known blocks, the\n * HTML-like syntax doesn’t have to be strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n */\nexport const htmlBlockNames = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\n/**\n * List of lowercase HTML tag names which when parsing HTML (flow), result in\n * HTML that can include lines w/o exiting, until a closing tag also in this\n * list is found (condition 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * Note that `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {htmlBlockNames, htmlRawNames} from 'micromark-util-html-tag-name'\nimport {blankLine} from './blank-line.js'\n/** @type {Construct} */\n\nexport const htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n}\n/** @type {Construct} */\n\nconst nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n}\n/** @type {Resolver} */\n\nfunction resolveToHtmlFlow(events) {\n  let index = events.length\n\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break\n    }\n  }\n\n  if (index > 1 && events[index - 2][1].type === 'linePrefix') {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start // Add the prefix start to the HTML line token.\n\n    events[index + 1][1].start = events[index - 2][1].start // Remove the line prefix.\n\n    events.splice(index - 2, 2)\n  }\n\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this\n  /** @type {number} */\n\n  let kind\n  /** @type {boolean} */\n\n  let startTag\n  /** @type {string} */\n\n  let buffer\n  /** @type {number} */\n\n  let index\n  /** @type {Code} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('htmlFlow')\n    effects.enter('htmlFlowData')\n    effects.consume(code)\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationStart\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      kind = 3 // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = String.fromCharCode(code)\n      startTag = true\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code)\n      kind = 2\n      return commentOpenInside\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      kind = 5\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpenInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      kind = 4\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function cdataOpenInside(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length\n        ? self.interrupt\n          ? ok\n          : continuation\n        : cdataOpenInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = String.fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagName(code) {\n    if (\n      code === null ||\n      code === 47 ||\n      code === 62 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      if (\n        code !== 47 &&\n        startTag &&\n        htmlRawNames.includes(buffer.toLowerCase())\n      ) {\n        kind = 1\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        kind = 6\n\n        if (code === 47) {\n          effects.consume(code)\n          return basicSelfClosing\n        }\n\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      kind = 7 // Do not support complete HTML when interrupting\n\n      return self.interrupt && !self.parser.lazy[self.now().line]\n        ? nok(code)\n        : startTag\n        ? completeAttributeNameBefore(code)\n        : completeClosingTagAfter(code)\n    }\n\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      buffer += String.fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuation\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeClosingTagAfter\n    }\n\n    return completeEnd(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return completeEnd\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameBefore\n    }\n\n    return completeEnd(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    return completeAttributeNameAfter(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameAfter\n    }\n\n    return completeAttributeNameBefore(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return completeAttributeValueQuoted\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    marker = null\n    return completeAttributeValueUnquoted(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeValueQuoted(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    if (code === marker) {\n      effects.consume(code)\n      return completeAttributeValueQuotedAfter\n    }\n\n    effects.consume(code)\n    return completeAttributeValueQuoted\n  }\n  /** @type {State} */\n\n  function completeAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      return completeAttributeNameAfter(code)\n    }\n\n    effects.consume(code)\n    return completeAttributeValueUnquoted\n  }\n  /** @type {State} */\n\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return code === null || markdownLineEnding(code)\n      ? continuation(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code)\n      return continuationCommentInside\n    }\n\n    if (code === 60 && kind === 1) {\n      effects.consume(code)\n      return continuationRawTagOpen\n    }\n\n    if (code === 62 && kind === 4) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (code === 63 && kind === 3) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    if (code === 93 && kind === 5) {\n      effects.consume(code)\n      return continuationCharacterDataInside\n    }\n\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(\n        nextBlankConstruct,\n        continuationClose,\n        continuationAtLineEnding\n      )(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code)\n    }\n\n    effects.consume(code)\n    return continuation\n  }\n  /** @type {State} */\n\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData')\n    return htmlContinueStart(code)\n  }\n  /** @type {State} */\n\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(\n        {\n          tokenize: htmlLineEnd,\n          partial: true\n        },\n        htmlContinueStart,\n        done\n      )(code)\n    }\n\n    effects.enter('htmlFlowData')\n    return continuation(code)\n  }\n  /** @type {Tokenizer} */\n\n  function htmlLineEnd(effects, ok, nok) {\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return lineStart\n    }\n    /** @type {State} */\n\n    function lineStart(code) {\n      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n    }\n  }\n  /** @type {State} */\n\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code)\n      buffer = ''\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.includes(buffer.toLowerCase())) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code)\n      buffer += String.fromCharCode(code)\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return continuationClose\n    } // More dashes.\n\n    if (code === 45 && kind === 2) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData')\n      return done(code)\n    }\n\n    effects.consume(code)\n    return continuationClose\n  }\n  /** @type {State} */\n\n  function done(code) {\n    effects.exit('htmlFlow')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.exit('htmlFlowData')\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    return effects.attempt(blankLine, ok, nok)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this\n  /** @type {Construct} */\n\n  const closingFenceConstruct = {\n    tokenize: tokenizeClosingFence,\n    partial: true\n  }\n  /** @type {Construct} */\n\n  const nonLazyLine = {\n    tokenize: tokenizeNonLazyLine,\n    partial: true\n  }\n  const tail = this.events[this.events.length - 1]\n  const initialPrefix =\n    tail && tail[1].type === 'linePrefix'\n      ? tail[2].sliceSerialize(tail[1], true).length\n      : 0\n  let sizeOpen = 0\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeFenced')\n    effects.enter('codeFencedFence')\n    effects.enter('codeFencedFenceSequence')\n    marker = code\n    return sequenceOpen(code)\n  }\n  /** @type {State} */\n\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code)\n      sizeOpen++\n      return sequenceOpen\n    }\n\n    effects.exit('codeFencedFenceSequence')\n    return sizeOpen < 3\n      ? nok(code)\n      : factorySpace(effects, infoOpen, 'whitespace')(code)\n  }\n  /** @type {State} */\n\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceInfo')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return info(code)\n  }\n  /** @type {State} */\n\n  function info(code) {\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceInfo')\n      return factorySpace(effects, infoAfter, 'whitespace')(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return info\n  }\n  /** @type {State} */\n\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceMeta')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return meta(code)\n  }\n  /** @type {State} */\n\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceMeta')\n      return openAfter(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return meta\n  }\n  /** @type {State} */\n\n  function openAfter(code) {\n    effects.exit('codeFencedFence')\n    return self.interrupt ? ok(code) : contentStart(code)\n  }\n  /** @type {State} */\n\n  function contentStart(code) {\n    if (code === null) {\n      return after(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(\n        nonLazyLine,\n        effects.attempt(\n          closingFenceConstruct,\n          after,\n          initialPrefix\n            ? factorySpace(\n                effects,\n                contentStart,\n                'linePrefix',\n                initialPrefix + 1\n              )\n            : contentStart\n        ),\n        after\n      )(code)\n    }\n\n    effects.enter('codeFlowValue')\n    return contentContinue(code)\n  }\n  /** @type {State} */\n\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return contentStart(code)\n    }\n\n    effects.consume(code)\n    return contentContinue\n  }\n  /** @type {State} */\n\n  function after(code) {\n    effects.exit('codeFenced')\n    return ok(code)\n  }\n  /** @type {Tokenizer} */\n\n  function tokenizeNonLazyLine(effects, ok, nok) {\n    const self = this\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return lineStart\n    }\n    /** @type {State} */\n\n    function lineStart(code) {\n      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n    }\n  }\n  /** @type {Tokenizer} */\n\n  function tokenizeClosingFence(effects, ok, nok) {\n    let size = 0\n    return factorySpace(\n      effects,\n      closingSequenceStart,\n      'linePrefix',\n      this.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )\n    /** @type {State} */\n\n    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence')\n      effects.enter('codeFencedFenceSequence')\n      return closingSequence(code)\n    }\n    /** @type {State} */\n\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code)\n        size++\n        return closingSequence\n      }\n\n      if (size < sizeOpen) return nok(code)\n      effects.exit('codeFencedFenceSequence')\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code)\n    }\n    /** @type {State} */\n\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence')\n        return ok(code)\n      }\n\n      return nok(code)\n    }\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {\n  asciiAlphanumeric,\n  asciiDigit,\n  asciiHexDigit\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this\n  let size = 0\n  /** @type {number} */\n\n  let max\n  /** @type {(code: Code) => code is number} */\n\n  let test\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('characterReference')\n    effects.enter('characterReferenceMarker')\n    effects.consume(code)\n    effects.exit('characterReferenceMarker')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerNumeric')\n      return numeric\n    }\n\n    effects.enter('characterReferenceValue')\n    max = 31\n    test = asciiAlphanumeric\n    return value(code)\n  }\n  /** @type {State} */\n\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter('characterReferenceMarkerHexadecimal')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerHexadecimal')\n      effects.enter('characterReferenceValue')\n      max = 6\n      test = asciiHexDigit\n      return value\n    }\n\n    effects.enter('characterReferenceValue')\n    max = 7\n    test = asciiDigit\n    return value(code)\n  }\n  /** @type {State} */\n\n  function value(code) {\n    /** @type {Token} */\n    let token\n\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue')\n\n      if (\n        test === asciiAlphanumeric &&\n        !decodeNamedCharacterReference(self.sliceSerialize(token))\n      ) {\n        return nok(code)\n      }\n\n      effects.enter('characterReferenceMarker')\n      effects.consume(code)\n      effects.exit('characterReferenceMarker')\n      effects.exit('characterReference')\n      return ok\n    }\n\n    if (test(code) && size++ < max) {\n      effects.consume(code)\n      return value\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {asciiPunctuation} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('characterEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    effects.exit('escapeMarker')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (asciiPunctuation(code)) {\n      effects.enter('characterEscapeValue')\n      effects.consume(code)\n      effects.exit('characterEscapeValue')\n      effects.exit('characterEscape')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLineEnding(effects, ok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, ok, 'linePrefix')\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factoryDestination} from 'micromark-factory-destination'\nimport {factoryLabel} from 'micromark-factory-label'\nimport {factoryTitle} from 'micromark-factory-title'\nimport {factoryWhitespace} from 'micromark-factory-whitespace'\nimport {markdownLineEndingOrSpace} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n}\n/** @type {Construct} */\n\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n}\n/** @type {Construct} */\n\nconst fullReferenceConstruct = {\n  tokenize: tokenizeFullReference\n}\n/** @type {Construct} */\n\nconst collapsedReferenceConstruct = {\n  tokenize: tokenizeCollapsedReference\n}\n/** @type {Resolver} */\n\nfunction resolveAllLabelEnd(events) {\n  let index = -1\n  /** @type {Token} */\n\n  let token\n\n  while (++index < events.length) {\n    token = events[index][1]\n\n    if (\n      token.type === 'labelImage' ||\n      token.type === 'labelLink' ||\n      token.type === 'labelEnd'\n    ) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2)\n      token.type = 'data'\n      index++\n    }\n  }\n\n  return events\n}\n/** @type {Resolver} */\n\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length\n  let offset = 0\n  /** @type {Token} */\n\n  let token\n  /** @type {number|undefined} */\n\n  let open\n  /** @type {number|undefined} */\n\n  let close\n  /** @type {Event[]} */\n\n  let media // Find an opening.\n\n  while (index--) {\n    token = events[index][1]\n\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (\n        token.type === 'link' ||\n        (token.type === 'labelLink' && token._inactive)\n      ) {\n        break\n      } // Mark other link openings as inactive, as we can’t have links in\n      // links.\n\n      if (events[index][0] === 'enter' && token.type === 'labelLink') {\n        token._inactive = true\n      }\n    } else if (close) {\n      if (\n        events[index][0] === 'enter' &&\n        (token.type === 'labelImage' || token.type === 'labelLink') &&\n        !token._balanced\n      ) {\n        open = index\n\n        if (token.type !== 'labelLink') {\n          offset = 2\n          break\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index\n    }\n  }\n\n  const group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }\n  const label = {\n    type: 'label',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[close][1].end)\n  }\n  const text = {\n    type: 'labelText',\n    start: Object.assign({}, events[open + offset + 2][1].end),\n    end: Object.assign({}, events[close - 2][1].start)\n  }\n  media = [\n    ['enter', group, context],\n    ['enter', label, context]\n  ] // Opening marker.\n\n  media = push(media, events.slice(open + 1, open + offset + 3)) // Text open.\n\n  media = push(media, [['enter', text, context]]) // Between.\n\n  media = push(\n    media,\n    resolveAll(\n      context.parser.constructs.insideSpan.null,\n      events.slice(open + offset + 4, close - 3),\n      context\n    )\n  ) // Text close, marker close, label close.\n\n  media = push(media, [\n    ['exit', text, context],\n    events[close - 2],\n    events[close - 1],\n    ['exit', label, context]\n  ]) // Reference, resource, or so.\n\n  media = push(media, events.slice(close + 1)) // Media close.\n\n  media = push(media, [['exit', group, context]])\n  splice(events, open, events.length, media)\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {Token} */\n\n  let labelStart\n  /** @type {boolean} */\n\n  let defined // Find an opening.\n\n  while (index--) {\n    if (\n      (self.events[index][1].type === 'labelImage' ||\n        self.events[index][1].type === 'labelLink') &&\n      !self.events[index][1]._balanced\n    ) {\n      labelStart = self.events[index][1]\n      break\n    }\n  }\n\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (!labelStart) {\n      return nok(code)\n    } // It’s a balanced bracket, but contains a link.\n\n    if (labelStart._inactive) return balanced(code)\n    defined = self.parser.defined.includes(\n      normalizeIdentifier(\n        self.sliceSerialize({\n          start: labelStart.end,\n          end: self.now()\n        })\n      )\n    )\n    effects.enter('labelEnd')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelEnd')\n    return afterLabelEnd\n  }\n  /** @type {State} */\n\n  function afterLabelEnd(code) {\n    // Resource: `[asd](fgh)`.\n    if (code === 40) {\n      return effects.attempt(\n        resourceConstruct,\n        ok,\n        defined ? ok : balanced\n      )(code)\n    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?\n\n    if (code === 91) {\n      return effects.attempt(\n        fullReferenceConstruct,\n        ok,\n        defined\n          ? effects.attempt(collapsedReferenceConstruct, ok, balanced)\n          : balanced\n      )(code)\n    } // Shortcut reference: `[asd]`?\n\n    return defined ? ok(code) : balanced(code)\n  }\n  /** @type {State} */\n\n  function balanced(code) {\n    labelStart._balanced = true\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeResource(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('resource')\n    effects.enter('resourceMarker')\n    effects.consume(code)\n    effects.exit('resourceMarker')\n    return factoryWhitespace(effects, open)\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 41) {\n      return end(code)\n    }\n\n    return factoryDestination(\n      effects,\n      destinationAfter,\n      nok,\n      'resourceDestination',\n      'resourceDestinationLiteral',\n      'resourceDestinationLiteralMarker',\n      'resourceDestinationRaw',\n      'resourceDestinationString',\n      32\n    )(code)\n  }\n  /** @type {State} */\n\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, between)(code)\n      : end(code)\n  }\n  /** @type {State} */\n\n  function between(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factoryWhitespace(effects, end),\n        nok,\n        'resourceTitle',\n        'resourceTitleMarker',\n        'resourceTitleString'\n      )(code)\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function end(code) {\n    if (code === 41) {\n      effects.enter('resourceMarker')\n      effects.consume(code)\n      effects.exit('resourceMarker')\n      effects.exit('resource')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeFullReference(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    return factoryLabel.call(\n      self,\n      effects,\n      afterLabel,\n      nok,\n      'reference',\n      'referenceMarker',\n      'referenceString'\n    )(code)\n  }\n  /** @type {State} */\n\n  function afterLabel(code) {\n    return self.parser.defined.includes(\n      normalizeIdentifier(\n        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n      )\n    )\n      ? ok(code)\n      : nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('reference')\n    effects.enter('referenceMarker')\n    effects.consume(code)\n    effects.exit('referenceMarker')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 93) {\n      effects.enter('referenceMarker')\n      effects.consume(code)\n      effects.exit('referenceMarker')\n      effects.exit('reference')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {\n  markdownLineEndingOrSpace,\n  unicodePunctuation,\n  unicodeWhitespace\n} from 'micromark-util-character'\n\n/**\n * Classify whether a character code represents whitespace, punctuation, or\n * something else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * Note that eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n * @returns {number|undefined}\n */\nexport function classifyCharacter(code) {\n  if (\n    code === null ||\n    markdownLineEndingOrSpace(code) ||\n    unicodeWhitespace(code)\n  ) {\n    return 1\n  }\n\n  if (unicodePunctuation(code)) {\n    return 2\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Point} Point\n */\nimport {push, splice} from 'micromark-util-chunked'\nimport {classifyCharacter} from 'micromark-util-classify-character'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n}\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n\nfunction resolveAllAttention(events, context) {\n  let index = -1\n  /** @type {number} */\n\n  let open\n  /** @type {Token} */\n\n  let group\n  /** @type {Token} */\n\n  let text\n  /** @type {Token} */\n\n  let openingSequence\n  /** @type {Token} */\n\n  let closingSequence\n  /** @type {number} */\n\n  let use\n  /** @type {Event[]} */\n\n  let nextEvents\n  /** @type {number} */\n\n  let offset // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (\n      events[index][0] === 'enter' &&\n      events[index][1].type === 'attentionSequence' &&\n      events[index][1]._close\n    ) {\n      open = index // Now walk back to find an opener.\n\n      while (open--) {\n        // Find a token that can open the closer.\n        if (\n          events[open][0] === 'exit' &&\n          events[open][1].type === 'attentionSequence' &&\n          events[open][1]._open && // If the markers are the same:\n          context.sliceSerialize(events[open][1]).charCodeAt(0) ===\n            context.sliceSerialize(events[index][1]).charCodeAt(0)\n        ) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if (\n            (events[open][1]._close || events[index][1]._open) &&\n            (events[index][1].end.offset - events[index][1].start.offset) % 3 &&\n            !(\n              (events[open][1].end.offset -\n                events[open][1].start.offset +\n                events[index][1].end.offset -\n                events[index][1].start.offset) %\n              3\n            )\n          ) {\n            continue\n          } // Number of markers to use from the sequence.\n\n          use =\n            events[open][1].end.offset - events[open][1].start.offset > 1 &&\n            events[index][1].end.offset - events[index][1].start.offset > 1\n              ? 2\n              : 1\n          const start = Object.assign({}, events[open][1].end)\n          const end = Object.assign({}, events[index][1].start)\n          movePoint(start, -use)\n          movePoint(end, use)\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start,\n            end: Object.assign({}, events[open][1].end)\n          }\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: Object.assign({}, events[index][1].start),\n            end\n          }\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: Object.assign({}, events[open][1].end),\n            end: Object.assign({}, events[index][1].start)\n          }\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: Object.assign({}, openingSequence.start),\n            end: Object.assign({}, closingSequence.end)\n          }\n          events[open][1].end = Object.assign({}, openingSequence.start)\n          events[index][1].start = Object.assign({}, closingSequence.end)\n          nextEvents = [] // If there are more markers in the opening, add them before.\n\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context]\n            ])\n          } // Opening.\n\n          nextEvents = push(nextEvents, [\n            ['enter', group, context],\n            ['enter', openingSequence, context],\n            ['exit', openingSequence, context],\n            ['enter', text, context]\n          ]) // Between.\n\n          nextEvents = push(\n            nextEvents,\n            resolveAll(\n              context.parser.constructs.insideSpan.null,\n              events.slice(open + 1, index),\n              context\n            )\n          ) // Closing.\n\n          nextEvents = push(nextEvents, [\n            ['exit', text, context],\n            ['enter', closingSequence, context],\n            ['exit', closingSequence, context],\n            ['exit', group, context]\n          ]) // If there are more markers in the closing, add them after.\n\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2\n            nextEvents = push(nextEvents, [\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context]\n            ])\n          } else {\n            offset = 0\n          }\n\n          splice(events, open - 1, index - open + 3, nextEvents)\n          index = open + nextEvents.length - offset - 2\n          break\n        }\n      }\n    }\n  } // Remove remaining sequences.\n\n  index = -1\n\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data'\n    }\n  }\n\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null\n  const previous = this.previous\n  const before = classifyCharacter(previous)\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('attentionSequence')\n    marker = code\n    return sequence(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return sequence\n    }\n\n    const token = effects.exit('attentionSequence')\n    const after = classifyCharacter(code)\n    const open =\n      !after || (after === 2 && before) || attentionMarkers.includes(code)\n    const close =\n      !before || (before === 2 && after) || attentionMarkers.includes(previous)\n    token._open = Boolean(marker === 42 ? open : open && (before || !close))\n    token._close = Boolean(marker === 42 ? close : close && (after || !open))\n    return ok(code)\n  }\n}\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n * @param {number} offset\n * @returns {void}\n */\n\nfunction movePoint(point, offset) {\n  point.column += offset\n  point.offset += offset\n  point._bufferIndex += offset\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n */\nimport {\n  attention,\n  autolink,\n  blockQuote,\n  characterEscape,\n  characterReference,\n  codeFenced,\n  codeIndented,\n  codeText,\n  definition,\n  hardBreakEscape,\n  headingAtx,\n  htmlFlow,\n  htmlText,\n  labelEnd,\n  labelStartImage,\n  labelStartLink,\n  lineEnding,\n  list,\n  setextUnderline,\n  thematicBreak\n} from 'micromark-core-commonmark'\nimport {resolver as resolveText} from './initialize/text.js'\n/** @type {Extension['document']} */\n\nexport const document = {\n  [42]: list,\n  [43]: list,\n  [45]: list,\n  [48]: list,\n  [49]: list,\n  [50]: list,\n  [51]: list,\n  [52]: list,\n  [53]: list,\n  [54]: list,\n  [55]: list,\n  [56]: list,\n  [57]: list,\n  [62]: blockQuote\n}\n/** @type {Extension['contentInitial']} */\n\nexport const contentInitial = {\n  [91]: definition\n}\n/** @type {Extension['flowInitial']} */\n\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n}\n/** @type {Extension['flow']} */\n\nexport const flow = {\n  [35]: headingAtx,\n  [42]: thematicBreak,\n  [45]: [setextUnderline, thematicBreak],\n  [60]: htmlFlow,\n  [61]: setextUnderline,\n  [95]: thematicBreak,\n  [96]: codeFenced,\n  [126]: codeFenced\n}\n/** @type {Extension['string']} */\n\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n}\n/** @type {Extension['text']} */\n\nexport const text = {\n  [-5]: lineEnding,\n  [-4]: lineEnding,\n  [-3]: lineEnding,\n  [33]: labelStartImage,\n  [38]: characterReference,\n  [42]: attention,\n  [60]: [autolink, htmlText],\n  [91]: labelStartLink,\n  [92]: [hardBreakEscape, characterEscape],\n  [93]: labelEnd,\n  [95]: attention,\n  [96]: codeText\n}\n/** @type {Extension['insideSpan']} */\n\nexport const insideSpan = {\n  null: [attention, resolveText]\n}\n/** @type {Extension['attentionMarkers']} */\n\nexport const attentionMarkers = {\n  null: [42, 95]\n}\n/** @type {Extension['disable']} */\n\nexport const disable = {\n  null: []\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {labelEnd} from './label-end.js'\n/** @type {Construct} */\n\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('labelImage')\n    effects.enter('labelImageMarker')\n    effects.consume(code)\n    effects.exit('labelImageMarker')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 91) {\n      effects.enter('labelMarker')\n      effects.consume(code)\n      effects.exit('labelMarker')\n      effects.exit('labelImage')\n      return after\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    /* To do: remove in the future once we’ve switched from\n     * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n     * which doesn’t need this */\n\n    /* Hidden footnotes hook */\n\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  asciiAtext,\n  asciiControl\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 1\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('autolink')\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.enter('autolinkProtocol')\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return schemeOrEmailAtext\n    }\n\n    return asciiAtext(code) ? emailAtext(code) : nok(code)\n  }\n  /** @type {State} */\n\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)\n      ? schemeInsideOrEmailAtext(code)\n      : emailAtext(code)\n  }\n  /** @type {State} */\n\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code)\n      return urlInside\n    }\n\n    if (\n      (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&\n      size++ < 32\n    ) {\n      effects.consume(code)\n      return schemeInsideOrEmailAtext\n    }\n\n    return emailAtext(code)\n  }\n  /** @type {State} */\n\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol')\n      return end(code)\n    }\n\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return urlInside\n  }\n  /** @type {State} */\n\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n\n    if (asciiAtext(code)) {\n      effects.consume(code)\n      return emailAtext\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)\n  }\n  /** @type {State} */\n\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail'\n      return end(code)\n    }\n\n    return emailValue(code)\n  }\n  /** @type {State} */\n\n  function emailValue(code) {\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      effects.consume(code)\n      return code === 45 ? emailValue : emailLabel\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function end(code) {\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.exit('autolink')\n    return ok\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this\n  /** @type {NonNullable<Code>|undefined} */\n\n  let marker\n  /** @type {string} */\n\n  let buffer\n  /** @type {number} */\n\n  let index\n  /** @type {State} */\n\n  let returnState\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('htmlText')\n    effects.enter('htmlTextData')\n    effects.consume(code)\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationOpen\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instruction\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentOpen\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpen\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return declaration\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentStart\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentStartDash\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function comment(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = comment\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return comment\n  }\n  /** @type {State} */\n\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return end\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length ? cdata : cdataOpen\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function cdata(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = cdata\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return cdata\n  }\n  /** @type {State} */\n\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n  /** @type {State} */\n\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n  /** @type {State} */\n\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = declaration\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return declaration\n  }\n  /** @type {State} */\n\n  function instruction(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instructionClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = instruction\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return instruction\n  }\n  /** @type {State} */\n\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code)\n  }\n  /** @type {State} */\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return tagCloseBetween(code)\n  }\n  /** @type {State} */\n\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagCloseBetween\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return end\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenBetween\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    return tagOpenAttributeNameAfter(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeNameAfter\n    }\n\n    return tagOpenBetween(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return tagOpenAttributeValueQuoted\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    effects.consume(code)\n    marker = undefined\n    return tagOpenAttributeValueUnquoted\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return tagOpenAttributeValueQuotedAfter\n    }\n\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueQuoted\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueUnquoted\n  } // We can’t have blank lines in content, so no need to worry about empty\n  // tokens.\n\n  /** @type {State} */\n\n  function atLineEnding(code) {\n    effects.exit('htmlTextData')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(\n      effects,\n      afterPrefix,\n      'linePrefix',\n      self.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    effects.enter('htmlTextData')\n    return returnState(code)\n  }\n  /** @type {State} */\n\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code)\n      effects.exit('htmlTextData')\n      effects.exit('htmlText')\n      return ok\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {labelEnd} from './label-end.js'\n/** @type {Construct} */\n\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('labelLink')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelLink')\n    return after\n  }\n  /** @type {State} */\n\n  function after(code) {\n    /* To do: remove in the future once we’ve switched from\n     * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n     * which doesn’t need this */\n\n    /* Hidden footnotes hook. */\n\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('hardBreakEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker')\n      effects.exit('hardBreakEscape')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Previous} Previous\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous\n}\n/** @type {Resolver} */\n\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4\n  let headEnterIndex = 3\n  /** @type {number} */\n\n  let index\n  /** @type {number|undefined} */\n\n  let enter // If we start and end with an EOL or a space.\n\n  if (\n    (events[headEnterIndex][1].type === 'lineEnding' ||\n      events[headEnterIndex][1].type === 'space') &&\n    (events[tailExitIndex][1].type === 'lineEnding' ||\n      events[tailExitIndex][1].type === 'space')\n  ) {\n    index = headEnterIndex // And we have data.\n\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === 'codeTextData') {\n        // Then we have padding.\n        events[headEnterIndex][1].type = 'codeTextPadding'\n        events[tailExitIndex][1].type = 'codeTextPadding'\n        headEnterIndex += 2\n        tailExitIndex -= 2\n        break\n      }\n    }\n  } // Merge adjacent spaces and data.\n\n  index = headEnterIndex - 1\n  tailExitIndex++\n\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index\n      }\n    } else if (\n      index === tailExitIndex ||\n      events[index][1].type === 'lineEnding'\n    ) {\n      events[enter][1].type = 'codeTextData'\n\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end\n        events.splice(enter + 2, index - enter - 2)\n        tailExitIndex -= index - enter - 2\n        index = enter + 2\n      }\n\n      enter = undefined\n    }\n  }\n\n  return events\n}\n/** @type {Previous} */\n\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return (\n    code !== 96 ||\n    this.events[this.events.length - 1][1].type === 'characterEscape'\n  )\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this\n  let sizeOpen = 0\n  /** @type {number} */\n\n  let size\n  /** @type {Token} */\n\n  let token\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeText')\n    effects.enter('codeTextSequence')\n    return openingSequence(code)\n  }\n  /** @type {State} */\n\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code)\n      sizeOpen++\n      return openingSequence\n    }\n\n    effects.exit('codeTextSequence')\n    return gap(code)\n  }\n  /** @type {State} */\n\n  function gap(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code)\n    } // Closing fence?\n    // Could also be data.\n\n    if (code === 96) {\n      token = effects.enter('codeTextSequence')\n      size = 0\n      return closingSequence(code)\n    } // Tabs don’t work, and virtual spaces don’t make sense.\n\n    if (code === 32) {\n      effects.enter('space')\n      effects.consume(code)\n      effects.exit('space')\n      return gap\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return gap\n    } // Data.\n\n    effects.enter('codeTextData')\n    return data(code)\n  } // In code.\n\n  /** @type {State} */\n\n  function data(code) {\n    if (\n      code === null ||\n      code === 32 ||\n      code === 96 ||\n      markdownLineEnding(code)\n    ) {\n      effects.exit('codeTextData')\n      return gap(code)\n    }\n\n    effects.consume(code)\n    return data\n  } // Closing fence.\n\n  /** @type {State} */\n\n  function closingSequence(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code)\n      size++\n      return closingSequence\n    } // Done!\n\n    if (size === sizeOpen) {\n      effects.exit('codeTextSequence')\n      effects.exit('codeText')\n      return ok(code)\n    } // More or less accents: mark as data.\n\n    token.type = 'codeTextData'\n    return data(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Value} Value\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n */\n\n/**\n * @callback Preprocessor\n * @param {Value} value\n * @param {Encoding} [encoding]\n * @param {boolean} [end=false]\n * @returns {Array<Chunk>}\n */\nconst search = /[\\0\\t\\n\\r]/g\n/**\n * @returns {Preprocessor}\n */\n\nexport function preprocess() {\n  let column = 1\n  let buffer = ''\n  /** @type {boolean|undefined} */\n\n  let start = true\n  /** @type {boolean|undefined} */\n\n  let atCarriageReturn\n  return preprocessor\n  /** @type {Preprocessor} */\n\n  function preprocessor(value, encoding, end) {\n    /** @type {Array<Chunk>} */\n    const chunks = []\n    /** @type {RegExpMatchArray|null} */\n\n    let match\n    /** @type {number} */\n\n    let next\n    /** @type {number} */\n\n    let startPosition\n    /** @type {number} */\n\n    let endPosition\n    /** @type {Code} */\n\n    let code // @ts-expect-error `Buffer` does allow an encoding.\n\n    value = buffer + value.toString(encoding)\n    startPosition = 0\n    buffer = ''\n\n    if (start) {\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++\n      }\n\n      start = undefined\n    }\n\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition\n      match = search.exec(value)\n      endPosition =\n        match && match.index !== undefined ? match.index : value.length\n      code = value.charCodeAt(endPosition)\n\n      if (!match) {\n        buffer = value.slice(startPosition)\n        break\n      }\n\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3)\n        atCarriageReturn = undefined\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5)\n          atCarriageReturn = undefined\n        }\n\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition))\n          column += endPosition - startPosition\n        }\n\n        switch (code) {\n          case 0: {\n            chunks.push(65533)\n            column++\n            break\n          }\n\n          case 9: {\n            next = Math.ceil(column / 4) * 4\n            chunks.push(-2)\n\n            while (column++ < next) chunks.push(-1)\n\n            break\n          }\n\n          case 10: {\n            chunks.push(-4)\n            column = 1\n            break\n          }\n\n          default: {\n            atCarriageReturn = true\n            column = 1\n          }\n        }\n      }\n\n      startPosition = endPosition + 1\n    }\n\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5)\n      if (buffer) chunks.push(buffer)\n      chunks.push(null)\n    }\n\n    return chunks\n  }\n}\n","/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base)\n\n  if (\n    // C0 except for HT, LF, FF, CR, space\n    code < 9 ||\n    code === 11 ||\n    (code > 13 && code < 32) || // Control character (DEL) of the basic block and C1 controls.\n    (code > 126 && code < 160) || // Lone high surrogates and low surrogates.\n    (code > 55295 && code < 57344) || // Noncharacters.\n    (code > 64975 && code < 65008) ||\n    (code & 65535) === 65535 ||\n    (code & 65535) === 65534 || // Out of range\n    code > 1114111\n  ) {\n    return '\\uFFFD'\n  }\n\n  return String.fromCharCode(code)\n}\n","import {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nconst characterEscapeOrReference =\n  /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi\n/**\n * Utility to decode markdown strings (which occur in places such as fenced\n * code info strings, destinations, labels, and titles).\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n * @returns {string}\n */\n\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode)\n}\n/**\n * @param {string} $0\n * @param {string} $1\n * @param {string} $2\n * @returns {string}\n */\n\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1\n  } // Reference.\n\n  const head = $2.charCodeAt(0)\n\n  if (head === 35) {\n    const head = $2.charCodeAt(1)\n    const hex = head === 120 || head === 88\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10)\n  }\n\n  return decodeNamedCharacterReference($2) || $0\n}\n","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Value} Value\n *\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist').Point} Point\n *\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').StaticPhrasingContent} StaticPhrasingContent\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').Break} Break\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('mdast').Code} Code\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('mdast').HTML} HTML\n * @typedef {import('mdast').Image} Image\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').List} List\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('mdast').Text} Text\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('mdast').ReferenceType} ReferenceType\n * @typedef {import('../index.js').CompileData} CompileData\n */\n\n/**\n * @typedef {Root | Content} Node\n * @typedef {Extract<Node, UnistParent>} Parent\n *\n * @typedef {Omit<UnistParent, 'type' | 'children'> & {type: 'fragment', children: Array<PhrasingContent>}} Fragment\n */\n\n/**\n * @callback Transform\n *   Extra transform, to change the AST afterwards.\n * @param {Root} tree\n *   Tree to transform.\n * @returns {Root | undefined | null | void}\n *   New tree or nothing (in which case the current tree is used).\n *\n * @callback Handle\n *   Handle a token.\n * @param {CompileContext} this\n *   Context.\n * @param {Token} token\n *   Current token.\n * @returns {void}\n *   Nothing.\n *\n * @typedef {Record<string, Handle>} Handles\n *   Token types mapping to handles\n *\n * @callback OnEnterError\n *   Handle the case where the `right` token is open, but it is closed (by the\n *   `left` token) or because we reached the end of the document.\n * @param {Omit<CompileContext, 'sliceSerialize'>} this\n *   Context.\n * @param {Token | undefined} left\n *   Left token.\n * @param {Token} right\n *   Right token.\n * @returns {void}\n *   Nothing.\n *\n * @callback OnExitError\n *   Handle the case where the `right` token is open but it is closed by\n *   exiting the `left` token.\n * @param {Omit<CompileContext, 'sliceSerialize'>} this\n *   Context.\n * @param {Token} left\n *   Left token.\n * @param {Token} right\n *   Right token.\n * @returns {void}\n *   Nothing.\n *\n * @typedef {[Token, OnEnterError | undefined]} TokenTuple\n *   Open token on the stack, with an optional error handler for when\n *   that token isn’t closed properly.\n */\n\n/**\n * @typedef Config\n *   Configuration.\n *\n *   We have our defaults, but extensions will add more.\n * @property {Array<string>} canContainEols\n *   Token types where line endings are used.\n * @property {Handles} enter\n *   Opening handles.\n * @property {Handles} exit\n *   Closing handles.\n * @property {Array<Transform>} transforms\n *   Tree transforms.\n *\n * @typedef {Partial<Config>} Extension\n *   Change how markdown tokens from micromark are turned into mdast.\n *\n * @typedef CompileContext\n *   mdast compiler context.\n * @property {Array<Node | Fragment>} stack\n *   Stack of nodes.\n * @property {Array<TokenTuple>} tokenStack\n *   Stack of tokens.\n * @property {<Key extends keyof CompileData>(key: Key) => CompileData[Key]} getData\n *   Get data from the key/value store.\n * @property {<Key extends keyof CompileData>(key: Key, value?: CompileData[Key]) => void} setData\n *   Set data into the key/value store.\n * @property {(this: CompileContext) => void} buffer\n *   Capture some of the output data.\n * @property {(this: CompileContext) => string} resume\n *   Stop capturing and access the output data.\n * @property {<Kind extends Node>(this: CompileContext, node: Kind, token: Token, onError?: OnEnterError) => Kind} enter\n *   Enter a token.\n * @property {(this: CompileContext, token: Token, onError?: OnExitError) => Node} exit\n *   Exit a token.\n * @property {TokenizeContext['sliceSerialize']} sliceSerialize\n *   Get the string value of a token.\n * @property {Config} config\n *   Configuration.\n *\n * @typedef FromMarkdownOptions\n *   Configuration for how to build mdast.\n * @property {Array<Extension | Array<Extension>> | null | undefined} [mdastExtensions]\n *   Extensions for this utility to change how tokens are turned into a tree.\n *\n * @typedef {ParseOptions & FromMarkdownOptions} Options\n *   Configuration.\n */\n\n// To do: micromark: create a registry of tokens?\n// To do: next major: don’t return given `Node` from `enter`.\n// To do: next major: remove setter/getter.\n\nimport {toString} from 'mdast-util-to-string'\nimport {parse} from 'micromark/lib/parse.js'\nimport {preprocess} from 'micromark/lib/preprocess.js'\nimport {postprocess} from 'micromark/lib/postprocess.js'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nimport {decodeString} from 'micromark-util-decode-string'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {stringifyPosition} from 'unist-util-stringify-position'\nconst own = {}.hasOwnProperty\n\n/**\n * @param value\n *   Markdown to parse.\n * @param encoding\n *   Character encoding for when `value` is `Buffer`.\n * @param options\n *   Configuration.\n * @returns\n *   mdast tree.\n */\nexport const fromMarkdown =\n  /**\n   * @type {(\n   *   ((value: Value, encoding: Encoding, options?: Options | null | undefined) => Root) &\n   *   ((value: Value, options?: Options | null | undefined) => Root)\n   * )}\n   */\n\n  /**\n   * @param {Value} value\n   * @param {Encoding | Options | null | undefined} [encoding]\n   * @param {Options | null | undefined} [options]\n   * @returns {Root}\n   */\n  function (value, encoding, options) {\n    if (typeof encoding !== 'string') {\n      options = encoding\n      encoding = undefined\n    }\n    return compiler(options)(\n      postprocess(\n        // @ts-expect-error: micromark types need to accept `null`.\n        parse(options).document().write(preprocess()(value, encoding, true))\n      )\n    )\n  }\n\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options | null | undefined} [options]\n */\nfunction compiler(options) {\n  /** @type {Config} */\n  const config = {\n    transforms: [],\n    canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],\n    enter: {\n      autolink: opener(link),\n      autolinkProtocol: onenterdata,\n      autolinkEmail: onenterdata,\n      atxHeading: opener(heading),\n      blockQuote: opener(blockQuote),\n      characterEscape: onenterdata,\n      characterReference: onenterdata,\n      codeFenced: opener(codeFlow),\n      codeFencedFenceInfo: buffer,\n      codeFencedFenceMeta: buffer,\n      codeIndented: opener(codeFlow, buffer),\n      codeText: opener(codeText, buffer),\n      codeTextData: onenterdata,\n      data: onenterdata,\n      codeFlowValue: onenterdata,\n      definition: opener(definition),\n      definitionDestinationString: buffer,\n      definitionLabelString: buffer,\n      definitionTitleString: buffer,\n      emphasis: opener(emphasis),\n      hardBreakEscape: opener(hardBreak),\n      hardBreakTrailing: opener(hardBreak),\n      htmlFlow: opener(html, buffer),\n      htmlFlowData: onenterdata,\n      htmlText: opener(html, buffer),\n      htmlTextData: onenterdata,\n      image: opener(image),\n      label: buffer,\n      link: opener(link),\n      listItem: opener(listItem),\n      listItemValue: onenterlistitemvalue,\n      listOrdered: opener(list, onenterlistordered),\n      listUnordered: opener(list),\n      paragraph: opener(paragraph),\n      reference: onenterreference,\n      referenceString: buffer,\n      resourceDestinationString: buffer,\n      resourceTitleString: buffer,\n      setextHeading: opener(heading),\n      strong: opener(strong),\n      thematicBreak: opener(thematicBreak)\n    },\n    exit: {\n      atxHeading: closer(),\n      atxHeadingSequence: onexitatxheadingsequence,\n      autolink: closer(),\n      autolinkEmail: onexitautolinkemail,\n      autolinkProtocol: onexitautolinkprotocol,\n      blockQuote: closer(),\n      characterEscapeValue: onexitdata,\n      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n      characterReferenceValue: onexitcharacterreferencevalue,\n      codeFenced: closer(onexitcodefenced),\n      codeFencedFence: onexitcodefencedfence,\n      codeFencedFenceInfo: onexitcodefencedfenceinfo,\n      codeFencedFenceMeta: onexitcodefencedfencemeta,\n      codeFlowValue: onexitdata,\n      codeIndented: closer(onexitcodeindented),\n      codeText: closer(onexitcodetext),\n      codeTextData: onexitdata,\n      data: onexitdata,\n      definition: closer(),\n      definitionDestinationString: onexitdefinitiondestinationstring,\n      definitionLabelString: onexitdefinitionlabelstring,\n      definitionTitleString: onexitdefinitiontitlestring,\n      emphasis: closer(),\n      hardBreakEscape: closer(onexithardbreak),\n      hardBreakTrailing: closer(onexithardbreak),\n      htmlFlow: closer(onexithtmlflow),\n      htmlFlowData: onexitdata,\n      htmlText: closer(onexithtmltext),\n      htmlTextData: onexitdata,\n      image: closer(onexitimage),\n      label: onexitlabel,\n      labelText: onexitlabeltext,\n      lineEnding: onexitlineending,\n      link: closer(onexitlink),\n      listItem: closer(),\n      listOrdered: closer(),\n      listUnordered: closer(),\n      paragraph: closer(),\n      referenceString: onexitreferencestring,\n      resourceDestinationString: onexitresourcedestinationstring,\n      resourceTitleString: onexitresourcetitlestring,\n      resource: onexitresource,\n      setextHeading: closer(onexitsetextheading),\n      setextHeadingLineSequence: onexitsetextheadinglinesequence,\n      setextHeadingText: onexitsetextheadingtext,\n      strong: closer(),\n      thematicBreak: closer()\n    }\n  }\n  configure(config, (options || {}).mdastExtensions || [])\n\n  /** @type {CompileData} */\n  const data = {}\n  return compile\n\n  /**\n   * Turn micromark events into an mdast tree.\n   *\n   * @param {Array<Event>} events\n   *   Events.\n   * @returns {Root}\n   *   mdast tree.\n   */\n  function compile(events) {\n    /** @type {Root} */\n    let tree = {\n      type: 'root',\n      children: []\n    }\n    /** @type {Omit<CompileContext, 'sliceSerialize'>} */\n    const context = {\n      stack: [tree],\n      tokenStack: [],\n      config,\n      enter,\n      exit,\n      buffer,\n      resume,\n      setData,\n      getData\n    }\n    /** @type {Array<number>} */\n    const listStack = []\n    let index = -1\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (\n        events[index][1].type === 'listOrdered' ||\n        events[index][1].type === 'listUnordered'\n      ) {\n        if (events[index][0] === 'enter') {\n          listStack.push(index)\n        } else {\n          const tail = listStack.pop()\n          index = prepareList(events, tail, index)\n        }\n      }\n    }\n    index = -1\n    while (++index < events.length) {\n      const handler = config[events[index][0]]\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(\n          Object.assign(\n            {\n              sliceSerialize: events[index][2].sliceSerialize\n            },\n            context\n          ),\n          events[index][1]\n        )\n      }\n    }\n\n    // Handle tokens still being open.\n    if (context.tokenStack.length > 0) {\n      const tail = context.tokenStack[context.tokenStack.length - 1]\n      const handler = tail[1] || defaultOnError\n      handler.call(context, undefined, tail[0])\n    }\n\n    // Figure out `root` position.\n    tree.position = {\n      start: point(\n        events.length > 0\n          ? events[0][1].start\n          : {\n              line: 1,\n              column: 1,\n              offset: 0\n            }\n      ),\n      end: point(\n        events.length > 0\n          ? events[events.length - 2][1].end\n          : {\n              line: 1,\n              column: 1,\n              offset: 0\n            }\n      )\n    }\n\n    // Call transforms.\n    index = -1\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree\n    }\n    return tree\n  }\n\n  /**\n   * @param {Array<Event>} events\n   * @param {number} start\n   * @param {number} length\n   * @returns {number}\n   */\n  function prepareList(events, start, length) {\n    let index = start - 1\n    let containerBalance = -1\n    let listSpread = false\n    /** @type {Token | undefined} */\n    let listItem\n    /** @type {number | undefined} */\n    let lineIndex\n    /** @type {number | undefined} */\n    let firstBlankLineIndex\n    /** @type {boolean | undefined} */\n    let atMarker\n    while (++index <= length) {\n      const event = events[index]\n      if (\n        event[1].type === 'listUnordered' ||\n        event[1].type === 'listOrdered' ||\n        event[1].type === 'blockQuote'\n      ) {\n        if (event[0] === 'enter') {\n          containerBalance++\n        } else {\n          containerBalance--\n        }\n        atMarker = undefined\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (\n            listItem &&\n            !atMarker &&\n            !containerBalance &&\n            !firstBlankLineIndex\n          ) {\n            firstBlankLineIndex = index\n          }\n          atMarker = undefined\n        }\n      } else if (\n        event[1].type === 'linePrefix' ||\n        event[1].type === 'listItemValue' ||\n        event[1].type === 'listItemMarker' ||\n        event[1].type === 'listItemPrefix' ||\n        event[1].type === 'listItemPrefixWhitespace'\n      ) {\n        // Empty.\n      } else {\n        atMarker = undefined\n      }\n      if (\n        (!containerBalance &&\n          event[0] === 'enter' &&\n          event[1].type === 'listItemPrefix') ||\n        (containerBalance === -1 &&\n          event[0] === 'exit' &&\n          (event[1].type === 'listUnordered' ||\n            event[1].type === 'listOrdered'))\n      ) {\n        if (listItem) {\n          let tailIndex = index\n          lineIndex = undefined\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex]\n            if (\n              tailEvent[1].type === 'lineEnding' ||\n              tailEvent[1].type === 'lineEndingBlank'\n            ) {\n              if (tailEvent[0] === 'exit') continue\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank'\n                listSpread = true\n              }\n              tailEvent[1].type = 'lineEnding'\n              lineIndex = tailIndex\n            } else if (\n              tailEvent[1].type === 'linePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefixWhitespace' ||\n              tailEvent[1].type === 'blockQuoteMarker' ||\n              tailEvent[1].type === 'listItemIndent'\n            ) {\n              // Empty\n            } else {\n              break\n            }\n          }\n          if (\n            firstBlankLineIndex &&\n            (!lineIndex || firstBlankLineIndex < lineIndex)\n          ) {\n            // @ts-expect-error Patched.\n            listItem._spread = true\n          }\n\n          // Fix position.\n          listItem.end = Object.assign(\n            {},\n            lineIndex ? events[lineIndex][1].start : event[1].end\n          )\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]])\n          index++\n          length++\n        }\n\n        // Create a new list item.\n        if (event[1].type === 'listItemPrefix') {\n          listItem = {\n            type: 'listItem',\n            // @ts-expect-error Patched\n            _spread: false,\n            start: Object.assign({}, event[1].start)\n          }\n          // @ts-expect-error: `listItem` is most definitely defined, TS...\n          events.splice(index, 0, ['enter', listItem, event[2]])\n          index++\n          length++\n          firstBlankLineIndex = undefined\n          atMarker = true\n        }\n      }\n    }\n\n    // @ts-expect-error Patched.\n    events[start][1]._spread = listSpread\n    return length\n  }\n\n  /**\n   * Set data.\n   *\n   * @template {keyof CompileData} Key\n   *   Field type.\n   * @param {Key} key\n   *   Key of field.\n   * @param {CompileData[Key]} [value]\n   *   New value.\n   * @returns {void}\n   *   Nothing.\n   */\n  function setData(key, value) {\n    data[key] = value\n  }\n\n  /**\n   * Get data.\n   *\n   * @template {keyof CompileData} Key\n   *   Field type.\n   * @param {Key} key\n   *   Key of field.\n   * @returns {CompileData[Key]}\n   *   Value.\n   */\n  function getData(key) {\n    return data[key]\n  }\n\n  /**\n   * Create an opener handle.\n   *\n   * @param {(token: Token) => Node} create\n   *   Create a node.\n   * @param {Handle} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function opener(create, and) {\n    return open\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {void}\n     */\n    function open(token) {\n      enter.call(this, create(token), token)\n      if (and) and.call(this, token)\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @returns {void}\n   */\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    })\n  }\n\n  /**\n   * @template {Node} Kind\n   *   Node type.\n   * @this {CompileContext}\n   *   Context.\n   * @param {Kind} node\n   *   Node to enter.\n   * @param {Token} token\n   *   Corresponding token.\n   * @param {OnEnterError | undefined} [errorHandler]\n   *   Handle the case where this token is open, but it is closed by something else.\n   * @returns {Kind}\n   *   The given node.\n   */\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1]\n    // @ts-expect-error: Assume `Node` can exist as a child of `parent`.\n    parent.children.push(node)\n    this.stack.push(node)\n    this.tokenStack.push([token, errorHandler])\n    // @ts-expect-error: `end` will be patched later.\n    node.position = {\n      start: point(token.start)\n    }\n    return node\n  }\n\n  /**\n   * Create a closer handle.\n   *\n   * @param {Handle} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function closer(and) {\n    return close\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {void}\n     */\n    function close(token) {\n      if (and) and.call(this, token)\n      exit.call(this, token)\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   *   Context.\n   * @param {Token} token\n   *   Corresponding token.\n   * @param {OnExitError | undefined} [onExitError]\n   *   Handle the case where another token is open.\n   * @returns {Node}\n   *   The closed node.\n   */\n  function exit(token, onExitError) {\n    const node = this.stack.pop()\n    const open = this.tokenStack.pop()\n    if (!open) {\n      throw new Error(\n        'Cannot close `' +\n          token.type +\n          '` (' +\n          stringifyPosition({\n            start: token.start,\n            end: token.end\n          }) +\n          '): it’s not open'\n      )\n    } else if (open[0].type !== token.type) {\n      if (onExitError) {\n        onExitError.call(this, token, open[0])\n      } else {\n        const handler = open[1] || defaultOnError\n        handler.call(this, token, open[0])\n      }\n    }\n    node.position.end = point(token.end)\n    return node\n  }\n\n  /**\n   * @this {CompileContext}\n   * @returns {string}\n   */\n  function resume() {\n    return toString(this.stack.pop())\n  }\n\n  //\n  // Handlers.\n  //\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      const ancestor = this.stack[this.stack.length - 2]\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10)\n      setData('expectingFirstListItemValue')\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfenceinfo() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.lang = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfencemeta() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.meta = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (getData('flowCodeInside')) return\n    this.buffer()\n    setData('flowCodeInside', true)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefenced() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '')\n    setData('flowCodeInside')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodeindented() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data.replace(/(\\r?\\n|\\r)$/g, '')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitionlabelstring(token) {\n    const label = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.label = label\n    node.identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiontitlestring() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.title = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiondestinationstring() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.url = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitatxheadingsequence(token) {\n    const node = this.stack[this.stack.length - 1]\n    if (!node.depth) {\n      const depth = this.sliceSerialize(token).length\n      node.depth = depth\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadinglinesequence(token) {\n    const node = this.stack[this.stack.length - 1]\n    node.depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterdata(token) {\n    const node = this.stack[this.stack.length - 1]\n    let tail = node.children[node.children.length - 1]\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text()\n      // @ts-expect-error: we’ll add `end` later.\n      tail.position = {\n        start: point(token.start)\n      }\n      // @ts-expect-error: Assume `parent` accepts `text`.\n      node.children.push(tail)\n    }\n    this.stack.push(tail)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitdata(token) {\n    const tail = this.stack.pop()\n    tail.value += this.sliceSerialize(token)\n    tail.position.end = point(token.end)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlineending(token) {\n    const context = this.stack[this.stack.length - 1]\n    // If we’re at a hard break, include the line ending in there.\n    if (getData('atHardBreak')) {\n      const tail = context.children[context.children.length - 1]\n      tail.position.end = point(token.end)\n      setData('atHardBreak')\n      return\n    }\n    if (\n      !getData('setextHeadingSlurpLineEnding') &&\n      config.canContainEols.includes(context.type)\n    ) {\n      onenterdata.call(this, token)\n      onexitdata.call(this, token)\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithardbreak() {\n    setData('atHardBreak', true)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmlflow() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmltext() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcodetext() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlink() {\n    const node = this.stack[this.stack.length - 1]\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (getData('inReference')) {\n      /** @type {ReferenceType} */\n      const referenceType = getData('referenceType') || 'shortcut'\n      node.type += 'Reference'\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType\n      // @ts-expect-error: mutate.\n      delete node.url\n      delete node.title\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier\n      // @ts-expect-error: mutate.\n      delete node.label\n    }\n    setData('referenceType')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitimage() {\n    const node = this.stack[this.stack.length - 1]\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (getData('inReference')) {\n      /** @type {ReferenceType} */\n      const referenceType = getData('referenceType') || 'shortcut'\n      node.type += 'Reference'\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType\n      // @ts-expect-error: mutate.\n      delete node.url\n      delete node.title\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier\n      // @ts-expect-error: mutate.\n      delete node.label\n    }\n    setData('referenceType')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabeltext(token) {\n    const string = this.sliceSerialize(token)\n    const ancestor = this.stack[this.stack.length - 2]\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    ancestor.label = decodeString(string)\n    // @ts-expect-error: same as above.\n    ancestor.identifier = normalizeIdentifier(string).toLowerCase()\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabel() {\n    const fragment = this.stack[this.stack.length - 1]\n    const value = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    // Assume a reference.\n    setData('inReference', true)\n    if (node.type === 'link') {\n      /** @type {Array<StaticPhrasingContent>} */\n      // @ts-expect-error: Assume static phrasing content.\n      const children = fragment.children\n      node.children = children\n    } else {\n      node.alt = value\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcedestinationstring() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.url = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcetitlestring() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.title = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresource() {\n    setData('inReference')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterreference() {\n    setData('referenceType', 'collapsed')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitreferencestring(token) {\n    const label = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    node.label = label\n    // @ts-expect-error: same as above.\n    node.identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n    setData('referenceType', 'full')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreferencevalue(token) {\n    const data = this.sliceSerialize(token)\n    const type = getData('characterReferenceType')\n    /** @type {string} */\n    let value\n    if (type) {\n      value = decodeNumericCharacterReference(\n        data,\n        type === 'characterReferenceMarkerNumeric' ? 10 : 16\n      )\n      setData('characterReferenceType')\n    } else {\n      const result = decodeNamedCharacterReference(data)\n      value = result\n    }\n    const tail = this.stack.pop()\n    tail.value += value\n    tail.position.end = point(token.end)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token)\n    const node = this.stack[this.stack.length - 1]\n    node.url = this.sliceSerialize(token)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token)\n    const node = this.stack[this.stack.length - 1]\n    node.url = 'mailto:' + this.sliceSerialize(token)\n  }\n\n  //\n  // Creaters.\n  //\n\n  /** @returns {Blockquote} */\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    }\n  }\n\n  /** @returns {Code} */\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    }\n  }\n\n  /** @returns {InlineCode} */\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    }\n  }\n\n  /** @returns {Definition} */\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    }\n  }\n\n  /** @returns {Emphasis} */\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    }\n  }\n\n  /** @returns {Heading} */\n  function heading() {\n    // @ts-expect-error `depth` will be set later.\n    return {\n      type: 'heading',\n      depth: undefined,\n      children: []\n    }\n  }\n\n  /** @returns {Break} */\n  function hardBreak() {\n    return {\n      type: 'break'\n    }\n  }\n\n  /** @returns {HTML} */\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    }\n  }\n\n  /** @returns {Image} */\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    }\n  }\n\n  /** @returns {Link} */\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    }\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {List}\n   */\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      // @ts-expect-error Patched.\n      spread: token._spread,\n      children: []\n    }\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {ListItem}\n   */\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      // @ts-expect-error Patched.\n      spread: token._spread,\n      checked: null,\n      children: []\n    }\n  }\n\n  /** @returns {Paragraph} */\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    }\n  }\n\n  /** @returns {Strong} */\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    }\n  }\n\n  /** @returns {Text} */\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    }\n  }\n\n  /** @returns {ThematicBreak} */\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    }\n  }\n}\n\n/**\n * Copy a point-like value.\n *\n * @param {Point} d\n *   Point-like value.\n * @returns {Point}\n *   unist point.\n */\nfunction point(d) {\n  return {\n    line: d.line,\n    column: d.column,\n    offset: d.offset\n  }\n}\n\n/**\n * @param {Config} combined\n * @param {Array<Extension | Array<Extension>>} extensions\n * @returns {void}\n */\nfunction configure(combined, extensions) {\n  let index = -1\n  while (++index < extensions.length) {\n    const value = extensions[index]\n    if (Array.isArray(value)) {\n      configure(combined, value)\n    } else {\n      extension(combined, value)\n    }\n  }\n}\n\n/**\n * @param {Config} combined\n * @param {Extension} extension\n * @returns {void}\n */\nfunction extension(combined, extension) {\n  /** @type {keyof Extension} */\n  let key\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      if (key === 'canContainEols') {\n        const right = extension[key]\n        if (right) {\n          combined[key].push(...right)\n        }\n      } else if (key === 'transforms') {\n        const right = extension[key]\n        if (right) {\n          combined[key].push(...right)\n        }\n      } else if (key === 'enter' || key === 'exit') {\n        const right = extension[key]\n        if (right) {\n          Object.assign(combined[key], right)\n        }\n      }\n    }\n  }\n}\n\n/** @type {OnEnterError} */\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error(\n      'Cannot close `' +\n        left.type +\n        '` (' +\n        stringifyPosition({\n          start: left.start,\n          end: left.end\n        }) +\n        '): a different token (`' +\n        right.type +\n        '`, ' +\n        stringifyPosition({\n          start: right.start,\n          end: right.end\n        }) +\n        ') is open'\n    )\n  } else {\n    throw new Error(\n      'Cannot close document, a token (`' +\n        right.type +\n        '`, ' +\n        stringifyPosition({\n          start: right.start,\n          end: right.end\n        }) +\n        ') is still open'\n    )\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\nimport {subtokenize} from 'micromark-util-subtokenize'\n/**\n * @param {Array<Event>} events\n * @returns {Array<Event>}\n */\n\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').Create} Create\n */\nimport {combineExtensions} from 'micromark-util-combine-extensions'\nimport {content} from './initialize/content.js'\nimport {document} from './initialize/document.js'\nimport {flow} from './initialize/flow.js'\nimport {text, string} from './initialize/text.js'\nimport {createTokenizer} from './create-tokenizer.js'\nimport * as defaultConstructs from './constructs.js'\n/**\n * @param {ParseOptions} [options]\n * @returns {ParseContext}\n */\n\nexport function parse(options = {}) {\n  /** @type {FullNormalizedExtension} */\n  // @ts-expect-error `defaultConstructs` is full, so the result will be too.\n  const constructs = combineExtensions(\n    // @ts-expect-error Same as above.\n    [defaultConstructs].concat(options.extensions || [])\n  )\n  /** @type {ParseContext} */\n\n  const parser = {\n    defined: [],\n    lazy: {},\n    constructs,\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(string),\n    text: create(text)\n  }\n  return parser\n  /**\n   * @param {InitialConstruct} initial\n   */\n\n  function create(initial) {\n    return creator\n    /** @type {Create} */\n\n    function creator(from) {\n      return createTokenizer(parser, initial, from)\n    }\n  }\n}\n","import {asciiAlphanumeric} from 'micromark-util-character'\nimport {encode} from 'micromark-util-encode'\n\n/**\n * Make a value safe for injection as a URL.\n *\n * This encodes unsafe characters with percent-encoding and skips already\n * encoded sequences (see `normalizeUri` below).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * Then, a regex of allowed protocols can be given, in which case the URL is\n * sanitized.\n * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`,\n * or `/^https?$/i` for `img[src]`.\n * If the URL includes an unknown protocol (one not matched by `protocol`, such\n * as a dangerous example, `javascript:`), the value is ignored.\n *\n * @param {string|undefined} url\n * @param {RegExp} [protocol]\n * @returns {string}\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''))\n\n  if (!protocol) {\n    return value\n  }\n\n  const colon = value.indexOf(':')\n  const questionMark = value.indexOf('?')\n  const numberSign = value.indexOf('#')\n  const slash = value.indexOf('/')\n\n  if (\n    // If there is no protocol, it’s relative.\n    colon < 0 || // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n    (slash > -1 && colon > slash) ||\n    (questionMark > -1 && colon > questionMark) ||\n    (numberSign > -1 && colon > numberSign) || // It is a protocol, it should be allowed.\n    protocol.test(value.slice(0, colon))\n  ) {\n    return value\n  }\n\n  return ''\n}\n/**\n * Normalize a URL (such as used in definitions).\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n * @returns {string}\n */\n\nexport function normalizeUri(value) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n  let start = 0\n  let skip = 0\n\n  while (++index < value.length) {\n    const code = value.charCodeAt(index)\n    /** @type {string} */\n\n    let replace = '' // A correct percent encoded value.\n\n    if (\n      code === 37 &&\n      asciiAlphanumeric(value.charCodeAt(index + 1)) &&\n      asciiAlphanumeric(value.charCodeAt(index + 2))\n    ) {\n      skip = 2\n    } // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code)\n      }\n    } // Astral.\n    else if (code > 55295 && code < 57344) {\n      const next = value.charCodeAt(index + 1) // A correct surrogate pair.\n\n      if (code < 56320 && next > 56319 && next < 57344) {\n        replace = String.fromCharCode(code, next)\n        skip = 1\n      } // Lone surrogate.\n      else {\n        replace = '\\uFFFD'\n      }\n    } // Unicode.\n    else {\n      replace = String.fromCharCode(code)\n    }\n\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace))\n      start = index + skip + 1\n      replace = ''\n    }\n\n    if (skip) {\n      index += skip\n      skip = 0\n    }\n  }\n\n  return result.join('') + value.slice(start)\n}\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').Definition} Definition\n */\n\n/**\n * @typedef {Root | Content} Node\n *\n * @callback GetDefinition\n *   Get a definition by identifier.\n * @param {string | null | undefined} [identifier]\n *   Identifier of definition.\n * @returns {Definition | null}\n *   Definition corresponding to `identifier` or `null`.\n */\n\nimport {visit} from 'unist-util-visit'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Find definitions in `tree`.\n *\n * Uses CommonMark precedence, which means that earlier definitions are\n * preferred over duplicate later definitions.\n *\n * @param {Node} tree\n *   Tree to check.\n * @returns {GetDefinition}\n *   Getter.\n */\nexport function definitions(tree) {\n  /** @type {Record<string, Definition>} */\n  const cache = Object.create(null)\n\n  if (!tree || !tree.type) {\n    throw new Error('mdast-util-definitions expected node')\n  }\n\n  visit(tree, 'definition', (definition) => {\n    const id = clean(definition.identifier)\n    if (id && !own.call(cache, id)) {\n      cache[id] = definition\n    }\n  })\n\n  return definition\n\n  /** @type {GetDefinition} */\n  function definition(identifier) {\n    const id = clean(identifier)\n    // To do: next major: return `undefined` when not found.\n    return id && own.call(cache, id) ? cache[id] : null\n  }\n}\n\n/**\n * @param {string | null | undefined} [value]\n * @returns {string}\n */\nfunction clean(value) {\n  return String(value || '').toUpperCase()\n}\n","/**\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('hast').Element} Element\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `footnoteReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {FootnoteReference} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function footnoteReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const safeId = normalizeUri(id.toLowerCase())\n  const index = state.footnoteOrder.indexOf(id)\n  /** @type {number} */\n  let counter\n\n  if (index === -1) {\n    state.footnoteOrder.push(id)\n    state.footnoteCounts[id] = 1\n    counter = state.footnoteOrder.length\n  } else {\n    state.footnoteCounts[id]++\n    counter = index + 1\n  }\n\n  const reuseCounter = state.footnoteCounts[id]\n\n  /** @type {Element} */\n  const link = {\n    type: 'element',\n    tagName: 'a',\n    properties: {\n      href: '#' + state.clobberPrefix + 'fn-' + safeId,\n      id:\n        state.clobberPrefix +\n        'fnref-' +\n        safeId +\n        (reuseCounter > 1 ? '-' + reuseCounter : ''),\n      dataFootnoteRef: true,\n      ariaDescribedBy: ['footnote-label']\n    },\n    children: [{type: 'text', value: String(counter)}]\n  }\n  state.patch(node, link)\n\n  /** @type {Element} */\n  const sup = {\n    type: 'element',\n    tagName: 'sup',\n    properties: {},\n    children: [link]\n  }\n  state.patch(node, sup)\n  return state.applyData(node, sup)\n}\n","/**\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').Reference} Reference\n * @typedef {import('mdast').Root} Root\n *\n * @typedef {import('./state.js').State} State\n */\n\n/**\n * @typedef {Root | Content} Nodes\n * @typedef {Extract<Nodes, Reference>} References\n */\n\n// To do: next major: always return array.\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @param {State} state\n *   Info passed around.\n * @param {References} node\n *   Reference node (image, link).\n * @returns {ElementContent | Array<ElementContent>}\n *   hast content.\n */\nexport function revert(state, node) {\n  const subtype = node.referenceType\n  let suffix = ']'\n\n  if (subtype === 'collapsed') {\n    suffix += '[]'\n  } else if (subtype === 'full') {\n    suffix += '[' + (node.label || node.identifier) + ']'\n  }\n\n  if (node.type === 'imageReference') {\n    return {type: 'text', value: '![' + node.alt + suffix}\n  }\n\n  const contents = state.all(node)\n  const head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift({type: 'text', value: '['})\n  }\n\n  const tail = contents[contents.length - 1]\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix\n  } else {\n    contents.push({type: 'text', value: suffix})\n  }\n\n  return contents\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').Root} Root\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * @typedef {Root | Content} Nodes\n * @typedef {Extract<Nodes, Parent>} Parents\n */\n\n/**\n * Turn an mdast `listItem` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ListItem} node\n *   mdast node.\n * @param {Parents | null | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function listItem(state, node, parent) {\n  const results = state.all(node)\n  const loose = parent ? listLoose(parent) : listItemLoose(node)\n  /** @type {Properties} */\n  const properties = {}\n  /** @type {Array<ElementContent>} */\n  const children = []\n\n  if (typeof node.checked === 'boolean') {\n    const head = results[0]\n    /** @type {Element} */\n    let paragraph\n\n    if (head && head.type === 'element' && head.tagName === 'p') {\n      paragraph = head\n    } else {\n      paragraph = {type: 'element', tagName: 'p', properties: {}, children: []}\n      results.unshift(paragraph)\n    }\n\n    if (paragraph.children.length > 0) {\n      paragraph.children.unshift({type: 'text', value: ' '})\n    }\n\n    paragraph.children.unshift({\n      type: 'element',\n      tagName: 'input',\n      properties: {type: 'checkbox', checked: node.checked, disabled: true},\n      children: []\n    })\n\n    // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n    properties.className = ['task-list-item']\n  }\n\n  let index = -1\n\n  while (++index < results.length) {\n    const child = results[index]\n\n    // Add eols before nodes, except if this is a loose, first paragraph.\n    if (\n      loose ||\n      index !== 0 ||\n      child.type !== 'element' ||\n      child.tagName !== 'p'\n    ) {\n      children.push({type: 'text', value: '\\n'})\n    }\n\n    if (child.type === 'element' && child.tagName === 'p' && !loose) {\n      children.push(...child.children)\n    } else {\n      children.push(child)\n    }\n  }\n\n  const tail = results[results.length - 1]\n\n  // Add a final eol.\n  if (tail && (loose || tail.type !== 'element' || tail.tagName !== 'p')) {\n    children.push({type: 'text', value: '\\n'})\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'li', properties, children}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * @param {Parents} node\n * @return {Boolean}\n */\nfunction listLoose(node) {\n  let loose = false\n  if (node.type === 'list') {\n    loose = node.spread || false\n    const children = node.children\n    let index = -1\n\n    while (!loose && ++index < children.length) {\n      loose = listItemLoose(children[index])\n    }\n  }\n\n  return loose\n}\n\n/**\n * @param {ListItem} node\n * @return {Boolean}\n */\nfunction listItemLoose(node) {\n  const spread = node.spread\n\n  return spread === undefined || spread === null\n    ? node.children.length > 1\n    : spread\n}\n","import {blockquote} from './blockquote.js'\nimport {hardBreak} from './break.js'\nimport {code} from './code.js'\nimport {strikethrough} from './delete.js'\nimport {emphasis} from './emphasis.js'\nimport {footnoteReference} from './footnote-reference.js'\nimport {footnote} from './footnote.js'\nimport {heading} from './heading.js'\nimport {html} from './html.js'\nimport {imageReference} from './image-reference.js'\nimport {image} from './image.js'\nimport {inlineCode} from './inline-code.js'\nimport {linkReference} from './link-reference.js'\nimport {link} from './link.js'\nimport {listItem} from './list-item.js'\nimport {list} from './list.js'\nimport {paragraph} from './paragraph.js'\nimport {root} from './root.js'\nimport {strong} from './strong.js'\nimport {table} from './table.js'\nimport {tableRow} from './table-row.js'\nimport {tableCell} from './table-cell.js'\nimport {text} from './text.js'\nimport {thematicBreak} from './thematic-break.js'\n\n/**\n * Default handlers for nodes.\n */\nexport const handlers = {\n  blockquote,\n  break: hardBreak,\n  code,\n  delete: strikethrough,\n  emphasis,\n  footnoteReference,\n  footnote,\n  heading,\n  html,\n  imageReference,\n  image,\n  inlineCode,\n  linkReference,\n  link,\n  listItem,\n  list,\n  paragraph,\n  root,\n  strong,\n  table,\n  tableCell,\n  tableRow,\n  text,\n  thematicBreak,\n  toml: ignore,\n  yaml: ignore,\n  definition: ignore,\n  footnoteDefinition: ignore\n}\n\n// Return nothing for nodes that are ignored.\nfunction ignore() {\n  // To do: next major: return `undefined`.\n  return null\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `blockquote` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Blockquote} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function blockquote(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'blockquote',\n    properties: {},\n    children: state.wrap(state.all(node), true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').Break} Break\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `break` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Break} node\n *   mdast node.\n * @returns {Array<Element | Text>}\n *   hast element content.\n */\nexport function hardBreak(state, node) {\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'br', properties: {}, children: []}\n  state.patch(node, result)\n  return [state.applyData(node, result), {type: 'text', value: '\\n'}]\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Code} Code\n * @typedef {import('../state.js').State} State\n\n */\n\n/**\n * Turn an mdast `code` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Code} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function code(state, node) {\n  const value = node.value ? node.value + '\\n' : ''\n  // To do: next major, use `node.lang` w/o regex, the splitting’s been going\n  // on for years in remark now.\n  const lang = node.lang ? node.lang.match(/^[^ \\t]+(?=[ \\t]|$)/) : null\n  /** @type {Properties} */\n  const properties = {}\n\n  if (lang) {\n    properties.className = ['language-' + lang]\n  }\n\n  // Create `<code>`.\n  /** @type {Element} */\n  let result = {\n    type: 'element',\n    tagName: 'code',\n    properties,\n    children: [{type: 'text', value}]\n  }\n\n  if (node.meta) {\n    result.data = {meta: node.meta}\n  }\n\n  state.patch(node, result)\n  result = state.applyData(node, result)\n\n  // Create `<pre>`.\n  result = {type: 'element', tagName: 'pre', properties: {}, children: [result]}\n  state.patch(node, result)\n  return result\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Delete} Delete\n * @typedef {import('../state.js').State} State\n\n */\n\n/**\n * Turn an mdast `delete` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Delete} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strikethrough(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'del',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `emphasis` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Emphasis} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function emphasis(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'em',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Footnote} Footnote\n * @typedef {import('../state.js').State} State\n */\n\nimport {footnoteReference} from './footnote-reference.js'\n\n// To do: when both:\n// * <https://github.com/micromark/micromark-extension-footnote>\n// * <https://github.com/syntax-tree/mdast-util-footnote>\n// …are archived, remove this (also from mdast).\n// These inline notes are not used in GFM.\n\n/**\n * Turn an mdast `footnote` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Footnote} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function footnote(state, node) {\n  const footnoteById = state.footnoteById\n  let no = 1\n\n  while (no in footnoteById) no++\n\n  const identifier = String(no)\n\n  footnoteById[identifier] = {\n    type: 'footnoteDefinition',\n    identifier,\n    children: [{type: 'paragraph', children: node.children}],\n    position: node.position\n  }\n\n  return footnoteReference(state, {\n    type: 'footnoteReference',\n    identifier,\n    position: node.position\n  })\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `heading` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Heading} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function heading(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'h' + node.depth,\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').HTML} Html\n * @typedef {import('../state.js').State} State\n * @typedef {import('../../index.js').Raw} Raw\n */\n\n/**\n * Turn an mdast `html` node into hast (`raw` node in dangerous mode, otherwise\n * nothing).\n *\n * @param {State} state\n *   Info passed around.\n * @param {Html} node\n *   mdast node.\n * @returns {Raw | Element | null}\n *   hast node.\n */\nexport function html(state, node) {\n  if (state.dangerous) {\n    /** @type {Raw} */\n    const result = {type: 'raw', value: node.value}\n    state.patch(node, result)\n    return state.applyData(node, result)\n  }\n\n  // To do: next major: return `undefined`.\n  return null\n}\n","/**\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `imageReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ImageReference} node\n *   mdast node.\n * @returns {ElementContent | Array<ElementContent>}\n *   hast node.\n */\nexport function imageReference(state, node) {\n  const def = state.definition(node.identifier)\n\n  if (!def) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(def.url || ''), alt: node.alt}\n\n  if (def.title !== null && def.title !== undefined) {\n    properties.title = def.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Image} Image\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `image` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Image} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function image(state, node) {\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(node.url)}\n\n  if (node.alt !== null && node.alt !== undefined) {\n    properties.alt = node.alt\n  }\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `inlineCode` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {InlineCode} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function inlineCode(state, node) {\n  /** @type {Text} */\n  const text = {type: 'text', value: node.value.replace(/\\r?\\n|\\r/g, ' ')}\n  state.patch(node, text)\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'code',\n    properties: {},\n    children: [text]\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `linkReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {LinkReference} node\n *   mdast node.\n * @returns {ElementContent | Array<ElementContent>}\n *   hast node.\n */\nexport function linkReference(state, node) {\n  const def = state.definition(node.identifier)\n\n  if (!def) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(def.url || '')}\n\n  if (def.title !== null && def.title !== undefined) {\n    properties.title = def.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Link} Link\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `link` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Link} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function link(state, node) {\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(node.url)}\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').List} List\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `list` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {List} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function list(state, node) {\n  /** @type {Properties} */\n  const properties = {}\n  const results = state.all(node)\n  let index = -1\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    properties.start = node.start\n  }\n\n  // Like GitHub, add a class for custom styling.\n  while (++index < results.length) {\n    const child = results[index]\n\n    if (\n      child.type === 'element' &&\n      child.tagName === 'li' &&\n      child.properties &&\n      Array.isArray(child.properties.className) &&\n      child.properties.className.includes('task-list-item')\n    ) {\n      properties.className = ['contains-task-list']\n      break\n    }\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: node.ordered ? 'ol' : 'ul',\n    properties,\n    children: state.wrap(results, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `paragraph` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Paragraph} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function paragraph(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'p',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `root` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastRoot} node\n *   mdast node.\n * @returns {HastRoot | HastElement}\n *   hast node.\n */\nexport function root(state, node) {\n  /** @type {HastRoot} */\n  const result = {type: 'root', children: state.wrap(state.all(node))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `strong` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Strong} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strong(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'strong',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Table} Table\n * @typedef {import('../state.js').State} State\n */\n\nimport {pointStart, pointEnd} from 'unist-util-position'\n\n/**\n * Turn an mdast `table` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Table} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function table(state, node) {\n  const rows = state.all(node)\n  const firstRow = rows.shift()\n  /** @type {Array<Element>} */\n  const tableContent = []\n\n  if (firstRow) {\n    /** @type {Element} */\n    const head = {\n      type: 'element',\n      tagName: 'thead',\n      properties: {},\n      children: state.wrap([firstRow], true)\n    }\n    state.patch(node.children[0], head)\n    tableContent.push(head)\n  }\n\n  if (rows.length > 0) {\n    /** @type {Element} */\n    const body = {\n      type: 'element',\n      tagName: 'tbody',\n      properties: {},\n      children: state.wrap(rows, true)\n    }\n\n    const start = pointStart(node.children[1])\n    const end = pointEnd(node.children[node.children.length - 1])\n    if (start.line && end.line) body.position = {start, end}\n    tableContent.push(body)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'table',\n    properties: {},\n    children: state.wrap(tableContent, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `tableCell` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableCell} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function tableCell(state, node) {\n  // Note: this function is normally not called: see `table-row` for how rows\n  // and their cells are compiled.\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'td', // Assume body cell.\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').TableRow} TableRow\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * @typedef {Root | Content} Nodes\n * @typedef {Extract<Nodes, Parent>} Parents\n */\n\n/**\n * Turn an mdast `tableRow` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableRow} node\n *   mdast node.\n * @param {Parents | null | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function tableRow(state, node, parent) {\n  const siblings = parent ? parent.children : undefined\n  // Generate a body row when without parent.\n  const rowIndex = siblings ? siblings.indexOf(node) : 1\n  const tagName = rowIndex === 0 ? 'th' : 'td'\n  const align = parent && parent.type === 'table' ? parent.align : undefined\n  const length = align ? align.length : node.children.length\n  let cellIndex = -1\n  /** @type {Array<ElementContent>} */\n  const cells = []\n\n  while (++cellIndex < length) {\n    // Note: can also be undefined.\n    const cell = node.children[cellIndex]\n    /** @type {Properties} */\n    const properties = {}\n    const alignValue = align ? align[cellIndex] : undefined\n\n    if (alignValue) {\n      properties.align = alignValue\n    }\n\n    /** @type {Element} */\n    let result = {type: 'element', tagName, properties, children: []}\n\n    if (cell) {\n      result.children = state.all(cell)\n      state.patch(cell, result)\n      result = state.applyData(node, result)\n    }\n\n    cells.push(result)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'tr',\n    properties: {},\n    children: state.wrap(cells, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').Text} HastText\n * @typedef {import('mdast').Text} MdastText\n * @typedef {import('../state.js').State} State\n */\n\nimport {trimLines} from 'trim-lines'\n\n/**\n * Turn an mdast `text` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastText} node\n *   mdast node.\n * @returns {HastText | HastElement}\n *   hast node.\n */\nexport function text(state, node) {\n  /** @type {HastText} */\n  const result = {type: 'text', value: trimLines(String(node.value))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * Turn an mdast `thematicBreak` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ThematicBreak} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function thematicBreak(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'hr',\n    properties: {},\n    children: []\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Content} HastContent\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').ElementContent} HastElementContent\n * @typedef {import('hast').Properties} HastProperties\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('hast').Text} HastText\n *\n * @typedef {import('mdast').Content} MdastContent\n * @typedef {import('mdast').Definition} MdastDefinition\n * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition\n * @typedef {import('mdast').Parent} MdastParent\n * @typedef {import('mdast').Root} MdastRoot\n */\n\n/**\n * @typedef {HastRoot | HastContent} HastNodes\n * @typedef {MdastRoot | MdastContent} MdastNodes\n * @typedef {Extract<MdastNodes, MdastParent>} MdastParents\n *\n * @typedef EmbeddedHastFields\n *   hast fields.\n * @property {string | null | undefined} [hName]\n *   Generate a specific element with this tag name instead.\n * @property {HastProperties | null | undefined} [hProperties]\n *   Generate an element with these properties instead.\n * @property {Array<HastElementContent> | null | undefined} [hChildren]\n *   Generate an element with this content instead.\n *\n * @typedef {Record<string, unknown> & EmbeddedHastFields} MdastData\n *   mdast data with embedded hast fields.\n *\n * @typedef {MdastNodes & {data?: MdastData | null | undefined}} MdastNodeWithData\n *   mdast node with embedded hast data.\n *\n * @typedef PointLike\n *   Point-like value.\n * @property {number | null | undefined} [line]\n *   Line.\n * @property {number | null | undefined} [column]\n *   Column.\n * @property {number | null | undefined} [offset]\n *   Offset.\n *\n * @typedef PositionLike\n *   Position-like value.\n * @property {PointLike | null | undefined} [start]\n *   Point-like value.\n * @property {PointLike | null | undefined} [end]\n *   Point-like value.\n *\n * @callback Handler\n *   Handle a node.\n * @param {State} state\n *   Info passed around.\n * @param {any} node\n *   mdast node to handle.\n * @param {MdastParents | null | undefined} parent\n *   Parent of `node`.\n * @returns {HastElementContent | Array<HastElementContent> | null | undefined}\n *   hast node.\n *\n * @callback HFunctionProps\n *   Signature of `state` for when props are passed.\n * @param {MdastNodes | PositionLike | null | undefined} node\n *   mdast node or unist position.\n * @param {string} tagName\n *   HTML tag name.\n * @param {HastProperties} props\n *   Properties.\n * @param {Array<HastElementContent> | null | undefined} [children]\n *   hast content.\n * @returns {HastElement}\n *   Compiled element.\n *\n * @callback HFunctionNoProps\n *   Signature of `state` for when no props are passed.\n * @param {MdastNodes | PositionLike | null | undefined} node\n *   mdast node or unist position.\n * @param {string} tagName\n *   HTML tag name.\n * @param {Array<HastElementContent> | null | undefined} [children]\n *   hast content.\n * @returns {HastElement}\n *   Compiled element.\n *\n * @typedef HFields\n *   Info on `state`.\n * @property {boolean} dangerous\n *   Whether HTML is allowed.\n * @property {string} clobberPrefix\n *   Prefix to use to prevent DOM clobbering.\n * @property {string} footnoteLabel\n *   Label to use to introduce the footnote section.\n * @property {string} footnoteLabelTagName\n *   HTML used for the footnote label.\n * @property {HastProperties} footnoteLabelProperties\n *   Properties on the HTML tag used for the footnote label.\n * @property {string} footnoteBackLabel\n *   Label to use from backreferences back to their footnote call.\n * @property {(identifier: string) => MdastDefinition | null} definition\n *   Definition cache.\n * @property {Record<string, MdastFootnoteDefinition>} footnoteById\n *   Footnote definitions by their identifier.\n * @property {Array<string>} footnoteOrder\n *   Identifiers of order when footnote calls first appear in tree order.\n * @property {Record<string, number>} footnoteCounts\n *   Counts for how often the same footnote was called.\n * @property {Handlers} handlers\n *   Applied handlers.\n * @property {Handler} unknownHandler\n *   Handler for any none not in `passThrough` or otherwise handled.\n * @property {(from: MdastNodes, node: HastNodes) => void} patch\n *   Copy a node’s positional info.\n * @property {<Type extends HastNodes>(from: MdastNodes, to: Type) => Type | HastElement} applyData\n *   Honor the `data` of `from`, and generate an element instead of `node`.\n * @property {(node: MdastNodes, parent: MdastParents | null | undefined) => HastElementContent | Array<HastElementContent> | null | undefined} one\n *   Transform an mdast node to hast.\n * @property {(node: MdastNodes) => Array<HastElementContent>} all\n *   Transform the children of an mdast parent to hast.\n * @property {<Type extends HastContent>(nodes: Array<Type>, loose?: boolean | null | undefined) => Array<Type | HastText>} wrap\n *   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.\n * @property {(left: MdastNodeWithData | PositionLike | null | undefined, right: HastElementContent) => HastElementContent} augment\n *   Like `state` but lower-level and usable on non-elements.\n *   Deprecated: use `patch` and `applyData`.\n * @property {Array<string>} passThrough\n *   List of node types to pass through untouched (except for their children).\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [allowDangerousHtml=false]\n *   Whether to persist raw HTML in markdown in the hast tree.\n * @property {string | null | undefined} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` attribute on footnotes to prevent it from\n *   *clobbering*.\n * @property {string | null | undefined} [footnoteBackLabel='Back to content']\n *   Label to use from backreferences back to their footnote call (affects\n *   screen readers).\n * @property {string | null | undefined} [footnoteLabel='Footnotes']\n *   Label to use for the footnotes section (affects screen readers).\n * @property {HastProperties | null | undefined} [footnoteLabelProperties={className: ['sr-only']}]\n *   Properties to use on the footnote label (note that `id: 'footnote-label'`\n *   is always added as footnote calls use it with `aria-describedby` to\n *   provide an accessible label).\n * @property {string | null | undefined} [footnoteLabelTagName='h2']\n *   Tag name to use for the footnote label.\n * @property {Handlers | null | undefined} [handlers]\n *   Extra handlers for nodes.\n * @property {Array<string> | null | undefined} [passThrough]\n *   List of custom mdast node types to pass through (keep) in hast (note that\n *   the node itself is passed, but eventual children are transformed).\n * @property {Handler | null | undefined} [unknownHandler]\n *   Handler for all unknown nodes.\n *\n * @typedef {Record<string, Handler>} Handlers\n *   Handle nodes.\n *\n * @typedef {HFunctionProps & HFunctionNoProps & HFields} State\n *   Info passed around.\n */\n\nimport {visit} from 'unist-util-visit'\nimport {position, pointStart, pointEnd} from 'unist-util-position'\nimport {generated} from 'unist-util-generated'\nimport {definitions} from 'mdast-util-definitions'\nimport {handlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Create `state` from an mdast tree.\n *\n * @param {MdastNodes} tree\n *   mdast node to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {State}\n *   `state` function.\n */\nexport function createState(tree, options) {\n  const settings = options || {}\n  const dangerous = settings.allowDangerousHtml || false\n  /** @type {Record<string, MdastFootnoteDefinition>} */\n  const footnoteById = {}\n\n  // To do: next major: add `options` to state, remove:\n  // `dangerous`, `clobberPrefix`, `footnoteLabel`, `footnoteLabelTagName`,\n  // `footnoteLabelProperties`, `footnoteBackLabel`, `passThrough`,\n  // `unknownHandler`.\n\n  // To do: next major: move to `state.options.allowDangerousHtml`.\n  state.dangerous = dangerous\n  // To do: next major: move to `state.options`.\n  state.clobberPrefix =\n    settings.clobberPrefix === undefined || settings.clobberPrefix === null\n      ? 'user-content-'\n      : settings.clobberPrefix\n  // To do: next major: move to `state.options`.\n  state.footnoteLabel = settings.footnoteLabel || 'Footnotes'\n  // To do: next major: move to `state.options`.\n  state.footnoteLabelTagName = settings.footnoteLabelTagName || 'h2'\n  // To do: next major: move to `state.options`.\n  state.footnoteLabelProperties = settings.footnoteLabelProperties || {\n    className: ['sr-only']\n  }\n  // To do: next major: move to `state.options`.\n  state.footnoteBackLabel = settings.footnoteBackLabel || 'Back to content'\n  // To do: next major: move to `state.options`.\n  state.unknownHandler = settings.unknownHandler\n  // To do: next major: move to `state.options`.\n  state.passThrough = settings.passThrough\n\n  state.handlers = {...handlers, ...settings.handlers}\n\n  // To do: next major: replace utility with `definitionById` object, so we\n  // only walk once (as we need footnotes too).\n  state.definition = definitions(tree)\n  state.footnoteById = footnoteById\n  /** @type {Array<string>} */\n  state.footnoteOrder = []\n  /** @type {Record<string, number>} */\n  state.footnoteCounts = {}\n\n  state.patch = patch\n  state.applyData = applyData\n  state.one = oneBound\n  state.all = allBound\n  state.wrap = wrap\n  // To do: next major: remove `augment`.\n  state.augment = augment\n\n  visit(tree, 'footnoteDefinition', (definition) => {\n    const id = String(definition.identifier).toUpperCase()\n\n    // Mimick CM behavior of link definitions.\n    // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/8290999/index.js#L26>.\n    if (!own.call(footnoteById, id)) {\n      footnoteById[id] = definition\n    }\n  })\n\n  // @ts-expect-error Hush, it’s fine!\n  return state\n\n  /**\n   * Finalise the created `right`, a hast node, from `left`, an mdast node.\n   *\n   * @param {MdastNodeWithData | PositionLike | null | undefined} left\n   * @param {HastElementContent} right\n   * @returns {HastElementContent}\n   */\n  /* c8 ignore start */\n  // To do: next major: remove.\n  function augment(left, right) {\n    // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n    if (left && 'data' in left && left.data) {\n      /** @type {MdastData} */\n      const data = left.data\n\n      if (data.hName) {\n        if (right.type !== 'element') {\n          right = {\n            type: 'element',\n            tagName: '',\n            properties: {},\n            children: []\n          }\n        }\n\n        right.tagName = data.hName\n      }\n\n      if (right.type === 'element' && data.hProperties) {\n        right.properties = {...right.properties, ...data.hProperties}\n      }\n\n      if ('children' in right && right.children && data.hChildren) {\n        right.children = data.hChildren\n      }\n    }\n\n    if (left) {\n      const ctx = 'type' in left ? left : {position: left}\n\n      if (!generated(ctx)) {\n        // @ts-expect-error: fine.\n        right.position = {start: pointStart(ctx), end: pointEnd(ctx)}\n      }\n    }\n\n    return right\n  }\n  /* c8 ignore stop */\n\n  /**\n   * Create an element for `node`.\n   *\n   * @type {HFunctionProps}\n   */\n  /* c8 ignore start */\n  // To do: next major: remove.\n  function state(node, tagName, props, children) {\n    if (Array.isArray(props)) {\n      children = props\n      props = {}\n    }\n\n    // @ts-expect-error augmenting an element yields an element.\n    return augment(node, {\n      type: 'element',\n      tagName,\n      properties: props || {},\n      children: children || []\n    })\n  }\n  /* c8 ignore stop */\n\n  /**\n   * Transform an mdast node into a hast node.\n   *\n   * @param {MdastNodes} node\n   *   mdast node.\n   * @param {MdastParents | null | undefined} [parent]\n   *   Parent of `node`.\n   * @returns {HastElementContent | Array<HastElementContent> | null | undefined}\n   *   Resulting hast node.\n   */\n  function oneBound(node, parent) {\n    // @ts-expect-error: that’s a state :)\n    return one(state, node, parent)\n  }\n\n  /**\n   * Transform the children of an mdast node into hast nodes.\n   *\n   * @param {MdastNodes} parent\n   *   mdast node to compile\n   * @returns {Array<HastElementContent>}\n   *   Resulting hast nodes.\n   */\n  function allBound(parent) {\n    // @ts-expect-error: that’s a state :)\n    return all(state, parent)\n  }\n}\n\n/**\n * Copy a node’s positional info.\n *\n * @param {MdastNodes} from\n *   mdast node to copy from.\n * @param {HastNodes} to\n *   hast node to copy into.\n * @returns {void}\n *   Nothing.\n */\nfunction patch(from, to) {\n  if (from.position) to.position = position(from)\n}\n\n/**\n * Honor the `data` of `from` and maybe generate an element instead of `to`.\n *\n * @template {HastNodes} Type\n *   Node type.\n * @param {MdastNodes} from\n *   mdast node to use data from.\n * @param {Type} to\n *   hast node to change.\n * @returns {Type | HastElement}\n *   Nothing.\n */\nfunction applyData(from, to) {\n  /** @type {Type | HastElement} */\n  let result = to\n\n  // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n  if (from && from.data) {\n    const hName = from.data.hName\n    const hChildren = from.data.hChildren\n    const hProperties = from.data.hProperties\n\n    if (typeof hName === 'string') {\n      // Transforming the node resulted in an element with a different name\n      // than wanted:\n      if (result.type === 'element') {\n        result.tagName = hName\n      }\n      // Transforming the node resulted in a non-element, which happens for\n      // raw, text, and root nodes (unless custom handlers are passed).\n      // The intent is likely to keep the content around (otherwise: pass\n      // `hChildren`).\n      else {\n        result = {\n          type: 'element',\n          tagName: hName,\n          properties: {},\n          children: []\n        }\n\n        // To do: next major: take the children from the `root`, or inject the\n        // raw/text/comment or so into the element?\n        // if ('children' in node) {\n        //   // @ts-expect-error: assume `children` are allowed in elements.\n        //   result.children = node.children\n        // } else {\n        //   // @ts-expect-error: assume `node` is allowed in elements.\n        //   result.children.push(node)\n        // }\n      }\n    }\n\n    if (result.type === 'element' && hProperties) {\n      result.properties = {...result.properties, ...hProperties}\n    }\n\n    if (\n      'children' in result &&\n      result.children &&\n      hChildren !== null &&\n      hChildren !== undefined\n    ) {\n      // @ts-expect-error: assume valid children are defined.\n      result.children = hChildren\n    }\n  }\n\n  return result\n}\n\n/**\n * Transform an mdast node into a hast node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} node\n *   mdast node.\n * @param {MdastParents | null | undefined} [parent]\n *   Parent of `node`.\n * @returns {HastElementContent | Array<HastElementContent> | null | undefined}\n *   Resulting hast node.\n */\n// To do: next major: do not expose, keep bound.\nexport function one(state, node, parent) {\n  const type = node && node.type\n\n  // Fail on non-nodes.\n  if (!type) {\n    throw new Error('Expected node, got `' + node + '`')\n  }\n\n  if (own.call(state.handlers, type)) {\n    return state.handlers[type](state, node, parent)\n  }\n\n  if (state.passThrough && state.passThrough.includes(type)) {\n    // To do: next major: deep clone.\n    // @ts-expect-error: types of passed through nodes are expected to be added manually.\n    return 'children' in node ? {...node, children: all(state, node)} : node\n  }\n\n  if (state.unknownHandler) {\n    return state.unknownHandler(state, node, parent)\n  }\n\n  return defaultUnknownHandler(state, node)\n}\n\n/**\n * Transform the children of an mdast node into hast nodes.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} parent\n *   mdast node to compile\n * @returns {Array<HastElementContent>}\n *   Resulting hast nodes.\n */\n// To do: next major: do not expose, keep bound.\nexport function all(state, parent) {\n  /** @type {Array<HastElementContent>} */\n  const values = []\n\n  if ('children' in parent) {\n    const nodes = parent.children\n    let index = -1\n    while (++index < nodes.length) {\n      const result = one(state, nodes[index], parent)\n\n      // To do: see if we van clean this? Can we merge texts?\n      if (result) {\n        if (index && nodes[index - 1].type === 'break') {\n          if (!Array.isArray(result) && result.type === 'text') {\n            result.value = result.value.replace(/^\\s+/, '')\n          }\n\n          if (!Array.isArray(result) && result.type === 'element') {\n            const head = result.children[0]\n\n            if (head && head.type === 'text') {\n              head.value = head.value.replace(/^\\s+/, '')\n            }\n          }\n        }\n\n        if (Array.isArray(result)) {\n          values.push(...result)\n        } else {\n          values.push(result)\n        }\n      }\n    }\n  }\n\n  return values\n}\n\n/**\n * Transform an unknown node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} node\n *   Unknown mdast node.\n * @returns {HastText | HastElement}\n *   Resulting hast node.\n */\nfunction defaultUnknownHandler(state, node) {\n  const data = node.data || {}\n  /** @type {HastText | HastElement} */\n  const result =\n    'value' in node &&\n    !(own.call(data, 'hProperties') || own.call(data, 'hChildren'))\n      ? {type: 'text', value: node.value}\n      : {\n          type: 'element',\n          tagName: 'div',\n          properties: {},\n          children: all(state, node)\n        }\n\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * Wrap `nodes` with line endings between each node.\n *\n * @template {HastContent} Type\n *   Node type.\n * @param {Array<Type>} nodes\n *   List of nodes to wrap.\n * @param {boolean | null | undefined} [loose=false]\n *   Whether to add line endings at start and end.\n * @returns {Array<Type | HastText>}\n *   Wrapped nodes.\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<Type | HastText>} */\n  const result = []\n  let index = -1\n\n  if (loose) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  while (++index < nodes.length) {\n    if (index) result.push({type: 'text', value: '\\n'})\n    result.push(nodes[index])\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  return result\n}\n","/**\n * @typedef {import('hast').Content} HastContent\n * @typedef {import('hast').Root} HastRoot\n *\n * @typedef {import('mdast').Content} MdastContent\n * @typedef {import('mdast').Root} MdastRoot\n *\n * @typedef {import('./state.js').Options} Options\n */\n\n/**\n * @typedef {HastRoot | HastContent} HastNodes\n * @typedef {MdastRoot | MdastContent} MdastNodes\n */\n\nimport {footer} from './footer.js'\nimport {createState} from './state.js'\n\n/**\n * Transform mdast to hast.\n *\n * ##### Notes\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most utilities ignore `raw` nodes but two notable ones don’t:\n *\n * *   `hast-util-to-html` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful\n *     if you completely trust authors\n * *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only\n *     way to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `mdast-util-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * Example: headings (DOM clobbering) in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @param {MdastNodes} tree\n *   mdast tree.\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {HastNodes | null | undefined}\n *   hast tree.\n */\n// To do: next major: always return a single `root`.\nexport function toHast(tree, options) {\n  const state = createState(tree, options)\n  const node = state.one(tree, null)\n  const foot = footer(state)\n\n  if (foot) {\n    // @ts-expect-error If there’s a footer, there were definitions, meaning block\n    // content.\n    // So assume `node` is a parent node.\n    node.children.push({type: 'text', value: '\\n'}, foot)\n  }\n\n  // To do: next major: always return root?\n  return Array.isArray(node) ? {type: 'root', children: node} : node\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('./state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Generate a hast footer for called footnote definitions.\n *\n * @param {State} state\n *   Info passed around.\n * @returns {Element | undefined}\n *   `section` element or `undefined`.\n */\nexport function footer(state) {\n  /** @type {Array<ElementContent>} */\n  const listItems = []\n  let index = -1\n\n  while (++index < state.footnoteOrder.length) {\n    const def = state.footnoteById[state.footnoteOrder[index]]\n\n    if (!def) {\n      continue\n    }\n\n    const content = state.all(def)\n    const id = String(def.identifier).toUpperCase()\n    const safeId = normalizeUri(id.toLowerCase())\n    let referenceIndex = 0\n    /** @type {Array<ElementContent>} */\n    const backReferences = []\n\n    while (++referenceIndex <= state.footnoteCounts[id]) {\n      /** @type {Element} */\n      const backReference = {\n        type: 'element',\n        tagName: 'a',\n        properties: {\n          href:\n            '#' +\n            state.clobberPrefix +\n            'fnref-' +\n            safeId +\n            (referenceIndex > 1 ? '-' + referenceIndex : ''),\n          dataFootnoteBackref: true,\n          className: ['data-footnote-backref'],\n          ariaLabel: state.footnoteBackLabel\n        },\n        children: [{type: 'text', value: '↩'}]\n      }\n\n      if (referenceIndex > 1) {\n        backReference.children.push({\n          type: 'element',\n          tagName: 'sup',\n          children: [{type: 'text', value: String(referenceIndex)}]\n        })\n      }\n\n      if (backReferences.length > 0) {\n        backReferences.push({type: 'text', value: ' '})\n      }\n\n      backReferences.push(backReference)\n    }\n\n    const tail = content[content.length - 1]\n\n    if (tail && tail.type === 'element' && tail.tagName === 'p') {\n      const tailTail = tail.children[tail.children.length - 1]\n      if (tailTail && tailTail.type === 'text') {\n        tailTail.value += ' '\n      } else {\n        tail.children.push({type: 'text', value: ' '})\n      }\n\n      tail.children.push(...backReferences)\n    } else {\n      content.push(...backReferences)\n    }\n\n    /** @type {Element} */\n    const listItem = {\n      type: 'element',\n      tagName: 'li',\n      properties: {id: state.clobberPrefix + 'fn-' + safeId},\n      children: state.wrap(content, true)\n    }\n\n    state.patch(def, listItem)\n\n    listItems.push(listItem)\n  }\n\n  if (listItems.length === 0) {\n    return\n  }\n\n  return {\n    type: 'element',\n    tagName: 'section',\n    properties: {dataFootnotes: true, className: ['footnotes']},\n    children: [\n      {\n        type: 'element',\n        tagName: state.footnoteLabelTagName,\n        properties: {\n          // To do: use structured clone.\n          ...JSON.parse(JSON.stringify(state.footnoteLabelProperties)),\n          id: 'footnote-label'\n        },\n        children: [{type: 'text', value: state.footnoteLabel}]\n      },\n      {type: 'text', value: '\\n'},\n      {\n        type: 'element',\n        tagName: 'ol',\n        properties: {},\n        children: state.wrap(listItems, true)\n      },\n      {type: 'text', value: '\\n'}\n    ]\n  }\n}\n","// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\nexport const unicodePunctuationRegex =\n  /[!-/:-@[-`{-~\\u00A1\\u00A7\\u00AB\\u00B6\\u00B7\\u00BB\\u00BF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {unicodePunctuationRegex} from './lib/unicode-punctuation-regex.js'\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n */\n\nexport const asciiAlpha = regexCheck(/[A-Za-z]/)\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n */\n\nexport const asciiDigit = regexCheck(/\\d/)\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n */\n\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n */\n\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n */\n\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n */\n\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  )\n}\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32)\n}\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2\n}\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\n}\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n */\n\nexport const unicodeWhitespace = regexCheck(/\\s/)\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n */\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n\nexport const unicodePunctuation = regexCheck(unicodePunctuationRegex)\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => code is number}\n */\n\nfunction regexCheck(regex) {\n  return check\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code Character code\n   * @returns {code is number} Whether the character code matches the bound regex\n   */\n\n  function check(code) {\n    return code !== null && regex.test(String.fromCharCode(code))\n  }\n}\n"],"names":["HandshakeProtocol","writeHandshakeRequest","handshakeRequest","TextMessageFormat","write","JSON","stringify","parseHandshakeResponse","data","messageData","remainingData","binaryData","Uint8Array","separatorIndex","indexOf","RecordSeparatorCode","Error","responseLength","String","fromCharCode","apply","Array","prototype","slice","call","byteLength","buffer","textData","RecordSeparator","substring","length","messages","parse","response","type","HubConnectionState","Subject","constructor","this","observers","next","item","observer","error","err","complete","subscribe","push","HubConnection","connection","logger","protocol","reconnectPolicy","_nextKeepAlive","_freezeEventListener","_logger","log","Warning","isRequired","serverTimeoutInMilliseconds","keepAliveIntervalInMilliseconds","_protocol","_reconnectPolicy","_handshakeProtocol","onreceive","_processIncomingData","onclose","_connectionClosed","_callbacks","_methods","_closedCallbacks","_reconnectingCallbacks","_reconnectedCallbacks","_invocationId","_receivedHandshakeResponse","_connectionState","Disconnected","_connectionStarted","_cachedPingMessage","writeMessage","Ping","create","state","connectionId","baseUrl","url","Reconnecting","start","_startPromise","_startWithStateTransitions","Promise","reject","Connecting","Debug","_startInternal","isBrowser","window","document","addEventListener","Connected","e","_stopDuringStartError","undefined","handshakePromise","resolve","_handshakeResolver","_handshakeRejecter","transferFormat","name","version","_sendMessage","Information","_cleanupTimeout","_resetTimeoutPeriod","_resetKeepAliveInterval","_cleanupPingTimer","stop","startPromise","_stopPromise","_stopInternal","Disconnecting","_reconnectDelayHandle","clearTimeout","_completeClose","stream","methodName","args","streams","streamIds","_replaceStreamingParams","invocationDescriptor","_createStreamInvocation","promiseQueue","subject","cancelCallback","cancelInvocation","_createCancelInvocation","invocationId","then","_sendWithProtocol","invocationEvent","Completion","catch","_launchStreams","message","send","sendPromise","_createInvocation","invoke","result","on","newMethod","toLowerCase","off","method","handlers","removeIdx","splice","callback","onreconnecting","onreconnected","_processHandshakeResponse","parseMessages","Invocation","_invokeClientMethod","StreamItem","Close","allowReconnect","responseMessage","features","inherentKeepAlive","Date","getTime","_timeoutHandle","setTimeout","serverTimeout","_pingServerHandle","nextPing","async","invocationMessage","methods","target","forEach","m","arguments","_cancelCallbacksWithError","_reconnect","removeEventListener","c","reconnectStartTime","now","previousReconnectAttempts","retryError","nextRetryDelay","_getNextRetryDelay","toString","previousRetryCount","elapsedMilliseconds","retryReason","nextRetryDelayInMilliseconds","callbacks","Object","keys","key","nonblocking","streamId","_createCompletionMessage","_createStreamItemMessage","i","argument","_isObservable","arg","StreamInvocation","id","CancelInvocation","DEFAULT_RETRY_DELAYS_IN_MILLISECONDS","DefaultReconnectPolicy","retryDelays","_retryDelays","retryContext","HttpError","errorMessage","statusCode","trueProto","super","__proto__","TimeoutError","AbortError","UnsupportedTransportError","transport","errorType","DisabledTransportError","FailedToStartTransportError","FailedToNegotiateWithServerError","AggregateErrors","innerErrors","HttpResponse","statusText","content","HttpClient","get","options","post","getCookieString","HttpTransportType","TransferFormat","FetchHttpClient","fetch","requireFunc","_jar","CookieJar","_fetchType","bind","AbortController","_abortControllerType","request","abortSignal","aborted","abortController","onabort","abort","timeoutId","timeout","msTimeout","body","cache","credentials","withCredentials","headers","mode","redirect","signal","ok","deserializeContent","status","responseType","payload","cookies","isNode","getCookies","join","arrayBuffer","text","XhrHttpClient","xhr","XMLHttpRequest","open","setRequestHeader","header","onload","responseText","onerror","ontimeout","DefaultHttpClient","_httpClient","HeaderNames","Authorization","Cookie","_isAborted","LongPollingTransport","httpClient","accessTokenFactory","_accessTokenFactory","_pollAbort","_options","_running","pollAborted","connect","isIn","_url","Trace","Binary","value","pollOptions","token","_getAccessToken","_updateHeaderToken","pollUrl","_closeError","_receiving","_poll","logMessageContent","_raiseOnClose","deleteOptions","delete","logMessage","ServerSentEventsTransport","encodeURIComponent","eventSource","opened","Text","isWebWorker","EventSource","onmessage","_close","onopen","_eventSource","close","WebSocketTransport","webSocketConstructor","_logMessageContent","_webSocketConstructor","_headers","webSocket","replace","binaryType","_event","_webSocket","event","ErrorEvent","readyState","OPEN","_isCloseEvent","wasClean","code","reason","HttpConnection","_stopPromiseResolver","_negotiateVersion","_resolveUrl","webSocketModule","eventSourceModule","WebSocket","_startInternalPromise","_sendQueue","TransportSendQueue","_stopError","_stopConnection","skipNegotiation","WebSockets","_constructTransport","_startTransport","negotiateResponse","redirects","_getNegotiationResponse","ProtocolVersion","accessToken","_createTransport","negotiateUrl","_resolveNegotiateUrl","negotiateVersion","connectionToken","_createConnectUrl","requestedTransport","requestedTransferFormat","connectUrl","_isITransport","transportExceptions","transports","availableTransports","negotiate","endpoint","transportOrError","_resolveTransportOrError","ex","ServerSentEvents","LongPolling","actualTransport","transportMatches","transferFormats","map","s","lastIndexOf","aTag","createElement","href","index","_transport","_buffer","_executing","_sendBufferedData","PromiseSource","_transportResult","_sendLoopPromise","_sendLoop","_bufferData","promise","transportResult","_concatBuffers","arrayBuffers","totalLength","b","reduce","a","offset","set","_resolver","_rejecter","JsonHubProtocol","input","instance","hubMessages","parsedMessage","_isInvocationMessage","_isStreamItemMessage","_isCompletionMessage","_assertNotEmptyString","LogLevelNameMapping","trace","debug","info","information","warn","warning","critical","Critical","none","None","HubConnectionBuilder","configureLogging","logging","logLevel","mapping","parseLogLevel","withUrl","transportTypeOrOptions","isNotEmpty","httpConnectionOptions","withHubProtocol","withAutomaticReconnect","retryDelaysOrReconnectPolicy","isArray","build","MessageType","LogLevel","NullLogger","_logLevel","_message","output","split","pop","VERSION","Arg","val","match","values","Platform","self","isReactNative","getDataDetail","includeContent","detail","isArrayBuffer","view","str","num","substr","formatArrayBuffer","ArrayBuffer","sendMessage","transportName","getUserAgentHeader","createLogger","ConsoleLogger","SubjectSubscription","_subject","_observer","dispose","_","minimumLogLevel","_minLevel","out","console","msg","toISOString","userAgentHeaderName","constructUserAgent","getOsName","getRuntimeVersion","os","runtime","runtimeVersion","userAgent","majorAndMinor","process","platform","versions","node","getErrorString","stack","getGlobalThis","globalThis","g","exports","read","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","d","NaN","Infinity","Math","pow","rt","abs","isNaN","floor","LN2","module","ctor","superCtor","super_","enumerable","writable","configurable","TempCtor","COMMENT_REGEX","NEWLINE_REGEX","WHITESPACE_REGEX","PROPERTY_REGEX","COLON_REGEX","VALUE_REGEX","SEMICOLON_REGEX","TRIM_REGEX","EMPTY_STRING","trim","style","TypeError","lineno","column","updatePosition","lines","position","line","Position","whitespace","end","source","errorsList","filename","silent","re","exec","comments","rules","comment","pos","charAt","declaration","prop","ret","property","decl","decls","declarations","camel2hyphen","obj2mq","obj","mq","feature","test","isDimension","query","q","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","freeGlobal","freeSelf","root","Function","objectToString","nativeMax","max","nativeMin","min","isObject","toNumber","isObjectLike","isSymbol","other","valueOf","isBinary","func","wait","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","invokeFunc","time","thisArg","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","remainingWait","debounced","isInvoking","leadingEdge","cancel","flush","hashClear","hashDelete","hashGet","hashHas","hashSet","Hash","entries","clear","entry","has","listCacheClear","listCacheDelete","listCacheGet","listCacheHas","listCacheSet","ListCache","Map","getNative","mapCacheClear","mapCacheDelete","mapCacheGet","mapCacheHas","mapCacheSet","MapCache","stackClear","stackDelete","stackGet","stackHas","stackSet","Stack","__data__","size","Symbol","baseTimes","isArguments","isBuffer","isIndex","isTypedArray","hasOwnProperty","inherited","isArr","isArg","isBuff","isType","skipIndexes","baseAssignValue","eq","object","objValue","array","defineProperty","objectCreate","baseCreate","proto","baseFor","createBaseFor","getRawTag","symToStringTag","toStringTag","baseGetTag","isFunction","isMasked","toSource","reIsHostCtor","funcProto","objectProto","funcToString","reIsNative","RegExp","isLength","typedArrayTags","isPrototype","nativeKeysIn","isProto","assignMergeValue","baseMergeDeep","keysIn","safeGet","baseMerge","srcIndex","customizer","srcValue","newValue","cloneBuffer","cloneTypedArray","copyArray","initCloneObject","isArrayLikeObject","isPlainObject","toPlainObject","mergeFunc","stacked","isCommon","isTyped","identity","overRest","setToString","constant","baseSetToString","string","n","iteratee","freeExports","nodeType","freeModule","Buffer","allocUnsafe","isDeep","copy","cloneArrayBuffer","typedArray","byteOffset","assignValue","props","isNew","coreJsData","baseRest","isIterateeCall","assigner","sources","guard","fromRight","keysFunc","iterable","isKeyable","baseIsNative","getValue","getPrototype","overArg","getPrototypeOf","nativeObjectToString","isOwn","tag","unmasked","nativeCreate","reIsUint","isArrayLike","uid","maskSrcKey","IE_PROTO","Ctor","assocIndexOf","getMapData","freeProcess","nodeUtil","require","types","binding","transform","otherArgs","shortOut","nativeNow","count","lastCalled","stamp","remaining","pairs","LARGE_ARRAY_SIZE","baseIsArguments","propertyIsEnumerable","stubFalse","objectCtorString","baseIsTypedArray","baseUnary","nodeIsTypedArray","arrayLikeKeys","baseKeysIn","merge","createAssigner","copyObject","MAX_SIGNED_31_BIT_INT","commonjsGlobal","defaultValue","calculateChangedBits","_Provider$childContex","_Consumer$contextType","contextProp","Provider","_Component","_this","emitter","handler","filter","h","changedBits","_proto","getChildContext","_ref","componentWillReceiveProps","nextProps","oldValue","x","y","render","children","Component","childContextTypes","Consumer","_Component2","_this2","onUpdate","observedBits","setState","_proto2","componentDidMount","context","componentWillUnmount","contextTypes","r","t","Q","Z","L","v","o","nn","u","f","add","X","Set","p","l","rn","freeze","isFrozen","tn","U","j","O","S","w","P","M","H","A","I","k","N","R","concat","D","z","getOwnPropertyDescriptor","E","F","T","C","en","Proxy","revocable","revoke","proxy","J","K","from","G","W","B","Reflect","for","iterator","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","getOwnPropertyDescriptors","Number","deleteProperty","setPrototypeOf","un","produce","produceWithPatches","useProxies","setUseProxies","autoFreeze","setAutoFreeze","createDraft","finishDraft","applyPatches","path","op","$","an","one","includeImageAlt","Boolean","alt","list","remove","items","parameters","chunkStart","unshift","syntaxExtension","all","extension","hook","left","right","constructs","existing","before","factorySpace","effects","limit","POSITIVE_INFINITY","enter","prefix","consume","exit","tokenize","contentStart","attempt","parser","contentInitial","lineStart","previous","contentType","childFlow","childToken","lineStartOffset","continued","containerState","continuation","documentContinue","checkNewContainers","_closeFlow","closeFlow","indexBeforeExits","events","point","indexBeforeFlow","exitContainers","assign","documentContinued","currentConstruct","concrete","flowStart","interrupt","_gfmTableDynamicInterruptHack","check","containerConstruct","thereIsANewContainer","thereIsNoNewContainer","lazy","containerContinue","flow","_tokenizer","flowContinue","writeToChild","eof","sliceStream","defineSkip","seen","nok","disable","null","includes","blankLine","partial","subtokenize","jumps","lineIndex","otherIndex","otherEvent","subevents","more","_isInFirstContentOfListItem","subcontent","_container","eventIndex","startPosition","startPositions","tokenizer","childEvents","gaps","current","adjust","breaks","_gfmTasklistFirstContentOfListItem","contentEnd","continuationConstruct","contentContinue","prefixed","tail","sliceSerialize","initial","flowInitial","afterConstruct","resolver","resolveAll","createResolver","initializeFactory","field","notText","atBreak","resolveAllLineSuffixes","extraResolver","chunks","tabs","bufferIndex","chunk","charCodeAt","_index","_bufferIndex","called","createTokenizer","initialize","columnStart","resolveAllConstructs","consumed","accountForPotentialSkip","fields","constructFactory","construct","addResult","onsuccessfulcheck","expandTabs","atTab","serializeChunks","chunkIndex","go","main","expectedCode","startIndex","startBufferIndex","endIndex","endBufferIndex","sliceChunks","restore","onreturn","returnState","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","def","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","resolveTo","thematicBreak","marker","sequence","initialSize","kind","atMarker","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","furtherBlankLines","notInCurrentItem","indentConstruct","blockQuote","after","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","factoryLabel","markerType","label","labelEscape","factoryTitle","atFirstTitleBreak","atTitleBreak","title","titleEscape","factoryWhitespace","normalizeIdentifier","toUpperCase","definition","identifier","labelAfter","titleConstruct","defined","codeIndented","afterStartPrefix","afterPrefix","indentedContent","headingAtx","fenceOpenInside","headingBreak","setextUnderline","paragraph","closingSequence","closingSequenceEnd","heading","htmlBlockNames","htmlRawNames","htmlFlow","startTag","declarationStart","tagCloseStart","continuationDeclarationInside","tagName","commentOpenInside","cdataOpenInside","basicSelfClosing","completeAttributeNameBefore","completeClosingTagAfter","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCharacterDataInside","continuationAtLineEnding","nextBlankConstruct","htmlContinueStart","done","htmlLineEnd","continuationRawEndTag","codeFenced","closingFenceConstruct","sizeOpen","nonLazyLine","initialPrefix","sequenceOpen","infoOpen","openAfter","infoAfter","meta","characterReference","numeric","characterEscape","lineEnding","labelEnd","labelStart","_balanced","_inactive","balanced","afterLabelEnd","resourceConstruct","fullReferenceConstruct","collapsedReferenceConstruct","media","group","insideSpan","destinationAfter","between","afterLabel","classifyCharacter","attention","attentionMarkers","_open","openingSequence","use","nextEvents","movePoint","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","declarationOpen","instruction","tagOpen","commentOpen","cdataOpen","commentStart","commentStartDash","commentClose","atLineEnding","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","gap","tailExitIndex","headEnterIndex","search","decodeNumericCharacterReference","base","characterEscapeOrReference","decode","$0","$1","$2","head","hex","own","fromMarkdown","encoding","config","transforms","canContainEols","autolink","opener","link","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeText","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreakEscape","hardBreak","hardBreakTrailing","html","htmlFlowData","htmlText","htmlTextData","image","listItem","spread","_spread","checked","listItemValue","getData","setData","listOrdered","listUnordered","reference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","closer","atxHeadingSequence","depth","onexitdata","characterEscapeValue","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","resume","codeFencedFence","lang","onexithardbreak","referenceType","fragment","labelText","ancestor","decodeString","resource","setextHeadingLineSequence","setextHeadingText","configure","mdastExtensions","tree","tokenStack","listStack","prepareList","defaultOnError","firstBlankLineIndex","containerBalance","listSpread","tailIndex","tailEvent","and","errorHandler","onExitError","ordered","compiler","postprocess","extensions","combineExtensions","atCarriageReturn","endPosition","lastIndex","ceil","preprocess","combined","normalizeUri","skip","clean","footnoteReference","safeId","footnoteOrder","counter","footnoteCounts","reuseCounter","properties","clobberPrefix","dataFootnoteRef","ariaDescribedBy","patch","sup","applyData","revert","subtype","suffix","contents","listItemLoose","blockquote","wrap","break","className","footnote","footnoteById","no","dangerous","imageReference","src","inlineCode","linkReference","parent","results","loose","listLoose","disabled","child","table","rows","firstRow","shift","tableContent","tableCell","tableRow","siblings","align","cellIndex","cells","cell","alignValue","toml","ignore","yaml","footnoteDefinition","to","hName","hChildren","hProperties","passThrough","unknownHandler","defaultUnknownHandler","nodes","toHast","settings","allowDangerousHtml","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","footnoteBackLabel","definitions","augment","ctx","createState","foot","listItems","referenceIndex","backReferences","backReference","dataFootnoteBackref","ariaLabel","tailTail","dataFootnotes","footer","asciiAlpha","regexCheck","asciiDigit","asciiHexDigit","asciiAlphanumeric","asciiPunctuation","asciiAtext","asciiControl","markdownLineEndingOrSpace","markdownLineEnding","markdownSpace","unicodeWhitespace","unicodePunctuation","regex"],"sourceRoot":""}