@vitest/browser 5.0.0-beta.5 → 5.0.0-beta.7

package/dist/client/__vitest_browser__/rrweb-snapshot-DkFyu2W8.js

@@ -0,0 +1,4665 @@
+//#region ../../node_modules/.pnpm/rrweb-snapshot@2.0.1_patch_hash=9e976b2c55a5c2ed589c41b8f46cc44b6fe6f528ebb4d3780a44b1ca8cbb17a4/node_modules/rrweb-snapshot/dist/rrweb-snapshot.js
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+	NodeType2[NodeType2["Document"] = 0] = "Document";
+	NodeType2[NodeType2["DocumentType"] = 1] = "DocumentType";
+	NodeType2[NodeType2["Element"] = 2] = "Element";
+	NodeType2[NodeType2["Text"] = 3] = "Text";
+	NodeType2[NodeType2["CDATA"] = 4] = "CDATA";
+	NodeType2[NodeType2["Comment"] = 5] = "Comment";
+	return NodeType2;
+})(NodeType || {});
+var testableAccessors = {
+	Node: [
+		"childNodes",
+		"parentNode",
+		"parentElement",
+		"textContent",
+		"ownerDocument"
+	],
+	ShadowRoot: ["host", "styleSheets"],
+	Element: [
+		"shadowRoot",
+		"querySelector",
+		"querySelectorAll"
+	],
+	MutationObserver: []
+};
+var testableMethods = {
+	Node: ["contains", "getRootNode"],
+	ShadowRoot: ["getSelection"],
+	Element: [],
+	MutationObserver: ["constructor"]
+};
+var untaintedBasePrototype = {};
+var untaintedBaseIframeCleanup = {};
+var isAngularZonePresent = () => {
+	return !!globalThis.Zone;
+};
+function getUntaintedPrototype(key) {
+	if (untaintedBasePrototype[key]) return untaintedBasePrototype[key];
+	const defaultObj = globalThis[key];
+	const defaultPrototype = defaultObj.prototype;
+	const accessorNames = key in testableAccessors ? testableAccessors[key] : void 0;
+	const isUntaintedAccessors = Boolean(accessorNames && accessorNames.every((accessor) => {
+		var _a, _b;
+		return Boolean((_b = (_a = Object.getOwnPropertyDescriptor(defaultPrototype, accessor)) == null ? void 0 : _a.get) == null ? void 0 : _b.toString().includes("[native code]"));
+	}));
+	const methodNames = key in testableMethods ? testableMethods[key] : void 0;
+	const isUntaintedMethods = Boolean(methodNames && methodNames.every((method) => {
+		var _a;
+		return typeof defaultPrototype[method] === "function" && ((_a = defaultPrototype[method]) == null ? void 0 : _a.toString().includes("[native code]"));
+	}));
+	if (isUntaintedAccessors && isUntaintedMethods && !isAngularZonePresent()) {
+		untaintedBasePrototype[key] = defaultObj.prototype;
+		return defaultObj.prototype;
+	}
+	try {
+		const iframeEl = document.createElement("iframe");
+		iframeEl.style.display = "none";
+		document.body.appendChild(iframeEl);
+		const win = iframeEl.contentWindow;
+		if (!win) return defaultObj.prototype;
+		const untaintedObject = win[key].prototype;
+		if (!untaintedObject) {
+			iframeEl.remove();
+			return defaultPrototype;
+		}
+		const ua = navigator.userAgent;
+		if (ua.includes("Safari") && !ua.includes("Chrome")) {
+			iframeEl.classList.add("rr-block");
+			iframeEl.setAttribute("__rrwebUntaintedMutationObserver", "");
+			untaintedBaseIframeCleanup[key] = () => iframeEl.remove();
+		} else iframeEl.remove();
+		return untaintedBasePrototype[key] = untaintedObject;
+	} catch {
+		return defaultPrototype;
+	}
+}
+var untaintedAccessorCache = {};
+function getUntaintedAccessor(key, instance, accessor) {
+	var _a;
+	const cacheKey = `${key}.${String(accessor)}`;
+	if (untaintedAccessorCache[cacheKey]) return untaintedAccessorCache[cacheKey].call(instance);
+	const untaintedPrototype = getUntaintedPrototype(key);
+	const untaintedAccessor = (_a = Object.getOwnPropertyDescriptor(untaintedPrototype, accessor)) == null ? void 0 : _a.get;
+	if (!untaintedAccessor) return instance[accessor];
+	untaintedAccessorCache[cacheKey] = untaintedAccessor;
+	return untaintedAccessor.call(instance);
+}
+var untaintedMethodCache = {};
+function getUntaintedMethod(key, instance, method) {
+	const cacheKey = `${key}.${String(method)}`;
+	if (untaintedMethodCache[cacheKey]) return untaintedMethodCache[cacheKey].bind(instance);
+	const untaintedMethod = getUntaintedPrototype(key)[method];
+	if (typeof untaintedMethod !== "function") return instance[method];
+	untaintedMethodCache[cacheKey] = untaintedMethod;
+	return untaintedMethod.bind(instance);
+}
+function ownerDocument(n) {
+	return getUntaintedAccessor("Node", n, "ownerDocument");
+}
+function childNodes(n) {
+	return getUntaintedAccessor("Node", n, "childNodes");
+}
+function parentNode(n) {
+	return getUntaintedAccessor("Node", n, "parentNode");
+}
+function parentElement(n) {
+	return getUntaintedAccessor("Node", n, "parentElement");
+}
+function textContent(n) {
+	return getUntaintedAccessor("Node", n, "textContent");
+}
+function contains(n, other) {
+	return getUntaintedMethod("Node", n, "contains")(other);
+}
+function getRootNode(n) {
+	return getUntaintedMethod("Node", n, "getRootNode")();
+}
+function host(n) {
+	if (!n || !("host" in n)) return null;
+	return getUntaintedAccessor("ShadowRoot", n, "host");
+}
+function styleSheets(n) {
+	return n.styleSheets;
+}
+function shadowRoot(n) {
+	if (!n || !("shadowRoot" in n)) return null;
+	return getUntaintedAccessor("Element", n, "shadowRoot");
+}
+function querySelector(n, selectors) {
+	return getUntaintedAccessor("Element", n, "querySelector")(selectors);
+}
+function querySelectorAll(n, selectors) {
+	return getUntaintedAccessor("Element", n, "querySelectorAll")(selectors);
+}
+function mutationObserverCtor() {
+	return [getUntaintedPrototype("MutationObserver").constructor, untaintedBaseIframeCleanup["MutationObserver"] ?? (() => {})];
+}
+var nowTimestamp = Date.now;
+if (!/* @__PURE__ */ /[1-9][0-9]{12}/.test(Date.now().toString())) nowTimestamp = () => (/* @__PURE__ */ new Date()).getTime();
+function patch(source, name, replacement) {
+	try {
+		if (!(name in source)) return () => {};
+		const original = source[name];
+		const wrapped = replacement(original);
+		if (typeof wrapped === "function") {
+			wrapped.prototype = wrapped.prototype || {};
+			Object.defineProperties(wrapped, { __rrweb_original__: {
+				enumerable: false,
+				value: original
+			} });
+		}
+		source[name] = wrapped;
+		return () => {
+			source[name] = original;
+		};
+	} catch {
+		return () => {};
+	}
+}
+var index = {
+	ownerDocument,
+	childNodes,
+	parentNode,
+	parentElement,
+	textContent,
+	contains,
+	getRootNode,
+	host,
+	styleSheets,
+	shadowRoot,
+	querySelector,
+	querySelectorAll,
+	nowTimestamp,
+	mutationObserverCtor,
+	patch
+};
+function isElement(n) {
+	return n.nodeType === n.ELEMENT_NODE;
+}
+function isShadowRoot(n) {
+	const hostEl = n && "host" in n && "mode" in n && index.host(n) || null;
+	return Boolean(hostEl && "shadowRoot" in hostEl && index.shadowRoot(hostEl) === n);
+}
+function isNativeShadowDom(shadowRoot2) {
+	return Object.prototype.toString.call(shadowRoot2) === "[object ShadowRoot]";
+}
+function fixBrowserCompatibilityIssuesInCSS(cssText) {
+	if (cssText.includes(" background-clip: text;") && !cssText.includes(" -webkit-background-clip: text;")) cssText = cssText.replace(/\sbackground-clip:\s*text;/g, " -webkit-background-clip: text; background-clip: text;");
+	return cssText;
+}
+function escapeImportStatement(rule2) {
+	const { cssText } = rule2;
+	if (cssText.split("\"").length < 3) return cssText;
+	const statement = ["@import", `url(${JSON.stringify(rule2.href)})`];
+	if (rule2.layerName === "") statement.push(`layer`);
+	else if (rule2.layerName) statement.push(`layer(${rule2.layerName})`);
+	if (rule2.supportsText) statement.push(`supports(${rule2.supportsText})`);
+	if (rule2.media.length) statement.push(rule2.media.mediaText);
+	return statement.join(" ") + ";";
+}
+function stringifyStylesheet(s) {
+	try {
+		const rules = s.rules || s.cssRules;
+		if (!rules) return null;
+		let sheetHref = s.href;
+		if (!sheetHref && s.ownerNode) sheetHref = s.ownerNode.baseURI;
+		return fixBrowserCompatibilityIssuesInCSS(Array.from(rules, (rule2) => stringifyRule(rule2, sheetHref)).join(""));
+	} catch (error) {
+		return null;
+	}
+}
+function stringifyRule(rule2, sheetHref) {
+	if (isCSSImportRule(rule2)) {
+		let importStringified;
+		try {
+			importStringified = stringifyStylesheet(rule2.styleSheet) || escapeImportStatement(rule2);
+		} catch (error) {
+			importStringified = rule2.cssText;
+		}
+		if (rule2.styleSheet.href) return absolutifyURLs(importStringified, rule2.styleSheet.href);
+		return importStringified;
+	} else {
+		let ruleStringified = rule2.cssText;
+		if (isCSSStyleRule(rule2) && rule2.selectorText.includes(":")) ruleStringified = fixSafariColons(ruleStringified);
+		if (sheetHref) return absolutifyURLs(ruleStringified, sheetHref);
+		return ruleStringified;
+	}
+}
+function fixSafariColons(cssStringified) {
+	return cssStringified.replace(/(\[(?:[\w-]+)[^\\])(:(?:[\w-]+)\])/gm, "$1\\$2");
+}
+function isCSSImportRule(rule2) {
+	return "styleSheet" in rule2;
+}
+function isCSSStyleRule(rule2) {
+	return "selectorText" in rule2;
+}
+var Mirror = class {
+	constructor() {
+		__publicField(this, "idNodeMap", /* @__PURE__ */ new Map());
+		__publicField(this, "nodeMetaMap", /* @__PURE__ */ new WeakMap());
+	}
+	getId(n) {
+		var _a;
+		if (!n) return -1;
+		return ((_a = this.getMeta(n)) == null ? void 0 : _a.id) ?? -1;
+	}
+	getNode(id) {
+		return this.idNodeMap.get(id) || null;
+	}
+	getIds() {
+		return Array.from(this.idNodeMap.keys());
+	}
+	getMeta(n) {
+		return this.nodeMetaMap.get(n) || null;
+	}
+	removeNodeFromMap(n) {
+		const id = this.getId(n);
+		this.idNodeMap.delete(id);
+		if (n.childNodes) n.childNodes.forEach((childNode) => this.removeNodeFromMap(childNode));
+	}
+	has(id) {
+		return this.idNodeMap.has(id);
+	}
+	hasNode(node2) {
+		return this.nodeMetaMap.has(node2);
+	}
+	add(n, meta) {
+		const id = meta.id;
+		this.idNodeMap.set(id, n);
+		this.nodeMetaMap.set(n, meta);
+	}
+	replace(id, n) {
+		const oldNode = this.getNode(id);
+		if (oldNode) {
+			const meta = this.nodeMetaMap.get(oldNode);
+			if (meta) this.nodeMetaMap.set(n, meta);
+		}
+		this.idNodeMap.set(id, n);
+	}
+	reset() {
+		this.idNodeMap = /* @__PURE__ */ new Map();
+		this.nodeMetaMap = /* @__PURE__ */ new WeakMap();
+	}
+};
+function createMirror() {
+	return new Mirror();
+}
+function maskInputValue({ element, maskInputOptions, tagName, type, value, maskInputFn }) {
+	let text = value || "";
+	const actualType = type && toLowerCase(type);
+	if (maskInputOptions[tagName.toLowerCase()] || actualType && maskInputOptions[actualType]) if (maskInputFn) text = maskInputFn(text, element);
+	else text = "*".repeat(text.length);
+	return text;
+}
+function toLowerCase(str) {
+	return str.toLowerCase();
+}
+var ORIGINAL_ATTRIBUTE_NAME = "__rrweb_original__";
+function is2DCanvasBlank(canvas) {
+	const ctx = canvas.getContext("2d");
+	if (!ctx) return true;
+	const chunkSize = 50;
+	for (let x = 0; x < canvas.width; x += chunkSize) for (let y = 0; y < canvas.height; y += chunkSize) {
+		const getImageData = ctx.getImageData;
+		const originalGetImageData = ORIGINAL_ATTRIBUTE_NAME in getImageData ? getImageData[ORIGINAL_ATTRIBUTE_NAME] : getImageData;
+		if (new Uint32Array(originalGetImageData.call(ctx, x, y, Math.min(chunkSize, canvas.width - x), Math.min(chunkSize, canvas.height - y)).data.buffer).some((pixel) => pixel !== 0)) return false;
+	}
+	return true;
+}
+function isNodeMetaEqual(a, b) {
+	if (!a || !b || a.type !== b.type) return false;
+	if (a.type === NodeType.Document) return a.compatMode === b.compatMode;
+	else if (a.type === NodeType.DocumentType) return a.name === b.name && a.publicId === b.publicId && a.systemId === b.systemId;
+	else if (a.type === NodeType.Comment || a.type === NodeType.Text || a.type === NodeType.CDATA) return a.textContent === b.textContent;
+	else if (a.type === NodeType.Element) return a.tagName === b.tagName && JSON.stringify(a.attributes) === JSON.stringify(b.attributes) && a.isSVG === b.isSVG && a.needBlock === b.needBlock;
+	return false;
+}
+function getInputType(element) {
+	const type = element.type;
+	return element.hasAttribute("data-rr-is-password") ? "password" : type ? toLowerCase(type) : null;
+}
+function extractFileExtension(path, baseURL) {
+	let url;
+	try {
+		url = new URL(path, baseURL ?? window.location.href);
+	} catch (err) {
+		return null;
+	}
+	const match = url.pathname.match(/\.([0-9a-z]+)(?:$)/i);
+	return (match == null ? void 0 : match[1]) ?? null;
+}
+function extractOrigin(url) {
+	let origin = "";
+	if (url.indexOf("//") > -1) origin = url.split("/").slice(0, 3).join("/");
+	else origin = url.split("/")[0];
+	origin = origin.split("?")[0];
+	return origin;
+}
+var URL_IN_CSS_REF = /url\((?:(')([^']*)'|(")(.*?)"|([^)]*))\)/gm;
+var URL_PROTOCOL_MATCH = /^(?:[a-z+]+:)?\/\//i;
+var URL_WWW_MATCH = /^www\..*/i;
+var DATA_URI = /^(data:)([^,]*),(.*)/i;
+function absolutifyURLs(cssText, href) {
+	return (cssText || "").replace(URL_IN_CSS_REF, (origin, quote1, path1, quote2, path2, path3) => {
+		const filePath = path1 || path2 || path3;
+		const maybeQuote = quote1 || quote2 || "";
+		if (!filePath) return origin;
+		if (URL_PROTOCOL_MATCH.test(filePath) || URL_WWW_MATCH.test(filePath)) return `url(${maybeQuote}${filePath}${maybeQuote})`;
+		if (DATA_URI.test(filePath)) return `url(${maybeQuote}${filePath}${maybeQuote})`;
+		if (filePath[0] === "/") return `url(${maybeQuote}${extractOrigin(href) + filePath}${maybeQuote})`;
+		const stack = href.split("/");
+		const parts = filePath.split("/");
+		stack.pop();
+		for (const part of parts) if (part === ".") continue;
+		else if (part === "..") stack.pop();
+		else stack.push(part);
+		return `url(${maybeQuote}${stack.join("/")}${maybeQuote})`;
+	});
+}
+function normalizeCssString(cssText, _testNoPxNorm = false) {
+	if (_testNoPxNorm) return cssText.replace(/(\/\*[^*]*\*\/)|[\s;]/g, "");
+	else return cssText.replace(/(\/\*[^*]*\*\/)|[\s;]/g, "").replace(/0px/g, "0");
+}
+function splitCssText(cssText, style, _testNoPxNorm = false) {
+	const childNodes2 = Array.from(style.childNodes);
+	const splits = [];
+	let iterCount = 0;
+	if (childNodes2.length > 1 && cssText && typeof cssText === "string") {
+		let cssTextNorm = normalizeCssString(cssText, _testNoPxNorm);
+		const normFactor = cssTextNorm.length / cssText.length;
+		for (let i = 1; i < childNodes2.length; i++) if (childNodes2[i].textContent && typeof childNodes2[i].textContent === "string") {
+			const textContentNorm = normalizeCssString(childNodes2[i].textContent, _testNoPxNorm);
+			const jLimit = 100;
+			let j = 3;
+			for (; j < textContentNorm.length; j++) {
+				if (textContentNorm[j].match(/[a-zA-Z0-9]/) || textContentNorm.indexOf(textContentNorm.substring(0, j), 1) !== -1) continue;
+				break;
+			}
+			for (; j < textContentNorm.length; j++) {
+				let startSubstring = textContentNorm.substring(0, j);
+				let cssNormSplits = cssTextNorm.split(startSubstring);
+				let splitNorm = -1;
+				if (cssNormSplits.length === 2) splitNorm = cssNormSplits[0].length;
+				else if (cssNormSplits.length > 2 && cssNormSplits[0] === "" && childNodes2[i - 1].textContent !== "") splitNorm = cssTextNorm.indexOf(startSubstring, 1);
+				else if (cssNormSplits.length === 1) {
+					startSubstring = startSubstring.substring(0, startSubstring.length - 1);
+					cssNormSplits = cssTextNorm.split(startSubstring);
+					if (cssNormSplits.length <= 1) {
+						splits.push(cssText);
+						return splits;
+					}
+					j = jLimit + 1;
+				} else if (j === textContentNorm.length - 1) splitNorm = cssTextNorm.indexOf(startSubstring);
+				if (cssNormSplits.length >= 2 && j > jLimit) {
+					const prevTextContent = childNodes2[i - 1].textContent;
+					if (prevTextContent && typeof prevTextContent === "string") {
+						const prevMinLength = normalizeCssString(prevTextContent).length;
+						splitNorm = cssTextNorm.indexOf(startSubstring, prevMinLength);
+					}
+					if (splitNorm === -1) splitNorm = cssNormSplits[0].length;
+				}
+				if (splitNorm !== -1) {
+					let k = Math.floor(splitNorm / normFactor);
+					for (; k > 0 && k < cssText.length;) {
+						iterCount += 1;
+						if (iterCount > 50 * childNodes2.length) {
+							splits.push(cssText);
+							return splits;
+						}
+						const normPart = normalizeCssString(cssText.substring(0, k), _testNoPxNorm);
+						if (normPart.length === splitNorm) {
+							splits.push(cssText.substring(0, k));
+							cssText = cssText.substring(k);
+							cssTextNorm = cssTextNorm.substring(splitNorm);
+							break;
+						} else if (normPart.length < splitNorm) k += Math.max(1, Math.floor((splitNorm - normPart.length) / normFactor));
+						else k -= Math.max(1, Math.floor((normPart.length - splitNorm) * normFactor));
+					}
+					break;
+				}
+			}
+		}
+	}
+	splits.push(cssText);
+	return splits;
+}
+function markCssSplits(cssText, style) {
+	return splitCssText(cssText, style).join("/* rr_split */");
+}
+var _id = 1;
+var tagNameRegex = /* @__PURE__ */ new RegExp("[^a-z0-9-_:]");
+var IGNORED_NODE = -2;
+function genId() {
+	return _id++;
+}
+function getValidTagName(element) {
+	if (element instanceof HTMLFormElement) return "form";
+	const processedTagName = toLowerCase(element.tagName);
+	if (tagNameRegex.test(processedTagName)) return "div";
+	return processedTagName;
+}
+var canvasService;
+var canvasCtx;
+var SRCSET_NOT_SPACES = /^[^ \t\n\r\u000c]+/;
+var SRCSET_COMMAS_OR_SPACES = /^[, \t\n\r\u000c]+/;
+function getAbsoluteSrcsetString(doc, attributeValue) {
+	if (attributeValue.trim() === "") return attributeValue;
+	let pos = 0;
+	function collectCharacters(regEx) {
+		let chars;
+		const match = regEx.exec(attributeValue.substring(pos));
+		if (match) {
+			chars = match[0];
+			pos += chars.length;
+			return chars;
+		}
+		return "";
+	}
+	const output = [];
+	while (true) {
+		collectCharacters(SRCSET_COMMAS_OR_SPACES);
+		if (pos >= attributeValue.length) break;
+		let url = collectCharacters(SRCSET_NOT_SPACES);
+		if (url.slice(-1) === ",") {
+			url = absoluteToDoc(doc, url.substring(0, url.length - 1));
+			output.push(url);
+		} else {
+			let descriptorsStr = "";
+			url = absoluteToDoc(doc, url);
+			let inParens = false;
+			while (true) {
+				const c = attributeValue.charAt(pos);
+				if (c === "") {
+					output.push((url + descriptorsStr).trim());
+					break;
+				} else if (!inParens) {
+					if (c === ",") {
+						pos += 1;
+						output.push((url + descriptorsStr).trim());
+						break;
+					} else if (c === "(") inParens = true;
+				} else if (c === ")") inParens = false;
+				descriptorsStr += c;
+				pos += 1;
+			}
+		}
+	}
+	return output.join(", ");
+}
+var cachedDocument = /* @__PURE__ */ new WeakMap();
+function absoluteToDoc(doc, attributeValue) {
+	if (!attributeValue || attributeValue.trim() === "") return attributeValue;
+	return getHref(doc, attributeValue);
+}
+function isSVGElement(el) {
+	return Boolean(el.tagName === "svg" || el.ownerSVGElement);
+}
+function getHref(doc, customHref) {
+	let a = cachedDocument.get(doc);
+	if (!a) {
+		a = doc.createElement("a");
+		cachedDocument.set(doc, a);
+	}
+	if (!customHref) customHref = "";
+	else if (customHref.startsWith("blob:") || customHref.startsWith("data:")) return customHref;
+	a.setAttribute("href", customHref);
+	return a.href;
+}
+function transformAttribute(doc, tagName, name, value) {
+	if (!value) return value;
+	if (name === "src" || name === "href" && !(tagName === "use" && value[0] === "#")) return absoluteToDoc(doc, value);
+	else if (name === "xlink:href" && value[0] !== "#") return absoluteToDoc(doc, value);
+	else if (name === "background" && [
+		"table",
+		"td",
+		"th"
+	].includes(tagName)) return absoluteToDoc(doc, value);
+	else if (name === "srcset") return getAbsoluteSrcsetString(doc, value);
+	else if (name === "style") return absolutifyURLs(value, getHref(doc));
+	else if (tagName === "object" && name === "data") return absoluteToDoc(doc, value);
+	return value;
+}
+function ignoreAttribute(tagName, name, _value) {
+	return ["video", "audio"].includes(tagName) && name === "autoplay";
+}
+function _isBlockedElement(element, blockClass, blockSelector) {
+	try {
+		if (typeof blockClass === "string") {
+			if (element.classList.contains(blockClass)) return true;
+		} else for (let eIndex = element.classList.length; eIndex--;) {
+			const className = element.classList[eIndex];
+			if (blockClass.test(className)) return true;
+		}
+		if (blockSelector) return element.matches(blockSelector);
+	} catch (e) {}
+	return false;
+}
+function classMatchesRegex(node2, regex, checkAncestors) {
+	if (!node2) return false;
+	if (node2.nodeType !== node2.ELEMENT_NODE) {
+		if (!checkAncestors) return false;
+		return classMatchesRegex(index.parentNode(node2), regex, checkAncestors);
+	}
+	for (let eIndex = node2.classList.length; eIndex--;) {
+		const className = node2.classList[eIndex];
+		if (regex.test(className)) return true;
+	}
+	if (!checkAncestors) return false;
+	return classMatchesRegex(index.parentNode(node2), regex, checkAncestors);
+}
+function needMaskingText(node2, maskTextClass, maskTextSelector, checkAncestors) {
+	let el;
+	if (isElement(node2)) {
+		el = node2;
+		if (!index.childNodes(el).length) return false;
+	} else if (index.parentElement(node2) === null) return false;
+	else el = index.parentElement(node2);
+	try {
+		if (typeof maskTextClass === "string") {
+			if (checkAncestors) {
+				if (el.closest(`.${maskTextClass}`)) return true;
+			} else if (el.classList.contains(maskTextClass)) return true;
+		} else if (classMatchesRegex(el, maskTextClass, checkAncestors)) return true;
+		if (maskTextSelector) {
+			if (checkAncestors) {
+				if (el.closest(maskTextSelector)) return true;
+			} else if (el.matches(maskTextSelector)) return true;
+		}
+	} catch (e) {}
+	return false;
+}
+function onceIframeLoaded(iframeEl, listener, iframeLoadTimeout) {
+	const win = iframeEl.contentWindow;
+	if (!win) return;
+	let fired = false;
+	let readyState;
+	try {
+		readyState = win.document.readyState;
+	} catch (error) {
+		return;
+	}
+	if (readyState !== "complete") {
+		const timer = setTimeout(() => {
+			if (!fired) {
+				listener();
+				fired = true;
+			}
+		}, iframeLoadTimeout);
+		iframeEl.addEventListener("load", () => {
+			clearTimeout(timer);
+			fired = true;
+			listener();
+		});
+		return;
+	}
+	const blankUrl = "about:blank";
+	if (win.location.href !== blankUrl || iframeEl.src === blankUrl || iframeEl.src === "") {
+		setTimeout(listener, 0);
+		return iframeEl.addEventListener("load", listener);
+	}
+	iframeEl.addEventListener("load", listener);
+}
+function onceStylesheetLoaded(link, listener, styleSheetLoadTimeout) {
+	let fired = false;
+	let styleSheetLoaded;
+	try {
+		styleSheetLoaded = link.sheet;
+	} catch (error) {
+		return;
+	}
+	if (styleSheetLoaded) return;
+	const timer = setTimeout(() => {
+		if (!fired) {
+			listener();
+			fired = true;
+		}
+	}, styleSheetLoadTimeout);
+	link.addEventListener("load", () => {
+		clearTimeout(timer);
+		fired = true;
+		listener();
+	});
+}
+function serializeNode(n, options) {
+	const { doc, mirror, blockClass, blockSelector, needsMask, inlineStylesheet, maskInputOptions = {}, maskTextFn, maskInputFn, dataURLOptions = {}, inlineImages, recordCanvas, keepIframeSrcFn, newlyAddedElement = false, cssCaptured = false } = options;
+	const rootId = getRootId(doc, mirror);
+	switch (n.nodeType) {
+		case n.DOCUMENT_NODE: if (n.compatMode !== "CSS1Compat") return {
+			type: NodeType.Document,
+			childNodes: [],
+			compatMode: n.compatMode
+		};
+		else return {
+			type: NodeType.Document,
+			childNodes: []
+		};
+		case n.DOCUMENT_TYPE_NODE: return {
+			type: NodeType.DocumentType,
+			name: n.name,
+			publicId: n.publicId,
+			systemId: n.systemId,
+			rootId
+		};
+		case n.ELEMENT_NODE: return serializeElementNode(n, {
+			doc,
+			blockClass,
+			blockSelector,
+			inlineStylesheet,
+			maskInputOptions,
+			maskInputFn,
+			dataURLOptions,
+			inlineImages,
+			recordCanvas,
+			keepIframeSrcFn,
+			newlyAddedElement,
+			rootId
+		});
+		case n.TEXT_NODE: return serializeTextNode(n, {
+			doc,
+			needsMask,
+			maskTextFn,
+			rootId,
+			cssCaptured
+		});
+		case n.CDATA_SECTION_NODE: return {
+			type: NodeType.CDATA,
+			textContent: "",
+			rootId
+		};
+		case n.COMMENT_NODE: return {
+			type: NodeType.Comment,
+			textContent: index.textContent(n) || "",
+			rootId
+		};
+		default: return false;
+	}
+}
+function getRootId(doc, mirror) {
+	if (!mirror.hasNode(doc)) return void 0;
+	const docId = mirror.getId(doc);
+	return docId === 1 ? void 0 : docId;
+}
+function serializeTextNode(n, options) {
+	const { needsMask, maskTextFn, rootId, cssCaptured } = options;
+	const parent = index.parentNode(n);
+	const parentTagName = parent && parent.tagName;
+	let textContent2 = "";
+	const isStyle = parentTagName === "STYLE" ? true : void 0;
+	const isScript = parentTagName === "SCRIPT" ? true : void 0;
+	if (isScript) textContent2 = "SCRIPT_PLACEHOLDER";
+	else if (!cssCaptured) {
+		textContent2 = index.textContent(n);
+		if (isStyle && textContent2) textContent2 = absolutifyURLs(textContent2, getHref(options.doc));
+	}
+	if (!isStyle && !isScript && textContent2 && needsMask) textContent2 = maskTextFn ? maskTextFn(textContent2, index.parentElement(n)) : textContent2.replace(/[\S]/g, "*");
+	return {
+		type: NodeType.Text,
+		textContent: textContent2 || "",
+		rootId
+	};
+}
+function serializeElementNode(n, options) {
+	const { doc, blockClass, blockSelector, inlineStylesheet, maskInputOptions = {}, maskInputFn, dataURLOptions = {}, inlineImages, recordCanvas, keepIframeSrcFn, newlyAddedElement = false, rootId } = options;
+	const needBlock = _isBlockedElement(n, blockClass, blockSelector);
+	const tagName = getValidTagName(n);
+	let attributes = {};
+	const len = n.attributes.length;
+	for (let i = 0; i < len; i++) {
+		const attr = n.attributes[i];
+		if (!ignoreAttribute(tagName, attr.name, attr.value)) attributes[attr.name] = transformAttribute(doc, tagName, toLowerCase(attr.name), attr.value);
+	}
+	if (tagName === "link" && inlineStylesheet) {
+		const stylesheet = Array.from(doc.styleSheets).find((s) => {
+			return s.href === n.href;
+		});
+		let cssText = null;
+		if (stylesheet) cssText = stringifyStylesheet(stylesheet);
+		if (cssText) {
+			delete attributes.rel;
+			delete attributes.href;
+			attributes._cssText = cssText;
+		}
+	}
+	if (tagName === "style" && n.sheet) {
+		let cssText = stringifyStylesheet(n.sheet);
+		if (cssText) {
+			if (n.childNodes.length > 1) cssText = markCssSplits(cssText, n);
+			attributes._cssText = cssText;
+		}
+	}
+	if ([
+		"input",
+		"textarea",
+		"select"
+	].includes(tagName)) {
+		const value = n.value;
+		const checked = n.checked;
+		if (attributes.type !== "radio" && attributes.type !== "checkbox" && attributes.type !== "submit" && attributes.type !== "button" && value) attributes.value = maskInputValue({
+			element: n,
+			type: getInputType(n),
+			tagName,
+			value,
+			maskInputOptions,
+			maskInputFn
+		});
+		else if (checked) attributes.checked = checked;
+	}
+	if (tagName === "option") if (n.selected && !maskInputOptions["select"]) attributes.selected = true;
+	else delete attributes.selected;
+	if (tagName === "dialog" && n.open) attributes.rr_open_mode = n.matches("dialog:modal") ? "modal" : "non-modal";
+	if (tagName === "canvas" && recordCanvas) {
+		if (n.__context === "2d") {
+			if (!is2DCanvasBlank(n)) attributes.rr_dataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+		} else if (!("__context" in n)) {
+			const canvasDataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+			const blankCanvas = doc.createElement("canvas");
+			blankCanvas.width = n.width;
+			blankCanvas.height = n.height;
+			if (canvasDataURL !== blankCanvas.toDataURL(dataURLOptions.type, dataURLOptions.quality)) attributes.rr_dataURL = canvasDataURL;
+		}
+	}
+	if (tagName === "img" && inlineImages) {
+		if (!canvasService) {
+			canvasService = doc.createElement("canvas");
+			canvasCtx = canvasService.getContext("2d");
+		}
+		const image = n;
+		const imageSrc = image.currentSrc || image.getAttribute("src") || "<unknown-src>";
+		const priorCrossOrigin = image.crossOrigin;
+		const recordInlineImage = () => {
+			image.removeEventListener("load", recordInlineImage);
+			try {
+				canvasService.width = image.naturalWidth;
+				canvasService.height = image.naturalHeight;
+				canvasCtx.drawImage(image, 0, 0);
+				attributes.rr_dataURL = canvasService.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+			} catch (err) {
+				if (image.crossOrigin !== "anonymous") {
+					image.crossOrigin = "anonymous";
+					if (image.complete && image.naturalWidth !== 0) recordInlineImage();
+					else image.addEventListener("load", recordInlineImage);
+					return;
+				} else console.warn(`Cannot inline img src=${imageSrc}! Error: ${err}`);
+			}
+			if (image.crossOrigin === "anonymous") priorCrossOrigin ? attributes.crossOrigin = priorCrossOrigin : image.removeAttribute("crossorigin");
+		};
+		if (image.complete && image.naturalWidth !== 0) recordInlineImage();
+		else image.addEventListener("load", recordInlineImage);
+	}
+	if (["audio", "video"].includes(tagName)) {
+		const mediaAttributes = attributes;
+		mediaAttributes.rr_mediaState = n.paused ? "paused" : "played";
+		mediaAttributes.rr_mediaCurrentTime = n.currentTime;
+		mediaAttributes.rr_mediaPlaybackRate = n.playbackRate;
+		mediaAttributes.rr_mediaMuted = n.muted;
+		mediaAttributes.rr_mediaLoop = n.loop;
+		mediaAttributes.rr_mediaVolume = n.volume;
+	}
+	if (!newlyAddedElement) {
+		if (n.scrollLeft) attributes.rr_scrollLeft = n.scrollLeft;
+		if (n.scrollTop) attributes.rr_scrollTop = n.scrollTop;
+	}
+	if (needBlock) {
+		const { width, height } = n.getBoundingClientRect();
+		attributes = {
+			class: attributes.class,
+			rr_width: `${width}px`,
+			rr_height: `${height}px`
+		};
+	}
+	if (tagName === "iframe" && !keepIframeSrcFn(attributes.src)) {
+		if (!n.contentDocument) attributes.rr_src = attributes.src;
+		delete attributes.src;
+	}
+	let isCustomElement;
+	try {
+		if (customElements.get(tagName)) isCustomElement = true;
+	} catch (e) {}
+	return {
+		type: NodeType.Element,
+		tagName,
+		attributes,
+		childNodes: [],
+		isSVG: isSVGElement(n) || void 0,
+		needBlock,
+		rootId,
+		isCustom: isCustomElement
+	};
+}
+function lowerIfExists(maybeAttr) {
+	if (maybeAttr === void 0 || maybeAttr === null) return "";
+	else return maybeAttr.toLowerCase();
+}
+function slimDOMDefaults(_slimDOMOptions) {
+	if (_slimDOMOptions === true || _slimDOMOptions === "all") return {
+		script: true,
+		comment: true,
+		headFavicon: true,
+		headWhitespace: true,
+		headMetaSocial: true,
+		headMetaRobots: true,
+		headMetaHttpEquiv: true,
+		headMetaVerification: true,
+		headMetaAuthorship: _slimDOMOptions === "all",
+		headMetaDescKeywords: _slimDOMOptions === "all",
+		headTitleMutations: _slimDOMOptions === "all"
+	};
+	else if (_slimDOMOptions) return _slimDOMOptions;
+	return {};
+}
+function slimDOMExcluded(sn, slimDOMOptions) {
+	if (slimDOMOptions.comment && sn.type === NodeType.Comment) return true;
+	else if (sn.type === NodeType.Element) {
+		if (slimDOMOptions.script && (sn.tagName === "script" || sn.tagName === "link" && (sn.attributes.rel === "preload" && sn.attributes.as === "script" || sn.attributes.rel === "modulepreload") || sn.tagName === "link" && sn.attributes.rel === "prefetch" && typeof sn.attributes.href === "string" && extractFileExtension(sn.attributes.href) === "js")) return true;
+		else if (slimDOMOptions.headFavicon && (sn.tagName === "link" && sn.attributes.rel === "shortcut icon" || sn.tagName === "meta" && (lowerIfExists(sn.attributes.name).match(/^msapplication-tile(image|color)$/) || lowerIfExists(sn.attributes.name) === "application-name" || lowerIfExists(sn.attributes.rel) === "icon" || lowerIfExists(sn.attributes.rel) === "apple-touch-icon" || lowerIfExists(sn.attributes.rel) === "shortcut icon"))) return true;
+		else if (sn.tagName === "meta") {
+			if (slimDOMOptions.headMetaDescKeywords && lowerIfExists(sn.attributes.name).match(/^description|keywords$/)) return true;
+			else if (slimDOMOptions.headMetaSocial && (lowerIfExists(sn.attributes.property).match(/^(og|twitter|fb):/) || lowerIfExists(sn.attributes.name).match(/^(og|twitter):/) || lowerIfExists(sn.attributes.name) === "pinterest")) return true;
+			else if (slimDOMOptions.headMetaRobots && (lowerIfExists(sn.attributes.name) === "robots" || lowerIfExists(sn.attributes.name) === "googlebot" || lowerIfExists(sn.attributes.name) === "bingbot")) return true;
+			else if (slimDOMOptions.headMetaHttpEquiv && sn.attributes["http-equiv"] !== void 0) return true;
+			else if (slimDOMOptions.headMetaAuthorship && (lowerIfExists(sn.attributes.name) === "author" || lowerIfExists(sn.attributes.name) === "generator" || lowerIfExists(sn.attributes.name) === "framework" || lowerIfExists(sn.attributes.name) === "publisher" || lowerIfExists(sn.attributes.name) === "progid" || lowerIfExists(sn.attributes.property).match(/^article:/) || lowerIfExists(sn.attributes.property).match(/^product:/))) return true;
+			else if (slimDOMOptions.headMetaVerification && (lowerIfExists(sn.attributes.name) === "google-site-verification" || lowerIfExists(sn.attributes.name) === "yandex-verification" || lowerIfExists(sn.attributes.name) === "csrf-token" || lowerIfExists(sn.attributes.name) === "p:domain_verify" || lowerIfExists(sn.attributes.name) === "verify-v1" || lowerIfExists(sn.attributes.name) === "verification" || lowerIfExists(sn.attributes.name) === "shopify-checkout-api-token")) return true;
+		}
+	}
+	return false;
+}
+function serializeNodeWithId(n, options) {
+	const { doc, mirror, blockClass, blockSelector, maskTextClass, maskTextSelector, skipChild = false, inlineStylesheet = true, maskInputOptions = {}, maskTextFn, maskInputFn, slimDOMOptions, dataURLOptions = {}, inlineImages = false, recordCanvas = false, onSerialize, onIframeLoad, iframeLoadTimeout = 5e3, onStylesheetLoad, stylesheetLoadTimeout = 5e3, keepIframeSrcFn = () => false, newlyAddedElement = false, cssCaptured = false } = options;
+	let { needsMask } = options;
+	let { preserveWhiteSpace = true } = options;
+	if (!needsMask) needsMask = needMaskingText(n, maskTextClass, maskTextSelector, needsMask === void 0);
+	const _serializedNode = serializeNode(n, {
+		doc,
+		mirror,
+		blockClass,
+		blockSelector,
+		needsMask,
+		inlineStylesheet,
+		maskInputOptions,
+		maskTextFn,
+		maskInputFn,
+		dataURLOptions,
+		inlineImages,
+		recordCanvas,
+		keepIframeSrcFn,
+		newlyAddedElement,
+		cssCaptured
+	});
+	if (!_serializedNode) {
+		console.warn(n, "not serialized");
+		return null;
+	}
+	let id;
+	if (mirror.hasNode(n)) id = mirror.getId(n);
+	else if (slimDOMExcluded(_serializedNode, slimDOMOptions) || !preserveWhiteSpace && _serializedNode.type === NodeType.Text && !_serializedNode.textContent.replace(/^\s+|\s+$/gm, "").length) id = -2;
+	else id = genId();
+	const serializedNode = Object.assign(_serializedNode, { id });
+	mirror.add(n, serializedNode);
+	if (id === -2) return null;
+	if (onSerialize) onSerialize(n);
+	let recordChild = !skipChild;
+	if (serializedNode.type === NodeType.Element) {
+		recordChild = recordChild && !serializedNode.needBlock;
+		delete serializedNode.needBlock;
+		const shadowRootEl = index.shadowRoot(n);
+		if (shadowRootEl && isNativeShadowDom(shadowRootEl)) serializedNode.isShadowHost = true;
+	}
+	if ((serializedNode.type === NodeType.Document || serializedNode.type === NodeType.Element) && recordChild) {
+		if (slimDOMOptions.headWhitespace && serializedNode.type === NodeType.Element && serializedNode.tagName === "head") preserveWhiteSpace = false;
+		const bypassOptions = {
+			doc,
+			mirror,
+			blockClass,
+			blockSelector,
+			needsMask,
+			maskTextClass,
+			maskTextSelector,
+			skipChild,
+			inlineStylesheet,
+			maskInputOptions,
+			maskTextFn,
+			maskInputFn,
+			slimDOMOptions,
+			dataURLOptions,
+			inlineImages,
+			recordCanvas,
+			preserveWhiteSpace,
+			onSerialize,
+			onIframeLoad,
+			iframeLoadTimeout,
+			onStylesheetLoad,
+			stylesheetLoadTimeout,
+			keepIframeSrcFn,
+			cssCaptured: false
+		};
+		if (serializedNode.type === NodeType.Element && serializedNode.tagName === "textarea" && serializedNode.attributes.value !== void 0);
+		else {
+			if (serializedNode.type === NodeType.Element && serializedNode.attributes._cssText !== void 0 && typeof serializedNode.attributes._cssText === "string") bypassOptions.cssCaptured = true;
+			for (const childN of Array.from(index.childNodes(n))) {
+				const serializedChildNode = serializeNodeWithId(childN, bypassOptions);
+				if (serializedChildNode) serializedNode.childNodes.push(serializedChildNode);
+			}
+		}
+		let shadowRootEl = null;
+		if (isElement(n) && (shadowRootEl = index.shadowRoot(n))) for (const childN of Array.from(index.childNodes(shadowRootEl))) {
+			const serializedChildNode = serializeNodeWithId(childN, bypassOptions);
+			if (serializedChildNode) {
+				isNativeShadowDom(shadowRootEl) && (serializedChildNode.isShadow = true);
+				serializedNode.childNodes.push(serializedChildNode);
+			}
+		}
+	}
+	const parent = index.parentNode(n);
+	if (parent && isShadowRoot(parent) && isNativeShadowDom(parent)) serializedNode.isShadow = true;
+	if (serializedNode.type === NodeType.Element && serializedNode.tagName === "iframe") onceIframeLoaded(n, () => {
+		const iframeDoc = n.contentDocument;
+		if (iframeDoc && onIframeLoad) {
+			const serializedIframeNode = serializeNodeWithId(iframeDoc, {
+				doc: iframeDoc,
+				mirror,
+				blockClass,
+				blockSelector,
+				needsMask,
+				maskTextClass,
+				maskTextSelector,
+				skipChild: false,
+				inlineStylesheet,
+				maskInputOptions,
+				maskTextFn,
+				maskInputFn,
+				slimDOMOptions,
+				dataURLOptions,
+				inlineImages,
+				recordCanvas,
+				preserveWhiteSpace,
+				onSerialize,
+				onIframeLoad,
+				iframeLoadTimeout,
+				onStylesheetLoad,
+				stylesheetLoadTimeout,
+				keepIframeSrcFn
+			});
+			if (serializedIframeNode) onIframeLoad(n, serializedIframeNode);
+		}
+	}, iframeLoadTimeout);
+	if (serializedNode.type === NodeType.Element && serializedNode.tagName === "link" && typeof serializedNode.attributes.rel === "string" && (serializedNode.attributes.rel === "stylesheet" || serializedNode.attributes.rel === "preload" && typeof serializedNode.attributes.href === "string" && extractFileExtension(serializedNode.attributes.href) === "css")) onceStylesheetLoaded(n, () => {
+		if (onStylesheetLoad) {
+			const serializedLinkNode = serializeNodeWithId(n, {
+				doc,
+				mirror,
+				blockClass,
+				blockSelector,
+				needsMask,
+				maskTextClass,
+				maskTextSelector,
+				skipChild: false,
+				inlineStylesheet,
+				maskInputOptions,
+				maskTextFn,
+				maskInputFn,
+				slimDOMOptions,
+				dataURLOptions,
+				inlineImages,
+				recordCanvas,
+				preserveWhiteSpace,
+				onSerialize,
+				onIframeLoad,
+				iframeLoadTimeout,
+				onStylesheetLoad,
+				stylesheetLoadTimeout,
+				keepIframeSrcFn
+			});
+			if (serializedLinkNode) onStylesheetLoad(n, serializedLinkNode);
+		}
+	}, stylesheetLoadTimeout);
+	return serializedNode;
+}
+function snapshot(n, options) {
+	const { mirror = new Mirror(), blockClass = "rr-block", blockSelector = null, maskTextClass = "rr-mask", maskTextSelector = null, inlineStylesheet = true, inlineImages = false, recordCanvas = false, maskAllInputs = false, maskTextFn, maskInputFn, slimDOM = false, dataURLOptions, preserveWhiteSpace, onSerialize, onIframeLoad, iframeLoadTimeout, onStylesheetLoad, stylesheetLoadTimeout, keepIframeSrcFn = () => false } = options || {};
+	return serializeNodeWithId(n, {
+		doc: n,
+		mirror,
+		blockClass,
+		blockSelector,
+		maskTextClass,
+		maskTextSelector,
+		skipChild: false,
+		inlineStylesheet,
+		maskInputOptions: maskAllInputs === true ? {
+			color: true,
+			date: true,
+			"datetime-local": true,
+			email: true,
+			month: true,
+			number: true,
+			range: true,
+			search: true,
+			tel: true,
+			text: true,
+			time: true,
+			url: true,
+			week: true,
+			textarea: true,
+			select: true,
+			password: true
+		} : maskAllInputs === false ? { password: true } : maskAllInputs,
+		maskTextFn,
+		maskInputFn,
+		slimDOMOptions: slimDOMDefaults(slimDOM),
+		dataURLOptions,
+		inlineImages,
+		recordCanvas,
+		preserveWhiteSpace,
+		onSerialize,
+		onIframeLoad,
+		iframeLoadTimeout,
+		onStylesheetLoad,
+		stylesheetLoadTimeout,
+		keepIframeSrcFn,
+		newlyAddedElement: false
+	});
+}
+function visitSnapshot(node2, onVisit) {
+	function walk(current) {
+		onVisit(current);
+		if (current.type === NodeType.Document || current.type === NodeType.Element) current.childNodes.forEach(walk);
+	}
+	walk(node2);
+}
+function cleanupSnapshot() {
+	_id = 1;
+}
+var MEDIA_SELECTOR_GLOBAL = new RegExp(/(max|min)-device-(width|height)/.source, "g");
+var mediaSelectorPlugin = {
+	postcssPlugin: "postcss-custom-selectors",
+	prepare() {
+		return {
+			postcssPlugin: "postcss-custom-selectors",
+			AtRule: function(atrule) {
+				if (atrule.params.match(MEDIA_SELECTOR_GLOBAL)) atrule.params = atrule.params.replace(MEDIA_SELECTOR_GLOBAL, "$1-$2");
+			}
+		};
+	}
+};
+var pseudoClassPlugin = {
+	postcssPlugin: "postcss-hover-classes",
+	prepare: function() {
+		const fixed = [];
+		return { Rule: function(rule2) {
+			if (fixed.indexOf(rule2) !== -1) return;
+			fixed.push(rule2);
+			rule2.selectors.forEach(function(selector) {
+				if (selector.includes(":hover")) rule2.selector += ",\n" + selector.replace(/:hover/g, ".\\:hover");
+				if (selector.includes(":active")) rule2.selector += ",\n" + selector.replace(/:active/g, ".\\:active");
+				if (selector.includes(":focus-visible")) rule2.selector += ",\n" + selector.replace(/:focus-visible/g, ".\\:focus-visible");
+				if (selector.includes(":focus-within")) rule2.selector += ",\n" + selector.replace(/:focus-within/g, ".\\:focus-within");
+				if (/:focus(?![-\w])/.test(selector)) rule2.selector += ",\n" + selector.replace(/:focus(?![-\w])/g, ".\\:focus");
+			});
+		} };
+	}
+};
+function getDefaultExportFromCjs(x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+function getAugmentedNamespace(n) {
+	if (n.__esModule) return n;
+	var f = n.default;
+	if (typeof f == "function") {
+		var a = function a2() {
+			if (this instanceof a2) return Reflect.construct(f, arguments, this.constructor);
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+	} else a = {};
+	Object.defineProperty(a, "__esModule", { value: true });
+	Object.keys(n).forEach(function(k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function() {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+var picocolors_browser = { exports: {} };
+var hasRequiredPicocolors_browser;
+function requirePicocolors_browser() {
+	if (hasRequiredPicocolors_browser) return picocolors_browser.exports;
+	hasRequiredPicocolors_browser = 1;
+	var x = String;
+	var create = function() {
+		return {
+			isColorSupported: false,
+			reset: x,
+			bold: x,
+			dim: x,
+			italic: x,
+			underline: x,
+			inverse: x,
+			hidden: x,
+			strikethrough: x,
+			black: x,
+			red: x,
+			green: x,
+			yellow: x,
+			blue: x,
+			magenta: x,
+			cyan: x,
+			white: x,
+			gray: x,
+			bgBlack: x,
+			bgRed: x,
+			bgGreen: x,
+			bgYellow: x,
+			bgBlue: x,
+			bgMagenta: x,
+			bgCyan: x,
+			bgWhite: x
+		};
+	};
+	picocolors_browser.exports = create();
+	picocolors_browser.exports.createColors = create;
+	return picocolors_browser.exports;
+}
+var require$$2 = /* @__PURE__ */ getAugmentedNamespace(/* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+	__proto__: null,
+	default: {}
+}, Symbol.toStringTag, { value: "Module" })));
+var cssSyntaxError;
+var hasRequiredCssSyntaxError;
+function requireCssSyntaxError() {
+	if (hasRequiredCssSyntaxError) return cssSyntaxError;
+	hasRequiredCssSyntaxError = 1;
+	let pico = /* @__PURE__ */ requirePicocolors_browser();
+	let terminalHighlight = require$$2;
+	class CssSyntaxError extends Error {
+		constructor(message, line, column, source, file, plugin) {
+			super(message);
+			this.name = "CssSyntaxError";
+			this.reason = message;
+			if (file) this.file = file;
+			if (source) this.source = source;
+			if (plugin) this.plugin = plugin;
+			if (typeof line !== "undefined" && typeof column !== "undefined") if (typeof line === "number") {
+				this.line = line;
+				this.column = column;
+			} else {
+				this.line = line.line;
+				this.column = line.column;
+				this.endLine = column.line;
+				this.endColumn = column.column;
+			}
+			this.setMessage();
+			if (Error.captureStackTrace) Error.captureStackTrace(this, CssSyntaxError);
+		}
+		setMessage() {
+			this.message = this.plugin ? this.plugin + ": " : "";
+			this.message += this.file ? this.file : "<css input>";
+			if (typeof this.line !== "undefined") this.message += ":" + this.line + ":" + this.column;
+			this.message += ": " + this.reason;
+		}
+		showSourceCode(color) {
+			if (!this.source) return "";
+			let css = this.source;
+			if (color == null) color = pico.isColorSupported;
+			if (terminalHighlight) {
+				if (color) css = terminalHighlight(css);
+			}
+			let lines = css.split(/\r?\n/);
+			let start = Math.max(this.line - 3, 0);
+			let end = Math.min(this.line + 2, lines.length);
+			let maxWidth = String(end).length;
+			let mark, aside;
+			if (color) {
+				let { bold, gray, red } = pico.createColors(true);
+				mark = (text) => bold(red(text));
+				aside = (text) => gray(text);
+			} else mark = aside = (str) => str;
+			return lines.slice(start, end).map((line, index2) => {
+				let number = start + 1 + index2;
+				let gutter = " " + (" " + number).slice(-maxWidth) + " | ";
+				if (number === this.line) {
+					let spacing = aside(gutter.replace(/\d/g, " ")) + line.slice(0, this.column - 1).replace(/[^\t]/g, " ");
+					return mark(">") + aside(gutter) + line + "\n " + spacing + mark("^");
+				}
+				return " " + aside(gutter) + line;
+			}).join("\n");
+		}
+		toString() {
+			let code = this.showSourceCode();
+			if (code) code = "\n\n" + code + "\n";
+			return this.name + ": " + this.message + code;
+		}
+	}
+	cssSyntaxError = CssSyntaxError;
+	CssSyntaxError.default = CssSyntaxError;
+	return cssSyntaxError;
+}
+var symbols = {};
+var hasRequiredSymbols;
+function requireSymbols() {
+	if (hasRequiredSymbols) return symbols;
+	hasRequiredSymbols = 1;
+	symbols.isClean = Symbol("isClean");
+	symbols.my = Symbol("my");
+	return symbols;
+}
+var stringifier;
+var hasRequiredStringifier;
+function requireStringifier() {
+	if (hasRequiredStringifier) return stringifier;
+	hasRequiredStringifier = 1;
+	const DEFAULT_RAW = {
+		after: "\n",
+		beforeClose: "\n",
+		beforeComment: "\n",
+		beforeDecl: "\n",
+		beforeOpen: " ",
+		beforeRule: "\n",
+		colon: ": ",
+		commentLeft: " ",
+		commentRight: " ",
+		emptyBody: "",
+		indent: "    ",
+		semicolon: false
+	};
+	function capitalize(str) {
+		return str[0].toUpperCase() + str.slice(1);
+	}
+	class Stringifier {
+		constructor(builder) {
+			this.builder = builder;
+		}
+		atrule(node2, semicolon) {
+			let name = "@" + node2.name;
+			let params = node2.params ? this.rawValue(node2, "params") : "";
+			if (typeof node2.raws.afterName !== "undefined") name += node2.raws.afterName;
+			else if (params) name += " ";
+			if (node2.nodes) this.block(node2, name + params);
+			else {
+				let end = (node2.raws.between || "") + (semicolon ? ";" : "");
+				this.builder(name + params + end, node2);
+			}
+		}
+		beforeAfter(node2, detect) {
+			let value;
+			if (node2.type === "decl") value = this.raw(node2, null, "beforeDecl");
+			else if (node2.type === "comment") value = this.raw(node2, null, "beforeComment");
+			else if (detect === "before") value = this.raw(node2, null, "beforeRule");
+			else value = this.raw(node2, null, "beforeClose");
+			let buf = node2.parent;
+			let depth = 0;
+			while (buf && buf.type !== "root") {
+				depth += 1;
+				buf = buf.parent;
+			}
+			if (value.includes("\n")) {
+				let indent = this.raw(node2, null, "indent");
+				if (indent.length) for (let step = 0; step < depth; step++) value += indent;
+			}
+			return value;
+		}
+		block(node2, start) {
+			let between = this.raw(node2, "between", "beforeOpen");
+			this.builder(start + between + "{", node2, "start");
+			let after;
+			if (node2.nodes && node2.nodes.length) {
+				this.body(node2);
+				after = this.raw(node2, "after");
+			} else after = this.raw(node2, "after", "emptyBody");
+			if (after) this.builder(after);
+			this.builder("}", node2, "end");
+		}
+		body(node2) {
+			let last = node2.nodes.length - 1;
+			while (last > 0) {
+				if (node2.nodes[last].type !== "comment") break;
+				last -= 1;
+			}
+			let semicolon = this.raw(node2, "semicolon");
+			for (let i = 0; i < node2.nodes.length; i++) {
+				let child = node2.nodes[i];
+				let before = this.raw(child, "before");
+				if (before) this.builder(before);
+				this.stringify(child, last !== i || semicolon);
+			}
+		}
+		comment(node2) {
+			let left = this.raw(node2, "left", "commentLeft");
+			let right = this.raw(node2, "right", "commentRight");
+			this.builder("/*" + left + node2.text + right + "*/", node2);
+		}
+		decl(node2, semicolon) {
+			let between = this.raw(node2, "between", "colon");
+			let string = node2.prop + between + this.rawValue(node2, "value");
+			if (node2.important) string += node2.raws.important || " !important";
+			if (semicolon) string += ";";
+			this.builder(string, node2);
+		}
+		document(node2) {
+			this.body(node2);
+		}
+		raw(node2, own, detect) {
+			let value;
+			if (!detect) detect = own;
+			if (own) {
+				value = node2.raws[own];
+				if (typeof value !== "undefined") return value;
+			}
+			let parent = node2.parent;
+			if (detect === "before") {
+				if (!parent || parent.type === "root" && parent.first === node2) return "";
+				if (parent && parent.type === "document") return "";
+			}
+			if (!parent) return DEFAULT_RAW[detect];
+			let root2 = node2.root();
+			if (!root2.rawCache) root2.rawCache = {};
+			if (typeof root2.rawCache[detect] !== "undefined") return root2.rawCache[detect];
+			if (detect === "before" || detect === "after") return this.beforeAfter(node2, detect);
+			else {
+				let method = "raw" + capitalize(detect);
+				if (this[method]) value = this[method](root2, node2);
+				else root2.walk((i) => {
+					value = i.raws[own];
+					if (typeof value !== "undefined") return false;
+				});
+			}
+			if (typeof value === "undefined") value = DEFAULT_RAW[detect];
+			root2.rawCache[detect] = value;
+			return value;
+		}
+		rawBeforeClose(root2) {
+			let value;
+			root2.walk((i) => {
+				if (i.nodes && i.nodes.length > 0) {
+					if (typeof i.raws.after !== "undefined") {
+						value = i.raws.after;
+						if (value.includes("\n")) value = value.replace(/[^\n]+$/, "");
+						return false;
+					}
+				}
+			});
+			if (value) value = value.replace(/\S/g, "");
+			return value;
+		}
+		rawBeforeComment(root2, node2) {
+			let value;
+			root2.walkComments((i) => {
+				if (typeof i.raws.before !== "undefined") {
+					value = i.raws.before;
+					if (value.includes("\n")) value = value.replace(/[^\n]+$/, "");
+					return false;
+				}
+			});
+			if (typeof value === "undefined") value = this.raw(node2, null, "beforeDecl");
+			else if (value) value = value.replace(/\S/g, "");
+			return value;
+		}
+		rawBeforeDecl(root2, node2) {
+			let value;
+			root2.walkDecls((i) => {
+				if (typeof i.raws.before !== "undefined") {
+					value = i.raws.before;
+					if (value.includes("\n")) value = value.replace(/[^\n]+$/, "");
+					return false;
+				}
+			});
+			if (typeof value === "undefined") value = this.raw(node2, null, "beforeRule");
+			else if (value) value = value.replace(/\S/g, "");
+			return value;
+		}
+		rawBeforeOpen(root2) {
+			let value;
+			root2.walk((i) => {
+				if (i.type !== "decl") {
+					value = i.raws.between;
+					if (typeof value !== "undefined") return false;
+				}
+			});
+			return value;
+		}
+		rawBeforeRule(root2) {
+			let value;
+			root2.walk((i) => {
+				if (i.nodes && (i.parent !== root2 || root2.first !== i)) {
+					if (typeof i.raws.before !== "undefined") {
+						value = i.raws.before;
+						if (value.includes("\n")) value = value.replace(/[^\n]+$/, "");
+						return false;
+					}
+				}
+			});
+			if (value) value = value.replace(/\S/g, "");
+			return value;
+		}
+		rawColon(root2) {
+			let value;
+			root2.walkDecls((i) => {
+				if (typeof i.raws.between !== "undefined") {
+					value = i.raws.between.replace(/[^\s:]/g, "");
+					return false;
+				}
+			});
+			return value;
+		}
+		rawEmptyBody(root2) {
+			let value;
+			root2.walk((i) => {
+				if (i.nodes && i.nodes.length === 0) {
+					value = i.raws.after;
+					if (typeof value !== "undefined") return false;
+				}
+			});
+			return value;
+		}
+		rawIndent(root2) {
+			if (root2.raws.indent) return root2.raws.indent;
+			let value;
+			root2.walk((i) => {
+				let p = i.parent;
+				if (p && p !== root2 && p.parent && p.parent === root2) {
+					if (typeof i.raws.before !== "undefined") {
+						let parts = i.raws.before.split("\n");
+						value = parts[parts.length - 1];
+						value = value.replace(/\S/g, "");
+						return false;
+					}
+				}
+			});
+			return value;
+		}
+		rawSemicolon(root2) {
+			let value;
+			root2.walk((i) => {
+				if (i.nodes && i.nodes.length && i.last.type === "decl") {
+					value = i.raws.semicolon;
+					if (typeof value !== "undefined") return false;
+				}
+			});
+			return value;
+		}
+		rawValue(node2, prop) {
+			let value = node2[prop];
+			let raw = node2.raws[prop];
+			if (raw && raw.value === value) return raw.raw;
+			return value;
+		}
+		root(node2) {
+			this.body(node2);
+			if (node2.raws.after) this.builder(node2.raws.after);
+		}
+		rule(node2) {
+			this.block(node2, this.rawValue(node2, "selector"));
+			if (node2.raws.ownSemicolon) this.builder(node2.raws.ownSemicolon, node2, "end");
+		}
+		stringify(node2, semicolon) {
+			if (!this[node2.type]) throw new Error("Unknown AST node type " + node2.type + ". Maybe you need to change PostCSS stringifier.");
+			this[node2.type](node2, semicolon);
+		}
+	}
+	stringifier = Stringifier;
+	Stringifier.default = Stringifier;
+	return stringifier;
+}
+var stringify_1;
+var hasRequiredStringify;
+function requireStringify() {
+	if (hasRequiredStringify) return stringify_1;
+	hasRequiredStringify = 1;
+	let Stringifier = requireStringifier();
+	function stringify(node2, builder) {
+		new Stringifier(builder).stringify(node2);
+	}
+	stringify_1 = stringify;
+	stringify.default = stringify;
+	return stringify_1;
+}
+var node;
+var hasRequiredNode;
+function requireNode() {
+	if (hasRequiredNode) return node;
+	hasRequiredNode = 1;
+	let { isClean, my } = requireSymbols();
+	let CssSyntaxError = requireCssSyntaxError();
+	let Stringifier = requireStringifier();
+	let stringify = requireStringify();
+	function cloneNode(obj, parent) {
+		let cloned = new obj.constructor();
+		for (let i in obj) {
+			if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
+			if (i === "proxyCache") continue;
+			let value = obj[i];
+			let type = typeof value;
+			if (i === "parent" && type === "object") {
+				if (parent) cloned[i] = parent;
+			} else if (i === "source") cloned[i] = value;
+			else if (Array.isArray(value)) cloned[i] = value.map((j) => cloneNode(j, cloned));
+			else {
+				if (type === "object" && value !== null) value = cloneNode(value);
+				cloned[i] = value;
+			}
+		}
+		return cloned;
+	}
+	class Node {
+		constructor(defaults = {}) {
+			this.raws = {};
+			this[isClean] = false;
+			this[my] = true;
+			for (let name in defaults) if (name === "nodes") {
+				this.nodes = [];
+				for (let node2 of defaults[name]) if (typeof node2.clone === "function") this.append(node2.clone());
+				else this.append(node2);
+			} else this[name] = defaults[name];
+		}
+		addToError(error) {
+			error.postcssNode = this;
+			if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
+				let s = this.source;
+				error.stack = error.stack.replace(/\n\s{4}at /, `$&${s.input.from}:${s.start.line}:${s.start.column}$&`);
+			}
+			return error;
+		}
+		after(add) {
+			this.parent.insertAfter(this, add);
+			return this;
+		}
+		assign(overrides = {}) {
+			for (let name in overrides) this[name] = overrides[name];
+			return this;
+		}
+		before(add) {
+			this.parent.insertBefore(this, add);
+			return this;
+		}
+		cleanRaws(keepBetween) {
+			delete this.raws.before;
+			delete this.raws.after;
+			if (!keepBetween) delete this.raws.between;
+		}
+		clone(overrides = {}) {
+			let cloned = cloneNode(this);
+			for (let name in overrides) cloned[name] = overrides[name];
+			return cloned;
+		}
+		cloneAfter(overrides = {}) {
+			let cloned = this.clone(overrides);
+			this.parent.insertAfter(this, cloned);
+			return cloned;
+		}
+		cloneBefore(overrides = {}) {
+			let cloned = this.clone(overrides);
+			this.parent.insertBefore(this, cloned);
+			return cloned;
+		}
+		error(message, opts = {}) {
+			if (this.source) {
+				let { end, start } = this.rangeBy(opts);
+				return this.source.input.error(message, {
+					column: start.column,
+					line: start.line
+				}, {
+					column: end.column,
+					line: end.line
+				}, opts);
+			}
+			return new CssSyntaxError(message);
+		}
+		getProxyProcessor() {
+			return {
+				get(node2, prop) {
+					if (prop === "proxyOf") return node2;
+					else if (prop === "root") return () => node2.root().toProxy();
+					else return node2[prop];
+				},
+				set(node2, prop, value) {
+					if (node2[prop] === value) return true;
+					node2[prop] = value;
+					if (prop === "prop" || prop === "value" || prop === "name" || prop === "params" || prop === "important" || prop === "text") node2.markDirty();
+					return true;
+				}
+			};
+		}
+		markDirty() {
+			if (this[isClean]) {
+				this[isClean] = false;
+				let next = this;
+				while (next = next.parent) next[isClean] = false;
+			}
+		}
+		next() {
+			if (!this.parent) return void 0;
+			let index2 = this.parent.index(this);
+			return this.parent.nodes[index2 + 1];
+		}
+		positionBy(opts, stringRepresentation) {
+			let pos = this.source.start;
+			if (opts.index) pos = this.positionInside(opts.index, stringRepresentation);
+			else if (opts.word) {
+				stringRepresentation = this.toString();
+				let index2 = stringRepresentation.indexOf(opts.word);
+				if (index2 !== -1) pos = this.positionInside(index2, stringRepresentation);
+			}
+			return pos;
+		}
+		positionInside(index2, stringRepresentation) {
+			let string = stringRepresentation || this.toString();
+			let column = this.source.start.column;
+			let line = this.source.start.line;
+			for (let i = 0; i < index2; i++) if (string[i] === "\n") {
+				column = 1;
+				line += 1;
+			} else column += 1;
+			return {
+				column,
+				line
+			};
+		}
+		prev() {
+			if (!this.parent) return void 0;
+			let index2 = this.parent.index(this);
+			return this.parent.nodes[index2 - 1];
+		}
+		rangeBy(opts) {
+			let start = {
+				column: this.source.start.column,
+				line: this.source.start.line
+			};
+			let end = this.source.end ? {
+				column: this.source.end.column + 1,
+				line: this.source.end.line
+			} : {
+				column: start.column + 1,
+				line: start.line
+			};
+			if (opts.word) {
+				let stringRepresentation = this.toString();
+				let index2 = stringRepresentation.indexOf(opts.word);
+				if (index2 !== -1) {
+					start = this.positionInside(index2, stringRepresentation);
+					end = this.positionInside(index2 + opts.word.length, stringRepresentation);
+				}
+			} else {
+				if (opts.start) start = {
+					column: opts.start.column,
+					line: opts.start.line
+				};
+				else if (opts.index) start = this.positionInside(opts.index);
+				if (opts.end) end = {
+					column: opts.end.column,
+					line: opts.end.line
+				};
+				else if (typeof opts.endIndex === "number") end = this.positionInside(opts.endIndex);
+				else if (opts.index) end = this.positionInside(opts.index + 1);
+			}
+			if (end.line < start.line || end.line === start.line && end.column <= start.column) end = {
+				column: start.column + 1,
+				line: start.line
+			};
+			return {
+				end,
+				start
+			};
+		}
+		raw(prop, defaultType) {
+			return new Stringifier().raw(this, prop, defaultType);
+		}
+		remove() {
+			if (this.parent) this.parent.removeChild(this);
+			this.parent = void 0;
+			return this;
+		}
+		replaceWith(...nodes) {
+			if (this.parent) {
+				let bookmark = this;
+				let foundSelf = false;
+				for (let node2 of nodes) if (node2 === this) foundSelf = true;
+				else if (foundSelf) {
+					this.parent.insertAfter(bookmark, node2);
+					bookmark = node2;
+				} else this.parent.insertBefore(bookmark, node2);
+				if (!foundSelf) this.remove();
+			}
+			return this;
+		}
+		root() {
+			let result2 = this;
+			while (result2.parent && result2.parent.type !== "document") result2 = result2.parent;
+			return result2;
+		}
+		toJSON(_, inputs) {
+			let fixed = {};
+			let emitInputs = inputs == null;
+			inputs = inputs || /* @__PURE__ */ new Map();
+			let inputsNextIndex = 0;
+			for (let name in this) {
+				if (!Object.prototype.hasOwnProperty.call(this, name)) continue;
+				if (name === "parent" || name === "proxyCache") continue;
+				let value = this[name];
+				if (Array.isArray(value)) fixed[name] = value.map((i) => {
+					if (typeof i === "object" && i.toJSON) return i.toJSON(null, inputs);
+					else return i;
+				});
+				else if (typeof value === "object" && value.toJSON) fixed[name] = value.toJSON(null, inputs);
+				else if (name === "source") {
+					let inputId = inputs.get(value.input);
+					if (inputId == null) {
+						inputId = inputsNextIndex;
+						inputs.set(value.input, inputsNextIndex);
+						inputsNextIndex++;
+					}
+					fixed[name] = {
+						end: value.end,
+						inputId,
+						start: value.start
+					};
+				} else fixed[name] = value;
+			}
+			if (emitInputs) fixed.inputs = [...inputs.keys()].map((input2) => input2.toJSON());
+			return fixed;
+		}
+		toProxy() {
+			if (!this.proxyCache) this.proxyCache = new Proxy(this, this.getProxyProcessor());
+			return this.proxyCache;
+		}
+		toString(stringifier2 = stringify) {
+			if (stringifier2.stringify) stringifier2 = stringifier2.stringify;
+			let result2 = "";
+			stringifier2(this, (i) => {
+				result2 += i;
+			});
+			return result2;
+		}
+		warn(result2, text, opts) {
+			let data = { node: this };
+			for (let i in opts) data[i] = opts[i];
+			return result2.warn(text, data);
+		}
+		get proxyOf() {
+			return this;
+		}
+	}
+	node = Node;
+	Node.default = Node;
+	return node;
+}
+var declaration;
+var hasRequiredDeclaration;
+function requireDeclaration() {
+	if (hasRequiredDeclaration) return declaration;
+	hasRequiredDeclaration = 1;
+	let Node = requireNode();
+	class Declaration extends Node {
+		constructor(defaults) {
+			if (defaults && typeof defaults.value !== "undefined" && typeof defaults.value !== "string") defaults = {
+				...defaults,
+				value: String(defaults.value)
+			};
+			super(defaults);
+			this.type = "decl";
+		}
+		get variable() {
+			return this.prop.startsWith("--") || this.prop[0] === "$";
+		}
+	}
+	declaration = Declaration;
+	Declaration.default = Declaration;
+	return declaration;
+}
+var nonSecure;
+var hasRequiredNonSecure;
+function requireNonSecure() {
+	if (hasRequiredNonSecure) return nonSecure;
+	hasRequiredNonSecure = 1;
+	let urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+	let customAlphabet = (alphabet, defaultSize = 21) => {
+		return (size = defaultSize) => {
+			let id = "";
+			let i = size;
+			while (i--) id += alphabet[Math.random() * alphabet.length | 0];
+			return id;
+		};
+	};
+	let nanoid = (size = 21) => {
+		let id = "";
+		let i = size;
+		while (i--) id += urlAlphabet[Math.random() * 64 | 0];
+		return id;
+	};
+	nonSecure = {
+		nanoid,
+		customAlphabet
+	};
+	return nonSecure;
+}
+var previousMap;
+var hasRequiredPreviousMap;
+function requirePreviousMap() {
+	if (hasRequiredPreviousMap) return previousMap;
+	hasRequiredPreviousMap = 1;
+	let { SourceMapConsumer, SourceMapGenerator } = require$$2;
+	let { existsSync, readFileSync } = require$$2;
+	let { dirname, join } = require$$2;
+	function fromBase64(str) {
+		if (Buffer) return Buffer.from(str, "base64").toString();
+		else return window.atob(str);
+	}
+	class PreviousMap {
+		constructor(css, opts) {
+			if (opts.map === false) return;
+			this.loadAnnotation(css);
+			this.inline = this.startWith(this.annotation, "data:");
+			let prev = opts.map ? opts.map.prev : void 0;
+			let text = this.loadMap(opts.from, prev);
+			if (!this.mapFile && opts.from) this.mapFile = opts.from;
+			if (this.mapFile) this.root = dirname(this.mapFile);
+			if (text) this.text = text;
+		}
+		consumer() {
+			if (!this.consumerCache) this.consumerCache = new SourceMapConsumer(this.text);
+			return this.consumerCache;
+		}
+		decodeInline(text) {
+			let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
+			let baseUri = /^data:application\/json;base64,/;
+			if (/^data:application\/json;charset=utf-?8,/.test(text) || /^data:application\/json,/.test(text)) return decodeURIComponent(text.substr(RegExp.lastMatch.length));
+			if (baseCharsetUri.test(text) || baseUri.test(text)) return fromBase64(text.substr(RegExp.lastMatch.length));
+			let encoding = text.match(/data:application\/json;([^,]+),/)[1];
+			throw new Error("Unsupported source map encoding " + encoding);
+		}
+		getAnnotationURL(sourceMapString) {
+			return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, "").trim();
+		}
+		isMap(map) {
+			if (typeof map !== "object") return false;
+			return typeof map.mappings === "string" || typeof map._mappings === "string" || Array.isArray(map.sections);
+		}
+		loadAnnotation(css) {
+			let comments = css.match(/\/\*\s*# sourceMappingURL=/gm);
+			if (!comments) return;
+			let start = css.lastIndexOf(comments.pop());
+			let end = css.indexOf("*/", start);
+			if (start > -1 && end > -1) this.annotation = this.getAnnotationURL(css.substring(start, end));
+		}
+		loadFile(path) {
+			this.root = dirname(path);
+			if (existsSync(path)) {
+				this.mapFile = path;
+				return readFileSync(path, "utf-8").toString().trim();
+			}
+		}
+		loadMap(file, prev) {
+			if (prev === false) return false;
+			if (prev) if (typeof prev === "string") return prev;
+			else if (typeof prev === "function") {
+				let prevPath = prev(file);
+				if (prevPath) {
+					let map = this.loadFile(prevPath);
+					if (!map) throw new Error("Unable to load previous source map: " + prevPath.toString());
+					return map;
+				}
+			} else if (prev instanceof SourceMapConsumer) return SourceMapGenerator.fromSourceMap(prev).toString();
+			else if (prev instanceof SourceMapGenerator) return prev.toString();
+			else if (this.isMap(prev)) return JSON.stringify(prev);
+			else throw new Error("Unsupported previous source map format: " + prev.toString());
+			else if (this.inline) return this.decodeInline(this.annotation);
+			else if (this.annotation) {
+				let map = this.annotation;
+				if (file) map = join(dirname(file), map);
+				return this.loadFile(map);
+			}
+		}
+		startWith(string, start) {
+			if (!string) return false;
+			return string.substr(0, start.length) === start;
+		}
+		withContent() {
+			return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
+		}
+	}
+	previousMap = PreviousMap;
+	PreviousMap.default = PreviousMap;
+	return previousMap;
+}
+var input;
+var hasRequiredInput;
+function requireInput() {
+	if (hasRequiredInput) return input;
+	hasRequiredInput = 1;
+	let { SourceMapConsumer, SourceMapGenerator } = require$$2;
+	let { fileURLToPath, pathToFileURL } = require$$2;
+	let { isAbsolute, resolve } = require$$2;
+	let { nanoid } = /* @__PURE__ */ requireNonSecure();
+	let terminalHighlight = require$$2;
+	let CssSyntaxError = requireCssSyntaxError();
+	let PreviousMap = requirePreviousMap();
+	let fromOffsetCache = Symbol("fromOffsetCache");
+	let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
+	let pathAvailable = Boolean(resolve && isAbsolute);
+	class Input {
+		constructor(css, opts = {}) {
+			if (css === null || typeof css === "undefined" || typeof css === "object" && !css.toString) throw new Error(`PostCSS received ${css} instead of CSS string`);
+			this.css = css.toString();
+			if (this.css[0] === "" || this.css[0] === "￾") {
+				this.hasBOM = true;
+				this.css = this.css.slice(1);
+			} else this.hasBOM = false;
+			if (opts.from) if (!pathAvailable || /^\w+:\/\//.test(opts.from) || isAbsolute(opts.from)) this.file = opts.from;
+			else this.file = resolve(opts.from);
+			if (pathAvailable && sourceMapAvailable) {
+				let map = new PreviousMap(this.css, opts);
+				if (map.text) {
+					this.map = map;
+					let file = map.consumer().file;
+					if (!this.file && file) this.file = this.mapResolve(file);
+				}
+			}
+			if (!this.file) this.id = "<input css " + nanoid(6) + ">";
+			if (this.map) this.map.file = this.from;
+		}
+		error(message, line, column, opts = {}) {
+			let result2, endLine, endColumn;
+			if (line && typeof line === "object") {
+				let start = line;
+				let end = column;
+				if (typeof start.offset === "number") {
+					let pos = this.fromOffset(start.offset);
+					line = pos.line;
+					column = pos.col;
+				} else {
+					line = start.line;
+					column = start.column;
+				}
+				if (typeof end.offset === "number") {
+					let pos = this.fromOffset(end.offset);
+					endLine = pos.line;
+					endColumn = pos.col;
+				} else {
+					endLine = end.line;
+					endColumn = end.column;
+				}
+			} else if (!column) {
+				let pos = this.fromOffset(line);
+				line = pos.line;
+				column = pos.col;
+			}
+			let origin = this.origin(line, column, endLine, endColumn);
+			if (origin) result2 = new CssSyntaxError(message, origin.endLine === void 0 ? origin.line : {
+				column: origin.column,
+				line: origin.line
+			}, origin.endLine === void 0 ? origin.column : {
+				column: origin.endColumn,
+				line: origin.endLine
+			}, origin.source, origin.file, opts.plugin);
+			else result2 = new CssSyntaxError(message, endLine === void 0 ? line : {
+				column,
+				line
+			}, endLine === void 0 ? column : {
+				column: endColumn,
+				line: endLine
+			}, this.css, this.file, opts.plugin);
+			result2.input = {
+				column,
+				endColumn,
+				endLine,
+				line,
+				source: this.css
+			};
+			if (this.file) {
+				if (pathToFileURL) result2.input.url = pathToFileURL(this.file).toString();
+				result2.input.file = this.file;
+			}
+			return result2;
+		}
+		fromOffset(offset) {
+			let lastLine, lineToIndex;
+			if (!this[fromOffsetCache]) {
+				let lines = this.css.split("\n");
+				lineToIndex = new Array(lines.length);
+				let prevIndex = 0;
+				for (let i = 0, l = lines.length; i < l; i++) {
+					lineToIndex[i] = prevIndex;
+					prevIndex += lines[i].length + 1;
+				}
+				this[fromOffsetCache] = lineToIndex;
+			} else lineToIndex = this[fromOffsetCache];
+			lastLine = lineToIndex[lineToIndex.length - 1];
+			let min = 0;
+			if (offset >= lastLine) min = lineToIndex.length - 1;
+			else {
+				let max = lineToIndex.length - 2;
+				let mid;
+				while (min < max) {
+					mid = min + (max - min >> 1);
+					if (offset < lineToIndex[mid]) max = mid - 1;
+					else if (offset >= lineToIndex[mid + 1]) min = mid + 1;
+					else {
+						min = mid;
+						break;
+					}
+				}
+			}
+			return {
+				col: offset - lineToIndex[min] + 1,
+				line: min + 1
+			};
+		}
+		mapResolve(file) {
+			if (/^\w+:\/\//.test(file)) return file;
+			return resolve(this.map.consumer().sourceRoot || this.map.root || ".", file);
+		}
+		origin(line, column, endLine, endColumn) {
+			if (!this.map) return false;
+			let consumer = this.map.consumer();
+			let from = consumer.originalPositionFor({
+				column,
+				line
+			});
+			if (!from.source) return false;
+			let to;
+			if (typeof endLine === "number") to = consumer.originalPositionFor({
+				column: endColumn,
+				line: endLine
+			});
+			let fromUrl;
+			if (isAbsolute(from.source)) fromUrl = pathToFileURL(from.source);
+			else fromUrl = new URL(from.source, this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile));
+			let result2 = {
+				column: from.column,
+				endColumn: to && to.column,
+				endLine: to && to.line,
+				line: from.line,
+				url: fromUrl.toString()
+			};
+			if (fromUrl.protocol === "file:") if (fileURLToPath) result2.file = fileURLToPath(fromUrl);
+			else throw new Error(`file: protocol is not available in this PostCSS build`);
+			let source = consumer.sourceContentFor(from.source);
+			if (source) result2.source = source;
+			return result2;
+		}
+		toJSON() {
+			let json = {};
+			for (let name of [
+				"hasBOM",
+				"css",
+				"file",
+				"id"
+			]) if (this[name] != null) json[name] = this[name];
+			if (this.map) {
+				json.map = { ...this.map };
+				if (json.map.consumerCache) json.map.consumerCache = void 0;
+			}
+			return json;
+		}
+		get from() {
+			return this.file || this.id;
+		}
+	}
+	input = Input;
+	Input.default = Input;
+	if (terminalHighlight && terminalHighlight.registerInput) terminalHighlight.registerInput(Input);
+	return input;
+}
+var mapGenerator;
+var hasRequiredMapGenerator;
+function requireMapGenerator() {
+	if (hasRequiredMapGenerator) return mapGenerator;
+	hasRequiredMapGenerator = 1;
+	let { SourceMapConsumer, SourceMapGenerator } = require$$2;
+	let { dirname, relative, resolve, sep } = require$$2;
+	let { pathToFileURL } = require$$2;
+	let Input = requireInput();
+	let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
+	let pathAvailable = Boolean(dirname && resolve && relative && sep);
+	class MapGenerator {
+		constructor(stringify, root2, opts, cssString) {
+			this.stringify = stringify;
+			this.mapOpts = opts.map || {};
+			this.root = root2;
+			this.opts = opts;
+			this.css = cssString;
+			this.originalCSS = cssString;
+			this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute;
+			this.memoizedFileURLs = /* @__PURE__ */ new Map();
+			this.memoizedPaths = /* @__PURE__ */ new Map();
+			this.memoizedURLs = /* @__PURE__ */ new Map();
+		}
+		addAnnotation() {
+			let content;
+			if (this.isInline()) content = "data:application/json;base64," + this.toBase64(this.map.toString());
+			else if (typeof this.mapOpts.annotation === "string") content = this.mapOpts.annotation;
+			else if (typeof this.mapOpts.annotation === "function") content = this.mapOpts.annotation(this.opts.to, this.root);
+			else content = this.outputFile() + ".map";
+			let eol = "\n";
+			if (this.css.includes("\r\n")) eol = "\r\n";
+			this.css += eol + "/*# sourceMappingURL=" + content + " */";
+		}
+		applyPrevMaps() {
+			for (let prev of this.previous()) {
+				let from = this.toUrl(this.path(prev.file));
+				let root2 = prev.root || dirname(prev.file);
+				let map;
+				if (this.mapOpts.sourcesContent === false) {
+					map = new SourceMapConsumer(prev.text);
+					if (map.sourcesContent) map.sourcesContent = null;
+				} else map = prev.consumer();
+				this.map.applySourceMap(map, from, this.toUrl(this.path(root2)));
+			}
+		}
+		clearAnnotation() {
+			if (this.mapOpts.annotation === false) return;
+			if (this.root) {
+				let node2;
+				for (let i = this.root.nodes.length - 1; i >= 0; i--) {
+					node2 = this.root.nodes[i];
+					if (node2.type !== "comment") continue;
+					if (node2.text.indexOf("# sourceMappingURL=") === 0) this.root.removeChild(i);
+				}
+			} else if (this.css) this.css = this.css.replace(/\n*?\/\*#[\S\s]*?\*\/$/gm, "");
+		}
+		generate() {
+			this.clearAnnotation();
+			if (pathAvailable && sourceMapAvailable && this.isMap()) return this.generateMap();
+			else {
+				let result2 = "";
+				this.stringify(this.root, (i) => {
+					result2 += i;
+				});
+				return [result2];
+			}
+		}
+		generateMap() {
+			if (this.root) this.generateString();
+			else if (this.previous().length === 1) {
+				let prev = this.previous()[0].consumer();
+				prev.file = this.outputFile();
+				this.map = SourceMapGenerator.fromSourceMap(prev, { ignoreInvalidMapping: true });
+			} else {
+				this.map = new SourceMapGenerator({
+					file: this.outputFile(),
+					ignoreInvalidMapping: true
+				});
+				this.map.addMapping({
+					generated: {
+						column: 0,
+						line: 1
+					},
+					original: {
+						column: 0,
+						line: 1
+					},
+					source: this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>"
+				});
+			}
+			if (this.isSourcesContent()) this.setSourcesContent();
+			if (this.root && this.previous().length > 0) this.applyPrevMaps();
+			if (this.isAnnotation()) this.addAnnotation();
+			if (this.isInline()) return [this.css];
+			else return [this.css, this.map];
+		}
+		generateString() {
+			this.css = "";
+			this.map = new SourceMapGenerator({
+				file: this.outputFile(),
+				ignoreInvalidMapping: true
+			});
+			let line = 1;
+			let column = 1;
+			let noSource = "<no source>";
+			let mapping = {
+				generated: {
+					column: 0,
+					line: 0
+				},
+				original: {
+					column: 0,
+					line: 0
+				},
+				source: ""
+			};
+			let lines, last;
+			this.stringify(this.root, (str, node2, type) => {
+				this.css += str;
+				if (node2 && type !== "end") {
+					mapping.generated.line = line;
+					mapping.generated.column = column - 1;
+					if (node2.source && node2.source.start) {
+						mapping.source = this.sourcePath(node2);
+						mapping.original.line = node2.source.start.line;
+						mapping.original.column = node2.source.start.column - 1;
+						this.map.addMapping(mapping);
+					} else {
+						mapping.source = noSource;
+						mapping.original.line = 1;
+						mapping.original.column = 0;
+						this.map.addMapping(mapping);
+					}
+				}
+				lines = str.match(/\n/g);
+				if (lines) {
+					line += lines.length;
+					last = str.lastIndexOf("\n");
+					column = str.length - last;
+				} else column += str.length;
+				if (node2 && type !== "start") {
+					let p = node2.parent || { raws: {} };
+					if (!(node2.type === "decl" || node2.type === "atrule" && !node2.nodes) || node2 !== p.last || p.raws.semicolon) if (node2.source && node2.source.end) {
+						mapping.source = this.sourcePath(node2);
+						mapping.original.line = node2.source.end.line;
+						mapping.original.column = node2.source.end.column - 1;
+						mapping.generated.line = line;
+						mapping.generated.column = column - 2;
+						this.map.addMapping(mapping);
+					} else {
+						mapping.source = noSource;
+						mapping.original.line = 1;
+						mapping.original.column = 0;
+						mapping.generated.line = line;
+						mapping.generated.column = column - 1;
+						this.map.addMapping(mapping);
+					}
+				}
+			});
+		}
+		isAnnotation() {
+			if (this.isInline()) return true;
+			if (typeof this.mapOpts.annotation !== "undefined") return this.mapOpts.annotation;
+			if (this.previous().length) return this.previous().some((i) => i.annotation);
+			return true;
+		}
+		isInline() {
+			if (typeof this.mapOpts.inline !== "undefined") return this.mapOpts.inline;
+			let annotation = this.mapOpts.annotation;
+			if (typeof annotation !== "undefined" && annotation !== true) return false;
+			if (this.previous().length) return this.previous().some((i) => i.inline);
+			return true;
+		}
+		isMap() {
+			if (typeof this.opts.map !== "undefined") return !!this.opts.map;
+			return this.previous().length > 0;
+		}
+		isSourcesContent() {
+			if (typeof this.mapOpts.sourcesContent !== "undefined") return this.mapOpts.sourcesContent;
+			if (this.previous().length) return this.previous().some((i) => i.withContent());
+			return true;
+		}
+		outputFile() {
+			if (this.opts.to) return this.path(this.opts.to);
+			else if (this.opts.from) return this.path(this.opts.from);
+			else return "to.css";
+		}
+		path(file) {
+			if (this.mapOpts.absolute) return file;
+			if (file.charCodeAt(0) === 60) return file;
+			if (/^\w+:\/\//.test(file)) return file;
+			let cached = this.memoizedPaths.get(file);
+			if (cached) return cached;
+			let from = this.opts.to ? dirname(this.opts.to) : ".";
+			if (typeof this.mapOpts.annotation === "string") from = dirname(resolve(from, this.mapOpts.annotation));
+			let path = relative(from, file);
+			this.memoizedPaths.set(file, path);
+			return path;
+		}
+		previous() {
+			if (!this.previousMaps) {
+				this.previousMaps = [];
+				if (this.root) this.root.walk((node2) => {
+					if (node2.source && node2.source.input.map) {
+						let map = node2.source.input.map;
+						if (!this.previousMaps.includes(map)) this.previousMaps.push(map);
+					}
+				});
+				else {
+					let input2 = new Input(this.originalCSS, this.opts);
+					if (input2.map) this.previousMaps.push(input2.map);
+				}
+			}
+			return this.previousMaps;
+		}
+		setSourcesContent() {
+			let already = {};
+			if (this.root) this.root.walk((node2) => {
+				if (node2.source) {
+					let from = node2.source.input.from;
+					if (from && !already[from]) {
+						already[from] = true;
+						let fromUrl = this.usesFileUrls ? this.toFileUrl(from) : this.toUrl(this.path(from));
+						this.map.setSourceContent(fromUrl, node2.source.input.css);
+					}
+				}
+			});
+			else if (this.css) {
+				let from = this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>";
+				this.map.setSourceContent(from, this.css);
+			}
+		}
+		sourcePath(node2) {
+			if (this.mapOpts.from) return this.toUrl(this.mapOpts.from);
+			else if (this.usesFileUrls) return this.toFileUrl(node2.source.input.from);
+			else return this.toUrl(this.path(node2.source.input.from));
+		}
+		toBase64(str) {
+			if (Buffer) return Buffer.from(str).toString("base64");
+			else return window.btoa(unescape(encodeURIComponent(str)));
+		}
+		toFileUrl(path) {
+			let cached = this.memoizedFileURLs.get(path);
+			if (cached) return cached;
+			if (pathToFileURL) {
+				let fileURL = pathToFileURL(path).toString();
+				this.memoizedFileURLs.set(path, fileURL);
+				return fileURL;
+			} else throw new Error("`map.absolute` option is not available in this PostCSS build");
+		}
+		toUrl(path) {
+			let cached = this.memoizedURLs.get(path);
+			if (cached) return cached;
+			if (sep === "\\") path = path.replace(/\\/g, "/");
+			let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
+			this.memoizedURLs.set(path, url);
+			return url;
+		}
+	}
+	mapGenerator = MapGenerator;
+	return mapGenerator;
+}
+var comment;
+var hasRequiredComment;
+function requireComment() {
+	if (hasRequiredComment) return comment;
+	hasRequiredComment = 1;
+	let Node = requireNode();
+	class Comment extends Node {
+		constructor(defaults) {
+			super(defaults);
+			this.type = "comment";
+		}
+	}
+	comment = Comment;
+	Comment.default = Comment;
+	return comment;
+}
+var container;
+var hasRequiredContainer;
+function requireContainer() {
+	if (hasRequiredContainer) return container;
+	hasRequiredContainer = 1;
+	let { isClean, my } = requireSymbols();
+	let Declaration = requireDeclaration();
+	let Comment = requireComment();
+	let Node = requireNode();
+	let parse, Rule, AtRule, Root;
+	function cleanSource(nodes) {
+		return nodes.map((i) => {
+			if (i.nodes) i.nodes = cleanSource(i.nodes);
+			delete i.source;
+			return i;
+		});
+	}
+	function markDirtyUp(node2) {
+		node2[isClean] = false;
+		if (node2.proxyOf.nodes) for (let i of node2.proxyOf.nodes) markDirtyUp(i);
+	}
+	class Container extends Node {
+		append(...children) {
+			for (let child of children) {
+				let nodes = this.normalize(child, this.last);
+				for (let node2 of nodes) this.proxyOf.nodes.push(node2);
+			}
+			this.markDirty();
+			return this;
+		}
+		cleanRaws(keepBetween) {
+			super.cleanRaws(keepBetween);
+			if (this.nodes) for (let node2 of this.nodes) node2.cleanRaws(keepBetween);
+		}
+		each(callback) {
+			if (!this.proxyOf.nodes) return void 0;
+			let iterator = this.getIterator();
+			let index2, result2;
+			while (this.indexes[iterator] < this.proxyOf.nodes.length) {
+				index2 = this.indexes[iterator];
+				result2 = callback(this.proxyOf.nodes[index2], index2);
+				if (result2 === false) break;
+				this.indexes[iterator] += 1;
+			}
+			delete this.indexes[iterator];
+			return result2;
+		}
+		every(condition) {
+			return this.nodes.every(condition);
+		}
+		getIterator() {
+			if (!this.lastEach) this.lastEach = 0;
+			if (!this.indexes) this.indexes = {};
+			this.lastEach += 1;
+			let iterator = this.lastEach;
+			this.indexes[iterator] = 0;
+			return iterator;
+		}
+		getProxyProcessor() {
+			return {
+				get(node2, prop) {
+					if (prop === "proxyOf") return node2;
+					else if (!node2[prop]) return node2[prop];
+					else if (prop === "each" || typeof prop === "string" && prop.startsWith("walk")) return (...args) => {
+						return node2[prop](...args.map((i) => {
+							if (typeof i === "function") return (child, index2) => i(child.toProxy(), index2);
+							else return i;
+						}));
+					};
+					else if (prop === "every" || prop === "some") return (cb) => {
+						return node2[prop]((child, ...other) => cb(child.toProxy(), ...other));
+					};
+					else if (prop === "root") return () => node2.root().toProxy();
+					else if (prop === "nodes") return node2.nodes.map((i) => i.toProxy());
+					else if (prop === "first" || prop === "last") return node2[prop].toProxy();
+					else return node2[prop];
+				},
+				set(node2, prop, value) {
+					if (node2[prop] === value) return true;
+					node2[prop] = value;
+					if (prop === "name" || prop === "params" || prop === "selector") node2.markDirty();
+					return true;
+				}
+			};
+		}
+		index(child) {
+			if (typeof child === "number") return child;
+			if (child.proxyOf) child = child.proxyOf;
+			return this.proxyOf.nodes.indexOf(child);
+		}
+		insertAfter(exist, add) {
+			let existIndex = this.index(exist);
+			let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse();
+			existIndex = this.index(exist);
+			for (let node2 of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node2);
+			let index2;
+			for (let id in this.indexes) {
+				index2 = this.indexes[id];
+				if (existIndex < index2) this.indexes[id] = index2 + nodes.length;
+			}
+			this.markDirty();
+			return this;
+		}
+		insertBefore(exist, add) {
+			let existIndex = this.index(exist);
+			let type = existIndex === 0 ? "prepend" : false;
+			let nodes = this.normalize(add, this.proxyOf.nodes[existIndex], type).reverse();
+			existIndex = this.index(exist);
+			for (let node2 of nodes) this.proxyOf.nodes.splice(existIndex, 0, node2);
+			let index2;
+			for (let id in this.indexes) {
+				index2 = this.indexes[id];
+				if (existIndex <= index2) this.indexes[id] = index2 + nodes.length;
+			}
+			this.markDirty();
+			return this;
+		}
+		normalize(nodes, sample) {
+			if (typeof nodes === "string") nodes = cleanSource(parse(nodes).nodes);
+			else if (typeof nodes === "undefined") nodes = [];
+			else if (Array.isArray(nodes)) {
+				nodes = nodes.slice(0);
+				for (let i of nodes) if (i.parent) i.parent.removeChild(i, "ignore");
+			} else if (nodes.type === "root" && this.type !== "document") {
+				nodes = nodes.nodes.slice(0);
+				for (let i of nodes) if (i.parent) i.parent.removeChild(i, "ignore");
+			} else if (nodes.type) nodes = [nodes];
+			else if (nodes.prop) {
+				if (typeof nodes.value === "undefined") throw new Error("Value field is missed in node creation");
+				else if (typeof nodes.value !== "string") nodes.value = String(nodes.value);
+				nodes = [new Declaration(nodes)];
+			} else if (nodes.selector) nodes = [new Rule(nodes)];
+			else if (nodes.name) nodes = [new AtRule(nodes)];
+			else if (nodes.text) nodes = [new Comment(nodes)];
+			else throw new Error("Unknown node type in node creation");
+			return nodes.map((i) => {
+				if (!i[my]) Container.rebuild(i);
+				i = i.proxyOf;
+				if (i.parent) i.parent.removeChild(i);
+				if (i[isClean]) markDirtyUp(i);
+				if (typeof i.raws.before === "undefined") {
+					if (sample && typeof sample.raws.before !== "undefined") i.raws.before = sample.raws.before.replace(/\S/g, "");
+				}
+				i.parent = this.proxyOf;
+				return i;
+			});
+		}
+		prepend(...children) {
+			children = children.reverse();
+			for (let child of children) {
+				let nodes = this.normalize(child, this.first, "prepend").reverse();
+				for (let node2 of nodes) this.proxyOf.nodes.unshift(node2);
+				for (let id in this.indexes) this.indexes[id] = this.indexes[id] + nodes.length;
+			}
+			this.markDirty();
+			return this;
+		}
+		push(child) {
+			child.parent = this;
+			this.proxyOf.nodes.push(child);
+			return this;
+		}
+		removeAll() {
+			for (let node2 of this.proxyOf.nodes) node2.parent = void 0;
+			this.proxyOf.nodes = [];
+			this.markDirty();
+			return this;
+		}
+		removeChild(child) {
+			child = this.index(child);
+			this.proxyOf.nodes[child].parent = void 0;
+			this.proxyOf.nodes.splice(child, 1);
+			let index2;
+			for (let id in this.indexes) {
+				index2 = this.indexes[id];
+				if (index2 >= child) this.indexes[id] = index2 - 1;
+			}
+			this.markDirty();
+			return this;
+		}
+		replaceValues(pattern, opts, callback) {
+			if (!callback) {
+				callback = opts;
+				opts = {};
+			}
+			this.walkDecls((decl) => {
+				if (opts.props && !opts.props.includes(decl.prop)) return;
+				if (opts.fast && !decl.value.includes(opts.fast)) return;
+				decl.value = decl.value.replace(pattern, callback);
+			});
+			this.markDirty();
+			return this;
+		}
+		some(condition) {
+			return this.nodes.some(condition);
+		}
+		walk(callback) {
+			return this.each((child, i) => {
+				let result2;
+				try {
+					result2 = callback(child, i);
+				} catch (e) {
+					throw child.addToError(e);
+				}
+				if (result2 !== false && child.walk) result2 = child.walk(callback);
+				return result2;
+			});
+		}
+		walkAtRules(name, callback) {
+			if (!callback) {
+				callback = name;
+				return this.walk((child, i) => {
+					if (child.type === "atrule") return callback(child, i);
+				});
+			}
+			if (name instanceof RegExp) return this.walk((child, i) => {
+				if (child.type === "atrule" && name.test(child.name)) return callback(child, i);
+			});
+			return this.walk((child, i) => {
+				if (child.type === "atrule" && child.name === name) return callback(child, i);
+			});
+		}
+		walkComments(callback) {
+			return this.walk((child, i) => {
+				if (child.type === "comment") return callback(child, i);
+			});
+		}
+		walkDecls(prop, callback) {
+			if (!callback) {
+				callback = prop;
+				return this.walk((child, i) => {
+					if (child.type === "decl") return callback(child, i);
+				});
+			}
+			if (prop instanceof RegExp) return this.walk((child, i) => {
+				if (child.type === "decl" && prop.test(child.prop)) return callback(child, i);
+			});
+			return this.walk((child, i) => {
+				if (child.type === "decl" && child.prop === prop) return callback(child, i);
+			});
+		}
+		walkRules(selector, callback) {
+			if (!callback) {
+				callback = selector;
+				return this.walk((child, i) => {
+					if (child.type === "rule") return callback(child, i);
+				});
+			}
+			if (selector instanceof RegExp) return this.walk((child, i) => {
+				if (child.type === "rule" && selector.test(child.selector)) return callback(child, i);
+			});
+			return this.walk((child, i) => {
+				if (child.type === "rule" && child.selector === selector) return callback(child, i);
+			});
+		}
+		get first() {
+			if (!this.proxyOf.nodes) return void 0;
+			return this.proxyOf.nodes[0];
+		}
+		get last() {
+			if (!this.proxyOf.nodes) return void 0;
+			return this.proxyOf.nodes[this.proxyOf.nodes.length - 1];
+		}
+	}
+	Container.registerParse = (dependant) => {
+		parse = dependant;
+	};
+	Container.registerRule = (dependant) => {
+		Rule = dependant;
+	};
+	Container.registerAtRule = (dependant) => {
+		AtRule = dependant;
+	};
+	Container.registerRoot = (dependant) => {
+		Root = dependant;
+	};
+	container = Container;
+	Container.default = Container;
+	Container.rebuild = (node2) => {
+		if (node2.type === "atrule") Object.setPrototypeOf(node2, AtRule.prototype);
+		else if (node2.type === "rule") Object.setPrototypeOf(node2, Rule.prototype);
+		else if (node2.type === "decl") Object.setPrototypeOf(node2, Declaration.prototype);
+		else if (node2.type === "comment") Object.setPrototypeOf(node2, Comment.prototype);
+		else if (node2.type === "root") Object.setPrototypeOf(node2, Root.prototype);
+		node2[my] = true;
+		if (node2.nodes) node2.nodes.forEach((child) => {
+			Container.rebuild(child);
+		});
+	};
+	return container;
+}
+var document$1;
+var hasRequiredDocument;
+function requireDocument() {
+	if (hasRequiredDocument) return document$1;
+	hasRequiredDocument = 1;
+	let Container = requireContainer();
+	let LazyResult, Processor;
+	class Document extends Container {
+		constructor(defaults) {
+			super({
+				type: "document",
+				...defaults
+			});
+			if (!this.nodes) this.nodes = [];
+		}
+		toResult(opts = {}) {
+			return new LazyResult(new Processor(), this, opts).stringify();
+		}
+	}
+	Document.registerLazyResult = (dependant) => {
+		LazyResult = dependant;
+	};
+	Document.registerProcessor = (dependant) => {
+		Processor = dependant;
+	};
+	document$1 = Document;
+	Document.default = Document;
+	return document$1;
+}
+var warnOnce;
+var hasRequiredWarnOnce;
+function requireWarnOnce() {
+	if (hasRequiredWarnOnce) return warnOnce;
+	hasRequiredWarnOnce = 1;
+	let printed = {};
+	warnOnce = function warnOnce2(message) {
+		if (printed[message]) return;
+		printed[message] = true;
+		if (typeof console !== "undefined" && console.warn) console.warn(message);
+	};
+	return warnOnce;
+}
+var warning;
+var hasRequiredWarning;
+function requireWarning() {
+	if (hasRequiredWarning) return warning;
+	hasRequiredWarning = 1;
+	class Warning {
+		constructor(text, opts = {}) {
+			this.type = "warning";
+			this.text = text;
+			if (opts.node && opts.node.source) {
+				let range = opts.node.rangeBy(opts);
+				this.line = range.start.line;
+				this.column = range.start.column;
+				this.endLine = range.end.line;
+				this.endColumn = range.end.column;
+			}
+			for (let opt in opts) this[opt] = opts[opt];
+		}
+		toString() {
+			if (this.node) return this.node.error(this.text, {
+				index: this.index,
+				plugin: this.plugin,
+				word: this.word
+			}).message;
+			if (this.plugin) return this.plugin + ": " + this.text;
+			return this.text;
+		}
+	}
+	warning = Warning;
+	Warning.default = Warning;
+	return warning;
+}
+var result;
+var hasRequiredResult;
+function requireResult() {
+	if (hasRequiredResult) return result;
+	hasRequiredResult = 1;
+	let Warning = requireWarning();
+	class Result {
+		constructor(processor2, root2, opts) {
+			this.processor = processor2;
+			this.messages = [];
+			this.root = root2;
+			this.opts = opts;
+			this.css = void 0;
+			this.map = void 0;
+		}
+		toString() {
+			return this.css;
+		}
+		warn(text, opts = {}) {
+			if (!opts.plugin) {
+				if (this.lastPlugin && this.lastPlugin.postcssPlugin) opts.plugin = this.lastPlugin.postcssPlugin;
+			}
+			let warning2 = new Warning(text, opts);
+			this.messages.push(warning2);
+			return warning2;
+		}
+		warnings() {
+			return this.messages.filter((i) => i.type === "warning");
+		}
+		get content() {
+			return this.css;
+		}
+	}
+	result = Result;
+	Result.default = Result;
+	return result;
+}
+var tokenize;
+var hasRequiredTokenize;
+function requireTokenize() {
+	if (hasRequiredTokenize) return tokenize;
+	hasRequiredTokenize = 1;
+	const SINGLE_QUOTE = "'".charCodeAt(0);
+	const DOUBLE_QUOTE = "\"".charCodeAt(0);
+	const BACKSLASH = "\\".charCodeAt(0);
+	const SLASH = "/".charCodeAt(0);
+	const NEWLINE = "\n".charCodeAt(0);
+	const SPACE = " ".charCodeAt(0);
+	const FEED = "\f".charCodeAt(0);
+	const TAB = "	".charCodeAt(0);
+	const CR = "\r".charCodeAt(0);
+	const OPEN_SQUARE = "[".charCodeAt(0);
+	const CLOSE_SQUARE = "]".charCodeAt(0);
+	const OPEN_PARENTHESES = "(".charCodeAt(0);
+	const CLOSE_PARENTHESES = ")".charCodeAt(0);
+	const OPEN_CURLY = "{".charCodeAt(0);
+	const CLOSE_CURLY = "}".charCodeAt(0);
+	const SEMICOLON = ";".charCodeAt(0);
+	const ASTERISK = "*".charCodeAt(0);
+	const COLON = ":".charCodeAt(0);
+	const AT = "@".charCodeAt(0);
+	const RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g;
+	const RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g;
+	const RE_BAD_BRACKET = /.[\r\n"'(/\\]/;
+	const RE_HEX_ESCAPE = /[\da-f]/i;
+	tokenize = function tokenizer(input2, options = {}) {
+		let css = input2.css.valueOf();
+		let ignore = options.ignoreErrors;
+		let code, next, quote, content, escape;
+		let escaped, escapePos, prev, n, currentToken;
+		let length = css.length;
+		let pos = 0;
+		let buffer = [];
+		let returned = [];
+		function position() {
+			return pos;
+		}
+		function unclosed(what) {
+			throw input2.error("Unclosed " + what, pos);
+		}
+		function endOfFile() {
+			return returned.length === 0 && pos >= length;
+		}
+		function nextToken(opts) {
+			if (returned.length) return returned.pop();
+			if (pos >= length) return;
+			let ignoreUnclosed = opts ? opts.ignoreUnclosed : false;
+			code = css.charCodeAt(pos);
+			switch (code) {
+				case NEWLINE:
+				case SPACE:
+				case TAB:
+				case CR:
+				case FEED:
+					next = pos;
+					do {
+						next += 1;
+						code = css.charCodeAt(next);
+					} while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);
+					currentToken = ["space", css.slice(pos, next)];
+					pos = next - 1;
+					break;
+				case OPEN_SQUARE:
+				case CLOSE_SQUARE:
+				case OPEN_CURLY:
+				case CLOSE_CURLY:
+				case COLON:
+				case SEMICOLON:
+				case CLOSE_PARENTHESES: {
+					let controlChar = String.fromCharCode(code);
+					currentToken = [
+						controlChar,
+						controlChar,
+						pos
+					];
+					break;
+				}
+				case OPEN_PARENTHESES:
+					prev = buffer.length ? buffer.pop()[1] : "";
+					n = css.charCodeAt(pos + 1);
+					if (prev === "url" && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) {
+						next = pos;
+						do {
+							escaped = false;
+							next = css.indexOf(")", next + 1);
+							if (next === -1) if (ignore || ignoreUnclosed) {
+								next = pos;
+								break;
+							} else unclosed("bracket");
+							escapePos = next;
+							while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
+								escapePos -= 1;
+								escaped = !escaped;
+							}
+						} while (escaped);
+						currentToken = [
+							"brackets",
+							css.slice(pos, next + 1),
+							pos,
+							next
+						];
+						pos = next;
+					} else {
+						next = css.indexOf(")", pos + 1);
+						content = css.slice(pos, next + 1);
+						if (next === -1 || RE_BAD_BRACKET.test(content)) currentToken = [
+							"(",
+							"(",
+							pos
+						];
+						else {
+							currentToken = [
+								"brackets",
+								content,
+								pos,
+								next
+							];
+							pos = next;
+						}
+					}
+					break;
+				case SINGLE_QUOTE:
+				case DOUBLE_QUOTE:
+					quote = code === SINGLE_QUOTE ? "'" : "\"";
+					next = pos;
+					do {
+						escaped = false;
+						next = css.indexOf(quote, next + 1);
+						if (next === -1) if (ignore || ignoreUnclosed) {
+							next = pos + 1;
+							break;
+						} else unclosed("string");
+						escapePos = next;
+						while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
+							escapePos -= 1;
+							escaped = !escaped;
+						}
+					} while (escaped);
+					currentToken = [
+						"string",
+						css.slice(pos, next + 1),
+						pos,
+						next
+					];
+					pos = next;
+					break;
+				case AT:
+					RE_AT_END.lastIndex = pos + 1;
+					RE_AT_END.test(css);
+					if (RE_AT_END.lastIndex === 0) next = css.length - 1;
+					else next = RE_AT_END.lastIndex - 2;
+					currentToken = [
+						"at-word",
+						css.slice(pos, next + 1),
+						pos,
+						next
+					];
+					pos = next;
+					break;
+				case BACKSLASH:
+					next = pos;
+					escape = true;
+					while (css.charCodeAt(next + 1) === BACKSLASH) {
+						next += 1;
+						escape = !escape;
+					}
+					code = css.charCodeAt(next + 1);
+					if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) {
+						next += 1;
+						if (RE_HEX_ESCAPE.test(css.charAt(next))) {
+							while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) next += 1;
+							if (css.charCodeAt(next + 1) === SPACE) next += 1;
+						}
+					}
+					currentToken = [
+						"word",
+						css.slice(pos, next + 1),
+						pos,
+						next
+					];
+					pos = next;
+					break;
+				default:
+					if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
+						next = css.indexOf("*/", pos + 2) + 1;
+						if (next === 0) if (ignore || ignoreUnclosed) next = css.length;
+						else unclosed("comment");
+						currentToken = [
+							"comment",
+							css.slice(pos, next + 1),
+							pos,
+							next
+						];
+						pos = next;
+					} else {
+						RE_WORD_END.lastIndex = pos + 1;
+						RE_WORD_END.test(css);
+						if (RE_WORD_END.lastIndex === 0) next = css.length - 1;
+						else next = RE_WORD_END.lastIndex - 2;
+						currentToken = [
+							"word",
+							css.slice(pos, next + 1),
+							pos,
+							next
+						];
+						buffer.push(currentToken);
+						pos = next;
+					}
+					break;
+			}
+			pos++;
+			return currentToken;
+		}
+		function back(token) {
+			returned.push(token);
+		}
+		return {
+			back,
+			endOfFile,
+			nextToken,
+			position
+		};
+	};
+	return tokenize;
+}
+var atRule;
+var hasRequiredAtRule;
+function requireAtRule() {
+	if (hasRequiredAtRule) return atRule;
+	hasRequiredAtRule = 1;
+	let Container = requireContainer();
+	class AtRule extends Container {
+		constructor(defaults) {
+			super(defaults);
+			this.type = "atrule";
+		}
+		append(...children) {
+			if (!this.proxyOf.nodes) this.nodes = [];
+			return super.append(...children);
+		}
+		prepend(...children) {
+			if (!this.proxyOf.nodes) this.nodes = [];
+			return super.prepend(...children);
+		}
+	}
+	atRule = AtRule;
+	AtRule.default = AtRule;
+	Container.registerAtRule(AtRule);
+	return atRule;
+}
+var root;
+var hasRequiredRoot;
+function requireRoot() {
+	if (hasRequiredRoot) return root;
+	hasRequiredRoot = 1;
+	let Container = requireContainer();
+	let LazyResult, Processor;
+	class Root extends Container {
+		constructor(defaults) {
+			super(defaults);
+			this.type = "root";
+			if (!this.nodes) this.nodes = [];
+		}
+		normalize(child, sample, type) {
+			let nodes = super.normalize(child);
+			if (sample) {
+				if (type === "prepend") if (this.nodes.length > 1) sample.raws.before = this.nodes[1].raws.before;
+				else delete sample.raws.before;
+				else if (this.first !== sample) for (let node2 of nodes) node2.raws.before = sample.raws.before;
+			}
+			return nodes;
+		}
+		removeChild(child, ignore) {
+			let index2 = this.index(child);
+			if (!ignore && index2 === 0 && this.nodes.length > 1) this.nodes[1].raws.before = this.nodes[index2].raws.before;
+			return super.removeChild(child);
+		}
+		toResult(opts = {}) {
+			return new LazyResult(new Processor(), this, opts).stringify();
+		}
+	}
+	Root.registerLazyResult = (dependant) => {
+		LazyResult = dependant;
+	};
+	Root.registerProcessor = (dependant) => {
+		Processor = dependant;
+	};
+	root = Root;
+	Root.default = Root;
+	Container.registerRoot(Root);
+	return root;
+}
+var list_1;
+var hasRequiredList;
+function requireList() {
+	if (hasRequiredList) return list_1;
+	hasRequiredList = 1;
+	let list = {
+		comma(string) {
+			return list.split(string, [","], true);
+		},
+		space(string) {
+			return list.split(string, [
+				" ",
+				"\n",
+				"	"
+			]);
+		},
+		split(string, separators, last) {
+			let array = [];
+			let current = "";
+			let split = false;
+			let func = 0;
+			let inQuote = false;
+			let prevQuote = "";
+			let escape = false;
+			for (let letter of string) {
+				if (escape) escape = false;
+				else if (letter === "\\") escape = true;
+				else if (inQuote) {
+					if (letter === prevQuote) inQuote = false;
+				} else if (letter === "\"" || letter === "'") {
+					inQuote = true;
+					prevQuote = letter;
+				} else if (letter === "(") func += 1;
+				else if (letter === ")") {
+					if (func > 0) func -= 1;
+				} else if (func === 0) {
+					if (separators.includes(letter)) split = true;
+				}
+				if (split) {
+					if (current !== "") array.push(current.trim());
+					current = "";
+					split = false;
+				} else current += letter;
+			}
+			if (last || current !== "") array.push(current.trim());
+			return array;
+		}
+	};
+	list_1 = list;
+	list.default = list;
+	return list_1;
+}
+var rule;
+var hasRequiredRule;
+function requireRule() {
+	if (hasRequiredRule) return rule;
+	hasRequiredRule = 1;
+	let Container = requireContainer();
+	let list = requireList();
+	class Rule extends Container {
+		constructor(defaults) {
+			super(defaults);
+			this.type = "rule";
+			if (!this.nodes) this.nodes = [];
+		}
+		get selectors() {
+			return list.comma(this.selector);
+		}
+		set selectors(values) {
+			let match = this.selector ? this.selector.match(/,\s*/) : null;
+			let sep = match ? match[0] : "," + this.raw("between", "beforeOpen");
+			this.selector = values.join(sep);
+		}
+	}
+	rule = Rule;
+	Rule.default = Rule;
+	Container.registerRule(Rule);
+	return rule;
+}
+var parser;
+var hasRequiredParser;
+function requireParser() {
+	if (hasRequiredParser) return parser;
+	hasRequiredParser = 1;
+	let Declaration = requireDeclaration();
+	let tokenizer = requireTokenize();
+	let Comment = requireComment();
+	let AtRule = requireAtRule();
+	let Root = requireRoot();
+	let Rule = requireRule();
+	const SAFE_COMMENT_NEIGHBOR = {
+		empty: true,
+		space: true
+	};
+	function findLastWithPosition(tokens) {
+		for (let i = tokens.length - 1; i >= 0; i--) {
+			let token = tokens[i];
+			let pos = token[3] || token[2];
+			if (pos) return pos;
+		}
+	}
+	class Parser {
+		constructor(input2) {
+			this.input = input2;
+			this.root = new Root();
+			this.current = this.root;
+			this.spaces = "";
+			this.semicolon = false;
+			this.createTokenizer();
+			this.root.source = {
+				input: input2,
+				start: {
+					column: 1,
+					line: 1,
+					offset: 0
+				}
+			};
+		}
+		atrule(token) {
+			let node2 = new AtRule();
+			node2.name = token[1].slice(1);
+			if (node2.name === "") this.unnamedAtrule(node2, token);
+			this.init(node2, token[2]);
+			let type;
+			let prev;
+			let shift;
+			let last = false;
+			let open = false;
+			let params = [];
+			let brackets = [];
+			while (!this.tokenizer.endOfFile()) {
+				token = this.tokenizer.nextToken();
+				type = token[0];
+				if (type === "(" || type === "[") brackets.push(type === "(" ? ")" : "]");
+				else if (type === "{" && brackets.length > 0) brackets.push("}");
+				else if (type === brackets[brackets.length - 1]) brackets.pop();
+				if (brackets.length === 0) if (type === ";") {
+					node2.source.end = this.getPosition(token[2]);
+					node2.source.end.offset++;
+					this.semicolon = true;
+					break;
+				} else if (type === "{") {
+					open = true;
+					break;
+				} else if (type === "}") {
+					if (params.length > 0) {
+						shift = params.length - 1;
+						prev = params[shift];
+						while (prev && prev[0] === "space") prev = params[--shift];
+						if (prev) {
+							node2.source.end = this.getPosition(prev[3] || prev[2]);
+							node2.source.end.offset++;
+						}
+					}
+					this.end(token);
+					break;
+				} else params.push(token);
+				else params.push(token);
+				if (this.tokenizer.endOfFile()) {
+					last = true;
+					break;
+				}
+			}
+			node2.raws.between = this.spacesAndCommentsFromEnd(params);
+			if (params.length) {
+				node2.raws.afterName = this.spacesAndCommentsFromStart(params);
+				this.raw(node2, "params", params);
+				if (last) {
+					token = params[params.length - 1];
+					node2.source.end = this.getPosition(token[3] || token[2]);
+					node2.source.end.offset++;
+					this.spaces = node2.raws.between;
+					node2.raws.between = "";
+				}
+			} else {
+				node2.raws.afterName = "";
+				node2.params = "";
+			}
+			if (open) {
+				node2.nodes = [];
+				this.current = node2;
+			}
+		}
+		checkMissedSemicolon(tokens) {
+			let colon = this.colon(tokens);
+			if (colon === false) return;
+			let founded = 0;
+			let token;
+			for (let j = colon - 1; j >= 0; j--) {
+				token = tokens[j];
+				if (token[0] !== "space") {
+					founded += 1;
+					if (founded === 2) break;
+				}
+			}
+			throw this.input.error("Missed semicolon", token[0] === "word" ? token[3] + 1 : token[2]);
+		}
+		colon(tokens) {
+			let brackets = 0;
+			let token, type, prev;
+			for (let [i, element] of tokens.entries()) {
+				token = element;
+				type = token[0];
+				if (type === "(") brackets += 1;
+				if (type === ")") brackets -= 1;
+				if (brackets === 0 && type === ":") if (!prev) this.doubleColon(token);
+				else if (prev[0] === "word" && prev[1] === "progid") continue;
+				else return i;
+				prev = token;
+			}
+			return false;
+		}
+		comment(token) {
+			let node2 = new Comment();
+			this.init(node2, token[2]);
+			node2.source.end = this.getPosition(token[3] || token[2]);
+			node2.source.end.offset++;
+			let text = token[1].slice(2, -2);
+			if (/^\s*$/.test(text)) {
+				node2.text = "";
+				node2.raws.left = text;
+				node2.raws.right = "";
+			} else {
+				let match = text.match(/^(\s*)([^]*\S)(\s*)$/);
+				node2.text = match[2];
+				node2.raws.left = match[1];
+				node2.raws.right = match[3];
+			}
+		}
+		createTokenizer() {
+			this.tokenizer = tokenizer(this.input);
+		}
+		decl(tokens, customProperty) {
+			let node2 = new Declaration();
+			this.init(node2, tokens[0][2]);
+			let last = tokens[tokens.length - 1];
+			if (last[0] === ";") {
+				this.semicolon = true;
+				tokens.pop();
+			}
+			node2.source.end = this.getPosition(last[3] || last[2] || findLastWithPosition(tokens));
+			node2.source.end.offset++;
+			while (tokens[0][0] !== "word") {
+				if (tokens.length === 1) this.unknownWord(tokens);
+				node2.raws.before += tokens.shift()[1];
+			}
+			node2.source.start = this.getPosition(tokens[0][2]);
+			node2.prop = "";
+			while (tokens.length) {
+				let type = tokens[0][0];
+				if (type === ":" || type === "space" || type === "comment") break;
+				node2.prop += tokens.shift()[1];
+			}
+			node2.raws.between = "";
+			let token;
+			while (tokens.length) {
+				token = tokens.shift();
+				if (token[0] === ":") {
+					node2.raws.between += token[1];
+					break;
+				} else {
+					if (token[0] === "word" && /\w/.test(token[1])) this.unknownWord([token]);
+					node2.raws.between += token[1];
+				}
+			}
+			if (node2.prop[0] === "_" || node2.prop[0] === "*") {
+				node2.raws.before += node2.prop[0];
+				node2.prop = node2.prop.slice(1);
+			}
+			let firstSpaces = [];
+			let next;
+			while (tokens.length) {
+				next = tokens[0][0];
+				if (next !== "space" && next !== "comment") break;
+				firstSpaces.push(tokens.shift());
+			}
+			this.precheckMissedSemicolon(tokens);
+			for (let i = tokens.length - 1; i >= 0; i--) {
+				token = tokens[i];
+				if (token[1].toLowerCase() === "!important") {
+					node2.important = true;
+					let string = this.stringFrom(tokens, i);
+					string = this.spacesFromEnd(tokens) + string;
+					if (string !== " !important") node2.raws.important = string;
+					break;
+				} else if (token[1].toLowerCase() === "important") {
+					let cache = tokens.slice(0);
+					let str = "";
+					for (let j = i; j > 0; j--) {
+						let type = cache[j][0];
+						if (str.trim().indexOf("!") === 0 && type !== "space") break;
+						str = cache.pop()[1] + str;
+					}
+					if (str.trim().indexOf("!") === 0) {
+						node2.important = true;
+						node2.raws.important = str;
+						tokens = cache;
+					}
+				}
+				if (token[0] !== "space" && token[0] !== "comment") break;
+			}
+			if (tokens.some((i) => i[0] !== "space" && i[0] !== "comment")) {
+				node2.raws.between += firstSpaces.map((i) => i[1]).join("");
+				firstSpaces = [];
+			}
+			this.raw(node2, "value", firstSpaces.concat(tokens), customProperty);
+			if (node2.value.includes(":") && !customProperty) this.checkMissedSemicolon(tokens);
+		}
+		doubleColon(token) {
+			throw this.input.error("Double colon", { offset: token[2] }, { offset: token[2] + token[1].length });
+		}
+		emptyRule(token) {
+			let node2 = new Rule();
+			this.init(node2, token[2]);
+			node2.selector = "";
+			node2.raws.between = "";
+			this.current = node2;
+		}
+		end(token) {
+			if (this.current.nodes && this.current.nodes.length) this.current.raws.semicolon = this.semicolon;
+			this.semicolon = false;
+			this.current.raws.after = (this.current.raws.after || "") + this.spaces;
+			this.spaces = "";
+			if (this.current.parent) {
+				this.current.source.end = this.getPosition(token[2]);
+				this.current.source.end.offset++;
+				this.current = this.current.parent;
+			} else this.unexpectedClose(token);
+		}
+		endFile() {
+			if (this.current.parent) this.unclosedBlock();
+			if (this.current.nodes && this.current.nodes.length) this.current.raws.semicolon = this.semicolon;
+			this.current.raws.after = (this.current.raws.after || "") + this.spaces;
+			this.root.source.end = this.getPosition(this.tokenizer.position());
+		}
+		freeSemicolon(token) {
+			this.spaces += token[1];
+			if (this.current.nodes) {
+				let prev = this.current.nodes[this.current.nodes.length - 1];
+				if (prev && prev.type === "rule" && !prev.raws.ownSemicolon) {
+					prev.raws.ownSemicolon = this.spaces;
+					this.spaces = "";
+				}
+			}
+		}
+		getPosition(offset) {
+			let pos = this.input.fromOffset(offset);
+			return {
+				column: pos.col,
+				line: pos.line,
+				offset
+			};
+		}
+		init(node2, offset) {
+			this.current.push(node2);
+			node2.source = {
+				input: this.input,
+				start: this.getPosition(offset)
+			};
+			node2.raws.before = this.spaces;
+			this.spaces = "";
+			if (node2.type !== "comment") this.semicolon = false;
+		}
+		other(start) {
+			let end = false;
+			let type = null;
+			let colon = false;
+			let bracket = null;
+			let brackets = [];
+			let customProperty = start[1].startsWith("--");
+			let tokens = [];
+			let token = start;
+			while (token) {
+				type = token[0];
+				tokens.push(token);
+				if (type === "(" || type === "[") {
+					if (!bracket) bracket = token;
+					brackets.push(type === "(" ? ")" : "]");
+				} else if (customProperty && colon && type === "{") {
+					if (!bracket) bracket = token;
+					brackets.push("}");
+				} else if (brackets.length === 0) {
+					if (type === ";") if (colon) {
+						this.decl(tokens, customProperty);
+						return;
+					} else break;
+					else if (type === "{") {
+						this.rule(tokens);
+						return;
+					} else if (type === "}") {
+						this.tokenizer.back(tokens.pop());
+						end = true;
+						break;
+					} else if (type === ":") colon = true;
+				} else if (type === brackets[brackets.length - 1]) {
+					brackets.pop();
+					if (brackets.length === 0) bracket = null;
+				}
+				token = this.tokenizer.nextToken();
+			}
+			if (this.tokenizer.endOfFile()) end = true;
+			if (brackets.length > 0) this.unclosedBracket(bracket);
+			if (end && colon) {
+				if (!customProperty) while (tokens.length) {
+					token = tokens[tokens.length - 1][0];
+					if (token !== "space" && token !== "comment") break;
+					this.tokenizer.back(tokens.pop());
+				}
+				this.decl(tokens, customProperty);
+			} else this.unknownWord(tokens);
+		}
+		parse() {
+			let token;
+			while (!this.tokenizer.endOfFile()) {
+				token = this.tokenizer.nextToken();
+				switch (token[0]) {
+					case "space":
+						this.spaces += token[1];
+						break;
+					case ";":
+						this.freeSemicolon(token);
+						break;
+					case "}":
+						this.end(token);
+						break;
+					case "comment":
+						this.comment(token);
+						break;
+					case "at-word":
+						this.atrule(token);
+						break;
+					case "{":
+						this.emptyRule(token);
+						break;
+					default:
+						this.other(token);
+						break;
+				}
+			}
+			this.endFile();
+		}
+		precheckMissedSemicolon() {}
+		raw(node2, prop, tokens, customProperty) {
+			let token, type;
+			let length = tokens.length;
+			let value = "";
+			let clean = true;
+			let next, prev;
+			for (let i = 0; i < length; i += 1) {
+				token = tokens[i];
+				type = token[0];
+				if (type === "space" && i === length - 1 && !customProperty) clean = false;
+				else if (type === "comment") {
+					prev = tokens[i - 1] ? tokens[i - 1][0] : "empty";
+					next = tokens[i + 1] ? tokens[i + 1][0] : "empty";
+					if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) if (value.slice(-1) === ",") clean = false;
+					else value += token[1];
+					else clean = false;
+				} else value += token[1];
+			}
+			if (!clean) {
+				let raw = tokens.reduce((all, i) => all + i[1], "");
+				node2.raws[prop] = {
+					raw,
+					value
+				};
+			}
+			node2[prop] = value;
+		}
+		rule(tokens) {
+			tokens.pop();
+			let node2 = new Rule();
+			this.init(node2, tokens[0][2]);
+			node2.raws.between = this.spacesAndCommentsFromEnd(tokens);
+			this.raw(node2, "selector", tokens);
+			this.current = node2;
+		}
+		spacesAndCommentsFromEnd(tokens) {
+			let lastTokenType;
+			let spaces = "";
+			while (tokens.length) {
+				lastTokenType = tokens[tokens.length - 1][0];
+				if (lastTokenType !== "space" && lastTokenType !== "comment") break;
+				spaces = tokens.pop()[1] + spaces;
+			}
+			return spaces;
+		}
+		spacesAndCommentsFromStart(tokens) {
+			let next;
+			let spaces = "";
+			while (tokens.length) {
+				next = tokens[0][0];
+				if (next !== "space" && next !== "comment") break;
+				spaces += tokens.shift()[1];
+			}
+			return spaces;
+		}
+		spacesFromEnd(tokens) {
+			let lastTokenType;
+			let spaces = "";
+			while (tokens.length) {
+				lastTokenType = tokens[tokens.length - 1][0];
+				if (lastTokenType !== "space") break;
+				spaces = tokens.pop()[1] + spaces;
+			}
+			return spaces;
+		}
+		stringFrom(tokens, from) {
+			let result2 = "";
+			for (let i = from; i < tokens.length; i++) result2 += tokens[i][1];
+			tokens.splice(from, tokens.length - from);
+			return result2;
+		}
+		unclosedBlock() {
+			let pos = this.current.source.start;
+			throw this.input.error("Unclosed block", pos.line, pos.column);
+		}
+		unclosedBracket(bracket) {
+			throw this.input.error("Unclosed bracket", { offset: bracket[2] }, { offset: bracket[2] + 1 });
+		}
+		unexpectedClose(token) {
+			throw this.input.error("Unexpected }", { offset: token[2] }, { offset: token[2] + 1 });
+		}
+		unknownWord(tokens) {
+			throw this.input.error("Unknown word", { offset: tokens[0][2] }, { offset: tokens[0][2] + tokens[0][1].length });
+		}
+		unnamedAtrule(node2, token) {
+			throw this.input.error("At-rule without name", { offset: token[2] }, { offset: token[2] + token[1].length });
+		}
+	}
+	parser = Parser;
+	return parser;
+}
+var parse_1;
+var hasRequiredParse;
+function requireParse() {
+	if (hasRequiredParse) return parse_1;
+	hasRequiredParse = 1;
+	let Container = requireContainer();
+	let Parser = requireParser();
+	let Input = requireInput();
+	function parse(css, opts) {
+		let parser2 = new Parser(new Input(css, opts));
+		try {
+			parser2.parse();
+		} catch (e) {
+			throw e;
+		}
+		return parser2.root;
+	}
+	parse_1 = parse;
+	parse.default = parse;
+	Container.registerParse(parse);
+	return parse_1;
+}
+var lazyResult;
+var hasRequiredLazyResult;
+function requireLazyResult() {
+	if (hasRequiredLazyResult) return lazyResult;
+	hasRequiredLazyResult = 1;
+	let { isClean, my } = requireSymbols();
+	let MapGenerator = requireMapGenerator();
+	let stringify = requireStringify();
+	let Container = requireContainer();
+	let Document = requireDocument();
+	requireWarnOnce();
+	let Result = requireResult();
+	let parse = requireParse();
+	let Root = requireRoot();
+	const TYPE_TO_CLASS_NAME = {
+		atrule: "AtRule",
+		comment: "Comment",
+		decl: "Declaration",
+		document: "Document",
+		root: "Root",
+		rule: "Rule"
+	};
+	const PLUGIN_PROPS = {
+		AtRule: true,
+		AtRuleExit: true,
+		Comment: true,
+		CommentExit: true,
+		Declaration: true,
+		DeclarationExit: true,
+		Document: true,
+		DocumentExit: true,
+		Once: true,
+		OnceExit: true,
+		postcssPlugin: true,
+		prepare: true,
+		Root: true,
+		RootExit: true,
+		Rule: true,
+		RuleExit: true
+	};
+	const NOT_VISITORS = {
+		Once: true,
+		postcssPlugin: true,
+		prepare: true
+	};
+	const CHILDREN = 0;
+	function isPromise(obj) {
+		return typeof obj === "object" && typeof obj.then === "function";
+	}
+	function getEvents(node2) {
+		let key = false;
+		let type = TYPE_TO_CLASS_NAME[node2.type];
+		if (node2.type === "decl") key = node2.prop.toLowerCase();
+		else if (node2.type === "atrule") key = node2.name.toLowerCase();
+		if (key && node2.append) return [
+			type,
+			type + "-" + key,
+			CHILDREN,
+			type + "Exit",
+			type + "Exit-" + key
+		];
+		else if (key) return [
+			type,
+			type + "-" + key,
+			type + "Exit",
+			type + "Exit-" + key
+		];
+		else if (node2.append) return [
+			type,
+			CHILDREN,
+			type + "Exit"
+		];
+		else return [type, type + "Exit"];
+	}
+	function toStack(node2) {
+		let events;
+		if (node2.type === "document") events = [
+			"Document",
+			CHILDREN,
+			"DocumentExit"
+		];
+		else if (node2.type === "root") events = [
+			"Root",
+			CHILDREN,
+			"RootExit"
+		];
+		else events = getEvents(node2);
+		return {
+			eventIndex: 0,
+			events,
+			iterator: 0,
+			node: node2,
+			visitorIndex: 0,
+			visitors: []
+		};
+	}
+	function cleanMarks(node2) {
+		node2[isClean] = false;
+		if (node2.nodes) node2.nodes.forEach((i) => cleanMarks(i));
+		return node2;
+	}
+	let postcss2 = {};
+	class LazyResult {
+		constructor(processor2, css, opts) {
+			this.stringified = false;
+			this.processed = false;
+			let root2;
+			if (typeof css === "object" && css !== null && (css.type === "root" || css.type === "document")) root2 = cleanMarks(css);
+			else if (css instanceof LazyResult || css instanceof Result) {
+				root2 = cleanMarks(css.root);
+				if (css.map) {
+					if (typeof opts.map === "undefined") opts.map = {};
+					if (!opts.map.inline) opts.map.inline = false;
+					opts.map.prev = css.map;
+				}
+			} else {
+				let parser2 = parse;
+				if (opts.syntax) parser2 = opts.syntax.parse;
+				if (opts.parser) parser2 = opts.parser;
+				if (parser2.parse) parser2 = parser2.parse;
+				try {
+					root2 = parser2(css, opts);
+				} catch (error) {
+					this.processed = true;
+					this.error = error;
+				}
+				if (root2 && !root2[my]) Container.rebuild(root2);
+			}
+			this.result = new Result(processor2, root2, opts);
+			this.helpers = {
+				...postcss2,
+				postcss: postcss2,
+				result: this.result
+			};
+			this.plugins = this.processor.plugins.map((plugin) => {
+				if (typeof plugin === "object" && plugin.prepare) return {
+					...plugin,
+					...plugin.prepare(this.result)
+				};
+				else return plugin;
+			});
+		}
+		async() {
+			if (this.error) return Promise.reject(this.error);
+			if (this.processed) return Promise.resolve(this.result);
+			if (!this.processing) this.processing = this.runAsync();
+			return this.processing;
+		}
+		catch(onRejected) {
+			return this.async().catch(onRejected);
+		}
+		finally(onFinally) {
+			return this.async().then(onFinally, onFinally);
+		}
+		getAsyncError() {
+			throw new Error("Use process(css).then(cb) to work with async plugins");
+		}
+		handleError(error, node2) {
+			let plugin = this.result.lastPlugin;
+			try {
+				if (node2) node2.addToError(error);
+				this.error = error;
+				if (error.name === "CssSyntaxError" && !error.plugin) {
+					error.plugin = plugin.postcssPlugin;
+					error.setMessage();
+				} else if (plugin.postcssVersion) {}
+			} catch (err) {
+				if (console && console.error) console.error(err);
+			}
+			return error;
+		}
+		prepareVisitors() {
+			this.listeners = {};
+			let add = (plugin, type, cb) => {
+				if (!this.listeners[type]) this.listeners[type] = [];
+				this.listeners[type].push([plugin, cb]);
+			};
+			for (let plugin of this.plugins) if (typeof plugin === "object") for (let event in plugin) {
+				if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) throw new Error(`Unknown event ${event} in ${plugin.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`);
+				if (!NOT_VISITORS[event]) {
+					if (typeof plugin[event] === "object") for (let filter in plugin[event]) if (filter === "*") add(plugin, event, plugin[event][filter]);
+					else add(plugin, event + "-" + filter.toLowerCase(), plugin[event][filter]);
+					else if (typeof plugin[event] === "function") add(plugin, event, plugin[event]);
+				}
+			}
+			this.hasListener = Object.keys(this.listeners).length > 0;
+		}
+		async runAsync() {
+			this.plugin = 0;
+			for (let i = 0; i < this.plugins.length; i++) {
+				let plugin = this.plugins[i];
+				let promise = this.runOnRoot(plugin);
+				if (isPromise(promise)) try {
+					await promise;
+				} catch (error) {
+					throw this.handleError(error);
+				}
+			}
+			this.prepareVisitors();
+			if (this.hasListener) {
+				let root2 = this.result.root;
+				while (!root2[isClean]) {
+					root2[isClean] = true;
+					let stack = [toStack(root2)];
+					while (stack.length > 0) {
+						let promise = this.visitTick(stack);
+						if (isPromise(promise)) try {
+							await promise;
+						} catch (e) {
+							let node2 = stack[stack.length - 1].node;
+							throw this.handleError(e, node2);
+						}
+					}
+				}
+				if (this.listeners.OnceExit) for (let [plugin, visitor] of this.listeners.OnceExit) {
+					this.result.lastPlugin = plugin;
+					try {
+						if (root2.type === "document") {
+							let roots = root2.nodes.map((subRoot) => visitor(subRoot, this.helpers));
+							await Promise.all(roots);
+						} else await visitor(root2, this.helpers);
+					} catch (e) {
+						throw this.handleError(e);
+					}
+				}
+			}
+			this.processed = true;
+			return this.stringify();
+		}
+		runOnRoot(plugin) {
+			this.result.lastPlugin = plugin;
+			try {
+				if (typeof plugin === "object" && plugin.Once) {
+					if (this.result.root.type === "document") {
+						let roots = this.result.root.nodes.map((root2) => plugin.Once(root2, this.helpers));
+						if (isPromise(roots[0])) return Promise.all(roots);
+						return roots;
+					}
+					return plugin.Once(this.result.root, this.helpers);
+				} else if (typeof plugin === "function") return plugin(this.result.root, this.result);
+			} catch (error) {
+				throw this.handleError(error);
+			}
+		}
+		stringify() {
+			if (this.error) throw this.error;
+			if (this.stringified) return this.result;
+			this.stringified = true;
+			this.sync();
+			let opts = this.result.opts;
+			let str = stringify;
+			if (opts.syntax) str = opts.syntax.stringify;
+			if (opts.stringifier) str = opts.stringifier;
+			if (str.stringify) str = str.stringify;
+			let data = new MapGenerator(str, this.result.root, this.result.opts).generate();
+			this.result.css = data[0];
+			this.result.map = data[1];
+			return this.result;
+		}
+		sync() {
+			if (this.error) throw this.error;
+			if (this.processed) return this.result;
+			this.processed = true;
+			if (this.processing) throw this.getAsyncError();
+			for (let plugin of this.plugins) if (isPromise(this.runOnRoot(plugin))) throw this.getAsyncError();
+			this.prepareVisitors();
+			if (this.hasListener) {
+				let root2 = this.result.root;
+				while (!root2[isClean]) {
+					root2[isClean] = true;
+					this.walkSync(root2);
+				}
+				if (this.listeners.OnceExit) if (root2.type === "document") for (let subRoot of root2.nodes) this.visitSync(this.listeners.OnceExit, subRoot);
+				else this.visitSync(this.listeners.OnceExit, root2);
+			}
+			return this.result;
+		}
+		then(onFulfilled, onRejected) {
+			return this.async().then(onFulfilled, onRejected);
+		}
+		toString() {
+			return this.css;
+		}
+		visitSync(visitors, node2) {
+			for (let [plugin, visitor] of visitors) {
+				this.result.lastPlugin = plugin;
+				let promise;
+				try {
+					promise = visitor(node2, this.helpers);
+				} catch (e) {
+					throw this.handleError(e, node2.proxyOf);
+				}
+				if (node2.type !== "root" && node2.type !== "document" && !node2.parent) return true;
+				if (isPromise(promise)) throw this.getAsyncError();
+			}
+		}
+		visitTick(stack) {
+			let visit2 = stack[stack.length - 1];
+			let { node: node2, visitors } = visit2;
+			if (node2.type !== "root" && node2.type !== "document" && !node2.parent) {
+				stack.pop();
+				return;
+			}
+			if (visitors.length > 0 && visit2.visitorIndex < visitors.length) {
+				let [plugin, visitor] = visitors[visit2.visitorIndex];
+				visit2.visitorIndex += 1;
+				if (visit2.visitorIndex === visitors.length) {
+					visit2.visitors = [];
+					visit2.visitorIndex = 0;
+				}
+				this.result.lastPlugin = plugin;
+				try {
+					return visitor(node2.toProxy(), this.helpers);
+				} catch (e) {
+					throw this.handleError(e, node2);
+				}
+			}
+			if (visit2.iterator !== 0) {
+				let iterator = visit2.iterator;
+				let child;
+				while (child = node2.nodes[node2.indexes[iterator]]) {
+					node2.indexes[iterator] += 1;
+					if (!child[isClean]) {
+						child[isClean] = true;
+						stack.push(toStack(child));
+						return;
+					}
+				}
+				visit2.iterator = 0;
+				delete node2.indexes[iterator];
+			}
+			let events = visit2.events;
+			while (visit2.eventIndex < events.length) {
+				let event = events[visit2.eventIndex];
+				visit2.eventIndex += 1;
+				if (event === CHILDREN) {
+					if (node2.nodes && node2.nodes.length) {
+						node2[isClean] = true;
+						visit2.iterator = node2.getIterator();
+					}
+					return;
+				} else if (this.listeners[event]) {
+					visit2.visitors = this.listeners[event];
+					return;
+				}
+			}
+			stack.pop();
+		}
+		walkSync(node2) {
+			node2[isClean] = true;
+			let events = getEvents(node2);
+			for (let event of events) if (event === CHILDREN) {
+				if (node2.nodes) node2.each((child) => {
+					if (!child[isClean]) this.walkSync(child);
+				});
+			} else {
+				let visitors = this.listeners[event];
+				if (visitors) {
+					if (this.visitSync(visitors, node2.toProxy())) return;
+				}
+			}
+		}
+		warnings() {
+			return this.sync().warnings();
+		}
+		get content() {
+			return this.stringify().content;
+		}
+		get css() {
+			return this.stringify().css;
+		}
+		get map() {
+			return this.stringify().map;
+		}
+		get messages() {
+			return this.sync().messages;
+		}
+		get opts() {
+			return this.result.opts;
+		}
+		get processor() {
+			return this.result.processor;
+		}
+		get root() {
+			return this.sync().root;
+		}
+		get [Symbol.toStringTag]() {
+			return "LazyResult";
+		}
+	}
+	LazyResult.registerPostcss = (dependant) => {
+		postcss2 = dependant;
+	};
+	lazyResult = LazyResult;
+	LazyResult.default = LazyResult;
+	Root.registerLazyResult(LazyResult);
+	Document.registerLazyResult(LazyResult);
+	return lazyResult;
+}
+var noWorkResult;
+var hasRequiredNoWorkResult;
+function requireNoWorkResult() {
+	if (hasRequiredNoWorkResult) return noWorkResult;
+	hasRequiredNoWorkResult = 1;
+	let MapGenerator = requireMapGenerator();
+	let stringify = requireStringify();
+	requireWarnOnce();
+	let parse = requireParse();
+	const Result = requireResult();
+	class NoWorkResult {
+		constructor(processor2, css, opts) {
+			css = css.toString();
+			this.stringified = false;
+			this._processor = processor2;
+			this._css = css;
+			this._opts = opts;
+			this._map = void 0;
+			let root2;
+			let str = stringify;
+			this.result = new Result(this._processor, root2, this._opts);
+			this.result.css = css;
+			let self = this;
+			Object.defineProperty(this.result, "root", { get() {
+				return self.root;
+			} });
+			let map = new MapGenerator(str, root2, this._opts, css);
+			if (map.isMap()) {
+				let [generatedCSS, generatedMap] = map.generate();
+				if (generatedCSS) this.result.css = generatedCSS;
+				if (generatedMap) this.result.map = generatedMap;
+			} else {
+				map.clearAnnotation();
+				this.result.css = map.css;
+			}
+		}
+		async() {
+			if (this.error) return Promise.reject(this.error);
+			return Promise.resolve(this.result);
+		}
+		catch(onRejected) {
+			return this.async().catch(onRejected);
+		}
+		finally(onFinally) {
+			return this.async().then(onFinally, onFinally);
+		}
+		sync() {
+			if (this.error) throw this.error;
+			return this.result;
+		}
+		then(onFulfilled, onRejected) {
+			return this.async().then(onFulfilled, onRejected);
+		}
+		toString() {
+			return this._css;
+		}
+		warnings() {
+			return [];
+		}
+		get content() {
+			return this.result.css;
+		}
+		get css() {
+			return this.result.css;
+		}
+		get map() {
+			return this.result.map;
+		}
+		get messages() {
+			return [];
+		}
+		get opts() {
+			return this.result.opts;
+		}
+		get processor() {
+			return this.result.processor;
+		}
+		get root() {
+			if (this._root) return this._root;
+			let root2;
+			let parser2 = parse;
+			try {
+				root2 = parser2(this._css, this._opts);
+			} catch (error) {
+				this.error = error;
+			}
+			if (this.error) throw this.error;
+			else {
+				this._root = root2;
+				return root2;
+			}
+		}
+		get [Symbol.toStringTag]() {
+			return "NoWorkResult";
+		}
+	}
+	noWorkResult = NoWorkResult;
+	NoWorkResult.default = NoWorkResult;
+	return noWorkResult;
+}
+var processor;
+var hasRequiredProcessor;
+function requireProcessor() {
+	if (hasRequiredProcessor) return processor;
+	hasRequiredProcessor = 1;
+	let NoWorkResult = requireNoWorkResult();
+	let LazyResult = requireLazyResult();
+	let Document = requireDocument();
+	let Root = requireRoot();
+	class Processor {
+		constructor(plugins = []) {
+			this.version = "8.4.38";
+			this.plugins = this.normalize(plugins);
+		}
+		normalize(plugins) {
+			let normalized = [];
+			for (let i of plugins) {
+				if (i.postcss === true) i = i();
+				else if (i.postcss) i = i.postcss;
+				if (typeof i === "object" && Array.isArray(i.plugins)) normalized = normalized.concat(i.plugins);
+				else if (typeof i === "object" && i.postcssPlugin) normalized.push(i);
+				else if (typeof i === "function") normalized.push(i);
+				else if (typeof i === "object" && (i.parse || i.stringify)) {} else throw new Error(i + " is not a PostCSS plugin");
+			}
+			return normalized;
+		}
+		process(css, opts = {}) {
+			if (!this.plugins.length && !opts.parser && !opts.stringifier && !opts.syntax) return new NoWorkResult(this, css, opts);
+			else return new LazyResult(this, css, opts);
+		}
+		use(plugin) {
+			this.plugins = this.plugins.concat(this.normalize([plugin]));
+			return this;
+		}
+	}
+	processor = Processor;
+	Processor.default = Processor;
+	Root.registerProcessor(Processor);
+	Document.registerProcessor(Processor);
+	return processor;
+}
+var fromJSON_1;
+var hasRequiredFromJSON;
+function requireFromJSON() {
+	if (hasRequiredFromJSON) return fromJSON_1;
+	hasRequiredFromJSON = 1;
+	let Declaration = requireDeclaration();
+	let PreviousMap = requirePreviousMap();
+	let Comment = requireComment();
+	let AtRule = requireAtRule();
+	let Input = requireInput();
+	let Root = requireRoot();
+	let Rule = requireRule();
+	function fromJSON(json, inputs) {
+		if (Array.isArray(json)) return json.map((n) => fromJSON(n));
+		let { inputs: ownInputs, ...defaults } = json;
+		if (ownInputs) {
+			inputs = [];
+			for (let input2 of ownInputs) {
+				let inputHydrated = {
+					...input2,
+					__proto__: Input.prototype
+				};
+				if (inputHydrated.map) inputHydrated.map = {
+					...inputHydrated.map,
+					__proto__: PreviousMap.prototype
+				};
+				inputs.push(inputHydrated);
+			}
+		}
+		if (defaults.nodes) defaults.nodes = json.nodes.map((n) => fromJSON(n, inputs));
+		if (defaults.source) {
+			let { inputId, ...source } = defaults.source;
+			defaults.source = source;
+			if (inputId != null) defaults.source.input = inputs[inputId];
+		}
+		if (defaults.type === "root") return new Root(defaults);
+		else if (defaults.type === "decl") return new Declaration(defaults);
+		else if (defaults.type === "rule") return new Rule(defaults);
+		else if (defaults.type === "comment") return new Comment(defaults);
+		else if (defaults.type === "atrule") return new AtRule(defaults);
+		else throw new Error("Unknown node type: " + json.type);
+	}
+	fromJSON_1 = fromJSON;
+	fromJSON.default = fromJSON;
+	return fromJSON_1;
+}
+var postcss_1;
+var hasRequiredPostcss;
+function requirePostcss() {
+	if (hasRequiredPostcss) return postcss_1;
+	hasRequiredPostcss = 1;
+	let CssSyntaxError = requireCssSyntaxError();
+	let Declaration = requireDeclaration();
+	let LazyResult = requireLazyResult();
+	let Container = requireContainer();
+	let Processor = requireProcessor();
+	let stringify = requireStringify();
+	let fromJSON = requireFromJSON();
+	let Document = requireDocument();
+	let Warning = requireWarning();
+	let Comment = requireComment();
+	let AtRule = requireAtRule();
+	let Result = requireResult();
+	let Input = requireInput();
+	let parse = requireParse();
+	let list = requireList();
+	let Rule = requireRule();
+	let Root = requireRoot();
+	let Node = requireNode();
+	function postcss2(...plugins) {
+		if (plugins.length === 1 && Array.isArray(plugins[0])) plugins = plugins[0];
+		return new Processor(plugins);
+	}
+	postcss2.plugin = function plugin(name, initializer) {
+		let warningPrinted = false;
+		function creator(...args) {
+			if (console && console.warn && !warningPrinted) {
+				warningPrinted = true;
+				console.warn(name + ": postcss.plugin was deprecated. Migration guide:\nhttps://evilmartians.com/chronicles/postcss-8-plugin-migration");
+				if ({}.LANG && {}.LANG.startsWith("cn")) console.warn(name + ": 里面 postcss.plugin 被弃用. 迁移指南:\nhttps://www.w3ctech.com/topic/2226");
+			}
+			let transformer = initializer(...args);
+			transformer.postcssPlugin = name;
+			transformer.postcssVersion = new Processor().version;
+			return transformer;
+		}
+		let cache;
+		Object.defineProperty(creator, "postcss", { get() {
+			if (!cache) cache = creator();
+			return cache;
+		} });
+		creator.process = function(css, processOpts, pluginOpts) {
+			return postcss2([creator(pluginOpts)]).process(css, processOpts);
+		};
+		return creator;
+	};
+	postcss2.stringify = stringify;
+	postcss2.parse = parse;
+	postcss2.fromJSON = fromJSON;
+	postcss2.list = list;
+	postcss2.comment = (defaults) => new Comment(defaults);
+	postcss2.atRule = (defaults) => new AtRule(defaults);
+	postcss2.decl = (defaults) => new Declaration(defaults);
+	postcss2.rule = (defaults) => new Rule(defaults);
+	postcss2.root = (defaults) => new Root(defaults);
+	postcss2.document = (defaults) => new Document(defaults);
+	postcss2.CssSyntaxError = CssSyntaxError;
+	postcss2.Declaration = Declaration;
+	postcss2.Container = Container;
+	postcss2.Processor = Processor;
+	postcss2.Document = Document;
+	postcss2.Comment = Comment;
+	postcss2.Warning = Warning;
+	postcss2.AtRule = AtRule;
+	postcss2.Result = Result;
+	postcss2.Input = Input;
+	postcss2.Rule = Rule;
+	postcss2.Root = Root;
+	postcss2.Node = Node;
+	LazyResult.registerPostcss(postcss2);
+	postcss_1 = postcss2;
+	postcss2.default = postcss2;
+	return postcss_1;
+}
+var postcss = /* @__PURE__ */ getDefaultExportFromCjs(requirePostcss());
+postcss.stringify;
+postcss.fromJSON;
+postcss.plugin;
+postcss.parse;
+postcss.list;
+postcss.document;
+postcss.comment;
+postcss.atRule;
+postcss.rule;
+postcss.decl;
+postcss.root;
+postcss.CssSyntaxError;
+postcss.Declaration;
+postcss.Container;
+postcss.Processor;
+postcss.Document;
+postcss.Comment;
+postcss.Warning;
+postcss.AtRule;
+postcss.Result;
+postcss.Input;
+postcss.Rule;
+postcss.Root;
+postcss.Node;
+var tagMap = {
+	script: "noscript",
+	altglyph: "altGlyph",
+	altglyphdef: "altGlyphDef",
+	altglyphitem: "altGlyphItem",
+	animatecolor: "animateColor",
+	animatemotion: "animateMotion",
+	animatetransform: "animateTransform",
+	clippath: "clipPath",
+	feblend: "feBlend",
+	fecolormatrix: "feColorMatrix",
+	fecomponenttransfer: "feComponentTransfer",
+	fecomposite: "feComposite",
+	feconvolvematrix: "feConvolveMatrix",
+	fediffuselighting: "feDiffuseLighting",
+	fedisplacementmap: "feDisplacementMap",
+	fedistantlight: "feDistantLight",
+	fedropshadow: "feDropShadow",
+	feflood: "feFlood",
+	fefunca: "feFuncA",
+	fefuncb: "feFuncB",
+	fefuncg: "feFuncG",
+	fefuncr: "feFuncR",
+	fegaussianblur: "feGaussianBlur",
+	feimage: "feImage",
+	femerge: "feMerge",
+	femergenode: "feMergeNode",
+	femorphology: "feMorphology",
+	feoffset: "feOffset",
+	fepointlight: "fePointLight",
+	fespecularlighting: "feSpecularLighting",
+	fespotlight: "feSpotLight",
+	fetile: "feTile",
+	feturbulence: "feTurbulence",
+	foreignobject: "foreignObject",
+	glyphref: "glyphRef",
+	lineargradient: "linearGradient",
+	radialgradient: "radialGradient"
+};
+function getTagName(n) {
+	let tagName = tagMap[n.tagName] ? tagMap[n.tagName] : n.tagName;
+	if (tagName === "link" && n.attributes._cssText) tagName = "style";
+	return tagName;
+}
+function adaptCssForReplay(cssText, cache) {
+	const cachedStyle = cache == null ? void 0 : cache.stylesWithHoverClass.get(cssText);
+	if (cachedStyle) return cachedStyle;
+	let result2 = cssText;
+	try {
+		result2 = postcss([mediaSelectorPlugin, pseudoClassPlugin]).process(cssText).css;
+	} catch (error) {
+		console.warn("Failed to adapt css for replay", error);
+	}
+	cache == null || cache.stylesWithHoverClass.set(cssText, result2);
+	return result2;
+}
+function createCache() {
+	return { stylesWithHoverClass: /* @__PURE__ */ new Map() };
+}
+var REBUILD_TARGET_ERROR = "rrweb-snapshot.rebuild() cannot rebuild into an unprotected browser document. Use rebuildIntoSandboxedIframe() or set UNSAFE_allowUnprotectedRebuild: true only when you accept the script-execution risk.";
+var SANDBOXED_IFRAME_ROOT_ERROR = "rrweb-snapshot.createSandboxedIframe() requires root to be connected to a document before creating a sandboxed iframe.";
+var sandboxedRebuildDocuments = /* @__PURE__ */ new WeakSet();
+function isSupportedSandboxedIframe(frameElement) {
+	if (!frameElement || frameElement.tagName !== "IFRAME") return false;
+	if (!("sandbox" in frameElement)) return false;
+	const sandboxTokens = Array.from(frameElement.sandbox);
+	return sandboxTokens.length === 1 && sandboxTokens[0] === "allow-same-origin";
+}
+function assertRebuildTargetAllowed(options) {
+	if (options.UNSAFE_allowUnprotectedRebuild) return;
+	const win = options.doc.defaultView;
+	if (!win) return;
+	if (sandboxedRebuildDocuments.has(options.doc) && isSupportedSandboxedIframe(win.frameElement)) return;
+	throw new Error(REBUILD_TARGET_ERROR);
+}
+function applyCssSplits(n, cssText, hackCss, cache) {
+	const childTextNodes = [];
+	for (const scn of n.childNodes) if (scn.type === NodeType.Text) childTextNodes.push(scn);
+	const cssTextSplits = cssText.split("/* rr_split */");
+	while (cssTextSplits.length > 1 && cssTextSplits.length > childTextNodes.length) cssTextSplits.splice(-2, 2, cssTextSplits.slice(-2).join(""));
+	let adaptedCss = "";
+	if (hackCss) adaptedCss = adaptCssForReplay(cssTextSplits.join(""), cache);
+	let startIndex = 0;
+	for (let i = 0; i < childTextNodes.length; i++) {
+		if (i === cssTextSplits.length) break;
+		const childTextNode = childTextNodes[i];
+		if (!hackCss) childTextNode.textContent = cssTextSplits[i];
+		else if (i < cssTextSplits.length - 1) {
+			let endIndex = startIndex;
+			let endSearch = cssTextSplits[i + 1].length;
+			endSearch = Math.min(endSearch, 30);
+			let found = false;
+			for (; endSearch > 2; endSearch--) {
+				const searchBit = cssTextSplits[i + 1].substring(0, endSearch);
+				const searchIndex = adaptedCss.substring(startIndex).indexOf(searchBit);
+				found = searchIndex !== -1;
+				if (found) {
+					endIndex += searchIndex;
+					break;
+				}
+			}
+			if (!found) endIndex += cssTextSplits[i].length;
+			childTextNode.textContent = adaptedCss.substring(startIndex, endIndex);
+			startIndex = endIndex;
+		} else childTextNode.textContent = adaptedCss.substring(startIndex);
+	}
+}
+function buildStyleNode(n, styleEl, cssText, options) {
+	const { doc, hackCss, cache } = options;
+	if (n.childNodes.length) applyCssSplits(n, cssText, hackCss, cache);
+	else {
+		if (hackCss) cssText = adaptCssForReplay(cssText, cache);
+		styleEl.appendChild(doc.createTextNode(cssText));
+	}
+}
+function buildNode(n, options) {
+	var _a;
+	const { doc, hackCss, cache } = options;
+	switch (n.type) {
+		case NodeType.Document: return doc.implementation.createDocument(null, "", null);
+		case NodeType.DocumentType: return doc.implementation.createDocumentType(n.name || "html", n.publicId, n.systemId);
+		case NodeType.Element: {
+			const tagName = getTagName(n);
+			let node2;
+			if (n.isSVG) node2 = doc.createElementNS("http://www.w3.org/2000/svg", tagName);
+			else {
+				if (n.isCustom && ((_a = doc.defaultView) == null ? void 0 : _a.customElements) && !doc.defaultView.customElements.get(n.tagName)) doc.defaultView.customElements.define(n.tagName, class extends doc.defaultView.HTMLElement {});
+				node2 = doc.createElement(tagName);
+			}
+			const specialAttributes = {};
+			for (const name in n.attributes) {
+				if (!Object.prototype.hasOwnProperty.call(n.attributes, name)) continue;
+				let value = n.attributes[name];
+				if (tagName === "option" && name === "selected" && value === false) continue;
+				if (value === null) continue;
+				if (value === true) value = "";
+				if (name.startsWith("rr_")) {
+					specialAttributes[name] = value;
+					continue;
+				}
+				if (typeof value !== "string");
+				else if (tagName === "style" && name === "_cssText") {
+					buildStyleNode(n, node2, value, options);
+					continue;
+				} else if (tagName === "textarea" && name === "value") {
+					node2.appendChild(doc.createTextNode(value));
+					n.childNodes = [];
+					continue;
+				}
+				try {
+					if (n.isSVG && name === "xlink:href") node2.setAttributeNS("http://www.w3.org/1999/xlink", name, value.toString());
+					else if (name === "onload" || name === "onclick" || name.substring(0, 7) === "onmouse") node2.setAttribute("_" + name, value.toString());
+					else if (tagName === "meta" && n.attributes["http-equiv"] === "Content-Security-Policy" && name === "content") {
+						node2.setAttribute("csp-content", value.toString());
+						continue;
+					} else if (tagName === "link" && (n.attributes.rel === "preload" && n.attributes.as === "script" || n.attributes.rel === "modulepreload")) {} else if (tagName === "link" && n.attributes.rel === "prefetch" && typeof n.attributes.href === "string" && extractFileExtension(n.attributes.href) === "js") {} else if (tagName === "img" && n.attributes.srcset && n.attributes.rr_dataURL) node2.setAttribute("rrweb-original-srcset", n.attributes.srcset);
+					else node2.setAttribute(name, value.toString());
+				} catch (error) {}
+			}
+			for (const name in specialAttributes) {
+				const value = specialAttributes[name];
+				if (tagName === "canvas" && name === "rr_dataURL") {
+					const image = doc.createElement("img");
+					image.onload = () => {
+						const ctx = node2.getContext("2d");
+						if (ctx) ctx.drawImage(image, 0, 0, image.width, image.height);
+					};
+					image.src = value.toString();
+					if (node2.RRNodeType) node2.rr_dataURL = value.toString();
+				} else if (tagName === "img" && name === "rr_dataURL") {
+					const image = node2;
+					if (!image.currentSrc.startsWith("data:")) {
+						image.setAttribute("rrweb-original-src", n.attributes.src);
+						image.src = value.toString();
+					}
+				}
+				if (name === "rr_width") node2.style.setProperty("width", value.toString());
+				else if (name === "rr_height") node2.style.setProperty("height", value.toString());
+				else if (name === "rr_mediaCurrentTime" && typeof value === "number") node2.currentTime = value;
+				else if (name === "rr_mediaState") switch (value) {
+					case "played":
+						node2.play().catch((e) => console.warn("media playback error", e));
+						break;
+					case "paused":
+						node2.pause();
+						break;
+				}
+				else if (name === "rr_mediaPlaybackRate" && typeof value === "number") node2.playbackRate = value;
+				else if (name === "rr_mediaMuted" && typeof value === "boolean") node2.muted = value;
+				else if (name === "rr_mediaLoop" && typeof value === "boolean") node2.loop = value;
+				else if (name === "rr_mediaVolume" && typeof value === "number") node2.volume = value;
+				else if (name === "rr_open_mode") node2.setAttribute("rr_open_mode", value);
+			}
+			if (n.isShadowHost) if (!node2.shadowRoot) node2.attachShadow({ mode: "open" });
+			else while (node2.shadowRoot.firstChild) node2.shadowRoot.removeChild(node2.shadowRoot.firstChild);
+			return node2;
+		}
+		case NodeType.Text:
+			if (n.isStyle && hackCss) return doc.createTextNode(adaptCssForReplay(n.textContent, cache));
+			return doc.createTextNode(n.textContent);
+		case NodeType.CDATA: return doc.createCDATASection(n.textContent);
+		case NodeType.Comment: return doc.createComment(n.textContent);
+		default: return null;
+	}
+}
+function buildNodeWithSN(n, options) {
+	const { doc, mirror, skipChild = false, hackCss = true, afterAppend, cache } = options;
+	if (mirror.has(n.id)) {
+		const nodeInMirror = mirror.getNode(n.id);
+		if (isNodeMetaEqual(mirror.getMeta(nodeInMirror), n)) return mirror.getNode(n.id);
+	}
+	let node2 = buildNode(n, {
+		doc,
+		hackCss,
+		cache
+	});
+	if (!node2) return null;
+	if (n.rootId && mirror.getNode(n.rootId) !== doc) mirror.replace(n.rootId, doc);
+	if (n.type === NodeType.Document) {
+		doc.close();
+		doc.open();
+		if (n.compatMode === "BackCompat" && n.childNodes && n.childNodes[0].type !== NodeType.DocumentType) if (n.childNodes[0].type === NodeType.Element && "xmlns" in n.childNodes[0].attributes && n.childNodes[0].attributes.xmlns === "http://www.w3.org/1999/xhtml") doc.write("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"\">");
+		else doc.write("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\" \"\">");
+		node2 = doc;
+	}
+	mirror.add(node2, n);
+	if ((n.type === NodeType.Document || n.type === NodeType.Element) && !skipChild) for (const childN of n.childNodes) {
+		const childNode = buildNodeWithSN(childN, {
+			doc,
+			mirror,
+			skipChild: false,
+			hackCss,
+			afterAppend,
+			cache
+		});
+		if (!childNode) {
+			console.warn("Failed to rebuild", childN);
+			continue;
+		}
+		if (childN.isShadow && isElement(node2) && node2.shadowRoot) node2.shadowRoot.appendChild(childNode);
+		else if (n.type === NodeType.Document && childN.type == NodeType.Element) {
+			const htmlElement = childNode;
+			let body = null;
+			htmlElement.childNodes.forEach((child) => {
+				if (child.nodeName === "BODY") body = child;
+			});
+			if (body) {
+				htmlElement.removeChild(body);
+				node2.appendChild(childNode);
+				htmlElement.appendChild(body);
+			} else node2.appendChild(childNode);
+		} else node2.appendChild(childNode);
+		if (afterAppend) afterAppend(childNode, childN.id);
+	}
+	return node2;
+}
+function visit(mirror, onVisit) {
+	function walk(node2) {
+		onVisit(node2);
+	}
+	for (const id of mirror.getIds()) if (mirror.has(id)) walk(mirror.getNode(id));
+}
+function handleScroll(node2, mirror) {
+	const n = mirror.getMeta(node2);
+	if ((n == null ? void 0 : n.type) !== NodeType.Element) return;
+	const el = node2;
+	for (const name in n.attributes) {
+		if (!(Object.prototype.hasOwnProperty.call(n.attributes, name) && name.startsWith("rr_"))) continue;
+		const value = n.attributes[name];
+		if (name === "rr_scrollLeft") el.scrollLeft = value;
+		if (name === "rr_scrollTop") el.scrollTop = value;
+	}
+}
+function rebuild(n, options) {
+	assertRebuildTargetAllowed(options);
+	const { doc, onVisit, hackCss = true, afterAppend, cache, mirror = new Mirror() } = options;
+	const node2 = buildNodeWithSN(n, {
+		doc,
+		mirror,
+		skipChild: false,
+		hackCss,
+		afterAppend,
+		cache
+	});
+	visit(mirror, (visitedNode) => {
+		if (onVisit) onVisit(visitedNode);
+		handleScroll(visitedNode, mirror);
+	});
+	return node2;
+}
+function createSandboxedIframe(options) {
+	var _a;
+	if (!options.root.isConnected) throw new Error(SANDBOXED_IFRAME_ROOT_ERROR);
+	const iframe = options.root.ownerDocument.createElement("iframe");
+	for (const [name, value] of Object.entries(options.iframeAttributes || {})) {
+		if (name === "sandbox") continue;
+		iframe.setAttribute(name, value);
+	}
+	iframe.setAttribute("sandbox", "allow-same-origin");
+	options.root.appendChild(iframe);
+	const doc = iframe.contentDocument;
+	if (!doc || !iframe.contentWindow) {
+		(_a = iframe.parentNode) == null || _a.removeChild(iframe);
+		throw new Error(SANDBOXED_IFRAME_ROOT_ERROR);
+	}
+	sandboxedRebuildDocuments.add(doc);
+	return iframe;
+}
+function rebuildIntoSandboxedIframe(n, options) {
+	var _a;
+	const iframe = createSandboxedIframe(options);
+	const doc = iframe.contentDocument;
+	let node2;
+	try {
+		node2 = rebuild(n, {
+			...options,
+			doc
+		});
+	} catch (error) {
+		(_a = iframe.parentNode) == null || _a.removeChild(iframe);
+		throw error;
+	}
+	return {
+		iframe,
+		node: node2
+	};
+}
+
+//#endregion
+export { IGNORED_NODE, Mirror, absolutifyURLs, adaptCssForReplay, buildNodeWithSN, classMatchesRegex, cleanupSnapshot, createCache, createMirror, createSandboxedIframe, escapeImportStatement, extractFileExtension, fixSafariColons, genId, getInputType, ignoreAttribute, is2DCanvasBlank, isCSSImportRule, isCSSStyleRule, isElement, isNativeShadowDom, isNodeMetaEqual, isShadowRoot, markCssSplits, maskInputValue, needMaskingText, normalizeCssString, rebuild, rebuildIntoSandboxedIframe, serializeNodeWithId, slimDOMDefaults, snapshot, splitCssText, stringifyRule, stringifyStylesheet, toLowerCase, transformAttribute, visitSnapshot };