@variance-authority/presentation 0.1.0

package/dist/browser-agent.bundle.js

@@ -0,0 +1,3587 @@
+"use strict";
+(() => {
+  // packages/core/dist/format/canonical.js
+  function canonicalize(value) {
+    if (value === null)
+      return "null";
+    switch (typeof value) {
+      case "boolean":
+        return value ? "true" : "false";
+      case "number":
+        return canonicalNumber(value);
+      case "string":
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+      return `[${value.map((item) => canonicalize(item)).join(",")}]`;
+    }
+    const record2 = value;
+    const parts = [];
+    for (const key of Object.keys(record2).sort()) {
+      const member = record2[key];
+      if (member === void 0)
+        continue;
+      parts.push(`${JSON.stringify(key)}:${canonicalize(member)}`);
+    }
+    return `{${parts.join(",")}}`;
+  }
+  function canonicalNumber(value) {
+    if (!Number.isFinite(value)) {
+      throw new RangeError(`canonical serialization requires a finite number, received ${value}`);
+    }
+    if (Object.is(value, -0))
+      return "0";
+    return String(value);
+  }
+
+  // packages/core/dist/format/sha256.js
+  var K = new Uint32Array([
+    1116352408,
+    1899447441,
+    3049323471,
+    3921009573,
+    961987163,
+    1508970993,
+    2453635748,
+    2870763221,
+    3624381080,
+    310598401,
+    607225278,
+    1426881987,
+    1925078388,
+    2162078206,
+    2614888103,
+    3248222580,
+    3835390401,
+    4022224774,
+    264347078,
+    604807628,
+    770255983,
+    1249150122,
+    1555081692,
+    1996064986,
+    2554220882,
+    2821834349,
+    2952996808,
+    3210313671,
+    3336571891,
+    3584528711,
+    113926993,
+    338241895,
+    666307205,
+    773529912,
+    1294757372,
+    1396182291,
+    1695183700,
+    1986661051,
+    2177026350,
+    2456956037,
+    2730485921,
+    2820302411,
+    3259730800,
+    3345764771,
+    3516065817,
+    3600352804,
+    4094571909,
+    275423344,
+    430227734,
+    506948616,
+    659060556,
+    883997877,
+    958139571,
+    1322822218,
+    1537002063,
+    1747873779,
+    1955562222,
+    2024104815,
+    2227730452,
+    2361852424,
+    2428436474,
+    2756734187,
+    3204031479,
+    3329325298
+  ]);
+  var INITIAL = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  function sha256Hex(input) {
+    return sha256HexBytes(utf8Bytes(input));
+  }
+  function sha256HexBytes(bytes) {
+    const state = new Uint32Array(INITIAL);
+    const bitLength = bytes.length * 8;
+    const paddedLength = Math.ceil((bytes.length + 9) / 64) * 64;
+    const padded = new Uint8Array(paddedLength);
+    padded.set(bytes);
+    padded[bytes.length] = 128;
+    const view = new DataView(padded.buffer);
+    view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296), false);
+    view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+    const w = new Uint32Array(64);
+    for (let offset = 0; offset < paddedLength; offset += 64) {
+      for (let i = 0; i < 16; i += 1) {
+        w[i] = view.getUint32(offset + i * 4, false);
+      }
+      for (let i = 16; i < 64; i += 1) {
+        const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
+        const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
+        w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+      }
+      let [a, b, c, d, e, f, g, h] = state;
+      for (let i = 0; i < 64; i += 1) {
+        const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+        const ch = e & f ^ ~e & g;
+        const temp1 = h + S1 + ch + K[i] + w[i] >>> 0;
+        const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+        const maj = a & b ^ a & c ^ b & c;
+        const temp2 = S0 + maj >>> 0;
+        h = g;
+        g = f;
+        f = e;
+        e = d + temp1 >>> 0;
+        d = c;
+        c = b;
+        b = a;
+        a = temp1 + temp2 >>> 0;
+      }
+      state[0] = state[0] + a >>> 0;
+      state[1] = state[1] + b >>> 0;
+      state[2] = state[2] + c >>> 0;
+      state[3] = state[3] + d >>> 0;
+      state[4] = state[4] + e >>> 0;
+      state[5] = state[5] + f >>> 0;
+      state[6] = state[6] + g >>> 0;
+      state[7] = state[7] + h >>> 0;
+    }
+    let hex = "";
+    for (const word of state) {
+      hex += word.toString(16).padStart(8, "0");
+    }
+    return hex;
+  }
+  function rotr(value, bits) {
+    return (value >>> bits | value << 32 - bits) >>> 0;
+  }
+  function utf8Bytes(input) {
+    const bytes = [];
+    for (let i = 0; i < input.length; i += 1) {
+      let code = input.charCodeAt(i);
+      if (code >= 55296 && code <= 56319) {
+        const next = input.charCodeAt(i + 1);
+        if (next >= 56320 && next <= 57343) {
+          code = 65536 + (code - 55296 << 10) + (next - 56320);
+          i += 1;
+        } else {
+          code = 65533;
+        }
+      } else if (code >= 56320 && code <= 57343) {
+        code = 65533;
+      }
+      if (code < 128) {
+        bytes.push(code);
+      } else if (code < 2048) {
+        bytes.push(192 | code >> 6, 128 | code & 63);
+      } else if (code < 65536) {
+        bytes.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+      } else {
+        bytes.push(240 | code >> 18, 128 | code >> 12 & 63, 128 | code >> 6 & 63, 128 | code & 63);
+      }
+    }
+    return Uint8Array.from(bytes);
+  }
+
+  // packages/core/dist/format/hash.js
+  var PREFIX = "v1";
+  var HEX_LENGTH = 32;
+  function digestString(input) {
+    return `${PREFIX}:${sha256Hex(input).slice(0, HEX_LENGTH)}`;
+  }
+  function digestValue(value) {
+    return digestString(canonicalize(value));
+  }
+
+  // packages/core/dist/format/profile.js
+  var JSDOM_PROFILE = {
+    id: "jsdom",
+    ariaTree: true,
+    declaredStyle: true,
+    computedStyle: false,
+    layout: false,
+    raster: false
+  };
+  var CHROMIUM_PROFILE = {
+    id: "chromium",
+    ariaTree: true,
+    declaredStyle: true,
+    computedStyle: true,
+    layout: true,
+    raster: true
+  };
+  function tierOfProfile(profile) {
+    if (profile.layout || profile.computedStyle)
+      return "layout";
+    if (profile.declaredStyle || profile.ariaTree)
+      return "semantic";
+    return "reachability";
+  }
+
+  // packages/core/dist/format/tier.js
+  var TIER_ORDER = {
+    reachability: 0,
+    semantic: 1,
+    layout: 2,
+    raster: 3
+  };
+  function tierReaches(available, needs) {
+    return TIER_ORDER[needs] <= TIER_ORDER[available];
+  }
+
+  // packages/core/dist/format/stabilize.js
+  var holdAnimations = {
+    id: "hold-animations",
+    trick: "hold",
+    needs: "layout",
+    governs: "animations",
+    because: "animations settled by the browser: finite fast-forwarded, infinite reset",
+    screenshot: { animations: "disabled" }
+  };
+  var pinAnimations = {
+    id: "pin-animations",
+    trick: "hold",
+    needs: "layout",
+    governs: "animations",
+    because: "animations pinned at their first frame, which is not where a user sees them",
+    css: "*,*::before,*::after{animation-play-state:paused !important;animation-delay:-0.0001s !important;transition-duration:0s !important;transition-delay:0s !important;scroll-behavior:auto !important}"
+  };
+  var hideCaret = {
+    id: "hide-caret",
+    trick: "support",
+    // A caret paints and does not lay out, so a tier that never rasterizes cannot
+    // see it and must not pay to hide it.
+    needs: "raster",
+    governs: "caret",
+    because: "text caret hidden, because it blinks on its own schedule",
+    screenshot: { caret: "hide" }
+  };
+  var hideScrollbars = {
+    id: "hide-scrollbars",
+    trick: "support",
+    needs: "layout",
+    governs: "scrollbars",
+    because: "scrollbars hidden, removing a platform and preference difference \u2014 and their width",
+    css: "*{scrollbar-width:none !important}\n*::-webkit-scrollbar{display:none !important}"
+  };
+  var hidePresentationalImages = {
+    id: "hide-presentational-images",
+    trick: "support",
+    // `layout` rather than `raster`, and the difference is whether it runs at all.
+    // A raster-tier trick is filtered out of every *collection* — `tierOfProfile`
+    // never returns `raster` — so it would only reach a page through a renderer
+    // option, which is not where an operator configures their suite. A collection
+    // sheet is in force when the document is serialized, so hiding it here is what
+    // makes the pixels absent from the render.
+    needs: "layout",
+    governs: "presentational-images",
+    because: "images the page marked decorative hidden, keeping their boxes \u2014 real changes inside them are not reported",
+    css: 'img[role="presentation"],img[alt=""],[role="presentation"] img,[role="none"] img{visibility:hidden !important}'
+  };
+  var waitForFonts = {
+    id: "wait-for-fonts",
+    trick: "wait",
+    needs: "layout",
+    governs: "fonts",
+    because: "waited for web fonts, whose advances change every metric on the page",
+    // Written without a module-scope helper on purpose: a settle closure is
+    // shipped to a page as source text, so anything it names by identifier is a
+    // `ReferenceError` on the far side. Types are erased and therefore free.
+    settle: async (target) => {
+      await target.evaluate(async () => {
+        const view = globalThis;
+        await view.document.fonts?.ready;
+      });
+    }
+  };
+  var waitForImages = {
+    id: "wait-for-images",
+    trick: "wait",
+    needs: "layout",
+    governs: "images",
+    because: "waited for images to decode, since their intrinsic size participates in layout, and asked for the ones the browser had deferred",
+    settle: async (target) => {
+      await target.evaluate(async () => {
+        const view = globalThis;
+        const pending = Array.from(view.document.images).filter((image) => !image.complete);
+        const arrived = Promise.all(pending.map((image) => new Promise((resolve) => {
+          image.addEventListener("load", () => resolve(), { once: true });
+          image.addEventListener("error", () => resolve(), { once: true });
+        })));
+        const asServed = pending.map((image) => image.loading);
+        for (const image of pending)
+          image.loading = "eager";
+        let timer;
+        const expired = new Promise((_, reject) => {
+          timer = view.setTimeout(() => {
+            const stuck = pending.filter((image) => !image.complete);
+            reject(new Error(`${stuck.length} image(s) had not loaded after 15000ms, and neither answered nor failed: ${stuck.map((image) => image.currentSrc || image.src).join(", ")}`));
+          }, 15e3);
+        });
+        try {
+          await Promise.race([arrived, expired]);
+        } finally {
+          view.clearTimeout(timer);
+          for (let index = 0; index < pending.length; index += 1) {
+            pending[index].loading = asServed[index];
+          }
+        }
+      });
+    }
+  };
+  var INTERVENTIONS = [
+    holdAnimations,
+    pinAnimations,
+    hideCaret,
+    hideScrollbars,
+    hidePresentationalImages,
+    waitForFonts,
+    waitForImages
+  ];
+  var LAYOUT_RECIPE = [holdAnimations, hideScrollbars, waitForFonts, waitForImages];
+  var RASTER_RECIPE = [...LAYOUT_RECIPE, hideCaret];
+  var COLLECT_RECIPE = [
+    pinAnimations,
+    hideScrollbars,
+    waitForFonts,
+    waitForImages
+  ];
+  function interventionById(id) {
+    return INTERVENTIONS.find((intervention) => intervention.id === id);
+  }
+  function recipeOf(ids) {
+    return ids.map((id) => {
+      const intervention = interventionById(id);
+      if (intervention === void 0) {
+        throw new Error(`no stabilization trick is called \`${id}\`; this build knows ` + INTERVENTIONS.map((known) => `\`${known.id}\``).join(", "));
+      }
+      return intervention;
+    });
+  }
+  function forTier(recipe, tier) {
+    return recipe.filter((intervention) => tierReaches(tier, intervention.needs));
+  }
+  function recipeCss(recipe) {
+    return recipe.map((intervention) => intervention.css).filter((css) => css !== void 0).join("\n");
+  }
+  async function settleRecipe(recipe, target) {
+    for (const intervention of recipe) {
+      if (intervention.settle !== void 0)
+        await intervention.settle(target);
+    }
+  }
+  function recipeDigest(recipe) {
+    return digestValue(recipe.map((intervention) => intervention.id).sort());
+  }
+
+  // packages/core/dist/format/provenance.js
+  var JSX_SOURCE = Symbol.for("@variance-authority/jsx-source");
+
+  // packages/core/dist/rules/ruleset.js
+  var STYLE_ALLOWLIST = [
+    // Box model and formatting context
+    "display",
+    "position",
+    "top",
+    "right",
+    "bottom",
+    "left",
+    "float",
+    "clear",
+    "width",
+    "height",
+    "min-width",
+    "min-height",
+    "max-width",
+    "max-height",
+    "margin-top",
+    "margin-right",
+    "margin-bottom",
+    "margin-left",
+    "padding-top",
+    "padding-right",
+    "padding-bottom",
+    "padding-left",
+    "box-sizing",
+    "overflow-x",
+    "overflow-y",
+    "z-index",
+    "aspect-ratio",
+    // Flex and grid
+    "flex-direction",
+    "flex-wrap",
+    "flex-grow",
+    "flex-shrink",
+    "flex-basis",
+    "justify-content",
+    "align-items",
+    "align-self",
+    "align-content",
+    "order",
+    "grid-template-columns",
+    "grid-template-rows",
+    "grid-template-areas",
+    "grid-auto-columns",
+    "grid-auto-rows",
+    "grid-auto-flow",
+    "grid-column-start",
+    "grid-column-end",
+    "grid-row-start",
+    "grid-row-end",
+    "row-gap",
+    "column-gap",
+    // Typography
+    "font-family",
+    "font-size",
+    "font-weight",
+    "font-style",
+    "font-variant",
+    "font-stretch",
+    "line-height",
+    "letter-spacing",
+    "word-spacing",
+    "text-align",
+    "text-indent",
+    "text-transform",
+    "text-overflow",
+    "text-decoration-line",
+    "text-decoration-color",
+    "text-decoration-style",
+    "text-decoration-thickness",
+    "white-space",
+    "word-break",
+    "overflow-wrap",
+    "vertical-align",
+    "writing-mode",
+    "direction",
+    // Paint
+    "color",
+    "opacity",
+    "background-color",
+    "background-image",
+    // Native-control painting. `accent-color` restyles checkboxes and radios,
+    // which is exactly the kind of property the rest of this list misses: it
+    // describes what the *engine* paints rather than what the author declares
+    // about a box. See the note below.
+    "accent-color",
+    "-webkit-text-stroke-width",
+    "background-position",
+    "background-size",
+    "background-repeat",
+    "background-clip",
+    "background-origin",
+    "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-top-left-radius",
+    "border-top-right-radius",
+    "border-bottom-right-radius",
+    "border-bottom-left-radius",
+    "outline-width",
+    "outline-style",
+    "outline-color",
+    "outline-offset",
+    "box-shadow",
+    "text-shadow",
+    "filter",
+    "backdrop-filter",
+    "mix-blend-mode",
+    // Visibility and geometry transforms
+    "visibility",
+    "content-visibility",
+    "transform",
+    "transform-origin",
+    "object-fit",
+    "object-position",
+    // Tables
+    "table-layout",
+    "border-collapse",
+    "border-spacing",
+    "caption-side"
+  ];
+  var ALLOWED = new Set(STYLE_ALLOWLIST);
+  function isAllowedProperty(property) {
+    return ALLOWED.has(property);
+  }
+  function isCustomProperty(property) {
+    return property.startsWith("--");
+  }
+  function admits(property) {
+    return isCustomProperty(property) || isAllowedProperty(property);
+  }
+  var ATTRIBUTE_ALLOWLIST = [
+    "type",
+    "value",
+    "checked",
+    "disabled",
+    "readonly",
+    "required",
+    "multiple",
+    "placeholder",
+    "name",
+    "href",
+    "target",
+    "rel",
+    "src",
+    "alt",
+    "title",
+    "for",
+    "form",
+    "list",
+    "headers",
+    "colspan",
+    "rowspan",
+    "scope",
+    "lang",
+    "dir",
+    "hidden",
+    "open",
+    "selected",
+    "download",
+    "min",
+    "max",
+    "step",
+    "pattern",
+    "maxlength",
+    "minlength",
+    "autocomplete",
+    "role",
+    "tabindex",
+    "draggable",
+    "contenteditable",
+    "width",
+    "height",
+    "loading",
+    "decoding",
+    "srcset",
+    "sizes",
+    "poster",
+    "controls"
+  ];
+  var ATTRIBUTES = new Set(ATTRIBUTE_ALLOWLIST);
+  var ID_REFERENCE_ATTRIBUTES = [
+    "id",
+    "for",
+    "form",
+    "list",
+    "headers",
+    "aria-labelledby",
+    "aria-describedby",
+    "aria-controls",
+    "aria-owns",
+    "aria-activedescendant",
+    "aria-details",
+    "aria-errormessage",
+    "aria-flowto"
+  ];
+  var ID_REFERENCE_LIST_ATTRIBUTES = [
+    "headers",
+    "aria-labelledby",
+    "aria-describedby",
+    "aria-controls",
+    "aria-owns",
+    "aria-flowto"
+  ];
+
+  // packages/core/dist/rules/normalize/alias.js
+  var ID_LIST_ATTRIBUTES = new Set(ID_REFERENCE_LIST_ATTRIBUTES);
+  var ID_REFERENCE = new Set(ID_REFERENCE_ATTRIBUTES);
+
+  // packages/core/dist/rules/normalize/color.js
+  var NAMED = {
+    transparent: [0, 0, 0, 0],
+    aliceblue: [240, 248, 255, 1],
+    antiquewhite: [250, 235, 215, 1],
+    aqua: [0, 255, 255, 1],
+    aquamarine: [127, 255, 212, 1],
+    azure: [240, 255, 255, 1],
+    beige: [245, 245, 220, 1],
+    bisque: [255, 228, 196, 1],
+    black: [0, 0, 0, 1],
+    blanchedalmond: [255, 235, 205, 1],
+    blue: [0, 0, 255, 1],
+    blueviolet: [138, 43, 226, 1],
+    brown: [165, 42, 42, 1],
+    burlywood: [222, 184, 135, 1],
+    cadetblue: [95, 158, 160, 1],
+    chartreuse: [127, 255, 0, 1],
+    chocolate: [210, 105, 30, 1],
+    coral: [255, 127, 80, 1],
+    cornflowerblue: [100, 149, 237, 1],
+    cornsilk: [255, 248, 220, 1],
+    crimson: [220, 20, 60, 1],
+    cyan: [0, 255, 255, 1],
+    darkblue: [0, 0, 139, 1],
+    darkcyan: [0, 139, 139, 1],
+    darkgoldenrod: [184, 134, 11, 1],
+    darkgray: [169, 169, 169, 1],
+    darkgreen: [0, 100, 0, 1],
+    darkgrey: [169, 169, 169, 1],
+    darkkhaki: [189, 183, 107, 1],
+    darkmagenta: [139, 0, 139, 1],
+    darkolivegreen: [85, 107, 47, 1],
+    darkorange: [255, 140, 0, 1],
+    darkorchid: [153, 50, 204, 1],
+    darkred: [139, 0, 0, 1],
+    darksalmon: [233, 150, 122, 1],
+    darkseagreen: [143, 188, 143, 1],
+    darkslateblue: [72, 61, 139, 1],
+    darkslategray: [47, 79, 79, 1],
+    darkslategrey: [47, 79, 79, 1],
+    darkturquoise: [0, 206, 209, 1],
+    darkviolet: [148, 0, 211, 1],
+    deeppink: [255, 20, 147, 1],
+    deepskyblue: [0, 191, 255, 1],
+    dimgray: [105, 105, 105, 1],
+    dimgrey: [105, 105, 105, 1],
+    dodgerblue: [30, 144, 255, 1],
+    firebrick: [178, 34, 34, 1],
+    floralwhite: [255, 250, 240, 1],
+    forestgreen: [34, 139, 34, 1],
+    fuchsia: [255, 0, 255, 1],
+    gainsboro: [220, 220, 220, 1],
+    ghostwhite: [248, 248, 255, 1],
+    gold: [255, 215, 0, 1],
+    goldenrod: [218, 165, 32, 1],
+    gray: [128, 128, 128, 1],
+    green: [0, 128, 0, 1],
+    greenyellow: [173, 255, 47, 1],
+    grey: [128, 128, 128, 1],
+    honeydew: [240, 255, 240, 1],
+    hotpink: [255, 105, 180, 1],
+    indianred: [205, 92, 92, 1],
+    indigo: [75, 0, 130, 1],
+    ivory: [255, 255, 240, 1],
+    khaki: [240, 230, 140, 1],
+    lavender: [230, 230, 250, 1],
+    lavenderblush: [255, 240, 245, 1],
+    lawngreen: [124, 252, 0, 1],
+    lemonchiffon: [255, 250, 205, 1],
+    lightblue: [173, 216, 230, 1],
+    lightcoral: [240, 128, 128, 1],
+    lightcyan: [224, 255, 255, 1],
+    lightgoldenrodyellow: [250, 250, 210, 1],
+    lightgray: [211, 211, 211, 1],
+    lightgreen: [144, 238, 144, 1],
+    lightgrey: [211, 211, 211, 1],
+    lightpink: [255, 182, 193, 1],
+    lightsalmon: [255, 160, 122, 1],
+    lightseagreen: [32, 178, 170, 1],
+    lightskyblue: [135, 206, 250, 1],
+    lightslategray: [119, 136, 153, 1],
+    lightslategrey: [119, 136, 153, 1],
+    lightsteelblue: [176, 196, 222, 1],
+    lightyellow: [255, 255, 224, 1],
+    lime: [0, 255, 0, 1],
+    limegreen: [50, 205, 50, 1],
+    linen: [250, 240, 230, 1],
+    magenta: [255, 0, 255, 1],
+    maroon: [128, 0, 0, 1],
+    mediumaquamarine: [102, 205, 170, 1],
+    mediumblue: [0, 0, 205, 1],
+    mediumorchid: [186, 85, 211, 1],
+    mediumpurple: [147, 112, 219, 1],
+    mediumseagreen: [60, 179, 113, 1],
+    mediumslateblue: [123, 104, 238, 1],
+    mediumspringgreen: [0, 250, 154, 1],
+    mediumturquoise: [72, 209, 204, 1],
+    mediumvioletred: [199, 21, 133, 1],
+    midnightblue: [25, 25, 112, 1],
+    mintcream: [245, 255, 250, 1],
+    mistyrose: [255, 228, 225, 1],
+    moccasin: [255, 228, 181, 1],
+    navajowhite: [255, 222, 173, 1],
+    navy: [0, 0, 128, 1],
+    oldlace: [253, 245, 230, 1],
+    olive: [128, 128, 0, 1],
+    olivedrab: [107, 142, 35, 1],
+    orange: [255, 165, 0, 1],
+    orangered: [255, 69, 0, 1],
+    orchid: [218, 112, 214, 1],
+    palegoldenrod: [238, 232, 170, 1],
+    palegreen: [152, 251, 152, 1],
+    paleturquoise: [175, 238, 238, 1],
+    palevioletred: [219, 112, 147, 1],
+    papayawhip: [255, 239, 213, 1],
+    peachpuff: [255, 218, 185, 1],
+    peru: [205, 133, 63, 1],
+    pink: [255, 192, 203, 1],
+    plum: [221, 160, 221, 1],
+    powderblue: [176, 224, 230, 1],
+    purple: [128, 0, 128, 1],
+    rebeccapurple: [102, 51, 153, 1],
+    red: [255, 0, 0, 1],
+    rosybrown: [188, 143, 143, 1],
+    royalblue: [65, 105, 225, 1],
+    saddlebrown: [139, 69, 19, 1],
+    salmon: [250, 128, 114, 1],
+    sandybrown: [244, 164, 96, 1],
+    seagreen: [46, 139, 87, 1],
+    seashell: [255, 245, 238, 1],
+    sienna: [160, 82, 45, 1],
+    silver: [192, 192, 192, 1],
+    skyblue: [135, 206, 235, 1],
+    slateblue: [106, 90, 205, 1],
+    slategray: [112, 128, 144, 1],
+    slategrey: [112, 128, 144, 1],
+    snow: [255, 250, 250, 1],
+    springgreen: [0, 255, 127, 1],
+    steelblue: [70, 130, 180, 1],
+    tan: [210, 180, 140, 1],
+    teal: [0, 128, 128, 1],
+    thistle: [216, 191, 216, 1],
+    tomato: [255, 99, 71, 1],
+    turquoise: [64, 224, 208, 1],
+    violet: [238, 130, 238, 1],
+    wheat: [245, 222, 179, 1],
+    white: [255, 255, 255, 1],
+    whitesmoke: [245, 245, 245, 1],
+    yellow: [255, 255, 0, 1],
+    yellowgreen: [154, 205, 50, 1]
+  };
+  function parseColor(input) {
+    const value = input.trim().toLowerCase();
+    const named = NAMED[value];
+    if (named)
+      return named;
+    if (value.startsWith("#"))
+      return parseHex(value);
+    if (value.startsWith("rgb"))
+      return parseRgbFunction(value);
+    if (value.startsWith("hsl"))
+      return parseHslFunction(value);
+    return null;
+  }
+  function formatColor([r, g, b, a]) {
+    const channels = `${clampChannel(r)} ${clampChannel(g)} ${clampChannel(b)}`;
+    const alpha = Math.round(clamp(a, 0, 1) * 1e3) / 1e3;
+    return `rgb(${channels} / ${alpha})`;
+  }
+  function canonicalizeColor(input) {
+    const parsed = parseColor(input);
+    return parsed ? formatColor(parsed) : collapseWhitespace(input);
+  }
+  function isColorProperty(property) {
+    return property === "color" || property.endsWith("-color") || property === "background-color" || property === "caret-color";
+  }
+  function parseHex(value) {
+    const hex = value.slice(1);
+    const expand = (c) => Number.parseInt(c + c, 16);
+    const pair2 = (i) => Number.parseInt(hex.slice(i, i + 2), 16);
+    switch (hex.length) {
+      case 3:
+        return [expand(hex[0]), expand(hex[1]), expand(hex[2]), 1];
+      case 4:
+        return [expand(hex[0]), expand(hex[1]), expand(hex[2]), expand(hex[3]) / 255];
+      case 6:
+        return [pair2(0), pair2(2), pair2(4), 1];
+      case 8:
+        return [pair2(0), pair2(2), pair2(4), pair2(6) / 255];
+      default:
+        return null;
+    }
+  }
+  function parseRgbFunction(value) {
+    const args = functionArguments(value);
+    if (!args || args.length < 3)
+      return null;
+    const channel = (raw) => raw.endsWith("%") ? Number.parseFloat(raw) / 100 * 255 : Number.parseFloat(raw);
+    const r = channel(args[0]);
+    const g = channel(args[1]);
+    const b = channel(args[2]);
+    const a = args.length > 3 ? parseAlpha(args[3]) : 1;
+    return [r, g, b, a].some(Number.isNaN) ? null : [Math.round(r), Math.round(g), Math.round(b), a];
+  }
+  function parseHslFunction(value) {
+    const args = functionArguments(value);
+    if (!args || args.length < 3)
+      return null;
+    const h = (Number.parseFloat(args[0]) % 360 + 360) % 360;
+    const s = Number.parseFloat(args[1]) / 100;
+    const l = Number.parseFloat(args[2]) / 100;
+    const a = args.length > 3 ? parseAlpha(args[3]) : 1;
+    if ([h, s, l, a].some(Number.isNaN))
+      return null;
+    const c = (1 - Math.abs(2 * l - 1)) * s;
+    const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+    const m = l - c / 2;
+    const sextant = Math.floor(h / 60) % 6;
+    const rgb = [
+      [c, x, 0],
+      [x, c, 0],
+      [0, c, x],
+      [0, x, c],
+      [x, 0, c],
+      [c, 0, x]
+    ];
+    const [r, g, b] = rgb[sextant];
+    return [Math.round((r + m) * 255), Math.round((g + m) * 255), Math.round((b + m) * 255), a];
+  }
+  function parseAlpha(raw) {
+    return raw.endsWith("%") ? Number.parseFloat(raw) / 100 : Number.parseFloat(raw);
+  }
+  function functionArguments(value) {
+    const open = value.indexOf("(");
+    const close = value.lastIndexOf(")");
+    if (open < 0 || close < open)
+      return null;
+    return value.slice(open + 1, close).split(/[\s,/]+/).filter((part) => part.length > 0);
+  }
+  function clampChannel(value) {
+    return Math.round(clamp(value, 0, 255));
+  }
+  function clamp(value, min, max) {
+    return value < min ? min : value > max ? max : value;
+  }
+  function collapseWhitespace(value) {
+    return value.trim().replace(/\s+/g, " ");
+  }
+
+  // packages/core/dist/rules/normalize/value.js
+  var ABSOLUTE_LENGTHS = {
+    px: 1,
+    pt: 96 / 72,
+    pc: 16,
+    in: 96,
+    cm: 96 / 2.54,
+    mm: 96 / 25.4,
+    q: 96 / 101.6
+  };
+  var ANGLES = {
+    deg: 1,
+    grad: 0.9,
+    rad: 180 / Math.PI,
+    turn: 360
+  };
+  var RELATIVE_UNITS = [
+    "em",
+    "rem",
+    "ex",
+    "ch",
+    "cap",
+    "ic",
+    "lh",
+    "rlh",
+    "vw",
+    "vh",
+    "vmin",
+    "vmax",
+    "vi",
+    "vb",
+    "svw",
+    "svh",
+    "lvw",
+    "lvh",
+    "dvw",
+    "dvh",
+    "%"
+  ];
+  var LENGTH_PRECISION = 4;
+  function canonicalizeValue(property, value) {
+    if (isColorProperty(property))
+      return canonicalizeColor(value);
+    return canonicalizeTokens(value);
+  }
+  function canonicalizeTokens(value) {
+    const out = [];
+    let index = 0;
+    const input = value.trim();
+    while (index < input.length) {
+      const char = input[index];
+      if (/\s/.test(char)) {
+        if (out.length > 0 && out[out.length - 1] !== " ")
+          out.push(" ");
+        index += 1;
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        const end = closingQuote(input, index);
+        out.push(input.slice(index, end + 1));
+        index = end + 1;
+        continue;
+      }
+      if (input.slice(index).toLowerCase().startsWith("url(")) {
+        const end = matchingParen(input, index + 3);
+        out.push(`url${input.slice(index + 3, end + 1)}`);
+        index = end + 1;
+        continue;
+      }
+      const numeric = /^[+-]?(\d+\.?\d*|\.\d+)(e[+-]?\d+)?([a-z%]*)/i.exec(input.slice(index));
+      if (numeric && numeric[0].length > 0) {
+        out.push(canonicalizeDimension(numeric[0]));
+        index += numeric[0].length;
+        continue;
+      }
+      const identifier = /^[a-z_-][\w-]*/i.exec(input.slice(index));
+      if (identifier) {
+        out.push(identifier[0].toLowerCase());
+        index += identifier[0].length;
+        continue;
+      }
+      if (char === "," && out[out.length - 1] === " ")
+        out.pop();
+      out.push(char);
+      index += 1;
+    }
+    return out.join("").trim();
+  }
+  function canonicalizeDimension(token) {
+    const match = /^([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)([a-z%]*)$/i.exec(token);
+    if (!match)
+      return token.toLowerCase();
+    const magnitude = Number.parseFloat(match[1]);
+    const unit = match[2].toLowerCase();
+    if (!Number.isFinite(magnitude))
+      return token.toLowerCase();
+    if (magnitude === 0 && (unit === "" || unit in ABSOLUTE_LENGTHS || isRelativeUnit(unit))) {
+      return "0";
+    }
+    const lengthFactor = ABSOLUTE_LENGTHS[unit];
+    if (lengthFactor !== void 0)
+      return `${round(magnitude * lengthFactor)}px`;
+    const angleFactor = ANGLES[unit];
+    if (angleFactor !== void 0)
+      return `${round(magnitude * angleFactor)}deg`;
+    return `${round(magnitude)}${unit}`;
+  }
+  function isRelativeUnit(unit) {
+    return RELATIVE_UNITS.includes(unit.toLowerCase());
+  }
+  function round(value) {
+    const factor = 10 ** LENGTH_PRECISION;
+    const rounded = Math.round(value * factor) / factor;
+    return Object.is(rounded, -0) ? 0 : rounded;
+  }
+  function closingQuote(input, start) {
+    const quote = input[start];
+    for (let i = start + 1; i < input.length; i += 1) {
+      if (input[i] === "\\") {
+        i += 1;
+        continue;
+      }
+      if (input[i] === quote)
+        return i;
+    }
+    return input.length - 1;
+  }
+  function matchingParen(input, openIndex) {
+    let depth = 0;
+    for (let i = openIndex; i < input.length; i += 1) {
+      if (input[i] === "(")
+        depth += 1;
+      else if (input[i] === ")") {
+        depth -= 1;
+        if (depth === 0)
+          return i;
+      }
+    }
+    return input.length - 1;
+  }
+
+  // packages/core/dist/rules/normalize/shorthand.js
+  var SHORTHAND_PROPERTIES = [
+    "margin",
+    "padding",
+    "inset",
+    "gap",
+    "overflow",
+    "border",
+    "border-width",
+    "border-style",
+    "border-color",
+    "border-radius",
+    "border-top",
+    "border-right",
+    "border-bottom",
+    "border-left",
+    "outline",
+    "flex",
+    "flex-flow",
+    "place-items",
+    "place-content",
+    "place-self",
+    "grid-row",
+    "grid-column",
+    "grid-area",
+    "text-decoration",
+    "background",
+    "font"
+  ];
+  var SIDES = ["top", "right", "bottom", "left"];
+  var CORNERS = [
+    "border-top-left-radius",
+    "border-top-right-radius",
+    "border-bottom-right-radius",
+    "border-bottom-left-radius"
+  ];
+  var LINE_STYLES = /* @__PURE__ */ new Set([
+    "none",
+    "hidden",
+    "dotted",
+    "dashed",
+    "solid",
+    "double",
+    "groove",
+    "ridge",
+    "inset",
+    "outset"
+  ]);
+  var LINE_WIDTHS = /* @__PURE__ */ new Set(["thin", "medium", "thick"]);
+  function expandDeclaration(property, value) {
+    const expand = EXPANDERS[property];
+    if (!expand)
+      return { declarations: [{ property, value }], confident: true };
+    const expanded = expand(value.trim());
+    return expanded ?? { declarations: [{ property, value }], confident: false };
+  }
+  var EXPANDERS = {
+    margin: (v) => box(v, (side) => `margin-${side}`),
+    padding: (v) => box(v, (side) => `padding-${side}`),
+    inset: (v) => box(v, (side) => side),
+    "border-width": (v) => box(v, (side) => `border-${side}-width`),
+    "border-style": (v) => box(v, (side) => `border-${side}-style`),
+    "border-color": (v) => box(v, (side) => `border-${side}-color`),
+    "scroll-margin": (v) => box(v, (side) => `scroll-margin-${side}`),
+    "scroll-padding": (v) => box(v, (side) => `scroll-padding-${side}`),
+    gap: (v) => pair(v, "row-gap", "column-gap"),
+    overflow: (v) => pair(v, "overflow-x", "overflow-y"),
+    "place-items": (v) => pair(v, "align-items", "justify-items"),
+    "place-content": (v) => pair(v, "align-content", "justify-content"),
+    "place-self": (v) => pair(v, "align-self", "justify-self"),
+    "grid-row": (v) => slash(v, "grid-row-start", "grid-row-end"),
+    "grid-column": (v) => slash(v, "grid-column-start", "grid-column-end"),
+    "border-radius": expandBorderRadius,
+    border: (v) => expandBorderSides(v, SIDES),
+    "border-top": (v) => expandBorderSides(v, ["top"]),
+    "border-right": (v) => expandBorderSides(v, ["right"]),
+    "border-bottom": (v) => expandBorderSides(v, ["bottom"]),
+    "border-left": (v) => expandBorderSides(v, ["left"]),
+    outline: expandOutline,
+    flex: expandFlex,
+    "flex-flow": expandFlexFlow,
+    "text-decoration": expandTextDecoration,
+    // `background` and `font` are the two shorthands whose grammars are genuinely
+    // ambiguous to decompose (a bare `<length>` in `background` may be a position
+    // or a size; `font` interleaves four optional keyword slots before a required
+    // size). Both are declared unexpandable rather than guessed at — see the
+    // safety rule above. Under a profile with computed style the engine has
+    // already resolved them into longhands, so this only affects the declared-only
+    // tier, where an un-normalized value is a correct description of what is known.
+    background: () => null,
+    font: () => null
+  };
+  function box(value, name) {
+    const parts = topLevelParts(value);
+    if (parts.length === 0 || parts.length > 4)
+      return null;
+    if (parts.some(isGlobalKeywordAmbiguity))
+      return null;
+    const [a, b = a, c = a, d = b] = parts;
+    const resolved = [a, b, c, d];
+    return {
+      declarations: SIDES.map((side, index) => ({
+        property: name(side),
+        value: resolved[index]
+      })),
+      confident: true
+    };
+  }
+  function pair(value, first, second) {
+    const parts = topLevelParts(value);
+    if (parts.length === 0 || parts.length > 2)
+      return null;
+    const a = parts[0];
+    const b = parts[1] ?? a;
+    return {
+      declarations: [
+        { property: first, value: a },
+        { property: second, value: b }
+      ],
+      confident: true
+    };
+  }
+  function slash(value, start, end) {
+    const parts = value.split("/").map((part) => part.trim());
+    if (parts.length > 2)
+      return null;
+    const a = parts[0];
+    if (parts.length === 1) {
+      if (/^-?[a-z_]/i.test(a) && !/^(auto|span)\b/i.test(a))
+        return null;
+      return {
+        declarations: [
+          { property: start, value: a },
+          { property: end, value: "auto" }
+        ],
+        confident: true
+      };
+    }
+    return {
+      declarations: [
+        { property: start, value: a },
+        { property: end, value: parts[1] }
+      ],
+      confident: true
+    };
+  }
+  function expandBorderRadius(value) {
+    const [horizontal, vertical] = value.split("/").map((part) => part.trim());
+    const h = cornerValues(horizontal ?? "");
+    if (!h)
+      return null;
+    if (vertical === void 0) {
+      return {
+        declarations: CORNERS.map((property, index) => ({ property, value: h[index] })),
+        confident: true
+      };
+    }
+    const v = cornerValues(vertical);
+    if (!v)
+      return null;
+    return {
+      declarations: CORNERS.map((property, index) => ({
+        property,
+        value: `${h[index]} ${v[index]}`
+      })),
+      confident: true
+    };
+  }
+  function cornerValues(value) {
+    const parts = topLevelParts(value);
+    if (parts.length === 0 || parts.length > 4)
+      return null;
+    const [a, b = a, c = a, d = b] = parts;
+    return [a, b, c, d];
+  }
+  function expandBorderSides(value, sides) {
+    const parsed = classifyLineComponents(value);
+    if (!parsed)
+      return null;
+    const declarations = sides.flatMap((side) => [
+      { property: `border-${side}-width`, value: parsed.width },
+      { property: `border-${side}-style`, value: parsed.style },
+      { property: `border-${side}-color`, value: parsed.color }
+    ]);
+    return { declarations, confident: true };
+  }
+  function expandOutline(value) {
+    const parsed = classifyLineComponents(value);
+    if (!parsed)
+      return null;
+    return {
+      declarations: [
+        { property: "outline-width", value: parsed.width },
+        { property: "outline-style", value: parsed.style },
+        { property: "outline-color", value: parsed.color }
+      ],
+      confident: true
+    };
+  }
+  function classifyLineComponents(value) {
+    const parts = topLevelParts(value);
+    if (parts.length === 0 || parts.length > 3)
+      return null;
+    let width;
+    let style;
+    let color;
+    for (const part of parts) {
+      const lower = part.toLowerCase();
+      if (LINE_STYLES.has(lower)) {
+        if (style !== void 0)
+          return null;
+        style = lower;
+      } else if (LINE_WIDTHS.has(lower) || isLength(part)) {
+        if (width !== void 0)
+          return null;
+        width = part;
+      } else if (lower === "currentcolor" || parseColor(part) !== null || part.startsWith("var(")) {
+        if (color !== void 0)
+          return null;
+        color = part;
+      } else {
+        return null;
+      }
+    }
+    return {
+      width: width ?? "medium",
+      style: style ?? "none",
+      color: color ?? "currentcolor"
+    };
+  }
+  function expandFlex(value) {
+    const lower = value.toLowerCase().trim();
+    const keyword = {
+      none: ["0", "0", "auto"],
+      auto: ["1", "1", "auto"],
+      initial: ["0", "1", "auto"]
+    };
+    const preset = keyword[lower];
+    const [grow, shrink, basis] = preset ?? classifyFlexParts(topLevelParts(value)) ?? [];
+    if (grow === void 0 || shrink === void 0 || basis === void 0)
+      return null;
+    return {
+      declarations: [
+        { property: "flex-grow", value: grow },
+        { property: "flex-shrink", value: shrink },
+        { property: "flex-basis", value: basis }
+      ],
+      confident: true
+    };
+  }
+  function classifyFlexParts(parts) {
+    if (parts.length === 1) {
+      const only = parts[0];
+      if (isBareNumber(only))
+        return [only, "1", "0%"];
+      if (isLength(only) || only === "auto" || only === "content")
+        return ["1", "1", only];
+      return null;
+    }
+    if (parts.length === 2) {
+      const [first, second] = parts;
+      if (!isBareNumber(first))
+        return null;
+      if (isBareNumber(second))
+        return [first, second, "0%"];
+      return [first, "1", second];
+    }
+    if (parts.length === 3) {
+      const [grow, shrink, basis] = parts;
+      if (!isBareNumber(grow) || !isBareNumber(shrink))
+        return null;
+      return [grow, shrink, basis];
+    }
+    return null;
+  }
+  function expandFlexFlow(value) {
+    const parts = topLevelParts(value);
+    if (parts.length === 0 || parts.length > 2)
+      return null;
+    const wraps = /* @__PURE__ */ new Set(["nowrap", "wrap", "wrap-reverse"]);
+    const directions = /* @__PURE__ */ new Set(["row", "row-reverse", "column", "column-reverse"]);
+    let direction;
+    let wrap;
+    for (const part of parts) {
+      const lower = part.toLowerCase();
+      if (directions.has(lower)) {
+        if (direction !== void 0)
+          return null;
+        direction = lower;
+      } else if (wraps.has(lower)) {
+        if (wrap !== void 0)
+          return null;
+        wrap = lower;
+      } else {
+        return null;
+      }
+    }
+    return {
+      declarations: [
+        { property: "flex-direction", value: direction ?? "row" },
+        { property: "flex-wrap", value: wrap ?? "nowrap" }
+      ],
+      confident: true
+    };
+  }
+  function expandTextDecoration(value) {
+    const parts = topLevelParts(value);
+    if (parts.length === 0 || parts.length > 4)
+      return null;
+    const lines = /* @__PURE__ */ new Set(["none", "underline", "overline", "line-through", "blink"]);
+    const styles = /* @__PURE__ */ new Set(["solid", "double", "dotted", "dashed", "wavy"]);
+    const lineParts = [];
+    let style;
+    let color;
+    let thickness;
+    for (const part of parts) {
+      const lower = part.toLowerCase();
+      if (lines.has(lower))
+        lineParts.push(lower);
+      else if (styles.has(lower)) {
+        if (style !== void 0)
+          return null;
+        style = lower;
+      } else if (lower === "auto" || lower === "from-font" || isLength(part)) {
+        if (thickness !== void 0)
+          return null;
+        thickness = part;
+      } else if (lower === "currentcolor" || parseColor(part) !== null || part.startsWith("var(")) {
+        if (color !== void 0)
+          return null;
+        color = part;
+      } else {
+        return null;
+      }
+    }
+    return {
+      declarations: [
+        { property: "text-decoration-line", value: lineParts.length > 0 ? lineParts.join(" ") : "none" },
+        { property: "text-decoration-style", value: style ?? "solid" },
+        { property: "text-decoration-color", value: color ?? "currentcolor" },
+        { property: "text-decoration-thickness", value: thickness ?? "auto" }
+      ],
+      confident: true
+    };
+  }
+  function topLevelParts(value) {
+    const parts = [];
+    let depth = 0;
+    let current = "";
+    for (const char of value.trim()) {
+      if (char === "(")
+        depth += 1;
+      else if (char === ")")
+        depth -= 1;
+      if (depth === 0 && /\s/.test(char)) {
+        if (current.length > 0)
+          parts.push(current);
+        current = "";
+        continue;
+      }
+      current += char;
+    }
+    if (current.length > 0)
+      parts.push(current);
+    return parts;
+  }
+  function isGlobalKeywordAmbiguity(part) {
+    const lower = part.toLowerCase();
+    return lower === "inherit" || lower === "initial" || lower === "unset" || lower === "revert" || lower === "revert-layer";
+  }
+  function isLength(part) {
+    return /^[+-]?(\d+\.?\d*|\.\d+)([a-z]+|%)?$/i.test(part) || part.toLowerCase().startsWith("calc(");
+  }
+  function isBareNumber(part) {
+    return /^[+-]?(\d+\.?\d*|\.\d+)$/.test(part);
+  }
+
+  // packages/core/dist/rules/normalize/cascade.js
+  var INHERITED_PROPERTIES = [
+    "color",
+    "font-family",
+    "font-size",
+    "font-weight",
+    "font-style",
+    "font-variant",
+    "font-stretch",
+    "line-height",
+    "letter-spacing",
+    "word-spacing",
+    "text-align",
+    "text-indent",
+    "text-transform",
+    "white-space",
+    "word-break",
+    "overflow-wrap",
+    "visibility",
+    "direction",
+    "writing-mode",
+    "caption-side",
+    "border-collapse",
+    "border-spacing"
+  ];
+  var INHERITED = new Set(INHERITED_PROPERTIES);
+  var EMPTY_CONTEXT = { inherited: {}, customProperties: {} };
+  function resolveStyle(input) {
+    const candidates = collectCandidates(input);
+    const winners = /* @__PURE__ */ new Map();
+    for (const candidate of candidates) {
+      const incumbent = winners.get(candidate.property);
+      if (incumbent === void 0 || wins(candidate, incumbent)) {
+        winners.set(candidate.property, candidate);
+      }
+    }
+    const customProperties = { ...input.context.customProperties };
+    for (const [property, candidate] of winners) {
+      if (isCustomProperty(property))
+        customProperties[property] = candidate.value.trim();
+    }
+    const style = {};
+    const tokens = {};
+    const origins = {};
+    for (const [property, value] of Object.entries(input.context.inherited)) {
+      style[property] = value;
+      const token = input.context.inheritedTokens?.[property];
+      if (token !== void 0) {
+        const resolved = customProperties[token];
+        tokens[token] = resolved === void 0 ? value : tokenValue(property, resolved, customProperties);
+      }
+    }
+    for (const [property, candidate] of winners) {
+      if (isCustomProperty(property))
+        continue;
+      const resolution = resolveVariables(candidate.value, customProperties);
+      style[property] = canonicalizeValue(property, resolution.value);
+      for (const name of resolution.used) {
+        const resolved = customProperties[name];
+        if (resolved !== void 0)
+          tokens[name] = tokenValue(property, resolved, customProperties);
+      }
+      origins[property] = {
+        sheet: candidate.sheet,
+        selector: candidate.selector,
+        ...candidate.source ? { source: candidate.source } : {},
+        ...resolution.used[0] !== void 0 ? { tokenName: resolution.used[0] } : {}
+      };
+    }
+    if (input.computedStyle) {
+      for (const [property, value] of Object.entries(input.computedStyle)) {
+        if (!admits(property) || isCustomProperty(property))
+          continue;
+        style[property] = canonicalizeValue(property, value);
+      }
+    }
+    const propertyTokens = {};
+    for (const property of Object.keys(style)) {
+      const own = origins[property];
+      const token = own !== void 0 ? own.tokenName : input.context.inheritedTokens?.[property];
+      if (token !== void 0)
+        propertyTokens[property] = token;
+    }
+    const childInherited = {};
+    const childInheritedTokens = {};
+    for (const [property, value] of Object.entries(style)) {
+      if (!INHERITED.has(property))
+        continue;
+      childInherited[property] = value;
+      const token = propertyTokens[property];
+      if (token !== void 0)
+        childInheritedTokens[property] = token;
+    }
+    return {
+      style,
+      tokens,
+      origins,
+      propertyTokens,
+      childContext: {
+        inherited: childInherited,
+        customProperties,
+        inheritedTokens: childInheritedTokens
+      }
+    };
+  }
+  function collectCandidates(input) {
+    const candidates = [];
+    for (const rule of input.matchedRules) {
+      for (const declaration2 of rule.declarations) {
+        for (const admitted of admitDeclaration(declaration2)) {
+          candidates.push({
+            ...admitted,
+            inline: false,
+            specificity: specificityRank(rule.specificity),
+            order: rule.order,
+            sheet: rule.sheet,
+            selector: rule.selector,
+            ...rule.source ? { source: rule.source } : {}
+          });
+        }
+      }
+    }
+    for (const [property, value] of Object.entries(input.inlineStyle ?? {})) {
+      const important = value.trimEnd().toLowerCase().endsWith("!important");
+      const bare = important ? value.replace(/!\s*important\s*$/i, "").trim() : value;
+      for (const admitted of admitDeclaration({ property, value: bare, important })) {
+        candidates.push({
+          ...admitted,
+          inline: true,
+          specificity: 0,
+          order: Number.MAX_SAFE_INTEGER,
+          sheet: "inline",
+          selector: "[style]"
+        });
+      }
+    }
+    return candidates;
+  }
+  function admitDeclaration(declaration2) {
+    const property = declaration2.property.trim().toLowerCase();
+    if (isCustomProperty(declaration2.property)) {
+      return [{
+        property: declaration2.property.trim(),
+        value: declaration2.value,
+        important: declaration2.important
+      }];
+    }
+    const expansion = expandDeclaration(property, declaration2.value);
+    if (!expansion.confident) {
+      return [{ property, value: declaration2.value, important: declaration2.important }];
+    }
+    return expansion.declarations.filter((entry) => admits(entry.property)).map((entry) => ({
+      property: entry.property,
+      value: entry.value,
+      important: declaration2.important
+    }));
+  }
+  function wins(candidate, incumbent) {
+    if (candidate.important !== incumbent.important)
+      return candidate.important;
+    if (candidate.inline !== incumbent.inline)
+      return candidate.inline;
+    if (candidate.specificity !== incumbent.specificity) {
+      return candidate.specificity > incumbent.specificity;
+    }
+    return candidate.order >= incumbent.order;
+  }
+  function specificityRank(specificity) {
+    return specificity[0] * 1e6 + specificity[1] * 1e3 + specificity[2];
+  }
+  function tokenValue(property, declared, customProperties) {
+    return canonicalizeValue(property, resolveVariables(declared, customProperties).value);
+  }
+  function resolveVariables(value, customProperties, depth = 0) {
+    if (!value.includes("var(") || depth > 16)
+      return { value, used: [] };
+    const used = [];
+    let result = "";
+    let index = 0;
+    while (index < value.length) {
+      const start = value.indexOf("var(", index);
+      if (start < 0) {
+        result += value.slice(index);
+        break;
+      }
+      result += value.slice(index, start);
+      const end = matchingParen2(value, start + 3);
+      const inner = value.slice(start + 4, end);
+      const comma = topLevelComma(inner);
+      const name = (comma < 0 ? inner : inner.slice(0, comma)).trim();
+      const fallback = comma < 0 ? void 0 : inner.slice(comma + 1).trim();
+      if (!used.includes(name))
+        used.push(name);
+      const declared = customProperties[name];
+      const substituted = declared ?? fallback ?? "";
+      const nested = resolveVariables(substituted, customProperties, depth + 1);
+      result += nested.value;
+      for (const nestedName of nested.used) {
+        if (!used.includes(nestedName))
+          used.push(nestedName);
+      }
+      index = end + 1;
+    }
+    return { value: result, used };
+  }
+  function matchingParen2(input, openIndex) {
+    let depth = 0;
+    for (let i = openIndex; i < input.length; i += 1) {
+      if (input[i] === "(")
+        depth += 1;
+      else if (input[i] === ")") {
+        depth -= 1;
+        if (depth === 0)
+          return i;
+      }
+    }
+    return input.length;
+  }
+  function topLevelComma(input) {
+    let depth = 0;
+    for (let i = 0; i < input.length; i += 1) {
+      const char = input[i];
+      if (char === "(")
+        depth += 1;
+      else if (char === ")")
+        depth -= 1;
+      else if (char === "," && depth === 0)
+        return i;
+    }
+    return -1;
+  }
+
+  // packages/core/dist/compare/impact.js
+  var LAYOUT = [
+    "display",
+    "position",
+    "top",
+    "right",
+    "bottom",
+    "left",
+    "float",
+    "clear",
+    "width",
+    "height",
+    "min-width",
+    "min-height",
+    "max-width",
+    "max-height",
+    "margin-top",
+    "margin-right",
+    "margin-bottom",
+    "margin-left",
+    "padding-top",
+    "padding-right",
+    "padding-bottom",
+    "padding-left",
+    "box-sizing",
+    "overflow-x",
+    "overflow-y",
+    "aspect-ratio",
+    "flex-direction",
+    "flex-wrap",
+    "flex-grow",
+    "flex-shrink",
+    "flex-basis",
+    "justify-content",
+    "align-items",
+    "align-self",
+    "align-content",
+    "order",
+    "grid-template-columns",
+    "grid-template-rows",
+    "grid-template-areas",
+    "grid-auto-columns",
+    "grid-auto-rows",
+    "grid-auto-flow",
+    "grid-column-start",
+    "grid-column-end",
+    "grid-row-start",
+    "grid-row-end",
+    "row-gap",
+    "column-gap",
+    "font-family",
+    "font-size",
+    "font-weight",
+    "font-style",
+    "font-stretch",
+    "font-variant",
+    "line-height",
+    "letter-spacing",
+    "word-spacing",
+    "text-align",
+    "text-indent",
+    "text-transform",
+    "white-space",
+    "word-break",
+    "overflow-wrap",
+    "text-overflow",
+    "vertical-align",
+    "writing-mode",
+    "direction",
+    // Border *width* occupies space; border colour does not. The style longhand
+    // belongs here too, because `none` collapses the border to zero width whatever
+    // the declared width says.
+    "border-top-width",
+    "border-right-width",
+    "border-bottom-width",
+    "border-left-width",
+    "border-top-style",
+    "border-right-style",
+    "border-bottom-style",
+    "border-left-style",
+    "table-layout",
+    "border-collapse",
+    "border-spacing",
+    "caption-side",
+    "content-visibility"
+  ];
+  var PAINT = [
+    "color",
+    "background-color",
+    "background-image",
+    "background-position",
+    "background-size",
+    "background-repeat",
+    "background-clip",
+    "background-origin",
+    "border-top-color",
+    "border-right-color",
+    "border-bottom-color",
+    "border-left-color",
+    "border-top-left-radius",
+    "border-top-right-radius",
+    "border-bottom-right-radius",
+    "border-bottom-left-radius",
+    "box-shadow",
+    "text-shadow",
+    "text-decoration-line",
+    "text-decoration-color",
+    "text-decoration-style",
+    "text-decoration-thickness",
+    "object-fit",
+    "object-position",
+    // `outline` is painted outside the box and never affects layout — that is the
+    // whole reason it exists as a separate property from `border`.
+    "outline-width",
+    "outline-style",
+    "outline-color",
+    "outline-offset",
+    // `visibility: hidden` still occupies its space, unlike `display: none`.
+    "visibility"
+  ];
+  var COMPOSITE = [
+    "transform",
+    "transform-origin",
+    "opacity",
+    "filter",
+    "backdrop-filter",
+    "mix-blend-mode",
+    "z-index"
+  ];
+  var IMPACTS = new Map([
+    ...LAYOUT.map((property) => [property, "layout"]),
+    ...PAINT.map((property) => [property, "paint"]),
+    ...COMPOSITE.map((property) => [property, "composite"])
+  ]);
+
+  // packages/core/dist/attribute/source-map.js
+  var DIGITS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  var VALUE_OF = new Int8Array(128).fill(-1);
+  for (let i = 0; i < DIGITS.length; i += 1)
+    VALUE_OF[DIGITS.charCodeAt(i)] = i;
+
+  // packages/core/dist/attribute/call-site.js
+  var URL_OF = globalThis.URL;
+
+  // packages/core/dist/attribute/instances.js
+  var REFERENCE = new Set(ID_REFERENCE_ATTRIBUTES);
+  var REFERENCE_LIST = new Set(ID_REFERENCE_LIST_ATTRIBUTES);
+
+  // packages/dom/dist/aria.js
+  var IMPLICIT_ROLES = {
+    article: "article",
+    aside: "complementary",
+    button: "button",
+    datalist: "listbox",
+    dd: "definition",
+    details: "group",
+    dialog: "dialog",
+    dt: "term",
+    fieldset: "group",
+    figure: "figure",
+    form: "form",
+    h1: "heading",
+    h2: "heading",
+    h3: "heading",
+    h4: "heading",
+    h5: "heading",
+    h6: "heading",
+    hr: "separator",
+    main: "main",
+    math: "math",
+    menu: "list",
+    meter: "meter",
+    nav: "navigation",
+    ol: "list",
+    optgroup: "group",
+    option: "option",
+    output: "status",
+    p: "paragraph",
+    progress: "progressbar",
+    search: "search",
+    summary: "button",
+    table: "table",
+    tbody: "rowgroup",
+    textarea: "textbox",
+    tfoot: "rowgroup",
+    thead: "rowgroup",
+    tr: "row",
+    ul: "list",
+    caption: "caption",
+    legend: "legend",
+    img: "img"
+  };
+  var INPUT_ROLES = {
+    button: "button",
+    checkbox: "checkbox",
+    email: "textbox",
+    image: "button",
+    number: "spinbutton",
+    radio: "radio",
+    range: "slider",
+    reset: "button",
+    search: "searchbox",
+    submit: "button",
+    tel: "textbox",
+    text: "textbox",
+    url: "textbox"
+  };
+  function ariaOf(element) {
+    const description = accessibleDescription(element);
+    return {
+      role: roleOf(element),
+      name: accessibleName(element),
+      ...description !== null ? { description } : {},
+      state: stateOf(element)
+    };
+  }
+  function roleOf(element) {
+    const explicit = element.getAttribute("role");
+    if (explicit) {
+      const first = explicit.trim().split(/\s+/)[0];
+      if (first)
+        return first;
+    }
+    const tag = element.tagName.toLowerCase();
+    if (tag === "input") {
+      const type = (element.getAttribute("type") ?? "text").toLowerCase();
+      if (type === "text" && element.hasAttribute("list"))
+        return "combobox";
+      return INPUT_ROLES[type] ?? null;
+    }
+    if (tag === "a" || tag === "area") {
+      return element.hasAttribute("href") ? "link" : null;
+    }
+    if (tag === "select") {
+      const multiple = element.hasAttribute("multiple");
+      const size = Number.parseInt(element.getAttribute("size") ?? "1", 10);
+      return multiple || size > 1 ? "listbox" : "combobox";
+    }
+    if (tag === "td" || tag === "th") {
+      return tag === "th" ? "columnheader" : "cell";
+    }
+    if (tag === "header" || tag === "footer") {
+      return element.closest("article, aside, main, nav, section") === null ? tag === "header" ? "banner" : "contentinfo" : null;
+    }
+    if (tag === "section") {
+      return explicitName(element) === null ? null : "region";
+    }
+    if (tag === "img") {
+      return element.getAttribute("alt") === "" ? "presentation" : "img";
+    }
+    return IMPLICIT_ROLES[tag] ?? null;
+  }
+  function accessibleName(element) {
+    const explicit = explicitName(element);
+    if (explicit !== null)
+      return explicit;
+    const tag = element.tagName.toLowerCase();
+    if (tag === "input" || tag === "select" || tag === "textarea") {
+      const native = nativeLabelFor(element);
+      if (native)
+        return native;
+      const placeholder = element.getAttribute("placeholder");
+      if (placeholder && placeholder.trim().length > 0)
+        return normalize2(placeholder);
+      const type = (element.getAttribute("type") ?? "").toLowerCase();
+      if (type === "submit" || type === "button" || type === "reset") {
+        const value = element.getAttribute("value");
+        if (value)
+          return normalize2(value);
+      }
+      return null;
+    }
+    if (tag === "img" || tag === "area") {
+      const alt = element.getAttribute("alt");
+      return alt === null ? null : alt === "" ? null : normalize2(alt);
+    }
+    const role = roleOf(element);
+    if (role !== null && NAME_FROM_CONTENT.has(role)) {
+      const text = visibleText(element);
+      if (text.trim().length > 0)
+        return normalize2(text);
+    }
+    const title = element.getAttribute("title");
+    return title && title.trim().length > 0 ? normalize2(title) : null;
+  }
+  function explicitName(element) {
+    const labelledBy = element.getAttribute("aria-labelledby");
+    if (labelledBy) {
+      const parts = labelledBy.trim().split(/\s+/).map((id) => element.ownerDocument.getElementById(id)?.textContent?.trim() ?? "").filter((part) => part.length > 0);
+      if (parts.length > 0)
+        return normalize2(parts.join(" "));
+    }
+    const label = element.getAttribute("aria-label");
+    return label && label.trim().length > 0 ? normalize2(label) : null;
+  }
+  function visibleText(element) {
+    let text = "";
+    for (const child of element.childNodes) {
+      if (child.nodeType === 3) {
+        text += child.nodeValue ?? "";
+        continue;
+      }
+      if (child.nodeType !== 1)
+        continue;
+      const node = child;
+      if (node.getAttribute("aria-hidden") === "true" || node.hasAttribute("hidden"))
+        continue;
+      text += visibleText(node);
+    }
+    return text;
+  }
+  function accessibleDescription(element) {
+    const describedBy = element.getAttribute("aria-describedby");
+    if (describedBy) {
+      const parts = describedBy.trim().split(/\s+/).map((id) => element.ownerDocument.getElementById(id)?.textContent?.trim() ?? "").filter((part) => part.length > 0);
+      return parts.length > 0 ? normalize2(parts.join(" ")) : null;
+    }
+    const title = element.getAttribute("title");
+    if (!title || title.trim().length === 0)
+      return null;
+    return accessibleName(element) === normalize2(title) ? null : normalize2(title);
+  }
+  var NAME_FROM_CONTENT = /* @__PURE__ */ new Set([
+    "button",
+    "cell",
+    "checkbox",
+    "columnheader",
+    "gridcell",
+    "heading",
+    "link",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "row",
+    "rowheader",
+    "switch",
+    "tab",
+    "tooltip",
+    "treeitem",
+    "term",
+    "definition",
+    "caption",
+    "legend"
+  ]);
+  function nativeLabelFor(element) {
+    const id = element.getAttribute("id");
+    if (id) {
+      const escaped = cssEscape(id);
+      const label = element.ownerDocument.querySelector(`label[for="${escaped}"]`);
+      const text2 = label?.textContent?.trim();
+      if (text2)
+        return normalize2(text2);
+    }
+    const wrapping = element.closest("label");
+    const text = wrapping?.textContent?.trim();
+    return text ? normalize2(text) : null;
+  }
+  function stateOf(element) {
+    const state = {};
+    const ariaStates = [
+      "checked",
+      "disabled",
+      "expanded",
+      "selected",
+      "pressed",
+      "current",
+      "invalid",
+      "required",
+      "readonly",
+      "hidden",
+      "busy",
+      "live",
+      "modal",
+      "multiselectable",
+      "sort",
+      "level",
+      "valuenow",
+      "valuemin",
+      "valuemax",
+      "valuetext",
+      "haspopup",
+      "setsize",
+      "posinset",
+      "placeholder",
+      "orientation"
+    ];
+    for (const name of ariaStates) {
+      const value = element.getAttribute(`aria-${name}`);
+      if (value !== null)
+        state[name] = coerce(value);
+    }
+    const nativeBooleans = ["disabled", "checked", "readonly", "required", "hidden", "open"];
+    for (const name of nativeBooleans) {
+      if (element.hasAttribute(name))
+        state[name] = true;
+    }
+    if (element instanceof element.ownerDocument.defaultView.HTMLInputElement) {
+      const input = element;
+      if (input.type === "checkbox" || input.type === "radio")
+        state["checked"] = input.checked;
+    }
+    const tag = element.tagName.toLowerCase();
+    if (/^h[1-6]$/.test(tag) && state["level"] === void 0) {
+      state["level"] = Number.parseInt(tag.slice(1), 10);
+    }
+    return state;
+  }
+  function coerce(value) {
+    if (value === "true")
+      return true;
+    if (value === "false")
+      return false;
+    if (value !== "" && !Number.isNaN(Number(value)))
+      return Number(value);
+    return value;
+  }
+  function normalize2(text) {
+    return text.replace(/\s+/g, " ").trim();
+  }
+  function cssEscape(value) {
+    return value.replace(/["\\]/g, "\\$&");
+  }
+
+  // packages/dom/dist/ignore.js
+  var IGNORE_ATTRIBUTE = "data-variance-ignore";
+  var MARKED_RULE = "marked";
+  function resolveIgnores(root, options = {}) {
+    const marks = /* @__PURE__ */ new Map();
+    const unmatched = [];
+    const mark = (element, rule) => {
+      const existing = marks.get(element);
+      if (existing === void 0) {
+        marks.set(element, [rule]);
+        return;
+      }
+      if (!existing.includes(rule))
+        existing.push(rule);
+    };
+    for (const selector of options.selectors ?? []) {
+      let found = 0;
+      try {
+        if (root.matches(selector.select)) {
+          mark(root, selector.id);
+          found += 1;
+        }
+        for (const element of root.querySelectorAll(selector.select)) {
+          mark(element, selector.id);
+          found += 1;
+        }
+      } catch {
+      }
+      if (found === 0)
+        unmatched.push(selector);
+    }
+    if (options.markers !== false) {
+      const marked = [
+        ...root.hasAttribute(IGNORE_ATTRIBUTE) ? [root] : [],
+        ...root.querySelectorAll(`[${IGNORE_ATTRIBUTE}]`)
+      ];
+      for (const element of marked) {
+        const value = element.getAttribute(IGNORE_ATTRIBUTE)?.trim();
+        mark(element, value === void 0 || value === "" ? MARKED_RULE : value);
+      }
+    }
+    return { marks, unmatched };
+  }
+
+  // packages/dom/dist/media.js
+  var CERTAIN_MATCH = { matches: true, uncertain: false };
+  function evaluateMedia(query, environment) {
+    const normalized = query.trim().toLowerCase();
+    if (normalized.length === 0 || normalized === "all")
+      return CERTAIN_MATCH;
+    let uncertain = false;
+    for (const branch of splitTopLevel(normalized, ",")) {
+      const result = evaluateBranch(branch, environment);
+      if (result.matches)
+        return { matches: true, uncertain: result.uncertain };
+      uncertain = uncertain || result.uncertain;
+    }
+    return { matches: false, uncertain };
+  }
+  function evaluateSupports(condition, environment) {
+    const probe = environment?.supports;
+    if (!probe)
+      return { matches: true, uncertain: true };
+    const answer = probe(condition);
+    return answer === null ? { matches: true, uncertain: true } : { matches: answer, uncertain: false };
+  }
+  function evaluateBranch(branch, environment) {
+    let uncertain = false;
+    let negated = false;
+    let rest = branch.trim();
+    if (rest.startsWith("not ")) {
+      negated = true;
+      rest = rest.slice(4).trim();
+    } else if (rest.startsWith("only ")) {
+      rest = rest.slice(5).trim();
+    }
+    let matches = true;
+    for (const term of splitTopLevel(rest, " and ")) {
+      const trimmed = term.trim();
+      if (trimmed.length === 0)
+        continue;
+      if (!trimmed.startsWith("(")) {
+        if (trimmed === "screen" || trimmed === "all")
+          continue;
+        if (trimmed === "print" || trimmed === "speech") {
+          matches = false;
+          continue;
+        }
+        uncertain = true;
+        continue;
+      }
+      const feature = evaluateFeature(trimmed.replace(/^\(|\)$/g, ""), environment);
+      if (feature.uncertain)
+        uncertain = true;
+      if (!feature.matches)
+        matches = false;
+    }
+    return { matches: negated ? !matches : matches, uncertain };
+  }
+  function evaluateFeature(feature, environment) {
+    const colon = feature.indexOf(":");
+    if (colon < 0) {
+      return { matches: true, uncertain: true };
+    }
+    const name = feature.slice(0, colon).trim();
+    const value = feature.slice(colon + 1).trim();
+    switch (name) {
+      case "width":
+        return exact(environment.width, value);
+      case "min-width":
+        return atLeast(environment.width, value);
+      case "max-width":
+        return atMost(environment.width, value);
+      case "height":
+        return exact(environment.height, value);
+      case "min-height":
+        return atLeast(environment.height, value);
+      case "max-height":
+        return atMost(environment.height, value);
+      case "min-resolution":
+        return atLeast(environment.deviceScaleFactor * 96, value);
+      case "max-resolution":
+        return atMost(environment.deviceScaleFactor * 96, value);
+      case "prefers-color-scheme":
+        return { matches: value === environment.colorScheme, uncertain: false };
+      case "orientation":
+        return {
+          matches: value === (environment.width >= environment.height ? "landscape" : "portrait"),
+          uncertain: false
+        };
+      default: {
+        const declared = environment.features?.[name];
+        if (declared !== void 0)
+          return { matches: declared === value, uncertain: false };
+        return { matches: true, uncertain: true };
+      }
+    }
+  }
+  function toPixels(value) {
+    const match = /^([+-]?(?:\d+\.?\d*|\.\d+))(px|em|rem|dppx|dpi|x)?$/.exec(value);
+    if (!match)
+      return null;
+    const magnitude = Number.parseFloat(match[1]);
+    switch (match[2]) {
+      case void 0:
+      case "px":
+        return magnitude;
+      // Media-query `em`/`rem` are relative to the *initial* font size, which is
+      // 16px and not affected by page styles — so this conversion is exact.
+      case "em":
+      case "rem":
+        return magnitude * 16;
+      case "dpi":
+        return magnitude;
+      case "dppx":
+      case "x":
+        return magnitude * 96;
+      default:
+        return null;
+    }
+  }
+  function exact(actual, value) {
+    const target = toPixels(value);
+    return target === null ? { matches: true, uncertain: true } : { matches: actual === target, uncertain: false };
+  }
+  function atLeast(actual, value) {
+    const target = toPixels(value);
+    return target === null ? { matches: true, uncertain: true } : { matches: actual >= target, uncertain: false };
+  }
+  function atMost(actual, value) {
+    const target = toPixels(value);
+    return target === null ? { matches: true, uncertain: true } : { matches: actual <= target, uncertain: false };
+  }
+  function splitTopLevel(input, separator) {
+    const parts = [];
+    let depth = 0;
+    let current = "";
+    let index = 0;
+    while (index < input.length) {
+      const char = input[index];
+      if (char === "(")
+        depth += 1;
+      else if (char === ")")
+        depth -= 1;
+      if (depth === 0 && input.startsWith(separator, index)) {
+        parts.push(current);
+        current = "";
+        index += separator.length;
+        continue;
+      }
+      current += char;
+      index += 1;
+    }
+    parts.push(current);
+    return parts;
+  }
+
+  // packages/dom/dist/specificity.js
+  var ARGUMENT_SPECIFICITY = /* @__PURE__ */ new Set(["is", "not", "has", "matches", "-webkit-any", "-moz-any"]);
+  function specificityOf(selector) {
+    let ids = 0;
+    let classes = 0;
+    let types = 0;
+    let index = 0;
+    const input = selector.trim();
+    while (index < input.length) {
+      const char = input[index];
+      if (char === "#") {
+        ids += 1;
+        index += 1 + consumeIdentifier(input, index + 1);
+        continue;
+      }
+      if (char === ".") {
+        classes += 1;
+        index += 1 + consumeIdentifier(input, index + 1);
+        continue;
+      }
+      if (char === "[") {
+        classes += 1;
+        index = skipTo(input, index, "]") + 1;
+        continue;
+      }
+      if (char === ":") {
+        const doubled = input[index + 1] === ":";
+        const nameStart = index + (doubled ? 2 : 1);
+        const nameLength = consumeIdentifier(input, nameStart);
+        const name = input.slice(nameStart, nameStart + nameLength).toLowerCase();
+        let cursor = nameStart + nameLength;
+        if (input[cursor] === "(") {
+          const close = matchingParen3(input, cursor);
+          const argument = input.slice(cursor + 1, close);
+          cursor = close + 1;
+          if (ARGUMENT_SPECIFICITY.has(name)) {
+            const [argIds, argClasses, argTypes] = mostSpecific(argument);
+            ids += argIds;
+            classes += argClasses;
+            types += argTypes;
+          } else if (name !== "where") {
+            classes += 1;
+          }
+        } else if (doubled || PSEUDO_ELEMENTS.has(name)) {
+          types += 1;
+        } else {
+          classes += 1;
+        }
+        index = cursor;
+        continue;
+      }
+      if (/[a-z*|_-]/i.test(char)) {
+        const length = consumeIdentifier(input, index) || 1;
+        if (char !== "*")
+          types += 1;
+        index += length;
+        continue;
+      }
+      index += 1;
+    }
+    return [ids, classes, types];
+  }
+  function mostSpecific(selectorList) {
+    let best = [0, 0, 0];
+    for (const branch of splitSelectorList(selectorList)) {
+      const candidate = specificityOf(branch);
+      if (compareSpecificity(candidate, best) > 0)
+        best = candidate;
+    }
+    return best;
+  }
+  function compareSpecificity(a, b) {
+    return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+  }
+  function splitSelectorList(selectorList) {
+    const branches = [];
+    let depth = 0;
+    let quote = null;
+    let current = "";
+    for (let i = 0; i < selectorList.length; i += 1) {
+      const char = selectorList[i];
+      if (quote !== null) {
+        current += char;
+        if (char === quote && selectorList[i - 1] !== "\\")
+          quote = null;
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        quote = char;
+        current += char;
+        continue;
+      }
+      if (char === "(" || char === "[")
+        depth += 1;
+      else if (char === ")" || char === "]")
+        depth -= 1;
+      if (char === "," && depth === 0) {
+        if (current.trim().length > 0)
+          branches.push(current.trim());
+        current = "";
+        continue;
+      }
+      current += char;
+    }
+    if (current.trim().length > 0)
+      branches.push(current.trim());
+    return branches;
+  }
+  var PSEUDO_ELEMENTS = /* @__PURE__ */ new Set([
+    "before",
+    "after",
+    "first-line",
+    "first-letter",
+    "selection",
+    "backdrop",
+    "placeholder",
+    "marker",
+    "file-selector-button"
+  ]);
+  function consumeIdentifier(input, start) {
+    let length = 0;
+    while (start + length < input.length) {
+      const char = input[start + length];
+      if (char === "\\") {
+        length += 2;
+        continue;
+      }
+      if (/[A-Za-z0-9_-]/.test(char) || char.charCodeAt(0) > 127) {
+        length += 1;
+        continue;
+      }
+      break;
+    }
+    return length;
+  }
+  function skipTo(input, start, terminator) {
+    for (let i = start + 1; i < input.length; i += 1) {
+      if (input[i] === terminator)
+        return i;
+    }
+    return input.length - 1;
+  }
+  function matchingParen3(input, openIndex) {
+    let depth = 0;
+    for (let i = openIndex; i < input.length; i += 1) {
+      if (input[i] === "(")
+        depth += 1;
+      else if (input[i] === ")") {
+        depth -= 1;
+        if (depth === 0)
+          return i;
+      }
+    }
+    return input.length - 1;
+  }
+
+  // packages/dom/dist/dom-list.js
+  function items(collection) {
+    if (!collection)
+      return [];
+    const result = [];
+    for (let index = 0; index < collection.length; index += 1) {
+      const value = typeof collection.item === "function" ? collection.item(index) : collection[index];
+      if (value !== null && value !== void 0)
+        result.push(value);
+    }
+    return result;
+  }
+  function propertyNames(style) {
+    if (!style)
+      return [];
+    const names = [];
+    for (let index = 0; index < style.length; index += 1) {
+      const name = typeof style.item === "function" ? style.item(index) : style[index];
+      if (name)
+        names.push(name);
+    }
+    return names;
+  }
+  function elements(collection) {
+    if (!collection)
+      return [];
+    const result = [];
+    for (let index = 0; index < collection.length; index += 1) {
+      const element = typeof collection.item === "function" ? collection.item(index) : collection[index];
+      if (element)
+        result.push(element);
+    }
+    return result;
+  }
+  function attributesOf(element) {
+    const attributes = {};
+    const map = element.attributes;
+    for (let index = 0; index < map.length; index += 1) {
+      const attribute2 = typeof map.item === "function" ? map.item(index) : map[index];
+      if (attribute2)
+        attributes[attribute2.name] = attribute2.value;
+    }
+    return attributes;
+  }
+  function childNodesOf(node) {
+    const children = [];
+    const list = node.childNodes;
+    for (let index = 0; index < list.length; index += 1) {
+      const child = typeof list.item === "function" ? list.item(index) : list[index];
+      if (child)
+        children.push(child);
+    }
+    return children;
+  }
+  function classNamesOf(element) {
+    const value = element.getAttribute("class");
+    if (!value)
+      return [];
+    return value.trim().split(/\s+/).filter((name) => name.length > 0);
+  }
+
+  // packages/dom/dist/selector-parts.js
+  function ancestorPortion(selector) {
+    let depth = 0;
+    let lastBreak = -1;
+    for (let index = 0; index < selector.length; index += 1) {
+      const char = selector[index];
+      if (char === "(" || char === "[")
+        depth += 1;
+      else if (char === ")" || char === "]")
+        depth -= 1;
+      else if (depth === 0 && (char === " " || char === ">" || char === "+" || char === "~")) {
+        lastBreak = index;
+      }
+    }
+    return lastBreak < 0 ? null : selector.slice(0, lastBreak);
+  }
+  function lastCompound(selector) {
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < selector.length; i += 1) {
+      const char = selector[i];
+      if (char === "(" || char === "[")
+        depth += 1;
+      else if (char === ")" || char === "]")
+        depth -= 1;
+      else if (depth === 0 && (char === " " || char === ">" || char === "+" || char === "~")) {
+        start = i + 1;
+      }
+    }
+    return selector.slice(start).trim();
+  }
+
+  // packages/dom/dist/profile.js
+  function detectProfile(view) {
+    if (!view)
+      return JSDOM_PROFILE;
+    const probe = view.document.createElement("div");
+    probe.style.cssText = "position:absolute;width:100px;height:100px;";
+    view.document.body?.appendChild(probe);
+    const measured = probe.getBoundingClientRect().width;
+    probe.remove();
+    return measured > 0 ? CHROMIUM_PROFILE : JSDOM_PROFILE;
+  }
+
+  // packages/dom/dist/stabilize.js
+  var STABILIZE_ATTRIBUTE = "data-va-stabilize";
+  async function stabilizeForObservation(document2, options = {}) {
+    const view = document2.defaultView;
+    const profile = options.profile ?? detectProfile(view);
+    const recipe = forTier(options.recipe ?? COLLECT_RECIPE, tierOfProfile(profile));
+    if (recipe.length === 0) {
+      return { ids: [], digest: void 0, release: () => void 0 };
+    }
+    const css = recipeCss(recipe);
+    const style = existingSheet(document2) ?? insertSheet(document2);
+    const already = style.textContent === css;
+    if (!already)
+      style.textContent = css;
+    await settleRecipe(recipe, localTarget());
+    if (!already)
+      await settleFrames(view);
+    return {
+      ids: recipe.map((intervention) => intervention.id),
+      digest: recipeDigest(recipe),
+      release: () => style.remove()
+    };
+    function localTarget() {
+      return { evaluate: async (fn) => await fn() };
+    }
+  }
+  function existingSheet(document2) {
+    return document2.querySelector(`style[${STABILIZE_ATTRIBUTE}]`);
+  }
+  function insertSheet(document2) {
+    const style = document2.createElement("style");
+    style.setAttribute(STABILIZE_ATTRIBUTE, "");
+    (document2.head ?? document2.documentElement).append(style);
+    return style;
+  }
+  async function settleFrames(view) {
+    if (view === null || typeof view.requestAnimationFrame !== "function")
+      return;
+    await new Promise((resolve) => {
+      view.requestAnimationFrame(() => {
+        view.requestAnimationFrame(() => resolve());
+      });
+    });
+  }
+
+  // packages/dom/dist/css-index.js
+  function conditionKey(environment) {
+    const features = Object.entries(environment.features ?? {}).map(([name, value]) => `${name}=${value}`).sort();
+    return [
+      `width=${environment.width}`,
+      `height=${environment.height}`,
+      `scale=${environment.deviceScaleFactor}`,
+      `scheme=${environment.colorScheme}`,
+      `features=${features.join(",")}`,
+      `supports=${environment.supports ? "probed" : "assumed"}`
+    ].join(" ");
+  }
+  function isStabilizationSheet(sheet) {
+    const owner = sheet.ownerNode;
+    return owner?.hasAttribute?.(STABILIZE_ATTRIBUTE) === true;
+  }
+  function indexStyleSheets(document2, environment) {
+    const byKey = /* @__PURE__ */ new Map();
+    const universal = [];
+    const diagnostics = [];
+    const evaluatedConditions = {};
+    let order = 0;
+    let totalRules = 0;
+    const sheets = items(document2.styleSheets).filter(isStyleSheet).filter((sheet) => !isStabilizationSheet(sheet));
+    for (const adopted of adoptedSheets(document2))
+      sheets.push(adopted);
+    for (const [index, sheet] of sheets.entries()) {
+      const name = sheetName(sheet, index);
+      let rules;
+      try {
+        rules = sheet.cssRules;
+      } catch {
+        diagnostics.push({
+          severity: "warn",
+          code: "unreadable-stylesheet",
+          message: `stylesheet "${name}" is cross-origin; its rules were not collected`
+        });
+        continue;
+      }
+      walk(rules, name, false);
+    }
+    return {
+      byKey,
+      universal,
+      diagnostics,
+      totalRules,
+      evaluatedConditions,
+      conditions: conditionKey(environment)
+    };
+    function walk(rules, sheet, uncertain) {
+      for (const rule of items(rules)) {
+        if (isGroupingRule(rule)) {
+          const condition = conditionOf(rule, environment);
+          const prelude = preludeOf(rule);
+          if (prelude !== null && dependsOnOmittedInput(prelude)) {
+            evaluatedConditions[prelude] = condition.matches;
+          }
+          if (!condition.matches)
+            continue;
+          walk(rule.cssRules, sheet, uncertain || condition.uncertain);
+          continue;
+        }
+        if (!isStyleRule(rule))
+          continue;
+        totalRules += 1;
+        const declarations = declarationsOf(rule.style);
+        if (declarations.length === 0)
+          continue;
+        for (const branch of splitSelectorList(rule.selectorText)) {
+          const indexed = {
+            sheet,
+            selector: rule.selectorText,
+            branch,
+            specificity: specificityOf(branch),
+            order: order += 1,
+            declarations,
+            key: rightmostKey(branch),
+            uncertain
+          };
+          if (indexed.key === "*")
+            universal.push(indexed);
+          else {
+            const bucket = byKey.get(indexed.key);
+            if (bucket)
+              bucket.push(indexed);
+            else
+              byKey.set(indexed.key, [indexed]);
+          }
+        }
+      }
+    }
+  }
+  function rightmostKey(selector) {
+    const compound = lastCompound(selector);
+    const id = /#([\w-]+)/.exec(compound);
+    if (id)
+      return `#${id[1]}`;
+    const className = /\.((?:\\.|[\w-])+)/.exec(compound);
+    if (className)
+      return `.${className[1].replace(/\\/g, "")}`;
+    const tag = /^([a-z][\w-]*)/i.exec(compound);
+    if (tag && !compound.startsWith(":"))
+      return tag[1].toLowerCase();
+    if (compound.startsWith("["))
+      return "[attr]";
+    return "*";
+  }
+  function declarationsOf(style) {
+    const declarations = [];
+    let pending = false;
+    for (const property of propertyNames(style)) {
+      const value = style.getPropertyValue(property);
+      if (value === "") {
+        pending = true;
+        continue;
+      }
+      declarations.push(declaration(property, value, style));
+    }
+    if (!pending)
+      return declarations;
+    for (const shorthand of SHORTHAND_PROPERTIES) {
+      const value = style.getPropertyValue(shorthand);
+      if (value === "" || !value.includes("var("))
+        continue;
+      declarations.push(declaration(shorthand, value, style));
+    }
+    return declarations;
+  }
+  function declaration(property, value, style) {
+    const references = [...value.matchAll(/var\(\s*(--[\w-]+)/g)].map((match) => match[1]);
+    return {
+      property,
+      value,
+      important: style.getPropertyPriority(property) === "important",
+      ...references.length > 0 ? { references } : {}
+    };
+  }
+  function conditionOf(rule, environment) {
+    const type = rule.constructor.name;
+    if (type === "CSSMediaRule" || "media" in rule) {
+      const media = rule.media;
+      return evaluateMedia(media?.mediaText ?? "", environment);
+    }
+    if (type === "CSSSupportsRule" || "conditionText" in rule) {
+      return evaluateSupports(rule.conditionText ?? "", environment);
+    }
+    return { matches: true, uncertain: true };
+  }
+  function dependsOnOmittedInput(prelude) {
+    return /\b(min-|max-)?resolution\b|-webkit-device-pixel-ratio/i.test(prelude);
+  }
+  function preludeOf(rule) {
+    const media = rule.media?.mediaText;
+    if (media)
+      return `@media ${media}`;
+    const supports = rule.conditionText;
+    if (supports)
+      return `@supports ${supports}`;
+    return null;
+  }
+  function isStyleSheet(sheet) {
+    return "cssRules" in sheet;
+  }
+  function isStyleRule(rule) {
+    return "selectorText" in rule && "style" in rule;
+  }
+  function isGroupingRule(rule) {
+    return "cssRules" in rule && !("selectorText" in rule);
+  }
+  function adoptedSheets(document2) {
+    const adopted = document2.adoptedStyleSheets;
+    return adopted ? [...adopted] : [];
+  }
+  function sheetName(sheet, index) {
+    if (sheet.href)
+      return sheet.href;
+    const owner = sheet.ownerNode;
+    const id = owner?.getAttribute?.("id");
+    if (id)
+      return `<style#${id}>`;
+    return `<style:${index}>`;
+  }
+
+  // packages/dom/dist/css-match.js
+  function matchRulesFor(element, index) {
+    const candidates = [...index.universal];
+    const id = element.getAttribute("id");
+    if (id)
+      candidates.push(...index.byKey.get(`#${id}`) ?? []);
+    for (const className of classNamesOf(element)) {
+      candidates.push(...index.byKey.get(`.${className}`) ?? []);
+    }
+    candidates.push(...index.byKey.get(element.tagName.toLowerCase()) ?? []);
+    candidates.push(...index.byKey.get("[attr]") ?? []);
+    const matched = [];
+    const couplings = /* @__PURE__ */ new Set();
+    for (const candidate of candidates) {
+      if (safeMatches(element, candidate.branch)) {
+        matched.push({
+          sheet: candidate.sheet,
+          selector: candidate.branch,
+          specificity: candidate.specificity,
+          order: candidate.order,
+          declarations: candidate.declarations
+        });
+        continue;
+      }
+      for (const key of latentCouplings(element, candidate.branch))
+        couplings.add(key);
+    }
+    return { matched: matched.sort((a, b) => a.order - b.order), couplings: [...couplings] };
+  }
+  function latentCouplings(element, selector) {
+    const ancestor = ancestorPortion(selector);
+    if (ancestor === null)
+      return [];
+    const own = lastCompound(selector);
+    if (own.length === 0 || !safeMatches(element, own))
+      return [];
+    const keys = [];
+    const lower = ancestor.toLowerCase();
+    if (/(^|[\s>+~])(html|:root)\b/.test(lower) && /[.[]/.test(lower)) {
+      keys.push("root-attr:class");
+      for (const match of ancestor.matchAll(/\[([\w-]+)/g))
+        keys.push(`root-attr:${match[1]}`);
+    }
+    if (/(^|[\s>+~])body\b/.test(lower) && /[.[]/.test(lower)) {
+      keys.push("body-attr:class");
+      for (const match of ancestor.matchAll(/\[([\w-]+)/g))
+        keys.push(`body-attr:${match[1]}`);
+    }
+    return keys;
+  }
+  function safeMatches(element, selector) {
+    try {
+      return element.matches(selector);
+    } catch {
+      return true;
+    }
+  }
+
+  // packages/dom/dist/inherit.js
+  function inheritedSeed(root, profile, view, index) {
+    if (!root.parentElement)
+      return {};
+    if (profile.computedStyle && view) {
+      const parent = view.getComputedStyle(root.parentElement);
+      const seed = {};
+      for (const property of INHERITABLE) {
+        const value = parent.getPropertyValue(property);
+        if (value)
+          seed[property] = value;
+      }
+      for (const property of propertyNames(parent)) {
+        if (property.startsWith("--"))
+          seed[property] = parent.getPropertyValue(property);
+      }
+      return seed;
+    }
+    return declaredAncestorSeed(root, index);
+  }
+  function declaredAncestorSeed(root, index) {
+    const chain = [];
+    for (let node = root.parentElement; node; node = node.parentElement)
+      chain.unshift(node);
+    let context = EMPTY_CONTEXT;
+    for (const ancestor of chain) {
+      const inline = ancestor.style;
+      const inlineStyle = {};
+      for (const property of propertyNames(inline)) {
+        inlineStyle[property] = inline.getPropertyValue(property);
+      }
+      context = resolveStyle({
+        matchedRules: matchRulesFor(ancestor, index).matched,
+        ...Object.keys(inlineStyle).length > 0 ? { inlineStyle } : {},
+        context
+      }).childContext;
+    }
+    return { ...context.inherited, ...context.customProperties };
+  }
+  var INHERITABLE = [
+    "color",
+    "font-family",
+    "font-size",
+    "font-weight",
+    "font-style",
+    "font-variant",
+    "font-stretch",
+    "line-height",
+    "letter-spacing",
+    "word-spacing",
+    "text-align",
+    "text-indent",
+    "text-transform",
+    "white-space",
+    "word-break",
+    "overflow-wrap",
+    "visibility",
+    "direction",
+    "writing-mode",
+    "caption-side",
+    "border-collapse",
+    "border-spacing"
+  ];
+
+  // packages/dom/dist/collect.js
+  function conditionsFor(document2, viewport, features) {
+    const supports = supportsProbe(document2.defaultView);
+    return {
+      width: viewport.width,
+      height: viewport.height,
+      deviceScaleFactor: viewport.deviceScaleFactor,
+      colorScheme: viewport.colorScheme,
+      ...features ? { features } : {},
+      ...supports ? { supports } : {}
+    };
+  }
+  function collect(root, options) {
+    const document2 = root.ownerDocument;
+    const view = document2.defaultView;
+    const profile = options.profile ?? detectProfile(view);
+    const conditions = conditionsFor(document2, options.viewport, options.features);
+    const index = options.index ? sameEnvironment(options.index, conditions) : indexStyleSheets(document2, conditions);
+    const diagnostics = [...index.diagnostics];
+    if (options.fonts === void 0) {
+      diagnostics.push({
+        severity: "warn",
+        code: "unverified-fonts",
+        message: "no font content hashes supplied; the environment key cannot detect a font substitution, which changes metrics and therefore geometry without changing code"
+      });
+    }
+    const ignores = resolveIgnores(root, options.ignore ? { selectors: options.ignore } : {});
+    for (const selector of ignores.unmatched) {
+      diagnostics.push({
+        severity: "warn",
+        code: "ignore-unmatched",
+        message: `ignore rule "${selector.id}" selector \`${selector.select}\` matched nothing in this subject; if it matches nothing anywhere, it is a hole in the suite that absorbs nothing`
+      });
+    }
+    const portalRoots = options.portalsOf?.(root) ?? [];
+    const couplings = /* @__PURE__ */ new Set();
+    if (options.portalsOf === void 0) {
+      diagnostics.push({
+        severity: "warn",
+        code: "portals-not-resolved",
+        message: "no portal provider supplied; content rendered through createPortal is outside this capture, and a subject that portals will report unchanged when that content changes"
+      });
+    }
+    const capture = {
+      captureVersion: 1,
+      subject: options.subject,
+      profile,
+      environment: {
+        profile: profile.id,
+        engine: options.engine,
+        viewport: options.viewport,
+        fonts: options.fonts ?? [],
+        // Caller-declared features *and* the conditions actually resolved while
+        // flattening. The second half is what lets the semantic key drop
+        // `deviceScaleFactor` safely: a resolution-gated rule that resolves
+        // differently on two machines splits the key through its outcome.
+        conditions: { ...options.features, ...index.evaluatedConditions },
+        assets: options.assets ?? {},
+        ...options.stabilization !== void 0 ? { stabilization: options.stabilization } : {}
+      },
+      root: captureNode(root, profile, index, view, options, couplings, ignores.marks),
+      inheritedSeed: inheritedSeed(root, profile, view, index),
+      ...couplings.size > 0 ? { couplings: [...couplings].sort() } : {},
+      ...portalRoots.length > 0 ? {
+        portals: portalRoots.map((host) => captureNode(host, profile, index, view, options, couplings, ignores.marks))
+      } : {},
+      diagnostics
+    };
+    return capture;
+  }
+  function sameEnvironment(index, conditions) {
+    const wanted = conditionKey(conditions);
+    if (index.conditions === wanted)
+      return index;
+    throw new Error(`the supplied style index was built for a different condition environment (index: ${index.conditions}; capture: ${wanted}). Conditional groups are erased during indexing, so reusing it would flatten @media and @supports against one environment while keying the capture to another \u2014 two different rule sets sharing one baseline. Build an index per environment with indexStyleSheets(document, conditionsFor(document, viewport)).`);
+  }
+  function captureNode(element, profile, index, view, options, couplingSink, marks) {
+    const attributes = attributesOf(element);
+    const inline = element.style;
+    const inlineStyle = {};
+    for (const property of propertyNames(inline)) {
+      inlineStyle[property] = inline.getPropertyValue(property);
+    }
+    const provenance = options.provenanceOf?.(element);
+    const wiring = options.wiringOf?.(element);
+    const holding = options.holdingOf?.(element);
+    const ignoredBy = marks.get(element);
+    const { matched, couplings } = matchRulesFor(element, index);
+    for (const coupling of couplings)
+      couplingSink.add(coupling);
+    const children = [];
+    for (const child of childNodesOf(element)) {
+      if (child.nodeType === 1) {
+        children.push(captureNode(child, profile, index, view, options, couplingSink, marks));
+        continue;
+      }
+      if (child.nodeType === 3) {
+        children.push(textNode(child.nodeValue ?? "", provenance));
+      }
+    }
+    const shadow = element.shadowRoot;
+    const shadowChildren = [];
+    if (shadow) {
+      for (const child of elements(shadow.children)) {
+        shadowChildren.push(captureNode(child, profile, index, view, options, couplingSink, marks));
+      }
+    }
+    return {
+      tag: element.tagName.toLowerCase(),
+      attributes,
+      aria: ariaOf(element),
+      matchedRules: matched,
+      ...Object.keys(inlineStyle).length > 0 ? { inlineStyle } : {},
+      ...profile.computedStyle && view ? { computedStyle: computedStyleOf(element, view) } : {},
+      ...profile.layout ? { rect: rectOf(element) } : {},
+      ...provenance ? { provenance } : {},
+      ...wiring ? { wiring } : {},
+      ...holding ? { holding } : {},
+      children,
+      ...shadowChildren.length > 0 ? { shadowChildren } : {},
+      // Marked here and nowhere else. Only the element that matched carries the
+      // rule; containment is a question about paths, which `core` answers without
+      // a DOM — so a deep subtree costs one mark rather than one per node.
+      ...ignoredBy ? { ignoredBy } : {}
+    };
+  }
+  function textNode(text, provenance) {
+    return {
+      tag: "#text",
+      attributes: {},
+      matchedRules: [],
+      text,
+      ...provenance ? { provenance } : {},
+      children: []
+    };
+  }
+  function computedStyleOf(element, view) {
+    const computed = view.getComputedStyle(element);
+    const style = {};
+    for (const property of propertyNames(computed)) {
+      if (!admits(property))
+        continue;
+      style[property] = computed.getPropertyValue(property);
+    }
+    return style;
+  }
+  function rectOf(element) {
+    const rect = element.getBoundingClientRect();
+    const round2 = (value) => Math.round(value * 100) / 100;
+    return {
+      x: round2(rect.x),
+      y: round2(rect.y),
+      width: round2(rect.width),
+      height: round2(rect.height)
+    };
+  }
+  function supportsProbe(view) {
+    const css = view?.CSS;
+    if (!css || typeof css.supports !== "function")
+      return null;
+    return (condition) => {
+      try {
+        return css.supports(condition);
+      } catch {
+        return null;
+      }
+    };
+  }
+
+  // packages/react/dist/fiber.js
+  var FiberTag = {
+    FunctionComponent: 0,
+    ClassComponent: 1,
+    /**
+     * Removed in React 19; a hole in the numbering there rather than a reuse.
+     * In React ≤18 it is the mount-time tag of a component whose return value has
+     * not been observed yet, and it is rewritten to 0 or 1 before commit — so it
+     * should never be seen by a post-commit walk. Recognised anyway: costs
+     * nothing, and covers a concurrent read mid-render.
+     */
+    IndeterminateComponent: 2,
+    HostRoot: 3,
+    HostPortal: 4,
+    HostComponent: 5,
+    HostText: 6,
+    Fragment: 7,
+    Mode: 8,
+    ContextConsumer: 9,
+    ContextProvider: 10,
+    ForwardRef: 11,
+    Profiler: 12,
+    SuspenseComponent: 13,
+    /** `memo(X)` where X is *not* a plain function: an extra wrapper fiber. */
+    MemoComponent: 14,
+    /** `memo(fn)` where fn is a plain function: the component fiber itself. */
+    SimpleMemoComponent: 15,
+    LazyComponent: 16,
+    IncompleteClassComponent: 17,
+    DehydratedFragment: 18,
+    SuspenseListComponent: 19,
+    ScopeComponent: 21,
+    OffscreenComponent: 22,
+    LegacyHiddenComponent: 23,
+    CacheComponent: 24,
+    TracingMarkerComponent: 25,
+    HostHoistable: 26,
+    HostSingleton: 27,
+    IncompleteFunctionComponent: 28,
+    Throw: 29
+  };
+  var COMPOSITE_TAGS = /* @__PURE__ */ new Set([
+    FiberTag.FunctionComponent,
+    FiberTag.ClassComponent,
+    FiberTag.IndeterminateComponent,
+    FiberTag.ForwardRef,
+    FiberTag.SimpleMemoComponent,
+    FiberTag.IncompleteClassComponent,
+    FiberTag.IncompleteFunctionComponent
+  ]);
+  function isOwnerFrame(fiber) {
+    return COMPOSITE_TAGS.has(fiber.tag);
+  }
+  var MAX_FIBER_DEPTH = 1e4;
+  var FIBER_KEY_PREFIXES = ["__reactFiber$", "__reactInternalInstance$"];
+  var CONTAINER_KEY_PREFIX = "__reactContainer$";
+  var cachedFiberKey = null;
+  function scanForKey(node, prefixes) {
+    for (const key of Object.keys(node)) {
+      for (const prefix of prefixes) {
+        if (key.startsWith(prefix))
+          return key;
+      }
+    }
+    return null;
+  }
+  function rawFiber(node) {
+    if (cachedFiberKey !== null) {
+      const hit = node[cachedFiberKey];
+      if (hit)
+        return hit;
+    }
+    const key = scanForKey(node, FIBER_KEY_PREFIXES);
+    if (key === null)
+      return null;
+    cachedFiberKey = key;
+    return node[key] ?? null;
+  }
+  function currentFiber(fiber) {
+    const root = rootOf(fiber);
+    if (root === null)
+      return null;
+    const fiberRoot = root.stateNode;
+    if (!fiberRoot || !fiberRoot.current)
+      return fiber;
+    if (fiberRoot.current === root)
+      return fiber;
+    return fiber.alternate ?? fiber;
+  }
+  function rootOf(fiber) {
+    let node = fiber;
+    for (let depth = 0; depth < MAX_FIBER_DEPTH; depth += 1) {
+      if (node.return === null)
+        return node.tag === FiberTag.HostRoot ? node : null;
+      node = node.return;
+    }
+    return null;
+  }
+  function findFiber(node) {
+    const raw = rawFiber(node);
+    if (raw === null)
+      return null;
+    return currentFiber(raw);
+  }
+  function hasFiber(node) {
+    return rawFiber(node) !== null;
+  }
+  function findReactContainers(scope) {
+    const found = [];
+    const all = scope.querySelectorAll("*");
+    for (let index = 0; index < all.length; index += 1) {
+      const element = all[index];
+      if (element && scanForKey(element, [CONTAINER_KEY_PREFIX]) !== null) {
+        found.push(element);
+      }
+    }
+    return found;
+  }
+
+  // packages/react/dist/names.js
+  var ANONYMOUS = "Anonymous";
+  var MAX_UNWRAP_DEPTH = 10;
+  var MEMO = "react.memo";
+  var FORWARD_REF = "react.forward_ref";
+  var LAZY = "react.lazy";
+  function nameOf(type, depth) {
+    if (depth > MAX_UNWRAP_DEPTH)
+      return null;
+    if (type === null || type === void 0)
+      return null;
+    if (typeof type === "string")
+      return type;
+    if (typeof type === "function") {
+      const fn = type;
+      if (typeof fn.displayName === "string" && fn.displayName !== "")
+        return fn.displayName;
+      if (typeof fn.name === "string" && fn.name !== "")
+        return fn.name;
+      return null;
+    }
+    if (typeof type !== "object")
+      return null;
+    const wrapper = type;
+    if (typeof wrapper.displayName === "string" && wrapper.displayName !== "") {
+      return wrapper.displayName;
+    }
+    const brand = typeof wrapper.$$typeof === "symbol" ? wrapper.$$typeof.description ?? "" : "";
+    switch (brand) {
+      case MEMO:
+        return nameOf(wrapper.type, depth + 1);
+      case FORWARD_REF:
+        return nameOf(wrapper.render, depth + 1);
+      case LAZY:
+        return nameOf(wrapper._payload?._result, depth + 1);
+      default:
+        return null;
+    }
+  }
+  function fiberComponentName(fiber) {
+    return nameOf(fiber.elementType, 0) ?? nameOf(fiber.type, 0) ?? ANONYMOUS;
+  }
+  function debugOwnerName(owner) {
+    if (!owner)
+      return null;
+    if (typeof owner.tag === "number") {
+      const fiber = owner;
+      return nameOf(fiber.elementType, 0) ?? nameOf(fiber.type, 0);
+    }
+    const info = owner;
+    return typeof info.name === "string" && info.name !== "" ? info.name : null;
+  }
+
+  // packages/react/dist/resolve.js
+  var NO_FIBER = Object.freeze({
+    status: "no-fiber",
+    reason: "no-client-fiber"
+  });
+  var UNMOUNTED = Object.freeze({
+    status: "no-fiber",
+    reason: "unmounted"
+  });
+
+  // packages/react/dist/portal.js
+  var HOST_TAGS = /* @__PURE__ */ new Set([
+    FiberTag.HostComponent,
+    FiberTag.HostHoistable,
+    FiberTag.HostSingleton
+  ]);
+  function portalContentOf(root) {
+    const fiber = subtreeFiber(root);
+    if (!fiber)
+      return [];
+    const found = [];
+    collectPortals(fiber.child, found, /* @__PURE__ */ new Set());
+    return found;
+  }
+  function subtreeFiber(root) {
+    const own = findFiber(root);
+    if (own)
+      return own;
+    const descendants = root.querySelectorAll("*");
+    for (let index = 0; index < descendants.length; index += 1) {
+      const element = descendants[index];
+      if (!element)
+        continue;
+      const fiber = findFiber(element);
+      if (!fiber)
+        continue;
+      return currentFiber(topOf(fiber)) ?? topOf(fiber);
+    }
+    return null;
+  }
+  function topOf(fiber) {
+    let node = fiber;
+    for (let depth = 0; depth < 1e4 && node.return; depth += 1) {
+      node = node.return;
+    }
+    return node;
+  }
+  function collectPortals(start, found, seen) {
+    let fiber = start;
+    while (fiber) {
+      if (fiber.tag === FiberTag.HostPortal) {
+        collectPortalHosts(fiber.child, found, seen);
+        fiber = fiber.sibling;
+        continue;
+      }
+      if (fiber.child)
+        collectPortals(fiber.child, found, seen);
+      fiber = fiber.sibling;
+    }
+  }
+  function collectPortalHosts(start, found, seen) {
+    let fiber = start;
+    while (fiber) {
+      if (HOST_TAGS.has(fiber.tag)) {
+        const element = fiber.stateNode;
+        if (isElement(element) && !seen.has(element)) {
+          seen.add(element);
+          found.push(element);
+        }
+        if (fiber.child)
+          collectPortals(fiber.child, found, seen);
+        fiber = fiber.sibling;
+        continue;
+      }
+      if (fiber.tag === FiberTag.HostPortal) {
+        collectPortalHosts(fiber.child, found, seen);
+        fiber = fiber.sibling;
+        continue;
+      }
+      if (fiber.child)
+        collectPortalHosts(fiber.child, found, seen);
+      fiber = fiber.sibling;
+    }
+  }
+  function isElement(value) {
+    return typeof value === "object" && value !== null && value.nodeType === 1;
+  }
+
+  // packages/react/dist/suspense.js
+  var MAX_WALK_DEPTH = 1e4;
+  var MAX_FIBERS = 5e5;
+  var CONTAINER_KEY_PREFIX2 = "__reactContainer$";
+  function boundariesUnder(node) {
+    let own = null;
+    try {
+      if (hasFiber(node))
+        own = findFiber(node);
+    } catch {
+      return null;
+    }
+    if (own !== null) {
+      const found2 = [];
+      collectFrom(own, found2);
+      return found2;
+    }
+    const scope = node;
+    if (typeof scope.querySelectorAll !== "function")
+      return null;
+    const roots = [];
+    if (node.nodeType === 1) {
+      const here = containerFiber(node);
+      if (here !== null)
+        roots.push(here);
+    }
+    for (const container of findReactContainers(node)) {
+      const fiber = containerFiber(container);
+      if (fiber !== null)
+        roots.push(fiber);
+    }
+    if (roots.length === 0)
+      return null;
+    const found = [];
+    for (const root of roots)
+      collectFrom(root, found);
+    return found;
+  }
+  function containerFiber(element) {
+    const record2 = element;
+    for (const key of Object.keys(record2)) {
+      if (!key.startsWith(CONTAINER_KEY_PREFIX2))
+        continue;
+      const fiber = record2[key];
+      if (!fiber)
+        return null;
+      try {
+        return currentFiber(fiber);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  function collectFrom(root, into) {
+    const stack = [{ fiber: root, boundaries: 0 }];
+    let visited = 0;
+    while (stack.length > 0) {
+      const entry = stack.pop();
+      if (!entry)
+        break;
+      if ((visited += 1) > MAX_FIBERS)
+        return;
+      const { fiber } = entry;
+      let { boundaries: boundaries2 } = entry;
+      if (fiber.tag === FiberTag.SuspenseComponent) {
+        into.push(describe(fiber, boundaries2));
+        boundaries2 += 1;
+      }
+      if (fiber.sibling && fiber !== root) {
+        stack.push({ fiber: fiber.sibling, boundaries: entry.boundaries });
+      }
+      if (fiber.child)
+        stack.push({ fiber: fiber.child, boundaries: boundaries2 });
+    }
+  }
+  function describe(fiber, depth) {
+    const state = stateOf2(fiber);
+    const createdBy = debugOwnerName(fiber._debugOwner);
+    const boundary = { state, owners: ownersAbove(fiber), depth };
+    if (createdBy !== null)
+      boundary.createdBy = createdBy;
+    if (fiber.key !== null)
+      boundary.key = fiber.key;
+    return boundary;
+  }
+  function stateOf2(fiber) {
+    const state = fiber.memoizedState;
+    if (state === null || state === void 0)
+      return "resolved";
+    if (typeof state !== "object")
+      return "resolved";
+    return state.dehydrated != null ? "dehydrated" : "pending";
+  }
+  function ownersAbove(fiber) {
+    const names = [];
+    let node = fiber.return;
+    for (let depth = 0; node !== null && depth < MAX_WALK_DEPTH; depth += 1) {
+      if (node.tag === FiberTag.HostRoot)
+        break;
+      if (isOwnerFrame(node))
+        names.push(fiberComponentName(node));
+      node = node.return;
+    }
+    return names;
+  }
+
+  // packages/react/dist/arrival.js
+  var DEFAULT_SUSPENSE_TIMEOUT_MS = 5e3;
+  var DEFAULT_POLL_MS = 16;
+  var DEFAULT_CONFIRMATIONS = 2;
+  async function awaitSuspense(node, options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_SUSPENSE_TIMEOUT_MS;
+    const pollMs = Math.max(1, options.pollMs ?? DEFAULT_POLL_MS);
+    const confirmations = Math.max(1, options.confirmations ?? DEFAULT_CONFIRMATIONS);
+    const started = now();
+    let clean = 0;
+    for (; ; ) {
+      const boundaries2 = boundariesUnder(node);
+      if (boundaries2 === null) {
+        return { outcome: "unobserved", waitedMs: now() - started, boundaries: 0, pending: [] };
+      }
+      const waiting = boundaries2.filter((boundary) => boundary.state !== "resolved");
+      const waitedMs = now() - started;
+      if (waiting.length === 0) {
+        clean += 1;
+        if (boundaries2.length === 0 || clean >= confirmations) {
+          return { outcome: "settled", waitedMs, boundaries: boundaries2.length, pending: [] };
+        }
+      } else {
+        clean = 0;
+      }
+      if (waitedMs >= timeoutMs) {
+        return {
+          outcome: waiting.length === 0 ? "settled" : "pending",
+          waitedMs,
+          boundaries: boundaries2.length,
+          pending: waiting
+        };
+      }
+      await sleep(pollMs);
+    }
+  }
+  function now() {
+    const clock = globalThis.performance;
+    return clock && typeof clock.now === "function" ? clock.now() : Date.now();
+  }
+  function sleep(ms) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+  }
+
+  // packages/react/dist/wiring.js
+  var HOST_TAGS2 = /* @__PURE__ */ new Set([
+    FiberTag.HostRoot,
+    FiberTag.HostComponent,
+    FiberTag.HostText,
+    FiberTag.HostPortal,
+    FiberTag.HostHoistable,
+    FiberTag.HostSingleton
+  ]);
+
+  // packages/react/dist/holding.js
+  var ABSENT = Symbol("absent");
+
+  // packages/react/dist/identity.js
+  var HOST_TAGS3 = /* @__PURE__ */ new Set([
+    FiberTag.HostRoot,
+    FiberTag.HostComponent,
+    FiberTag.HostText,
+    FiberTag.HostPortal,
+    FiberTag.HostHoistable,
+    FiberTag.HostSingleton
+  ]);
+
+  // packages/presentation/dist/browser-agent.js
+  var PRESENTATION_AGENT = "__variance_authority_presentation__";
+  var PRESENTATION_AGENT_VERSION = "presentation@0";
+  var PRESENTATION_ROOT_ATTRIBUTE = "data-variance-authority-presentation-root";
+  var PRESENTATION_OVERLAY_ATTRIBUTE = "data-variance-authority-presentation-overlay";
+  var sequence = 0;
+  async function acquirePresentation(root, request) {
+    clearPresentationPaint();
+    await awaitSuspense(root, request.suspense ?? {});
+    const portalRoots = portalContentOf(root);
+    const held = await stabilizeForObservation(root.ownerDocument, {
+      recipe: request.stabilize === void 0 ? presentationRecipe([root, ...portalRoots]) : recipeOf(request.stabilize)
+    });
+    const capture = collect(root, {
+      subject: request.subject,
+      viewport: request.viewport,
+      engine: request.engine,
+      portalsOf: () => portalRoots,
+      ...request.fonts === void 0 ? {} : { fonts: request.fonts },
+      ...held.digest === void 0 ? {} : { stabilization: held.digest }
+    });
+    const current = ++sequence;
+    const portals = portalRoots.map((portal, index) => {
+      const previous = portal.getAttribute(PRESENTATION_ROOT_ATTRIBUTE);
+      const marker = `${current}-${index}`;
+      portal.setAttribute(PRESENTATION_ROOT_ATTRIBUTE, marker);
+      return { marker, ...previous === null ? {} : { previous } };
+    });
+    return JSON.stringify({
+      capture,
+      stabilization: {
+        ids: held.ids,
+        ...held.digest === void 0 ? {} : { digest: held.digest }
+      },
+      portals
+    });
+  }
+  function presentationRecipe(roots) {
+    const waitForSubjectImages = {
+      id: "wait-for-subject-images",
+      trick: "wait",
+      needs: "layout",
+      governs: "images",
+      because: "waited only for images inside the presentation subject and its portals",
+      settle: async () => {
+        const images = roots.flatMap((root) => [
+          ...root.tagName.toLowerCase() === "img" ? [root] : [],
+          ...Array.from(root.querySelectorAll("img"))
+        ]);
+        await Promise.all(images.filter((image) => !image.complete).map((image) => new Promise((resolve) => {
+          image.addEventListener("load", () => resolve(), { once: true });
+          image.addEventListener("error", () => resolve(), { once: true });
+        })));
+      }
+    };
+    return [
+      ...COLLECT_RECIPE.filter((intervention) => intervention.id !== "wait-for-images"),
+      waitForSubjectImages
+    ];
+  }
+  function paintPresentation(instructions, layers) {
+    clearPresentationPaint();
+    const selected = layers === void 0 ? void 0 : new Set(layers);
+    const visible = instructions.filter((instruction) => selected?.has(instruction.layer) ?? true);
+    if (visible.length === 0)
+      return 0;
+    const document2 = globalThis.document;
+    const namespace = "http://www.w3.org/2000/svg";
+    const svg = document2.createElementNS(namespace, "svg");
+    svg.setAttribute(PRESENTATION_OVERLAY_ATTRIBUTE, "");
+    svg.setAttribute("aria-hidden", "true");
+    svg.setAttribute("width", String(Math.max(document2.documentElement.scrollWidth, innerWidth)));
+    svg.setAttribute("height", String(Math.max(document2.documentElement.scrollHeight, innerHeight)));
+    Object.assign(svg.style, {
+      position: "absolute",
+      left: "0",
+      top: "0",
+      pointerEvents: "none",
+      overflow: "visible",
+      zIndex: "2147483647"
+    });
+    for (const instruction of visible) {
+      const group = document2.createElementNS(namespace, "g");
+      group.setAttribute("data-layer", instruction.layer);
+      group.setAttribute("data-measurement", instruction.id);
+      if (instruction.shape === "rect" && instruction.rect !== void 0) {
+        const rectangle = document2.createElementNS(namespace, "rect");
+        rectangle.setAttribute("x", String(instruction.rect.x + scrollX));
+        rectangle.setAttribute("y", String(instruction.rect.y + scrollY));
+        rectangle.setAttribute("width", String(instruction.rect.width));
+        rectangle.setAttribute("height", String(instruction.rect.height));
+        rectangle.setAttribute("fill", "none");
+        rectangle.setAttribute("stroke", instruction.color);
+        rectangle.setAttribute("stroke-width", instruction.layer === "findings" ? "3" : "1");
+        rectangle.setAttribute("stroke-dasharray", instruction.layer === "semantic" ? "3 2" : "none");
+        group.append(rectangle);
+        group.append(paintLabel(instruction.label, instruction.rect.x + scrollX + 2, instruction.rect.y + scrollY + 11));
+      } else if (instruction.shape === "line" && instruction.line !== void 0) {
+        const line = document2.createElementNS(namespace, "line");
+        line.setAttribute("x1", String(instruction.line.x1 + scrollX));
+        line.setAttribute("y1", String(instruction.line.y1 + scrollY));
+        line.setAttribute("x2", String(instruction.line.x2 + scrollX));
+        line.setAttribute("y2", String(instruction.line.y2 + scrollY));
+        line.setAttribute("stroke", instruction.color);
+        group.append(line);
+        group.append(paintLabel(instruction.label, (instruction.line.x1 + instruction.line.x2) / 2 + scrollX, (instruction.line.y1 + instruction.line.y2) / 2 + scrollY));
+      }
+      svg.append(group);
+    }
+    document2.documentElement.append(svg);
+    return visible.length;
+  }
+  function clearPresentationPaint() {
+    globalThis.document?.querySelector(`[${PRESENTATION_OVERLAY_ATTRIBUTE}]`)?.remove();
+  }
+  function paintLabel(text, x, y) {
+    const value = document.createElementNS("http://www.w3.org/2000/svg", "text");
+    value.setAttribute("x", String(x));
+    value.setAttribute("y", String(y));
+    value.setAttribute("fill", "#111");
+    value.setAttribute("stroke", "#fff");
+    value.setAttribute("stroke-width", "3");
+    value.setAttribute("paint-order", "stroke");
+    value.setAttribute("font-family", "ui-monospace, monospace");
+    value.setAttribute("font-size", "10");
+    value.textContent = text;
+    return value;
+  }
+
+  // packages/presentation/dist/browser-agent-entry.js
+  globalThis[PRESENTATION_AGENT] = {
+    acquire: acquirePresentation,
+    paint: paintPresentation,
+    clear: clearPresentationPaint,
+    version: PRESENTATION_AGENT_VERSION
+  };
+})();