sheetom 0.1.0-rc.0

package/dist/index.cjs

@@ -0,0 +1,3644 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let lightningcss = require("lightningcss");
+let css_tree = require("css-tree");
+css_tree = __toESM(css_tree, 1);
+let _csstools_css_tokenizer = require("@csstools/css-tokenizer");
+let cssstyle = require("cssstyle");
+//#region src/internal/declaration-block.ts
+/** Owns ordered declaration records and all atomic mutation decisions. */
+var DeclarationBlock = class {
+	#codec;
+	#reportDiagnostic;
+	#records = [];
+	constructor(codec, reportDiagnostic) {
+		this.#codec = codec;
+		this.#reportDiagnostic = reportDiagnostic;
+	}
+	replace(declarations) {
+		if (!declarations) {
+			this.#records.splice(0);
+			return;
+		}
+		const winners = /* @__PURE__ */ new Map();
+		let sourceIndex = 0;
+		const consider = (record, subIndex) => {
+			if (winners.get(record.name)?.important && !record.important) return;
+			winners.set(record.name, {
+				...record,
+				sourceIndex,
+				subIndex
+			});
+		};
+		for (const declaration of declarations) {
+			const name = declaration.name.startsWith("--") ? declaration.name : declaration.name.toLowerCase();
+			const propertyValue = this.#codec.parseValue(name, declaration.value);
+			if (!propertyValue) {
+				sourceIndex += 1;
+				continue;
+			}
+			const longhands = this.#codec.shorthandLonghands(name);
+			if (propertyValue.pendingSubstitution && longhands) {
+				const pendingGroup = {
+					shorthand: name,
+					observableValue: propertyValue.observableValue,
+					safeValue: propertyValue.safeValue
+				};
+				for (let index = 0; index < longhands.length; index += 1) {
+					const longhand = longhands[index];
+					if (!longhand) continue;
+					consider({
+						name: longhand,
+						observableValue: "",
+						safeValue: "",
+						pendingSubstitution: true,
+						important: declaration.important,
+						pendingGroup
+					}, index);
+				}
+				sourceIndex += 1;
+				continue;
+			}
+			const expansion = this.#codec.expandFourSide(name, propertyValue, declaration.important) ?? this.#codec.expandShorthand(name, propertyValue, declaration.important);
+			if (expansion) {
+				for (let index = 0; index < expansion.length; index += 1) {
+					const record = expansion[index];
+					if (record) consider(record, index);
+				}
+				sourceIndex += 1;
+				continue;
+			}
+			consider({
+				name,
+				...propertyValue,
+				important: declaration.important,
+				pendingGroup: null
+			}, 0);
+			sourceIndex += 1;
+		}
+		const records = [...winners.values()].sort((left, right) => {
+			if (left.important !== right.important) return left.important ? 1 : -1;
+			return left.sourceIndex - right.sourceIndex || left.subIndex - right.subIndex;
+		});
+		this.#records.splice(0, this.#records.length, ...records);
+	}
+	get length() {
+		return this.#records.length;
+	}
+	item(index) {
+		return this.#records[this.#codec.normalizeIndex(index)]?.name ?? "";
+	}
+	getPropertyValue(name) {
+		const normalizedName = name.startsWith("--") ? name : name.toLowerCase();
+		const shorthand = this.#shorthand(normalizedName, false);
+		if (shorthand) return shorthand.value;
+		return this.#records.find((record) => record.name === normalizedName)?.observableValue ?? "";
+	}
+	getPropertyPriority(name) {
+		const normalizedName = name.startsWith("--") ? name : name.toLowerCase();
+		const shorthand = this.#shorthand(normalizedName, false);
+		if (shorthand) return shorthand.important ? "important" : "";
+		return this.#records.find((record) => record.name === normalizedName)?.important ? "important" : "";
+	}
+	setProperty(name, value, priority) {
+		const normalizedName = name.startsWith("--") ? name : name.toLowerCase();
+		const normalizedPriority = priority.toLowerCase();
+		if (normalizedPriority !== "" && normalizedPriority !== "important") {
+			this.#reportDiagnostic("INVALID_PRIORITY", normalizedName, priority);
+			return;
+		}
+		if (value === "") {
+			this.removeProperty(normalizedName);
+			return;
+		}
+		const parsed = this.#codec.parseValue(normalizedName, value);
+		if (!parsed) {
+			this.#reportDiagnostic("INVALID_PROPERTY_VALUE", normalizedName, value);
+			return;
+		}
+		const important = normalizedPriority === "important";
+		const longhands = this.#codec.shorthandLonghands(normalizedName);
+		if (parsed.pendingSubstitution && longhands) {
+			const pendingGroup = {
+				shorthand: normalizedName,
+				observableValue: parsed.observableValue,
+				safeValue: parsed.safeValue
+			};
+			for (const longhand of longhands) this.#commitRecord(longhand, {
+				observableValue: "",
+				safeValue: "",
+				pendingSubstitution: true
+			}, important, pendingGroup);
+			return;
+		}
+		const expansion = this.#codec.expandFourSide(normalizedName, parsed, important) ?? this.#codec.expandShorthand(normalizedName, parsed, important);
+		if (expansion) {
+			for (const record of expansion) this.#commitRecord(record.name, record, record.important, record.pendingGroup);
+			return;
+		}
+		this.#commitRecord(normalizedName, parsed, important);
+	}
+	removeProperty(name) {
+		const normalizedName = name.startsWith("--") ? name : name.toLowerCase();
+		const longhands = this.#codec.shorthandLonghands(normalizedName);
+		if (longhands) {
+			const previousValue = this.getPropertyValue(normalizedName);
+			const names = /* @__PURE__ */ new Set([normalizedName, ...longhands]);
+			for (let index = this.#records.length - 1; index >= 0; index -= 1) {
+				const record = this.#records[index];
+				if (record && names.has(record.name)) this.#records.splice(index, 1);
+			}
+			return previousValue;
+		}
+		const index = this.#records.findIndex((record) => record.name === normalizedName);
+		if (index === -1) return "";
+		const [removed] = this.#records.splice(index, 1);
+		return removed?.observableValue ?? "";
+	}
+	serialize(safe, indent, separator) {
+		const declarations = [];
+		const writtenPendingGroups = /* @__PURE__ */ new Set();
+		const writtenStaticShorthands = /* @__PURE__ */ new Set();
+		const staticShorthands = /* @__PURE__ */ new Map();
+		for (const name of [
+			"padding",
+			"margin",
+			"inset",
+			"border-width",
+			"border-style",
+			"border-color",
+			"scroll-margin",
+			"scroll-padding"
+		]) {
+			const shorthand = this.#shorthand(name, safe);
+			if (shorthand) staticShorthands.set(name, shorthand);
+		}
+		for (const record of this.#records) {
+			const pendingGroup = record.pendingGroup;
+			if (pendingGroup) {
+				const shorthand = this.#shorthand(pendingGroup.shorthand, safe);
+				if (shorthand) {
+					if (writtenPendingGroups.has(pendingGroup)) continue;
+					declarations.push(`${indent}${pendingGroup.shorthand}: ${shorthand.value}${shorthand.important ? " !important" : ""};`);
+					writtenPendingGroups.add(pendingGroup);
+					continue;
+				}
+			}
+			let staticShorthandWritten = false;
+			for (const [name, shorthand] of staticShorthands) {
+				if (!this.#codec.shorthandLonghands(name)?.includes(record.name)) continue;
+				if (!writtenStaticShorthands.has(name)) {
+					declarations.push(`${indent}${name}: ${shorthand.value}${shorthand.important ? " !important" : ""};`);
+					writtenStaticShorthands.add(name);
+				}
+				staticShorthandWritten = true;
+				break;
+			}
+			if (staticShorthandWritten) continue;
+			const name = record.name.startsWith("--") ? this.#codec.serializeIdentifier(record.name) : record.name;
+			const value = safe ? record.safeValue : record.observableValue;
+			declarations.push(`${indent}${name}: ${value}${record.important ? " !important" : ""};`);
+		}
+		return declarations.join(separator);
+	}
+	#commitRecord(name, parsed, important, pendingGroup = null) {
+		const existing = this.#records.find((record) => record.name === name);
+		if (existing) {
+			existing.observableValue = parsed.observableValue;
+			existing.safeValue = parsed.safeValue;
+			existing.pendingSubstitution = parsed.pendingSubstitution;
+			existing.important = important;
+			existing.pendingGroup = pendingGroup;
+			return;
+		}
+		this.#records.push({
+			name,
+			...parsed,
+			important,
+			pendingGroup
+		});
+	}
+	#shorthand(name, safe) {
+		const longhands = this.#codec.shorthandLonghands(name);
+		if (!longhands) return null;
+		const records = longhands.map((longhand) => this.#records.find((record) => record.name === longhand));
+		if (records.some((record) => record === void 0)) return null;
+		const first = records[0];
+		if (!first || records.some((record) => record?.important !== first.important)) return null;
+		const pendingGroup = first.pendingGroup;
+		if (pendingGroup?.shorthand === name && records.every((record) => record?.pendingGroup === pendingGroup)) return {
+			value: safe ? pendingGroup.safeValue : pendingGroup.observableValue,
+			important: first.important
+		};
+		if (records.some((record) => record?.pendingGroup)) return null;
+		if (!this.#codec.isFourSideShorthand(name) || records.length !== 4) return null;
+		const [top, right, bottom, left] = records;
+		if (!top || !right || !bottom || !left) return null;
+		return {
+			value: compressFourSides([
+				top,
+				right,
+				bottom,
+				left
+			].map((record) => safe ? record.safeValue : record.observableValue)),
+			important: first.important
+		};
+	}
+};
+function compressFourSides([top, right, bottom, left]) {
+	if (top === right && top === bottom && top === left) return top;
+	if (top === bottom && right === left) return `${top} ${right}`;
+	if (right === left) return `${top} ${right} ${bottom}`;
+	return [
+		top,
+		right,
+		bottom,
+		left
+	].join(" ");
+}
+//#endregion
+//#region src/internal/css-rule-scanner.ts
+const trivia = /* @__PURE__ */ new Set([
+	_csstools_css_tokenizer.TokenType.Whitespace,
+	_csstools_css_tokenizer.TokenType.Comment,
+	_csstools_css_tokenizer.TokenType.CDO,
+	_csstools_css_tokenizer.TokenType.CDC
+]);
+const closingFor = /* @__PURE__ */ new Map([
+	[_csstools_css_tokenizer.TokenType.Function, _csstools_css_tokenizer.TokenType.CloseParen],
+	[_csstools_css_tokenizer.TokenType.OpenParen, _csstools_css_tokenizer.TokenType.CloseParen],
+	[_csstools_css_tokenizer.TokenType.OpenSquare, _csstools_css_tokenizer.TokenType.CloseSquare],
+	[_csstools_css_tokenizer.TokenType.OpenCurly, _csstools_css_tokenizer.TokenType.CloseCurly]
+]);
+/** Consumes top-level CSS Syntax rules and retains their exact UTF-16 spans. */
+function scanTopLevelRules(css) {
+	const tokens = (0, _csstools_css_tokenizer.tokenize)({ css });
+	const rules = [];
+	let index = 0;
+	while (index < tokens.length) {
+		const token = tokens[index];
+		if (!token || token[0] === _csstools_css_tokenizer.TokenType.EOF) break;
+		if (trivia.has(token[0]) || token[0] === _csstools_css_tokenizer.TokenType.Semicolon) {
+			index += 1;
+			continue;
+		}
+		if (token[0] === _csstools_css_tokenizer.TokenType.CloseCurly) {
+			index += 1;
+			continue;
+		}
+		const start = token[2];
+		const stack = [];
+		let end = token[3];
+		let foundBoundary = false;
+		for (; index < tokens.length; index += 1) {
+			const current = tokens[index];
+			if (!current || current[0] === _csstools_css_tokenizer.TokenType.EOF) break;
+			end = current[3];
+			const closing = closingFor.get(current[0]);
+			if (closing) {
+				stack.push(closing);
+				continue;
+			}
+			const expected = stack.at(-1);
+			if (expected && current[0] === expected) {
+				stack.pop();
+				if (current[0] === _csstools_css_tokenizer.TokenType.CloseCurly && stack.length === 0) {
+					index += 1;
+					foundBoundary = true;
+					break;
+				}
+				continue;
+			}
+			if (current[0] === _csstools_css_tokenizer.TokenType.Semicolon && stack.length === 0) {
+				index += 1;
+				foundBoundary = true;
+				break;
+			}
+		}
+		const sourceEnd = foundBoundary ? end + 1 : css.length;
+		const rule = css.slice(start, sourceEnd).trim();
+		if (rule !== "") rules.push(rule);
+	}
+	return rules;
+}
+//#endregion
+//#region src/internal/rule-tree.ts
+/** Owns child-list identity and parent propagation for every live rule node. */
+var RuleTree = class {
+	#children = /* @__PURE__ */ new WeakMap();
+	#setParentage;
+	#parentStyleSheet;
+	constructor(setParentage, parentStyleSheet) {
+		this.#setParentage = setParentage;
+		this.#parentStyleSheet = parentStyleSheet;
+	}
+	createChildren(owner) {
+		const children = [];
+		this.#children.set(owner, children);
+		return children;
+	}
+	children(owner) {
+		return this.#children.get(owner) ?? [];
+	}
+	replace(owner, children) {
+		const current = this.#children.get(owner);
+		if (!current) return;
+		for (const child of current) this.attach(child, null, null);
+		current.splice(0, current.length, ...children);
+		for (const child of children) this.attach(child, owner, this.#parentStyleSheet(owner));
+	}
+	attach(node, parentRule, parentStyleSheet) {
+		this.#setParentage(node, parentRule, parentStyleSheet);
+		for (const child of this.#children.get(node) ?? []) this.attach(child, node, parentStyleSheet);
+	}
+};
+//#endregion
+//#region src/internal/serializer.ts
+/** Formats reparsable CSS from immutable descriptions of live rule state. */
+var Serializer = class {
+	#describe;
+	constructor(describe) {
+		this.#describe = describe;
+	}
+	serialize(node) {
+		const plan = this.#describe(node);
+		if (plan.kind === "raw") return `${plan.cssText}\n`;
+		if (plan.kind === "declarations") return `${plan.declarations}${plan.declarations === "" ? "" : "\n"}`;
+		const contents = [];
+		if (plan.declarations) contents.push(plan.declarations);
+		for (const child of plan.children ?? []) contents.push(indent(this.serialize(child).trimEnd()));
+		if (contents.length === 0) return `${plan.header} {\n}\n`;
+		return `${plan.header} {\n${contents.join("\n")}\n}\n`;
+	}
+};
+function indent(value) {
+	return value.split("\n").map((line) => `  ${line}`).join("\n");
+}
+//#endregion
+//#region src/chromium-properties.ts
+const chromiumSupportedProperties = /* @__PURE__ */ new Set([
+	"-webkit-align-content",
+	"-webkit-align-items",
+	"-webkit-align-self",
+	"-webkit-animation",
+	"-webkit-animation-delay",
+	"-webkit-animation-direction",
+	"-webkit-animation-duration",
+	"-webkit-animation-fill-mode",
+	"-webkit-animation-iteration-count",
+	"-webkit-animation-name",
+	"-webkit-animation-play-state",
+	"-webkit-animation-timing-function",
+	"-webkit-app-region",
+	"-webkit-appearance",
+	"-webkit-backface-visibility",
+	"-webkit-background-clip",
+	"-webkit-background-origin",
+	"-webkit-background-size",
+	"-webkit-border-after",
+	"-webkit-border-after-color",
+	"-webkit-border-after-style",
+	"-webkit-border-after-width",
+	"-webkit-border-before",
+	"-webkit-border-before-color",
+	"-webkit-border-before-style",
+	"-webkit-border-before-width",
+	"-webkit-border-bottom-left-radius",
+	"-webkit-border-bottom-right-radius",
+	"-webkit-border-end",
+	"-webkit-border-end-color",
+	"-webkit-border-end-style",
+	"-webkit-border-end-width",
+	"-webkit-border-horizontal-spacing",
+	"-webkit-border-image",
+	"-webkit-border-radius",
+	"-webkit-border-start",
+	"-webkit-border-start-color",
+	"-webkit-border-start-style",
+	"-webkit-border-start-width",
+	"-webkit-border-top-left-radius",
+	"-webkit-border-top-right-radius",
+	"-webkit-border-vertical-spacing",
+	"-webkit-box-align",
+	"-webkit-box-decoration-break",
+	"-webkit-box-direction",
+	"-webkit-box-flex",
+	"-webkit-box-ordinal-group",
+	"-webkit-box-orient",
+	"-webkit-box-pack",
+	"-webkit-box-reflect",
+	"-webkit-box-shadow",
+	"-webkit-box-sizing",
+	"-webkit-clip-path",
+	"-webkit-column-break-after",
+	"-webkit-column-break-before",
+	"-webkit-column-break-inside",
+	"-webkit-column-count",
+	"-webkit-column-gap",
+	"-webkit-column-rule",
+	"-webkit-column-rule-color",
+	"-webkit-column-rule-style",
+	"-webkit-column-rule-width",
+	"-webkit-column-span",
+	"-webkit-column-width",
+	"-webkit-columns",
+	"-webkit-filter",
+	"-webkit-flex",
+	"-webkit-flex-basis",
+	"-webkit-flex-direction",
+	"-webkit-flex-flow",
+	"-webkit-flex-grow",
+	"-webkit-flex-shrink",
+	"-webkit-flex-wrap",
+	"-webkit-font-feature-settings",
+	"-webkit-font-smoothing",
+	"-webkit-hyphenate-character",
+	"-webkit-justify-content",
+	"-webkit-line-break",
+	"-webkit-line-clamp",
+	"-webkit-locale",
+	"-webkit-logical-height",
+	"-webkit-logical-width",
+	"-webkit-margin-after",
+	"-webkit-margin-before",
+	"-webkit-margin-end",
+	"-webkit-margin-start",
+	"-webkit-mask",
+	"-webkit-mask-box-image",
+	"-webkit-mask-box-image-outset",
+	"-webkit-mask-box-image-repeat",
+	"-webkit-mask-box-image-slice",
+	"-webkit-mask-box-image-source",
+	"-webkit-mask-box-image-width",
+	"-webkit-mask-clip",
+	"-webkit-mask-composite",
+	"-webkit-mask-image",
+	"-webkit-mask-origin",
+	"-webkit-mask-position",
+	"-webkit-mask-position-x",
+	"-webkit-mask-position-y",
+	"-webkit-mask-repeat",
+	"-webkit-mask-size",
+	"-webkit-max-logical-height",
+	"-webkit-max-logical-width",
+	"-webkit-min-logical-height",
+	"-webkit-min-logical-width",
+	"-webkit-opacity",
+	"-webkit-order",
+	"-webkit-padding-after",
+	"-webkit-padding-before",
+	"-webkit-padding-end",
+	"-webkit-padding-start",
+	"-webkit-perspective",
+	"-webkit-perspective-origin",
+	"-webkit-perspective-origin-x",
+	"-webkit-perspective-origin-y",
+	"-webkit-print-color-adjust",
+	"-webkit-rtl-ordering",
+	"-webkit-ruby-position",
+	"-webkit-shape-image-threshold",
+	"-webkit-shape-margin",
+	"-webkit-shape-outside",
+	"-webkit-tap-highlight-color",
+	"-webkit-text-combine",
+	"-webkit-text-decorations-in-effect",
+	"-webkit-text-emphasis",
+	"-webkit-text-emphasis-color",
+	"-webkit-text-emphasis-position",
+	"-webkit-text-emphasis-style",
+	"-webkit-text-fill-color",
+	"-webkit-text-orientation",
+	"-webkit-text-security",
+	"-webkit-text-size-adjust",
+	"-webkit-text-stroke",
+	"-webkit-text-stroke-color",
+	"-webkit-text-stroke-width",
+	"-webkit-transform",
+	"-webkit-transform-origin",
+	"-webkit-transform-origin-x",
+	"-webkit-transform-origin-y",
+	"-webkit-transform-origin-z",
+	"-webkit-transform-style",
+	"-webkit-transition",
+	"-webkit-transition-delay",
+	"-webkit-transition-duration",
+	"-webkit-transition-property",
+	"-webkit-transition-timing-function",
+	"-webkit-user-drag",
+	"-webkit-user-modify",
+	"-webkit-user-select",
+	"-webkit-writing-mode",
+	"accent-color",
+	"align-content",
+	"align-items",
+	"align-self",
+	"alignment-baseline",
+	"all",
+	"anchor-name",
+	"anchor-scope",
+	"animation",
+	"animation-composition",
+	"animation-delay",
+	"animation-direction",
+	"animation-duration",
+	"animation-fill-mode",
+	"animation-iteration-count",
+	"animation-name",
+	"animation-play-state",
+	"animation-range",
+	"animation-range-end",
+	"animation-range-start",
+	"animation-timeline",
+	"animation-timing-function",
+	"animation-trigger",
+	"app-region",
+	"appearance",
+	"aspect-ratio",
+	"backdrop-filter",
+	"backface-visibility",
+	"background",
+	"background-attachment",
+	"background-blend-mode",
+	"background-clip",
+	"background-color",
+	"background-image",
+	"background-origin",
+	"background-position",
+	"background-position-x",
+	"background-position-y",
+	"background-repeat",
+	"background-size",
+	"baseline-shift",
+	"baseline-source",
+	"block-size",
+	"border",
+	"border-block",
+	"border-block-color",
+	"border-block-end",
+	"border-block-end-color",
+	"border-block-end-style",
+	"border-block-end-width",
+	"border-block-start",
+	"border-block-start-color",
+	"border-block-start-style",
+	"border-block-start-width",
+	"border-block-style",
+	"border-block-width",
+	"border-bottom",
+	"border-bottom-color",
+	"border-bottom-left-radius",
+	"border-bottom-right-radius",
+	"border-bottom-style",
+	"border-bottom-width",
+	"border-collapse",
+	"border-color",
+	"border-end-end-radius",
+	"border-end-start-radius",
+	"border-image",
+	"border-image-outset",
+	"border-image-repeat",
+	"border-image-slice",
+	"border-image-source",
+	"border-image-width",
+	"border-inline",
+	"border-inline-color",
+	"border-inline-end",
+	"border-inline-end-color",
+	"border-inline-end-style",
+	"border-inline-end-width",
+	"border-inline-start",
+	"border-inline-start-color",
+	"border-inline-start-style",
+	"border-inline-start-width",
+	"border-inline-style",
+	"border-inline-width",
+	"border-left",
+	"border-left-color",
+	"border-left-style",
+	"border-left-width",
+	"border-radius",
+	"border-right",
+	"border-right-color",
+	"border-right-style",
+	"border-right-width",
+	"border-shape",
+	"border-spacing",
+	"border-start-end-radius",
+	"border-start-start-radius",
+	"border-style",
+	"border-top",
+	"border-top-color",
+	"border-top-left-radius",
+	"border-top-right-radius",
+	"border-top-style",
+	"border-top-width",
+	"border-width",
+	"bottom",
+	"box-decoration-break",
+	"box-shadow",
+	"box-sizing",
+	"break-after",
+	"break-before",
+	"break-inside",
+	"buffered-rendering",
+	"caption-side",
+	"caret-animation",
+	"caret-color",
+	"caret-shape",
+	"clear",
+	"clip",
+	"clip-path",
+	"clip-rule",
+	"color",
+	"color-interpolation",
+	"color-interpolation-filters",
+	"color-rendering",
+	"color-scheme",
+	"column-count",
+	"column-fill",
+	"column-gap",
+	"column-height",
+	"column-rule",
+	"column-rule-break",
+	"column-rule-color",
+	"column-rule-inset",
+	"column-rule-inset-cap",
+	"column-rule-inset-cap-end",
+	"column-rule-inset-cap-start",
+	"column-rule-inset-end",
+	"column-rule-inset-junction",
+	"column-rule-inset-junction-end",
+	"column-rule-inset-junction-start",
+	"column-rule-inset-start",
+	"column-rule-style",
+	"column-rule-visibility-items",
+	"column-rule-width",
+	"column-span",
+	"column-width",
+	"column-wrap",
+	"columns",
+	"contain",
+	"contain-intrinsic-block-size",
+	"contain-intrinsic-height",
+	"contain-intrinsic-inline-size",
+	"contain-intrinsic-size",
+	"contain-intrinsic-width",
+	"container",
+	"container-name",
+	"container-type",
+	"content",
+	"content-visibility",
+	"corner-block-end-shape",
+	"corner-block-start-shape",
+	"corner-bottom-left-shape",
+	"corner-bottom-right-shape",
+	"corner-bottom-shape",
+	"corner-end-end-shape",
+	"corner-end-start-shape",
+	"corner-inline-end-shape",
+	"corner-inline-start-shape",
+	"corner-left-shape",
+	"corner-right-shape",
+	"corner-shape",
+	"corner-start-end-shape",
+	"corner-start-start-shape",
+	"corner-top-left-shape",
+	"corner-top-right-shape",
+	"corner-top-shape",
+	"counter-increment",
+	"counter-reset",
+	"counter-set",
+	"cursor",
+	"cx",
+	"cy",
+	"d",
+	"direction",
+	"display",
+	"dominant-baseline",
+	"dynamic-range-limit",
+	"empty-cells",
+	"field-sizing",
+	"fill",
+	"fill-opacity",
+	"fill-rule",
+	"filter",
+	"flex",
+	"flex-basis",
+	"flex-direction",
+	"flex-flow",
+	"flex-grow",
+	"flex-line-count",
+	"flex-shrink",
+	"flex-wrap",
+	"float",
+	"flood-color",
+	"flood-opacity",
+	"font",
+	"font-family",
+	"font-feature-settings",
+	"font-kerning",
+	"font-language-override",
+	"font-optical-sizing",
+	"font-palette",
+	"font-size",
+	"font-size-adjust",
+	"font-stretch",
+	"font-style",
+	"font-synthesis",
+	"font-synthesis-small-caps",
+	"font-synthesis-style",
+	"font-synthesis-weight",
+	"font-variant",
+	"font-variant-alternates",
+	"font-variant-caps",
+	"font-variant-east-asian",
+	"font-variant-emoji",
+	"font-variant-ligatures",
+	"font-variant-numeric",
+	"font-variant-position",
+	"font-variation-settings",
+	"font-weight",
+	"forced-color-adjust",
+	"gap",
+	"grid",
+	"grid-area",
+	"grid-auto-columns",
+	"grid-auto-flow",
+	"grid-auto-rows",
+	"grid-column",
+	"grid-column-end",
+	"grid-column-gap",
+	"grid-column-start",
+	"grid-gap",
+	"grid-row",
+	"grid-row-end",
+	"grid-row-gap",
+	"grid-row-start",
+	"grid-template",
+	"grid-template-areas",
+	"grid-template-columns",
+	"grid-template-rows",
+	"height",
+	"hyphenate-character",
+	"hyphenate-limit-chars",
+	"hyphens",
+	"image-orientation",
+	"image-rendering",
+	"initial-letter",
+	"inline-size",
+	"inset",
+	"inset-block",
+	"inset-block-end",
+	"inset-block-start",
+	"inset-inline",
+	"inset-inline-end",
+	"inset-inline-start",
+	"interactivity",
+	"interest-delay",
+	"interest-delay-end",
+	"interest-delay-start",
+	"interpolate-size",
+	"isolation",
+	"justify-content",
+	"justify-items",
+	"justify-self",
+	"left",
+	"letter-spacing",
+	"lighting-color",
+	"line-break",
+	"line-height",
+	"list-style",
+	"list-style-image",
+	"list-style-position",
+	"list-style-type",
+	"margin",
+	"margin-block",
+	"margin-block-end",
+	"margin-block-start",
+	"margin-bottom",
+	"margin-inline",
+	"margin-inline-end",
+	"margin-inline-start",
+	"margin-left",
+	"margin-right",
+	"margin-top",
+	"marker",
+	"marker-end",
+	"marker-mid",
+	"marker-start",
+	"mask",
+	"mask-clip",
+	"mask-composite",
+	"mask-image",
+	"mask-mode",
+	"mask-origin",
+	"mask-position",
+	"mask-repeat",
+	"mask-size",
+	"mask-type",
+	"math-depth",
+	"math-shift",
+	"math-style",
+	"max-block-size",
+	"max-height",
+	"max-inline-size",
+	"max-width",
+	"min-block-size",
+	"min-height",
+	"min-inline-size",
+	"min-width",
+	"mix-blend-mode",
+	"object-fit",
+	"object-position",
+	"object-view-box",
+	"offset",
+	"offset-anchor",
+	"offset-distance",
+	"offset-path",
+	"offset-position",
+	"offset-rotate",
+	"opacity",
+	"order",
+	"orphans",
+	"outline",
+	"outline-color",
+	"outline-offset",
+	"outline-style",
+	"outline-width",
+	"overflow",
+	"overflow-anchor",
+	"overflow-block",
+	"overflow-clip-margin",
+	"overflow-inline",
+	"overflow-wrap",
+	"overflow-x",
+	"overflow-y",
+	"overlay",
+	"overscroll-behavior",
+	"overscroll-behavior-block",
+	"overscroll-behavior-inline",
+	"overscroll-behavior-x",
+	"overscroll-behavior-y",
+	"padding",
+	"padding-block",
+	"padding-block-end",
+	"padding-block-start",
+	"padding-bottom",
+	"padding-inline",
+	"padding-inline-end",
+	"padding-inline-start",
+	"padding-left",
+	"padding-right",
+	"padding-top",
+	"page",
+	"page-break-after",
+	"page-break-before",
+	"page-break-inside",
+	"page-margin-safety",
+	"page-orientation",
+	"paint-order",
+	"perspective",
+	"perspective-origin",
+	"place-content",
+	"place-items",
+	"place-self",
+	"pointer-events",
+	"position",
+	"position-anchor",
+	"position-area",
+	"position-try",
+	"position-try-fallbacks",
+	"position-try-order",
+	"position-visibility",
+	"print-color-adjust",
+	"quotes",
+	"r",
+	"reading-flow",
+	"reading-order",
+	"resize",
+	"right",
+	"rotate",
+	"row-gap",
+	"row-rule",
+	"row-rule-break",
+	"row-rule-color",
+	"row-rule-inset",
+	"row-rule-inset-cap",
+	"row-rule-inset-cap-end",
+	"row-rule-inset-cap-start",
+	"row-rule-inset-end",
+	"row-rule-inset-junction",
+	"row-rule-inset-junction-end",
+	"row-rule-inset-junction-start",
+	"row-rule-inset-start",
+	"row-rule-style",
+	"row-rule-visibility-items",
+	"row-rule-width",
+	"ruby-align",
+	"ruby-overhang",
+	"ruby-position",
+	"rule",
+	"rule-break",
+	"rule-color",
+	"rule-inset",
+	"rule-inset-cap",
+	"rule-inset-end",
+	"rule-inset-junction",
+	"rule-inset-start",
+	"rule-overlap",
+	"rule-style",
+	"rule-visibility-items",
+	"rule-width",
+	"rx",
+	"ry",
+	"scale",
+	"scroll-behavior",
+	"scroll-initial-target",
+	"scroll-margin",
+	"scroll-margin-block",
+	"scroll-margin-block-end",
+	"scroll-margin-block-start",
+	"scroll-margin-bottom",
+	"scroll-margin-inline",
+	"scroll-margin-inline-end",
+	"scroll-margin-inline-start",
+	"scroll-margin-left",
+	"scroll-margin-right",
+	"scroll-margin-top",
+	"scroll-marker-group",
+	"scroll-padding",
+	"scroll-padding-block",
+	"scroll-padding-block-end",
+	"scroll-padding-block-start",
+	"scroll-padding-bottom",
+	"scroll-padding-inline",
+	"scroll-padding-inline-end",
+	"scroll-padding-inline-start",
+	"scroll-padding-left",
+	"scroll-padding-right",
+	"scroll-padding-top",
+	"scroll-snap-align",
+	"scroll-snap-stop",
+	"scroll-snap-type",
+	"scroll-target-group",
+	"scroll-timeline",
+	"scroll-timeline-axis",
+	"scroll-timeline-name",
+	"scrollbar-color",
+	"scrollbar-gutter",
+	"scrollbar-width",
+	"shape-image-threshold",
+	"shape-margin",
+	"shape-outside",
+	"shape-rendering",
+	"size",
+	"speak",
+	"stop-color",
+	"stop-opacity",
+	"stroke",
+	"stroke-dasharray",
+	"stroke-dashoffset",
+	"stroke-linecap",
+	"stroke-linejoin",
+	"stroke-miterlimit",
+	"stroke-opacity",
+	"stroke-width",
+	"tab-size",
+	"table-layout",
+	"text-align",
+	"text-align-last",
+	"text-anchor",
+	"text-autospace",
+	"text-box",
+	"text-box-edge",
+	"text-box-trim",
+	"text-combine-upright",
+	"text-decoration",
+	"text-decoration-color",
+	"text-decoration-line",
+	"text-decoration-skip-ink",
+	"text-decoration-style",
+	"text-decoration-thickness",
+	"text-emphasis",
+	"text-emphasis-color",
+	"text-emphasis-position",
+	"text-emphasis-style",
+	"text-fit",
+	"text-indent",
+	"text-justify",
+	"text-orientation",
+	"text-overflow",
+	"text-rendering",
+	"text-shadow",
+	"text-size-adjust",
+	"text-spacing-trim",
+	"text-transform",
+	"text-underline-offset",
+	"text-underline-position",
+	"text-wrap",
+	"text-wrap-mode",
+	"text-wrap-style",
+	"timeline-scope",
+	"timeline-trigger",
+	"timeline-trigger-activation-range",
+	"timeline-trigger-activation-range-end",
+	"timeline-trigger-activation-range-start",
+	"timeline-trigger-active-range",
+	"timeline-trigger-active-range-end",
+	"timeline-trigger-active-range-start",
+	"timeline-trigger-name",
+	"timeline-trigger-source",
+	"top",
+	"touch-action",
+	"transform",
+	"transform-box",
+	"transform-origin",
+	"transform-style",
+	"transition",
+	"transition-behavior",
+	"transition-delay",
+	"transition-duration",
+	"transition-property",
+	"transition-timing-function",
+	"translate",
+	"trigger-scope",
+	"unicode-bidi",
+	"user-select",
+	"vector-effect",
+	"vertical-align",
+	"view-timeline",
+	"view-timeline-axis",
+	"view-timeline-inset",
+	"view-timeline-name",
+	"view-transition-class",
+	"view-transition-group",
+	"view-transition-name",
+	"view-transition-scope",
+	"visibility",
+	"white-space",
+	"white-space-collapse",
+	"widows",
+	"width",
+	"will-change",
+	"word-break",
+	"word-spacing",
+	"word-wrap",
+	"writing-mode",
+	"x",
+	"y",
+	"z-index",
+	"zoom"
+]);
+const chromiumShorthandLonghands = {
+	"-webkit-align-content": ["align-content"],
+	"-webkit-align-items": ["align-items"],
+	"-webkit-align-self": ["align-self"],
+	"-webkit-animation": [
+		"animation-duration",
+		"animation-timing-function",
+		"animation-delay",
+		"animation-iteration-count",
+		"animation-direction",
+		"animation-fill-mode",
+		"animation-play-state",
+		"animation-name",
+		"animation-timeline",
+		"animation-range-start",
+		"animation-range-end"
+	],
+	"-webkit-animation-delay": ["animation-delay"],
+	"-webkit-animation-direction": ["animation-direction"],
+	"-webkit-animation-duration": ["animation-duration"],
+	"-webkit-animation-fill-mode": ["animation-fill-mode"],
+	"-webkit-animation-iteration-count": ["animation-iteration-count"],
+	"-webkit-animation-name": ["animation-name"],
+	"-webkit-animation-play-state": ["animation-play-state"],
+	"-webkit-animation-timing-function": ["animation-timing-function"],
+	"-webkit-app-region": ["app-region"],
+	"-webkit-appearance": ["appearance"],
+	"-webkit-backface-visibility": ["backface-visibility"],
+	"-webkit-background-clip": ["background-clip"],
+	"-webkit-background-origin": ["background-origin"],
+	"-webkit-background-size": ["background-size"],
+	"-webkit-border-after": [
+		"border-block-end-width",
+		"border-block-end-style",
+		"border-block-end-color"
+	],
+	"-webkit-border-after-color": ["border-block-end-color"],
+	"-webkit-border-after-style": ["border-block-end-style"],
+	"-webkit-border-after-width": ["border-block-end-width"],
+	"-webkit-border-before": [
+		"border-block-start-width",
+		"border-block-start-style",
+		"border-block-start-color"
+	],
+	"-webkit-border-before-color": ["border-block-start-color"],
+	"-webkit-border-before-style": ["border-block-start-style"],
+	"-webkit-border-before-width": ["border-block-start-width"],
+	"-webkit-border-bottom-left-radius": ["border-bottom-left-radius"],
+	"-webkit-border-bottom-right-radius": ["border-bottom-right-radius"],
+	"-webkit-border-end": [
+		"border-inline-end-width",
+		"border-inline-end-style",
+		"border-inline-end-color"
+	],
+	"-webkit-border-end-color": ["border-inline-end-color"],
+	"-webkit-border-end-style": ["border-inline-end-style"],
+	"-webkit-border-end-width": ["border-inline-end-width"],
+	"-webkit-border-radius": [
+		"border-top-left-radius",
+		"border-top-right-radius",
+		"border-bottom-right-radius",
+		"border-bottom-left-radius"
+	],
+	"-webkit-border-start": [
+		"border-inline-start-width",
+		"border-inline-start-style",
+		"border-inline-start-color"
+	],
+	"-webkit-border-start-color": ["border-inline-start-color"],
+	"-webkit-border-start-style": ["border-inline-start-style"],
+	"-webkit-border-start-width": ["border-inline-start-width"],
+	"-webkit-border-top-left-radius": ["border-top-left-radius"],
+	"-webkit-border-top-right-radius": ["border-top-right-radius"],
+	"-webkit-box-shadow": ["box-shadow"],
+	"-webkit-box-sizing": ["box-sizing"],
+	"-webkit-clip-path": ["clip-path"],
+	"-webkit-column-break-after": ["break-after"],
+	"-webkit-column-break-before": ["break-before"],
+	"-webkit-column-break-inside": ["break-inside"],
+	"-webkit-column-count": ["column-count"],
+	"-webkit-column-gap": ["column-gap"],
+	"-webkit-column-rule": [
+		"column-rule-width",
+		"column-rule-style",
+		"column-rule-color"
+	],
+	"-webkit-column-rule-color": ["column-rule-color"],
+	"-webkit-column-rule-style": ["column-rule-style"],
+	"-webkit-column-rule-width": ["column-rule-width"],
+	"-webkit-column-span": ["column-span"],
+	"-webkit-column-width": ["column-width"],
+	"-webkit-columns": [
+		"column-width",
+		"column-count",
+		"column-height",
+		"column-wrap"
+	],
+	"-webkit-filter": ["filter"],
+	"-webkit-flex": [
+		"flex-grow",
+		"flex-shrink",
+		"flex-basis"
+	],
+	"-webkit-flex-basis": ["flex-basis"],
+	"-webkit-flex-direction": ["flex-direction"],
+	"-webkit-flex-flow": ["flex-direction", "flex-wrap"],
+	"-webkit-flex-grow": ["flex-grow"],
+	"-webkit-flex-shrink": ["flex-shrink"],
+	"-webkit-flex-wrap": ["flex-wrap"],
+	"-webkit-font-feature-settings": ["font-feature-settings"],
+	"-webkit-hyphenate-character": ["hyphenate-character"],
+	"-webkit-justify-content": ["justify-content"],
+	"-webkit-logical-height": ["block-size"],
+	"-webkit-logical-width": ["inline-size"],
+	"-webkit-margin-after": ["margin-block-end"],
+	"-webkit-margin-before": ["margin-block-start"],
+	"-webkit-margin-end": ["margin-inline-end"],
+	"-webkit-margin-start": ["margin-inline-start"],
+	"-webkit-mask": [
+		"mask-image",
+		"-webkit-mask-position-x",
+		"-webkit-mask-position-y",
+		"mask-size",
+		"mask-repeat",
+		"mask-origin",
+		"mask-clip",
+		"mask-composite",
+		"mask-mode"
+	],
+	"-webkit-mask-box-image": [
+		"-webkit-mask-box-image-source",
+		"-webkit-mask-box-image-slice",
+		"-webkit-mask-box-image-width",
+		"-webkit-mask-box-image-outset",
+		"-webkit-mask-box-image-repeat"
+	],
+	"-webkit-mask-clip": ["mask-clip"],
+	"-webkit-mask-composite": ["mask-composite"],
+	"-webkit-mask-image": ["mask-image"],
+	"-webkit-mask-origin": ["mask-origin"],
+	"-webkit-mask-position": ["-webkit-mask-position-x", "-webkit-mask-position-y"],
+	"-webkit-mask-repeat": ["mask-repeat"],
+	"-webkit-mask-size": ["mask-size"],
+	"-webkit-max-logical-height": ["max-block-size"],
+	"-webkit-max-logical-width": ["max-inline-size"],
+	"-webkit-min-logical-height": ["min-block-size"],
+	"-webkit-min-logical-width": ["min-inline-size"],
+	"-webkit-opacity": ["opacity"],
+	"-webkit-order": ["order"],
+	"-webkit-padding-after": ["padding-block-end"],
+	"-webkit-padding-before": ["padding-block-start"],
+	"-webkit-padding-end": ["padding-inline-end"],
+	"-webkit-padding-start": ["padding-inline-start"],
+	"-webkit-perspective": ["perspective"],
+	"-webkit-perspective-origin": ["perspective-origin"],
+	"-webkit-print-color-adjust": ["print-color-adjust"],
+	"-webkit-shape-image-threshold": ["shape-image-threshold"],
+	"-webkit-shape-margin": ["shape-margin"],
+	"-webkit-shape-outside": ["shape-outside"],
+	"-webkit-text-emphasis": ["text-emphasis-style", "text-emphasis-color"],
+	"-webkit-text-emphasis-color": ["text-emphasis-color"],
+	"-webkit-text-emphasis-position": ["text-emphasis-position"],
+	"-webkit-text-emphasis-style": ["text-emphasis-style"],
+	"-webkit-text-size-adjust": ["text-size-adjust"],
+	"-webkit-text-stroke": ["-webkit-text-stroke-width", "-webkit-text-stroke-color"],
+	"-webkit-transform": ["transform"],
+	"-webkit-transform-origin": ["transform-origin"],
+	"-webkit-transform-style": ["transform-style"],
+	"-webkit-transition": [
+		"transition-property",
+		"transition-duration",
+		"transition-timing-function",
+		"transition-delay",
+		"transition-behavior"
+	],
+	"-webkit-transition-delay": ["transition-delay"],
+	"-webkit-transition-duration": ["transition-duration"],
+	"-webkit-transition-property": ["transition-property"],
+	"-webkit-transition-timing-function": ["transition-timing-function"],
+	"-webkit-user-select": ["user-select"],
+	"animation": [
+		"animation-duration",
+		"animation-timing-function",
+		"animation-delay",
+		"animation-iteration-count",
+		"animation-direction",
+		"animation-fill-mode",
+		"animation-play-state",
+		"animation-name",
+		"animation-timeline",
+		"animation-range-start",
+		"animation-range-end"
+	],
+	"animation-range": ["animation-range-start", "animation-range-end"],
+	"background": [
+		"background-image",
+		"background-position-x",
+		"background-position-y",
+		"background-size",
+		"background-repeat",
+		"background-attachment",
+		"background-origin",
+		"background-clip",
+		"background-color"
+	],
+	"background-position": ["background-position-x", "background-position-y"],
+	"border": [
+		"border-top-color",
+		"border-top-style",
+		"border-top-width",
+		"border-right-color",
+		"border-right-style",
+		"border-right-width",
+		"border-bottom-color",
+		"border-bottom-style",
+		"border-bottom-width",
+		"border-left-color",
+		"border-left-style",
+		"border-left-width",
+		"border-image-source",
+		"border-image-slice",
+		"border-image-width",
+		"border-image-outset",
+		"border-image-repeat"
+	],
+	"border-block": [
+		"border-block-start-color",
+		"border-block-start-style",
+		"border-block-start-width",
+		"border-block-end-color",
+		"border-block-end-style",
+		"border-block-end-width"
+	],
+	"border-block-color": ["border-block-start-color", "border-block-end-color"],
+	"border-block-end": [
+		"border-block-end-width",
+		"border-block-end-style",
+		"border-block-end-color"
+	],
+	"border-block-start": [
+		"border-block-start-width",
+		"border-block-start-style",
+		"border-block-start-color"
+	],
+	"border-block-style": ["border-block-start-style", "border-block-end-style"],
+	"border-block-width": ["border-block-start-width", "border-block-end-width"],
+	"border-bottom": [
+		"border-bottom-width",
+		"border-bottom-style",
+		"border-bottom-color"
+	],
+	"border-color": [
+		"border-top-color",
+		"border-right-color",
+		"border-bottom-color",
+		"border-left-color"
+	],
+	"border-image": [
+		"border-image-source",
+		"border-image-slice",
+		"border-image-width",
+		"border-image-outset",
+		"border-image-repeat"
+	],
+	"border-inline": [
+		"border-inline-start-color",
+		"border-inline-start-style",
+		"border-inline-start-width",
+		"border-inline-end-color",
+		"border-inline-end-style",
+		"border-inline-end-width"
+	],
+	"border-inline-color": ["border-inline-start-color", "border-inline-end-color"],
+	"border-inline-end": [
+		"border-inline-end-width",
+		"border-inline-end-style",
+		"border-inline-end-color"
+	],
+	"border-inline-start": [
+		"border-inline-start-width",
+		"border-inline-start-style",
+		"border-inline-start-color"
+	],
+	"border-inline-style": ["border-inline-start-style", "border-inline-end-style"],
+	"border-inline-width": ["border-inline-start-width", "border-inline-end-width"],
+	"border-left": [
+		"border-left-width",
+		"border-left-style",
+		"border-left-color"
+	],
+	"border-radius": [
+		"border-top-left-radius",
+		"border-top-right-radius",
+		"border-bottom-right-radius",
+		"border-bottom-left-radius"
+	],
+	"border-right": [
+		"border-right-width",
+		"border-right-style",
+		"border-right-color"
+	],
+	"border-spacing": ["-webkit-border-horizontal-spacing", "-webkit-border-vertical-spacing"],
+	"border-style": [
+		"border-top-style",
+		"border-right-style",
+		"border-bottom-style",
+		"border-left-style"
+	],
+	"border-top": [
+		"border-top-width",
+		"border-top-style",
+		"border-top-color"
+	],
+	"border-width": [
+		"border-top-width",
+		"border-right-width",
+		"border-bottom-width",
+		"border-left-width"
+	],
+	"column-rule": [
+		"column-rule-width",
+		"column-rule-style",
+		"column-rule-color"
+	],
+	"column-rule-inset": [
+		"column-rule-inset-cap-start",
+		"column-rule-inset-cap-end",
+		"column-rule-inset-junction-start",
+		"column-rule-inset-junction-end"
+	],
+	"column-rule-inset-cap": ["column-rule-inset-cap-start", "column-rule-inset-cap-end"],
+	"column-rule-inset-end": ["column-rule-inset-cap-end", "column-rule-inset-junction-end"],
+	"column-rule-inset-junction": ["column-rule-inset-junction-start", "column-rule-inset-junction-end"],
+	"column-rule-inset-start": ["column-rule-inset-cap-start", "column-rule-inset-junction-start"],
+	"columns": [
+		"column-width",
+		"column-count",
+		"column-height",
+		"column-wrap"
+	],
+	"contain-intrinsic-size": ["contain-intrinsic-width", "contain-intrinsic-height"],
+	"container": ["container-name", "container-type"],
+	"corner-block-end-shape": ["corner-end-start-shape", "corner-end-end-shape"],
+	"corner-block-start-shape": ["corner-start-start-shape", "corner-start-end-shape"],
+	"corner-bottom-shape": ["corner-bottom-left-shape", "corner-bottom-right-shape"],
+	"corner-inline-end-shape": ["corner-start-end-shape", "corner-end-end-shape"],
+	"corner-inline-start-shape": ["corner-start-start-shape", "corner-end-start-shape"],
+	"corner-left-shape": ["corner-top-left-shape", "corner-bottom-left-shape"],
+	"corner-right-shape": ["corner-top-right-shape", "corner-bottom-right-shape"],
+	"corner-shape": [
+		"corner-top-left-shape",
+		"corner-top-right-shape",
+		"corner-bottom-right-shape",
+		"corner-bottom-left-shape"
+	],
+	"corner-top-shape": ["corner-top-left-shape", "corner-top-right-shape"],
+	"flex": [
+		"flex-grow",
+		"flex-shrink",
+		"flex-basis"
+	],
+	"flex-flow": ["flex-direction", "flex-wrap"],
+	"font": [
+		"font-style",
+		"font-variant-ligatures",
+		"font-variant-caps",
+		"font-variant-numeric",
+		"font-variant-east-asian",
+		"font-variant-alternates",
+		"font-variant-position",
+		"font-variant-emoji",
+		"font-weight",
+		"font-stretch",
+		"font-size",
+		"line-height",
+		"font-family",
+		"font-optical-sizing",
+		"font-size-adjust",
+		"font-kerning",
+		"font-feature-settings",
+		"font-variation-settings",
+		"font-language-override"
+	],
+	"font-synthesis": [
+		"font-synthesis-weight",
+		"font-synthesis-style",
+		"font-synthesis-small-caps"
+	],
+	"font-variant": [
+		"font-variant-ligatures",
+		"font-variant-caps",
+		"font-variant-alternates",
+		"font-variant-numeric",
+		"font-variant-east-asian",
+		"font-variant-position",
+		"font-variant-emoji"
+	],
+	"gap": ["row-gap", "column-gap"],
+	"grid": [
+		"grid-template-rows",
+		"grid-template-columns",
+		"grid-template-areas",
+		"grid-auto-flow",
+		"grid-auto-rows",
+		"grid-auto-columns"
+	],
+	"grid-area": [
+		"grid-row-start",
+		"grid-column-start",
+		"grid-row-end",
+		"grid-column-end"
+	],
+	"grid-column": ["grid-column-start", "grid-column-end"],
+	"grid-column-gap": ["column-gap"],
+	"grid-gap": ["row-gap", "column-gap"],
+	"grid-row": ["grid-row-start", "grid-row-end"],
+	"grid-row-gap": ["row-gap"],
+	"grid-template": [
+		"grid-template-rows",
+		"grid-template-columns",
+		"grid-template-areas"
+	],
+	"inset": [
+		"top",
+		"right",
+		"bottom",
+		"left"
+	],
+	"inset-block": ["inset-block-start", "inset-block-end"],
+	"inset-inline": ["inset-inline-start", "inset-inline-end"],
+	"interest-delay": ["interest-delay-start", "interest-delay-end"],
+	"list-style": [
+		"list-style-position",
+		"list-style-image",
+		"list-style-type"
+	],
+	"margin": [
+		"margin-top",
+		"margin-right",
+		"margin-bottom",
+		"margin-left"
+	],
+	"margin-block": ["margin-block-start", "margin-block-end"],
+	"margin-inline": ["margin-inline-start", "margin-inline-end"],
+	"marker": [
+		"marker-start",
+		"marker-mid",
+		"marker-end"
+	],
+	"mask": [
+		"mask-image",
+		"-webkit-mask-position-x",
+		"-webkit-mask-position-y",
+		"mask-size",
+		"mask-repeat",
+		"mask-origin",
+		"mask-clip",
+		"mask-composite",
+		"mask-mode"
+	],
+	"mask-position": ["-webkit-mask-position-x", "-webkit-mask-position-y"],
+	"offset": [
+		"offset-position",
+		"offset-path",
+		"offset-distance",
+		"offset-rotate",
+		"offset-anchor"
+	],
+	"outline": [
+		"outline-color",
+		"outline-style",
+		"outline-width"
+	],
+	"overflow": ["overflow-x", "overflow-y"],
+	"overscroll-behavior": ["overscroll-behavior-x", "overscroll-behavior-y"],
+	"padding": [
+		"padding-top",
+		"padding-right",
+		"padding-bottom",
+		"padding-left"
+	],
+	"padding-block": ["padding-block-start", "padding-block-end"],
+	"padding-inline": ["padding-inline-start", "padding-inline-end"],
+	"page-break-after": ["break-after"],
+	"page-break-before": ["break-before"],
+	"page-break-inside": ["break-inside"],
+	"place-content": ["align-content", "justify-content"],
+	"place-items": ["align-items", "justify-items"],
+	"place-self": ["align-self", "justify-self"],
+	"position-try": ["position-try-order", "position-try-fallbacks"],
+	"row-rule": [
+		"row-rule-width",
+		"row-rule-style",
+		"row-rule-color"
+	],
+	"row-rule-inset": [
+		"row-rule-inset-cap-start",
+		"row-rule-inset-cap-end",
+		"row-rule-inset-junction-start",
+		"row-rule-inset-junction-end"
+	],
+	"row-rule-inset-cap": ["row-rule-inset-cap-start", "row-rule-inset-cap-end"],
+	"row-rule-inset-end": ["row-rule-inset-cap-end", "row-rule-inset-junction-end"],
+	"row-rule-inset-junction": ["row-rule-inset-junction-start", "row-rule-inset-junction-end"],
+	"row-rule-inset-start": ["row-rule-inset-cap-start", "row-rule-inset-junction-start"],
+	"rule": [
+		"column-rule-width",
+		"column-rule-style",
+		"column-rule-color",
+		"row-rule-width",
+		"row-rule-style",
+		"row-rule-color"
+	],
+	"rule-break": ["row-rule-break", "column-rule-break"],
+	"rule-color": ["column-rule-color", "row-rule-color"],
+	"rule-inset": [
+		"row-rule-inset-cap-start",
+		"row-rule-inset-cap-end",
+		"row-rule-inset-junction-start",
+		"row-rule-inset-junction-end",
+		"column-rule-inset-cap-start",
+		"column-rule-inset-cap-end",
+		"column-rule-inset-junction-start",
+		"column-rule-inset-junction-end"
+	],
+	"rule-inset-cap": [
+		"row-rule-inset-cap-start",
+		"row-rule-inset-cap-end",
+		"column-rule-inset-cap-start",
+		"column-rule-inset-cap-end"
+	],
+	"rule-inset-end": [
+		"column-rule-inset-cap-end",
+		"column-rule-inset-junction-end",
+		"row-rule-inset-cap-end",
+		"row-rule-inset-junction-end"
+	],
+	"rule-inset-junction": [
+		"row-rule-inset-junction-start",
+		"row-rule-inset-junction-end",
+		"column-rule-inset-junction-start",
+		"column-rule-inset-junction-end"
+	],
+	"rule-inset-start": [
+		"column-rule-inset-cap-start",
+		"column-rule-inset-junction-start",
+		"row-rule-inset-cap-start",
+		"row-rule-inset-junction-start"
+	],
+	"rule-style": ["column-rule-style", "row-rule-style"],
+	"rule-visibility-items": ["column-rule-visibility-items", "row-rule-visibility-items"],
+	"rule-width": ["column-rule-width", "row-rule-width"],
+	"scroll-margin": [
+		"scroll-margin-top",
+		"scroll-margin-right",
+		"scroll-margin-bottom",
+		"scroll-margin-left"
+	],
+	"scroll-margin-block": ["scroll-margin-block-start", "scroll-margin-block-end"],
+	"scroll-margin-inline": ["scroll-margin-inline-start", "scroll-margin-inline-end"],
+	"scroll-padding": [
+		"scroll-padding-top",
+		"scroll-padding-right",
+		"scroll-padding-bottom",
+		"scroll-padding-left"
+	],
+	"scroll-padding-block": ["scroll-padding-block-start", "scroll-padding-block-end"],
+	"scroll-padding-inline": ["scroll-padding-inline-start", "scroll-padding-inline-end"],
+	"scroll-timeline": ["scroll-timeline-name", "scroll-timeline-axis"],
+	"text-box": ["text-box-trim", "text-box-edge"],
+	"text-decoration": [
+		"text-decoration-line",
+		"text-decoration-thickness",
+		"text-decoration-style",
+		"text-decoration-color"
+	],
+	"text-emphasis": ["text-emphasis-style", "text-emphasis-color"],
+	"text-wrap": ["text-wrap-mode", "text-wrap-style"],
+	"timeline-trigger": [
+		"timeline-trigger-name",
+		"timeline-trigger-source",
+		"timeline-trigger-activation-range-start",
+		"timeline-trigger-activation-range-end",
+		"timeline-trigger-active-range-start",
+		"timeline-trigger-active-range-end"
+	],
+	"timeline-trigger-activation-range": ["timeline-trigger-activation-range-start", "timeline-trigger-activation-range-end"],
+	"timeline-trigger-active-range": ["timeline-trigger-active-range-start", "timeline-trigger-active-range-end"],
+	"transition": [
+		"transition-property",
+		"transition-duration",
+		"transition-timing-function",
+		"transition-delay",
+		"transition-behavior"
+	],
+	"view-timeline": [
+		"view-timeline-name",
+		"view-timeline-axis",
+		"view-timeline-inset"
+	],
+	"white-space": ["white-space-collapse", "text-wrap-mode"],
+	"word-wrap": ["overflow-wrap"]
+};
+//#endregion
+//#region src/internal/shorthand-registry.ts
+const fourSideShorthandNames = /* @__PURE__ */ new Set([
+	"padding",
+	"margin",
+	"inset",
+	"border-width",
+	"border-style",
+	"border-color",
+	"scroll-margin",
+	"scroll-padding"
+]);
+function isFourSideShorthand(name) {
+	return fourSideShorthandNames.has(name);
+}
+function getShorthandLonghands(name) {
+	if (!Object.hasOwn(chromiumShorthandLonghands, name)) return null;
+	return chromiumShorthandLonghands[name] ?? null;
+}
+function splitTopLevelWhitespace(value) {
+	const components = [];
+	let current = "";
+	let depth = 0;
+	let quote = "";
+	let escaped = false;
+	for (const character of value) {
+		if (escaped) {
+			current += character;
+			escaped = false;
+			continue;
+		}
+		if (character === "\\") {
+			current += character;
+			escaped = true;
+			continue;
+		}
+		if (quote !== "") {
+			current += character;
+			if (character === quote) quote = "";
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			current += character;
+			quote = character;
+			continue;
+		}
+		if (character === "(" || character === "[" || character === "{") {
+			current += character;
+			depth += 1;
+			continue;
+		}
+		if (character === ")" || character === "]" || character === "}") {
+			current += character;
+			if (depth > 0) depth -= 1;
+			continue;
+		}
+		if (/\s/.test(character) && depth === 0) {
+			if (current !== "") components.push(current);
+			current = "";
+			continue;
+		}
+		current += character;
+	}
+	if (current !== "") components.push(current);
+	return components;
+}
+function expandFourSides(value) {
+	const components = splitTopLevelWhitespace(value);
+	if (components.length < 1 || components.length > 4) return null;
+	const top = components[0];
+	if (top === void 0) return null;
+	const right = components[1] ?? top;
+	return [
+		top,
+		right,
+		components[2] ?? top,
+		components[3] ?? right
+	];
+}
+function expandStaticFourSide(name, parsed, important) {
+	if (!fourSideShorthandNames.has(name)) return null;
+	const longhands = getShorthandLonghands(name);
+	if (!longhands || longhands.length !== 4) return null;
+	const observableSides = expandFourSides(parsed.observableValue);
+	const safeSides = expandFourSides(parsed.safeValue);
+	if (!observableSides || !safeSides) return null;
+	const records = [];
+	for (let index = 0; index < longhands.length; index += 1) {
+		const longhand = longhands[index];
+		const observableValue = observableSides[index];
+		const safeValue = safeSides[index];
+		if (!longhand || observableValue === void 0 || safeValue === void 0) return null;
+		records.push({
+			name: longhand,
+			observableValue,
+			safeValue,
+			pendingSubstitution: false,
+			important,
+			pendingGroup: null
+		});
+	}
+	return records;
+}
+function expandStaticShorthand(name, parsed, important) {
+	const longhands = getShorthandLonghands(name);
+	if (!longhands || longhands.length === 0 || parsed.pendingSubstitution) return null;
+	const observableStyle = new cssstyle.CSSStyleDeclaration();
+	const safeStyle = new cssstyle.CSSStyleDeclaration();
+	observableStyle.setProperty(name, parsed.observableValue);
+	safeStyle.setProperty(name, parsed.safeValue);
+	const fallbackValues = name === "border" ? {
+		"border-image-source": "none",
+		"border-image-slice": "100%",
+		"border-image-width": "1",
+		"border-image-outset": "0",
+		"border-image-repeat": "stretch"
+	} : {};
+	const orderedLonghands = name === "border" ? [
+		"border-top-width",
+		"border-right-width",
+		"border-bottom-width",
+		"border-left-width",
+		"border-top-style",
+		"border-right-style",
+		"border-bottom-style",
+		"border-left-style",
+		"border-top-color",
+		"border-right-color",
+		"border-bottom-color",
+		"border-left-color",
+		"border-image-source",
+		"border-image-slice",
+		"border-image-width",
+		"border-image-outset",
+		"border-image-repeat"
+	] : longhands;
+	const pendingGroup = {
+		shorthand: name,
+		observableValue: parsed.observableValue,
+		safeValue: parsed.safeValue
+	};
+	const records = [];
+	for (const longhand of orderedLonghands) {
+		if (!longhands.includes(longhand)) return null;
+		const observableValue = observableStyle.getPropertyValue(longhand) || fallbackValues[longhand] || "";
+		const safeValue = safeStyle.getPropertyValue(longhand) || fallbackValues[longhand] || "";
+		if (observableValue === "" || safeValue === "") return null;
+		records.push({
+			name: longhand,
+			observableValue,
+			safeValue,
+			pendingSubstitution: false,
+			important,
+			pendingGroup
+		});
+	}
+	return records;
+}
+//#endregion
+//#region src/internal/value-gate.ts
+const encoder$1 = new TextEncoder();
+const decoder$1 = new TextDecoder();
+const zeroLengthProperties = /* @__PURE__ */ new Set([
+	"width",
+	"height",
+	"min-width",
+	"min-height",
+	"max-width",
+	"max-height",
+	"padding",
+	...[
+		"padding-top",
+		"padding-right",
+		"padding-bottom",
+		"padding-left"
+	]
+]);
+for (const shorthand of [
+	"padding",
+	"margin",
+	"inset",
+	"border-width",
+	"scroll-margin",
+	"scroll-padding"
+]) {
+	zeroLengthProperties.add(shorthand);
+	for (const longhand of chromiumShorthandLonghands[shorthand] ?? []) zeroLengthProperties.add(longhand);
+}
+function isUnknownRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isToken(value, type, tokenValue) {
+	if (!isUnknownRecord(value) || value.type !== "token") return false;
+	const token = value.value;
+	if (!isUnknownRecord(token) || token.type !== type) return false;
+	return tokenValue === void 0 || token.value === tokenValue;
+}
+function isWhitespaceToken(value) {
+	return isToken(value, "white-space");
+}
+function significantTokens(values) {
+	return values.filter((value) => !isWhitespaceToken(value));
+}
+function functionValue(value) {
+	if (!isUnknownRecord(value) || value.type !== "function") return null;
+	const details = value.value;
+	if (!isUnknownRecord(details) || typeof details.name !== "string") return null;
+	if (!Array.isArray(details.arguments)) return null;
+	return {
+		name: details.name.toLowerCase(),
+		arguments: details.arguments
+	};
+}
+function isValidAttrType(value) {
+	const typeFunction = functionValue(value);
+	if (!typeFunction || typeFunction.name !== "type") return false;
+	const tokens = significantTokens(typeFunction.arguments);
+	if (tokens.length === 1 && isToken(tokens[0], "delim", "*")) return true;
+	if (tokens.length < 3) return false;
+	if (!isToken(tokens[0], "delim", "<")) return false;
+	if (!isToken(tokens[tokens.length - 1], "delim", ">")) return false;
+	let depth = 0;
+	for (const token of tokens) {
+		if (isToken(token, "delim", "<")) depth += 1;
+		if (!isToken(token, "delim", ">")) continue;
+		depth -= 1;
+		if (depth < 0) return false;
+	}
+	return depth === 0;
+}
+function isValidAttrFunction(argumentsList) {
+	const tokens = significantTokens(argumentsList);
+	if (!isToken(tokens[0], "ident")) return false;
+	if (tokens.length === 1) return true;
+	let index = 1;
+	const second = tokens[index];
+	if (isToken(second, "comma")) return true;
+	if (isValidAttrType(second)) index += 1;
+	else if (isToken(second, "ident") || isToken(second, "delim", "%")) index += 1;
+	else return false;
+	if (index === tokens.length) return true;
+	return isToken(tokens[index], "comma");
+}
+function isConditionFunction(value) {
+	const condition = functionValue(value);
+	if (!condition || ![
+		"media",
+		"style",
+		"supports"
+	].includes(condition.name)) return false;
+	return significantTokens(condition.arguments).length > 0;
+}
+function isElseToken(value) {
+	return isToken(value, "ident", "else");
+}
+function isValidIfFunction(argumentsList) {
+	const tokens = significantTokens(argumentsList);
+	const branches = [[]];
+	for (const token of tokens) {
+		if (isToken(token, "semicolon")) {
+			branches.push([]);
+			continue;
+		}
+		branches[branches.length - 1]?.push(token);
+	}
+	if (branches.length === 0 || branches.some((branch) => branch.length === 0)) return false;
+	let hasCondition = false;
+	for (let index = 0; index < branches.length; index += 1) {
+		const branch = branches[index];
+		if (!branch) return false;
+		const colonIndex = branch.findIndex((token) => isToken(token, "colon"));
+		if (colonIndex <= 0 || colonIndex === branch.length - 1) return false;
+		const condition = branch.slice(0, colonIndex);
+		if (condition.length === 1 && isElseToken(condition[0])) {
+			if (index !== branches.length - 1) return false;
+			continue;
+		}
+		if (!condition.some(isConditionFunction)) return false;
+		hasCondition = true;
+	}
+	return hasCondition;
+}
+function analyzeSubstitutions(value) {
+	if (Array.isArray(value)) {
+		let found = false;
+		for (const item of value) {
+			const result = analyzeSubstitutions(item);
+			found ||= result.found;
+			if (!result.valid) return {
+				found,
+				valid: false
+			};
+		}
+		return {
+			found,
+			valid: true
+		};
+	}
+	if (!isUnknownRecord(value)) return {
+		found: false,
+		valid: true
+	};
+	let found = value.type === "var" || value.type === "env";
+	const cssFunction = functionValue(value);
+	if (cssFunction?.name === "attr") {
+		found = true;
+		if (!isValidAttrFunction(cssFunction.arguments)) return {
+			found,
+			valid: false
+		};
+	}
+	if (cssFunction?.name === "if") {
+		found = true;
+		if (!isValidIfFunction(cssFunction.arguments)) return {
+			found,
+			valid: false
+		};
+	}
+	for (const key in value) {
+		if (!Object.hasOwn(value, key)) continue;
+		const result = analyzeSubstitutions(value[key]);
+		found ||= result.found;
+		if (!result.valid) return {
+			found,
+			valid: false
+		};
+	}
+	return {
+		found,
+		valid: true
+	};
+}
+function serializeIdentifier(value) {
+	const characters = [...value];
+	let result = "";
+	for (let index = 0; index < characters.length; index += 1) {
+		const character = characters[index];
+		if (character === void 0) continue;
+		const codePoint = character.codePointAt(0) ?? 0;
+		if (codePoint === 0) {
+			result += "�";
+			continue;
+		}
+		if (codePoint >= 1 && codePoint <= 31 || codePoint === 127) {
+			result += `\\${codePoint.toString(16)} `;
+			continue;
+		}
+		if (codePoint >= 48 && codePoint <= 57 && (index === 0 || index === 1 && characters[0] === "-")) {
+			result += `\\${codePoint.toString(16)} `;
+			continue;
+		}
+		if (index === 0 && character === "-" && characters.length === 1) {
+			result += "\\-";
+			continue;
+		}
+		if (codePoint >= 128 || character === "-" || character === "_" || codePoint >= 48 && codePoint <= 57 || codePoint >= 65 && codePoint <= 90 || codePoint >= 97 && codePoint <= 122) {
+			result += character;
+			continue;
+		}
+		result += `\\${character}`;
+	}
+	return result;
+}
+function containsPriorityDelimiter(value) {
+	let found = false;
+	css_tree.tokenize(value, (type, start, end) => {
+		if (css_tree.tokenNames[type] !== "delim-token") return;
+		if (value.slice(start, end) === "!") found = true;
+	});
+	return found;
+}
+function canonicalizeLeadingDecimal(value) {
+	const replacements = [];
+	css_tree.tokenize(value, (type, start, end) => {
+		const tokenName = css_tree.tokenNames[type];
+		if (tokenName === void 0 || ![
+			"number-token",
+			"percentage-token",
+			"dimension-token"
+		].includes(tokenName)) return;
+		const token = value.slice(start, end);
+		const normalized = token.replace(/^([+-]?)\.(\d)/, "$10.$2");
+		if (normalized !== token) replacements.push({
+			start,
+			end,
+			value: normalized
+		});
+	});
+	let result = value;
+	for (let index = replacements.length - 1; index >= 0; index -= 1) {
+		const replacement = replacements[index];
+		if (!replacement) continue;
+		result = `${result.slice(0, replacement.start)}${replacement.value}${result.slice(replacement.end)}`;
+	}
+	return result;
+}
+function parsePropertyValue(name, observableValue) {
+	if (name === "--") return null;
+	if (!name.startsWith("--") && !chromiumSupportedProperties.has(name)) return null;
+	if (containsPriorityDelimiter(observableValue)) return null;
+	let declaration;
+	try {
+		const result = (0, lightningcss.transformStyleAttribute)({
+			code: encoder$1.encode(`${name.startsWith("--") ? serializeIdentifier(name) : name}: ${observableValue}`),
+			visitor: { Declaration(candidate) {
+				declaration = candidate;
+			} }
+		});
+		if (!isUnknownRecord(declaration)) return null;
+		if (!Object.hasOwn(declaration, "property")) return null;
+		const pendingSubstitution = declaration.property === "unparsed";
+		if (pendingSubstitution) {
+			const analysis = analyzeSubstitutions(declaration);
+			if (!analysis.found || !analysis.valid) return null;
+		}
+		const serialized = decoder$1.decode(result.code);
+		const colonIndex = serialized.indexOf(":");
+		if (colonIndex === -1) return null;
+		const trimmedObservableValue = canonicalizeLeadingDecimal(observableValue.trim());
+		return {
+			observableValue: trimmedObservableValue === "0" && zeroLengthProperties.has(name) ? "0px" : trimmedObservableValue,
+			safeValue: serialized.slice(colonIndex + 1).trim(),
+			pendingSubstitution
+		};
+	} catch {
+		return null;
+	}
+}
+function parseAtruleDescriptorValue(atrule, name, observableValue) {
+	if (containsPriorityDelimiter(observableValue)) return null;
+	try {
+		if (css_tree.lexer.matchAtruleDescriptor(atrule, name, observableValue).error) return null;
+		const prelude = atrule === "counter-style" ? " sheetom" : "";
+		const result = (0, lightningcss.transform)({
+			filename: "sheetom-descriptor.css",
+			code: encoder$1.encode(`@${atrule}${prelude} { ${name}: ${observableValue}; }`)
+		});
+		const serializedSheet = decoder$1.decode(result.code);
+		const parsed = css_tree.parse(serializedSheet, { positions: true });
+		if (parsed.type !== "StyleSheet") return null;
+		const rule = parsed.children.first;
+		if (rule?.type !== "Atrule" || !rule.block) return null;
+		const declaration = rule.block.children.first;
+		if (declaration?.type !== "Declaration") return null;
+		const valueLocation = declaration.value.loc;
+		const serializedValue = valueLocation ? serializedSheet.slice(valueLocation.start.offset, valueLocation.end.offset) : css_tree.generate(declaration.value);
+		return {
+			observableValue: serializedValue,
+			safeValue: serializedValue,
+			pendingSubstitution: false
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/internal/webidl-construction.ts
+let internalConstructionDepth = 0;
+function constructInternally(factory) {
+	internalConstructionDepth += 1;
+	try {
+		return factory();
+	} finally {
+		internalConstructionDepth -= 1;
+	}
+}
+function assertInternalConstructor(name) {
+	if (internalConstructionDepth > 0) return;
+	throw new TypeError(`Failed to construct '${name}': Illegal constructor`);
+}
+//#endregion
+//#region src/index.ts
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const arrayIndexPattern = /^(0|[1-9]\d*)$/;
+const regularSheetMetadata = /* @__PURE__ */ new WeakMap();
+const ruleParentage = /* @__PURE__ */ new WeakMap();
+const unsignedLongRange = 2 ** 32;
+const pageMarginRuleNames = /* @__PURE__ */ new Set([
+	"top-left-corner",
+	"top-left",
+	"top-center",
+	"top-right",
+	"top-right-corner",
+	"right-top",
+	"right-middle",
+	"right-bottom",
+	"bottom-right-corner",
+	"bottom-right",
+	"bottom-center",
+	"bottom-left",
+	"bottom-left-corner",
+	"left-bottom",
+	"left-middle",
+	"left-top"
+]);
+const ignoreDiagnostic = () => {};
+const ruleDiagnostics = /* @__PURE__ */ new WeakMap();
+const ruleTree = new RuleTree((rule, parentRule, parentStyleSheet) => {
+	ruleParentage.set(rule, {
+		parentRule,
+		parentStyleSheet
+	});
+}, (rule) => rule.parentStyleSheet);
+const safeSerializer = new Serializer(describeRuleSafe);
+function parseDeclarationValue(declaration, name, observableValue) {
+	const atrule = declaration.parentRule instanceof CSSFontFaceRule ? "font-face" : null;
+	if (atrule) return parseAtruleDescriptorValue(atrule, name, observableValue);
+	return parsePropertyValue(name, observableValue);
+}
+function namedPropertyToCSS(property) {
+	if (property === "cssFloat") return "float";
+	let cssName = property.replace(/[A-Z]/g, (character) => `-${character.toLowerCase()}`);
+	if (/^(webkit|moz|ms|o)-/.test(cssName)) cssName = `-${cssName}`;
+	return cssName;
+}
+function normalizeSelectorText(value) {
+	let parsed;
+	try {
+		parsed = css_tree.parse(value, { context: "selectorList" });
+	} catch {
+		return null;
+	}
+	if (parsed.type !== "SelectorList" || parsed.children.isEmpty) return null;
+	try {
+		const generated = css_tree.generate(parsed);
+		const result = (0, lightningcss.transform)({
+			filename: "sheetom-selector.css",
+			code: encoder.encode(`${generated} { --sheetom-probe: 0; }`)
+		});
+		const serialized = decoder.decode(result.code);
+		const blockIndex = serialized.indexOf(" {");
+		if (blockIndex === -1) return null;
+		return serialized.slice(0, blockIndex);
+	} catch {
+		return null;
+	}
+}
+function toUnsignedLong(value) {
+	const number = Number(value);
+	if (!Number.isFinite(number) || number === 0) return 0;
+	return (Math.trunc(number) % unsignedLongRange + unsignedLongRange) % unsignedLongRange;
+}
+function requireArguments(actual, required, interfaceName, operation) {
+	if (actual >= required) return;
+	throw new TypeError(`Failed to execute '${operation}' on '${interfaceName}': ${required} ${required === 1 ? "argument" : "arguments"} required, but only ${actual} present.`);
+}
+function lockOwnProperties(target, ...properties) {
+	for (const property of properties) {
+		const descriptor = Object.getOwnPropertyDescriptor(target, property);
+		if (!descriptor || !("value" in descriptor)) continue;
+		Object.defineProperty(target, property, {
+			...descriptor,
+			writable: false
+		});
+	}
+}
+/** Base class for live stylesheet rules. */
+var CSSRule = class {
+	static STYLE_RULE = 1;
+	static CHARSET_RULE = 2;
+	static IMPORT_RULE = 3;
+	static MEDIA_RULE = 4;
+	static FONT_FACE_RULE = 5;
+	static PAGE_RULE = 6;
+	static KEYFRAMES_RULE = 7;
+	static KEYFRAME_RULE = 8;
+	static MARGIN_RULE = 9;
+	static NAMESPACE_RULE = 10;
+	static COUNTER_STYLE_RULE = 11;
+	static SUPPORTS_RULE = 12;
+	static FONT_FEATURE_VALUES_RULE = 14;
+	#type;
+	constructor(type) {
+		assertInternalConstructor(new.target.name);
+		this.#type = type;
+		ruleParentage.set(this, {
+			parentRule: null,
+			parentStyleSheet: null
+		});
+	}
+	get parentRule() {
+		return ruleParentage.get(this)?.parentRule ?? null;
+	}
+	get type() {
+		return this.#type;
+	}
+	get parentStyleSheet() {
+		return ruleParentage.get(this)?.parentStyleSheet ?? null;
+	}
+	get cssText() {
+		return "";
+	}
+	set cssText(_value) {}
+};
+for (const [name, value] of Object.entries({
+	STYLE_RULE: CSSRule.STYLE_RULE,
+	CHARSET_RULE: CSSRule.CHARSET_RULE,
+	IMPORT_RULE: CSSRule.IMPORT_RULE,
+	MEDIA_RULE: CSSRule.MEDIA_RULE,
+	FONT_FACE_RULE: CSSRule.FONT_FACE_RULE,
+	PAGE_RULE: CSSRule.PAGE_RULE,
+	KEYFRAMES_RULE: CSSRule.KEYFRAMES_RULE,
+	KEYFRAME_RULE: CSSRule.KEYFRAME_RULE,
+	MARGIN_RULE: CSSRule.MARGIN_RULE,
+	NAMESPACE_RULE: CSSRule.NAMESPACE_RULE,
+	COUNTER_STYLE_RULE: CSSRule.COUNTER_STYLE_RULE,
+	SUPPORTS_RULE: CSSRule.SUPPORTS_RULE,
+	FONT_FEATURE_VALUES_RULE: CSSRule.FONT_FEATURE_VALUES_RULE
+})) Object.defineProperty(CSSRule.prototype, name, {
+	value,
+	writable: false,
+	enumerable: true,
+	configurable: false
+});
+/** A stable, live, indexed collection of rules. */
+var CSSRuleList = class {
+	#rules;
+	/** @internal */
+	constructor(rules) {
+		assertInternalConstructor("CSSRuleList");
+		this.#rules = rules;
+		return new Proxy(this, {
+			get(target, property) {
+				if (typeof property !== "string" || !arrayIndexPattern.test(property)) {
+					const result = Reflect.get(target, property, target);
+					return typeof result === "function" ? result.bind(target) : result;
+				}
+				return target.#rules[Number(property)];
+			},
+			set(target, property, value) {
+				if (typeof property === "string" && arrayIndexPattern.test(property)) return false;
+				return Reflect.set(target, property, value, target);
+			}
+		});
+	}
+	get length() {
+		return this.#rules.length;
+	}
+	item(index) {
+		requireArguments(arguments.length, 1, "CSSRuleList", "item");
+		return this.#rules[toUnsignedLong(index)] ?? null;
+	}
+};
+function normalizeMediaText(value) {
+	try {
+		const result = (0, lightningcss.transform)({
+			filename: "sheetom-media.css",
+			code: encoder.encode(`@media ${value} { .sheetom-probe { --sheetom: 0; } }`)
+		});
+		const serialized = decoder.decode(result.code);
+		const blockIndex = serialized.indexOf("{");
+		if (!serialized.startsWith("@media ") || blockIndex === -1) return null;
+		return serialized.slice(7, blockIndex).trim();
+	} catch {
+		return null;
+	}
+}
+function normalizeConditionalPrelude(name, value) {
+	try {
+		const result = (0, lightningcss.transform)({
+			filename: `sheetom-${name}.css`,
+			code: encoder.encode(`@${name} ${value} { .sheetom-probe { --sheetom: 0; } }`)
+		});
+		const serialized = decoder.decode(result.code);
+		const blockIndex = serialized.indexOf("{");
+		const prefix = `@${name} `;
+		if (!serialized.startsWith(prefix) || blockIndex === -1) return value;
+		return serialized.slice(prefix.length, blockIndex).trim();
+	} catch {
+		return value;
+	}
+}
+function splitMediaQueries(value) {
+	const queries = [];
+	let start = 0;
+	let depth = 0;
+	for (let index = 0; index < value.length; index += 1) {
+		const character = value[index];
+		if (character === "(") depth += 1;
+		if (character === ")" && depth > 0) depth -= 1;
+		if (character !== "," || depth !== 0) continue;
+		queries.push(value.slice(start, index).trim());
+		start = index + 1;
+	}
+	queries.push(value.slice(start).trim());
+	return queries.filter((query) => query !== "");
+}
+/** A live serialized list of media queries. */
+var MediaList = class {
+	#mediaText;
+	constructor(mediaText = "") {
+		assertInternalConstructor("MediaList");
+		const input = `${mediaText}`.trim();
+		this.#mediaText = input === "" ? "" : normalizeMediaText(input) ?? "not all";
+		return new Proxy(this, {
+			get(target, property) {
+				if (typeof property !== "string" || !arrayIndexPattern.test(property)) {
+					const result = Reflect.get(target, property, target);
+					return typeof result === "function" ? result.bind(target) : result;
+				}
+				return target.item(Number(property)) || void 0;
+			},
+			set(target, property, value) {
+				if (typeof property === "string" && arrayIndexPattern.test(property)) return false;
+				return Reflect.set(target, property, value, target);
+			}
+		});
+	}
+	get mediaText() {
+		return this.#mediaText;
+	}
+	set mediaText(value) {
+		const input = `${value}`.trim();
+		if (input === "") {
+			this.#mediaText = "";
+			return;
+		}
+		const normalized = normalizeMediaText(input);
+		this.#mediaText = normalized ?? "not all";
+	}
+	get length() {
+		return splitMediaQueries(this.#mediaText).length;
+	}
+	item(index) {
+		requireArguments(arguments.length, 1, "MediaList", "item");
+		return splitMediaQueries(this.#mediaText)[toUnsignedLong(index)] ?? null;
+	}
+	appendMedium(medium) {
+		requireArguments(arguments.length, 1, "MediaList", "appendMedium");
+		const normalized = normalizeMediaText(`${medium}`);
+		if (!normalized) return;
+		const existing = splitMediaQueries(this.#mediaText);
+		if (existing.includes(normalized)) return;
+		this.#mediaText = [...existing, normalized].join(", ");
+	}
+	deleteMedium(medium) {
+		requireArguments(arguments.length, 1, "MediaList", "deleteMedium");
+		const normalized = normalizeMediaText(`${medium}`);
+		const existing = splitMediaQueries(this.#mediaText);
+		const index = normalized ? existing.indexOf(normalized) : -1;
+		if (index === -1) throw new DOMException("The medium was not found.", "NotFoundError");
+		existing.splice(index, 1);
+		this.#mediaText = existing.join(", ");
+	}
+};
+function indentRuleText(value) {
+	return value.split("\n").map((line) => `  ${line}`).join("\n");
+}
+/** A rule containing a live nested rule list. */
+var CSSGroupingRule = class extends CSSRule {
+	cssRules;
+	constructor(type) {
+		super(type);
+		const rules = ruleTree.createChildren(this);
+		this.cssRules = new CSSRuleList(rules);
+		lockOwnProperties(this, "cssRules");
+	}
+	insertRule(ruleText, index = 0) {
+		requireArguments(arguments.length, 1, this.constructor.name, "insertRule");
+		const rules = ruleTree.children(this);
+		const normalizedIndex = toUnsignedLong(index);
+		if (normalizedIndex > rules.length) throw new DOMException("The index is outside the allowed range.", "IndexSizeError");
+		const input = `${ruleText}`;
+		if (!(this instanceof CSSPageRule) && parsedAtRuleName(input) === "import") throw new DOMException("@import rules cannot be inserted inside a group rule.", "HierarchyRequestError");
+		const rule = parseStrictRule(input, ruleDiagnostics.get(this) ?? ignoreDiagnostic, false, this);
+		if (!rule) throw new DOMException("The rule could not be parsed.", "SyntaxError");
+		if (this instanceof CSSStyleRule && rule instanceof CSSStyleRule && !rule.selectorText.trimStart().startsWith("&")) rule.selectorText = `& ${rule.selectorText}`;
+		rules.splice(normalizedIndex, 0, rule);
+		attachRuleTree(rule, this, this.parentStyleSheet);
+		return normalizedIndex;
+	}
+	deleteRule(index) {
+		requireArguments(arguments.length, 1, this.constructor.name, "deleteRule");
+		const rules = ruleTree.children(this);
+		const normalizedIndex = toUnsignedLong(index);
+		if (normalizedIndex >= rules.length) throw new DOMException("The index is outside the allowed range.", "IndexSizeError");
+		const [removed] = rules.splice(normalizedIndex, 1);
+		if (removed) attachRuleTree(removed, null, null);
+	}
+	serializeGroup(header) {
+		const rules = ruleTree.children(this);
+		if (rules.length === 0) return `${header} { }`;
+		return `${header} {\n${rules.map((rule) => indentRuleText(rule.cssText)).join("\n")}\n}`;
+	}
+};
+/** A grouping rule controlled by a serialized condition. */
+var CSSConditionRule = class extends CSSGroupingRule {
+	#conditionText;
+	constructor(type, conditionText) {
+		super(type);
+		this.#conditionText = conditionText;
+	}
+	get conditionText() {
+		return this.#conditionText;
+	}
+};
+/** A live `@media` rule. */
+var CSSMediaRule = class extends CSSConditionRule {
+	media;
+	constructor(conditionText) {
+		const media = new MediaList(conditionText);
+		super(CSSRule.MEDIA_RULE, media.mediaText);
+		this.media = media;
+		lockOwnProperties(this, "media");
+	}
+	get conditionText() {
+		return this.media.mediaText;
+	}
+	get cssText() {
+		return this.serializeGroup(`@media ${this.media.mediaText}`);
+	}
+	set cssText(_value) {}
+};
+/** A live `@supports` rule. */
+var CSSSupportsRule = class extends CSSConditionRule {
+	constructor(conditionText) {
+		super(CSSRule.SUPPORTS_RULE, normalizeConditionalPrelude("supports", conditionText));
+	}
+	get cssText() {
+		return this.serializeGroup(`@supports ${this.conditionText}`);
+	}
+	set cssText(_value) {}
+};
+/** A live `@container` rule. */
+var CSSContainerRule = class extends CSSConditionRule {
+	containerName;
+	containerQuery;
+	constructor(conditionText) {
+		const normalizedCondition = normalizeConditionalPrelude("container", conditionText);
+		super(0, normalizedCondition);
+		const openingParenthesis = normalizedCondition.indexOf("(");
+		this.containerName = openingParenthesis === -1 ? "" : normalizedCondition.slice(0, openingParenthesis).trim();
+		this.containerQuery = openingParenthesis === -1 ? normalizedCondition : normalizedCondition.slice(openingParenthesis).trim();
+		lockOwnProperties(this, "containerName", "containerQuery");
+	}
+	get cssText() {
+		return this.serializeGroup(`@container ${this.conditionText}`);
+	}
+	set cssText(_value) {}
+};
+/** A live block-form `@layer` rule. */
+var CSSLayerBlockRule = class extends CSSGroupingRule {
+	name;
+	constructor(name) {
+		super(0);
+		this.name = name;
+		lockOwnProperties(this, "name");
+	}
+	get cssText() {
+		return this.serializeGroup(`@layer${this.name === "" ? "" : ` ${this.name}`}`);
+	}
+	set cssText(_value) {}
+};
+/** A live `@scope` rule. */
+var CSSScopeRule = class extends CSSGroupingRule {
+	start;
+	end;
+	constructor(start, end) {
+		super(0);
+		this.start = start;
+		this.end = end;
+		lockOwnProperties(this, "start", "end");
+	}
+	get cssText() {
+		const start = this.start === null ? "" : ` (${this.start})`;
+		const end = this.end === null ? "" : ` to (${this.end})`;
+		return this.serializeGroup(`@scope${start}${end}`);
+	}
+	set cssText(_value) {}
+};
+/** A live `@starting-style` rule. */
+var CSSStartingStyleRule = class extends CSSGroupingRule {
+	constructor() {
+		super(0);
+	}
+	get cssText() {
+		return this.serializeGroup("@starting-style");
+	}
+	set cssText(_value) {}
+};
+/** A non-loading `@import` rule with mutable media. */
+var CSSImportRule = class extends CSSRule {
+	media;
+	styleSheet = null;
+	layerName;
+	supportsText;
+	#rawHref;
+	constructor(href, mediaText = "", layerName = null, supportsText = null) {
+		super(CSSRule.IMPORT_RULE);
+		this.#rawHref = href;
+		this.media = new MediaList(mediaText);
+		this.layerName = layerName;
+		this.supportsText = supportsText;
+		lockOwnProperties(this, "media", "styleSheet", "layerName", "supportsText");
+	}
+	get href() {
+		const baseURL = this.parentStyleSheet?.baseURL;
+		if (!baseURL || baseURL === "about:blank") return this.#rawHref;
+		try {
+			return new URL(this.#rawHref, baseURL).href;
+		} catch {
+			return this.#rawHref;
+		}
+	}
+	get cssText() {
+		return `@import url("${this.#rawHref.replace(/["\\]/g, (character) => `\\${character}`)}")${this.layerName === null ? "" : this.layerName === "" ? " layer" : ` layer(${this.layerName})`}${this.supportsText === null ? "" : ` supports(${this.supportsText})`}${this.media.mediaText === "" ? "" : ` ${this.media.mediaText}`};`;
+	}
+	set cssText(_value) {}
+};
+var CSSGenericRule = class extends CSSRule {
+	#cssText;
+	constructor(type, cssText) {
+		super(type);
+		this.#cssText = cssText;
+	}
+	get cssText() {
+		return this.#cssText;
+	}
+	set cssText(_value) {}
+};
+var CSSOpaqueRule = class extends CSSGenericRule {};
+/** A live declaration block with indexed, named, and method-based access. */
+var CSSStyleDeclaration = class {
+	parentRule;
+	#block;
+	constructor(parentRule) {
+		assertInternalConstructor("CSSStyleDeclaration");
+		this.parentRule = parentRule;
+		lockOwnProperties(this, "parentRule");
+		this.#block = new DeclarationBlock({
+			parseValue: (name, value) => parseDeclarationValue(this, name, value),
+			shorthandLonghands: getShorthandLonghands,
+			expandFourSide: expandStaticFourSide,
+			expandShorthand: expandStaticShorthand,
+			serializeIdentifier,
+			normalizeIndex: toUnsignedLong,
+			isFourSideShorthand
+		}, (code, property, input) => {
+			const priority = code === "INVALID_PRIORITY";
+			(ruleDiagnostics.get(this.parentRule) ?? ignoreDiagnostic)({
+				code,
+				severity: "warning",
+				operation: "setProperty",
+				message: priority ? `The mutation was ignored because ${input} is not a valid priority.` : `The value was ignored because it is invalid for ${property}.`,
+				property,
+				input,
+				location: null
+			});
+		});
+		return new Proxy(this, {
+			get(target, property) {
+				if (typeof property === "string" && arrayIndexPattern.test(property)) return target.item(Number(property)) || void 0;
+				if (typeof property === "string" && !Reflect.has(target, property)) return target.getPropertyValue(namedPropertyToCSS(property));
+				const result = Reflect.get(target, property, target);
+				return typeof result === "function" ? result.bind(target) : result;
+			},
+			set(target, property, value) {
+				if (typeof property === "string" && !Reflect.has(target, property)) {
+					Reflect.apply(target.setProperty, target, [namedPropertyToCSS(property), value]);
+					return true;
+				}
+				return Reflect.set(target, property, value, target);
+			}
+		});
+	}
+	get cssText() {
+		return this.#block.serialize(false, "", " ");
+	}
+	set cssText(value) {
+		let parsed;
+		try {
+			parsed = css_tree.parse(`${value}`, { context: "declarationList" });
+		} catch {
+			this.#block.replace(null);
+			return;
+		}
+		if (parsed.type !== "DeclarationList") {
+			this.#block.replace(null);
+			return;
+		}
+		const declarations = [];
+		for (const child of parsed.children) {
+			if (child.type !== "Declaration") continue;
+			declarations.push({
+				name: child.property,
+				value: css_tree.generate(child.value),
+				important: child.important === true || child.important === "important"
+			});
+		}
+		this.#block.replace(declarations);
+	}
+	get length() {
+		return this.#block.length;
+	}
+	item(index) {
+		requireArguments(arguments.length, 1, "CSSStyleDeclaration", "item");
+		return this.#block.item(index);
+	}
+	getPropertyValue(name) {
+		requireArguments(arguments.length, 1, "CSSStyleDeclaration", "getPropertyValue");
+		return this.#block.getPropertyValue(`${name}`);
+	}
+	getPropertyPriority(name) {
+		requireArguments(arguments.length, 1, "CSSStyleDeclaration", "getPropertyPriority");
+		return this.#block.getPropertyPriority(`${name}`);
+	}
+	setProperty(name, value, priority = "") {
+		requireArguments(arguments.length, 2, "CSSStyleDeclaration", "setProperty");
+		const stringName = `${name}`;
+		const stringValue = value === null ? "" : `${value}`;
+		const stringPriority = priority === null ? "" : `${priority}`;
+		this.#block.setProperty(stringName, stringValue, stringPriority);
+	}
+	removeProperty(name) {
+		requireArguments(arguments.length, 1, "CSSStyleDeclaration", "removeProperty");
+		return this.#block.removeProperty(`${name}`);
+	}
+	/** @internal */
+	serializeSafe(indent) {
+		return this.#block.serialize(true, indent, "\n");
+	}
+};
+/** A live `@font-face` descriptor rule. */
+var CSSFontFaceRule = class extends CSSRule {
+	style;
+	constructor() {
+		super(CSSRule.FONT_FACE_RULE);
+		this.style = new CSSStyleDeclaration(this);
+		lockOwnProperties(this, "style");
+	}
+	get cssText() {
+		return `@font-face {${this.style.cssText === "" ? "" : ` ${this.style.cssText}`} }`;
+	}
+	set cssText(_value) {}
+};
+/** Declarations ordered after a nested style rule. */
+var CSSNestedDeclarations = class extends CSSRule {
+	#style;
+	constructor() {
+		super(0);
+		this.#style = new CSSStyleDeclaration(this);
+	}
+	get style() {
+		return this.#style;
+	}
+	set style(cssText) {
+		this.#style.cssText = `${cssText}`;
+	}
+	get cssText() {
+		return this.style.cssText;
+	}
+	set cssText(_value) {}
+};
+/** A page-margin rule nested inside `CSSPageRule`. */
+var CSSMarginRule = class extends CSSRule {
+	name;
+	style;
+	constructor(name) {
+		super(CSSRule.MARGIN_RULE);
+		this.name = name;
+		this.style = new CSSStyleDeclaration(this);
+		lockOwnProperties(this, "name", "style");
+	}
+	get cssText() {
+		return `@${this.name} {${this.style.cssText === "" ? "" : ` ${this.style.cssText}`} }`;
+	}
+	set cssText(_value) {}
+};
+/** A live `@page` rule with declarations and margin rules. */
+var CSSPageRule = class extends CSSGroupingRule {
+	style;
+	#selectorText;
+	constructor(selectorText) {
+		super(CSSRule.PAGE_RULE);
+		this.#selectorText = selectorText;
+		this.style = new CSSStyleDeclaration(this);
+		lockOwnProperties(this, "style");
+	}
+	get selectorText() {
+		return this.#selectorText;
+	}
+	set selectorText(value) {
+		this.#selectorText = `${value}`.trim();
+	}
+	get cssText() {
+		const contents = [];
+		if (this.style.cssText !== "") contents.push(this.style.cssText);
+		for (const child of ruleTree.children(this)) contents.push(child.cssText);
+		return `@page${this.selectorText === "" ? "" : ` ${this.selectorText}`} {${contents.length === 0 ? "" : ` ${contents.join(" ")}`} }`;
+	}
+	set cssText(_value) {}
+};
+/** A live `@position-try` declaration rule. */
+var CSSPositionTryRule = class extends CSSRule {
+	name;
+	style;
+	constructor(name) {
+		super(0);
+		this.name = name;
+		this.style = new CSSStyleDeclaration(this);
+		lockOwnProperties(this, "name", "style");
+	}
+	get cssText() {
+		return `@position-try ${this.name} {${this.style.cssText === "" ? "" : ` ${this.style.cssText}`} }`;
+	}
+	set cssText(_value) {}
+};
+function normalizeKeyText(value) {
+	const parts = value.split(",").map((part) => part.trim());
+	if (parts.length === 0 || parts.some((part) => part === "")) return null;
+	const normalized = [];
+	for (const part of parts) {
+		const lower = part.toLowerCase();
+		if (lower === "from") {
+			normalized.push("0%");
+			continue;
+		}
+		if (lower === "to") {
+			normalized.push("100%");
+			continue;
+		}
+		const match = lower.match(/^([+-]?(?:\d+(?:\.\d*)?|\.\d+))%$/);
+		if (!match) return null;
+		const percentage = Number(match[1]);
+		if (percentage < 0 || percentage > 100) return null;
+		normalized.push(`${percentage}%`);
+	}
+	return normalized.join(", ");
+}
+/** One mutable keyframe selector and declaration block. */
+var CSSKeyframeRule = class extends CSSRule {
+	style;
+	#keyText;
+	constructor(keyText) {
+		super(CSSRule.KEYFRAME_RULE);
+		this.#keyText = normalizeKeyText(keyText) ?? keyText;
+		this.style = new CSSStyleDeclaration(this);
+		lockOwnProperties(this, "style");
+	}
+	get keyText() {
+		return this.#keyText;
+	}
+	set keyText(value) {
+		const normalized = normalizeKeyText(`${value}`);
+		if (normalized !== null) this.#keyText = normalized;
+	}
+	get cssText() {
+		return `${this.keyText} {${this.style.cssText === "" ? "" : ` ${this.style.cssText}`} }`;
+	}
+	set cssText(_value) {}
+};
+/** A mutable `@keyframes` rule. */
+var CSSKeyframesRule = class extends CSSRule {
+	cssRules;
+	#name;
+	constructor(name) {
+		super(CSSRule.KEYFRAMES_RULE);
+		this.#name = name;
+		const rules = ruleTree.createChildren(this);
+		this.cssRules = new CSSRuleList(rules);
+		lockOwnProperties(this, "cssRules");
+	}
+	get name() {
+		return this.#name;
+	}
+	set name(value) {
+		this.#name = `${value}`;
+	}
+	get length() {
+		return this.cssRules.length;
+	}
+	appendRule(ruleText) {
+		requireArguments(arguments.length, 1, "CSSKeyframesRule", "appendRule");
+		const parsed = parseKeyframeRule(`${ruleText}`, ruleDiagnostics.get(this) ?? ignoreDiagnostic);
+		if (!parsed) return;
+		ruleTree.children(this).push(parsed);
+		attachRuleTree(parsed, this, this.parentStyleSheet);
+	}
+	deleteRule(select) {
+		requireArguments(arguments.length, 1, "CSSKeyframesRule", "deleteRule");
+		const normalized = normalizeKeyText(`${select}`);
+		if (normalized === null) return;
+		const rules = ruleTree.children(this);
+		let index = -1;
+		for (let candidate = rules.length - 1; candidate >= 0; candidate -= 1) {
+			const rule = rules[candidate];
+			if (!(rule instanceof CSSKeyframeRule) || rule.keyText !== normalized) continue;
+			index = candidate;
+			break;
+		}
+		if (index === -1) return;
+		const [removed] = rules.splice(index, 1);
+		if (removed) attachRuleTree(removed, null, null);
+	}
+	findRule(select) {
+		requireArguments(arguments.length, 1, "CSSKeyframesRule", "findRule");
+		const normalized = normalizeKeyText(`${select}`);
+		if (normalized === null) return null;
+		const rules = ruleTree.children(this);
+		for (let index = rules.length - 1; index >= 0; index -= 1) {
+			const rule = rules[index];
+			if (rule instanceof CSSKeyframeRule && rule.keyText === normalized) return rule;
+		}
+		return null;
+	}
+	get cssText() {
+		const rules = ruleTree.children(this);
+		if (rules.length === 0) return `@keyframes ${this.name} { }`;
+		return `@keyframes ${this.name} { \n${rules.map((rule) => indentRuleText(rule.cssText)).join("\n")}\n}`;
+	}
+	set cssText(_value) {}
+};
+const counterDescriptorNames = [
+	"system",
+	"symbols",
+	"additive-symbols",
+	"negative",
+	"prefix",
+	"suffix",
+	"range",
+	"pad",
+	"speak-as",
+	"fallback"
+];
+/** A mutable `@counter-style` descriptor rule. */
+var CSSCounterStyleRule = class extends CSSRule {
+	#descriptors = /* @__PURE__ */ new Map();
+	#name;
+	constructor(name) {
+		super(CSSRule.COUNTER_STYLE_RULE);
+		this.#name = name;
+	}
+	get name() {
+		return this.#name;
+	}
+	set name(value) {
+		this.#name = `${value}`;
+	}
+	get system() {
+		return this.#get("system");
+	}
+	set system(value) {
+		this.#set("system", value);
+	}
+	get symbols() {
+		return this.#get("symbols");
+	}
+	set symbols(value) {
+		this.#set("symbols", value);
+	}
+	get additiveSymbols() {
+		return this.#get("additive-symbols");
+	}
+	set additiveSymbols(value) {
+		this.#set("additive-symbols", value);
+	}
+	get negative() {
+		return this.#get("negative");
+	}
+	set negative(value) {
+		this.#set("negative", value);
+	}
+	get prefix() {
+		return this.#get("prefix");
+	}
+	set prefix(value) {
+		this.#set("prefix", value);
+	}
+	get suffix() {
+		return this.#get("suffix");
+	}
+	set suffix(value) {
+		this.#set("suffix", value);
+	}
+	get range() {
+		return this.#get("range");
+	}
+	set range(value) {
+		this.#set("range", value);
+	}
+	get pad() {
+		return this.#get("pad");
+	}
+	set pad(value) {
+		this.#set("pad", value);
+	}
+	get speakAs() {
+		return this.#get("speak-as");
+	}
+	set speakAs(value) {
+		this.#set("speak-as", value);
+	}
+	get fallback() {
+		return this.#get("fallback");
+	}
+	set fallback(value) {
+		this.#set("fallback", value);
+	}
+	#get(name) {
+		return this.#descriptors.get(name) ?? "";
+	}
+	#set(name, value) {
+		const text = `${value}`;
+		if (text === "") {
+			this.#descriptors.delete(name);
+			return;
+		}
+		const parsed = parseAtruleDescriptorValue("counter-style", name, text);
+		if (!parsed) return;
+		this.#descriptors.set(name, parsed.observableValue);
+	}
+	/** @internal */
+	setParsedDescriptor(name, value) {
+		if (!counterDescriptorNames.includes(name)) return;
+		this.#set(name, value);
+	}
+	get cssText() {
+		const declarations = [];
+		for (const name of counterDescriptorNames) {
+			const value = this.#descriptors.get(name);
+			if (value !== void 0) declarations.push(`${name}: ${value};`);
+		}
+		return `@counter-style ${this.name} {${declarations.length === 0 ? "" : ` ${declarations.join(" ")}`} }`;
+	}
+	set cssText(_value) {}
+};
+/** A live map exposed by one font-feature-values category. */
+var CSSFontFeatureValuesMap = class {
+	#values = /* @__PURE__ */ new Map();
+	constructor() {
+		assertInternalConstructor("CSSFontFeatureValuesMap");
+	}
+	get size() {
+		return this.#values.size;
+	}
+	set(featureValueName, values) {
+		const name = `${featureValueName}`;
+		if (!/^[-_a-zA-Z][-_a-zA-Z0-9]*$/.test(name)) throw new DOMException("The feature value name is invalid.", "SyntaxError");
+		const normalized = Array.from(values, (value) => Math.trunc(Number(value)));
+		if (normalized.some((value) => !Number.isFinite(value) || value < 0)) throw new TypeError("Feature values must be non-negative integers.");
+		this.#values.set(name, normalized);
+		return this;
+	}
+	clear() {
+		this.#values.clear();
+	}
+	delete(name) {
+		return this.#values.delete(`${name}`);
+	}
+	get(name) {
+		const value = this.#values.get(`${name}`);
+		return value ? [...value] : void 0;
+	}
+	has(name) {
+		return this.#values.has(`${name}`);
+	}
+	entries() {
+		return new Map([...this.#values].map(([name, values]) => [name, [...values]])).entries();
+	}
+	keys() {
+		return this.#values.keys();
+	}
+	values() {
+		return new Map([...this.#values].map(([name, values]) => [name, [...values]])).values();
+	}
+	forEach(callback, thisArg) {
+		for (const [name, values] of this.#values) callback.call(thisArg, [...values], name, this);
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+};
+const fontFeatureMapNames = [
+	"annotation",
+	"ornaments",
+	"stylistic",
+	"swash",
+	"character-variant",
+	"styleset"
+];
+/** A mutable `@font-feature-values` rule. */
+var CSSFontFeatureValuesRule = class extends CSSRule {
+	annotation = new CSSFontFeatureValuesMap();
+	ornaments = new CSSFontFeatureValuesMap();
+	stylistic = new CSSFontFeatureValuesMap();
+	swash = new CSSFontFeatureValuesMap();
+	characterVariant = new CSSFontFeatureValuesMap();
+	styleset = new CSSFontFeatureValuesMap();
+	#fontFamily;
+	constructor(fontFamily) {
+		super(CSSRule.FONT_FEATURE_VALUES_RULE);
+		this.#fontFamily = fontFamily;
+		lockOwnProperties(this, "annotation", "ornaments", "stylistic", "swash", "characterVariant", "styleset");
+	}
+	get fontFamily() {
+		return this.#fontFamily;
+	}
+	set fontFamily(value) {
+		this.#fontFamily = `${value}`.trim();
+	}
+	/** @internal */
+	featureMap(name) {
+		switch (name) {
+			case "annotation": return this.annotation;
+			case "ornaments": return this.ornaments;
+			case "stylistic": return this.stylistic;
+			case "swash": return this.swash;
+			case "character-variant": return this.characterVariant;
+			case "styleset": return this.styleset;
+			default: return null;
+		}
+	}
+	get cssText() {
+		const blocks = [];
+		for (const name of fontFeatureMapNames) {
+			const map = this.featureMap(name);
+			if (!map || map.size === 0) continue;
+			const declarations = [...map].map(([key, values]) => `${key}: ${values.join(" ")};`).join(" ");
+			blocks.push(`@${name} { ${declarations} }`);
+		}
+		return `@font-feature-values ${this.fontFamily} {${blocks.length === 0 ? "" : ` ${blocks.join(" ")}`} }`;
+	}
+	set cssText(_value) {}
+};
+/** A live style rule with declarations and nested rules. */
+var CSSStyleRule = class extends CSSGroupingRule {
+	style;
+	#selectorText;
+	constructor(selectorText) {
+		super(CSSRule.STYLE_RULE);
+		this.#selectorText = normalizeSelectorText(`${selectorText}`) ?? `${selectorText}`;
+		this.style = new CSSStyleDeclaration(this);
+		lockOwnProperties(this, "style");
+	}
+	get selectorText() {
+		return this.#selectorText;
+	}
+	set selectorText(value) {
+		const normalized = normalizeSelectorText(`${value}`);
+		if (normalized === null) return;
+		this.#selectorText = normalized;
+	}
+	get cssText() {
+		const declarations = this.style.cssText;
+		const children = ruleTree.children(this);
+		if (children.length === 0) return declarations === "" ? `${this.selectorText} { }` : `${this.selectorText} { ${declarations} }`;
+		const contents = [];
+		if (declarations !== "") contents.push(indentRuleText(declarations));
+		for (const child of children) contents.push(indentRuleText(child.cssText));
+		return `${this.selectorText} {\n${contents.join("\n")}\n}`;
+	}
+	set cssText(_value) {}
+};
+function createStyleRule(node, reportDiagnostic) {
+	const selectorText = normalizeSelectorText(css_tree.generate(node.prelude));
+	if (selectorText === null) return null;
+	const rule = new CSSStyleRule(selectorText);
+	ruleDiagnostics.set(rule, reportDiagnostic);
+	let declarationNodes = [];
+	const childRules = [];
+	let foundNestedRule = false;
+	const flushDeclarations = () => {
+		if (declarationNodes.length === 0) return;
+		const declarationText = declarationNodes.map((child) => css_tree.generate(child)).join(";");
+		if (!foundNestedRule) {
+			rule.style.cssText = declarationText;
+			declarationNodes = [];
+			return;
+		}
+		const nestedDeclarations = new CSSNestedDeclarations();
+		ruleDiagnostics.set(nestedDeclarations, reportDiagnostic);
+		nestedDeclarations.style.cssText = declarationText;
+		childRules.push(nestedDeclarations);
+		declarationNodes = [];
+	};
+	for (const child of node.block.children) {
+		if (child.type === "Declaration") {
+			declarationNodes.push(child);
+			continue;
+		}
+		if (child.type !== "Rule" && child.type !== "Atrule") continue;
+		flushDeclarations();
+		foundNestedRule = true;
+		const parsedChild = createRuleFromNode(child, reportDiagnostic, true);
+		if (parsedChild) childRules.push(parsedChild);
+	}
+	flushDeclarations();
+	replaceGroupingRules(rule, childRules);
+	return rule;
+}
+function declarationTextFromBlock(block) {
+	const declarations = [];
+	for (const child of block.children) if (child.type === "Declaration") declarations.push(css_tree.generate(child));
+	return declarations.join(";");
+}
+function generateDescriptorInput(value) {
+	if (value.type === "Raw") return value.value;
+	return value.children.toArray().map((child) => css_tree.generate(child)).join(" ");
+}
+function createKeyframeRuleFromNode(node, reportDiagnostic) {
+	return constructInternally(() => {
+		const rule = new CSSKeyframeRule(css_tree.generate(node.prelude));
+		ruleDiagnostics.set(rule, reportDiagnostic);
+		rule.style.cssText = declarationTextFromBlock(node.block);
+		return rule;
+	});
+}
+function parseKeyframeRule(ruleText, reportDiagnostic) {
+	try {
+		const parsed = css_tree.parse(`@keyframes sheetom { ${ruleText} }`);
+		if (parsed.type !== "StyleSheet") return null;
+		const keyframes = parsed.children.first;
+		if (keyframes?.type !== "Atrule" || !keyframes.block) return null;
+		const node = keyframes.block.children.first;
+		if (node?.type !== "Rule" || keyframes.block.children.size !== 1) return null;
+		return createKeyframeRuleFromNode(node, reportDiagnostic);
+	} catch {
+		return null;
+	}
+}
+function replaceKeyframeRules(rule, rules) {
+	ruleTree.replace(rule, rules);
+}
+function replaceGroupingRules(group, rules) {
+	ruleTree.replace(group, rules);
+}
+function attachRuleTree(rule, parentRule, parentStyleSheet) {
+	ruleTree.attach(rule, parentRule, parentStyleSheet);
+}
+function serializeRuleSafe(rule) {
+	return safeSerializer.serialize(rule);
+}
+function describeRuleSafe(rule) {
+	if (rule instanceof CSSStyleRule) return {
+		kind: "block",
+		header: rule.selectorText,
+		declarations: rule.style.serializeSafe("  "),
+		children: ruleTree.children(rule)
+	};
+	if (rule instanceof CSSNestedDeclarations) return {
+		kind: "declarations",
+		declarations: rule.style.serializeSafe("")
+	};
+	if (rule instanceof CSSFontFaceRule || rule instanceof CSSMarginRule || rule instanceof CSSPositionTryRule || rule instanceof CSSKeyframeRule) {
+		const blockIndex = rule.cssText.indexOf("{");
+		return {
+			kind: "block",
+			header: rule.cssText.slice(0, blockIndex).trimEnd(),
+			declarations: rule.style.serializeSafe("  ")
+		};
+	}
+	if (rule instanceof CSSKeyframesRule) return {
+		kind: "block",
+		header: `@keyframes ${rule.name}`,
+		children: ruleTree.children(rule)
+	};
+	if (rule instanceof CSSPageRule) return {
+		kind: "block",
+		header: `@page${rule.selectorText === "" ? "" : ` ${rule.selectorText}`}`,
+		declarations: rule.style.serializeSafe("  "),
+		children: ruleTree.children(rule)
+	};
+	if (!(rule instanceof CSSGroupingRule)) return {
+		kind: "raw",
+		cssText: rule.cssText
+	};
+	const blockIndex = rule.cssText.indexOf("{");
+	return {
+		kind: "block",
+		header: blockIndex === -1 ? rule.cssText : rule.cssText.slice(0, blockIndex).trimEnd(),
+		children: ruleTree.children(rule)
+	};
+}
+function parseScopePrelude(prelude) {
+	const text = prelude.trim();
+	if (text === "") return [null, null];
+	const consumeGroup = (value) => {
+		if (!value.startsWith("(")) return [null, value];
+		let depth = 0;
+		for (let index = 0; index < value.length; index += 1) {
+			const character = value[index];
+			if (character === "(") depth += 1;
+			if (character !== ")") continue;
+			depth -= 1;
+			if (depth !== 0) continue;
+			return [value.slice(1, index).trim(), value.slice(index + 1).trim()];
+		}
+		return [null, value];
+	};
+	const [start, remainder] = consumeGroup(text);
+	if (!remainder.startsWith("to")) return [start, null];
+	const [end] = consumeGroup(remainder.slice(2).trim());
+	return [start, end];
+}
+function parseImportPrelude(prelude) {
+	const hrefMatch = prelude.match(/^(?:url\(\s*(?:"([^"]*)"|'([^']*)'|([^)]*))\s*\)|"([^"]*)"|'([^']*)')\s*(.*)$/);
+	if (!hrefMatch) return null;
+	const href = hrefMatch[1] ?? hrefMatch[2] ?? hrefMatch[3]?.trim() ?? hrefMatch[4] ?? hrefMatch[5];
+	if (href === void 0) return null;
+	let remainder = hrefMatch[6]?.trim() ?? "";
+	let layer = null;
+	let supports = null;
+	const layerMatch = remainder.match(/^layer(?:\(([^)]*)\))?(?:\s+|$)(.*)$/);
+	if (layerMatch) {
+		layer = layerMatch[1]?.trim() ?? "";
+		remainder = layerMatch[2]?.trim() ?? "";
+	}
+	if (remainder.startsWith("supports(")) {
+		let depth = 0;
+		let end = -1;
+		for (let index = 8; index < remainder.length; index += 1) {
+			const character = remainder[index];
+			if (character === "(") depth += 1;
+			if (character !== ")") continue;
+			depth -= 1;
+			if (depth !== 0) continue;
+			end = index;
+			break;
+		}
+		if (end !== -1) {
+			supports = remainder.slice(9, end).trim();
+			remainder = remainder.slice(end + 1).trim();
+		}
+	}
+	return {
+		href,
+		media: remainder,
+		layer,
+		supports
+	};
+}
+function createRuleFromNode(node, reportDiagnostic, preserveImports) {
+	return constructInternally(() => createRuleFromNodeInternal(node, reportDiagnostic, preserveImports));
+}
+function createRuleFromNodeInternal(node, reportDiagnostic, preserveImports) {
+	if (node.type === "Rule") return createStyleRule(node, reportDiagnostic);
+	const name = node.name.toLowerCase();
+	if (name === "import" && !preserveImports) return null;
+	const prelude = node.prelude ? css_tree.generate(node.prelude) : "";
+	let rule;
+	switch (name) {
+		case "import": {
+			const parsedImport = parseImportPrelude(prelude);
+			if (!parsedImport) return null;
+			rule = new CSSImportRule(parsedImport.href, parsedImport.media, parsedImport.layer, parsedImport.supports);
+			break;
+		}
+		case "font-face": {
+			const fontFace = new CSSFontFaceRule();
+			if (node.block) fontFace.style.cssText = declarationTextFromBlock(node.block);
+			rule = fontFace;
+			break;
+		}
+		case "page": {
+			const page = new CSSPageRule(prelude);
+			if (node.block) {
+				page.style.cssText = declarationTextFromBlock(node.block);
+				const margins = [];
+				for (const child of node.block.children) {
+					if (child.type !== "Atrule" || !child.block) continue;
+					const margin = new CSSMarginRule(child.name.toLowerCase());
+					margin.style.cssText = declarationTextFromBlock(child.block);
+					ruleDiagnostics.set(margin, reportDiagnostic);
+					margins.push(margin);
+				}
+				replaceGroupingRules(page, margins);
+			}
+			rule = page;
+			break;
+		}
+		case "position-try": {
+			if (!prelude.startsWith("--")) return null;
+			const positionTry = new CSSPositionTryRule(prelude);
+			if (node.block) positionTry.style.cssText = declarationTextFromBlock(node.block);
+			rule = positionTry;
+			break;
+		}
+		case "keyframes":
+		case "-webkit-keyframes": {
+			if (prelude === "") return null;
+			const keyframes = new CSSKeyframesRule(prelude);
+			if (node.block) {
+				const frames = [];
+				for (const child of node.block.children) if (child.type === "Rule") frames.push(createKeyframeRuleFromNode(child, reportDiagnostic));
+				replaceKeyframeRules(keyframes, frames);
+			}
+			rule = keyframes;
+			break;
+		}
+		case "counter-style": {
+			if (prelude === "") return null;
+			const counterStyle = new CSSCounterStyleRule(prelude);
+			if (node.block) for (const child of node.block.children) {
+				if (child.type !== "Declaration") continue;
+				counterStyle.setParsedDescriptor(child.property.toLowerCase(), generateDescriptorInput(child.value));
+			}
+			rule = counterStyle;
+			break;
+		}
+		case "font-feature-values": {
+			if (prelude === "") return null;
+			const featureValues = new CSSFontFeatureValuesRule(prelude);
+			if (node.block) for (const child of node.block.children) {
+				if (child.type !== "Atrule" || !child.block) continue;
+				const map = featureValues.featureMap(child.name.toLowerCase());
+				if (!map) continue;
+				for (const declaration of child.block.children) {
+					if (declaration.type !== "Declaration") continue;
+					const values = css_tree.generate(declaration.value).trim().split(/\s+/).map((value) => Number(value));
+					if (values.some((value) => !Number.isFinite(value))) continue;
+					map.set(declaration.property, values);
+				}
+			}
+			rule = featureValues;
+			break;
+		}
+		case "media":
+			if (prelude === "") return null;
+			rule = new CSSMediaRule(prelude);
+			break;
+		case "supports":
+			if (prelude === "") return null;
+			rule = new CSSSupportsRule(prelude);
+			break;
+		case "container":
+			if (prelude === "") return null;
+			rule = new CSSContainerRule(prelude);
+			break;
+		case "layer":
+			if (!node.block) return new CSSGenericRule(0, css_tree.generate(node));
+			rule = new CSSLayerBlockRule(prelude);
+			break;
+		case "scope": {
+			const [start, end] = parseScopePrelude(prelude);
+			rule = new CSSScopeRule(start, end);
+			break;
+		}
+		case "starting-style":
+			rule = new CSSStartingStyleRule();
+			break;
+		default: return new CSSGenericRule(genericRuleType(name), css_tree.generate(node));
+	}
+	ruleDiagnostics.set(rule, reportDiagnostic);
+	if (!(rule instanceof CSSGroupingRule) || rule instanceof CSSPageRule || !node.block) return rule;
+	const children = [];
+	for (const child of node.block.children) {
+		if (child.type !== "Rule" && child.type !== "Atrule") continue;
+		const parsedChild = createRuleFromNode(child, reportDiagnostic, true);
+		if (parsedChild) children.push(parsedChild);
+	}
+	replaceGroupingRules(rule, children);
+	return rule;
+}
+function parseStrictRule(ruleText, reportDiagnostic, preserveImports = false, parentRule = null) {
+	let parsed;
+	try {
+		parsed = css_tree.parse(ruleText);
+	} catch {
+		return null;
+	}
+	if (parsed.type !== "StyleSheet" || parsed.children.size !== 1) return null;
+	const node = parsed.children.first;
+	if (!node) return null;
+	if (node.type !== "Rule" && node.type !== "Atrule") return null;
+	if (parentRule instanceof CSSPageRule) {
+		if (node.type !== "Atrule" || !node.block || !pageMarginRuleNames.has(node.name.toLowerCase())) return null;
+		return constructInternally(() => {
+			const margin = new CSSMarginRule(node.name.toLowerCase());
+			margin.style.cssText = declarationTextFromBlock(node.block);
+			ruleDiagnostics.set(margin, reportDiagnostic);
+			return margin;
+		});
+	}
+	if (node.type === "Atrule" && node.name.toLowerCase() === "import" && !preserveImports) return null;
+	return createRuleFromNode(node, reportDiagnostic, preserveImports);
+}
+function parsedAtRuleName(ruleText) {
+	try {
+		const parsed = css_tree.parse(ruleText);
+		if (parsed.type !== "StyleSheet" || parsed.children.size !== 1) return null;
+		const node = parsed.children.first;
+		return node?.type === "Atrule" ? node.name.toLowerCase() : null;
+	} catch {
+		return null;
+	}
+}
+function genericRuleType(name) {
+	switch (name.toLowerCase()) {
+		case "import": return CSSRule.IMPORT_RULE;
+		case "media": return CSSRule.MEDIA_RULE;
+		case "font-face": return CSSRule.FONT_FACE_RULE;
+		case "page": return CSSRule.PAGE_RULE;
+		case "keyframes":
+		case "-webkit-keyframes": return CSSRule.KEYFRAMES_RULE;
+		case "namespace": return CSSRule.NAMESPACE_RULE;
+		case "supports": return CSSRule.SUPPORTS_RULE;
+		default: return 0;
+	}
+}
+function parseStyleSheetRules(cssText, reportDiagnostic, preserveImports) {
+	const rules = [];
+	for (const rawRule of scanTopLevelRules(cssText)) {
+		const rule = parseStrictRule(rawRule, reportDiagnostic, preserveImports);
+		if (rule) {
+			rules.push(rule);
+			continue;
+		}
+		if (!preserveImports) continue;
+		rules.push(constructInternally(() => new CSSOpaqueRule(0, rawRule)));
+	}
+	return rules;
+}
+/** A mutable, browser-shaped authoring stylesheet. */
+var CSSStyleSheet = class {
+	cssRules;
+	media;
+	ownerNode = null;
+	parentStyleSheet = null;
+	ownerRule = null;
+	title = null;
+	type = "text/css";
+	disabled;
+	#rules = [];
+	#diagnostics;
+	#constructedBaseURL;
+	constructor(options = {}) {
+		const normalizedOptions = options ?? {};
+		this.#diagnostics = Boolean(normalizedOptions.diagnostics) ? [] : null;
+		this.#constructedBaseURL = normalizedOptions.baseURL === void 0 ? "about:blank" : `${normalizedOptions.baseURL}`;
+		const media = normalizedOptions.media === void 0 ? "" : `${normalizedOptions.media}`;
+		this.media = constructInternally(() => new MediaList(media));
+		this.disabled = Boolean(normalizedOptions.disabled);
+		this.cssRules = constructInternally(() => new CSSRuleList(this.#rules));
+		lockOwnProperties(this, "cssRules", "media", "ownerNode", "parentStyleSheet", "ownerRule", "title", "type");
+	}
+	get href() {
+		return regularSheetMetadata.get(this)?.href ?? null;
+	}
+	get baseURL() {
+		return regularSheetMetadata.get(this)?.baseURL ?? this.#constructedBaseURL;
+	}
+	#reportDiagnostic = (diagnostic) => {
+		this.#diagnostics?.push(diagnostic);
+	};
+	insertRule(ruleText, index = 0) {
+		requireArguments(arguments.length, 1, "CSSStyleSheet", "insertRule");
+		const normalizedIndex = toUnsignedLong(index);
+		if (normalizedIndex > this.#rules.length) throw new DOMException("The index is outside the allowed range.", "IndexSizeError");
+		const regular = regularSheetMetadata.has(this);
+		const rule = parseStrictRule(`${ruleText}`, this.#reportDiagnostic, regular);
+		if (!rule) throw new DOMException("The rule could not be parsed.", "SyntaxError");
+		const precedingRules = this.#rules.slice(0, normalizedIndex);
+		const followingRules = this.#rules.slice(normalizedIndex);
+		if (rule instanceof CSSImportRule ? precedingRules.some((candidate) => !(candidate instanceof CSSImportRule)) : followingRules.some((candidate) => candidate instanceof CSSImportRule)) throw new DOMException("The rule violates stylesheet ordering.", "HierarchyRequestError");
+		attachRuleTree(rule, null, this);
+		this.#rules.splice(normalizedIndex, 0, rule);
+		return normalizedIndex;
+	}
+	deleteRule(index) {
+		requireArguments(arguments.length, 1, "CSSStyleSheet", "deleteRule");
+		const normalizedIndex = toUnsignedLong(index);
+		if (normalizedIndex >= this.#rules.length) throw new DOMException("The index is outside the allowed range.", "IndexSizeError");
+		const [removed] = this.#rules.splice(normalizedIndex, 1);
+		if (!removed) return;
+		attachRuleTree(removed, null, null);
+	}
+	replaceSync(cssText) {
+		requireArguments(arguments.length, 1, "CSSStyleSheet", "replaceSync");
+		const replacement = parseStyleSheetRules(`${cssText}`, this.#reportDiagnostic, regularSheetMetadata.has(this));
+		for (const rule of this.#rules) attachRuleTree(rule, null, null);
+		for (const rule of replacement) attachRuleTree(rule, null, this);
+		this.#rules.splice(0, this.#rules.length, ...replacement);
+	}
+	async replace(cssText) {
+		requireArguments(arguments.length, 1, "CSSStyleSheet", "replace");
+		this.replaceSync(cssText);
+		return this;
+	}
+	/** Serialize current state as reparsable CSS without mutating live objects. */
+	serialize() {
+		return this.#rules.map(serializeRuleSafe).join("");
+	}
+	/** Drain opt-in mutation diagnostics without affecting CSSOM behavior. */
+	takeDiagnostics() {
+		if (!this.#diagnostics) return [];
+		return this.#diagnostics.splice(0);
+	}
+};
+/** Forgivingly parse an existing regular stylesheet without loading imports. */
+function parseStyleSheet(cssText, options = {}) {
+	const sheet = new CSSStyleSheet(options);
+	const href = options.href ?? null;
+	regularSheetMetadata.set(sheet, {
+		href,
+		baseURL: options.baseURL ?? href ?? "about:blank"
+	});
+	sheet.replaceSync(`${cssText}`);
+	return sheet;
+}
+//#endregion
+exports.CSSConditionRule = CSSConditionRule;
+exports.CSSContainerRule = CSSContainerRule;
+exports.CSSCounterStyleRule = CSSCounterStyleRule;
+exports.CSSFontFaceRule = CSSFontFaceRule;
+exports.CSSFontFeatureValuesMap = CSSFontFeatureValuesMap;
+exports.CSSFontFeatureValuesRule = CSSFontFeatureValuesRule;
+exports.CSSGroupingRule = CSSGroupingRule;
+exports.CSSImportRule = CSSImportRule;
+exports.CSSKeyframeRule = CSSKeyframeRule;
+exports.CSSKeyframesRule = CSSKeyframesRule;
+exports.CSSLayerBlockRule = CSSLayerBlockRule;
+exports.CSSMarginRule = CSSMarginRule;
+exports.CSSMediaRule = CSSMediaRule;
+exports.CSSNestedDeclarations = CSSNestedDeclarations;
+exports.CSSPageRule = CSSPageRule;
+exports.CSSPositionTryRule = CSSPositionTryRule;
+exports.CSSRule = CSSRule;
+exports.CSSRuleList = CSSRuleList;
+exports.CSSScopeRule = CSSScopeRule;
+exports.CSSStartingStyleRule = CSSStartingStyleRule;
+exports.CSSStyleDeclaration = CSSStyleDeclaration;
+exports.CSSStyleRule = CSSStyleRule;
+exports.CSSStyleSheet = CSSStyleSheet;
+exports.CSSSupportsRule = CSSSupportsRule;
+exports.MediaList = MediaList;
+exports.parseStyleSheet = parseStyleSheet;
+
+//# sourceMappingURL=index.cjs.map