',
+ "showdown": `S`
+ };
+ showdown2.Converter = function(converterOptions) {
+ "use strict";
+ var options = {}, langExtensions = [], outputModifiers = [], listeners = {}, setConvFlavor = setFlavor, metadata = {
+ parsed: {},
+ raw: "",
+ format: ""
+ };
+ _constructor();
+ function _constructor() {
+ converterOptions = converterOptions || {};
+ for (var gOpt in globalOptions) {
+ if (globalOptions.hasOwnProperty(gOpt)) {
+ options[gOpt] = globalOptions[gOpt];
+ }
+ }
+ if (typeof converterOptions === "object") {
+ for (var opt in converterOptions) {
+ if (converterOptions.hasOwnProperty(opt)) {
+ options[opt] = converterOptions[opt];
+ }
+ }
+ } else {
+ throw Error("Converter expects the passed parameter to be an object, but " + typeof converterOptions + " was passed instead.");
+ }
+ if (options.extensions) {
+ showdown2.helper.forEach(options.extensions, _parseExtension);
+ }
+ }
+ function _parseExtension(ext, name) {
+ name = name || null;
+ if (showdown2.helper.isString(ext)) {
+ ext = showdown2.helper.stdExtName(ext);
+ name = ext;
+ if (showdown2.extensions[ext]) {
+ console.warn("DEPRECATION WARNING: " + ext + " is an old extension that uses a deprecated loading method.Please inform the developer that the extension should be updated!");
+ legacyExtensionLoading(showdown2.extensions[ext], ext);
+ return;
+ } else if (!showdown2.helper.isUndefined(extensions[ext])) {
+ ext = extensions[ext];
+ } else {
+ throw Error('Extension "' + ext + '" could not be loaded. It was either not found or is not a valid extension.');
+ }
+ }
+ if (typeof ext === "function") {
+ ext = ext();
+ }
+ if (!showdown2.helper.isArray(ext)) {
+ ext = [ext];
+ }
+ var validExt = validate2(ext, name);
+ if (!validExt.valid) {
+ throw Error(validExt.error);
+ }
+ for (var i2 = 0; i2 < ext.length; ++i2) {
+ switch (ext[i2].type) {
+ case "lang":
+ langExtensions.push(ext[i2]);
+ break;
+ case "output":
+ outputModifiers.push(ext[i2]);
+ break;
+ }
+ if (ext[i2].hasOwnProperty("listeners")) {
+ for (var ln in ext[i2].listeners) {
+ if (ext[i2].listeners.hasOwnProperty(ln)) {
+ listen(ln, ext[i2].listeners[ln]);
+ }
+ }
+ }
+ }
+ }
+ function legacyExtensionLoading(ext, name) {
+ if (typeof ext === "function") {
+ ext = ext(new showdown2.Converter());
+ }
+ if (!showdown2.helper.isArray(ext)) {
+ ext = [ext];
+ }
+ var valid = validate2(ext, name);
+ if (!valid.valid) {
+ throw Error(valid.error);
+ }
+ for (var i2 = 0; i2 < ext.length; ++i2) {
+ switch (ext[i2].type) {
+ case "lang":
+ langExtensions.push(ext[i2]);
+ break;
+ case "output":
+ outputModifiers.push(ext[i2]);
+ break;
+ default:
+ throw Error("Extension loader error: Type unrecognized!!!");
+ }
+ }
+ }
+ function listen(name, callback) {
+ if (!showdown2.helper.isString(name)) {
+ throw Error("Invalid argument in converter.listen() method: name must be a string, but " + typeof name + " given");
+ }
+ if (typeof callback !== "function") {
+ throw Error("Invalid argument in converter.listen() method: callback must be a function, but " + typeof callback + " given");
+ }
+ if (!listeners.hasOwnProperty(name)) {
+ listeners[name] = [];
+ }
+ listeners[name].push(callback);
+ }
+ function rTrimInputText(text) {
+ var rsp = text.match(/^\s*/)[0].length, rgx = new RegExp("^\\s{0," + rsp + "}", "gm");
+ return text.replace(rgx, "");
+ }
+ this._dispatch = function dispatch2(evtName, text, options2, globals) {
+ if (listeners.hasOwnProperty(evtName)) {
+ for (var ei = 0; ei < listeners[evtName].length; ++ei) {
+ var nText = listeners[evtName][ei](evtName, text, this, options2, globals);
+ if (nText && typeof nText !== "undefined") {
+ text = nText;
+ }
+ }
+ }
+ return text;
+ };
+ this.listen = function(name, callback) {
+ listen(name, callback);
+ return this;
+ };
+ this.makeHtml = function(text) {
+ if (!text) {
+ return text;
+ }
+ var globals = {
+ gHtmlBlocks: [],
+ gHtmlMdBlocks: [],
+ gHtmlSpans: [],
+ gUrls: {},
+ gTitles: {},
+ gDimensions: {},
+ gListLevel: 0,
+ hashLinkCounts: {},
+ langExtensions,
+ outputModifiers,
+ converter: this,
+ ghCodeBlocks: [],
+ metadata: {
+ parsed: {},
+ raw: "",
+ format: ""
+ }
+ };
+ text = text.replace(/¨/g, "\xA8T");
+ text = text.replace(/\$/g, "\xA8D");
+ text = text.replace(/\r\n/g, "\n");
+ text = text.replace(/\r/g, "\n");
+ text = text.replace(/\u00A0/g, " ");
+ if (options.smartIndentationFix) {
+ text = rTrimInputText(text);
+ }
+ text = "\n\n" + text + "\n\n";
+ text = showdown2.subParser("detab")(text, options, globals);
+ text = text.replace(/^[ \t]+$/mg, "");
+ showdown2.helper.forEach(langExtensions, function(ext) {
+ text = showdown2.subParser("runExtension")(ext, text, options, globals);
+ });
+ text = showdown2.subParser("metadata")(text, options, globals);
+ text = showdown2.subParser("hashPreCodeTags")(text, options, globals);
+ text = showdown2.subParser("githubCodeBlocks")(text, options, globals);
+ text = showdown2.subParser("hashHTMLBlocks")(text, options, globals);
+ text = showdown2.subParser("hashCodeTags")(text, options, globals);
+ text = showdown2.subParser("stripLinkDefinitions")(text, options, globals);
+ text = showdown2.subParser("blockGamut")(text, options, globals);
+ text = showdown2.subParser("unhashHTMLSpans")(text, options, globals);
+ text = showdown2.subParser("unescapeSpecialChars")(text, options, globals);
+ text = text.replace(/¨D/g, "$$");
+ text = text.replace(/¨T/g, "\xA8");
+ text = showdown2.subParser("completeHTMLDocument")(text, options, globals);
+ showdown2.helper.forEach(outputModifiers, function(ext) {
+ text = showdown2.subParser("runExtension")(ext, text, options, globals);
+ });
+ metadata = globals.metadata;
+ return text;
+ };
+ this.makeMarkdown = this.makeMd = function(src, HTMLParser) {
+ src = src.replace(/\r\n/g, "\n");
+ src = src.replace(/\r/g, "\n");
+ src = src.replace(/>[ \t]+\xA8NBSP;<");
+ if (!HTMLParser) {
+ if (window && window.document) {
+ HTMLParser = window.document;
+ } else {
+ throw new Error("HTMLParser is undefined. If in a webworker or nodejs environment, you need to provide a WHATWG DOM and HTML such as JSDOM");
+ }
+ }
+ var doc = HTMLParser.createElement("div");
+ doc.innerHTML = src;
+ var globals = {
+ preList: substitutePreCodeTags(doc)
+ };
+ clean(doc);
+ var nodes = doc.childNodes, mdDoc = "";
+ for (var i2 = 0; i2 < nodes.length; i2++) {
+ mdDoc += showdown2.subParser("makeMarkdown.node")(nodes[i2], globals);
+ }
+ function clean(node) {
+ for (var n = 0; n < node.childNodes.length; ++n) {
+ var child = node.childNodes[n];
+ if (child.nodeType === 3) {
+ if (!/\S/.test(child.nodeValue) && !/^[ ]+$/.test(child.nodeValue)) {
+ node.removeChild(child);
+ --n;
+ } else {
+ child.nodeValue = child.nodeValue.split("\n").join(" ");
+ child.nodeValue = child.nodeValue.replace(/(\s)+/g, "$1");
+ }
+ } else if (child.nodeType === 1) {
+ clean(child);
+ }
+ }
+ }
+ function substitutePreCodeTags(doc2) {
+ var pres = doc2.querySelectorAll("pre"), presPH = [];
+ for (var i3 = 0; i3 < pres.length; ++i3) {
+ if (pres[i3].childElementCount === 1 && pres[i3].firstChild.tagName.toLowerCase() === "code") {
+ var content = pres[i3].firstChild.innerHTML.trim(), language = pres[i3].firstChild.getAttribute("data-language") || "";
+ if (language === "") {
+ var classes = pres[i3].firstChild.className.split(" ");
+ for (var c = 0; c < classes.length; ++c) {
+ var matches2 = classes[c].match(/^language-(.+)$/);
+ if (matches2 !== null) {
+ language = matches2[1];
+ break;
+ }
+ }
+ }
+ content = showdown2.helper.unescapeHTMLEntities(content);
+ presPH.push(content);
+ pres[i3].outerHTML = '[^\r]+?<\/pre>)/gm, function(wholeMatch, m1) {
+ var pre = m1;
+ pre = pre.replace(/^ /mg, "\xA80");
+ pre = pre.replace(/¨0/g, "");
+ return pre;
+ });
+ return showdown2.subParser("hashBlock")("\n" + bq + "\n
", options, globals);
+ });
+ text = globals.converter._dispatch("blockQuotes.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("codeBlocks", function(text, options, globals) {
+ "use strict";
+ text = globals.converter._dispatch("codeBlocks.before", text, options, globals);
+ text += "\xA80";
+ var pattern = /(?:\n\n|^)((?:(?:[ ]{4}|\t).*\n+)+)(\n*[ ]{0,3}[^ \t\n]|(?=¨0))/g;
+ text = text.replace(pattern, function(wholeMatch, m1, m2) {
+ var codeblock = m1, nextChar = m2, end = "\n";
+ codeblock = showdown2.subParser("outdent")(codeblock, options, globals);
+ codeblock = showdown2.subParser("encodeCode")(codeblock, options, globals);
+ codeblock = showdown2.subParser("detab")(codeblock, options, globals);
+ codeblock = codeblock.replace(/^\n+/g, "");
+ codeblock = codeblock.replace(/\n+$/g, "");
+ if (options.omitExtraWLInCodeBlocks) {
+ end = "";
+ }
+ codeblock = "" + codeblock + end + "
";
+ return showdown2.subParser("hashBlock")(codeblock, options, globals) + nextChar;
+ });
+ text = text.replace(/¨0/, "");
+ text = globals.converter._dispatch("codeBlocks.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("codeSpans", function(text, options, globals) {
+ "use strict";
+ text = globals.converter._dispatch("codeSpans.before", text, options, globals);
+ if (typeof text === "undefined") {
+ text = "";
+ }
+ text = text.replace(/(^|[^\\])(`+)([^\r]*?[^`])\2(?!`)/gm, function(wholeMatch, m1, m2, m3) {
+ var c = m3;
+ c = c.replace(/^([ \t]*)/g, "");
+ c = c.replace(/[ \t]*$/g, "");
+ c = showdown2.subParser("encodeCode")(c, options, globals);
+ c = m1 + "" + c + "";
+ c = showdown2.subParser("hashHTMLSpans")(c, options, globals);
+ return c;
+ });
+ text = globals.converter._dispatch("codeSpans.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("completeHTMLDocument", function(text, options, globals) {
+ "use strict";
+ if (!options.completeHTMLDocument) {
+ return text;
+ }
+ text = globals.converter._dispatch("completeHTMLDocument.before", text, options, globals);
+ var doctype = "html", doctypeParsed = "\n", title = "", charset = '\n', lang = "", metadata = "";
+ if (typeof globals.metadata.parsed.doctype !== "undefined") {
+ doctypeParsed = "\n";
+ doctype = globals.metadata.parsed.doctype.toString().toLowerCase();
+ if (doctype === "html" || doctype === "html5") {
+ charset = '';
+ }
+ }
+ for (var meta in globals.metadata.parsed) {
+ if (globals.metadata.parsed.hasOwnProperty(meta)) {
+ switch (meta.toLowerCase()) {
+ case "doctype":
+ break;
+ case "title":
+ title = "" + globals.metadata.parsed.title + " \n";
+ break;
+ case "charset":
+ if (doctype === "html" || doctype === "html5") {
+ charset = '\n';
+ } else {
+ charset = '\n';
+ }
+ break;
+ case "language":
+ case "lang":
+ lang = ' lang="' + globals.metadata.parsed[meta] + '"';
+ metadata += '\n';
+ break;
+ default:
+ metadata += '\n';
+ }
+ }
+ }
+ text = doctypeParsed + "\n\n" + title + charset + metadata + "\n\n" + text.trim() + "\n\n";
+ text = globals.converter._dispatch("completeHTMLDocument.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("detab", function(text, options, globals) {
+ "use strict";
+ text = globals.converter._dispatch("detab.before", text, options, globals);
+ text = text.replace(/\t(?=\t)/g, " ");
+ text = text.replace(/\t/g, "\xA8A\xA8B");
+ text = text.replace(/¨B(.+?)¨A/g, function(wholeMatch, m1) {
+ var leadingText = m1, numSpaces = 4 - leadingText.length % 4;
+ for (var i2 = 0; i2 < numSpaces; i2++) {
+ leadingText += " ";
+ }
+ return leadingText;
+ });
+ text = text.replace(/¨A/g, " ");
+ text = text.replace(/¨B/g, "");
+ text = globals.converter._dispatch("detab.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("ellipsis", function(text, options, globals) {
+ "use strict";
+ if (!options.ellipsis) {
+ return text;
+ }
+ text = globals.converter._dispatch("ellipsis.before", text, options, globals);
+ text = text.replace(/\.\.\./g, "\u2026");
+ text = globals.converter._dispatch("ellipsis.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("emoji", function(text, options, globals) {
+ "use strict";
+ if (!options.emoji) {
+ return text;
+ }
+ text = globals.converter._dispatch("emoji.before", text, options, globals);
+ var emojiRgx = /:([\S]+?):/g;
+ text = text.replace(emojiRgx, function(wm2, emojiCode) {
+ if (showdown2.helper.emojis.hasOwnProperty(emojiCode)) {
+ return showdown2.helper.emojis[emojiCode];
+ }
+ return wm2;
+ });
+ text = globals.converter._dispatch("emoji.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("encodeAmpsAndAngles", function(text, options, globals) {
+ "use strict";
+ text = globals.converter._dispatch("encodeAmpsAndAngles.before", text, options, globals);
+ text = text.replace(/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/g, "&");
+ text = text.replace(/<(?![a-z\/?$!])/gi, "<");
+ text = text.replace(//g, ">");
+ text = globals.converter._dispatch("encodeAmpsAndAngles.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("encodeBackslashEscapes", function(text, options, globals) {
+ "use strict";
+ text = globals.converter._dispatch("encodeBackslashEscapes.before", text, options, globals);
+ text = text.replace(/\\(\\)/g, showdown2.helper.escapeCharactersCallback);
+ text = text.replace(/\\([`*_{}\[\]()>#+.!~=|:-])/g, showdown2.helper.escapeCharactersCallback);
+ text = globals.converter._dispatch("encodeBackslashEscapes.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("encodeCode", function(text, options, globals) {
+ "use strict";
+ text = globals.converter._dispatch("encodeCode.before", text, options, globals);
+ text = text.replace(/&/g, "&").replace(//g, ">").replace(/([*_{}\[\]\\=~-])/g, showdown2.helper.escapeCharactersCallback);
+ text = globals.converter._dispatch("encodeCode.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("escapeSpecialCharsWithinTagAttributes", function(text, options, globals) {
+ "use strict";
+ text = globals.converter._dispatch("escapeSpecialCharsWithinTagAttributes.before", text, options, globals);
+ var tags = /<\/?[a-z\d_:-]+(?:[\s]+[\s\S]+?)?>/gi, comments = /-]|-[^>])(?:[^-]|-[^-])*)--)>/gi;
+ text = text.replace(tags, function(wholeMatch) {
+ return wholeMatch.replace(/(.)<\/?code>(?=.)/g, "$1`").replace(/([\\`*_~=|])/g, showdown2.helper.escapeCharactersCallback);
+ });
+ text = text.replace(comments, function(wholeMatch) {
+ return wholeMatch.replace(/([\\`*_~=|])/g, showdown2.helper.escapeCharactersCallback);
+ });
+ text = globals.converter._dispatch("escapeSpecialCharsWithinTagAttributes.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("githubCodeBlocks", function(text, options, globals) {
+ "use strict";
+ if (!options.ghCodeBlocks) {
+ return text;
+ }
+ text = globals.converter._dispatch("githubCodeBlocks.before", text, options, globals);
+ text += "\xA80";
+ text = text.replace(/(?:^|\n)(?: {0,3})(```+|~~~+)(?: *)([^\s`~]*)\n([\s\S]*?)\n(?: {0,3})\1/g, function(wholeMatch, delim, language, codeblock) {
+ var end = options.omitExtraWLInCodeBlocks ? "" : "\n";
+ codeblock = showdown2.subParser("encodeCode")(codeblock, options, globals);
+ codeblock = showdown2.subParser("detab")(codeblock, options, globals);
+ codeblock = codeblock.replace(/^\n+/g, "");
+ codeblock = codeblock.replace(/\n+$/g, "");
+ codeblock = "" + codeblock + end + "
";
+ codeblock = showdown2.subParser("hashBlock")(codeblock, options, globals);
+ return "\n\n\xA8G" + (globals.ghCodeBlocks.push({ text: wholeMatch, codeblock }) - 1) + "G\n\n";
+ });
+ text = text.replace(/¨0/, "");
+ return globals.converter._dispatch("githubCodeBlocks.after", text, options, globals);
+ });
+ showdown2.subParser("hashBlock", function(text, options, globals) {
+ "use strict";
+ text = globals.converter._dispatch("hashBlock.before", text, options, globals);
+ text = text.replace(/(^\n+|\n+$)/g, "");
+ text = "\n\n\xA8K" + (globals.gHtmlBlocks.push(text) - 1) + "K\n\n";
+ text = globals.converter._dispatch("hashBlock.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("hashCodeTags", function(text, options, globals) {
+ "use strict";
+ text = globals.converter._dispatch("hashCodeTags.before", text, options, globals);
+ var repFunc = function(wholeMatch, match, left, right) {
+ var codeblock = left + showdown2.subParser("encodeCode")(match, options, globals) + right;
+ return "\xA8C" + (globals.gHtmlSpans.push(codeblock) - 1) + "C";
+ };
+ text = showdown2.helper.replaceRecursiveRegExp(text, repFunc, "]*>", "", "gim");
+ text = globals.converter._dispatch("hashCodeTags.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("hashElement", function(text, options, globals) {
+ "use strict";
+ return function(wholeMatch, m1) {
+ var blockText = m1;
+ blockText = blockText.replace(/\n\n/g, "\n");
+ blockText = blockText.replace(/^\n/, "");
+ blockText = blockText.replace(/\n+$/g, "");
+ blockText = "\n\n\xA8K" + (globals.gHtmlBlocks.push(blockText) - 1) + "K\n\n";
+ return blockText;
+ };
+ });
+ showdown2.subParser("hashHTMLBlocks", function(text, options, globals) {
+ "use strict";
+ text = globals.converter._dispatch("hashHTMLBlocks.before", text, options, globals);
+ var blockTags = [
+ "pre",
+ "div",
+ "h1",
+ "h2",
+ "h3",
+ "h4",
+ "h5",
+ "h6",
+ "blockquote",
+ "table",
+ "dl",
+ "ol",
+ "ul",
+ "script",
+ "noscript",
+ "form",
+ "fieldset",
+ "iframe",
+ "math",
+ "style",
+ "section",
+ "header",
+ "footer",
+ "nav",
+ "article",
+ "aside",
+ "address",
+ "audio",
+ "canvas",
+ "figure",
+ "hgroup",
+ "output",
+ "video",
+ "p"
+ ], repFunc = function(wholeMatch, match, left, right) {
+ var txt = wholeMatch;
+ if (left.search(/\bmarkdown\b/) !== -1) {
+ txt = left + globals.converter.makeHtml(match) + right;
+ }
+ return "\n\n\xA8K" + (globals.gHtmlBlocks.push(txt) - 1) + "K\n\n";
+ };
+ if (options.backslashEscapesHTMLTags) {
+ text = text.replace(/\\<(\/?[^>]+?)>/g, function(wm2, inside) {
+ return "<" + inside + ">";
+ });
+ }
+ for (var i2 = 0; i2 < blockTags.length; ++i2) {
+ var opTagPos, rgx1 = new RegExp("^ {0,3}(<" + blockTags[i2] + "\\b[^>]*>)", "im"), patLeft = "<" + blockTags[i2] + "\\b[^>]*>", patRight = "";
+ while ((opTagPos = showdown2.helper.regexIndexOf(text, rgx1)) !== -1) {
+ var subTexts = showdown2.helper.splitAtIndex(text, opTagPos), newSubText1 = showdown2.helper.replaceRecursiveRegExp(subTexts[1], repFunc, patLeft, patRight, "im");
+ if (newSubText1 === subTexts[1]) {
+ break;
+ }
+ text = subTexts[0].concat(newSubText1);
+ }
+ }
+ text = text.replace(/(\n {0,3}(<(hr)\b([^<>])*?\/?>)[ \t]*(?=\n{2,}))/g, showdown2.subParser("hashElement")(text, options, globals));
+ text = showdown2.helper.replaceRecursiveRegExp(text, function(txt) {
+ return "\n\n\xA8K" + (globals.gHtmlBlocks.push(txt) - 1) + "K\n\n";
+ }, "^ {0,3}", "gm");
+ text = text.replace(/(?:\n\n)( {0,3}(?:<([?%])[^\r]*?\2>)[ \t]*(?=\n{2,}))/g, showdown2.subParser("hashElement")(text, options, globals));
+ text = globals.converter._dispatch("hashHTMLBlocks.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("hashHTMLSpans", function(text, options, globals) {
+ "use strict";
+ text = globals.converter._dispatch("hashHTMLSpans.before", text, options, globals);
+ function hashHTMLSpan(html) {
+ return "\xA8C" + (globals.gHtmlSpans.push(html) - 1) + "C";
+ }
+ text = text.replace(/<[^>]+?\/>/gi, function(wm2) {
+ return hashHTMLSpan(wm2);
+ });
+ text = text.replace(/<([^>]+?)>[\s\S]*?<\/\1>/g, function(wm2) {
+ return hashHTMLSpan(wm2);
+ });
+ text = text.replace(/<([^>]+?)\s[^>]+?>[\s\S]*?<\/\1>/g, function(wm2) {
+ return hashHTMLSpan(wm2);
+ });
+ text = text.replace(/<[^>]+?>/gi, function(wm2) {
+ return hashHTMLSpan(wm2);
+ });
+ text = globals.converter._dispatch("hashHTMLSpans.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("unhashHTMLSpans", function(text, options, globals) {
+ "use strict";
+ text = globals.converter._dispatch("unhashHTMLSpans.before", text, options, globals);
+ for (var i2 = 0; i2 < globals.gHtmlSpans.length; ++i2) {
+ var repText = globals.gHtmlSpans[i2], limit = 0;
+ while (/¨C(\d+)C/.test(repText)) {
+ var num = RegExp.$1;
+ repText = repText.replace("\xA8C" + num + "C", globals.gHtmlSpans[num]);
+ if (limit === 10) {
+ console.error("maximum nesting of 10 spans reached!!!");
+ break;
+ }
+ ++limit;
+ }
+ text = text.replace("\xA8C" + i2 + "C", repText);
+ }
+ text = globals.converter._dispatch("unhashHTMLSpans.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("hashPreCodeTags", function(text, options, globals) {
+ "use strict";
+ text = globals.converter._dispatch("hashPreCodeTags.before", text, options, globals);
+ var repFunc = function(wholeMatch, match, left, right) {
+ var codeblock = left + showdown2.subParser("encodeCode")(match, options, globals) + right;
+ return "\n\n\xA8G" + (globals.ghCodeBlocks.push({ text: wholeMatch, codeblock }) - 1) + "G\n\n";
+ };
+ text = showdown2.helper.replaceRecursiveRegExp(text, repFunc, "^ {0,3}]*>\\s*]*>", "^ {0,3}\\s* ", "gim");
+ text = globals.converter._dispatch("hashPreCodeTags.after", text, options, globals);
+ return text;
+ });
+ showdown2.subParser("headers", function(text, options, globals) {
+ "use strict";
+ text = globals.converter._dispatch("headers.before", text, options, globals);
+ var headerLevelStart = isNaN(parseInt(options.headerLevelStart)) ? 1 : parseInt(options.headerLevelStart), setextRegexH1 = options.smoothLivePreview ? /^(.+)[ \t]*\n={2,}[ \t]*\n+/gm : /^(.+)[ \t]*\n=+[ \t]*\n+/gm, setextRegexH2 = options.smoothLivePreview ? /^(.+)[ \t]*\n-{2,}[ \t]*\n+/gm : /^(.+)[ \t]*\n-+[ \t]*\n+/gm;
+ text = text.replace(setextRegexH1, function(wholeMatch, m1) {
+ var spanGamut = showdown2.subParser("spanGamut")(m1, options, globals), hID = options.noHeaderId ? "" : ' id="' + headerId(m1) + '"', hLevel = headerLevelStart, hashBlock = ""); + str += "
"; + grafsOut.push(str); + } + } + end = grafsOut.length; + for (i2 = 0; i2 < end; i2++) { + var blockText = "", grafsOutIt = grafsOut[i2], codeFlag = false; + while (/¨(K|G)(\d+)\1/.test(grafsOutIt)) { + var delim = RegExp.$1, num = RegExp.$2; + if (delim === "K") { + blockText = globals.gHtmlBlocks[num]; + } else { + if (codeFlag) { + blockText = showdown2.subParser("encodeCode")(globals.ghCodeBlocks[num].text, options, globals); + } else { + blockText = globals.ghCodeBlocks[num].codeblock; + } + } + blockText = blockText.replace(/\$/g, "$$$$"); + grafsOutIt = grafsOutIt.replace(/(\n\n)?¨(K|G)\d+\2(\n\n)?/, blockText); + if (/^" + globals.preList[num] + ""; + }); + showdown2.subParser("makeMarkdown.strikethrough", function(node, globals) { + "use strict"; + var txt = ""; + if (node.hasChildNodes()) { + txt += "~~"; + var children = node.childNodes, childrenLength = children.length; + for (var i2 = 0; i2 < childrenLength; ++i2) { + txt += showdown2.subParser("makeMarkdown.node")(children[i2], globals); + } + txt += "~~"; + } + return txt; + }); + showdown2.subParser("makeMarkdown.strong", function(node, globals) { + "use strict"; + var txt = ""; + if (node.hasChildNodes()) { + txt += "**"; + var children = node.childNodes, childrenLength = children.length; + for (var i2 = 0; i2 < childrenLength; ++i2) { + txt += showdown2.subParser("makeMarkdown.node")(children[i2], globals); + } + txt += "**"; + } + return txt; + }); + showdown2.subParser("makeMarkdown.table", function(node, globals) { + "use strict"; + var txt = "", tableArray = [[], []], headings = node.querySelectorAll("thead>tr>th"), rows = node.querySelectorAll("tbody>tr"), i2, ii; + for (i2 = 0; i2 < headings.length; ++i2) { + var headContent = showdown2.subParser("makeMarkdown.tableCell")(headings[i2], globals), allign = "---"; + if (headings[i2].hasAttribute("style")) { + var style = headings[i2].getAttribute("style").toLowerCase().replace(/\s/g, ""); + switch (style) { + case "text-align:left;": + allign = ":---"; + break; + case "text-align:right;": + allign = "---:"; + break; + case "text-align:center;": + allign = ":---:"; + break; + } + } + tableArray[0][i2] = headContent.trim(); + tableArray[1][i2] = allign; + } + for (i2 = 0; i2 < rows.length; ++i2) { + var r2 = tableArray.push([]) - 1, cols = rows[i2].getElementsByTagName("td"); + for (ii = 0; ii < headings.length; ++ii) { + var cellContent = " "; + if (typeof cols[ii] !== "undefined") { + cellContent = showdown2.subParser("makeMarkdown.tableCell")(cols[ii], globals); + } + tableArray[r2].push(cellContent); + } + } + var cellSpacesCount = 3; + for (i2 = 0; i2 < tableArray.length; ++i2) { + for (ii = 0; ii < tableArray[i2].length; ++ii) { + var strLen = tableArray[i2][ii].length; + if (strLen > cellSpacesCount) { + cellSpacesCount = strLen; + } + } + } + for (i2 = 0; i2 < tableArray.length; ++i2) { + for (ii = 0; ii < tableArray[i2].length; ++ii) { + if (i2 === 1) { + if (tableArray[i2][ii].slice(-1) === ":") { + tableArray[i2][ii] = showdown2.helper.padEnd(tableArray[i2][ii].slice(-1), cellSpacesCount - 1, "-") + ":"; + } else { + tableArray[i2][ii] = showdown2.helper.padEnd(tableArray[i2][ii], cellSpacesCount, "-"); + } + } else { + tableArray[i2][ii] = showdown2.helper.padEnd(tableArray[i2][ii], cellSpacesCount); + } + } + txt += "| " + tableArray[i2].join(" | ") + " |\n"; + } + return txt.trim(); + }); + showdown2.subParser("makeMarkdown.tableCell", function(node, globals) { + "use strict"; + var txt = ""; + if (!node.hasChildNodes()) { + return ""; + } + var children = node.childNodes, childrenLength = children.length; + for (var i2 = 0; i2 < childrenLength; ++i2) { + txt += showdown2.subParser("makeMarkdown.node")(children[i2], globals, true); + } + return txt.trim(); + }); + showdown2.subParser("makeMarkdown.txt", function(node) { + "use strict"; + var txt = node.nodeValue; + txt = txt.replace(/ +/g, " "); + txt = txt.replace(/¨NBSP;/g, " "); + txt = showdown2.helper.unescapeHTMLEntities(txt); + txt = txt.replace(/([*_~|`])/g, "\\$1"); + txt = txt.replace(/^(\s*)>/g, "\\$1>"); + txt = txt.replace(/^#/gm, "\\#"); + txt = txt.replace(/^(\s*)([-=]{3,})(\s*)$/, "$1\\$2$3"); + txt = txt.replace(/^( {0,3}\d+)\./gm, "$1\\."); + txt = txt.replace(/^( {0,3})([+-])/gm, "$1\\$2"); + txt = txt.replace(/]([\s]*)\(/g, "\\]$1\\("); + txt = txt.replace(/^ {0,3}\[([\S \t]*?)]:/gm, "\\[$1]:"); + return txt; + }); + var root = this; + if (typeof define === "function" && define.amd) { + define(function() { + "use strict"; + return showdown2; + }); + } else if (typeof module2 !== "undefined" && module2.exports) { + module2.exports = showdown2; + } else { + root.showdown = showdown2; + } + }).call(exports); + } +}); + +// node_modules/web-streams-polyfill/dist/ponyfill.es2018.js +var require_ponyfill_es2018 = __commonJS({ + "node_modules/web-streams-polyfill/dist/ponyfill.es2018.js"(exports, module2) { + (function(global2, factory) { + typeof exports === "object" && typeof module2 !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.WebStreamsPolyfill = {})); + })(exports, function(exports2) { + "use strict"; + const SymbolPolyfill = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol : (description) => `Symbol(${description})`; + function noop2() { + return void 0; + } + function getGlobals() { + if (typeof self !== "undefined") { + return self; + } else if (typeof window !== "undefined") { + return window; + } else if (typeof global !== "undefined") { + return global; + } + return void 0; + } + const globals = getGlobals(); + function typeIsObject(x2) { + return typeof x2 === "object" && x2 !== null || typeof x2 === "function"; + } + const rethrowAssertionErrorRejection = noop2; + const originalPromise = Promise; + const originalPromiseThen = Promise.prototype.then; + const originalPromiseResolve = Promise.resolve.bind(originalPromise); + const originalPromiseReject = Promise.reject.bind(originalPromise); + function newPromise(executor) { + return new originalPromise(executor); + } + function promiseResolvedWith(value) { + return originalPromiseResolve(value); + } + function promiseRejectedWith(reason) { + return originalPromiseReject(reason); + } + function PerformPromiseThen(promise, onFulfilled, onRejected) { + return originalPromiseThen.call(promise, onFulfilled, onRejected); + } + function uponPromise(promise, onFulfilled, onRejected) { + PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), void 0, rethrowAssertionErrorRejection); + } + function uponFulfillment(promise, onFulfilled) { + uponPromise(promise, onFulfilled); + } + function uponRejection(promise, onRejected) { + uponPromise(promise, void 0, onRejected); + } + function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) { + return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler); + } + function setPromiseIsHandledToTrue(promise) { + PerformPromiseThen(promise, void 0, rethrowAssertionErrorRejection); + } + const queueMicrotask = (() => { + const globalQueueMicrotask = globals && globals.queueMicrotask; + if (typeof globalQueueMicrotask === "function") { + return globalQueueMicrotask; + } + const resolvedPromise = promiseResolvedWith(void 0); + return (fn) => PerformPromiseThen(resolvedPromise, fn); + })(); + function reflectCall(F2, V, args) { + if (typeof F2 !== "function") { + throw new TypeError("Argument is not a function"); + } + return Function.prototype.apply.call(F2, V, args); + } + function promiseCall(F2, V, args) { + try { + return promiseResolvedWith(reflectCall(F2, V, args)); + } catch (value) { + return promiseRejectedWith(value); + } + } + const QUEUE_MAX_ARRAY_SIZE = 16384; + class SimpleQueue { + constructor() { + this._cursor = 0; + this._size = 0; + this._front = { + _elements: [], + _next: void 0 + }; + this._back = this._front; + this._cursor = 0; + this._size = 0; + } + get length() { + return this._size; + } + push(element) { + const oldBack = this._back; + let newBack = oldBack; + if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) { + newBack = { + _elements: [], + _next: void 0 + }; + } + oldBack._elements.push(element); + if (newBack !== oldBack) { + this._back = newBack; + oldBack._next = newBack; + } + ++this._size; + } + shift() { + const oldFront = this._front; + let newFront = oldFront; + const oldCursor = this._cursor; + let newCursor = oldCursor + 1; + const elements = oldFront._elements; + const element = elements[oldCursor]; + if (newCursor === QUEUE_MAX_ARRAY_SIZE) { + newFront = oldFront._next; + newCursor = 0; + } + --this._size; + this._cursor = newCursor; + if (oldFront !== newFront) { + this._front = newFront; + } + elements[oldCursor] = void 0; + return element; + } + forEach(callback) { + let i2 = this._cursor; + let node = this._front; + let elements = node._elements; + while (i2 !== elements.length || node._next !== void 0) { + if (i2 === elements.length) { + node = node._next; + elements = node._elements; + i2 = 0; + if (elements.length === 0) { + break; + } + } + callback(elements[i2]); + ++i2; + } + } + peek() { + const front = this._front; + const cursor = this._cursor; + return front._elements[cursor]; + } + } + function ReadableStreamReaderGenericInitialize(reader, stream) { + reader._ownerReadableStream = stream; + stream._reader = reader; + if (stream._state === "readable") { + defaultReaderClosedPromiseInitialize(reader); + } else if (stream._state === "closed") { + defaultReaderClosedPromiseInitializeAsResolved(reader); + } else { + defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError); + } + } + function ReadableStreamReaderGenericCancel(reader, reason) { + const stream = reader._ownerReadableStream; + return ReadableStreamCancel(stream, reason); + } + function ReadableStreamReaderGenericRelease(reader) { + if (reader._ownerReadableStream._state === "readable") { + defaultReaderClosedPromiseReject(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`)); + } else { + defaultReaderClosedPromiseResetToRejected(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`)); + } + reader._ownerReadableStream._reader = void 0; + reader._ownerReadableStream = void 0; + } + function readerLockException(name) { + return new TypeError("Cannot " + name + " a stream using a released reader"); + } + function defaultReaderClosedPromiseInitialize(reader) { + reader._closedPromise = newPromise((resolve, reject) => { + reader._closedPromise_resolve = resolve; + reader._closedPromise_reject = reject; + }); + } + function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) { + defaultReaderClosedPromiseInitialize(reader); + defaultReaderClosedPromiseReject(reader, reason); + } + function defaultReaderClosedPromiseInitializeAsResolved(reader) { + defaultReaderClosedPromiseInitialize(reader); + defaultReaderClosedPromiseResolve(reader); + } + function defaultReaderClosedPromiseReject(reader, reason) { + if (reader._closedPromise_reject === void 0) { + return; + } + setPromiseIsHandledToTrue(reader._closedPromise); + reader._closedPromise_reject(reason); + reader._closedPromise_resolve = void 0; + reader._closedPromise_reject = void 0; + } + function defaultReaderClosedPromiseResetToRejected(reader, reason) { + defaultReaderClosedPromiseInitializeAsRejected(reader, reason); + } + function defaultReaderClosedPromiseResolve(reader) { + if (reader._closedPromise_resolve === void 0) { + return; + } + reader._closedPromise_resolve(void 0); + reader._closedPromise_resolve = void 0; + reader._closedPromise_reject = void 0; + } + const AbortSteps = SymbolPolyfill("[[AbortSteps]]"); + const ErrorSteps = SymbolPolyfill("[[ErrorSteps]]"); + const CancelSteps = SymbolPolyfill("[[CancelSteps]]"); + const PullSteps = SymbolPolyfill("[[PullSteps]]"); + const NumberIsFinite = Number.isFinite || function(x2) { + return typeof x2 === "number" && isFinite(x2); + }; + const MathTrunc = Math.trunc || function(v) { + return v < 0 ? Math.ceil(v) : Math.floor(v); + }; + function isDictionary(x2) { + return typeof x2 === "object" || typeof x2 === "function"; + } + function assertDictionary(obj, context) { + if (obj !== void 0 && !isDictionary(obj)) { + throw new TypeError(`${context} is not an object.`); + } + } + function assertFunction(x2, context) { + if (typeof x2 !== "function") { + throw new TypeError(`${context} is not a function.`); + } + } + function isObject(x2) { + return typeof x2 === "object" && x2 !== null || typeof x2 === "function"; + } + function assertObject(x2, context) { + if (!isObject(x2)) { + throw new TypeError(`${context} is not an object.`); + } + } + function assertRequiredArgument(x2, position, context) { + if (x2 === void 0) { + throw new TypeError(`Parameter ${position} is required in '${context}'.`); + } + } + function assertRequiredField(x2, field, context) { + if (x2 === void 0) { + throw new TypeError(`${field} is required in '${context}'.`); + } + } + function convertUnrestrictedDouble(value) { + return Number(value); + } + function censorNegativeZero(x2) { + return x2 === 0 ? 0 : x2; + } + function integerPart(x2) { + return censorNegativeZero(MathTrunc(x2)); + } + function convertUnsignedLongLongWithEnforceRange(value, context) { + const lowerBound = 0; + const upperBound = Number.MAX_SAFE_INTEGER; + let x2 = Number(value); + x2 = censorNegativeZero(x2); + if (!NumberIsFinite(x2)) { + throw new TypeError(`${context} is not a finite number`); + } + x2 = integerPart(x2); + if (x2 < lowerBound || x2 > upperBound) { + throw new TypeError(`${context} is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`); + } + if (!NumberIsFinite(x2) || x2 === 0) { + return 0; + } + return x2; + } + function assertReadableStream(x2, context) { + if (!IsReadableStream(x2)) { + throw new TypeError(`${context} is not a ReadableStream.`); + } + } + function AcquireReadableStreamDefaultReader(stream) { + return new ReadableStreamDefaultReader(stream); + } + function ReadableStreamAddReadRequest(stream, readRequest) { + stream._reader._readRequests.push(readRequest); + } + function ReadableStreamFulfillReadRequest(stream, chunk, done) { + const reader = stream._reader; + const readRequest = reader._readRequests.shift(); + if (done) { + readRequest._closeSteps(); + } else { + readRequest._chunkSteps(chunk); + } + } + function ReadableStreamGetNumReadRequests(stream) { + return stream._reader._readRequests.length; + } + function ReadableStreamHasDefaultReader(stream) { + const reader = stream._reader; + if (reader === void 0) { + return false; + } + if (!IsReadableStreamDefaultReader(reader)) { + return false; + } + return true; + } + class ReadableStreamDefaultReader { + constructor(stream) { + assertRequiredArgument(stream, 1, "ReadableStreamDefaultReader"); + assertReadableStream(stream, "First parameter"); + if (IsReadableStreamLocked(stream)) { + throw new TypeError("This stream has already been locked for exclusive reading by another reader"); + } + ReadableStreamReaderGenericInitialize(this, stream); + this._readRequests = new SimpleQueue(); + } + get closed() { + if (!IsReadableStreamDefaultReader(this)) { + return promiseRejectedWith(defaultReaderBrandCheckException("closed")); + } + return this._closedPromise; + } + cancel(reason = void 0) { + if (!IsReadableStreamDefaultReader(this)) { + return promiseRejectedWith(defaultReaderBrandCheckException("cancel")); + } + if (this._ownerReadableStream === void 0) { + return promiseRejectedWith(readerLockException("cancel")); + } + return ReadableStreamReaderGenericCancel(this, reason); + } + read() { + if (!IsReadableStreamDefaultReader(this)) { + return promiseRejectedWith(defaultReaderBrandCheckException("read")); + } + if (this._ownerReadableStream === void 0) { + return promiseRejectedWith(readerLockException("read from")); + } + let resolvePromise; + let rejectPromise; + const promise = newPromise((resolve, reject) => { + resolvePromise = resolve; + rejectPromise = reject; + }); + const readRequest = { + _chunkSteps: (chunk) => resolvePromise({ value: chunk, done: false }), + _closeSteps: () => resolvePromise({ value: void 0, done: true }), + _errorSteps: (e2) => rejectPromise(e2) + }; + ReadableStreamDefaultReaderRead(this, readRequest); + return promise; + } + releaseLock() { + if (!IsReadableStreamDefaultReader(this)) { + throw defaultReaderBrandCheckException("releaseLock"); + } + if (this._ownerReadableStream === void 0) { + return; + } + if (this._readRequests.length > 0) { + throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled"); + } + ReadableStreamReaderGenericRelease(this); + } + } + Object.defineProperties(ReadableStreamDefaultReader.prototype, { + cancel: { enumerable: true }, + read: { enumerable: true }, + releaseLock: { enumerable: true }, + closed: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === "symbol") { + Object.defineProperty(ReadableStreamDefaultReader.prototype, SymbolPolyfill.toStringTag, { + value: "ReadableStreamDefaultReader", + configurable: true + }); + } + function IsReadableStreamDefaultReader(x2) { + if (!typeIsObject(x2)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x2, "_readRequests")) { + return false; + } + return x2 instanceof ReadableStreamDefaultReader; + } + function ReadableStreamDefaultReaderRead(reader, readRequest) { + const stream = reader._ownerReadableStream; + stream._disturbed = true; + if (stream._state === "closed") { + readRequest._closeSteps(); + } else if (stream._state === "errored") { + readRequest._errorSteps(stream._storedError); + } else { + stream._readableStreamController[PullSteps](readRequest); + } + } + function defaultReaderBrandCheckException(name) { + return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`); + } + const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () { + }).prototype); + class ReadableStreamAsyncIteratorImpl { + constructor(reader, preventCancel) { + this._ongoingPromise = void 0; + this._isFinished = false; + this._reader = reader; + this._preventCancel = preventCancel; + } + next() { + const nextSteps = () => this._nextSteps(); + this._ongoingPromise = this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) : nextSteps(); + return this._ongoingPromise; + } + return(value) { + const returnSteps = () => this._returnSteps(value); + return this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) : returnSteps(); + } + _nextSteps() { + if (this._isFinished) { + return Promise.resolve({ value: void 0, done: true }); + } + const reader = this._reader; + if (reader._ownerReadableStream === void 0) { + return promiseRejectedWith(readerLockException("iterate")); + } + let resolvePromise; + let rejectPromise; + const promise = newPromise((resolve, reject) => { + resolvePromise = resolve; + rejectPromise = reject; + }); + const readRequest = { + _chunkSteps: (chunk) => { + this._ongoingPromise = void 0; + queueMicrotask(() => resolvePromise({ value: chunk, done: false })); + }, + _closeSteps: () => { + this._ongoingPromise = void 0; + this._isFinished = true; + ReadableStreamReaderGenericRelease(reader); + resolvePromise({ value: void 0, done: true }); + }, + _errorSteps: (reason) => { + this._ongoingPromise = void 0; + this._isFinished = true; + ReadableStreamReaderGenericRelease(reader); + rejectPromise(reason); + } + }; + ReadableStreamDefaultReaderRead(reader, readRequest); + return promise; + } + _returnSteps(value) { + if (this._isFinished) { + return Promise.resolve({ value, done: true }); + } + this._isFinished = true; + const reader = this._reader; + if (reader._ownerReadableStream === void 0) { + return promiseRejectedWith(readerLockException("finish iterating")); + } + if (!this._preventCancel) { + const result = ReadableStreamReaderGenericCancel(reader, value); + ReadableStreamReaderGenericRelease(reader); + return transformPromiseWith(result, () => ({ value, done: true })); + } + ReadableStreamReaderGenericRelease(reader); + return promiseResolvedWith({ value, done: true }); + } + } + const ReadableStreamAsyncIteratorPrototype = { + next() { + if (!IsReadableStreamAsyncIterator(this)) { + return promiseRejectedWith(streamAsyncIteratorBrandCheckException("next")); + } + return this._asyncIteratorImpl.next(); + }, + return(value) { + if (!IsReadableStreamAsyncIterator(this)) { + return promiseRejectedWith(streamAsyncIteratorBrandCheckException("return")); + } + return this._asyncIteratorImpl.return(value); + } + }; + if (AsyncIteratorPrototype !== void 0) { + Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype); + } + function AcquireReadableStreamAsyncIterator(stream, preventCancel) { + const reader = AcquireReadableStreamDefaultReader(stream); + const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel); + const iterator = Object.create(ReadableStreamAsyncIteratorPrototype); + iterator._asyncIteratorImpl = impl; + return iterator; + } + function IsReadableStreamAsyncIterator(x2) { + if (!typeIsObject(x2)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x2, "_asyncIteratorImpl")) { + return false; + } + try { + return x2._asyncIteratorImpl instanceof ReadableStreamAsyncIteratorImpl; + } catch (_a) { + return false; + } + } + function streamAsyncIteratorBrandCheckException(name) { + return new TypeError(`ReadableStreamAsyncIterator.${name} can only be used on a ReadableSteamAsyncIterator`); + } + const NumberIsNaN = Number.isNaN || function(x2) { + return x2 !== x2; + }; + function CreateArrayFromList(elements) { + return elements.slice(); + } + function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) { + new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset); + } + function TransferArrayBuffer(O) { + return O; + } + function IsDetachedBuffer(O) { + return false; + } + function ArrayBufferSlice(buffer, begin, end) { + if (buffer.slice) { + return buffer.slice(begin, end); + } + const length = end - begin; + const slice = new ArrayBuffer(length); + CopyDataBlockBytes(slice, 0, buffer, begin, length); + return slice; + } + function IsNonNegativeNumber(v) { + if (typeof v !== "number") { + return false; + } + if (NumberIsNaN(v)) { + return false; + } + if (v < 0) { + return false; + } + return true; + } + function CloneAsUint8Array(O) { + const buffer = ArrayBufferSlice(O.buffer, O.byteOffset, O.byteOffset + O.byteLength); + return new Uint8Array(buffer); + } + function DequeueValue(container) { + const pair = container._queue.shift(); + container._queueTotalSize -= pair.size; + if (container._queueTotalSize < 0) { + container._queueTotalSize = 0; + } + return pair.value; + } + function EnqueueValueWithSize(container, value, size) { + if (!IsNonNegativeNumber(size) || size === Infinity) { + throw new RangeError("Size must be a finite, non-NaN, non-negative number."); + } + container._queue.push({ value, size }); + container._queueTotalSize += size; + } + function PeekQueueValue(container) { + const pair = container._queue.peek(); + return pair.value; + } + function ResetQueue(container) { + container._queue = new SimpleQueue(); + container._queueTotalSize = 0; + } + class ReadableStreamBYOBRequest { + constructor() { + throw new TypeError("Illegal constructor"); + } + get view() { + if (!IsReadableStreamBYOBRequest(this)) { + throw byobRequestBrandCheckException("view"); + } + return this._view; + } + respond(bytesWritten) { + if (!IsReadableStreamBYOBRequest(this)) { + throw byobRequestBrandCheckException("respond"); + } + assertRequiredArgument(bytesWritten, 1, "respond"); + bytesWritten = convertUnsignedLongLongWithEnforceRange(bytesWritten, "First parameter"); + if (this._associatedReadableByteStreamController === void 0) { + throw new TypeError("This BYOB request has been invalidated"); + } + if (IsDetachedBuffer(this._view.buffer)) + ; + ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten); + } + respondWithNewView(view) { + if (!IsReadableStreamBYOBRequest(this)) { + throw byobRequestBrandCheckException("respondWithNewView"); + } + assertRequiredArgument(view, 1, "respondWithNewView"); + if (!ArrayBuffer.isView(view)) { + throw new TypeError("You can only respond with array buffer views"); + } + if (this._associatedReadableByteStreamController === void 0) { + throw new TypeError("This BYOB request has been invalidated"); + } + if (IsDetachedBuffer(view.buffer)) + ; + ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view); + } + } + Object.defineProperties(ReadableStreamBYOBRequest.prototype, { + respond: { enumerable: true }, + respondWithNewView: { enumerable: true }, + view: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === "symbol") { + Object.defineProperty(ReadableStreamBYOBRequest.prototype, SymbolPolyfill.toStringTag, { + value: "ReadableStreamBYOBRequest", + configurable: true + }); + } + class ReadableByteStreamController { + constructor() { + throw new TypeError("Illegal constructor"); + } + get byobRequest() { + if (!IsReadableByteStreamController(this)) { + throw byteStreamControllerBrandCheckException("byobRequest"); + } + return ReadableByteStreamControllerGetBYOBRequest(this); + } + get desiredSize() { + if (!IsReadableByteStreamController(this)) { + throw byteStreamControllerBrandCheckException("desiredSize"); + } + return ReadableByteStreamControllerGetDesiredSize(this); + } + close() { + if (!IsReadableByteStreamController(this)) { + throw byteStreamControllerBrandCheckException("close"); + } + if (this._closeRequested) { + throw new TypeError("The stream has already been closed; do not close it again!"); + } + const state = this._controlledReadableByteStream._state; + if (state !== "readable") { + throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be closed`); + } + ReadableByteStreamControllerClose(this); + } + enqueue(chunk) { + if (!IsReadableByteStreamController(this)) { + throw byteStreamControllerBrandCheckException("enqueue"); + } + assertRequiredArgument(chunk, 1, "enqueue"); + if (!ArrayBuffer.isView(chunk)) { + throw new TypeError("chunk must be an array buffer view"); + } + if (chunk.byteLength === 0) { + throw new TypeError("chunk must have non-zero byteLength"); + } + if (chunk.buffer.byteLength === 0) { + throw new TypeError(`chunk's buffer must have non-zero byteLength`); + } + if (this._closeRequested) { + throw new TypeError("stream is closed or draining"); + } + const state = this._controlledReadableByteStream._state; + if (state !== "readable") { + throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be enqueued to`); + } + ReadableByteStreamControllerEnqueue(this, chunk); + } + error(e2 = void 0) { + if (!IsReadableByteStreamController(this)) { + throw byteStreamControllerBrandCheckException("error"); + } + ReadableByteStreamControllerError(this, e2); + } + [CancelSteps](reason) { + ReadableByteStreamControllerClearPendingPullIntos(this); + ResetQueue(this); + const result = this._cancelAlgorithm(reason); + ReadableByteStreamControllerClearAlgorithms(this); + return result; + } + [PullSteps](readRequest) { + const stream = this._controlledReadableByteStream; + if (this._queueTotalSize > 0) { + const entry = this._queue.shift(); + this._queueTotalSize -= entry.byteLength; + ReadableByteStreamControllerHandleQueueDrain(this); + const view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength); + readRequest._chunkSteps(view); + return; + } + const autoAllocateChunkSize = this._autoAllocateChunkSize; + if (autoAllocateChunkSize !== void 0) { + let buffer; + try { + buffer = new ArrayBuffer(autoAllocateChunkSize); + } catch (bufferE) { + readRequest._errorSteps(bufferE); + return; + } + const pullIntoDescriptor = { + buffer, + bufferByteLength: autoAllocateChunkSize, + byteOffset: 0, + byteLength: autoAllocateChunkSize, + bytesFilled: 0, + elementSize: 1, + viewConstructor: Uint8Array, + readerType: "default" + }; + this._pendingPullIntos.push(pullIntoDescriptor); + } + ReadableStreamAddReadRequest(stream, readRequest); + ReadableByteStreamControllerCallPullIfNeeded(this); + } + } + Object.defineProperties(ReadableByteStreamController.prototype, { + close: { enumerable: true }, + enqueue: { enumerable: true }, + error: { enumerable: true }, + byobRequest: { enumerable: true }, + desiredSize: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === "symbol") { + Object.defineProperty(ReadableByteStreamController.prototype, SymbolPolyfill.toStringTag, { + value: "ReadableByteStreamController", + configurable: true + }); + } + function IsReadableByteStreamController(x2) { + if (!typeIsObject(x2)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x2, "_controlledReadableByteStream")) { + return false; + } + return x2 instanceof ReadableByteStreamController; + } + function IsReadableStreamBYOBRequest(x2) { + if (!typeIsObject(x2)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x2, "_associatedReadableByteStreamController")) { + return false; + } + return x2 instanceof ReadableStreamBYOBRequest; + } + function ReadableByteStreamControllerCallPullIfNeeded(controller) { + const shouldPull = ReadableByteStreamControllerShouldCallPull(controller); + if (!shouldPull) { + return; + } + if (controller._pulling) { + controller._pullAgain = true; + return; + } + controller._pulling = true; + const pullPromise = controller._pullAlgorithm(); + uponPromise(pullPromise, () => { + controller._pulling = false; + if (controller._pullAgain) { + controller._pullAgain = false; + ReadableByteStreamControllerCallPullIfNeeded(controller); + } + }, (e2) => { + ReadableByteStreamControllerError(controller, e2); + }); + } + function ReadableByteStreamControllerClearPendingPullIntos(controller) { + ReadableByteStreamControllerInvalidateBYOBRequest(controller); + controller._pendingPullIntos = new SimpleQueue(); + } + function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) { + let done = false; + if (stream._state === "closed") { + done = true; + } + const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor); + if (pullIntoDescriptor.readerType === "default") { + ReadableStreamFulfillReadRequest(stream, filledView, done); + } else { + ReadableStreamFulfillReadIntoRequest(stream, filledView, done); + } + } + function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) { + const bytesFilled = pullIntoDescriptor.bytesFilled; + const elementSize = pullIntoDescriptor.elementSize; + return new pullIntoDescriptor.viewConstructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize); + } + function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) { + controller._queue.push({ buffer, byteOffset, byteLength }); + controller._queueTotalSize += byteLength; + } + function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) { + const elementSize = pullIntoDescriptor.elementSize; + const currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize; + const maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled); + const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy; + const maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize; + let totalBytesToCopyRemaining = maxBytesToCopy; + let ready = false; + if (maxAlignedBytes > currentAlignedBytes) { + totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled; + ready = true; + } + const queue = controller._queue; + while (totalBytesToCopyRemaining > 0) { + const headOfQueue = queue.peek(); + const bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength); + const destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled; + CopyDataBlockBytes(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy); + if (headOfQueue.byteLength === bytesToCopy) { + queue.shift(); + } else { + headOfQueue.byteOffset += bytesToCopy; + headOfQueue.byteLength -= bytesToCopy; + } + controller._queueTotalSize -= bytesToCopy; + ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor); + totalBytesToCopyRemaining -= bytesToCopy; + } + return ready; + } + function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) { + pullIntoDescriptor.bytesFilled += size; + } + function ReadableByteStreamControllerHandleQueueDrain(controller) { + if (controller._queueTotalSize === 0 && controller._closeRequested) { + ReadableByteStreamControllerClearAlgorithms(controller); + ReadableStreamClose(controller._controlledReadableByteStream); + } else { + ReadableByteStreamControllerCallPullIfNeeded(controller); + } + } + function ReadableByteStreamControllerInvalidateBYOBRequest(controller) { + if (controller._byobRequest === null) { + return; + } + controller._byobRequest._associatedReadableByteStreamController = void 0; + controller._byobRequest._view = null; + controller._byobRequest = null; + } + function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) { + while (controller._pendingPullIntos.length > 0) { + if (controller._queueTotalSize === 0) { + return; + } + const pullIntoDescriptor = controller._pendingPullIntos.peek(); + if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) { + ReadableByteStreamControllerShiftPendingPullInto(controller); + ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor); + } + } + } + function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest) { + const stream = controller._controlledReadableByteStream; + let elementSize = 1; + if (view.constructor !== DataView) { + elementSize = view.constructor.BYTES_PER_ELEMENT; + } + const ctor = view.constructor; + const buffer = TransferArrayBuffer(view.buffer); + const pullIntoDescriptor = { + buffer, + bufferByteLength: buffer.byteLength, + byteOffset: view.byteOffset, + byteLength: view.byteLength, + bytesFilled: 0, + elementSize, + viewConstructor: ctor, + readerType: "byob" + }; + if (controller._pendingPullIntos.length > 0) { + controller._pendingPullIntos.push(pullIntoDescriptor); + ReadableStreamAddReadIntoRequest(stream, readIntoRequest); + return; + } + if (stream._state === "closed") { + const emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0); + readIntoRequest._closeSteps(emptyView); + return; + } + if (controller._queueTotalSize > 0) { + if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) { + const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor); + ReadableByteStreamControllerHandleQueueDrain(controller); + readIntoRequest._chunkSteps(filledView); + return; + } + if (controller._closeRequested) { + const e2 = new TypeError("Insufficient bytes to fill elements in the given buffer"); + ReadableByteStreamControllerError(controller, e2); + readIntoRequest._errorSteps(e2); + return; + } + } + controller._pendingPullIntos.push(pullIntoDescriptor); + ReadableStreamAddReadIntoRequest(stream, readIntoRequest); + ReadableByteStreamControllerCallPullIfNeeded(controller); + } + function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) { + const stream = controller._controlledReadableByteStream; + if (ReadableStreamHasBYOBReader(stream)) { + while (ReadableStreamGetNumReadIntoRequests(stream) > 0) { + const pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller); + ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor); + } + } + } + function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) { + ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor); + if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) { + return; + } + ReadableByteStreamControllerShiftPendingPullInto(controller); + const remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize; + if (remainderSize > 0) { + const end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled; + const remainder = ArrayBufferSlice(pullIntoDescriptor.buffer, end - remainderSize, end); + ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength); + } + pullIntoDescriptor.bytesFilled -= remainderSize; + ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor); + ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller); + } + function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) { + const firstDescriptor = controller._pendingPullIntos.peek(); + ReadableByteStreamControllerInvalidateBYOBRequest(controller); + const state = controller._controlledReadableByteStream._state; + if (state === "closed") { + ReadableByteStreamControllerRespondInClosedState(controller); + } else { + ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor); + } + ReadableByteStreamControllerCallPullIfNeeded(controller); + } + function ReadableByteStreamControllerShiftPendingPullInto(controller) { + const descriptor = controller._pendingPullIntos.shift(); + return descriptor; + } + function ReadableByteStreamControllerShouldCallPull(controller) { + const stream = controller._controlledReadableByteStream; + if (stream._state !== "readable") { + return false; + } + if (controller._closeRequested) { + return false; + } + if (!controller._started) { + return false; + } + if (ReadableStreamHasDefaultReader(stream) && ReadableStreamGetNumReadRequests(stream) > 0) { + return true; + } + if (ReadableStreamHasBYOBReader(stream) && ReadableStreamGetNumReadIntoRequests(stream) > 0) { + return true; + } + const desiredSize = ReadableByteStreamControllerGetDesiredSize(controller); + if (desiredSize > 0) { + return true; + } + return false; + } + function ReadableByteStreamControllerClearAlgorithms(controller) { + controller._pullAlgorithm = void 0; + controller._cancelAlgorithm = void 0; + } + function ReadableByteStreamControllerClose(controller) { + const stream = controller._controlledReadableByteStream; + if (controller._closeRequested || stream._state !== "readable") { + return; + } + if (controller._queueTotalSize > 0) { + controller._closeRequested = true; + return; + } + if (controller._pendingPullIntos.length > 0) { + const firstPendingPullInto = controller._pendingPullIntos.peek(); + if (firstPendingPullInto.bytesFilled > 0) { + const e2 = new TypeError("Insufficient bytes to fill elements in the given buffer"); + ReadableByteStreamControllerError(controller, e2); + throw e2; + } + } + ReadableByteStreamControllerClearAlgorithms(controller); + ReadableStreamClose(stream); + } + function ReadableByteStreamControllerEnqueue(controller, chunk) { + const stream = controller._controlledReadableByteStream; + if (controller._closeRequested || stream._state !== "readable") { + return; + } + const buffer = chunk.buffer; + const byteOffset = chunk.byteOffset; + const byteLength = chunk.byteLength; + const transferredBuffer = TransferArrayBuffer(buffer); + if (controller._pendingPullIntos.length > 0) { + const firstPendingPullInto = controller._pendingPullIntos.peek(); + if (IsDetachedBuffer(firstPendingPullInto.buffer)) + ; + firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer); + } + ReadableByteStreamControllerInvalidateBYOBRequest(controller); + if (ReadableStreamHasDefaultReader(stream)) { + if (ReadableStreamGetNumReadRequests(stream) === 0) { + ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength); + } else { + if (controller._pendingPullIntos.length > 0) { + ReadableByteStreamControllerShiftPendingPullInto(controller); + } + const transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength); + ReadableStreamFulfillReadRequest(stream, transferredView, false); + } + } else if (ReadableStreamHasBYOBReader(stream)) { + ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength); + ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller); + } else { + ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength); + } + ReadableByteStreamControllerCallPullIfNeeded(controller); + } + function ReadableByteStreamControllerError(controller, e2) { + const stream = controller._controlledReadableByteStream; + if (stream._state !== "readable") { + return; + } + ReadableByteStreamControllerClearPendingPullIntos(controller); + ResetQueue(controller); + ReadableByteStreamControllerClearAlgorithms(controller); + ReadableStreamError(stream, e2); + } + function ReadableByteStreamControllerGetBYOBRequest(controller) { + if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) { + const firstDescriptor = controller._pendingPullIntos.peek(); + const view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled); + const byobRequest = Object.create(ReadableStreamBYOBRequest.prototype); + SetUpReadableStreamBYOBRequest(byobRequest, controller, view); + controller._byobRequest = byobRequest; + } + return controller._byobRequest; + } + function ReadableByteStreamControllerGetDesiredSize(controller) { + const state = controller._controlledReadableByteStream._state; + if (state === "errored") { + return null; + } + if (state === "closed") { + return 0; + } + return controller._strategyHWM - controller._queueTotalSize; + } + function ReadableByteStreamControllerRespond(controller, bytesWritten) { + const firstDescriptor = controller._pendingPullIntos.peek(); + const state = controller._controlledReadableByteStream._state; + if (state === "closed") { + if (bytesWritten !== 0) { + throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream"); + } + } else { + if (bytesWritten === 0) { + throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream"); + } + if (firstDescriptor.bytesFilled + bytesWritten > firstDescriptor.byteLength) { + throw new RangeError("bytesWritten out of range"); + } + } + firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer); + ReadableByteStreamControllerRespondInternal(controller, bytesWritten); + } + function ReadableByteStreamControllerRespondWithNewView(controller, view) { + const firstDescriptor = controller._pendingPullIntos.peek(); + const state = controller._controlledReadableByteStream._state; + if (state === "closed") { + if (view.byteLength !== 0) { + throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream"); + } + } else { + if (view.byteLength === 0) { + throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream"); + } + } + if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) { + throw new RangeError("The region specified by view does not match byobRequest"); + } + if (firstDescriptor.bufferByteLength !== view.buffer.byteLength) { + throw new RangeError("The buffer of view has different capacity than byobRequest"); + } + if (firstDescriptor.bytesFilled + view.byteLength > firstDescriptor.byteLength) { + throw new RangeError("The region specified by view is larger than byobRequest"); + } + const viewByteLength = view.byteLength; + firstDescriptor.buffer = TransferArrayBuffer(view.buffer); + ReadableByteStreamControllerRespondInternal(controller, viewByteLength); + } + function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) { + controller._controlledReadableByteStream = stream; + controller._pullAgain = false; + controller._pulling = false; + controller._byobRequest = null; + controller._queue = controller._queueTotalSize = void 0; + ResetQueue(controller); + controller._closeRequested = false; + controller._started = false; + controller._strategyHWM = highWaterMark; + controller._pullAlgorithm = pullAlgorithm; + controller._cancelAlgorithm = cancelAlgorithm; + controller._autoAllocateChunkSize = autoAllocateChunkSize; + controller._pendingPullIntos = new SimpleQueue(); + stream._readableStreamController = controller; + const startResult = startAlgorithm(); + uponPromise(promiseResolvedWith(startResult), () => { + controller._started = true; + ReadableByteStreamControllerCallPullIfNeeded(controller); + }, (r2) => { + ReadableByteStreamControllerError(controller, r2); + }); + } + function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) { + const controller = Object.create(ReadableByteStreamController.prototype); + let startAlgorithm = () => void 0; + let pullAlgorithm = () => promiseResolvedWith(void 0); + let cancelAlgorithm = () => promiseResolvedWith(void 0); + if (underlyingByteSource.start !== void 0) { + startAlgorithm = () => underlyingByteSource.start(controller); + } + if (underlyingByteSource.pull !== void 0) { + pullAlgorithm = () => underlyingByteSource.pull(controller); + } + if (underlyingByteSource.cancel !== void 0) { + cancelAlgorithm = (reason) => underlyingByteSource.cancel(reason); + } + const autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize; + if (autoAllocateChunkSize === 0) { + throw new TypeError("autoAllocateChunkSize must be greater than 0"); + } + SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize); + } + function SetUpReadableStreamBYOBRequest(request, controller, view) { + request._associatedReadableByteStreamController = controller; + request._view = view; + } + function byobRequestBrandCheckException(name) { + return new TypeError(`ReadableStreamBYOBRequest.prototype.${name} can only be used on a ReadableStreamBYOBRequest`); + } + function byteStreamControllerBrandCheckException(name) { + return new TypeError(`ReadableByteStreamController.prototype.${name} can only be used on a ReadableByteStreamController`); + } + function AcquireReadableStreamBYOBReader(stream) { + return new ReadableStreamBYOBReader(stream); + } + function ReadableStreamAddReadIntoRequest(stream, readIntoRequest) { + stream._reader._readIntoRequests.push(readIntoRequest); + } + function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) { + const reader = stream._reader; + const readIntoRequest = reader._readIntoRequests.shift(); + if (done) { + readIntoRequest._closeSteps(chunk); + } else { + readIntoRequest._chunkSteps(chunk); + } + } + function ReadableStreamGetNumReadIntoRequests(stream) { + return stream._reader._readIntoRequests.length; + } + function ReadableStreamHasBYOBReader(stream) { + const reader = stream._reader; + if (reader === void 0) { + return false; + } + if (!IsReadableStreamBYOBReader(reader)) { + return false; + } + return true; + } + class ReadableStreamBYOBReader { + constructor(stream) { + assertRequiredArgument(stream, 1, "ReadableStreamBYOBReader"); + assertReadableStream(stream, "First parameter"); + if (IsReadableStreamLocked(stream)) { + throw new TypeError("This stream has already been locked for exclusive reading by another reader"); + } + if (!IsReadableByteStreamController(stream._readableStreamController)) { + throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source"); + } + ReadableStreamReaderGenericInitialize(this, stream); + this._readIntoRequests = new SimpleQueue(); + } + get closed() { + if (!IsReadableStreamBYOBReader(this)) { + return promiseRejectedWith(byobReaderBrandCheckException("closed")); + } + return this._closedPromise; + } + cancel(reason = void 0) { + if (!IsReadableStreamBYOBReader(this)) { + return promiseRejectedWith(byobReaderBrandCheckException("cancel")); + } + if (this._ownerReadableStream === void 0) { + return promiseRejectedWith(readerLockException("cancel")); + } + return ReadableStreamReaderGenericCancel(this, reason); + } + read(view) { + if (!IsReadableStreamBYOBReader(this)) { + return promiseRejectedWith(byobReaderBrandCheckException("read")); + } + if (!ArrayBuffer.isView(view)) { + return promiseRejectedWith(new TypeError("view must be an array buffer view")); + } + if (view.byteLength === 0) { + return promiseRejectedWith(new TypeError("view must have non-zero byteLength")); + } + if (view.buffer.byteLength === 0) { + return promiseRejectedWith(new TypeError(`view's buffer must have non-zero byteLength`)); + } + if (IsDetachedBuffer(view.buffer)) + ; + if (this._ownerReadableStream === void 0) { + return promiseRejectedWith(readerLockException("read from")); + } + let resolvePromise; + let rejectPromise; + const promise = newPromise((resolve, reject) => { + resolvePromise = resolve; + rejectPromise = reject; + }); + const readIntoRequest = { + _chunkSteps: (chunk) => resolvePromise({ value: chunk, done: false }), + _closeSteps: (chunk) => resolvePromise({ value: chunk, done: true }), + _errorSteps: (e2) => rejectPromise(e2) + }; + ReadableStreamBYOBReaderRead(this, view, readIntoRequest); + return promise; + } + releaseLock() { + if (!IsReadableStreamBYOBReader(this)) { + throw byobReaderBrandCheckException("releaseLock"); + } + if (this._ownerReadableStream === void 0) { + return; + } + if (this._readIntoRequests.length > 0) { + throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled"); + } + ReadableStreamReaderGenericRelease(this); + } + } + Object.defineProperties(ReadableStreamBYOBReader.prototype, { + cancel: { enumerable: true }, + read: { enumerable: true }, + releaseLock: { enumerable: true }, + closed: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === "symbol") { + Object.defineProperty(ReadableStreamBYOBReader.prototype, SymbolPolyfill.toStringTag, { + value: "ReadableStreamBYOBReader", + configurable: true + }); + } + function IsReadableStreamBYOBReader(x2) { + if (!typeIsObject(x2)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x2, "_readIntoRequests")) { + return false; + } + return x2 instanceof ReadableStreamBYOBReader; + } + function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) { + const stream = reader._ownerReadableStream; + stream._disturbed = true; + if (stream._state === "errored") { + readIntoRequest._errorSteps(stream._storedError); + } else { + ReadableByteStreamControllerPullInto(stream._readableStreamController, view, readIntoRequest); + } + } + function byobReaderBrandCheckException(name) { + return new TypeError(`ReadableStreamBYOBReader.prototype.${name} can only be used on a ReadableStreamBYOBReader`); + } + function ExtractHighWaterMark(strategy, defaultHWM) { + const { highWaterMark } = strategy; + if (highWaterMark === void 0) { + return defaultHWM; + } + if (NumberIsNaN(highWaterMark) || highWaterMark < 0) { + throw new RangeError("Invalid highWaterMark"); + } + return highWaterMark; + } + function ExtractSizeAlgorithm(strategy) { + const { size } = strategy; + if (!size) { + return () => 1; + } + return size; + } + function convertQueuingStrategy(init, context) { + assertDictionary(init, context); + const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark; + const size = init === null || init === void 0 ? void 0 : init.size; + return { + highWaterMark: highWaterMark === void 0 ? void 0 : convertUnrestrictedDouble(highWaterMark), + size: size === void 0 ? void 0 : convertQueuingStrategySize(size, `${context} has member 'size' that`) + }; + } + function convertQueuingStrategySize(fn, context) { + assertFunction(fn, context); + return (chunk) => convertUnrestrictedDouble(fn(chunk)); + } + function convertUnderlyingSink(original, context) { + assertDictionary(original, context); + const abort = original === null || original === void 0 ? void 0 : original.abort; + const close = original === null || original === void 0 ? void 0 : original.close; + const start = original === null || original === void 0 ? void 0 : original.start; + const type = original === null || original === void 0 ? void 0 : original.type; + const write2 = original === null || original === void 0 ? void 0 : original.write; + return { + abort: abort === void 0 ? void 0 : convertUnderlyingSinkAbortCallback(abort, original, `${context} has member 'abort' that`), + close: close === void 0 ? void 0 : convertUnderlyingSinkCloseCallback(close, original, `${context} has member 'close' that`), + start: start === void 0 ? void 0 : convertUnderlyingSinkStartCallback(start, original, `${context} has member 'start' that`), + write: write2 === void 0 ? void 0 : convertUnderlyingSinkWriteCallback(write2, original, `${context} has member 'write' that`), + type + }; + } + function convertUnderlyingSinkAbortCallback(fn, original, context) { + assertFunction(fn, context); + return (reason) => promiseCall(fn, original, [reason]); + } + function convertUnderlyingSinkCloseCallback(fn, original, context) { + assertFunction(fn, context); + return () => promiseCall(fn, original, []); + } + function convertUnderlyingSinkStartCallback(fn, original, context) { + assertFunction(fn, context); + return (controller) => reflectCall(fn, original, [controller]); + } + function convertUnderlyingSinkWriteCallback(fn, original, context) { + assertFunction(fn, context); + return (chunk, controller) => promiseCall(fn, original, [chunk, controller]); + } + function assertWritableStream(x2, context) { + if (!IsWritableStream(x2)) { + throw new TypeError(`${context} is not a WritableStream.`); + } + } + function isAbortSignal2(value) { + if (typeof value !== "object" || value === null) { + return false; + } + try { + return typeof value.aborted === "boolean"; + } catch (_a) { + return false; + } + } + const supportsAbortController = typeof AbortController === "function"; + function createAbortController() { + if (supportsAbortController) { + return new AbortController(); + } + return void 0; + } + class WritableStream { + constructor(rawUnderlyingSink = {}, rawStrategy = {}) { + if (rawUnderlyingSink === void 0) { + rawUnderlyingSink = null; + } else { + assertObject(rawUnderlyingSink, "First parameter"); + } + const strategy = convertQueuingStrategy(rawStrategy, "Second parameter"); + const underlyingSink = convertUnderlyingSink(rawUnderlyingSink, "First parameter"); + InitializeWritableStream(this); + const type = underlyingSink.type; + if (type !== void 0) { + throw new RangeError("Invalid type is specified"); + } + const sizeAlgorithm = ExtractSizeAlgorithm(strategy); + const highWaterMark = ExtractHighWaterMark(strategy, 1); + SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm); + } + get locked() { + if (!IsWritableStream(this)) { + throw streamBrandCheckException$2("locked"); + } + return IsWritableStreamLocked(this); + } + abort(reason = void 0) { + if (!IsWritableStream(this)) { + return promiseRejectedWith(streamBrandCheckException$2("abort")); + } + if (IsWritableStreamLocked(this)) { + return promiseRejectedWith(new TypeError("Cannot abort a stream that already has a writer")); + } + return WritableStreamAbort(this, reason); + } + close() { + if (!IsWritableStream(this)) { + return promiseRejectedWith(streamBrandCheckException$2("close")); + } + if (IsWritableStreamLocked(this)) { + return promiseRejectedWith(new TypeError("Cannot close a stream that already has a writer")); + } + if (WritableStreamCloseQueuedOrInFlight(this)) { + return promiseRejectedWith(new TypeError("Cannot close an already-closing stream")); + } + return WritableStreamClose(this); + } + getWriter() { + if (!IsWritableStream(this)) { + throw streamBrandCheckException$2("getWriter"); + } + return AcquireWritableStreamDefaultWriter(this); + } + } + Object.defineProperties(WritableStream.prototype, { + abort: { enumerable: true }, + close: { enumerable: true }, + getWriter: { enumerable: true }, + locked: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === "symbol") { + Object.defineProperty(WritableStream.prototype, SymbolPolyfill.toStringTag, { + value: "WritableStream", + configurable: true + }); + } + function AcquireWritableStreamDefaultWriter(stream) { + return new WritableStreamDefaultWriter(stream); + } + function CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark = 1, sizeAlgorithm = () => 1) { + const stream = Object.create(WritableStream.prototype); + InitializeWritableStream(stream); + const controller = Object.create(WritableStreamDefaultController.prototype); + SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm); + return stream; + } + function InitializeWritableStream(stream) { + stream._state = "writable"; + stream._storedError = void 0; + stream._writer = void 0; + stream._writableStreamController = void 0; + stream._writeRequests = new SimpleQueue(); + stream._inFlightWriteRequest = void 0; + stream._closeRequest = void 0; + stream._inFlightCloseRequest = void 0; + stream._pendingAbortRequest = void 0; + stream._backpressure = false; + } + function IsWritableStream(x2) { + if (!typeIsObject(x2)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x2, "_writableStreamController")) { + return false; + } + return x2 instanceof WritableStream; + } + function IsWritableStreamLocked(stream) { + if (stream._writer === void 0) { + return false; + } + return true; + } + function WritableStreamAbort(stream, reason) { + var _a; + if (stream._state === "closed" || stream._state === "errored") { + return promiseResolvedWith(void 0); + } + stream._writableStreamController._abortReason = reason; + (_a = stream._writableStreamController._abortController) === null || _a === void 0 ? void 0 : _a.abort(); + const state = stream._state; + if (state === "closed" || state === "errored") { + return promiseResolvedWith(void 0); + } + if (stream._pendingAbortRequest !== void 0) { + return stream._pendingAbortRequest._promise; + } + let wasAlreadyErroring = false; + if (state === "erroring") { + wasAlreadyErroring = true; + reason = void 0; + } + const promise = newPromise((resolve, reject) => { + stream._pendingAbortRequest = { + _promise: void 0, + _resolve: resolve, + _reject: reject, + _reason: reason, + _wasAlreadyErroring: wasAlreadyErroring + }; + }); + stream._pendingAbortRequest._promise = promise; + if (!wasAlreadyErroring) { + WritableStreamStartErroring(stream, reason); + } + return promise; + } + function WritableStreamClose(stream) { + const state = stream._state; + if (state === "closed" || state === "errored") { + return promiseRejectedWith(new TypeError(`The stream (in ${state} state) is not in the writable state and cannot be closed`)); + } + const promise = newPromise((resolve, reject) => { + const closeRequest = { + _resolve: resolve, + _reject: reject + }; + stream._closeRequest = closeRequest; + }); + const writer = stream._writer; + if (writer !== void 0 && stream._backpressure && state === "writable") { + defaultWriterReadyPromiseResolve(writer); + } + WritableStreamDefaultControllerClose(stream._writableStreamController); + return promise; + } + function WritableStreamAddWriteRequest(stream) { + const promise = newPromise((resolve, reject) => { + const writeRequest = { + _resolve: resolve, + _reject: reject + }; + stream._writeRequests.push(writeRequest); + }); + return promise; + } + function WritableStreamDealWithRejection(stream, error) { + const state = stream._state; + if (state === "writable") { + WritableStreamStartErroring(stream, error); + return; + } + WritableStreamFinishErroring(stream); + } + function WritableStreamStartErroring(stream, reason) { + const controller = stream._writableStreamController; + stream._state = "erroring"; + stream._storedError = reason; + const writer = stream._writer; + if (writer !== void 0) { + WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason); + } + if (!WritableStreamHasOperationMarkedInFlight(stream) && controller._started) { + WritableStreamFinishErroring(stream); + } + } + function WritableStreamFinishErroring(stream) { + stream._state = "errored"; + stream._writableStreamController[ErrorSteps](); + const storedError = stream._storedError; + stream._writeRequests.forEach((writeRequest) => { + writeRequest._reject(storedError); + }); + stream._writeRequests = new SimpleQueue(); + if (stream._pendingAbortRequest === void 0) { + WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream); + return; + } + const abortRequest = stream._pendingAbortRequest; + stream._pendingAbortRequest = void 0; + if (abortRequest._wasAlreadyErroring) { + abortRequest._reject(storedError); + WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream); + return; + } + const promise = stream._writableStreamController[AbortSteps](abortRequest._reason); + uponPromise(promise, () => { + abortRequest._resolve(); + WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream); + }, (reason) => { + abortRequest._reject(reason); + WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream); + }); + } + function WritableStreamFinishInFlightWrite(stream) { + stream._inFlightWriteRequest._resolve(void 0); + stream._inFlightWriteRequest = void 0; + } + function WritableStreamFinishInFlightWriteWithError(stream, error) { + stream._inFlightWriteRequest._reject(error); + stream._inFlightWriteRequest = void 0; + WritableStreamDealWithRejection(stream, error); + } + function WritableStreamFinishInFlightClose(stream) { + stream._inFlightCloseRequest._resolve(void 0); + stream._inFlightCloseRequest = void 0; + const state = stream._state; + if (state === "erroring") { + stream._storedError = void 0; + if (stream._pendingAbortRequest !== void 0) { + stream._pendingAbortRequest._resolve(); + stream._pendingAbortRequest = void 0; + } + } + stream._state = "closed"; + const writer = stream._writer; + if (writer !== void 0) { + defaultWriterClosedPromiseResolve(writer); + } + } + function WritableStreamFinishInFlightCloseWithError(stream, error) { + stream._inFlightCloseRequest._reject(error); + stream._inFlightCloseRequest = void 0; + if (stream._pendingAbortRequest !== void 0) { + stream._pendingAbortRequest._reject(error); + stream._pendingAbortRequest = void 0; + } + WritableStreamDealWithRejection(stream, error); + } + function WritableStreamCloseQueuedOrInFlight(stream) { + if (stream._closeRequest === void 0 && stream._inFlightCloseRequest === void 0) { + return false; + } + return true; + } + function WritableStreamHasOperationMarkedInFlight(stream) { + if (stream._inFlightWriteRequest === void 0 && stream._inFlightCloseRequest === void 0) { + return false; + } + return true; + } + function WritableStreamMarkCloseRequestInFlight(stream) { + stream._inFlightCloseRequest = stream._closeRequest; + stream._closeRequest = void 0; + } + function WritableStreamMarkFirstWriteRequestInFlight(stream) { + stream._inFlightWriteRequest = stream._writeRequests.shift(); + } + function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) { + if (stream._closeRequest !== void 0) { + stream._closeRequest._reject(stream._storedError); + stream._closeRequest = void 0; + } + const writer = stream._writer; + if (writer !== void 0) { + defaultWriterClosedPromiseReject(writer, stream._storedError); + } + } + function WritableStreamUpdateBackpressure(stream, backpressure) { + const writer = stream._writer; + if (writer !== void 0 && backpressure !== stream._backpressure) { + if (backpressure) { + defaultWriterReadyPromiseReset(writer); + } else { + defaultWriterReadyPromiseResolve(writer); + } + } + stream._backpressure = backpressure; + } + class WritableStreamDefaultWriter { + constructor(stream) { + assertRequiredArgument(stream, 1, "WritableStreamDefaultWriter"); + assertWritableStream(stream, "First parameter"); + if (IsWritableStreamLocked(stream)) { + throw new TypeError("This stream has already been locked for exclusive writing by another writer"); + } + this._ownerWritableStream = stream; + stream._writer = this; + const state = stream._state; + if (state === "writable") { + if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._backpressure) { + defaultWriterReadyPromiseInitialize(this); + } else { + defaultWriterReadyPromiseInitializeAsResolved(this); + } + defaultWriterClosedPromiseInitialize(this); + } else if (state === "erroring") { + defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError); + defaultWriterClosedPromiseInitialize(this); + } else if (state === "closed") { + defaultWriterReadyPromiseInitializeAsResolved(this); + defaultWriterClosedPromiseInitializeAsResolved(this); + } else { + const storedError = stream._storedError; + defaultWriterReadyPromiseInitializeAsRejected(this, storedError); + defaultWriterClosedPromiseInitializeAsRejected(this, storedError); + } + } + get closed() { + if (!IsWritableStreamDefaultWriter(this)) { + return promiseRejectedWith(defaultWriterBrandCheckException("closed")); + } + return this._closedPromise; + } + get desiredSize() { + if (!IsWritableStreamDefaultWriter(this)) { + throw defaultWriterBrandCheckException("desiredSize"); + } + if (this._ownerWritableStream === void 0) { + throw defaultWriterLockException("desiredSize"); + } + return WritableStreamDefaultWriterGetDesiredSize(this); + } + get ready() { + if (!IsWritableStreamDefaultWriter(this)) { + return promiseRejectedWith(defaultWriterBrandCheckException("ready")); + } + return this._readyPromise; + } + abort(reason = void 0) { + if (!IsWritableStreamDefaultWriter(this)) { + return promiseRejectedWith(defaultWriterBrandCheckException("abort")); + } + if (this._ownerWritableStream === void 0) { + return promiseRejectedWith(defaultWriterLockException("abort")); + } + return WritableStreamDefaultWriterAbort(this, reason); + } + close() { + if (!IsWritableStreamDefaultWriter(this)) { + return promiseRejectedWith(defaultWriterBrandCheckException("close")); + } + const stream = this._ownerWritableStream; + if (stream === void 0) { + return promiseRejectedWith(defaultWriterLockException("close")); + } + if (WritableStreamCloseQueuedOrInFlight(stream)) { + return promiseRejectedWith(new TypeError("Cannot close an already-closing stream")); + } + return WritableStreamDefaultWriterClose(this); + } + releaseLock() { + if (!IsWritableStreamDefaultWriter(this)) { + throw defaultWriterBrandCheckException("releaseLock"); + } + const stream = this._ownerWritableStream; + if (stream === void 0) { + return; + } + WritableStreamDefaultWriterRelease(this); + } + write(chunk = void 0) { + if (!IsWritableStreamDefaultWriter(this)) { + return promiseRejectedWith(defaultWriterBrandCheckException("write")); + } + if (this._ownerWritableStream === void 0) { + return promiseRejectedWith(defaultWriterLockException("write to")); + } + return WritableStreamDefaultWriterWrite(this, chunk); + } + } + Object.defineProperties(WritableStreamDefaultWriter.prototype, { + abort: { enumerable: true }, + close: { enumerable: true }, + releaseLock: { enumerable: true }, + write: { enumerable: true }, + closed: { enumerable: true }, + desiredSize: { enumerable: true }, + ready: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === "symbol") { + Object.defineProperty(WritableStreamDefaultWriter.prototype, SymbolPolyfill.toStringTag, { + value: "WritableStreamDefaultWriter", + configurable: true + }); + } + function IsWritableStreamDefaultWriter(x2) { + if (!typeIsObject(x2)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x2, "_ownerWritableStream")) { + return false; + } + return x2 instanceof WritableStreamDefaultWriter; + } + function WritableStreamDefaultWriterAbort(writer, reason) { + const stream = writer._ownerWritableStream; + return WritableStreamAbort(stream, reason); + } + function WritableStreamDefaultWriterClose(writer) { + const stream = writer._ownerWritableStream; + return WritableStreamClose(stream); + } + function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) { + const stream = writer._ownerWritableStream; + const state = stream._state; + if (WritableStreamCloseQueuedOrInFlight(stream) || state === "closed") { + return promiseResolvedWith(void 0); + } + if (state === "errored") { + return promiseRejectedWith(stream._storedError); + } + return WritableStreamDefaultWriterClose(writer); + } + function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) { + if (writer._closedPromiseState === "pending") { + defaultWriterClosedPromiseReject(writer, error); + } else { + defaultWriterClosedPromiseResetToRejected(writer, error); + } + } + function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) { + if (writer._readyPromiseState === "pending") { + defaultWriterReadyPromiseReject(writer, error); + } else { + defaultWriterReadyPromiseResetToRejected(writer, error); + } + } + function WritableStreamDefaultWriterGetDesiredSize(writer) { + const stream = writer._ownerWritableStream; + const state = stream._state; + if (state === "errored" || state === "erroring") { + return null; + } + if (state === "closed") { + return 0; + } + return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController); + } + function WritableStreamDefaultWriterRelease(writer) { + const stream = writer._ownerWritableStream; + const releasedError = new TypeError(`Writer was released and can no longer be used to monitor the stream's closedness`); + WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError); + WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError); + stream._writer = void 0; + writer._ownerWritableStream = void 0; + } + function WritableStreamDefaultWriterWrite(writer, chunk) { + const stream = writer._ownerWritableStream; + const controller = stream._writableStreamController; + const chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk); + if (stream !== writer._ownerWritableStream) { + return promiseRejectedWith(defaultWriterLockException("write to")); + } + const state = stream._state; + if (state === "errored") { + return promiseRejectedWith(stream._storedError); + } + if (WritableStreamCloseQueuedOrInFlight(stream) || state === "closed") { + return promiseRejectedWith(new TypeError("The stream is closing or closed and cannot be written to")); + } + if (state === "erroring") { + return promiseRejectedWith(stream._storedError); + } + const promise = WritableStreamAddWriteRequest(stream); + WritableStreamDefaultControllerWrite(controller, chunk, chunkSize); + return promise; + } + const closeSentinel = {}; + class WritableStreamDefaultController { + constructor() { + throw new TypeError("Illegal constructor"); + } + get abortReason() { + if (!IsWritableStreamDefaultController(this)) { + throw defaultControllerBrandCheckException$2("abortReason"); + } + return this._abortReason; + } + get signal() { + if (!IsWritableStreamDefaultController(this)) { + throw defaultControllerBrandCheckException$2("signal"); + } + if (this._abortController === void 0) { + throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported"); + } + return this._abortController.signal; + } + error(e2 = void 0) { + if (!IsWritableStreamDefaultController(this)) { + throw defaultControllerBrandCheckException$2("error"); + } + const state = this._controlledWritableStream._state; + if (state !== "writable") { + return; + } + WritableStreamDefaultControllerError(this, e2); + } + [AbortSteps](reason) { + const result = this._abortAlgorithm(reason); + WritableStreamDefaultControllerClearAlgorithms(this); + return result; + } + [ErrorSteps]() { + ResetQueue(this); + } + } + Object.defineProperties(WritableStreamDefaultController.prototype, { + abortReason: { enumerable: true }, + signal: { enumerable: true }, + error: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === "symbol") { + Object.defineProperty(WritableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, { + value: "WritableStreamDefaultController", + configurable: true + }); + } + function IsWritableStreamDefaultController(x2) { + if (!typeIsObject(x2)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x2, "_controlledWritableStream")) { + return false; + } + return x2 instanceof WritableStreamDefaultController; + } + function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) { + controller._controlledWritableStream = stream; + stream._writableStreamController = controller; + controller._queue = void 0; + controller._queueTotalSize = void 0; + ResetQueue(controller); + controller._abortReason = void 0; + controller._abortController = createAbortController(); + controller._started = false; + controller._strategySizeAlgorithm = sizeAlgorithm; + controller._strategyHWM = highWaterMark; + controller._writeAlgorithm = writeAlgorithm; + controller._closeAlgorithm = closeAlgorithm; + controller._abortAlgorithm = abortAlgorithm; + const backpressure = WritableStreamDefaultControllerGetBackpressure(controller); + WritableStreamUpdateBackpressure(stream, backpressure); + const startResult = startAlgorithm(); + const startPromise = promiseResolvedWith(startResult); + uponPromise(startPromise, () => { + controller._started = true; + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + }, (r2) => { + controller._started = true; + WritableStreamDealWithRejection(stream, r2); + }); + } + function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) { + const controller = Object.create(WritableStreamDefaultController.prototype); + let startAlgorithm = () => void 0; + let writeAlgorithm = () => promiseResolvedWith(void 0); + let closeAlgorithm = () => promiseResolvedWith(void 0); + let abortAlgorithm = () => promiseResolvedWith(void 0); + if (underlyingSink.start !== void 0) { + startAlgorithm = () => underlyingSink.start(controller); + } + if (underlyingSink.write !== void 0) { + writeAlgorithm = (chunk) => underlyingSink.write(chunk, controller); + } + if (underlyingSink.close !== void 0) { + closeAlgorithm = () => underlyingSink.close(); + } + if (underlyingSink.abort !== void 0) { + abortAlgorithm = (reason) => underlyingSink.abort(reason); + } + SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm); + } + function WritableStreamDefaultControllerClearAlgorithms(controller) { + controller._writeAlgorithm = void 0; + controller._closeAlgorithm = void 0; + controller._abortAlgorithm = void 0; + controller._strategySizeAlgorithm = void 0; + } + function WritableStreamDefaultControllerClose(controller) { + EnqueueValueWithSize(controller, closeSentinel, 0); + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + } + function WritableStreamDefaultControllerGetChunkSize(controller, chunk) { + try { + return controller._strategySizeAlgorithm(chunk); + } catch (chunkSizeE) { + WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE); + return 1; + } + } + function WritableStreamDefaultControllerGetDesiredSize(controller) { + return controller._strategyHWM - controller._queueTotalSize; + } + function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) { + try { + EnqueueValueWithSize(controller, chunk, chunkSize); + } catch (enqueueE) { + WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE); + return; + } + const stream = controller._controlledWritableStream; + if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._state === "writable") { + const backpressure = WritableStreamDefaultControllerGetBackpressure(controller); + WritableStreamUpdateBackpressure(stream, backpressure); + } + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + } + function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) { + const stream = controller._controlledWritableStream; + if (!controller._started) { + return; + } + if (stream._inFlightWriteRequest !== void 0) { + return; + } + const state = stream._state; + if (state === "erroring") { + WritableStreamFinishErroring(stream); + return; + } + if (controller._queue.length === 0) { + return; + } + const value = PeekQueueValue(controller); + if (value === closeSentinel) { + WritableStreamDefaultControllerProcessClose(controller); + } else { + WritableStreamDefaultControllerProcessWrite(controller, value); + } + } + function WritableStreamDefaultControllerErrorIfNeeded(controller, error) { + if (controller._controlledWritableStream._state === "writable") { + WritableStreamDefaultControllerError(controller, error); + } + } + function WritableStreamDefaultControllerProcessClose(controller) { + const stream = controller._controlledWritableStream; + WritableStreamMarkCloseRequestInFlight(stream); + DequeueValue(controller); + const sinkClosePromise = controller._closeAlgorithm(); + WritableStreamDefaultControllerClearAlgorithms(controller); + uponPromise(sinkClosePromise, () => { + WritableStreamFinishInFlightClose(stream); + }, (reason) => { + WritableStreamFinishInFlightCloseWithError(stream, reason); + }); + } + function WritableStreamDefaultControllerProcessWrite(controller, chunk) { + const stream = controller._controlledWritableStream; + WritableStreamMarkFirstWriteRequestInFlight(stream); + const sinkWritePromise = controller._writeAlgorithm(chunk); + uponPromise(sinkWritePromise, () => { + WritableStreamFinishInFlightWrite(stream); + const state = stream._state; + DequeueValue(controller); + if (!WritableStreamCloseQueuedOrInFlight(stream) && state === "writable") { + const backpressure = WritableStreamDefaultControllerGetBackpressure(controller); + WritableStreamUpdateBackpressure(stream, backpressure); + } + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + }, (reason) => { + if (stream._state === "writable") { + WritableStreamDefaultControllerClearAlgorithms(controller); + } + WritableStreamFinishInFlightWriteWithError(stream, reason); + }); + } + function WritableStreamDefaultControllerGetBackpressure(controller) { + const desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller); + return desiredSize <= 0; + } + function WritableStreamDefaultControllerError(controller, error) { + const stream = controller._controlledWritableStream; + WritableStreamDefaultControllerClearAlgorithms(controller); + WritableStreamStartErroring(stream, error); + } + function streamBrandCheckException$2(name) { + return new TypeError(`WritableStream.prototype.${name} can only be used on a WritableStream`); + } + function defaultControllerBrandCheckException$2(name) { + return new TypeError(`WritableStreamDefaultController.prototype.${name} can only be used on a WritableStreamDefaultController`); + } + function defaultWriterBrandCheckException(name) { + return new TypeError(`WritableStreamDefaultWriter.prototype.${name} can only be used on a WritableStreamDefaultWriter`); + } + function defaultWriterLockException(name) { + return new TypeError("Cannot " + name + " a stream using a released writer"); + } + function defaultWriterClosedPromiseInitialize(writer) { + writer._closedPromise = newPromise((resolve, reject) => { + writer._closedPromise_resolve = resolve; + writer._closedPromise_reject = reject; + writer._closedPromiseState = "pending"; + }); + } + function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) { + defaultWriterClosedPromiseInitialize(writer); + defaultWriterClosedPromiseReject(writer, reason); + } + function defaultWriterClosedPromiseInitializeAsResolved(writer) { + defaultWriterClosedPromiseInitialize(writer); + defaultWriterClosedPromiseResolve(writer); + } + function defaultWriterClosedPromiseReject(writer, reason) { + if (writer._closedPromise_reject === void 0) { + return; + } + setPromiseIsHandledToTrue(writer._closedPromise); + writer._closedPromise_reject(reason); + writer._closedPromise_resolve = void 0; + writer._closedPromise_reject = void 0; + writer._closedPromiseState = "rejected"; + } + function defaultWriterClosedPromiseResetToRejected(writer, reason) { + defaultWriterClosedPromiseInitializeAsRejected(writer, reason); + } + function defaultWriterClosedPromiseResolve(writer) { + if (writer._closedPromise_resolve === void 0) { + return; + } + writer._closedPromise_resolve(void 0); + writer._closedPromise_resolve = void 0; + writer._closedPromise_reject = void 0; + writer._closedPromiseState = "resolved"; + } + function defaultWriterReadyPromiseInitialize(writer) { + writer._readyPromise = newPromise((resolve, reject) => { + writer._readyPromise_resolve = resolve; + writer._readyPromise_reject = reject; + }); + writer._readyPromiseState = "pending"; + } + function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) { + defaultWriterReadyPromiseInitialize(writer); + defaultWriterReadyPromiseReject(writer, reason); + } + function defaultWriterReadyPromiseInitializeAsResolved(writer) { + defaultWriterReadyPromiseInitialize(writer); + defaultWriterReadyPromiseResolve(writer); + } + function defaultWriterReadyPromiseReject(writer, reason) { + if (writer._readyPromise_reject === void 0) { + return; + } + setPromiseIsHandledToTrue(writer._readyPromise); + writer._readyPromise_reject(reason); + writer._readyPromise_resolve = void 0; + writer._readyPromise_reject = void 0; + writer._readyPromiseState = "rejected"; + } + function defaultWriterReadyPromiseReset(writer) { + defaultWriterReadyPromiseInitialize(writer); + } + function defaultWriterReadyPromiseResetToRejected(writer, reason) { + defaultWriterReadyPromiseInitializeAsRejected(writer, reason); + } + function defaultWriterReadyPromiseResolve(writer) { + if (writer._readyPromise_resolve === void 0) { + return; + } + writer._readyPromise_resolve(void 0); + writer._readyPromise_resolve = void 0; + writer._readyPromise_reject = void 0; + writer._readyPromiseState = "fulfilled"; + } + const NativeDOMException = typeof DOMException !== "undefined" ? DOMException : void 0; + function isDOMExceptionConstructor(ctor) { + if (!(typeof ctor === "function" || typeof ctor === "object")) { + return false; + } + try { + new ctor(); + return true; + } catch (_a) { + return false; + } + } + function createDOMExceptionPolyfill() { + const ctor = function DOMException3(message, name) { + this.message = message || ""; + this.name = name || "Error"; + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + }; + ctor.prototype = Object.create(Error.prototype); + Object.defineProperty(ctor.prototype, "constructor", { value: ctor, writable: true, configurable: true }); + return ctor; + } + const DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill(); + function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) { + const reader = AcquireReadableStreamDefaultReader(source); + const writer = AcquireWritableStreamDefaultWriter(dest); + source._disturbed = true; + let shuttingDown = false; + let currentWrite = promiseResolvedWith(void 0); + return newPromise((resolve, reject) => { + let abortAlgorithm; + if (signal !== void 0) { + abortAlgorithm = () => { + const error = new DOMException$1("Aborted", "AbortError"); + const actions = []; + if (!preventAbort) { + actions.push(() => { + if (dest._state === "writable") { + return WritableStreamAbort(dest, error); + } + return promiseResolvedWith(void 0); + }); + } + if (!preventCancel) { + actions.push(() => { + if (source._state === "readable") { + return ReadableStreamCancel(source, error); + } + return promiseResolvedWith(void 0); + }); + } + shutdownWithAction(() => Promise.all(actions.map((action) => action())), true, error); + }; + if (signal.aborted) { + abortAlgorithm(); + return; + } + signal.addEventListener("abort", abortAlgorithm); + } + function pipeLoop() { + return newPromise((resolveLoop, rejectLoop) => { + function next(done) { + if (done) { + resolveLoop(); + } else { + PerformPromiseThen(pipeStep(), next, rejectLoop); + } + } + next(false); + }); + } + function pipeStep() { + if (shuttingDown) { + return promiseResolvedWith(true); + } + return PerformPromiseThen(writer._readyPromise, () => { + return newPromise((resolveRead, rejectRead) => { + ReadableStreamDefaultReaderRead(reader, { + _chunkSteps: (chunk) => { + currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, chunk), void 0, noop2); + resolveRead(false); + }, + _closeSteps: () => resolveRead(true), + _errorSteps: rejectRead + }); + }); + }); + } + isOrBecomesErrored(source, reader._closedPromise, (storedError) => { + if (!preventAbort) { + shutdownWithAction(() => WritableStreamAbort(dest, storedError), true, storedError); + } else { + shutdown(true, storedError); + } + }); + isOrBecomesErrored(dest, writer._closedPromise, (storedError) => { + if (!preventCancel) { + shutdownWithAction(() => ReadableStreamCancel(source, storedError), true, storedError); + } else { + shutdown(true, storedError); + } + }); + isOrBecomesClosed(source, reader._closedPromise, () => { + if (!preventClose) { + shutdownWithAction(() => WritableStreamDefaultWriterCloseWithErrorPropagation(writer)); + } else { + shutdown(); + } + }); + if (WritableStreamCloseQueuedOrInFlight(dest) || dest._state === "closed") { + const destClosed = new TypeError("the destination writable stream closed before all data could be piped to it"); + if (!preventCancel) { + shutdownWithAction(() => ReadableStreamCancel(source, destClosed), true, destClosed); + } else { + shutdown(true, destClosed); + } + } + setPromiseIsHandledToTrue(pipeLoop()); + function waitForWritesToFinish() { + const oldCurrentWrite = currentWrite; + return PerformPromiseThen(currentWrite, () => oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : void 0); + } + function isOrBecomesErrored(stream, promise, action) { + if (stream._state === "errored") { + action(stream._storedError); + } else { + uponRejection(promise, action); + } + } + function isOrBecomesClosed(stream, promise, action) { + if (stream._state === "closed") { + action(); + } else { + uponFulfillment(promise, action); + } + } + function shutdownWithAction(action, originalIsError, originalError) { + if (shuttingDown) { + return; + } + shuttingDown = true; + if (dest._state === "writable" && !WritableStreamCloseQueuedOrInFlight(dest)) { + uponFulfillment(waitForWritesToFinish(), doTheRest); + } else { + doTheRest(); + } + function doTheRest() { + uponPromise(action(), () => finalize(originalIsError, originalError), (newError) => finalize(true, newError)); + } + } + function shutdown(isError, error) { + if (shuttingDown) { + return; + } + shuttingDown = true; + if (dest._state === "writable" && !WritableStreamCloseQueuedOrInFlight(dest)) { + uponFulfillment(waitForWritesToFinish(), () => finalize(isError, error)); + } else { + finalize(isError, error); + } + } + function finalize(isError, error) { + WritableStreamDefaultWriterRelease(writer); + ReadableStreamReaderGenericRelease(reader); + if (signal !== void 0) { + signal.removeEventListener("abort", abortAlgorithm); + } + if (isError) { + reject(error); + } else { + resolve(void 0); + } + } + }); + } + class ReadableStreamDefaultController { + constructor() { + throw new TypeError("Illegal constructor"); + } + get desiredSize() { + if (!IsReadableStreamDefaultController(this)) { + throw defaultControllerBrandCheckException$1("desiredSize"); + } + return ReadableStreamDefaultControllerGetDesiredSize(this); + } + close() { + if (!IsReadableStreamDefaultController(this)) { + throw defaultControllerBrandCheckException$1("close"); + } + if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) { + throw new TypeError("The stream is not in a state that permits close"); + } + ReadableStreamDefaultControllerClose(this); + } + enqueue(chunk = void 0) { + if (!IsReadableStreamDefaultController(this)) { + throw defaultControllerBrandCheckException$1("enqueue"); + } + if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) { + throw new TypeError("The stream is not in a state that permits enqueue"); + } + return ReadableStreamDefaultControllerEnqueue(this, chunk); + } + error(e2 = void 0) { + if (!IsReadableStreamDefaultController(this)) { + throw defaultControllerBrandCheckException$1("error"); + } + ReadableStreamDefaultControllerError(this, e2); + } + [CancelSteps](reason) { + ResetQueue(this); + const result = this._cancelAlgorithm(reason); + ReadableStreamDefaultControllerClearAlgorithms(this); + return result; + } + [PullSteps](readRequest) { + const stream = this._controlledReadableStream; + if (this._queue.length > 0) { + const chunk = DequeueValue(this); + if (this._closeRequested && this._queue.length === 0) { + ReadableStreamDefaultControllerClearAlgorithms(this); + ReadableStreamClose(stream); + } else { + ReadableStreamDefaultControllerCallPullIfNeeded(this); + } + readRequest._chunkSteps(chunk); + } else { + ReadableStreamAddReadRequest(stream, readRequest); + ReadableStreamDefaultControllerCallPullIfNeeded(this); + } + } + } + Object.defineProperties(ReadableStreamDefaultController.prototype, { + close: { enumerable: true }, + enqueue: { enumerable: true }, + error: { enumerable: true }, + desiredSize: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === "symbol") { + Object.defineProperty(ReadableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, { + value: "ReadableStreamDefaultController", + configurable: true + }); + } + function IsReadableStreamDefaultController(x2) { + if (!typeIsObject(x2)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x2, "_controlledReadableStream")) { + return false; + } + return x2 instanceof ReadableStreamDefaultController; + } + function ReadableStreamDefaultControllerCallPullIfNeeded(controller) { + const shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller); + if (!shouldPull) { + return; + } + if (controller._pulling) { + controller._pullAgain = true; + return; + } + controller._pulling = true; + const pullPromise = controller._pullAlgorithm(); + uponPromise(pullPromise, () => { + controller._pulling = false; + if (controller._pullAgain) { + controller._pullAgain = false; + ReadableStreamDefaultControllerCallPullIfNeeded(controller); + } + }, (e2) => { + ReadableStreamDefaultControllerError(controller, e2); + }); + } + function ReadableStreamDefaultControllerShouldCallPull(controller) { + const stream = controller._controlledReadableStream; + if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) { + return false; + } + if (!controller._started) { + return false; + } + if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) { + return true; + } + const desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller); + if (desiredSize > 0) { + return true; + } + return false; + } + function ReadableStreamDefaultControllerClearAlgorithms(controller) { + controller._pullAlgorithm = void 0; + controller._cancelAlgorithm = void 0; + controller._strategySizeAlgorithm = void 0; + } + function ReadableStreamDefaultControllerClose(controller) { + if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) { + return; + } + const stream = controller._controlledReadableStream; + controller._closeRequested = true; + if (controller._queue.length === 0) { + ReadableStreamDefaultControllerClearAlgorithms(controller); + ReadableStreamClose(stream); + } + } + function ReadableStreamDefaultControllerEnqueue(controller, chunk) { + if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) { + return; + } + const stream = controller._controlledReadableStream; + if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) { + ReadableStreamFulfillReadRequest(stream, chunk, false); + } else { + let chunkSize; + try { + chunkSize = controller._strategySizeAlgorithm(chunk); + } catch (chunkSizeE) { + ReadableStreamDefaultControllerError(controller, chunkSizeE); + throw chunkSizeE; + } + try { + EnqueueValueWithSize(controller, chunk, chunkSize); + } catch (enqueueE) { + ReadableStreamDefaultControllerError(controller, enqueueE); + throw enqueueE; + } + } + ReadableStreamDefaultControllerCallPullIfNeeded(controller); + } + function ReadableStreamDefaultControllerError(controller, e2) { + const stream = controller._controlledReadableStream; + if (stream._state !== "readable") { + return; + } + ResetQueue(controller); + ReadableStreamDefaultControllerClearAlgorithms(controller); + ReadableStreamError(stream, e2); + } + function ReadableStreamDefaultControllerGetDesiredSize(controller) { + const state = controller._controlledReadableStream._state; + if (state === "errored") { + return null; + } + if (state === "closed") { + return 0; + } + return controller._strategyHWM - controller._queueTotalSize; + } + function ReadableStreamDefaultControllerHasBackpressure(controller) { + if (ReadableStreamDefaultControllerShouldCallPull(controller)) { + return false; + } + return true; + } + function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) { + const state = controller._controlledReadableStream._state; + if (!controller._closeRequested && state === "readable") { + return true; + } + return false; + } + function SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) { + controller._controlledReadableStream = stream; + controller._queue = void 0; + controller._queueTotalSize = void 0; + ResetQueue(controller); + controller._started = false; + controller._closeRequested = false; + controller._pullAgain = false; + controller._pulling = false; + controller._strategySizeAlgorithm = sizeAlgorithm; + controller._strategyHWM = highWaterMark; + controller._pullAlgorithm = pullAlgorithm; + controller._cancelAlgorithm = cancelAlgorithm; + stream._readableStreamController = controller; + const startResult = startAlgorithm(); + uponPromise(promiseResolvedWith(startResult), () => { + controller._started = true; + ReadableStreamDefaultControllerCallPullIfNeeded(controller); + }, (r2) => { + ReadableStreamDefaultControllerError(controller, r2); + }); + } + function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) { + const controller = Object.create(ReadableStreamDefaultController.prototype); + let startAlgorithm = () => void 0; + let pullAlgorithm = () => promiseResolvedWith(void 0); + let cancelAlgorithm = () => promiseResolvedWith(void 0); + if (underlyingSource.start !== void 0) { + startAlgorithm = () => underlyingSource.start(controller); + } + if (underlyingSource.pull !== void 0) { + pullAlgorithm = () => underlyingSource.pull(controller); + } + if (underlyingSource.cancel !== void 0) { + cancelAlgorithm = (reason) => underlyingSource.cancel(reason); + } + SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm); + } + function defaultControllerBrandCheckException$1(name) { + return new TypeError(`ReadableStreamDefaultController.prototype.${name} can only be used on a ReadableStreamDefaultController`); + } + function ReadableStreamTee(stream, cloneForBranch2) { + if (IsReadableByteStreamController(stream._readableStreamController)) { + return ReadableByteStreamTee(stream); + } + return ReadableStreamDefaultTee(stream); + } + function ReadableStreamDefaultTee(stream, cloneForBranch2) { + const reader = AcquireReadableStreamDefaultReader(stream); + let reading = false; + let readAgain = false; + let canceled1 = false; + let canceled2 = false; + let reason1; + let reason2; + let branch1; + let branch2; + let resolveCancelPromise; + const cancelPromise = newPromise((resolve) => { + resolveCancelPromise = resolve; + }); + function pullAlgorithm() { + if (reading) { + readAgain = true; + return promiseResolvedWith(void 0); + } + reading = true; + const readRequest = { + _chunkSteps: (chunk) => { + queueMicrotask(() => { + readAgain = false; + const chunk1 = chunk; + const chunk2 = chunk; + if (!canceled1) { + ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, chunk1); + } + if (!canceled2) { + ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, chunk2); + } + reading = false; + if (readAgain) { + pullAlgorithm(); + } + }); + }, + _closeSteps: () => { + reading = false; + if (!canceled1) { + ReadableStreamDefaultControllerClose(branch1._readableStreamController); + } + if (!canceled2) { + ReadableStreamDefaultControllerClose(branch2._readableStreamController); + } + if (!canceled1 || !canceled2) { + resolveCancelPromise(void 0); + } + }, + _errorSteps: () => { + reading = false; + } + }; + ReadableStreamDefaultReaderRead(reader, readRequest); + return promiseResolvedWith(void 0); + } + function cancel1Algorithm(reason) { + canceled1 = true; + reason1 = reason; + if (canceled2) { + const compositeReason = CreateArrayFromList([reason1, reason2]); + const cancelResult = ReadableStreamCancel(stream, compositeReason); + resolveCancelPromise(cancelResult); + } + return cancelPromise; + } + function cancel2Algorithm(reason) { + canceled2 = true; + reason2 = reason; + if (canceled1) { + const compositeReason = CreateArrayFromList([reason1, reason2]); + const cancelResult = ReadableStreamCancel(stream, compositeReason); + resolveCancelPromise(cancelResult); + } + return cancelPromise; + } + function startAlgorithm() { + } + branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm); + branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm); + uponRejection(reader._closedPromise, (r2) => { + ReadableStreamDefaultControllerError(branch1._readableStreamController, r2); + ReadableStreamDefaultControllerError(branch2._readableStreamController, r2); + if (!canceled1 || !canceled2) { + resolveCancelPromise(void 0); + } + }); + return [branch1, branch2]; + } + function ReadableByteStreamTee(stream) { + let reader = AcquireReadableStreamDefaultReader(stream); + let reading = false; + let readAgainForBranch1 = false; + let readAgainForBranch2 = false; + let canceled1 = false; + let canceled2 = false; + let reason1; + let reason2; + let branch1; + let branch2; + let resolveCancelPromise; + const cancelPromise = newPromise((resolve) => { + resolveCancelPromise = resolve; + }); + function forwardReaderError(thisReader) { + uponRejection(thisReader._closedPromise, (r2) => { + if (thisReader !== reader) { + return; + } + ReadableByteStreamControllerError(branch1._readableStreamController, r2); + ReadableByteStreamControllerError(branch2._readableStreamController, r2); + if (!canceled1 || !canceled2) { + resolveCancelPromise(void 0); + } + }); + } + function pullWithDefaultReader() { + if (IsReadableStreamBYOBReader(reader)) { + ReadableStreamReaderGenericRelease(reader); + reader = AcquireReadableStreamDefaultReader(stream); + forwardReaderError(reader); + } + const readRequest = { + _chunkSteps: (chunk) => { + queueMicrotask(() => { + readAgainForBranch1 = false; + readAgainForBranch2 = false; + const chunk1 = chunk; + let chunk2 = chunk; + if (!canceled1 && !canceled2) { + try { + chunk2 = CloneAsUint8Array(chunk); + } catch (cloneE) { + ReadableByteStreamControllerError(branch1._readableStreamController, cloneE); + ReadableByteStreamControllerError(branch2._readableStreamController, cloneE); + resolveCancelPromise(ReadableStreamCancel(stream, cloneE)); + return; + } + } + if (!canceled1) { + ReadableByteStreamControllerEnqueue(branch1._readableStreamController, chunk1); + } + if (!canceled2) { + ReadableByteStreamControllerEnqueue(branch2._readableStreamController, chunk2); + } + reading = false; + if (readAgainForBranch1) { + pull1Algorithm(); + } else if (readAgainForBranch2) { + pull2Algorithm(); + } + }); + }, + _closeSteps: () => { + reading = false; + if (!canceled1) { + ReadableByteStreamControllerClose(branch1._readableStreamController); + } + if (!canceled2) { + ReadableByteStreamControllerClose(branch2._readableStreamController); + } + if (branch1._readableStreamController._pendingPullIntos.length > 0) { + ReadableByteStreamControllerRespond(branch1._readableStreamController, 0); + } + if (branch2._readableStreamController._pendingPullIntos.length > 0) { + ReadableByteStreamControllerRespond(branch2._readableStreamController, 0); + } + if (!canceled1 || !canceled2) { + resolveCancelPromise(void 0); + } + }, + _errorSteps: () => { + reading = false; + } + }; + ReadableStreamDefaultReaderRead(reader, readRequest); + } + function pullWithBYOBReader(view, forBranch2) { + if (IsReadableStreamDefaultReader(reader)) { + ReadableStreamReaderGenericRelease(reader); + reader = AcquireReadableStreamBYOBReader(stream); + forwardReaderError(reader); + } + const byobBranch = forBranch2 ? branch2 : branch1; + const otherBranch = forBranch2 ? branch1 : branch2; + const readIntoRequest = { + _chunkSteps: (chunk) => { + queueMicrotask(() => { + readAgainForBranch1 = false; + readAgainForBranch2 = false; + const byobCanceled = forBranch2 ? canceled2 : canceled1; + const otherCanceled = forBranch2 ? canceled1 : canceled2; + if (!otherCanceled) { + let clonedChunk; + try { + clonedChunk = CloneAsUint8Array(chunk); + } catch (cloneE) { + ReadableByteStreamControllerError(byobBranch._readableStreamController, cloneE); + ReadableByteStreamControllerError(otherBranch._readableStreamController, cloneE); + resolveCancelPromise(ReadableStreamCancel(stream, cloneE)); + return; + } + if (!byobCanceled) { + ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk); + } + ReadableByteStreamControllerEnqueue(otherBranch._readableStreamController, clonedChunk); + } else if (!byobCanceled) { + ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk); + } + reading = false; + if (readAgainForBranch1) { + pull1Algorithm(); + } else if (readAgainForBranch2) { + pull2Algorithm(); + } + }); + }, + _closeSteps: (chunk) => { + reading = false; + const byobCanceled = forBranch2 ? canceled2 : canceled1; + const otherCanceled = forBranch2 ? canceled1 : canceled2; + if (!byobCanceled) { + ReadableByteStreamControllerClose(byobBranch._readableStreamController); + } + if (!otherCanceled) { + ReadableByteStreamControllerClose(otherBranch._readableStreamController); + } + if (chunk !== void 0) { + if (!byobCanceled) { + ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk); + } + if (!otherCanceled && otherBranch._readableStreamController._pendingPullIntos.length > 0) { + ReadableByteStreamControllerRespond(otherBranch._readableStreamController, 0); + } + } + if (!byobCanceled || !otherCanceled) { + resolveCancelPromise(void 0); + } + }, + _errorSteps: () => { + reading = false; + } + }; + ReadableStreamBYOBReaderRead(reader, view, readIntoRequest); + } + function pull1Algorithm() { + if (reading) { + readAgainForBranch1 = true; + return promiseResolvedWith(void 0); + } + reading = true; + const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch1._readableStreamController); + if (byobRequest === null) { + pullWithDefaultReader(); + } else { + pullWithBYOBReader(byobRequest._view, false); + } + return promiseResolvedWith(void 0); + } + function pull2Algorithm() { + if (reading) { + readAgainForBranch2 = true; + return promiseResolvedWith(void 0); + } + reading = true; + const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch2._readableStreamController); + if (byobRequest === null) { + pullWithDefaultReader(); + } else { + pullWithBYOBReader(byobRequest._view, true); + } + return promiseResolvedWith(void 0); + } + function cancel1Algorithm(reason) { + canceled1 = true; + reason1 = reason; + if (canceled2) { + const compositeReason = CreateArrayFromList([reason1, reason2]); + const cancelResult = ReadableStreamCancel(stream, compositeReason); + resolveCancelPromise(cancelResult); + } + return cancelPromise; + } + function cancel2Algorithm(reason) { + canceled2 = true; + reason2 = reason; + if (canceled1) { + const compositeReason = CreateArrayFromList([reason1, reason2]); + const cancelResult = ReadableStreamCancel(stream, compositeReason); + resolveCancelPromise(cancelResult); + } + return cancelPromise; + } + function startAlgorithm() { + return; + } + branch1 = CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm); + branch2 = CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm); + forwardReaderError(reader); + return [branch1, branch2]; + } + function convertUnderlyingDefaultOrByteSource(source, context) { + assertDictionary(source, context); + const original = source; + const autoAllocateChunkSize = original === null || original === void 0 ? void 0 : original.autoAllocateChunkSize; + const cancel = original === null || original === void 0 ? void 0 : original.cancel; + const pull = original === null || original === void 0 ? void 0 : original.pull; + const start = original === null || original === void 0 ? void 0 : original.start; + const type = original === null || original === void 0 ? void 0 : original.type; + return { + autoAllocateChunkSize: autoAllocateChunkSize === void 0 ? void 0 : convertUnsignedLongLongWithEnforceRange(autoAllocateChunkSize, `${context} has member 'autoAllocateChunkSize' that`), + cancel: cancel === void 0 ? void 0 : convertUnderlyingSourceCancelCallback(cancel, original, `${context} has member 'cancel' that`), + pull: pull === void 0 ? void 0 : convertUnderlyingSourcePullCallback(pull, original, `${context} has member 'pull' that`), + start: start === void 0 ? void 0 : convertUnderlyingSourceStartCallback(start, original, `${context} has member 'start' that`), + type: type === void 0 ? void 0 : convertReadableStreamType(type, `${context} has member 'type' that`) + }; + } + function convertUnderlyingSourceCancelCallback(fn, original, context) { + assertFunction(fn, context); + return (reason) => promiseCall(fn, original, [reason]); + } + function convertUnderlyingSourcePullCallback(fn, original, context) { + assertFunction(fn, context); + return (controller) => promiseCall(fn, original, [controller]); + } + function convertUnderlyingSourceStartCallback(fn, original, context) { + assertFunction(fn, context); + return (controller) => reflectCall(fn, original, [controller]); + } + function convertReadableStreamType(type, context) { + type = `${type}`; + if (type !== "bytes") { + throw new TypeError(`${context} '${type}' is not a valid enumeration value for ReadableStreamType`); + } + return type; + } + function convertReaderOptions(options, context) { + assertDictionary(options, context); + const mode = options === null || options === void 0 ? void 0 : options.mode; + return { + mode: mode === void 0 ? void 0 : convertReadableStreamReaderMode(mode, `${context} has member 'mode' that`) + }; + } + function convertReadableStreamReaderMode(mode, context) { + mode = `${mode}`; + if (mode !== "byob") { + throw new TypeError(`${context} '${mode}' is not a valid enumeration value for ReadableStreamReaderMode`); + } + return mode; + } + function convertIteratorOptions(options, context) { + assertDictionary(options, context); + const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel; + return { preventCancel: Boolean(preventCancel) }; + } + function convertPipeOptions(options, context) { + assertDictionary(options, context); + const preventAbort = options === null || options === void 0 ? void 0 : options.preventAbort; + const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel; + const preventClose = options === null || options === void 0 ? void 0 : options.preventClose; + const signal = options === null || options === void 0 ? void 0 : options.signal; + if (signal !== void 0) { + assertAbortSignal(signal, `${context} has member 'signal' that`); + } + return { + preventAbort: Boolean(preventAbort), + preventCancel: Boolean(preventCancel), + preventClose: Boolean(preventClose), + signal + }; + } + function assertAbortSignal(signal, context) { + if (!isAbortSignal2(signal)) { + throw new TypeError(`${context} is not an AbortSignal.`); + } + } + function convertReadableWritablePair(pair, context) { + assertDictionary(pair, context); + const readable = pair === null || pair === void 0 ? void 0 : pair.readable; + assertRequiredField(readable, "readable", "ReadableWritablePair"); + assertReadableStream(readable, `${context} has member 'readable' that`); + const writable = pair === null || pair === void 0 ? void 0 : pair.writable; + assertRequiredField(writable, "writable", "ReadableWritablePair"); + assertWritableStream(writable, `${context} has member 'writable' that`); + return { readable, writable }; + } + class ReadableStream2 { + constructor(rawUnderlyingSource = {}, rawStrategy = {}) { + if (rawUnderlyingSource === void 0) { + rawUnderlyingSource = null; + } else { + assertObject(rawUnderlyingSource, "First parameter"); + } + const strategy = convertQueuingStrategy(rawStrategy, "Second parameter"); + const underlyingSource = convertUnderlyingDefaultOrByteSource(rawUnderlyingSource, "First parameter"); + InitializeReadableStream(this); + if (underlyingSource.type === "bytes") { + if (strategy.size !== void 0) { + throw new RangeError("The strategy for a byte stream cannot have a size function"); + } + const highWaterMark = ExtractHighWaterMark(strategy, 0); + SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, highWaterMark); + } else { + const sizeAlgorithm = ExtractSizeAlgorithm(strategy); + const highWaterMark = ExtractHighWaterMark(strategy, 1); + SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm); + } + } + get locked() { + if (!IsReadableStream(this)) { + throw streamBrandCheckException$1("locked"); + } + return IsReadableStreamLocked(this); + } + cancel(reason = void 0) { + if (!IsReadableStream(this)) { + return promiseRejectedWith(streamBrandCheckException$1("cancel")); + } + if (IsReadableStreamLocked(this)) { + return promiseRejectedWith(new TypeError("Cannot cancel a stream that already has a reader")); + } + return ReadableStreamCancel(this, reason); + } + getReader(rawOptions = void 0) { + if (!IsReadableStream(this)) { + throw streamBrandCheckException$1("getReader"); + } + const options = convertReaderOptions(rawOptions, "First parameter"); + if (options.mode === void 0) { + return AcquireReadableStreamDefaultReader(this); + } + return AcquireReadableStreamBYOBReader(this); + } + pipeThrough(rawTransform, rawOptions = {}) { + if (!IsReadableStream(this)) { + throw streamBrandCheckException$1("pipeThrough"); + } + assertRequiredArgument(rawTransform, 1, "pipeThrough"); + const transform = convertReadableWritablePair(rawTransform, "First parameter"); + const options = convertPipeOptions(rawOptions, "Second parameter"); + if (IsReadableStreamLocked(this)) { + throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream"); + } + if (IsWritableStreamLocked(transform.writable)) { + throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream"); + } + const promise = ReadableStreamPipeTo(this, transform.writable, options.preventClose, options.preventAbort, options.preventCancel, options.signal); + setPromiseIsHandledToTrue(promise); + return transform.readable; + } + pipeTo(destination, rawOptions = {}) { + if (!IsReadableStream(this)) { + return promiseRejectedWith(streamBrandCheckException$1("pipeTo")); + } + if (destination === void 0) { + return promiseRejectedWith(`Parameter 1 is required in 'pipeTo'.`); + } + if (!IsWritableStream(destination)) { + return promiseRejectedWith(new TypeError(`ReadableStream.prototype.pipeTo's first argument must be a WritableStream`)); + } + let options; + try { + options = convertPipeOptions(rawOptions, "Second parameter"); + } catch (e2) { + return promiseRejectedWith(e2); + } + if (IsReadableStreamLocked(this)) { + return promiseRejectedWith(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")); + } + if (IsWritableStreamLocked(destination)) { + return promiseRejectedWith(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")); + } + return ReadableStreamPipeTo(this, destination, options.preventClose, options.preventAbort, options.preventCancel, options.signal); + } + tee() { + if (!IsReadableStream(this)) { + throw streamBrandCheckException$1("tee"); + } + const branches = ReadableStreamTee(this); + return CreateArrayFromList(branches); + } + values(rawOptions = void 0) { + if (!IsReadableStream(this)) { + throw streamBrandCheckException$1("values"); + } + const options = convertIteratorOptions(rawOptions, "First parameter"); + return AcquireReadableStreamAsyncIterator(this, options.preventCancel); + } + } + Object.defineProperties(ReadableStream2.prototype, { + cancel: { enumerable: true }, + getReader: { enumerable: true }, + pipeThrough: { enumerable: true }, + pipeTo: { enumerable: true }, + tee: { enumerable: true }, + values: { enumerable: true }, + locked: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === "symbol") { + Object.defineProperty(ReadableStream2.prototype, SymbolPolyfill.toStringTag, { + value: "ReadableStream", + configurable: true + }); + } + if (typeof SymbolPolyfill.asyncIterator === "symbol") { + Object.defineProperty(ReadableStream2.prototype, SymbolPolyfill.asyncIterator, { + value: ReadableStream2.prototype.values, + writable: true, + configurable: true + }); + } + function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark = 1, sizeAlgorithm = () => 1) { + const stream = Object.create(ReadableStream2.prototype); + InitializeReadableStream(stream); + const controller = Object.create(ReadableStreamDefaultController.prototype); + SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm); + return stream; + } + function CreateReadableByteStream(startAlgorithm, pullAlgorithm, cancelAlgorithm) { + const stream = Object.create(ReadableStream2.prototype); + InitializeReadableStream(stream); + const controller = Object.create(ReadableByteStreamController.prototype); + SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, void 0); + return stream; + } + function InitializeReadableStream(stream) { + stream._state = "readable"; + stream._reader = void 0; + stream._storedError = void 0; + stream._disturbed = false; + } + function IsReadableStream(x2) { + if (!typeIsObject(x2)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x2, "_readableStreamController")) { + return false; + } + return x2 instanceof ReadableStream2; + } + function IsReadableStreamLocked(stream) { + if (stream._reader === void 0) { + return false; + } + return true; + } + function ReadableStreamCancel(stream, reason) { + stream._disturbed = true; + if (stream._state === "closed") { + return promiseResolvedWith(void 0); + } + if (stream._state === "errored") { + return promiseRejectedWith(stream._storedError); + } + ReadableStreamClose(stream); + const reader = stream._reader; + if (reader !== void 0 && IsReadableStreamBYOBReader(reader)) { + reader._readIntoRequests.forEach((readIntoRequest) => { + readIntoRequest._closeSteps(void 0); + }); + reader._readIntoRequests = new SimpleQueue(); + } + const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason); + return transformPromiseWith(sourceCancelPromise, noop2); + } + function ReadableStreamClose(stream) { + stream._state = "closed"; + const reader = stream._reader; + if (reader === void 0) { + return; + } + defaultReaderClosedPromiseResolve(reader); + if (IsReadableStreamDefaultReader(reader)) { + reader._readRequests.forEach((readRequest) => { + readRequest._closeSteps(); + }); + reader._readRequests = new SimpleQueue(); + } + } + function ReadableStreamError(stream, e2) { + stream._state = "errored"; + stream._storedError = e2; + const reader = stream._reader; + if (reader === void 0) { + return; + } + defaultReaderClosedPromiseReject(reader, e2); + if (IsReadableStreamDefaultReader(reader)) { + reader._readRequests.forEach((readRequest) => { + readRequest._errorSteps(e2); + }); + reader._readRequests = new SimpleQueue(); + } else { + reader._readIntoRequests.forEach((readIntoRequest) => { + readIntoRequest._errorSteps(e2); + }); + reader._readIntoRequests = new SimpleQueue(); + } + } + function streamBrandCheckException$1(name) { + return new TypeError(`ReadableStream.prototype.${name} can only be used on a ReadableStream`); + } + function convertQueuingStrategyInit(init, context) { + assertDictionary(init, context); + const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark; + assertRequiredField(highWaterMark, "highWaterMark", "QueuingStrategyInit"); + return { + highWaterMark: convertUnrestrictedDouble(highWaterMark) + }; + } + const byteLengthSizeFunction = (chunk) => { + return chunk.byteLength; + }; + Object.defineProperty(byteLengthSizeFunction, "name", { + value: "size", + configurable: true + }); + class ByteLengthQueuingStrategy { + constructor(options) { + assertRequiredArgument(options, 1, "ByteLengthQueuingStrategy"); + options = convertQueuingStrategyInit(options, "First parameter"); + this._byteLengthQueuingStrategyHighWaterMark = options.highWaterMark; + } + get highWaterMark() { + if (!IsByteLengthQueuingStrategy(this)) { + throw byteLengthBrandCheckException("highWaterMark"); + } + return this._byteLengthQueuingStrategyHighWaterMark; + } + get size() { + if (!IsByteLengthQueuingStrategy(this)) { + throw byteLengthBrandCheckException("size"); + } + return byteLengthSizeFunction; + } + } + Object.defineProperties(ByteLengthQueuingStrategy.prototype, { + highWaterMark: { enumerable: true }, + size: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === "symbol") { + Object.defineProperty(ByteLengthQueuingStrategy.prototype, SymbolPolyfill.toStringTag, { + value: "ByteLengthQueuingStrategy", + configurable: true + }); + } + function byteLengthBrandCheckException(name) { + return new TypeError(`ByteLengthQueuingStrategy.prototype.${name} can only be used on a ByteLengthQueuingStrategy`); + } + function IsByteLengthQueuingStrategy(x2) { + if (!typeIsObject(x2)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x2, "_byteLengthQueuingStrategyHighWaterMark")) { + return false; + } + return x2 instanceof ByteLengthQueuingStrategy; + } + const countSizeFunction = () => { + return 1; + }; + Object.defineProperty(countSizeFunction, "name", { + value: "size", + configurable: true + }); + class CountQueuingStrategy { + constructor(options) { + assertRequiredArgument(options, 1, "CountQueuingStrategy"); + options = convertQueuingStrategyInit(options, "First parameter"); + this._countQueuingStrategyHighWaterMark = options.highWaterMark; + } + get highWaterMark() { + if (!IsCountQueuingStrategy(this)) { + throw countBrandCheckException("highWaterMark"); + } + return this._countQueuingStrategyHighWaterMark; + } + get size() { + if (!IsCountQueuingStrategy(this)) { + throw countBrandCheckException("size"); + } + return countSizeFunction; + } + } + Object.defineProperties(CountQueuingStrategy.prototype, { + highWaterMark: { enumerable: true }, + size: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === "symbol") { + Object.defineProperty(CountQueuingStrategy.prototype, SymbolPolyfill.toStringTag, { + value: "CountQueuingStrategy", + configurable: true + }); + } + function countBrandCheckException(name) { + return new TypeError(`CountQueuingStrategy.prototype.${name} can only be used on a CountQueuingStrategy`); + } + function IsCountQueuingStrategy(x2) { + if (!typeIsObject(x2)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x2, "_countQueuingStrategyHighWaterMark")) { + return false; + } + return x2 instanceof CountQueuingStrategy; + } + function convertTransformer(original, context) { + assertDictionary(original, context); + const flush = original === null || original === void 0 ? void 0 : original.flush; + const readableType = original === null || original === void 0 ? void 0 : original.readableType; + const start = original === null || original === void 0 ? void 0 : original.start; + const transform = original === null || original === void 0 ? void 0 : original.transform; + const writableType = original === null || original === void 0 ? void 0 : original.writableType; + return { + flush: flush === void 0 ? void 0 : convertTransformerFlushCallback(flush, original, `${context} has member 'flush' that`), + readableType, + start: start === void 0 ? void 0 : convertTransformerStartCallback(start, original, `${context} has member 'start' that`), + transform: transform === void 0 ? void 0 : convertTransformerTransformCallback(transform, original, `${context} has member 'transform' that`), + writableType + }; + } + function convertTransformerFlushCallback(fn, original, context) { + assertFunction(fn, context); + return (controller) => promiseCall(fn, original, [controller]); + } + function convertTransformerStartCallback(fn, original, context) { + assertFunction(fn, context); + return (controller) => reflectCall(fn, original, [controller]); + } + function convertTransformerTransformCallback(fn, original, context) { + assertFunction(fn, context); + return (chunk, controller) => promiseCall(fn, original, [chunk, controller]); + } + class TransformStream { + constructor(rawTransformer = {}, rawWritableStrategy = {}, rawReadableStrategy = {}) { + if (rawTransformer === void 0) { + rawTransformer = null; + } + const writableStrategy = convertQueuingStrategy(rawWritableStrategy, "Second parameter"); + const readableStrategy = convertQueuingStrategy(rawReadableStrategy, "Third parameter"); + const transformer = convertTransformer(rawTransformer, "First parameter"); + if (transformer.readableType !== void 0) { + throw new RangeError("Invalid readableType specified"); + } + if (transformer.writableType !== void 0) { + throw new RangeError("Invalid writableType specified"); + } + const readableHighWaterMark = ExtractHighWaterMark(readableStrategy, 0); + const readableSizeAlgorithm = ExtractSizeAlgorithm(readableStrategy); + const writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1); + const writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy); + let startPromise_resolve; + const startPromise = newPromise((resolve) => { + startPromise_resolve = resolve; + }); + InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm); + SetUpTransformStreamDefaultControllerFromTransformer(this, transformer); + if (transformer.start !== void 0) { + startPromise_resolve(transformer.start(this._transformStreamController)); + } else { + startPromise_resolve(void 0); + } + } + get readable() { + if (!IsTransformStream(this)) { + throw streamBrandCheckException("readable"); + } + return this._readable; + } + get writable() { + if (!IsTransformStream(this)) { + throw streamBrandCheckException("writable"); + } + return this._writable; + } + } + Object.defineProperties(TransformStream.prototype, { + readable: { enumerable: true }, + writable: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === "symbol") { + Object.defineProperty(TransformStream.prototype, SymbolPolyfill.toStringTag, { + value: "TransformStream", + configurable: true + }); + } + function InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) { + function startAlgorithm() { + return startPromise; + } + function writeAlgorithm(chunk) { + return TransformStreamDefaultSinkWriteAlgorithm(stream, chunk); + } + function abortAlgorithm(reason) { + return TransformStreamDefaultSinkAbortAlgorithm(stream, reason); + } + function closeAlgorithm() { + return TransformStreamDefaultSinkCloseAlgorithm(stream); + } + stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, writableHighWaterMark, writableSizeAlgorithm); + function pullAlgorithm() { + return TransformStreamDefaultSourcePullAlgorithm(stream); + } + function cancelAlgorithm(reason) { + TransformStreamErrorWritableAndUnblockWrite(stream, reason); + return promiseResolvedWith(void 0); + } + stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm); + stream._backpressure = void 0; + stream._backpressureChangePromise = void 0; + stream._backpressureChangePromise_resolve = void 0; + TransformStreamSetBackpressure(stream, true); + stream._transformStreamController = void 0; + } + function IsTransformStream(x2) { + if (!typeIsObject(x2)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x2, "_transformStreamController")) { + return false; + } + return x2 instanceof TransformStream; + } + function TransformStreamError(stream, e2) { + ReadableStreamDefaultControllerError(stream._readable._readableStreamController, e2); + TransformStreamErrorWritableAndUnblockWrite(stream, e2); + } + function TransformStreamErrorWritableAndUnblockWrite(stream, e2) { + TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController); + WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e2); + if (stream._backpressure) { + TransformStreamSetBackpressure(stream, false); + } + } + function TransformStreamSetBackpressure(stream, backpressure) { + if (stream._backpressureChangePromise !== void 0) { + stream._backpressureChangePromise_resolve(); + } + stream._backpressureChangePromise = newPromise((resolve) => { + stream._backpressureChangePromise_resolve = resolve; + }); + stream._backpressure = backpressure; + } + class TransformStreamDefaultController { + constructor() { + throw new TypeError("Illegal constructor"); + } + get desiredSize() { + if (!IsTransformStreamDefaultController(this)) { + throw defaultControllerBrandCheckException("desiredSize"); + } + const readableController = this._controlledTransformStream._readable._readableStreamController; + return ReadableStreamDefaultControllerGetDesiredSize(readableController); + } + enqueue(chunk = void 0) { + if (!IsTransformStreamDefaultController(this)) { + throw defaultControllerBrandCheckException("enqueue"); + } + TransformStreamDefaultControllerEnqueue(this, chunk); + } + error(reason = void 0) { + if (!IsTransformStreamDefaultController(this)) { + throw defaultControllerBrandCheckException("error"); + } + TransformStreamDefaultControllerError(this, reason); + } + terminate() { + if (!IsTransformStreamDefaultController(this)) { + throw defaultControllerBrandCheckException("terminate"); + } + TransformStreamDefaultControllerTerminate(this); + } + } + Object.defineProperties(TransformStreamDefaultController.prototype, { + enqueue: { enumerable: true }, + error: { enumerable: true }, + terminate: { enumerable: true }, + desiredSize: { enumerable: true } + }); + if (typeof SymbolPolyfill.toStringTag === "symbol") { + Object.defineProperty(TransformStreamDefaultController.prototype, SymbolPolyfill.toStringTag, { + value: "TransformStreamDefaultController", + configurable: true + }); + } + function IsTransformStreamDefaultController(x2) { + if (!typeIsObject(x2)) { + return false; + } + if (!Object.prototype.hasOwnProperty.call(x2, "_controlledTransformStream")) { + return false; + } + return x2 instanceof TransformStreamDefaultController; + } + function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) { + controller._controlledTransformStream = stream; + stream._transformStreamController = controller; + controller._transformAlgorithm = transformAlgorithm; + controller._flushAlgorithm = flushAlgorithm; + } + function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) { + const controller = Object.create(TransformStreamDefaultController.prototype); + let transformAlgorithm = (chunk) => { + try { + TransformStreamDefaultControllerEnqueue(controller, chunk); + return promiseResolvedWith(void 0); + } catch (transformResultE) { + return promiseRejectedWith(transformResultE); + } + }; + let flushAlgorithm = () => promiseResolvedWith(void 0); + if (transformer.transform !== void 0) { + transformAlgorithm = (chunk) => transformer.transform(chunk, controller); + } + if (transformer.flush !== void 0) { + flushAlgorithm = () => transformer.flush(controller); + } + SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm); + } + function TransformStreamDefaultControllerClearAlgorithms(controller) { + controller._transformAlgorithm = void 0; + controller._flushAlgorithm = void 0; + } + function TransformStreamDefaultControllerEnqueue(controller, chunk) { + const stream = controller._controlledTransformStream; + const readableController = stream._readable._readableStreamController; + if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController)) { + throw new TypeError("Readable side is not in a state that permits enqueue"); + } + try { + ReadableStreamDefaultControllerEnqueue(readableController, chunk); + } catch (e2) { + TransformStreamErrorWritableAndUnblockWrite(stream, e2); + throw stream._readable._storedError; + } + const backpressure = ReadableStreamDefaultControllerHasBackpressure(readableController); + if (backpressure !== stream._backpressure) { + TransformStreamSetBackpressure(stream, true); + } + } + function TransformStreamDefaultControllerError(controller, e2) { + TransformStreamError(controller._controlledTransformStream, e2); + } + function TransformStreamDefaultControllerPerformTransform(controller, chunk) { + const transformPromise = controller._transformAlgorithm(chunk); + return transformPromiseWith(transformPromise, void 0, (r2) => { + TransformStreamError(controller._controlledTransformStream, r2); + throw r2; + }); + } + function TransformStreamDefaultControllerTerminate(controller) { + const stream = controller._controlledTransformStream; + const readableController = stream._readable._readableStreamController; + ReadableStreamDefaultControllerClose(readableController); + const error = new TypeError("TransformStream terminated"); + TransformStreamErrorWritableAndUnblockWrite(stream, error); + } + function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) { + const controller = stream._transformStreamController; + if (stream._backpressure) { + const backpressureChangePromise = stream._backpressureChangePromise; + return transformPromiseWith(backpressureChangePromise, () => { + const writable = stream._writable; + const state = writable._state; + if (state === "erroring") { + throw writable._storedError; + } + return TransformStreamDefaultControllerPerformTransform(controller, chunk); + }); + } + return TransformStreamDefaultControllerPerformTransform(controller, chunk); + } + function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) { + TransformStreamError(stream, reason); + return promiseResolvedWith(void 0); + } + function TransformStreamDefaultSinkCloseAlgorithm(stream) { + const readable = stream._readable; + const controller = stream._transformStreamController; + const flushPromise = controller._flushAlgorithm(); + TransformStreamDefaultControllerClearAlgorithms(controller); + return transformPromiseWith(flushPromise, () => { + if (readable._state === "errored") { + throw readable._storedError; + } + ReadableStreamDefaultControllerClose(readable._readableStreamController); + }, (r2) => { + TransformStreamError(stream, r2); + throw readable._storedError; + }); + } + function TransformStreamDefaultSourcePullAlgorithm(stream) { + TransformStreamSetBackpressure(stream, false); + return stream._backpressureChangePromise; + } + function defaultControllerBrandCheckException(name) { + return new TypeError(`TransformStreamDefaultController.prototype.${name} can only be used on a TransformStreamDefaultController`); + } + function streamBrandCheckException(name) { + return new TypeError(`TransformStream.prototype.${name} can only be used on a TransformStream`); + } + exports2.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy; + exports2.CountQueuingStrategy = CountQueuingStrategy; + exports2.ReadableByteStreamController = ReadableByteStreamController; + exports2.ReadableStream = ReadableStream2; + exports2.ReadableStreamBYOBReader = ReadableStreamBYOBReader; + exports2.ReadableStreamBYOBRequest = ReadableStreamBYOBRequest; + exports2.ReadableStreamDefaultController = ReadableStreamDefaultController; + exports2.ReadableStreamDefaultReader = ReadableStreamDefaultReader; + exports2.TransformStream = TransformStream; + exports2.TransformStreamDefaultController = TransformStreamDefaultController; + exports2.WritableStream = WritableStream; + exports2.WritableStreamDefaultController = WritableStreamDefaultController; + exports2.WritableStreamDefaultWriter = WritableStreamDefaultWriter; + Object.defineProperty(exports2, "__esModule", { value: true }); + }); + } +}); + +// node_modules/fetch-blob/streams.cjs +var require_streams = __commonJS({ + "node_modules/fetch-blob/streams.cjs"() { + var POOL_SIZE2 = 65536; + if (!globalThis.ReadableStream) { + try { + const process3 = require("node:process"); + const { emitWarning } = process3; + try { + process3.emitWarning = () => { + }; + Object.assign(globalThis, require("node:stream/web")); + process3.emitWarning = emitWarning; + } catch (error) { + process3.emitWarning = emitWarning; + throw error; + } + } catch (error) { + Object.assign(globalThis, require_ponyfill_es2018()); + } + } + try { + const { Blob: Blob3 } = require("buffer"); + if (Blob3 && !Blob3.prototype.stream) { + Blob3.prototype.stream = function name(params) { + let position = 0; + const blob = this; + return new ReadableStream({ + type: "bytes", + async pull(ctrl) { + const chunk = blob.slice(position, Math.min(blob.size, position + POOL_SIZE2)); + const buffer = await chunk.arrayBuffer(); + position += buffer.byteLength; + ctrl.enqueue(new Uint8Array(buffer)); + if (position === blob.size) { + ctrl.close(); + } + } + }); + }; + } + } catch (error) { + } + } +}); + +// node_modules/fetch-blob/index.js +async function* toIterator(parts, clone2 = true) { + for (const part of parts) { + if ("stream" in part) { + yield* part.stream(); + } else if (ArrayBuffer.isView(part)) { + if (clone2) { + let position = part.byteOffset; + const end = part.byteOffset + part.byteLength; + while (position !== end) { + const size = Math.min(end - position, POOL_SIZE); + const chunk = part.buffer.slice(position, position + size); + position += chunk.byteLength; + yield new Uint8Array(chunk); + } + } else { + yield part; + } + } else { + let position = 0, b = part; + while (position !== b.size) { + const chunk = b.slice(position, Math.min(b.size, position + POOL_SIZE)); + const buffer = await chunk.arrayBuffer(); + position += buffer.byteLength; + yield new Uint8Array(buffer); + } + } + } +} +var import_streams, POOL_SIZE, _Blob, Blob2, fetch_blob_default; +var init_fetch_blob = __esm({ + "node_modules/fetch-blob/index.js"() { + import_streams = __toESM(require_streams(), 1); + POOL_SIZE = 65536; + _Blob = class Blob { + #parts = []; + #type = ""; + #size = 0; + #endings = "transparent"; + constructor(blobParts = [], options = {}) { + if (typeof blobParts !== "object" || blobParts === null) { + throw new TypeError("Failed to construct 'Blob': The provided value cannot be converted to a sequence."); + } + if (typeof blobParts[Symbol.iterator] !== "function") { + throw new TypeError("Failed to construct 'Blob': The object must have a callable @@iterator property."); + } + if (typeof options !== "object" && typeof options !== "function") { + throw new TypeError("Failed to construct 'Blob': parameter 2 cannot convert to dictionary."); + } + if (options === null) + options = {}; + const encoder = new TextEncoder(); + for (const element of blobParts) { + let part; + if (ArrayBuffer.isView(element)) { + part = new Uint8Array(element.buffer.slice(element.byteOffset, element.byteOffset + element.byteLength)); + } else if (element instanceof ArrayBuffer) { + part = new Uint8Array(element.slice(0)); + } else if (element instanceof Blob) { + part = element; + } else { + part = encoder.encode(`${element}`); + } + const size = ArrayBuffer.isView(part) ? part.byteLength : part.size; + if (size) { + this.#size += size; + this.#parts.push(part); + } + } + this.#endings = `${options.endings === void 0 ? "transparent" : options.endings}`; + const type = options.type === void 0 ? "" : String(options.type); + this.#type = /^[\x20-\x7E]*$/.test(type) ? type : ""; + } + get size() { + return this.#size; + } + get type() { + return this.#type; + } + async text() { + const decoder = new TextDecoder(); + let str = ""; + for await (const part of toIterator(this.#parts, false)) { + str += decoder.decode(part, { stream: true }); + } + str += decoder.decode(); + return str; + } + async arrayBuffer() { + const data = new Uint8Array(this.size); + let offset = 0; + for await (const chunk of toIterator(this.#parts, false)) { + data.set(chunk, offset); + offset += chunk.length; + } + return data.buffer; + } + stream() { + const it = toIterator(this.#parts, true); + return new globalThis.ReadableStream({ + type: "bytes", + async pull(ctrl) { + const chunk = await it.next(); + chunk.done ? ctrl.close() : ctrl.enqueue(chunk.value); + }, + async cancel() { + await it.return(); + } + }); + } + slice(start = 0, end = this.size, type = "") { + const { size } = this; + let relativeStart = start < 0 ? Math.max(size + start, 0) : Math.min(start, size); + let relativeEnd = end < 0 ? Math.max(size + end, 0) : Math.min(end, size); + const span = Math.max(relativeEnd - relativeStart, 0); + const parts = this.#parts; + const blobParts = []; + let added = 0; + for (const part of parts) { + if (added >= span) { + break; + } + const size2 = ArrayBuffer.isView(part) ? part.byteLength : part.size; + if (relativeStart && size2 <= relativeStart) { + relativeStart -= size2; + relativeEnd -= size2; + } else { + let chunk; + if (ArrayBuffer.isView(part)) { + chunk = part.subarray(relativeStart, Math.min(size2, relativeEnd)); + added += chunk.byteLength; + } else { + chunk = part.slice(relativeStart, Math.min(size2, relativeEnd)); + added += chunk.size; + } + relativeEnd -= size2; + blobParts.push(chunk); + relativeStart = 0; + } + } + const blob = new Blob([], { type: String(type).toLowerCase() }); + blob.#size = span; + blob.#parts = blobParts; + return blob; + } + get [Symbol.toStringTag]() { + return "Blob"; + } + static [Symbol.hasInstance](object) { + return object && typeof object === "object" && typeof object.constructor === "function" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]); + } + }; + Object.defineProperties(_Blob.prototype, { + size: { enumerable: true }, + type: { enumerable: true }, + slice: { enumerable: true } + }); + Blob2 = _Blob; + fetch_blob_default = Blob2; + } +}); + +// node_modules/fetch-blob/file.js +var _File, File2, file_default; +var init_file = __esm({ + "node_modules/fetch-blob/file.js"() { + init_fetch_blob(); + _File = class File extends fetch_blob_default { + #lastModified = 0; + #name = ""; + constructor(fileBits, fileName, options = {}) { + if (arguments.length < 2) { + throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`); + } + super(fileBits, options); + if (options === null) + options = {}; + const lastModified = options.lastModified === void 0 ? Date.now() : Number(options.lastModified); + if (!Number.isNaN(lastModified)) { + this.#lastModified = lastModified; + } + this.#name = String(fileName); + } + get name() { + return this.#name; + } + get lastModified() { + return this.#lastModified; + } + get [Symbol.toStringTag]() { + return "File"; + } + static [Symbol.hasInstance](object) { + return !!object && object instanceof fetch_blob_default && /^(File)$/.test(object[Symbol.toStringTag]); + } + }; + File2 = _File; + file_default = File2; + } +}); + +// node_modules/formdata-polyfill/esm.min.js +function formDataToBlob(F2, B = fetch_blob_default) { + var b = `${r()}${r()}`.replace(/\./g, "").slice(-28).padStart(32, "-"), c = [], p = `--${b}\r +Content-Disposition: form-data; name="`; + F2.forEach((v, n) => typeof v == "string" ? c.push(p + e(n) + `"\r +\r +${v.replace(/\r(?!\n)|(? (a += "", /^(Blob|File)$/.test(b && b[t]) ? [(c = c !== void 0 ? c + "" : b[t] == "File" ? b.name : "blob", a), b.name !== c || b[t] == "blob" ? new file_default([b], c, b) : b] : [a, b + ""]); + e = (c, f3) => (f3 ? c : c.replace(/\r?\n|\r/g, "\r\n")).replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"); + x = (n, a, e2) => { + if (a.length < e2) { + throw new TypeError(`Failed to execute '${n}' on 'FormData': ${e2} arguments required, but only ${a.length} present.`); + } + }; + FormData2 = class FormData3 { + #d = []; + constructor(...a) { + if (a.length) + throw new TypeError(`Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.`); + } + get [t]() { + return "FormData"; + } + [i]() { + return this.entries(); + } + static [h](o) { + return o && typeof o === "object" && o[t] === "FormData" && !m.some((m2) => typeof o[m2] != "function"); + } + append(...a) { + x("append", arguments, 2); + this.#d.push(f(...a)); + } + delete(a) { + x("delete", arguments, 1); + a += ""; + this.#d = this.#d.filter(([b]) => b !== a); + } + get(a) { + x("get", arguments, 1); + a += ""; + for (var b = this.#d, l = b.length, c = 0; c < l; c++) + if (b[c][0] === a) + return b[c][1]; + return null; + } + getAll(a, b) { + x("getAll", arguments, 1); + b = []; + a += ""; + this.#d.forEach((c) => c[0] === a && b.push(c[1])); + return b; + } + has(a) { + x("has", arguments, 1); + a += ""; + return this.#d.some((b) => b[0] === a); + } + forEach(a, b) { + x("forEach", arguments, 1); + for (var [c, d] of this) + a.call(b, d, c, this); + } + set(...a) { + x("set", arguments, 2); + var b = [], c = true; + a = f(...a); + this.#d.forEach((d) => { + d[0] === a[0] ? c && (c = !b.push(a)) : b.push(d); + }); + c && b.push(a); + this.#d = b; + } + *entries() { + yield* this.#d; + } + *keys() { + for (var [a] of this) + yield a; + } + *values() { + for (var [, a] of this) + yield a; + } + }; + } +}); + +// node_modules/node-domexception/index.js +var require_node_domexception = __commonJS({ + "node_modules/node-domexception/index.js"(exports, module2) { + if (!globalThis.DOMException) { + try { + const { MessageChannel } = require("worker_threads"), port = new MessageChannel().port1, ab = new ArrayBuffer(); + port.postMessage(ab, [ab, ab]); + } catch (err) { + err.constructor.name === "DOMException" && (globalThis.DOMException = err.constructor); + } + } + module2.exports = globalThis.DOMException; + } +}); + +// node_modules/fetch-blob/from.js +var import_node_fs, import_node_domexception, stat, BlobDataItem; +var init_from = __esm({ + "node_modules/fetch-blob/from.js"() { + import_node_fs = require("node:fs"); + import_node_domexception = __toESM(require_node_domexception(), 1); + init_file(); + init_fetch_blob(); + ({ stat } = import_node_fs.promises); + BlobDataItem = class { + #path; + #start; + constructor(options) { + this.#path = options.path; + this.#start = options.start; + this.size = options.size; + this.lastModified = options.lastModified; + this.originalSize = options.originalSize === void 0 ? options.size : options.originalSize; + } + slice(start, end) { + return new BlobDataItem({ + path: this.#path, + lastModified: this.lastModified, + originalSize: this.originalSize, + size: end - start, + start: this.#start + start + }); + } + async *stream() { + const { mtimeMs, size } = await stat(this.#path); + if (mtimeMs > this.lastModified || this.originalSize !== size) { + throw new import_node_domexception.default("The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.", "NotReadableError"); + } + yield* (0, import_node_fs.createReadStream)(this.#path, { + start: this.#start, + end: this.#start + this.size - 1 + }); + } + get [Symbol.toStringTag]() { + return "Blob"; + } + }; + } +}); + +// node_modules/node-fetch/src/utils/multipart-parser.js +var multipart_parser_exports = {}; +__export(multipart_parser_exports, { + toFormData: () => toFormData +}); +function _fileName(headerValue) { + const m2 = headerValue.match(/\bfilename=("(.*?)"|([^()<>@,;:\\"/[\]?={}\s\t]+))($|;\s)/i); + if (!m2) { + return; + } + const match = m2[2] || m2[3] || ""; + let filename = match.slice(match.lastIndexOf("\\") + 1); + filename = filename.replace(/%22/g, '"'); + filename = filename.replace(/&#(\d{4});/g, (m3, code) => { + return String.fromCharCode(code); + }); + return filename; +} +async function toFormData(Body2, ct) { + if (!/multipart/i.test(ct)) { + throw new TypeError("Failed to fetch"); + } + const m2 = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i); + if (!m2) { + throw new TypeError("no or bad content-type header, no multipart boundary"); + } + const parser = new MultipartParser(m2[1] || m2[2]); + let headerField; + let headerValue; + let entryValue; + let entryName; + let contentType; + let filename; + const entryChunks = []; + const formData = new FormData2(); + const onPartData = (ui8a) => { + entryValue += decoder.decode(ui8a, { stream: true }); + }; + const appendToFile = (ui8a) => { + entryChunks.push(ui8a); + }; + const appendFileToFormData = () => { + const file = new file_default(entryChunks, filename, { type: contentType }); + formData.append(entryName, file); + }; + const appendEntryToFormData = () => { + formData.append(entryName, entryValue); + }; + const decoder = new TextDecoder("utf-8"); + decoder.decode(); + parser.onPartBegin = function() { + parser.onPartData = onPartData; + parser.onPartEnd = appendEntryToFormData; + headerField = ""; + headerValue = ""; + entryValue = ""; + entryName = ""; + contentType = ""; + filename = null; + entryChunks.length = 0; + }; + parser.onHeaderField = function(ui8a) { + headerField += decoder.decode(ui8a, { stream: true }); + }; + parser.onHeaderValue = function(ui8a) { + headerValue += decoder.decode(ui8a, { stream: true }); + }; + parser.onHeaderEnd = function() { + headerValue += decoder.decode(); + headerField = headerField.toLowerCase(); + if (headerField === "content-disposition") { + const m3 = headerValue.match(/\bname=("([^"]*)"|([^()<>@,;:\\"/[\]?={}\s\t]+))/i); + if (m3) { + entryName = m3[2] || m3[3] || ""; + } + filename = _fileName(headerValue); + if (filename) { + parser.onPartData = appendToFile; + parser.onPartEnd = appendFileToFormData; + } + } else if (headerField === "content-type") { + contentType = headerValue; + } + headerValue = ""; + headerField = ""; + }; + for await (const chunk of Body2) { + parser.write(chunk); + } + parser.end(); + return formData; +} +var s, S, f2, F, LF, CR, SPACE, HYPHEN, COLON, A, Z, lower, noop, MultipartParser; +var init_multipart_parser = __esm({ + "node_modules/node-fetch/src/utils/multipart-parser.js"() { + init_from(); + init_esm_min(); + s = 0; + S = { + START_BOUNDARY: s++, + HEADER_FIELD_START: s++, + HEADER_FIELD: s++, + HEADER_VALUE_START: s++, + HEADER_VALUE: s++, + HEADER_VALUE_ALMOST_DONE: s++, + HEADERS_ALMOST_DONE: s++, + PART_DATA_START: s++, + PART_DATA: s++, + END: s++ + }; + f2 = 1; + F = { + PART_BOUNDARY: f2, + LAST_BOUNDARY: f2 *= 2 + }; + LF = 10; + CR = 13; + SPACE = 32; + HYPHEN = 45; + COLON = 58; + A = 97; + Z = 122; + lower = (c) => c | 32; + noop = () => { + }; + MultipartParser = class { + constructor(boundary) { + this.index = 0; + this.flags = 0; + this.onHeaderEnd = noop; + this.onHeaderField = noop; + this.onHeadersEnd = noop; + this.onHeaderValue = noop; + this.onPartBegin = noop; + this.onPartData = noop; + this.onPartEnd = noop; + this.boundaryChars = {}; + boundary = "\r\n--" + boundary; + const ui8a = new Uint8Array(boundary.length); + for (let i2 = 0; i2 < boundary.length; i2++) { + ui8a[i2] = boundary.charCodeAt(i2); + this.boundaryChars[ui8a[i2]] = true; + } + this.boundary = ui8a; + this.lookbehind = new Uint8Array(this.boundary.length + 8); + this.state = S.START_BOUNDARY; + } + write(data) { + let i2 = 0; + const length_ = data.length; + let previousIndex = this.index; + let { lookbehind, boundary, boundaryChars, index, state, flags } = this; + const boundaryLength = this.boundary.length; + const boundaryEnd = boundaryLength - 1; + const bufferLength = data.length; + let c; + let cl; + const mark = (name) => { + this[name + "Mark"] = i2; + }; + const clear = (name) => { + delete this[name + "Mark"]; + }; + const callback = (callbackSymbol, start, end, ui8a) => { + if (start === void 0 || start !== end) { + this[callbackSymbol](ui8a && ui8a.subarray(start, end)); + } + }; + const dataCallback = (name, clear2) => { + const markSymbol = name + "Mark"; + if (!(markSymbol in this)) { + return; + } + if (clear2) { + callback(name, this[markSymbol], i2, data); + delete this[markSymbol]; + } else { + callback(name, this[markSymbol], data.length, data); + this[markSymbol] = 0; + } + }; + for (i2 = 0; i2 < length_; i2++) { + c = data[i2]; + switch (state) { + case S.START_BOUNDARY: + if (index === boundary.length - 2) { + if (c === HYPHEN) { + flags |= F.LAST_BOUNDARY; + } else if (c !== CR) { + return; + } + index++; + break; + } else if (index - 1 === boundary.length - 2) { + if (flags & F.LAST_BOUNDARY && c === HYPHEN) { + state = S.END; + flags = 0; + } else if (!(flags & F.LAST_BOUNDARY) && c === LF) { + index = 0; + callback("onPartBegin"); + state = S.HEADER_FIELD_START; + } else { + return; + } + break; + } + if (c !== boundary[index + 2]) { + index = -2; + } + if (c === boundary[index + 2]) { + index++; + } + break; + case S.HEADER_FIELD_START: + state = S.HEADER_FIELD; + mark("onHeaderField"); + index = 0; + case S.HEADER_FIELD: + if (c === CR) { + clear("onHeaderField"); + state = S.HEADERS_ALMOST_DONE; + break; + } + index++; + if (c === HYPHEN) { + break; + } + if (c === COLON) { + if (index === 1) { + return; + } + dataCallback("onHeaderField", true); + state = S.HEADER_VALUE_START; + break; + } + cl = lower(c); + if (cl < A || cl > Z) { + return; + } + break; + case S.HEADER_VALUE_START: + if (c === SPACE) { + break; + } + mark("onHeaderValue"); + state = S.HEADER_VALUE; + case S.HEADER_VALUE: + if (c === CR) { + dataCallback("onHeaderValue", true); + callback("onHeaderEnd"); + state = S.HEADER_VALUE_ALMOST_DONE; + } + break; + case S.HEADER_VALUE_ALMOST_DONE: + if (c !== LF) { + return; + } + state = S.HEADER_FIELD_START; + break; + case S.HEADERS_ALMOST_DONE: + if (c !== LF) { + return; + } + callback("onHeadersEnd"); + state = S.PART_DATA_START; + break; + case S.PART_DATA_START: + state = S.PART_DATA; + mark("onPartData"); + case S.PART_DATA: + previousIndex = index; + if (index === 0) { + i2 += boundaryEnd; + while (i2 < bufferLength && !(data[i2] in boundaryChars)) { + i2 += boundaryLength; + } + i2 -= boundaryEnd; + c = data[i2]; + } + if (index < boundary.length) { + if (boundary[index] === c) { + if (index === 0) { + dataCallback("onPartData", true); + } + index++; + } else { + index = 0; + } + } else if (index === boundary.length) { + index++; + if (c === CR) { + flags |= F.PART_BOUNDARY; + } else if (c === HYPHEN) { + flags |= F.LAST_BOUNDARY; + } else { + index = 0; + } + } else if (index - 1 === boundary.length) { + if (flags & F.PART_BOUNDARY) { + index = 0; + if (c === LF) { + flags &= ~F.PART_BOUNDARY; + callback("onPartEnd"); + callback("onPartBegin"); + state = S.HEADER_FIELD_START; + break; + } + } else if (flags & F.LAST_BOUNDARY) { + if (c === HYPHEN) { + callback("onPartEnd"); + state = S.END; + flags = 0; + } else { + index = 0; + } + } else { + index = 0; + } + } + if (index > 0) { + lookbehind[index - 1] = c; + } else if (previousIndex > 0) { + const _lookbehind = new Uint8Array(lookbehind.buffer, lookbehind.byteOffset, lookbehind.byteLength); + callback("onPartData", 0, previousIndex, _lookbehind); + previousIndex = 0; + mark("onPartData"); + i2--; + } + break; + case S.END: + break; + default: + throw new Error(`Unexpected state entered: ${state}`); + } + } + dataCallback("onHeaderField"); + dataCallback("onHeaderValue"); + dataCallback("onPartData"); + this.index = index; + this.state = state; + this.flags = flags; + } + end() { + if (this.state === S.HEADER_FIELD_START && this.index === 0 || this.state === S.PART_DATA && this.index === this.boundary.length) { + this.onPartEnd(); + } else if (this.state !== S.END) { + throw new Error("MultipartParser.end(): stream ended unexpectedly"); + } + } + }; + } +}); + +// src/action.ts +var import_core7 = __toESM(require_core(), 1); + +// src/lib/cache.ts +var import_core = __toESM(require_core(), 1); +var import_crypto = require("crypto"); +var import_fs = __toESM(require("fs"), 1); +var import_util = require("util"); +var read = (0, import_util.promisify)(import_fs.default.readFile); +var write = (0, import_util.promisify)(import_fs.default.writeFile); +var md = (0, import_util.promisify)(import_fs.default.mkdir); +var CacheRecord = class { + constructor(feedTitle, title, date) { + this.feedTitle = feedTitle; + this.title = title; + this.date = date; + } +}; +var hash = (str) => { + return (0, import_crypto.createHash)("sha256").update(str).digest("hex"); +}; +var cacheSlug = (item) => { + const { feedTitle, title, created } = item; + let slug = ""; + slug += feedTitle == null ? void 0 : feedTitle.toLowerCase().replace(/[^a-z0-9]/g, "-"); + slug += title == null ? void 0 : title.toLowerCase().replace(/[^a-z0-9]/g, "-"); + if (created) { + const date = new Date(created); + slug += `${slug}-${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`; + } + return slug; +}; +var readCache = async (rssFeed, cacheDir) => { + try { + import_core.default.debug(`Retrieving previously published entries\u2026`); + const rssFeedUrl = new URL(rssFeed); + const cachePath = `${cacheDir}/${rssFeedUrl.hostname.replace(/\./g, "_")}.json`; + const cached = JSON.parse(await read(cachePath, "utf8")); + import_core.default.debug(`Found ${cached.length} cached items`); + return cached; + } catch (err) { + import_core.default.debug(err.message); + throw new Error("Failed to read cache"); + } +}; +var checkCache = async (rss, cached) => { + try { + if (rss == null ? void 0 : rss.items) { + const output = []; + for (const item of rss.items) { + let cacheHit = false; + for (const published in cached) { + const record = new CacheRecord(rss.title, item.title, item.created); + if (cached[published] === hash(cacheSlug(record))) { + cacheHit = true; + import_core.default.debug(`Cache hit for ${item.title}`); + } + } + if (!cacheHit) + output.push(item); + } + import_core.default.debug(`Found ${output.length} new items`); + return output; + } else { + import_core.default.debug("Nothing to check"); + return []; + } + } catch (err) { + import_core.default.debug(err.message); + throw new Error("Error checking cache"); + } +}; +var writeCache = async (feedTitle, rssFeed, cacheDir, filtered, cached) => { + try { + const rssFeedUrl = new URL(rssFeed); + const cachePath = `${cacheDir}/${rssFeedUrl.hostname.replace(/\./g, "_")}.json`; + import_core.default.debug(`Writing cache to ${cachePath}`); + await md(cacheDir, { recursive: true }); + const hashed = [...cached]; + for (const sent of filtered) { + const record = new CacheRecord(feedTitle, sent.title, sent.created); + hashed.push(hash(cacheSlug(record))); + } + await write(cachePath, JSON.stringify(hashed)); + } catch (err) { + import_core.default.debug(err.message); + throw new Error("Failed to write to cache"); + } +}; + +// src/lib/getfeed.ts +var import_core2 = __toESM(require_core(), 1); +var import_dayjs = __toESM(require_dayjs_min(), 1); +var import_rss_to_json = __toESM(require_dist(), 1); +var getFeed = async (rssFeed, cacheDir, interval) => { + var _a, _b; + import_core2.default.debug(`Retrieving ${rssFeed}\u2026`); + const rss = await (0, import_rss_to_json.parse)(rssFeed, {}); + import_core2.default.debug(`Feed has ${(_a = rss == null ? void 0 : rss.items) == null ? void 0 : _a.length} items`); + if ((_b = rss == null ? void 0 : rss.items) == null ? void 0 : _b.length) { + let toSend = []; + let cached = []; + if (cacheDir) { + import_core2.default.debug(`Retrieving previously cached entries\u2026`); + try { + cached = await readCache(rssFeed, cacheDir); + toSend = await checkCache(rss, cached); + } catch (err) { + import_core2.default.debug(err.message); + toSend = rss.items.filter((item) => { + return (0, import_dayjs.default)(item.created).isAfter((0, import_dayjs.default)().subtract(60, "minute")); + }); + } + } else if (interval) { + import_core2.default.debug(`Selecting items posted in the last ${interval} minutes\u2026`); + toSend = rss.items.filter((item) => { + return (0, import_dayjs.default)(item.created).isAfter((0, import_dayjs.default)().subtract(interval, "minute")); + }); + } + return { filtered: toSend, unfiltered: rss, cached }; + } else { + throw new Error("No feed items found"); + } +}; + +// src/lib/payload.ts +var import_core4 = __toESM(require_core(), 1); +var import_html_to_text = __toESM(require_html_to_text2(), 1); + +// node_modules/linkedom/esm/shared/symbols.js +var CHANGED = Symbol("changed"); +var CLASS_LIST = Symbol("classList"); +var CUSTOM_ELEMENTS = Symbol("CustomElements"); +var CONTENT = Symbol("content"); +var DATASET = Symbol("dataset"); +var DOCTYPE = Symbol("doctype"); +var DOM_PARSER = Symbol("DOMParser"); +var END = Symbol("end"); +var EVENT_TARGET = Symbol("EventTarget"); +var GLOBALS = Symbol("globals"); +var IMAGE = Symbol("image"); +var MIME = Symbol("mime"); +var MUTATION_OBSERVER = Symbol("MutationObserver"); +var NEXT = Symbol("next"); +var OWNER_ELEMENT = Symbol("ownerElement"); +var PREV = Symbol("prev"); +var PRIVATE = Symbol("private"); +var SHEET = Symbol("sheet"); +var START = Symbol("start"); +var STYLE = Symbol("style"); +var UPGRADE = Symbol("upgrade"); +var VALUE = Symbol("value"); + +// node_modules/linkedom/esm/shared/parse-from-string.js +var HTMLParser2 = __toESM(require_lib7(), 1); + +// node_modules/linkedom/esm/shared/constants.js +var NODE_END = -1; +var ELEMENT_NODE = 1; +var ATTRIBUTE_NODE = 2; +var TEXT_NODE = 3; +var COMMENT_NODE = 8; +var DOCUMENT_NODE = 9; +var DOCUMENT_TYPE_NODE = 10; +var DOCUMENT_FRAGMENT_NODE = 11; +var SHOW_ALL = -1; +var SHOW_ELEMENT = 1; +var SHOW_TEXT = 4; +var SHOW_COMMENT = 128; +var DOCUMENT_POSITION_DISCONNECTED = 1; +var DOCUMENT_POSITION_PRECEDING = 2; +var DOCUMENT_POSITION_FOLLOWING = 4; +var DOCUMENT_POSITION_CONTAINS = 8; +var DOCUMENT_POSITION_CONTAINED_BY = 16; +var DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32; +var SVG_NAMESPACE = "http://www.w3.org/2000/svg"; + +// node_modules/linkedom/esm/shared/object.js +var { + assign, + create, + defineProperties, + entries, + getOwnPropertyDescriptors, + keys, + setPrototypeOf +} = Object; + +// node_modules/linkedom/esm/shared/utils.js +var $String = String; +var getEnd = (node) => node.nodeType === ELEMENT_NODE ? node[END] : node; +var ignoreCase = ({ ownerDocument }) => ownerDocument[MIME].ignoreCase; +var knownAdjacent = (prev, next) => { + prev[NEXT] = next; + next[PREV] = prev; +}; +var knownBoundaries = (prev, current, next) => { + knownAdjacent(prev, current); + knownAdjacent(getEnd(current), next); +}; +var knownSegment = (prev, start, end, next) => { + knownAdjacent(prev, start); + knownAdjacent(getEnd(end), next); +}; +var knownSiblings = (prev, current, next) => { + knownAdjacent(prev, current); + knownAdjacent(current, next); +}; +var localCase = ({ localName, ownerDocument }) => { + return ownerDocument[MIME].ignoreCase ? localName.toUpperCase() : localName; +}; +var setAdjacent = (prev, next) => { + if (prev) + prev[NEXT] = next; + if (next) + next[PREV] = prev; +}; + +// node_modules/linkedom/esm/interface/custom-element-registry.js +var reactive = false; +var Classes = /* @__PURE__ */ new WeakMap(); +var customElements = /* @__PURE__ */ new WeakMap(); +var attributeChangedCallback = (element, attributeName, oldValue, newValue) => { + if (reactive && customElements.has(element) && element.attributeChangedCallback && element.constructor.observedAttributes.includes(attributeName)) { + element.attributeChangedCallback(attributeName, oldValue, newValue); + } +}; +var createTrigger = (method, isConnected2) => (element) => { + if (customElements.has(element)) { + const info = customElements.get(element); + if (info.connected !== isConnected2 && element.isConnected === isConnected2) { + info.connected = isConnected2; + if (method in element) + element[method](); + } + } +}; +var triggerConnected = createTrigger("connectedCallback", true); +var connectedCallback = (element) => { + if (reactive) { + triggerConnected(element); + let { [NEXT]: next, [END]: end } = element; + while (next !== end) { + if (next.nodeType === ELEMENT_NODE) + triggerConnected(next); + next = next[NEXT]; + } + } +}; +var triggerDisconnected = createTrigger("disconnectedCallback", false); +var disconnectedCallback = (element) => { + if (reactive) { + triggerDisconnected(element); + let { [NEXT]: next, [END]: end } = element; + while (next !== end) { + if (next.nodeType === ELEMENT_NODE) + triggerDisconnected(next); + next = next[NEXT]; + } + } +}; +var CustomElementRegistry = class { + constructor(ownerDocument) { + this.ownerDocument = ownerDocument; + this.registry = /* @__PURE__ */ new Map(); + this.waiting = /* @__PURE__ */ new Map(); + this.active = false; + } + define(localName, Class, options = {}) { + const { ownerDocument, registry, waiting } = this; + if (registry.has(localName)) + throw new Error("unable to redefine " + localName); + if (Classes.has(Class)) + throw new Error("unable to redefine the same class: " + Class); + this.active = reactive = true; + const { extends: extend } = options; + Classes.set(Class, { + ownerDocument, + options: { is: extend ? localName : "" }, + localName: extend || localName + }); + const check = extend ? (element) => { + return element.localName === extend && element.getAttribute("is") === localName; + } : (element) => element.localName === localName; + registry.set(localName, { Class, check }); + if (waiting.has(localName)) { + for (const resolve of waiting.get(localName)) + resolve(Class); + waiting.delete(localName); + } + ownerDocument.querySelectorAll(extend ? `${extend}[is="${localName}"]` : localName).forEach(this.upgrade, this); + } + upgrade(element) { + if (customElements.has(element)) + return; + const { ownerDocument, registry } = this; + const ce = element.getAttribute("is") || element.localName; + if (registry.has(ce)) { + const { Class, check } = registry.get(ce); + if (check(element)) { + const { attributes, isConnected: isConnected2 } = element; + for (const attr of attributes) + element.removeAttributeNode(attr); + const values = entries(element); + for (const [key2] of values) + delete element[key2]; + setPrototypeOf(element, Class.prototype); + ownerDocument[UPGRADE] = { element, values }; + new Class(ownerDocument, ce); + customElements.set(element, { connected: isConnected2 }); + for (const attr of attributes) + element.setAttributeNode(attr); + if (isConnected2 && element.connectedCallback) + element.connectedCallback(); + } + } + } + whenDefined(localName) { + const { registry, waiting } = this; + return new Promise((resolve) => { + if (registry.has(localName)) + resolve(registry.get(localName).Class); + else { + if (!waiting.has(localName)) + waiting.set(localName, []); + waiting.get(localName).push(resolve); + } + }); + } + get(localName) { + const info = this.registry.get(localName); + return info && info.Class; + } +}; + +// node_modules/linkedom/esm/shared/parse-from-string.js +var { Parser } = HTMLParser2; +var notParsing = true; +var append = (self2, node, active) => { + const end = self2[END]; + node.parentNode = self2; + knownBoundaries(end[PREV], node, end); + if (active && node.nodeType === ELEMENT_NODE) + connectedCallback(node); + return node; +}; +var attribute = (element, end, attribute2, value, active) => { + attribute2[VALUE] = value; + attribute2.ownerElement = element; + knownSiblings(end[PREV], attribute2, end); + if (attribute2.name === "class") + element.className = value; + if (active) + attributeChangedCallback(element, attribute2.name, null, value); +}; +var parseFromString = (document2, isHTML, markupLanguage) => { + const { active, registry } = document2[CUSTOM_ELEMENTS]; + let node = document2; + let ownerSVGElement = null; + notParsing = false; + const content = new Parser({ + onprocessinginstruction(name, data) { + if (name.toLowerCase() === "!doctype") + document2.doctype = data.slice(name.length).trim(); + }, + onopentag(name, attributes) { + let create3 = true; + if (isHTML) { + if (ownerSVGElement) { + node = append(node, document2.createElementNS(SVG_NAMESPACE, name), active); + node.ownerSVGElement = ownerSVGElement; + create3 = false; + } else if (name === "svg" || name === "SVG") { + ownerSVGElement = document2.createElementNS(SVG_NAMESPACE, name); + node = append(node, ownerSVGElement, active); + create3 = false; + } else if (active) { + const ce = name.includes("-") ? name : attributes.is || ""; + if (ce && registry.has(ce)) { + const { Class } = registry.get(ce); + node = append(node, new Class(), active); + delete attributes.is; + create3 = false; + } + } + } + if (create3) + node = append(node, document2.createElement(name), false); + let end = node[END]; + for (const name2 of keys(attributes)) + attribute(node, end, document2.createAttribute(name2), attributes[name2], active); + }, + oncomment(data) { + append(node, document2.createComment(data), active); + }, + ontext(text) { + append(node, document2.createTextNode(text), active); + }, + onclosetag() { + if (isHTML && node === ownerSVGElement) + ownerSVGElement = null; + node = node.parentNode; + } + }, { + lowerCaseAttributeNames: false, + decodeEntities: true, + xmlMode: !isHTML + }); + content.write(markupLanguage); + content.end(); + notParsing = true; + return document2; +}; + +// node_modules/linkedom/esm/shared/register-html-class.js +var htmlClasses = /* @__PURE__ */ new Map(); +var registerHTMLClass = (names, Class) => { + for (const name of [].concat(names)) { + htmlClasses.set(name, Class); + htmlClasses.set(name.toUpperCase(), Class); + } +}; + +// node_modules/linkedom/esm/interface/document.js +var import_perf_hooks = __toESM(require_perf_hooks(), 1); + +// node_modules/linkedom/esm/shared/jsdon.js +var loopSegment = ({ [NEXT]: next, [END]: end }, json) => { + while (next !== end) { + switch (next.nodeType) { + case ATTRIBUTE_NODE: + attrAsJSON(next, json); + break; + case TEXT_NODE: + case COMMENT_NODE: + characterDataAsJSON(next, json); + break; + case ELEMENT_NODE: + elementAsJSON(next, json); + next = getEnd(next); + break; + case DOCUMENT_TYPE_NODE: + documentTypeAsJSON(next, json); + break; + } + next = next[NEXT]; + } + const last = json.length - 1; + const value = json[last]; + if (typeof value === "number" && value < 0) + json[last] += NODE_END; + else + json.push(NODE_END); +}; +var attrAsJSON = (attr, json) => { + json.push(ATTRIBUTE_NODE, attr.name); + const value = attr[VALUE].trim(); + if (value) + json.push(value); +}; +var characterDataAsJSON = (node, json) => { + const value = node[VALUE]; + if (value.trim()) + json.push(node.nodeType, value); +}; +var nonElementAsJSON = (node, json) => { + json.push(node.nodeType); + loopSegment(node, json); +}; +var documentTypeAsJSON = ({ name, publicId, systemId }, json) => { + json.push(DOCUMENT_TYPE_NODE, name); + if (publicId) + json.push(publicId); + if (systemId) + json.push(systemId); +}; +var elementAsJSON = (element, json) => { + json.push(ELEMENT_NODE, element.localName); + loopSegment(element, json); +}; + +// node_modules/linkedom/esm/interface/mutation-observer.js +var createRecord = (type, target, addedNodes, removedNodes, attributeName, oldValue) => ({ type, target, addedNodes, removedNodes, attributeName, oldValue }); +var queueAttribute = (observer, target, attributeName, attributeFilter, attributeOldValue, oldValue) => { + if (!attributeFilter || attributeFilter.includes(attributeName)) { + const { callback, records, scheduled } = observer; + records.push(createRecord("attributes", target, [], [], attributeName, attributeOldValue ? oldValue : void 0)); + if (!scheduled) { + observer.scheduled = true; + Promise.resolve().then(() => { + observer.scheduled = false; + callback(records.splice(0), observer); + }); + } + } +}; +var attributeChangedCallback2 = (element, attributeName, oldValue) => { + const { ownerDocument } = element; + const { active, observers } = ownerDocument[MUTATION_OBSERVER]; + if (active) { + for (const observer of observers) { + for (const [ + target, + { + childList, + subtree, + attributes, + attributeFilter, + attributeOldValue + } + ] of observer.nodes) { + if (childList) { + if (subtree && (target === ownerDocument || target.contains(element)) || !subtree && target.children.includes(element)) { + queueAttribute(observer, element, attributeName, attributeFilter, attributeOldValue, oldValue); + break; + } + } else if (attributes && target === element) { + queueAttribute(observer, element, attributeName, attributeFilter, attributeOldValue, oldValue); + break; + } + } + } + } +}; +var moCallback = (element, parentNode) => { + const { ownerDocument } = element; + const { active, observers } = ownerDocument[MUTATION_OBSERVER]; + if (active) { + for (const observer of observers) { + for (const [target, { subtree, childList, characterData }] of observer.nodes) { + if (childList) { + if (parentNode && (target === parentNode || subtree && target.contains(parentNode)) || !parentNode && (subtree && (target === ownerDocument || target.contains(element)) || !subtree && target[characterData ? "childNodes" : "children"].includes(element))) { + const { callback, records, scheduled } = observer; + records.push(createRecord("childList", target, parentNode ? [] : [element], parentNode ? [element] : [])); + if (!scheduled) { + observer.scheduled = true; + Promise.resolve().then(() => { + observer.scheduled = false; + callback(records.splice(0), observer); + }); + } + break; + } + } + } + } + } +}; +var MutationObserverClass = class { + constructor(ownerDocument) { + const observers = /* @__PURE__ */ new Set(); + this.observers = observers; + this.active = false; + this.class = class MutationObserver { + constructor(callback) { + this.callback = callback; + this.nodes = /* @__PURE__ */ new Map(); + this.records = []; + this.scheduled = false; + } + disconnect() { + this.records.splice(0); + this.nodes.clear(); + observers.delete(this); + ownerDocument[MUTATION_OBSERVER].active = !!observers.size; + } + observe(target, options = { + subtree: false, + childList: false, + attributes: false, + attributeFilter: null, + attributeOldValue: false, + characterData: false + }) { + if ("attributeOldValue" in options || "attributeFilter" in options) + options.attributes = true; + options.childList = !!options.childList; + options.subtree = !!options.subtree; + this.nodes.set(target, options); + observers.add(this); + ownerDocument[MUTATION_OBSERVER].active = true; + } + takeRecords() { + return this.records.splice(0); + } + }; + } +}; + +// node_modules/linkedom/esm/shared/attributes.js +var emptyAttributes = /* @__PURE__ */ new Set([ + "allowfullscreen", + "allowpaymentrequest", + "async", + "autofocus", + "autoplay", + "checked", + "class", + "contenteditable", + "controls", + "default", + "defer", + "disabled", + "draggable", + "formnovalidate", + "hidden", + "id", + "ismap", + "itemscope", + "loop", + "multiple", + "muted", + "nomodule", + "novalidate", + "open", + "playsinline", + "readonly", + "required", + "reversed", + "selected", + "style", + "truespeed" +]); +var setAttribute = (element, attribute2) => { + const { [VALUE]: value, name } = attribute2; + attribute2.ownerElement = element; + knownSiblings(element, attribute2, element[NEXT]); + if (name === "class") + element.className = value; + attributeChangedCallback2(element, name, null); + attributeChangedCallback(element, name, null, value); +}; +var removeAttribute = (element, attribute2) => { + const { [VALUE]: value, name } = attribute2; + knownAdjacent(attribute2[PREV], attribute2[NEXT]); + attribute2.ownerElement = attribute2[PREV] = attribute2[NEXT] = null; + if (name === "class") + element[CLASS_LIST] = null; + attributeChangedCallback2(element, name, value); + attributeChangedCallback(element, name, value, null); +}; +var booleanAttribute = { + get(element, name) { + return element.hasAttribute(name); + }, + set(element, name, value) { + if (value) + element.setAttribute(name, ""); + else + element.removeAttribute(name); + } +}; +var numericAttribute = { + get(element, name) { + return parseFloat(element.getAttribute(name) || 0); + }, + set(element, name, value) { + element.setAttribute(name, value); + } +}; +var stringAttribute = { + get(element, name) { + return element.getAttribute(name) || ""; + }, + set(element, name, value) { + element.setAttribute(name, value); + } +}; + +// node_modules/linkedom/esm/interface/event-target.js +var wm = /* @__PURE__ */ new WeakMap(); +function dispatch(event, listener) { + if (typeof listener === "function") + listener.call(event.target, event); + else + listener.handleEvent(event); + return event._stopImmediatePropagationFlag; +} +function invokeListeners({ currentTarget, target }) { + const map = wm.get(currentTarget); + if (map && map.has(this.type)) { + const listeners = map.get(this.type); + if (currentTarget === target) { + this.eventPhase = this.AT_TARGET; + } else { + this.eventPhase = this.BUBBLING_PHASE; + } + this.currentTarget = currentTarget; + this.target = target; + for (const [listener, options] of listeners) { + if (options && options.once) + listeners.delete(listener); + if (dispatch(this, listener)) + break; + } + delete this.currentTarget; + delete this.target; + return this.cancelBubble; + } +} +var DOMEventTarget = class { + constructor() { + wm.set(this, /* @__PURE__ */ new Map()); + } + _getParent() { + return null; + } + addEventListener(type, listener, options) { + const map = wm.get(this); + if (!map.has(type)) + map.set(type, /* @__PURE__ */ new Map()); + map.get(type).set(listener, options); + } + removeEventListener(type, listener) { + const map = wm.get(this); + if (map.has(type)) { + const listeners = map.get(type); + if (listeners.delete(listener) && !listeners.size) + map.delete(type); + } + } + dispatchEvent(event) { + let node = this; + event.eventPhase = event.CAPTURING_PHASE; + while (node) { + if (node.dispatchEvent) + event._path.push({ currentTarget: node, target: this }); + node = event.bubbles && node._getParent && node._getParent(); + } + event._path.some(invokeListeners, event); + event._path = []; + event.eventPhase = event.NONE; + return !event.defaultPrevented; + } +}; + +// node_modules/linkedom/esm/interface/node-list.js +var NodeList = class extends Array { + item(i2) { + return i2 < this.length ? this[i2] : null; + } +}; + +// node_modules/linkedom/esm/interface/node.js +var getParentNodeCount = ({ parentNode }) => { + let count = 0; + while (parentNode) { + count++; + parentNode = parentNode.parentNode; + } + return count; +}; +var Node = class extends DOMEventTarget { + static get ELEMENT_NODE() { + return ELEMENT_NODE; + } + static get ATTRIBUTE_NODE() { + return ATTRIBUTE_NODE; + } + static get TEXT_NODE() { + return TEXT_NODE; + } + static get COMMENT_NODE() { + return COMMENT_NODE; + } + static get DOCUMENT_NODE() { + return DOCUMENT_NODE; + } + static get DOCUMENT_FRAGMENT_NODE() { + return DOCUMENT_FRAGMENT_NODE; + } + static get DOCUMENT_TYPE_NODE() { + return DOCUMENT_TYPE_NODE; + } + constructor(ownerDocument, localName, nodeType) { + super(); + this.ownerDocument = ownerDocument; + this.localName = localName; + this.nodeType = nodeType; + this.parentNode = null; + this[NEXT] = null; + this[PREV] = null; + } + get ELEMENT_NODE() { + return ELEMENT_NODE; + } + get ATTRIBUTE_NODE() { + return ATTRIBUTE_NODE; + } + get TEXT_NODE() { + return TEXT_NODE; + } + get COMMENT_NODE() { + return COMMENT_NODE; + } + get DOCUMENT_NODE() { + return DOCUMENT_NODE; + } + get DOCUMENT_FRAGMENT_NODE() { + return DOCUMENT_FRAGMENT_NODE; + } + get DOCUMENT_TYPE_NODE() { + return DOCUMENT_TYPE_NODE; + } + get baseURI() { + const ownerDocument = this.nodeType === DOCUMENT_NODE ? this : this.ownerDocument; + if (ownerDocument) { + const base = ownerDocument.querySelector("base"); + if (base) + return base.getAttribute("href"); + const { location } = ownerDocument.defaultView; + if (location) + return location.href; + } + return null; + } + get isConnected() { + return false; + } + get nodeName() { + return this.localName; + } + get parentElement() { + return null; + } + get previousSibling() { + return null; + } + get previousElementSibling() { + return null; + } + get nextSibling() { + return null; + } + get nextElementSibling() { + return null; + } + get childNodes() { + return new NodeList(); + } + get firstChild() { + return null; + } + get lastChild() { + return null; + } + get nodeValue() { + return null; + } + set nodeValue(value) { + } + get textContent() { + return null; + } + set textContent(value) { + } + normalize() { + } + cloneNode() { + return null; + } + contains() { + return false; + } + insertBefore(newNode, referenceNode) { + return newNode; + } + appendChild(child) { + return child; + } + replaceChild(newChild, oldChild) { + return oldChild; + } + removeChild(child) { + return child; + } + toString() { + return ""; + } + hasChildNodes() { + return !!this.lastChild; + } + isSameNode(node) { + return this === node; + } + compareDocumentPosition(target) { + let result = 0; + if (this !== target) { + let self2 = getParentNodeCount(this); + let other = getParentNodeCount(target); + if (self2 < other) { + result += DOCUMENT_POSITION_FOLLOWING; + if (this.contains(target)) + result += DOCUMENT_POSITION_CONTAINED_BY; + } else if (other < self2) { + result += DOCUMENT_POSITION_PRECEDING; + if (target.contains(this)) + result += DOCUMENT_POSITION_CONTAINS; + } else if (self2 && other) { + const { childNodes } = this.parentNode; + if (childNodes.indexOf(this) < childNodes.indexOf(target)) + result += DOCUMENT_POSITION_FOLLOWING; + else + result += DOCUMENT_POSITION_PRECEDING; + } + if (!self2 || !other) { + result += DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC; + result += DOCUMENT_POSITION_DISCONNECTED; + } + } + return result; + } + isEqualNode(node) { + if (this === node) + return true; + if (this.nodeType === node.nodeType) { + switch (this.nodeType) { + case DOCUMENT_NODE: + case DOCUMENT_FRAGMENT_NODE: { + const aNodes = this.childNodes; + const bNodes = node.childNodes; + return aNodes.length === bNodes.length && aNodes.every((node2, i2) => node2.isEqualNode(bNodes[i2])); + } + } + return this.toString() === node.toString(); + } + return false; + } + _getParent() { + return this.parentNode; + } + getRootNode() { + let root = this; + while (root.parentNode) + root = root.parentNode; + return root.nodeType === DOCUMENT_NODE ? root.documentElement : root; + } +}; + +// node_modules/linkedom/esm/interface/attr.js +var QUOTE = /"/g; +var Attr = class extends Node { + constructor(ownerDocument, name, value = "") { + super(ownerDocument, "#attribute", ATTRIBUTE_NODE); + this.ownerElement = null; + this.name = $String(name); + this[VALUE] = $String(value); + this[CHANGED] = false; + } + get value() { + return this[VALUE]; + } + set value(newValue) { + const { [VALUE]: oldValue, name, ownerElement } = this; + this[VALUE] = $String(newValue); + this[CHANGED] = true; + if (ownerElement) { + attributeChangedCallback2(ownerElement, name, oldValue); + attributeChangedCallback(ownerElement, name, oldValue, this[VALUE]); + } + } + cloneNode() { + const { ownerDocument, name, [VALUE]: value } = this; + return new Attr(ownerDocument, name, value); + } + toString() { + const { name, [VALUE]: value } = this; + return emptyAttributes.has(name) && !value ? name : `${name}="${value.replace(QUOTE, """)}"`; + } + toJSON() { + const json = []; + attrAsJSON(this, json); + return json; + } +}; + +// node_modules/linkedom/esm/shared/node.js +var isConnected = ({ ownerDocument, parentNode }) => { + while (parentNode) { + if (parentNode === ownerDocument) + return true; + parentNode = parentNode.parentNode; + } + return false; +}; +var parentElement = ({ parentNode }) => { + if (parentNode) { + switch (parentNode.nodeType) { + case DOCUMENT_NODE: + case DOCUMENT_FRAGMENT_NODE: + return null; + } + } + return parentNode; +}; +var previousSibling = ({ [PREV]: prev }) => { + switch (prev ? prev.nodeType : 0) { + case NODE_END: + return prev[START]; + case TEXT_NODE: + case COMMENT_NODE: + return prev; + } + return null; +}; +var nextSibling = (node) => { + const next = getEnd(node)[NEXT]; + return next && (next.nodeType === NODE_END ? null : next); +}; + +// node_modules/linkedom/esm/mixin/non-document-type-child-node.js +var nextElementSibling = (node) => { + let next = nextSibling(node); + while (next && next.nodeType !== ELEMENT_NODE) + next = nextSibling(next); + return next; +}; +var previousElementSibling = (node) => { + let prev = previousSibling(node); + while (prev && prev.nodeType !== ELEMENT_NODE) + prev = previousSibling(prev); + return prev; +}; + +// node_modules/linkedom/esm/mixin/child-node.js +var asFragment = (ownerDocument, nodes) => { + const fragment = ownerDocument.createDocumentFragment(); + fragment.append(...nodes); + return fragment; +}; +var before = (node, nodes) => { + const { ownerDocument, parentNode } = node; + if (parentNode) + parentNode.insertBefore(asFragment(ownerDocument, nodes), node); +}; +var after = (node, nodes) => { + const { ownerDocument, parentNode } = node; + if (parentNode) + parentNode.insertBefore(asFragment(ownerDocument, nodes), getEnd(node)[NEXT]); +}; +var replaceWith = (node, nodes) => { + const { ownerDocument, parentNode } = node; + if (parentNode) { + parentNode.insertBefore(asFragment(ownerDocument, nodes), node); + node.remove(); + } +}; +var remove = (prev, current, next) => { + const { parentNode, nodeType } = current; + if (prev || next) { + setAdjacent(prev, next); + current[PREV] = null; + getEnd(current)[NEXT] = null; + } + if (parentNode) { + current.parentNode = null; + moCallback(current, parentNode); + if (nodeType === ELEMENT_NODE) + disconnectedCallback(current); + } +}; + +// node_modules/linkedom/esm/interface/character-data.js +var CharacterData = class extends Node { + constructor(ownerDocument, localName, nodeType, data) { + super(ownerDocument, localName, nodeType); + this[VALUE] = $String(data); + } + get isConnected() { + return isConnected(this); + } + get parentElement() { + return parentElement(this); + } + get previousSibling() { + return previousSibling(this); + } + get nextSibling() { + return nextSibling(this); + } + get previousElementSibling() { + return previousElementSibling(this); + } + get nextElementSibling() { + return nextElementSibling(this); + } + before(...nodes) { + before(this, nodes); + } + after(...nodes) { + after(this, nodes); + } + replaceWith(...nodes) { + replaceWith(this, nodes); + } + remove() { + remove(this[PREV], this, this[NEXT]); + } + get data() { + return this[VALUE]; + } + set data(value) { + this[VALUE] = $String(value); + moCallback(this, this.parentNode); + } + get nodeValue() { + return this.data; + } + set nodeValue(value) { + this.data = value; + } + get textContent() { + return this.data; + } + set textContent(value) { + this.data = value; + } + get length() { + return this.data.length; + } + substringData(offset, count) { + return this.data.substr(offset, count); + } + appendData(data) { + this.data += data; + } + insertData(offset, data) { + const { data: t2 } = this; + this.data = t2.slice(0, offset) + data + t2.slice(offset); + } + deleteData(offset, count) { + const { data: t2 } = this; + this.data = t2.slice(0, offset) + t2.slice(offset + count); + } + replaceData(offset, count, data) { + const { data: t2 } = this; + this.data = t2.slice(0, offset) + data + t2.slice(offset + count); + } + toJSON() { + const json = []; + characterDataAsJSON(this, json); + return json; + } +}; + +// node_modules/linkedom/esm/interface/comment.js +var Comment = class extends CharacterData { + constructor(ownerDocument, data = "") { + super(ownerDocument, "#comment", COMMENT_NODE, data); + } + cloneNode() { + const { ownerDocument, [VALUE]: data } = this; + return new Comment(ownerDocument, data); + } + toString() { + return ``; + } +}; + +// node_modules/linkedom/esm/shared/matches.js +var CSSselect = __toESM(require_lib10(), 1); +var { isArray } = Array; +var isTag = ({ nodeType }) => nodeType === ELEMENT_NODE; +var existsOne = (test, elements) => elements.some((element) => isTag(element) && (test(element) || existsOne(test, getChildren(element)))); +var getAttributeValue = (element, name) => name === "class" ? element.classList.value : element.getAttribute(name); +var getChildren = ({ childNodes }) => childNodes; +var getName = (element) => { + const { localName } = element; + return ignoreCase(element) ? localName.toLowerCase() : localName; +}; +var getParent = ({ parentNode }) => parentNode; +var getSiblings = (element) => { + const { parentNode } = element; + return parentNode ? getChildren(parentNode) : element; +}; +var getText = (node) => { + if (isArray(node)) + return node.map(getText).join(""); + if (isTag(node)) + return getText(getChildren(node)); + if (node.nodeType === TEXT_NODE) + return node.data; + return ""; +}; +var hasAttrib = (element, name) => element.hasAttribute(name); +var removeSubsets = (nodes) => { + let { length } = nodes; + while (length--) { + const node = nodes[length]; + if (length && -1 < nodes.lastIndexOf(node, length - 1)) { + nodes.splice(length, 1); + continue; + } + for (let { parentNode } = node; parentNode; parentNode = parentNode.parentNode) { + if (nodes.includes(parentNode)) { + nodes.splice(length, 1); + break; + } + } + } + return nodes; +}; +var findAll = (test, nodes) => { + const matches2 = []; + for (const node of nodes) { + if (isTag(node)) { + if (test(node)) + matches2.push(node); + matches2.push(...findAll(test, getChildren(node))); + } + } + return matches2; +}; +var findOne = (test, nodes) => { + for (let node of nodes) + if (test(node) || (node = findOne(test, getChildren(node)))) + return node; + return null; +}; +var adapter = { + isTag, + existsOne, + getAttributeValue, + getChildren, + getName, + getParent, + getSiblings, + getText, + hasAttrib, + removeSubsets, + findAll, + findOne +}; +var prepareMatch = (element, selectors) => { + return CSSselect.compile(selectors, { + xmlMode: !ignoreCase(element), + adapter + }); +}; +var matches = (element, selectors) => { + return CSSselect.is(element, selectors, { + strict: true, + xmlMode: !ignoreCase(element), + adapter + }); +}; + +// node_modules/linkedom/esm/shared/text-escaper.js +var { replace } = ""; +var ca = /[<>&\xA0]/g; +var esca = { + "\xA0": " ", + "&": "&", + "<": "<", + ">": ">" +}; +var pe = (m2) => esca[m2]; +var escape = (es) => replace.call(es, ca, pe); + +// node_modules/linkedom/esm/interface/text.js +var Text = class extends CharacterData { + constructor(ownerDocument, data = "") { + super(ownerDocument, "#text", TEXT_NODE, data); + } + get wholeText() { + const text = []; + let { previousSibling: previousSibling2, nextSibling: nextSibling2 } = this; + while (previousSibling2) { + if (previousSibling2.nodeType === TEXT_NODE) + text.unshift(previousSibling2[VALUE]); + else + break; + previousSibling2 = previousSibling2.previousSibling; + } + text.push(this[VALUE]); + while (nextSibling2) { + if (nextSibling2.nodeType === TEXT_NODE) + text.push(nextSibling2[VALUE]); + else + break; + nextSibling2 = nextSibling2.nextSibling; + } + return text.join(""); + } + cloneNode() { + const { ownerDocument, [VALUE]: data } = this; + return new Text(ownerDocument, data); + } + toString() { + return escape(this[VALUE]); + } +}; + +// node_modules/linkedom/esm/mixin/parent-node.js +var isNode = (node) => node instanceof Node; +var insert = (parentNode, child, nodes) => { + const { ownerDocument } = parentNode; + for (const node of nodes) + parentNode.insertBefore(isNode(node) ? node : new Text(ownerDocument, node), child); +}; +var ParentNode = class extends Node { + constructor(ownerDocument, localName, nodeType) { + super(ownerDocument, localName, nodeType); + this[PRIVATE] = null; + this[NEXT] = this[END] = { + [NEXT]: null, + [PREV]: this, + [START]: this, + nodeType: NODE_END, + ownerDocument: this.ownerDocument, + parentNode: null + }; + } + get childNodes() { + const childNodes = new NodeList(); + let { firstChild } = this; + while (firstChild) { + childNodes.push(firstChild); + firstChild = nextSibling(firstChild); + } + return childNodes; + } + get children() { + const children = new NodeList(); + let { firstElementChild } = this; + while (firstElementChild) { + children.push(firstElementChild); + firstElementChild = nextElementSibling(firstElementChild); + } + return children; + } + get firstChild() { + let { [NEXT]: next, [END]: end } = this; + while (next.nodeType === ATTRIBUTE_NODE) + next = next[NEXT]; + return next === end ? null : next; + } + get firstElementChild() { + let { firstChild } = this; + while (firstChild) { + if (firstChild.nodeType === ELEMENT_NODE) + return firstChild; + firstChild = nextSibling(firstChild); + } + return null; + } + get lastChild() { + const prev = this[END][PREV]; + switch (prev.nodeType) { + case NODE_END: + return prev[START]; + case ATTRIBUTE_NODE: + return null; + } + return prev === this ? null : prev; + } + get lastElementChild() { + let { lastChild } = this; + while (lastChild) { + if (lastChild.nodeType === ELEMENT_NODE) + return lastChild; + lastChild = previousSibling(lastChild); + } + return null; + } + get childElementCount() { + return this.children.length; + } + prepend(...nodes) { + insert(this, this.firstChild, nodes); + } + append(...nodes) { + insert(this, this[END], nodes); + } + replaceChildren(...nodes) { + let { [NEXT]: next, [END]: end } = this; + while (next !== end && next.nodeType === ATTRIBUTE_NODE) + next = next[NEXT]; + while (next !== end) { + const after2 = getEnd(next)[NEXT]; + next.remove(); + next = after2; + } + if (nodes.length) + insert(this, end, nodes); + } + getElementsByClassName(className) { + const elements = new NodeList(); + let { [NEXT]: next, [END]: end } = this; + while (next !== end) { + if (next.nodeType === ELEMENT_NODE && next.hasAttribute("class") && next.classList.has(className)) + elements.push(next); + next = next[NEXT]; + } + return elements; + } + getElementsByTagName(tagName15) { + const elements = new NodeList(); + let { [NEXT]: next, [END]: end } = this; + while (next !== end) { + if (next.nodeType === ELEMENT_NODE && (next.localName === tagName15 || localCase(next) === tagName15)) + elements.push(next); + next = next[NEXT]; + } + return elements; + } + querySelector(selectors) { + const matches2 = prepareMatch(this, selectors); + let { [NEXT]: next, [END]: end } = this; + while (next !== end) { + if (next.nodeType === ELEMENT_NODE && matches2(next)) + return next; + next = next[NEXT]; + } + return null; + } + querySelectorAll(selectors) { + const matches2 = prepareMatch(this, selectors); + const elements = new NodeList(); + let { [NEXT]: next, [END]: end } = this; + while (next !== end) { + if (next.nodeType === ELEMENT_NODE && matches2(next)) + elements.push(next); + next = next[NEXT]; + } + return elements; + } + appendChild(node) { + return this.insertBefore(node, this[END]); + } + contains(node) { + let parentNode = node; + while (parentNode && parentNode !== this) + parentNode = parentNode.parentNode; + return parentNode === this; + } + insertBefore(node, before2 = null) { + if (node === before2) + return node; + if (node === this) + throw new Error("unable to append a node to itself"); + const next = before2 || this[END]; + switch (node.nodeType) { + case ELEMENT_NODE: + node.remove(); + node.parentNode = this; + knownBoundaries(next[PREV], node, next); + moCallback(node, null); + connectedCallback(node); + break; + case DOCUMENT_FRAGMENT_NODE: { + let { [PRIVATE]: parentNode, firstChild, lastChild } = node; + if (firstChild) { + knownSegment(next[PREV], firstChild, lastChild, next); + knownAdjacent(node, node[END]); + if (parentNode) + parentNode.replaceChildren(); + do { + firstChild.parentNode = this; + moCallback(firstChild, null); + if (firstChild.nodeType === ELEMENT_NODE) + connectedCallback(firstChild); + } while (firstChild !== lastChild && (firstChild = nextSibling(firstChild))); + } + break; + } + case TEXT_NODE: + case COMMENT_NODE: + node.remove(); + default: + node.parentNode = this; + knownSiblings(next[PREV], node, next); + moCallback(node, null); + break; + } + return node; + } + normalize() { + let { [NEXT]: next, [END]: end } = this; + while (next !== end) { + const { [NEXT]: $next, [PREV]: $prev, nodeType } = next; + if (nodeType === TEXT_NODE) { + if (!next[VALUE]) + next.remove(); + else if ($prev && $prev.nodeType === TEXT_NODE) { + $prev.textContent += next.textContent; + next.remove(); + } + } + next = $next; + } + } + removeChild(node) { + if (node.parentNode !== this) + throw new Error("node is not a child"); + node.remove(); + return node; + } + replaceChild(node, replaced) { + const next = getEnd(replaced)[NEXT]; + replaced.remove(); + this.insertBefore(node, next); + return replaced; + } +}; + +// node_modules/linkedom/esm/mixin/non-element-parent-node.js +var NonElementParentNode = class extends ParentNode { + getElementById(id) { + let { [NEXT]: next, [END]: end } = this; + while (next !== end) { + if (next.nodeType === ELEMENT_NODE && next.id === id) + return next; + next = next[NEXT]; + } + return null; + } + cloneNode(deep) { + const { ownerDocument, constructor } = this; + const nonEPN = new constructor(ownerDocument); + if (deep) { + const { [END]: end } = nonEPN; + for (const node of this.childNodes) + nonEPN.insertBefore(node.cloneNode(deep), end); + } + return nonEPN; + } + toString() { + const { childNodes, localName } = this; + return `<${localName}>${childNodes.join("")}`; + } + toJSON() { + const json = []; + nonElementAsJSON(this, json); + return json; + } +}; + +// node_modules/linkedom/esm/interface/document-fragment.js +var DocumentFragment = class extends NonElementParentNode { + constructor(ownerDocument) { + super(ownerDocument, "#document-fragment", DOCUMENT_FRAGMENT_NODE); + } +}; + +// node_modules/linkedom/esm/interface/document-type.js +var DocumentType = class extends Node { + constructor(ownerDocument, name, publicId = "", systemId = "") { + super(ownerDocument, "#document-type", DOCUMENT_TYPE_NODE); + this.name = name; + this.publicId = publicId; + this.systemId = systemId; + } + cloneNode() { + const { ownerDocument, name, publicId, systemId } = this; + return new DocumentType(ownerDocument, name, publicId, systemId); + } + toString() { + const { name, publicId, systemId } = this; + const hasPublic = 0 < publicId.length; + const str = [name]; + if (hasPublic) + str.push("PUBLIC", `"${publicId}"`); + if (systemId.length) { + if (!hasPublic) + str.push("SYSTEM"); + str.push(`"${systemId}"`); + } + return ``; + } + toJSON() { + const json = []; + documentTypeAsJSON(this, json); + return json; + } +}; + +// node_modules/linkedom/esm/mixin/inner-html.js +var getInnerHtml = (node) => node.childNodes.join(""); +var setInnerHtml = (node, html) => { + const { ownerDocument } = node; + const { constructor } = ownerDocument; + const document2 = new constructor(); + document2[CUSTOM_ELEMENTS] = ownerDocument[CUSTOM_ELEMENTS]; + const { childNodes } = parseFromString(document2, ignoreCase(node), html); + node.replaceChildren(...childNodes); +}; + +// node_modules/uhyphen/esm/index.js +var esm_default = (camel) => camel.replace(/(([A-Z0-9])([A-Z0-9][a-z]))|(([a-z])([A-Z]))/g, "$2$5-$3$6").toLowerCase(); + +// node_modules/linkedom/esm/dom/string-map.js +var refs = /* @__PURE__ */ new WeakMap(); +var key = (name) => `data-${esm_default(name)}`; +var prop = (name) => name.slice(5).replace(/-([a-z])/g, (_, $1) => $1.toUpperCase()); +var handler = { + get(dataset, name) { + if (name in dataset) + return refs.get(dataset).getAttribute(key(name)); + }, + set(dataset, name, value) { + dataset[name] = value; + refs.get(dataset).setAttribute(key(name), value); + return true; + }, + deleteProperty(dataset, name) { + if (name in dataset) + refs.get(dataset).removeAttribute(key(name)); + return delete dataset[name]; + } +}; +var DOMStringMap = class { + constructor(ref) { + for (const { name, value } of ref.attributes) { + if (/^data-/.test(name)) + this[prop(name)] = value; + } + refs.set(this, ref); + return new Proxy(this, handler); + } +}; +setPrototypeOf(DOMStringMap.prototype, null); + +// node_modules/linkedom/esm/dom/token-list.js +var { add } = Set.prototype; +var addTokens = (self2, tokens) => { + for (const token of tokens) { + if (token) + add.call(self2, token); + } +}; +var update = ({ [OWNER_ELEMENT]: ownerElement, value }) => { + const attribute2 = ownerElement.getAttributeNode("class"); + if (attribute2) + attribute2.value = value; + else + setAttribute(ownerElement, new Attr(ownerElement.ownerDocument, "class", value)); +}; +var DOMTokenList = class extends Set { + constructor(ownerElement) { + super(); + this[OWNER_ELEMENT] = ownerElement; + const attribute2 = ownerElement.getAttributeNode("class"); + if (attribute2) + addTokens(this, attribute2.value.split(/\s+/)); + } + get length() { + return this.size; + } + get value() { + return [...this].join(" "); + } + add(...tokens) { + addTokens(this, tokens); + update(this); + } + contains(token) { + return this.has(token); + } + remove(...tokens) { + for (const token of tokens) + this.delete(token); + update(this); + } + toggle(token, force) { + if (this.has(token)) { + if (force) + return true; + this.delete(token); + update(this); + } else if (force || arguments.length === 1) { + super.add(token); + update(this); + return true; + } + return false; + } + replace(token, newToken) { + if (this.has(token)) { + this.delete(token); + super.add(newToken); + update(this); + return true; + } + return false; + } + supports() { + return true; + } +}; + +// node_modules/linkedom/esm/interface/css-style-declaration.js +var refs2 = /* @__PURE__ */ new WeakMap(); +var getKeys = (style) => [...style.keys()].filter((key2) => key2 !== PRIVATE); +var updateKeys = (style) => { + const attr = refs2.get(style).getAttributeNode("style"); + if (!attr || attr[CHANGED] || style.get(PRIVATE) !== attr) { + style.clear(); + if (attr) { + style.set(PRIVATE, attr); + for (const rule of attr[VALUE].split(/\s*;\s*/)) { + const pair = rule.split(/\s*:\s*/); + if (1 < pair.length) { + let [key2, value] = pair; + key2 = key2.trim(); + value = value.trim(); + if (key2 && value) + style.set(key2, value); + } + } + } + } + return attr; +}; +var handler2 = { + get(style, name) { + if (name in prototype) + return style[name]; + updateKeys(style); + if (name === "length") + return getKeys(style).length; + if (/^\d+$/.test(name)) + return getKeys(style)[name]; + return style.get(esm_default(name)); + }, + set(style, name, value) { + if (name === "cssText") + style[name] = value; + else { + let attr = updateKeys(style); + if (value == null) + style.delete(esm_default(name)); + else + style.set(esm_default(name), value); + if (!attr) { + const element = refs2.get(style); + attr = element.ownerDocument.createAttribute("style"); + element.setAttributeNode(attr); + style.set(PRIVATE, attr); + } + attr[CHANGED] = false; + attr[VALUE] = style.toString(); + } + return true; + } +}; +var CSSStyleDeclaration = class extends Map { + constructor(element) { + super(); + refs2.set(this, element); + return new Proxy(this, handler2); + } + get cssText() { + return this.toString(); + } + set cssText(value) { + refs2.get(this).setAttribute("style", value); + } + getPropertyValue(name) { + const self2 = this[PRIVATE]; + return handler2.get(self2, name); + } + setProperty(name, value) { + const self2 = this[PRIVATE]; + handler2.set(self2, name, value); + } + removeProperty(name) { + const self2 = this[PRIVATE]; + handler2.set(self2, name, null); + } + [Symbol.iterator]() { + const keys2 = getKeys(this[PRIVATE]); + const { length } = keys2; + let i2 = 0; + return { + next() { + const done = i2 === length; + return { done, value: done ? null : keys2[i2++] }; + } + }; + } + get [PRIVATE]() { + return this; + } + toString() { + const self2 = this[PRIVATE]; + updateKeys(self2); + const cssText = []; + self2.forEach(push, cssText); + return cssText.join(";"); + } +}; +var { prototype } = CSSStyleDeclaration; +function push(value, key2) { + if (key2 !== PRIVATE) + this.push(`${key2}:${value}`); +} + +// node_modules/linkedom/esm/interface/event.js +var BUBBLING_PHASE = 3; +var AT_TARGET = 2; +var CAPTURING_PHASE = 1; +var NONE = 0; +var GlobalEvent = class { + static get BUBBLING_PHASE() { + return BUBBLING_PHASE; + } + static get AT_TARGET() { + return AT_TARGET; + } + static get CAPTURING_PHASE() { + return CAPTURING_PHASE; + } + static get NONE() { + return NONE; + } + constructor(type, eventInitDict = {}) { + this.type = type; + this.bubbles = !!eventInitDict.bubbles; + this.cancelBubble = false; + this._stopImmediatePropagationFlag = false; + this.cancelable = !!eventInitDict.cancelable; + this.eventPhase = this.NONE; + this.timeStamp = Date.now(); + this.defaultPrevented = false; + this.originalTarget = null; + this.returnValue = null; + this.srcElement = null; + this.target = null; + this._path = []; + } + get BUBBLING_PHASE() { + return BUBBLING_PHASE; + } + get AT_TARGET() { + return AT_TARGET; + } + get CAPTURING_PHASE() { + return CAPTURING_PHASE; + } + get NONE() { + return NONE; + } + preventDefault() { + this.defaultPrevented = true; + } + composedPath() { + return this._path; + } + stopPropagation() { + this.cancelBubble = true; + } + stopImmediatePropagation() { + this.stopPropagation(); + this._stopImmediatePropagationFlag = true; + } +}; + +// node_modules/linkedom/esm/interface/named-node-map.js +var NamedNodeMap = class extends Array { + constructor(ownerElement) { + super(); + this.ownerElement = ownerElement; + } + getNamedItem(name) { + return this.ownerElement.getAttributeNode(name); + } + setNamedItem(attr) { + this.ownerElement.setAttributeNode(attr); + this.unshift(attr); + } + removeNamedItem(name) { + const item = this.getNamedItem(name); + this.ownerElement.removeAttribute(name); + this.splice(this.indexOf(item), 1); + } + item(index) { + return index < this.length ? this[index] : null; + } + getNamedItemNS(_, name) { + return this.getNamedItem(name); + } + setNamedItemNS(_, attr) { + return this.setNamedItem(attr); + } + removeNamedItemNS(_, name) { + return this.removeNamedItem(name); + } +}; + +// node_modules/linkedom/esm/interface/shadow-root.js +var ShadowRoot = class extends NonElementParentNode { + constructor(ownerDocument) { + super(ownerDocument, "#shadow-root", DOCUMENT_FRAGMENT_NODE); + } + get innerHTML() { + return getInnerHtml(this); + } + set innerHTML(html) { + setInnerHtml(this, html); + } +}; + +// node_modules/linkedom/esm/interface/element.js +var attributesHandler = { + get(target, key2) { + return key2 in target ? target[key2] : target.find(({ name }) => name === key2); + } +}; +var create2 = (ownerDocument, element, localName) => { + if ("ownerSVGElement" in element) { + const svg = ownerDocument.createElementNS(SVG_NAMESPACE, localName); + svg.ownerSVGElement = element.ownerSVGElement; + return svg; + } + return ownerDocument.createElement(localName); +}; +var isVoid = ({ localName, ownerDocument }) => { + return ownerDocument[MIME].voidElements.test(localName); +}; +var shadowRoots = /* @__PURE__ */ new WeakMap(); +var Element = class extends ParentNode { + constructor(ownerDocument, localName) { + super(ownerDocument, localName, ELEMENT_NODE); + this[CLASS_LIST] = null; + this[DATASET] = null; + this[STYLE] = null; + } + get isConnected() { + return isConnected(this); + } + get parentElement() { + return parentElement(this); + } + get previousSibling() { + return previousSibling(this); + } + get nextSibling() { + return nextSibling(this); + } + get previousElementSibling() { + return previousElementSibling(this); + } + get nextElementSibling() { + return nextElementSibling(this); + } + before(...nodes) { + before(this, nodes); + } + after(...nodes) { + after(this, nodes); + } + replaceWith(...nodes) { + replaceWith(this, nodes); + } + remove() { + remove(this[PREV], this, this[END][NEXT]); + } + get id() { + return stringAttribute.get(this, "id"); + } + set id(value) { + stringAttribute.set(this, "id", value); + } + get className() { + return this.classList.value; + } + set className(value) { + const { classList } = this; + classList.clear(); + classList.add(...value.split(/\s+/)); + } + get nodeName() { + return localCase(this); + } + get tagName() { + return localCase(this); + } + get classList() { + return this[CLASS_LIST] || (this[CLASS_LIST] = new DOMTokenList(this)); + } + get dataset() { + return this[DATASET] || (this[DATASET] = new DOMStringMap(this)); + } + get nonce() { + return stringAttribute.get(this, "nonce"); + } + set nonce(value) { + stringAttribute.set(this, "nonce", value); + } + get style() { + return this[STYLE] || (this[STYLE] = new CSSStyleDeclaration(this)); + } + get tabIndex() { + return numericAttribute.get(this, "tabindex") || -1; + } + set tabIndex(value) { + numericAttribute.set(this, "tabindex", value); + } + get innerText() { + return this.textContent; + } + get textContent() { + const text = []; + let { [NEXT]: next, [END]: end } = this; + while (next !== end) { + if (next.nodeType === TEXT_NODE) + text.push(next.textContent); + next = next[NEXT]; + } + return text.join(""); + } + set textContent(text) { + this.replaceChildren(); + if (text) + this.appendChild(new Text(this.ownerDocument, text)); + } + get innerHTML() { + return getInnerHtml(this); + } + set innerHTML(html) { + setInnerHtml(this, html); + } + get outerHTML() { + return this.toString(); + } + set outerHTML(html) { + const template = this.ownerDocument.createElement(""); + template.innerHTML = html; + this.replaceWith(...template.childNodes); + } + get attributes() { + const attributes = new NamedNodeMap(this); + let next = this[NEXT]; + while (next.nodeType === ATTRIBUTE_NODE) { + attributes.push(next); + next = next[NEXT]; + } + return new Proxy(attributes, attributesHandler); + } + focus() { + this.dispatchEvent(new GlobalEvent("focus")); + } + getAttribute(name) { + if (name === "class") + return this.className; + const attribute2 = this.getAttributeNode(name); + return attribute2 && attribute2.value; + } + getAttributeNode(name) { + let next = this[NEXT]; + while (next.nodeType === ATTRIBUTE_NODE) { + if (next.name === name) + return next; + next = next[NEXT]; + } + return null; + } + getAttributeNames() { + const attributes = new NodeList(); + let next = this[NEXT]; + while (next.nodeType === ATTRIBUTE_NODE) { + attributes.push(next.name); + next = next[NEXT]; + } + return attributes; + } + hasAttribute(name) { + return !!this.getAttributeNode(name); + } + hasAttributes() { + return this[NEXT].nodeType === ATTRIBUTE_NODE; + } + removeAttribute(name) { + if (name === "class" && this[CLASS_LIST]) + this[CLASS_LIST].clear(); + let next = this[NEXT]; + while (next.nodeType === ATTRIBUTE_NODE) { + if (next.name === name) { + removeAttribute(this, next); + return; + } + next = next[NEXT]; + } + } + removeAttributeNode(attribute2) { + let next = this[NEXT]; + while (next.nodeType === ATTRIBUTE_NODE) { + if (next === attribute2) { + removeAttribute(this, next); + return; + } + next = next[NEXT]; + } + } + setAttribute(name, value) { + if (name === "class") + this.className = value; + else { + const attribute2 = this.getAttributeNode(name); + if (attribute2) + attribute2.value = value; + else + setAttribute(this, new Attr(this.ownerDocument, name, value)); + } + } + setAttributeNode(attribute2) { + const { name } = attribute2; + const previously = this.getAttributeNode(name); + if (previously !== attribute2) { + if (previously) + this.removeAttributeNode(previously); + const { ownerElement } = attribute2; + if (ownerElement) + ownerElement.removeAttributeNode(attribute2); + setAttribute(this, attribute2); + } + return previously; + } + toggleAttribute(name, force) { + if (this.hasAttribute(name)) { + if (!force) { + this.removeAttribute(name); + return false; + } + return true; + } else if (force || arguments.length === 1) { + this.setAttribute(name, ""); + return true; + } + return false; + } + get shadowRoot() { + if (shadowRoots.has(this)) { + const { mode, shadowRoot } = shadowRoots.get(this); + if (mode === "open") + return shadowRoot; + } + return null; + } + attachShadow(init) { + if (shadowRoots.has(this)) + throw new Error("operation not supported"); + const shadowRoot = new ShadowRoot(this.ownerDocument); + shadowRoot.append(...this.childNodes); + shadowRoots.set(this, { + mode: init.mode, + shadowRoot + }); + return shadowRoot; + } + matches(selectors) { + return matches(this, selectors); + } + closest(selectors) { + let parentElement2 = this; + const matches2 = prepareMatch(parentElement2, selectors); + while (parentElement2 && !matches2(parentElement2)) + parentElement2 = parentElement2.parentElement; + return parentElement2; + } + insertAdjacentElement(position, element) { + const { parentElement: parentElement2 } = this; + switch (position) { + case "beforebegin": + if (parentElement2) { + parentElement2.insertBefore(element, this); + break; + } + return null; + case "afterbegin": + this.insertBefore(element, this.firstChild); + break; + case "beforeend": + this.insertBefore(element, null); + break; + case "afterend": + if (parentElement2) { + parentElement2.insertBefore(element, this.nextSibling); + break; + } + return null; + } + return element; + } + insertAdjacentHTML(position, html) { + const template = this.ownerDocument.createElement("template"); + template.innerHTML = html; + this.insertAdjacentElement(position, template.content); + } + insertAdjacentText(position, text) { + const node = this.ownerDocument.createTextNode(text); + this.insertAdjacentElement(position, node); + } + cloneNode(deep = false) { + const { ownerDocument, localName } = this; + const addNext = (next2) => { + next2.parentNode = parentNode; + knownAdjacent($next, next2); + $next = next2; + }; + const clone2 = create2(ownerDocument, this, localName); + let parentNode = clone2, $next = clone2; + let { [NEXT]: next, [END]: prev } = this; + while (next !== prev && (deep || next.nodeType === ATTRIBUTE_NODE)) { + switch (next.nodeType) { + case NODE_END: + knownAdjacent($next, parentNode[END]); + $next = parentNode[END]; + parentNode = parentNode.parentNode; + break; + case ELEMENT_NODE: { + const node = create2(ownerDocument, next, next.localName); + addNext(node); + parentNode = node; + break; + } + case ATTRIBUTE_NODE: + case TEXT_NODE: + case COMMENT_NODE: + addNext(next.cloneNode(deep)); + break; + } + next = next[NEXT]; + } + knownAdjacent($next, clone2[END]); + return clone2; + } + toString() { + const out = []; + const { [END]: end } = this; + let next = { [NEXT]: this }; + let isOpened = false; + do { + next = next[NEXT]; + switch (next.nodeType) { + case ATTRIBUTE_NODE: { + const attr = " " + next; + switch (attr) { + case " id": + case " class": + case " style": + break; + default: + out.push(attr); + } + break; + } + case NODE_END: { + const start = next[START]; + if (isOpened) { + if ("ownerSVGElement" in start) + out.push(" />"); + else if (isVoid(start)) + out.push(ignoreCase(start) ? ">" : " />"); + else + out.push(`>`); + isOpened = false; + } else + out.push(``); + break; + } + case ELEMENT_NODE: + if (isOpened) + out.push(">"); + if (next.toString !== this.toString) { + out.push(next.toString()); + next = next[END]; + isOpened = false; + } else { + out.push(`<${next.localName}`); + isOpened = true; + } + break; + case TEXT_NODE: + case COMMENT_NODE: + out.push((isOpened ? ">" : "") + next); + isOpened = false; + break; + } + } while (next !== end); + return out.join(""); + } + toJSON() { + const json = []; + elementAsJSON(this, json); + return json; + } + getAttributeNS(_, name) { + return this.getAttribute(name); + } + getElementsByTagNameNS(_, name) { + return this.getElementsByTagName(name); + } + hasAttributeNS(_, name) { + return this.hasAttribute(name); + } + removeAttributeNS(_, name) { + this.removeAttribute(name); + } + setAttributeNS(_, name, value) { + this.setAttribute(name, value); + } + setAttributeNodeNS(attr) { + return this.setAttributeNode(attr); + } +}; + +// node_modules/linkedom/esm/svg/element.js +var classNames = /* @__PURE__ */ new WeakMap(); +var handler3 = { + get(target, name) { + return target[name]; + }, + set(target, name, value) { + target[name] = value; + return true; + } +}; +var SVGElement = class extends Element { + constructor(ownerDocument, localName, ownerSVGElement = null) { + super(ownerDocument, localName); + this.ownerSVGElement = ownerSVGElement; + } + get className() { + if (!classNames.has(this)) + classNames.set(this, new Proxy({ baseVal: "", animVal: "" }, handler3)); + return classNames.get(this); + } + set className(value) { + const { classList } = this; + classList.clear(); + classList.add(...value.split(/\s+/)); + } + setAttribute(name, value) { + if (name === "style") { + const { className } = this; + className.baseVal = className.animVal = value; + } + super.setAttribute(name, value); + } +}; + +// node_modules/linkedom/esm/shared/facades.js +var illegalConstructor = () => { + throw new TypeError("Illegal constructor"); +}; +function Attr2() { + illegalConstructor(); +} +setPrototypeOf(Attr2, Attr); +Attr2.prototype = Attr.prototype; +function CharacterData2() { + illegalConstructor(); +} +setPrototypeOf(CharacterData2, CharacterData); +CharacterData2.prototype = CharacterData.prototype; +function Comment2() { + illegalConstructor(); +} +setPrototypeOf(Comment2, Comment); +Comment2.prototype = Comment.prototype; +function DocumentFragment2() { + illegalConstructor(); +} +setPrototypeOf(DocumentFragment2, DocumentFragment); +DocumentFragment2.prototype = DocumentFragment.prototype; +function DocumentType2() { + illegalConstructor(); +} +setPrototypeOf(DocumentType2, DocumentType); +DocumentType2.prototype = DocumentType.prototype; +function Element2() { + illegalConstructor(); +} +setPrototypeOf(Element2, Element); +Element2.prototype = Element.prototype; +function Node2() { + illegalConstructor(); +} +setPrototypeOf(Node2, Node); +Node2.prototype = Node.prototype; +function ShadowRoot2() { + illegalConstructor(); +} +setPrototypeOf(ShadowRoot2, ShadowRoot); +ShadowRoot2.prototype = ShadowRoot.prototype; +function Text2() { + illegalConstructor(); +} +setPrototypeOf(Text2, Text); +Text2.prototype = Text.prototype; +function SVGElement2() { + illegalConstructor(); +} +setPrototypeOf(SVGElement2, SVGElement); +SVGElement2.prototype = SVGElement.prototype; +var Facades = { + Attr: Attr2, + CharacterData: CharacterData2, + Comment: Comment2, + DocumentFragment: DocumentFragment2, + DocumentType: DocumentType2, + Element: Element2, + Node: Node2, + ShadowRoot: ShadowRoot2, + Text: Text2, + SVGElement: SVGElement2 +}; + +// node_modules/linkedom/esm/html/element.js +var Level0 = /* @__PURE__ */ new WeakMap(); +var level0 = { + get(element, name) { + return Level0.has(element) && Level0.get(element)[name] || null; + }, + set(element, name, value) { + if (!Level0.has(element)) + Level0.set(element, {}); + const handlers = Level0.get(element); + const type = name.slice(2); + if (handlers[name]) + element.removeEventListener(type, handlers[name], false); + if (handlers[name] = value) + element.addEventListener(type, value, false); + } +}; +var HTMLElement = class extends Element { + static get observedAttributes() { + return []; + } + constructor(ownerDocument = null, localName = "") { + super(ownerDocument, localName); + const ownerLess = !ownerDocument; + let options; + if (ownerLess) { + const { constructor: Class } = this; + if (!Classes.has(Class)) + throw new Error("unable to initialize this Custom Element"); + ({ ownerDocument, localName, options } = Classes.get(Class)); + } + if (ownerDocument[UPGRADE]) { + const { element, values } = ownerDocument[UPGRADE]; + ownerDocument[UPGRADE] = null; + for (const [key2, value] of values) + element[key2] = value; + return element; + } + if (ownerLess) { + this.ownerDocument = this[END].ownerDocument = ownerDocument; + this.localName = localName; + customElements.set(this, { connected: false }); + if (options.is) + this.setAttribute("is", options.is); + } + } + blur() { + this.dispatchEvent(new GlobalEvent("blur")); + } + click() { + this.dispatchEvent(new GlobalEvent("click")); + } + get accessKeyLabel() { + const { accessKey } = this; + return accessKey && `Alt+Shift+${accessKey}`; + } + get isContentEditable() { + return this.hasAttribute("contenteditable"); + } + get contentEditable() { + return booleanAttribute.get(this, "contenteditable"); + } + set contentEditable(value) { + booleanAttribute.set(this, "contenteditable", value); + } + get draggable() { + return booleanAttribute.get(this, "draggable"); + } + set draggable(value) { + booleanAttribute.set(this, "draggable", value); + } + get hidden() { + return booleanAttribute.get(this, "hidden"); + } + set hidden(value) { + booleanAttribute.set(this, "hidden", value); + } + get spellcheck() { + return booleanAttribute.get(this, "spellcheck"); + } + set spellcheck(value) { + booleanAttribute.set(this, "spellcheck", value); + } + get accessKey() { + return stringAttribute.get(this, "accesskey"); + } + set accessKey(value) { + stringAttribute.set(this, "accesskey", value); + } + get dir() { + return stringAttribute.get(this, "dir"); + } + set dir(value) { + stringAttribute.set(this, "dir", value); + } + get lang() { + return stringAttribute.get(this, "lang"); + } + set lang(value) { + stringAttribute.set(this, "lang", value); + } + get title() { + return stringAttribute.get(this, "title"); + } + set title(value) { + stringAttribute.set(this, "title", value); + } + get onabort() { + return level0.get(this, "onabort"); + } + set onabort(value) { + level0.set(this, "onabort", value); + } + get onblur() { + return level0.get(this, "onblur"); + } + set onblur(value) { + level0.set(this, "onblur", value); + } + get oncancel() { + return level0.get(this, "oncancel"); + } + set oncancel(value) { + level0.set(this, "oncancel", value); + } + get oncanplay() { + return level0.get(this, "oncanplay"); + } + set oncanplay(value) { + level0.set(this, "oncanplay", value); + } + get oncanplaythrough() { + return level0.get(this, "oncanplaythrough"); + } + set oncanplaythrough(value) { + level0.set(this, "oncanplaythrough", value); + } + get onchange() { + return level0.get(this, "onchange"); + } + set onchange(value) { + level0.set(this, "onchange", value); + } + get onclick() { + return level0.get(this, "onclick"); + } + set onclick(value) { + level0.set(this, "onclick", value); + } + get onclose() { + return level0.get(this, "onclose"); + } + set onclose(value) { + level0.set(this, "onclose", value); + } + get oncontextmenu() { + return level0.get(this, "oncontextmenu"); + } + set oncontextmenu(value) { + level0.set(this, "oncontextmenu", value); + } + get oncuechange() { + return level0.get(this, "oncuechange"); + } + set oncuechange(value) { + level0.set(this, "oncuechange", value); + } + get ondblclick() { + return level0.get(this, "ondblclick"); + } + set ondblclick(value) { + level0.set(this, "ondblclick", value); + } + get ondrag() { + return level0.get(this, "ondrag"); + } + set ondrag(value) { + level0.set(this, "ondrag", value); + } + get ondragend() { + return level0.get(this, "ondragend"); + } + set ondragend(value) { + level0.set(this, "ondragend", value); + } + get ondragenter() { + return level0.get(this, "ondragenter"); + } + set ondragenter(value) { + level0.set(this, "ondragenter", value); + } + get ondragleave() { + return level0.get(this, "ondragleave"); + } + set ondragleave(value) { + level0.set(this, "ondragleave", value); + } + get ondragover() { + return level0.get(this, "ondragover"); + } + set ondragover(value) { + level0.set(this, "ondragover", value); + } + get ondragstart() { + return level0.get(this, "ondragstart"); + } + set ondragstart(value) { + level0.set(this, "ondragstart", value); + } + get ondrop() { + return level0.get(this, "ondrop"); + } + set ondrop(value) { + level0.set(this, "ondrop", value); + } + get ondurationchange() { + return level0.get(this, "ondurationchange"); + } + set ondurationchange(value) { + level0.set(this, "ondurationchange", value); + } + get onemptied() { + return level0.get(this, "onemptied"); + } + set onemptied(value) { + level0.set(this, "onemptied", value); + } + get onended() { + return level0.get(this, "onended"); + } + set onended(value) { + level0.set(this, "onended", value); + } + get onerror() { + return level0.get(this, "onerror"); + } + set onerror(value) { + level0.set(this, "onerror", value); + } + get onfocus() { + return level0.get(this, "onfocus"); + } + set onfocus(value) { + level0.set(this, "onfocus", value); + } + get oninput() { + return level0.get(this, "oninput"); + } + set oninput(value) { + level0.set(this, "oninput", value); + } + get oninvalid() { + return level0.get(this, "oninvalid"); + } + set oninvalid(value) { + level0.set(this, "oninvalid", value); + } + get onkeydown() { + return level0.get(this, "onkeydown"); + } + set onkeydown(value) { + level0.set(this, "onkeydown", value); + } + get onkeypress() { + return level0.get(this, "onkeypress"); + } + set onkeypress(value) { + level0.set(this, "onkeypress", value); + } + get onkeyup() { + return level0.get(this, "onkeyup"); + } + set onkeyup(value) { + level0.set(this, "onkeyup", value); + } + get onload() { + return level0.get(this, "onload"); + } + set onload(value) { + level0.set(this, "onload", value); + } + get onloadeddata() { + return level0.get(this, "onloadeddata"); + } + set onloadeddata(value) { + level0.set(this, "onloadeddata", value); + } + get onloadedmetadata() { + return level0.get(this, "onloadedmetadata"); + } + set onloadedmetadata(value) { + level0.set(this, "onloadedmetadata", value); + } + get onloadstart() { + return level0.get(this, "onloadstart"); + } + set onloadstart(value) { + level0.set(this, "onloadstart", value); + } + get onmousedown() { + return level0.get(this, "onmousedown"); + } + set onmousedown(value) { + level0.set(this, "onmousedown", value); + } + get onmouseenter() { + return level0.get(this, "onmouseenter"); + } + set onmouseenter(value) { + level0.set(this, "onmouseenter", value); + } + get onmouseleave() { + return level0.get(this, "onmouseleave"); + } + set onmouseleave(value) { + level0.set(this, "onmouseleave", value); + } + get onmousemove() { + return level0.get(this, "onmousemove"); + } + set onmousemove(value) { + level0.set(this, "onmousemove", value); + } + get onmouseout() { + return level0.get(this, "onmouseout"); + } + set onmouseout(value) { + level0.set(this, "onmouseout", value); + } + get onmouseover() { + return level0.get(this, "onmouseover"); + } + set onmouseover(value) { + level0.set(this, "onmouseover", value); + } + get onmouseup() { + return level0.get(this, "onmouseup"); + } + set onmouseup(value) { + level0.set(this, "onmouseup", value); + } + get onmousewheel() { + return level0.get(this, "onmousewheel"); + } + set onmousewheel(value) { + level0.set(this, "onmousewheel", value); + } + get onpause() { + return level0.get(this, "onpause"); + } + set onpause(value) { + level0.set(this, "onpause", value); + } + get onplay() { + return level0.get(this, "onplay"); + } + set onplay(value) { + level0.set(this, "onplay", value); + } + get onplaying() { + return level0.get(this, "onplaying"); + } + set onplaying(value) { + level0.set(this, "onplaying", value); + } + get onprogress() { + return level0.get(this, "onprogress"); + } + set onprogress(value) { + level0.set(this, "onprogress", value); + } + get onratechange() { + return level0.get(this, "onratechange"); + } + set onratechange(value) { + level0.set(this, "onratechange", value); + } + get onreset() { + return level0.get(this, "onreset"); + } + set onreset(value) { + level0.set(this, "onreset", value); + } + get onresize() { + return level0.get(this, "onresize"); + } + set onresize(value) { + level0.set(this, "onresize", value); + } + get onscroll() { + return level0.get(this, "onscroll"); + } + set onscroll(value) { + level0.set(this, "onscroll", value); + } + get onseeked() { + return level0.get(this, "onseeked"); + } + set onseeked(value) { + level0.set(this, "onseeked", value); + } + get onseeking() { + return level0.get(this, "onseeking"); + } + set onseeking(value) { + level0.set(this, "onseeking", value); + } + get onselect() { + return level0.get(this, "onselect"); + } + set onselect(value) { + level0.set(this, "onselect", value); + } + get onshow() { + return level0.get(this, "onshow"); + } + set onshow(value) { + level0.set(this, "onshow", value); + } + get onstalled() { + return level0.get(this, "onstalled"); + } + set onstalled(value) { + level0.set(this, "onstalled", value); + } + get onsubmit() { + return level0.get(this, "onsubmit"); + } + set onsubmit(value) { + level0.set(this, "onsubmit", value); + } + get onsuspend() { + return level0.get(this, "onsuspend"); + } + set onsuspend(value) { + level0.set(this, "onsuspend", value); + } + get ontimeupdate() { + return level0.get(this, "ontimeupdate"); + } + set ontimeupdate(value) { + level0.set(this, "ontimeupdate", value); + } + get ontoggle() { + return level0.get(this, "ontoggle"); + } + set ontoggle(value) { + level0.set(this, "ontoggle", value); + } + get onvolumechange() { + return level0.get(this, "onvolumechange"); + } + set onvolumechange(value) { + level0.set(this, "onvolumechange", value); + } + get onwaiting() { + return level0.get(this, "onwaiting"); + } + set onwaiting(value) { + level0.set(this, "onwaiting", value); + } + get onauxclick() { + return level0.get(this, "onauxclick"); + } + set onauxclick(value) { + level0.set(this, "onauxclick", value); + } + get ongotpointercapture() { + return level0.get(this, "ongotpointercapture"); + } + set ongotpointercapture(value) { + level0.set(this, "ongotpointercapture", value); + } + get onlostpointercapture() { + return level0.get(this, "onlostpointercapture"); + } + set onlostpointercapture(value) { + level0.set(this, "onlostpointercapture", value); + } + get onpointercancel() { + return level0.get(this, "onpointercancel"); + } + set onpointercancel(value) { + level0.set(this, "onpointercancel", value); + } + get onpointerdown() { + return level0.get(this, "onpointerdown"); + } + set onpointerdown(value) { + level0.set(this, "onpointerdown", value); + } + get onpointerenter() { + return level0.get(this, "onpointerenter"); + } + set onpointerenter(value) { + level0.set(this, "onpointerenter", value); + } + get onpointerleave() { + return level0.get(this, "onpointerleave"); + } + set onpointerleave(value) { + level0.set(this, "onpointerleave", value); + } + get onpointermove() { + return level0.get(this, "onpointermove"); + } + set onpointermove(value) { + level0.set(this, "onpointermove", value); + } + get onpointerout() { + return level0.get(this, "onpointerout"); + } + set onpointerout(value) { + level0.set(this, "onpointerout", value); + } + get onpointerover() { + return level0.get(this, "onpointerover"); + } + set onpointerover(value) { + level0.set(this, "onpointerover", value); + } + get onpointerup() { + return level0.get(this, "onpointerup"); + } + set onpointerup(value) { + level0.set(this, "onpointerup", value); + } +}; + +// node_modules/linkedom/esm/html/template-element.js +var tagName = "template"; +var HTMLTemplateElement = class extends HTMLElement { + constructor(ownerDocument) { + super(ownerDocument, tagName); + const content = this.ownerDocument.createDocumentFragment(); + (this[CONTENT] = content)[PRIVATE] = this; + } + get content() { + if (this.hasChildNodes() && !this[CONTENT].hasChildNodes()) { + for (const node of this.childNodes) + this[CONTENT].appendChild(node.cloneNode(true)); + } + return this[CONTENT]; + } +}; +registerHTMLClass(tagName, HTMLTemplateElement); + +// node_modules/linkedom/esm/html/html-element.js +var HTMLHtmlElement = class extends HTMLElement { + constructor(ownerDocument, localName = "html") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/text-element.js +var { toString } = HTMLElement.prototype; +var TextElement = class extends HTMLElement { + get innerHTML() { + return this.textContent; + } + set innerHTML(html) { + this.textContent = html; + } + toString() { + const outerHTML = toString.call(this.cloneNode()); + return outerHTML.replace(/>${this.textContent}<`); + } +}; + +// node_modules/linkedom/esm/html/script-element.js +var tagName2 = "script"; +var HTMLScriptElement = class extends TextElement { + constructor(ownerDocument, localName = tagName2) { + super(ownerDocument, localName); + } +}; +registerHTMLClass(tagName2, HTMLScriptElement); + +// node_modules/linkedom/esm/html/frame-element.js +var HTMLFrameElement = class extends HTMLElement { + constructor(ownerDocument, localName = "frame") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/i-frame-element.js +var HTMLIFrameElement = class extends HTMLElement { + constructor(ownerDocument, localName = "iframe") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/object-element.js +var HTMLObjectElement = class extends HTMLElement { + constructor(ownerDocument, localName = "object") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/head-element.js +var HTMLHeadElement = class extends HTMLElement { + constructor(ownerDocument, localName = "head") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/body-element.js +var HTMLBodyElement = class extends HTMLElement { + constructor(ownerDocument, localName = "body") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/style-element.js +var import_cssom = __toESM(require_lib11(), 1); +var tagName3 = "style"; +var HTMLStyleElement = class extends TextElement { + constructor(ownerDocument, localName = tagName3) { + super(ownerDocument, localName); + this[SHEET] = null; + } + get sheet() { + const sheet = this[SHEET]; + if (sheet !== null) { + return sheet; + } + return this[SHEET] = (0, import_cssom.parse)(this.textContent); + } + get innerHTML() { + return super.innerHTML || ""; + } + set innerHTML(value) { + super.textContent = value; + this[SHEET] = null; + } + get innerText() { + return super.innerText || ""; + } + set innerText(value) { + super.textContent = value; + this[SHEET] = null; + } + get textContent() { + return super.textContent || ""; + } + set textContent(value) { + super.textContent = value; + this[SHEET] = null; + } +}; +registerHTMLClass(tagName3, HTMLStyleElement); + +// node_modules/linkedom/esm/html/time-element.js +var HTMLTimeElement = class extends HTMLElement { + constructor(ownerDocument, localName = "time") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/field-set-element.js +var HTMLFieldSetElement = class extends HTMLElement { + constructor(ownerDocument, localName = "fieldset") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/embed-element.js +var HTMLEmbedElement = class extends HTMLElement { + constructor(ownerDocument, localName = "embed") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/hr-element.js +var HTMLHRElement = class extends HTMLElement { + constructor(ownerDocument, localName = "hr") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/progress-element.js +var HTMLProgressElement = class extends HTMLElement { + constructor(ownerDocument, localName = "progress") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/paragraph-element.js +var HTMLParagraphElement = class extends HTMLElement { + constructor(ownerDocument, localName = "p") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/table-element.js +var HTMLTableElement = class extends HTMLElement { + constructor(ownerDocument, localName = "table") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/frame-set-element.js +var HTMLFrameSetElement = class extends HTMLElement { + constructor(ownerDocument, localName = "frameset") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/li-element.js +var HTMLLIElement = class extends HTMLElement { + constructor(ownerDocument, localName = "li") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/base-element.js +var HTMLBaseElement = class extends HTMLElement { + constructor(ownerDocument, localName = "base") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/data-list-element.js +var HTMLDataListElement = class extends HTMLElement { + constructor(ownerDocument, localName = "datalist") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/input-element.js +var tagName4 = "input"; +var HTMLInputElement = class extends HTMLElement { + constructor(ownerDocument, localName = tagName4) { + super(ownerDocument, localName); + } + get autofocus() { + return booleanAttribute.get(this, "autofocus") || -1; + } + set autofocus(value) { + booleanAttribute.set(this, "autofocus", value); + } + get disabled() { + return booleanAttribute.get(this, "disabled"); + } + set disabled(value) { + booleanAttribute.set(this, "disabled", value); + } + get name() { + return this.getAttribute("name"); + } + set name(value) { + this.setAttribute("name", value); + } + get placeholder() { + return this.getAttribute("placeholder"); + } + set placeholder(value) { + this.setAttribute("placeholder", value); + } + get type() { + return this.getAttribute("type"); + } + set type(value) { + this.setAttribute("type", value); + } +}; +registerHTMLClass(tagName4, HTMLInputElement); + +// node_modules/linkedom/esm/html/param-element.js +var HTMLParamElement = class extends HTMLElement { + constructor(ownerDocument, localName = "param") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/media-element.js +var HTMLMediaElement = class extends HTMLElement { + constructor(ownerDocument, localName = "media") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/audio-element.js +var HTMLAudioElement = class extends HTMLElement { + constructor(ownerDocument, localName = "audio") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/heading-element.js +var tagName5 = "h1"; +var HTMLHeadingElement = class extends HTMLElement { + constructor(ownerDocument, localName = tagName5) { + super(ownerDocument, localName); + } +}; +registerHTMLClass([tagName5, "h2", "h3", "h4", "h5", "h6"], HTMLHeadingElement); + +// node_modules/linkedom/esm/html/directory-element.js +var HTMLDirectoryElement = class extends HTMLElement { + constructor(ownerDocument, localName = "dir") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/quote-element.js +var HTMLQuoteElement = class extends HTMLElement { + constructor(ownerDocument, localName = "quote") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/canvas-element.js +var import_canvas = __toESM(require_canvas(), 1); +var { createCanvas } = import_canvas.default; +var tagName6 = "canvas"; +var HTMLCanvasElement = class extends HTMLElement { + constructor(ownerDocument, localName = tagName6) { + super(ownerDocument, localName); + this[IMAGE] = createCanvas(300, 150); + } + get width() { + return this[IMAGE].width; + } + set width(value) { + numericAttribute.set(this, "width", value); + this[IMAGE].width = value; + } + get height() { + return this[IMAGE].height; + } + set height(value) { + numericAttribute.set(this, "height", value); + this[IMAGE].height = value; + } + getContext(type) { + return this[IMAGE].getContext(type); + } + toDataURL(...args) { + return this[IMAGE].toDataURL(...args); + } +}; +registerHTMLClass(tagName6, HTMLCanvasElement); + +// node_modules/linkedom/esm/html/legend-element.js +var HTMLLegendElement = class extends HTMLElement { + constructor(ownerDocument, localName = "legend") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/option-element.js +var HTMLOptionElement = class extends HTMLElement { + constructor(ownerDocument, localName = "option") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/span-element.js +var HTMLSpanElement = class extends HTMLElement { + constructor(ownerDocument, localName = "span") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/meter-element.js +var HTMLMeterElement = class extends HTMLElement { + constructor(ownerDocument, localName = "meter") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/video-element.js +var HTMLVideoElement = class extends HTMLElement { + constructor(ownerDocument, localName = "video") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/table-cell-element.js +var HTMLTableCellElement = class extends HTMLElement { + constructor(ownerDocument, localName = "td") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/title-element.js +var tagName7 = "title"; +var HTMLTitleElement = class extends TextElement { + constructor(ownerDocument, localName = tagName7) { + super(ownerDocument, localName); + } +}; +registerHTMLClass(tagName7, HTMLTitleElement); + +// node_modules/linkedom/esm/html/output-element.js +var HTMLOutputElement = class extends HTMLElement { + constructor(ownerDocument, localName = "output") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/table-row-element.js +var HTMLTableRowElement = class extends HTMLElement { + constructor(ownerDocument, localName = "tr") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/data-element.js +var HTMLDataElement = class extends HTMLElement { + constructor(ownerDocument, localName = "data") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/menu-element.js +var HTMLMenuElement = class extends HTMLElement { + constructor(ownerDocument, localName = "menu") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/select-element.js +var tagName8 = "select"; +var HTMLSelectElement = class extends HTMLElement { + constructor(ownerDocument, localName = tagName8) { + super(ownerDocument, localName); + } + get options() { + let children = new NodeList(); + let { firstElementChild } = this; + while (firstElementChild) { + if (firstElementChild.tagName === "OPTGROUP") + children.push(...firstElementChild.children); + else + children.push(firstElementChild); + firstElementChild = firstElementChild.nextElementSibling; + } + return children; + } + get disabled() { + return booleanAttribute.get(this, "disabled"); + } + set disabled(value) { + booleanAttribute.set(this, "disabled", value); + } + get name() { + return this.getAttribute("name"); + } + set name(value) { + this.setAttribute("name", value); + } +}; +registerHTMLClass(tagName8, HTMLSelectElement); + +// node_modules/linkedom/esm/html/br-element.js +var HTMLBRElement = class extends HTMLElement { + constructor(ownerDocument, localName = "br") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/button-element.js +var tagName9 = "button"; +var HTMLButtonElement = class extends HTMLElement { + constructor(ownerDocument, localName = tagName9) { + super(ownerDocument, localName); + } + get disabled() { + return booleanAttribute.get(this, "disabled"); + } + set disabled(value) { + booleanAttribute.set(this, "disabled", value); + } + get name() { + return this.getAttribute("name"); + } + set name(value) { + this.setAttribute("name", value); + } + get type() { + return this.getAttribute("type"); + } + set type(value) { + this.setAttribute("type", value); + } +}; +registerHTMLClass(tagName9, HTMLButtonElement); + +// node_modules/linkedom/esm/html/map-element.js +var HTMLMapElement = class extends HTMLElement { + constructor(ownerDocument, localName = "map") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/opt-group-element.js +var HTMLOptGroupElement = class extends HTMLElement { + constructor(ownerDocument, localName = "optgroup") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/d-list-element.js +var HTMLDListElement = class extends HTMLElement { + constructor(ownerDocument, localName = "dl") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/text-area-element.js +var tagName10 = "textarea"; +var HTMLTextAreaElement = class extends TextElement { + constructor(ownerDocument, localName = tagName10) { + super(ownerDocument, localName); + } + get disabled() { + return booleanAttribute.get(this, "disabled"); + } + set disabled(value) { + booleanAttribute.set(this, "disabled", value); + } + get name() { + return this.getAttribute("name"); + } + set name(value) { + this.setAttribute("name", value); + } + get placeholder() { + return this.getAttribute("placeholder"); + } + set placeholder(value) { + this.setAttribute("placeholder", value); + } + get type() { + return this.getAttribute("type"); + } + set type(value) { + this.setAttribute("type", value); + } + get value() { + return this.textContent; + } + set value(content) { + this.textContent = content; + } +}; +registerHTMLClass(tagName10, HTMLTextAreaElement); + +// node_modules/linkedom/esm/html/font-element.js +var HTMLFontElement = class extends HTMLElement { + constructor(ownerDocument, localName = "font") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/div-element.js +var HTMLDivElement = class extends HTMLElement { + constructor(ownerDocument, localName = "div") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/link-element.js +var tagName11 = "link"; +var HTMLLinkElement = class extends HTMLElement { + constructor(ownerDocument, localName = tagName11) { + super(ownerDocument, localName); + } + get disabled() { + return booleanAttribute.get(this, "disabled"); + } + set disabled(value) { + booleanAttribute.set(this, "disabled", value); + } + get href() { + return stringAttribute.get(this, "href"); + } + set href(value) { + stringAttribute.set(this, "href", value); + } + get hreflang() { + return stringAttribute.get(this, "hreflang"); + } + set hreflang(value) { + stringAttribute.set(this, "hreflang", value); + } + get media() { + return stringAttribute.get(this, "media"); + } + set media(value) { + stringAttribute.set(this, "media", value); + } + get rel() { + return stringAttribute.get(this, "rel"); + } + set rel(value) { + stringAttribute.set(this, "rel", value); + } + get type() { + return stringAttribute.get(this, "type"); + } + set type(value) { + stringAttribute.set(this, "type", value); + } +}; +registerHTMLClass(tagName11, HTMLLinkElement); + +// node_modules/linkedom/esm/html/slot-element.js +var HTMLSlotElement = class extends HTMLElement { + constructor(ownerDocument, localName = "slot") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/form-element.js +var HTMLFormElement = class extends HTMLElement { + constructor(ownerDocument, localName = "form") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/image-element.js +var tagName12 = "img"; +var HTMLImageElement = class extends HTMLElement { + constructor(ownerDocument, localName = tagName12) { + super(ownerDocument, localName); + } + get alt() { + return stringAttribute.get(this, "alt"); + } + set alt(value) { + stringAttribute.set(this, "alt", value); + } + get sizes() { + return stringAttribute.get(this, "sizes"); + } + set sizes(value) { + stringAttribute.set(this, "sizes", value); + } + get src() { + return stringAttribute.get(this, "src"); + } + set src(value) { + stringAttribute.set(this, "src", value); + } + get srcset() { + return stringAttribute.get(this, "srcset"); + } + set srcset(value) { + stringAttribute.set(this, "srcset", value); + } + get title() { + return stringAttribute.get(this, "title"); + } + set title(value) { + stringAttribute.set(this, "title", value); + } + get width() { + return numericAttribute.get(this, "width"); + } + set width(value) { + numericAttribute.set(this, "width", value); + } + get height() { + return numericAttribute.get(this, "height"); + } + set height(value) { + numericAttribute.set(this, "height", value); + } +}; +registerHTMLClass(tagName12, HTMLImageElement); + +// node_modules/linkedom/esm/html/pre-element.js +var HTMLPreElement = class extends HTMLElement { + constructor(ownerDocument, localName = "pre") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/u-list-element.js +var HTMLUListElement = class extends HTMLElement { + constructor(ownerDocument, localName = "ul") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/meta-element.js +var HTMLMetaElement = class extends HTMLElement { + constructor(ownerDocument, localName = "meta") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/picture-element.js +var HTMLPictureElement = class extends HTMLElement { + constructor(ownerDocument, localName = "picture") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/area-element.js +var HTMLAreaElement = class extends HTMLElement { + constructor(ownerDocument, localName = "area") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/o-list-element.js +var HTMLOListElement = class extends HTMLElement { + constructor(ownerDocument, localName = "ol") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/table-caption-element.js +var HTMLTableCaptionElement = class extends HTMLElement { + constructor(ownerDocument, localName = "caption") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/anchor-element.js +var tagName13 = "a"; +var HTMLAnchorElement = class extends HTMLElement { + constructor(ownerDocument, localName = tagName13) { + super(ownerDocument, localName); + } + get href() { + return encodeURI(stringAttribute.get(this, "href")); + } + set href(value) { + stringAttribute.set(this, "href", decodeURI(value)); + } + get download() { + return encodeURI(stringAttribute.get(this, "download")); + } + set download(value) { + stringAttribute.set(this, "download", decodeURI(value)); + } + get target() { + return stringAttribute.get(this, "target"); + } + set target(value) { + stringAttribute.set(this, "target", value); + } + get type() { + return stringAttribute.get(this, "type"); + } + set type(value) { + stringAttribute.set(this, "type", value); + } +}; +registerHTMLClass(tagName13, HTMLAnchorElement); + +// node_modules/linkedom/esm/html/label-element.js +var HTMLLabelElement = class extends HTMLElement { + constructor(ownerDocument, localName = "label") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/unknown-element.js +var HTMLUnknownElement = class extends HTMLElement { + constructor(ownerDocument, localName = "unknown") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/mod-element.js +var HTMLModElement = class extends HTMLElement { + constructor(ownerDocument, localName = "mod") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/details-element.js +var HTMLDetailsElement = class extends HTMLElement { + constructor(ownerDocument, localName = "details") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/source-element.js +var tagName14 = "source"; +var HTMLSourceElement = class extends HTMLElement { + constructor(ownerDocument, localName = tagName14) { + super(ownerDocument, localName); + } + get src() { + return stringAttribute.get(this, "src"); + } + set src(value) { + stringAttribute.set(this, "src", value); + } + get srcset() { + return stringAttribute.get(this, "srcset"); + } + set srcset(value) { + stringAttribute.set(this, "srcset", value); + } + get sizes() { + return stringAttribute.get(this, "sizes"); + } + set sizes(value) { + stringAttribute.set(this, "sizes", value); + } + get type() { + return stringAttribute.get(this, "type"); + } + set type(value) { + stringAttribute.set(this, "type", value); + } +}; +registerHTMLClass(tagName14, HTMLSourceElement); + +// node_modules/linkedom/esm/html/track-element.js +var HTMLTrackElement = class extends HTMLElement { + constructor(ownerDocument, localName = "track") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/html/marquee-element.js +var HTMLMarqueeElement = class extends HTMLElement { + constructor(ownerDocument, localName = "marquee") { + super(ownerDocument, localName); + } +}; + +// node_modules/linkedom/esm/shared/html-classes.js +var HTMLClasses = { + HTMLElement, + HTMLTemplateElement, + HTMLHtmlElement, + HTMLScriptElement, + HTMLFrameElement, + HTMLIFrameElement, + HTMLObjectElement, + HTMLHeadElement, + HTMLBodyElement, + HTMLStyleElement, + HTMLTimeElement, + HTMLFieldSetElement, + HTMLEmbedElement, + HTMLHRElement, + HTMLProgressElement, + HTMLParagraphElement, + HTMLTableElement, + HTMLFrameSetElement, + HTMLLIElement, + HTMLBaseElement, + HTMLDataListElement, + HTMLInputElement, + HTMLParamElement, + HTMLMediaElement, + HTMLAudioElement, + HTMLHeadingElement, + HTMLDirectoryElement, + HTMLQuoteElement, + HTMLCanvasElement, + HTMLLegendElement, + HTMLOptionElement, + HTMLSpanElement, + HTMLMeterElement, + HTMLVideoElement, + HTMLTableCellElement, + HTMLTitleElement, + HTMLOutputElement, + HTMLTableRowElement, + HTMLDataElement, + HTMLMenuElement, + HTMLSelectElement, + HTMLBRElement, + HTMLButtonElement, + HTMLMapElement, + HTMLOptGroupElement, + HTMLDListElement, + HTMLTextAreaElement, + HTMLFontElement, + HTMLDivElement, + HTMLLinkElement, + HTMLSlotElement, + HTMLFormElement, + HTMLImageElement, + HTMLPreElement, + HTMLUListElement, + HTMLMetaElement, + HTMLPictureElement, + HTMLAreaElement, + HTMLOListElement, + HTMLTableCaptionElement, + HTMLAnchorElement, + HTMLLabelElement, + HTMLUnknownElement, + HTMLModElement, + HTMLDetailsElement, + HTMLSourceElement, + HTMLTrackElement, + HTMLMarqueeElement +}; + +// node_modules/linkedom/esm/shared/mime.js +var voidElements = { test: () => true }; +var Mime = { + "text/html": { + docType: "", + ignoreCase: true, + voidElements: /^(?:area|base|br|col|embed|hr|img|input|keygen|link|menuitem|meta|param|source|track|wbr)$/i + }, + "image/svg+xml": { + docType: '', + ignoreCase: false, + voidElements + }, + "text/xml": { + docType: '', + ignoreCase: false, + voidElements + }, + "application/xml": { + docType: '', + ignoreCase: false, + voidElements + }, + "application/xhtml+xml": { + docType: '', + ignoreCase: false, + voidElements + } +}; + +// node_modules/linkedom/esm/interface/custom-event.js +var GlobalCustomEvent = typeof CustomEvent === "function" ? CustomEvent : class CustomEvent2 extends GlobalEvent { + constructor(type, eventInitDict = {}) { + super(type, eventInitDict); + this.detail = eventInitDict.detail; + } +}; + +// node_modules/linkedom/esm/interface/input-event.js +var InputEvent = class extends GlobalEvent { + constructor(type, inputEventInit = {}) { + super(type, inputEventInit); + this.inputType = inputEventInit.inputType; + this.data = inputEventInit.data; + this.dataTransfer = inputEventInit.dataTransfer; + this.isComposing = inputEventInit.isComposing || false; + this.ranges = inputEventInit.ranges; + } +}; + +// node_modules/linkedom/esm/interface/image.js +var ImageClass = (ownerDocument) => class Image extends HTMLImageElement { + constructor(width, height) { + super(ownerDocument); + switch (arguments.length) { + case 1: + this.height = width; + this.width = width; + break; + case 2: + this.height = height; + this.width = width; + break; + } + } +}; + +// node_modules/linkedom/esm/interface/range.js +var deleteContents = ({ [START]: start, [END]: end }, fragment = null) => { + setAdjacent(start[PREV], end[NEXT]); + do { + const after2 = getEnd(start); + const next = after2 === end ? after2 : after2[NEXT]; + if (fragment) + fragment.insertBefore(start, fragment[END]); + else + start.remove(); + start = next; + } while (start !== end); +}; +var Range = class { + constructor() { + this[START] = null; + this[END] = null; + this.commonAncestorContainer = null; + } + insertNode(newNode) { + this[END].parentNode.insertBefore(newNode, this[START]); + } + selectNode(node) { + this[START] = node; + this[END] = getEnd(node); + } + surroundContents(parentNode) { + parentNode.replaceChildren(this.extractContents()); + } + setStartBefore(node) { + this[START] = node; + } + setStartAfter(node) { + this[START] = node.nextSibling; + } + setEndBefore(node) { + this[END] = getEnd(node.previousSibling); + } + setEndAfter(node) { + this[END] = getEnd(node); + } + cloneContents() { + let { [START]: start, [END]: end } = this; + const fragment = start.ownerDocument.createDocumentFragment(); + while (start !== end) { + fragment.insertBefore(start.cloneNode(true), fragment[END]); + start = getEnd(start); + if (start !== end) + start = start[NEXT]; + } + return fragment; + } + deleteContents() { + deleteContents(this); + } + extractContents() { + const fragment = this[START].ownerDocument.createDocumentFragment(); + deleteContents(this, fragment); + return fragment; + } + createContextualFragment(html) { + const template = this.commonAncestorContainer.createElement("template"); + template.innerHTML = html; + this.selectNode(template.content); + return template.content; + } + cloneRange() { + const range = new Range(); + range[START] = this[START]; + range[END] = this[END]; + return range; + } +}; + +// node_modules/linkedom/esm/interface/tree-walker.js +var isOK = ({ nodeType }, mask) => { + switch (nodeType) { + case ELEMENT_NODE: + return mask & SHOW_ELEMENT; + case TEXT_NODE: + return mask & SHOW_TEXT; + case COMMENT_NODE: + return mask & SHOW_COMMENT; + } + return 0; +}; +var TreeWalker = class { + constructor(root, whatToShow = SHOW_ALL) { + this.root = root; + this.currentNode = root; + this.whatToShow = whatToShow; + let { [NEXT]: next, [END]: end } = root; + if (root.nodeType === DOCUMENT_NODE) { + const { documentElement } = root; + next = documentElement; + end = documentElement[END]; + } + const nodes = []; + while (next !== end) { + if (isOK(next, whatToShow)) + nodes.push(next); + next = next[NEXT]; + } + this[PRIVATE] = { i: 0, nodes }; + } + nextNode() { + const $ = this[PRIVATE]; + this.currentNode = $.i < $.nodes.length ? $.nodes[$.i++] : null; + return this.currentNode; + } +}; + +// node_modules/linkedom/esm/interface/document.js +var query = (method, ownerDocument, selectors) => { + let { [NEXT]: next, [END]: end } = ownerDocument; + return method.call({ ownerDocument, [NEXT]: next, [END]: end }, selectors); +}; +var globalExports = assign({}, Facades, HTMLClasses, { + CustomEvent: GlobalCustomEvent, + Event: GlobalEvent, + EventTarget: DOMEventTarget, + InputEvent, + NamedNodeMap, + NodeList +}); +var window2 = /* @__PURE__ */ new WeakMap(); +var Document = class extends NonElementParentNode { + constructor(type) { + super(null, "#document", DOCUMENT_NODE); + this[CUSTOM_ELEMENTS] = { active: false, registry: null }; + this[MUTATION_OBSERVER] = { active: false, class: null }; + this[MIME] = Mime[type]; + this[DOCTYPE] = null; + this[DOM_PARSER] = null; + this[GLOBALS] = null; + this[IMAGE] = null; + this[UPGRADE] = null; + } + get defaultView() { + if (!window2.has(this)) + window2.set(this, new Proxy(globalThis, { + set: (target, name, value) => { + switch (name) { + case "addEventListener": + case "removeEventListener": + case "dispatchEvent": + this[EVENT_TARGET][name] = value; + break; + default: + target[name] = value; + break; + } + return true; + }, + get: (globalThis2, name) => { + switch (name) { + case "addEventListener": + case "removeEventListener": + case "dispatchEvent": + if (!this[EVENT_TARGET]) { + const et = this[EVENT_TARGET] = new DOMEventTarget(); + et.dispatchEvent = et.dispatchEvent.bind(et); + et.addEventListener = et.addEventListener.bind(et); + et.removeEventListener = et.removeEventListener.bind(et); + } + return this[EVENT_TARGET][name]; + case "document": + return this; + case "navigator": + return { + userAgent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 Safari/537.36" + }; + case "window": + return window2.get(this); + case "customElements": + if (!this[CUSTOM_ELEMENTS].registry) + this[CUSTOM_ELEMENTS] = new CustomElementRegistry(this); + return this[CUSTOM_ELEMENTS]; + case "performance": + return import_perf_hooks.performance; + case "DOMParser": + return this[DOM_PARSER]; + case "Image": + if (!this[IMAGE]) + this[IMAGE] = ImageClass(this); + return this[IMAGE]; + case "MutationObserver": + if (!this[MUTATION_OBSERVER].class) + this[MUTATION_OBSERVER] = new MutationObserverClass(this); + return this[MUTATION_OBSERVER].class; + } + return this[GLOBALS] && this[GLOBALS][name] || globalExports[name] || globalThis2[name]; + } + })); + return window2.get(this); + } + get doctype() { + const docType = this[DOCTYPE]; + if (docType) + return docType; + const { firstChild } = this; + if (firstChild && firstChild.nodeType === DOCUMENT_TYPE_NODE) + return this[DOCTYPE] = firstChild; + return null; + } + set doctype(value) { + if (/^([a-z:]+)(\s+system|\s+public(\s+"([^"]+)")?)?(\s+"([^"]+)")?/i.test(value)) { + const { $1: name, $4: publicId, $6: systemId } = RegExp; + this[DOCTYPE] = new DocumentType(this, name, publicId, systemId); + knownSiblings(this, this[DOCTYPE], this[NEXT]); + } + } + get documentElement() { + return this.firstElementChild; + } + get isConnected() { + return true; + } + _getParent() { + return this[EVENT_TARGET]; + } + createAttribute(name) { + return new Attr(this, name); + } + createComment(textContent) { + return new Comment(this, textContent); + } + createDocumentFragment() { + return new DocumentFragment(this); + } + createDocumentType(name, publicId, systemId) { + return new DocumentType(this, name, publicId, systemId); + } + createElement(localName) { + return new Element(this, localName); + } + createRange() { + const range = new Range(); + range.commonAncestorContainer = this; + return range; + } + createTextNode(textContent) { + return new Text(this, textContent); + } + createTreeWalker(root, whatToShow = -1) { + return new TreeWalker(root, whatToShow); + } + createNodeIterator(root, whatToShow = -1) { + return this.createTreeWalker(root, whatToShow); + } + createEvent(name) { + const event = create(name === "Event" ? new GlobalEvent("") : new GlobalCustomEvent("")); + event.initEvent = event.initCustomEvent = (type, canBubble = false, cancelable = false, detail) => { + defineProperties(event, { + type: { value: type }, + canBubble: { value: canBubble }, + cancelable: { value: cancelable }, + detail: { value: detail } + }); + }; + return event; + } + cloneNode(deep = false) { + const { + constructor, + [CUSTOM_ELEMENTS]: customElements2, + [DOCTYPE]: doctype + } = this; + const document2 = new constructor(); + document2[CUSTOM_ELEMENTS] = customElements2; + if (deep) { + const end = document2[END]; + const { childNodes } = this; + for (let { length } = childNodes, i2 = 0; i2 < length; i2++) + document2.insertBefore(childNodes[i2].cloneNode(true), end); + if (doctype) + document2[DOCTYPE] = childNodes[0]; + } + return document2; + } + importNode(externalNode) { + const deep = 1 < arguments.length && !!arguments[1]; + const node = externalNode.cloneNode(deep); + const { [CUSTOM_ELEMENTS]: customElements2 } = this; + const { active } = customElements2; + const upgrade = (element) => { + const { ownerDocument, nodeType } = element; + element.ownerDocument = this; + if (active && ownerDocument !== this && nodeType === ELEMENT_NODE) + customElements2.upgrade(element); + }; + upgrade(node); + if (deep) { + switch (node.nodeType) { + case ELEMENT_NODE: + case DOCUMENT_FRAGMENT_NODE: { + let { [NEXT]: next, [END]: end } = node; + while (next !== end) { + if (next.nodeType === ELEMENT_NODE) + upgrade(next); + next = next[NEXT]; + } + break; + } + } + } + return node; + } + toString() { + return this.childNodes.join(""); + } + querySelector(selectors) { + return query(super.querySelector, this, selectors); + } + querySelectorAll(selectors) { + return query(super.querySelectorAll, this, selectors); + } + getElementsByTagNameNS(_, name) { + return this.getElementsByTagName(name); + } + createAttributeNS(_, name) { + return this.createAttribute(name); + } + createElementNS(nsp, localName, options) { + return nsp === SVG_NAMESPACE ? new SVGElement(this, localName, null) : this.createElement(localName, options); + } +}; +setPrototypeOf(globalExports.Document = function Document2() { + illegalConstructor(); +}, Document).prototype = Document.prototype; + +// node_modules/linkedom/esm/html/document.js +var createHTMLElement = (ownerDocument, builtin, localName, options) => { + if (!builtin && htmlClasses.has(localName)) { + const Class = htmlClasses.get(localName); + return new Class(ownerDocument, localName); + } + const { [CUSTOM_ELEMENTS]: { active, registry } } = ownerDocument; + if (active) { + const ce = builtin ? options.is : localName; + if (registry.has(ce)) { + const { Class } = registry.get(ce); + const element = new Class(ownerDocument, localName); + customElements.set(element, { connected: false }); + return element; + } + } + return new HTMLElement(ownerDocument, localName); +}; +var HTMLDocument = class extends Document { + constructor() { + super("text/html"); + } + get all() { + const nodeList = new NodeList(); + let { [NEXT]: next, [END]: end } = this; + while (next !== end) { + switch (next.nodeType) { + case ELEMENT_NODE: + nodeList.push(next); + break; + } + next = next[NEXT]; + } + return nodeList; + } + get head() { + const { documentElement } = this; + let { firstElementChild } = documentElement; + if (!firstElementChild || firstElementChild.tagName !== "HEAD") { + firstElementChild = this.createElement("head"); + documentElement.prepend(firstElementChild); + } + return firstElementChild; + } + get body() { + const { head } = this; + let { nextElementSibling: nextElementSibling2 } = head; + if (!nextElementSibling2 || nextElementSibling2.tagName !== "BODY") { + nextElementSibling2 = this.createElement("body"); + head.after(nextElementSibling2); + } + return nextElementSibling2; + } + get title() { + const { head } = this; + let title = head.getElementsByTagName("title").shift(); + return title ? title.textContent : ""; + } + set title(textContent) { + const { head } = this; + let title = head.getElementsByTagName("title").shift(); + if (title) + title.textContent = textContent; + else { + head.insertBefore(this.createElement("title"), head.firstChild).textContent = textContent; + } + } + createElement(localName, options) { + const builtin = !!(options && options.is); + const element = createHTMLElement(this, builtin, localName, options); + if (builtin) + element.setAttribute("is", options.is); + return element; + } +}; + +// node_modules/linkedom/esm/svg/document.js +var SVGDocument = class extends Document { + constructor() { + super("image/svg+xml"); + } + toString() { + return this[MIME].docType + super.toString(); + } +}; + +// node_modules/linkedom/esm/xml/document.js +var XMLDocument = class extends Document { + constructor() { + super("text/xml"); + } + toString() { + return this[MIME].docType + super.toString(); + } +}; + +// node_modules/linkedom/esm/dom/parser.js +var DOMParser = class { + parseFromString(markupLanguage, mimeType, globals = null) { + let isHTML = false, document2; + if (mimeType === "text/html") { + isHTML = true; + document2 = new HTMLDocument(); + } else if (mimeType === "image/svg+xml") + document2 = new SVGDocument(); + else + document2 = new XMLDocument(); + document2[DOM_PARSER] = DOMParser; + if (globals) + document2[GLOBALS] = globals; + return markupLanguage ? parseFromString(document2, isHTML, markupLanguage) : document2; + } +}; + +// node_modules/linkedom/esm/shared/parse-json.js +var { parse: parse3 } = JSON; + +// node_modules/linkedom/esm/index.js +var parseHTML = (html, globals = null) => new DOMParser().parseFromString(html, "text/html", globals).defaultView; +function Document3() { + illegalConstructor(); +} +setPrototypeOf(Document3, Document).prototype = Document.prototype; + +// src/lib/payload.ts +var import_showdown = __toESM(require_showdown(), 1); + +// src/lib/feedimg.ts +var import_core3 = __toESM(require_core(), 1); + +// node_modules/node-fetch/src/index.js +var import_node_http2 = __toESM(require("node:http"), 1); +var import_node_https = __toESM(require("node:https"), 1); +var import_node_zlib = __toESM(require("node:zlib"), 1); +var import_node_stream2 = __toESM(require("node:stream"), 1); +var import_node_buffer2 = require("node:buffer"); + +// node_modules/data-uri-to-buffer/dist/index.js +function dataUriToBuffer(uri) { + if (!/^data:/i.test(uri)) { + throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")'); + } + uri = uri.replace(/\r?\n/g, ""); + const firstComma = uri.indexOf(","); + if (firstComma === -1 || firstComma <= 4) { + throw new TypeError("malformed data: URI"); + } + const meta = uri.substring(5, firstComma).split(";"); + let charset = ""; + let base64 = false; + const type = meta[0] || "text/plain"; + let typeFull = type; + for (let i2 = 1; i2 < meta.length; i2++) { + if (meta[i2] === "base64") { + base64 = true; + } else { + typeFull += `;${meta[i2]}`; + if (meta[i2].indexOf("charset=") === 0) { + charset = meta[i2].substring(8); + } + } + } + if (!meta[0] && !charset.length) { + typeFull += ";charset=US-ASCII"; + charset = "US-ASCII"; + } + const encoding = base64 ? "base64" : "ascii"; + const data = unescape(uri.substring(firstComma + 1)); + const buffer = Buffer.from(data, encoding); + buffer.type = type; + buffer.typeFull = typeFull; + buffer.charset = charset; + return buffer; +} +var dist_default = dataUriToBuffer; + +// node_modules/node-fetch/src/body.js +var import_node_stream = __toESM(require("node:stream"), 1); +var import_node_util = require("node:util"); +var import_node_buffer = require("node:buffer"); +init_fetch_blob(); +init_esm_min(); + +// node_modules/node-fetch/src/errors/base.js +var FetchBaseError = class extends Error { + constructor(message, type) { + super(message); + Error.captureStackTrace(this, this.constructor); + this.type = type; + } + get name() { + return this.constructor.name; + } + get [Symbol.toStringTag]() { + return this.constructor.name; + } +}; + +// node_modules/node-fetch/src/errors/fetch-error.js +var FetchError = class extends FetchBaseError { + constructor(message, type, systemError) { + super(message, type); + if (systemError) { + this.code = this.errno = systemError.code; + this.erroredSysCall = systemError.syscall; + } + } +}; + +// node_modules/node-fetch/src/utils/is.js +var NAME = Symbol.toStringTag; +var isURLSearchParameters = (object) => { + return typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && typeof object.sort === "function" && object[NAME] === "URLSearchParams"; +}; +var isBlob = (object) => { + return object && typeof object === "object" && typeof object.arrayBuffer === "function" && typeof object.type === "string" && typeof object.stream === "function" && typeof object.constructor === "function" && /^(Blob|File)$/.test(object[NAME]); +}; +var isAbortSignal = (object) => { + return typeof object === "object" && (object[NAME] === "AbortSignal" || object[NAME] === "EventTarget"); +}; +var isDomainOrSubdomain = (destination, original) => { + const orig = new URL(original).hostname; + const dest = new URL(destination).hostname; + return orig === dest || orig.endsWith(`.${dest}`); +}; + +// node_modules/node-fetch/src/body.js +var pipeline = (0, import_node_util.promisify)(import_node_stream.default.pipeline); +var INTERNALS = Symbol("Body internals"); +var Body = class { + constructor(body, { + size = 0 + } = {}) { + let boundary = null; + if (body === null) { + body = null; + } else if (isURLSearchParameters(body)) { + body = import_node_buffer.Buffer.from(body.toString()); + } else if (isBlob(body)) { + } else if (import_node_buffer.Buffer.isBuffer(body)) { + } else if (import_node_util.types.isAnyArrayBuffer(body)) { + body = import_node_buffer.Buffer.from(body); + } else if (ArrayBuffer.isView(body)) { + body = import_node_buffer.Buffer.from(body.buffer, body.byteOffset, body.byteLength); + } else if (body instanceof import_node_stream.default) { + } else if (body instanceof FormData2) { + body = formDataToBlob(body); + boundary = body.type.split("=")[1]; + } else { + body = import_node_buffer.Buffer.from(String(body)); + } + let stream = body; + if (import_node_buffer.Buffer.isBuffer(body)) { + stream = import_node_stream.default.Readable.from(body); + } else if (isBlob(body)) { + stream = import_node_stream.default.Readable.from(body.stream()); + } + this[INTERNALS] = { + body, + stream, + boundary, + disturbed: false, + error: null + }; + this.size = size; + if (body instanceof import_node_stream.default) { + body.on("error", (error_) => { + const error = error_ instanceof FetchBaseError ? error_ : new FetchError(`Invalid response body while trying to fetch ${this.url}: ${error_.message}`, "system", error_); + this[INTERNALS].error = error; + }); + } + } + get body() { + return this[INTERNALS].stream; + } + get bodyUsed() { + return this[INTERNALS].disturbed; + } + async arrayBuffer() { + const { buffer, byteOffset, byteLength } = await consumeBody(this); + return buffer.slice(byteOffset, byteOffset + byteLength); + } + async formData() { + const ct = this.headers.get("content-type"); + if (ct.startsWith("application/x-www-form-urlencoded")) { + const formData = new FormData2(); + const parameters = new URLSearchParams(await this.text()); + for (const [name, value] of parameters) { + formData.append(name, value); + } + return formData; + } + const { toFormData: toFormData2 } = await Promise.resolve().then(() => (init_multipart_parser(), multipart_parser_exports)); + return toFormData2(this.body, ct); + } + async blob() { + const ct = this.headers && this.headers.get("content-type") || this[INTERNALS].body && this[INTERNALS].body.type || ""; + const buf = await this.arrayBuffer(); + return new fetch_blob_default([buf], { + type: ct + }); + } + async json() { + const text = await this.text(); + return JSON.parse(text); + } + async text() { + const buffer = await consumeBody(this); + return new TextDecoder().decode(buffer); + } + buffer() { + return consumeBody(this); + } +}; +Body.prototype.buffer = (0, import_node_util.deprecate)(Body.prototype.buffer, "Please use 'response.arrayBuffer()' instead of 'response.buffer()'", "node-fetch#buffer"); +Object.defineProperties(Body.prototype, { + body: { enumerable: true }, + bodyUsed: { enumerable: true }, + arrayBuffer: { enumerable: true }, + blob: { enumerable: true }, + json: { enumerable: true }, + text: { enumerable: true }, + data: { get: (0, import_node_util.deprecate)(() => { + }, "data doesn't exist, use json(), text(), arrayBuffer(), or body instead", "https://github.com/node-fetch/node-fetch/issues/1000 (response)") } +}); +async function consumeBody(data) { + if (data[INTERNALS].disturbed) { + throw new TypeError(`body used already for: ${data.url}`); + } + data[INTERNALS].disturbed = true; + if (data[INTERNALS].error) { + throw data[INTERNALS].error; + } + const { body } = data; + if (body === null) { + return import_node_buffer.Buffer.alloc(0); + } + if (!(body instanceof import_node_stream.default)) { + return import_node_buffer.Buffer.alloc(0); + } + const accum = []; + let accumBytes = 0; + try { + for await (const chunk of body) { + if (data.size > 0 && accumBytes + chunk.length > data.size) { + const error = new FetchError(`content size at ${data.url} over limit: ${data.size}`, "max-size"); + body.destroy(error); + throw error; + } + accumBytes += chunk.length; + accum.push(chunk); + } + } catch (error) { + const error_ = error instanceof FetchBaseError ? error : new FetchError(`Invalid response body while trying to fetch ${data.url}: ${error.message}`, "system", error); + throw error_; + } + if (body.readableEnded === true || body._readableState.ended === true) { + try { + if (accum.every((c) => typeof c === "string")) { + return import_node_buffer.Buffer.from(accum.join("")); + } + return import_node_buffer.Buffer.concat(accum, accumBytes); + } catch (error) { + throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${error.message}`, "system", error); + } + } else { + throw new FetchError(`Premature close of server response while trying to fetch ${data.url}`); + } +} +var clone = (instance, highWaterMark) => { + let p1; + let p2; + let { body } = instance[INTERNALS]; + if (instance.bodyUsed) { + throw new Error("cannot clone body after it is used"); + } + if (body instanceof import_node_stream.default && typeof body.getBoundary !== "function") { + p1 = new import_node_stream.PassThrough({ highWaterMark }); + p2 = new import_node_stream.PassThrough({ highWaterMark }); + body.pipe(p1); + body.pipe(p2); + instance[INTERNALS].stream = p1; + body = p2; + } + return body; +}; +var getNonSpecFormDataBoundary = (0, import_node_util.deprecate)((body) => body.getBoundary(), "form-data doesn't follow the spec and requires special treatment. Use alternative package", "https://github.com/node-fetch/node-fetch/issues/1167"); +var extractContentType = (body, request) => { + if (body === null) { + return null; + } + if (typeof body === "string") { + return "text/plain;charset=UTF-8"; + } + if (isURLSearchParameters(body)) { + return "application/x-www-form-urlencoded;charset=UTF-8"; + } + if (isBlob(body)) { + return body.type || null; + } + if (import_node_buffer.Buffer.isBuffer(body) || import_node_util.types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) { + return null; + } + if (body instanceof FormData2) { + return `multipart/form-data; boundary=${request[INTERNALS].boundary}`; + } + if (body && typeof body.getBoundary === "function") { + return `multipart/form-data;boundary=${getNonSpecFormDataBoundary(body)}`; + } + if (body instanceof import_node_stream.default) { + return null; + } + return "text/plain;charset=UTF-8"; +}; +var getTotalBytes = (request) => { + const { body } = request[INTERNALS]; + if (body === null) { + return 0; + } + if (isBlob(body)) { + return body.size; + } + if (import_node_buffer.Buffer.isBuffer(body)) { + return body.length; + } + if (body && typeof body.getLengthSync === "function") { + return body.hasKnownLength && body.hasKnownLength() ? body.getLengthSync() : null; + } + return null; +}; +var writeToStream = async (dest, { body }) => { + if (body === null) { + dest.end(); + } else { + await pipeline(body, dest); + } +}; + +// node_modules/node-fetch/src/headers.js +var import_node_util2 = require("node:util"); +var import_node_http = __toESM(require("node:http"), 1); +var validateHeaderName = typeof import_node_http.default.validateHeaderName === "function" ? import_node_http.default.validateHeaderName : (name) => { + if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(name)) { + const error = new TypeError(`Header name must be a valid HTTP token [${name}]`); + Object.defineProperty(error, "code", { value: "ERR_INVALID_HTTP_TOKEN" }); + throw error; + } +}; +var validateHeaderValue = typeof import_node_http.default.validateHeaderValue === "function" ? import_node_http.default.validateHeaderValue : (name, value) => { + if (/[^\t\u0020-\u007E\u0080-\u00FF]/.test(value)) { + const error = new TypeError(`Invalid character in header content ["${name}"]`); + Object.defineProperty(error, "code", { value: "ERR_INVALID_CHAR" }); + throw error; + } +}; +var Headers = class extends URLSearchParams { + constructor(init) { + let result = []; + if (init instanceof Headers) { + const raw = init.raw(); + for (const [name, values] of Object.entries(raw)) { + result.push(...values.map((value) => [name, value])); + } + } else if (init == null) { + } else if (typeof init === "object" && !import_node_util2.types.isBoxedPrimitive(init)) { + const method = init[Symbol.iterator]; + if (method == null) { + result.push(...Object.entries(init)); + } else { + if (typeof method !== "function") { + throw new TypeError("Header pairs must be iterable"); + } + result = [...init].map((pair) => { + if (typeof pair !== "object" || import_node_util2.types.isBoxedPrimitive(pair)) { + throw new TypeError("Each header pair must be an iterable object"); + } + return [...pair]; + }).map((pair) => { + if (pair.length !== 2) { + throw new TypeError("Each header pair must be a name/value tuple"); + } + return [...pair]; + }); + } + } else { + throw new TypeError("Failed to construct 'Headers': The provided value is not of type '(sequence