hyperframes 0.6.90 → 0.6.91

package/dist/cli.js

@@ -50,7 +50,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.6.90" : "0.0.0-dev";
+    VERSION = true ? "0.6.91" : "0.0.0-dev";
   }
 });
 
@@ -47853,6 +47853,7 @@ __export(gsapParser_exports, {
   removeKeyframeFromScript: () => removeKeyframeFromScript,
   serializeGsapAnimations: () => serializeGsapAnimations,
   setArcPathInScript: () => setArcPathInScript,
+  splitAnimationsInScript: () => splitAnimationsInScript,
   unrollDynamicAnimations: () => unrollDynamicAnimations,
   updateAnimationInScript: () => updateAnimationInScript,
   updateArcSegmentInScript: () => updateArcSegmentInScript,
@@ -48200,6 +48201,19 @@ function parsePercentageKeyframes(node, scope) {
     ...easeEach ? { easeEach } : {}
   };
 }
+function computeKeyframesTotalDuration(varsNode, scope) {
+  const kfNode = (varsNode.properties ?? []).find(
+    (p2) => (p2.key?.name ?? p2.key?.value) === "keyframes"
+  )?.value;
+  if (!kfNode || kfNode.type !== "ArrayExpression") return void 0;
+  let total = 0;
+  for (const el of kfNode.elements ?? []) {
+    if (!el || el.type !== "ObjectExpression") continue;
+    const r2 = objectExpressionToRecord(el, scope);
+    if (typeof r2.duration === "number") total += r2.duration;
+  }
+  return total > 0 ? total : void 0;
+}
 function parseObjectArrayKeyframes(node, scope) {
   const elements = node.elements ?? [];
   const raw = [];
@@ -48417,8 +48431,11 @@ function tweenCallToAnimation(call, scope) {
   }
   const posVal = call.positionArg ? extractLiteralValue(call.positionArg, scope) : 0;
   const position = typeof posVal === "number" ? posVal : typeof posVal === "string" ? posVal : 0;
-  const duration = typeof vars.duration === "number" ? vars.duration : void 0;
+  let duration = typeof vars.duration === "number" ? vars.duration : void 0;
   const ease = typeof vars.ease === "string" ? vars.ease : void 0;
+  if (duration === void 0 && keyframesData) {
+    duration = computeKeyframesTotalDuration(call.varsArg, scope);
+  }
   const anim = {
     targetSelector: call.selector,
     method: call.method,
@@ -48524,15 +48541,18 @@ function setVarsKey(varsArg, key2, value) {
     varsArg.properties.push(makeObjectProperty(key2, value));
   }
 }
-function reconcileEditableProperties(varsArg, newProps) {
+function filterEditableKeys(varsArg, shouldKeep) {
   if (varsArg?.type !== "ObjectExpression") return;
   varsArg.properties = varsArg.properties.filter((p2) => {
     if (!isObjectProperty(p2)) return true;
     const key2 = propKeyName(p2);
     if (typeof key2 !== "string") return true;
     if (!isEditablePropertyKey(key2)) return true;
-    return key2 in newProps;
+    return shouldKeep(key2);
   });
+}
+function reconcileEditableProperties(varsArg, newProps) {
+  filterEditableKeys(varsArg, (key2) => key2 in newProps);
   for (const [key2, value] of Object.entries(newProps)) {
     setVarsKey(varsArg, key2, value);
   }
@@ -48602,6 +48622,23 @@ function updateAnimationInScript(script, animationId, updates) {
   applyUpdatesToCall(target.call, updates);
   return recast.print(parsed.ast).code;
 }
+function updateAnimationSelector(script, animationId, newSelector) {
+  let parsed;
+  try {
+    parsed = parseGsapAst(script);
+  } catch {
+    return script;
+  }
+  const target = parsed.located.find((l) => l.id === animationId);
+  if (!target) return script;
+  const selectorArg = target.call.path.node.arguments?.[0];
+  if (selectorArg?.type === "StringLiteral") {
+    selectorArg.value = newSelector;
+  } else if (selectorArg?.type === "Identifier") {
+    target.call.path.node.arguments[0] = { type: "StringLiteral", value: newSelector };
+  }
+  return recast.print(parsed.ast).code;
+}
 function addAnimationToScript(script, animation) {
   let parsed;
   try {
@@ -48716,6 +48753,127 @@ function removeAnimationFromScript(script, animationId) {
   }
   return recast.print(parsed.ast).code;
 }
+function insertInheritedStateSet(script, selector, position, properties) {
+  let parsed;
+  try {
+    parsed = parseGsapAst(script);
+  } catch {
+    return script;
+  }
+  const tlVar = parsed.timelineVar;
+  const props = Object.entries(properties).map(([k2, v2]) => `${k2}: ${typeof v2 === "string" ? JSON.stringify(v2) : v2}`).join(", ");
+  const code = `${tlVar}.set(${JSON.stringify(selector)}, { ${props} }, ${position});`;
+  const newStatement = parseScript(code).program.body[0];
+  const anchor = findTimelineDeclarationPath(parsed.ast, tlVar);
+  if (anchor) {
+    anchor.insertAfter(newStatement);
+  } else if (parsed.located.length > 0) {
+    const firstTween = parsed.located[0].call;
+    const stmtPath = findStatementPath(firstTween.path);
+    if (stmtPath) stmtPath.insertBefore(newStatement);
+    else parsed.ast.program.body.unshift(newStatement);
+  } else {
+    parsed.ast.program.body.push(newStatement);
+  }
+  return recast.print(parsed.ast).code;
+}
+function splitAnimationsInScript(script, opts) {
+  const parsed = parseGsapScript(script);
+  const originalSelector = `#${opts.originalId}`;
+  const newSelector = `#${opts.newId}`;
+  const skippedSelectors = [];
+  for (const a of parsed.animations) {
+    if (a.targetSelector !== originalSelector && a.targetSelector.includes(opts.originalId)) {
+      skippedSelectors.push(a.targetSelector);
+    }
+  }
+  const matching = parsed.animations.filter((a) => a.targetSelector === originalSelector);
+  if (matching.length === 0) return { script, skippedSelectors };
+  let result = script;
+  const newElementStart = opts.splitTime;
+  const inheritedProps = {};
+  for (let i2 = matching.length - 1; i2 >= 0; i2--) {
+    const anim = matching[i2];
+    const pos = typeof anim.position === "number" ? anim.position : 0;
+    const dur = anim.duration ?? 0;
+    const animEnd = pos + dur;
+    if (anim.keyframes) {
+      if (pos >= opts.splitTime) {
+        result = updateAnimationSelector(result, anim.id, newSelector);
+      } else if (animEnd > opts.splitTime) {
+        skippedSelectors.push(`${originalSelector} (keyframes spanning split)`);
+        const kfs = anim.keyframes.keyframes;
+        for (const kf of kfs) {
+          const kfTime = pos + kf.percentage / 100 * dur;
+          if (kfTime <= opts.splitTime) {
+            for (const [k2, v2] of Object.entries(kf.properties)) {
+              inheritedProps[k2] = v2;
+            }
+          }
+        }
+      } else {
+        const kfs = anim.keyframes.keyframes;
+        if (kfs.length > 0) {
+          for (const [k2, v2] of Object.entries(kfs[kfs.length - 1].properties)) {
+            inheritedProps[k2] = v2;
+          }
+        }
+      }
+      continue;
+    }
+    if (animEnd <= opts.splitTime) {
+      for (const [k2, v2] of Object.entries(anim.properties)) {
+        inheritedProps[k2] = v2;
+      }
+      continue;
+    }
+    if (pos >= opts.splitTime) {
+      result = updateAnimationSelector(result, anim.id, newSelector);
+      continue;
+    }
+    const progress = dur > 0 ? (opts.splitTime - pos) / dur : 0;
+    const fromSource = anim.fromProperties ?? inheritedProps;
+    const midProps = {};
+    for (const [k2, v2] of Object.entries(anim.properties)) {
+      if (typeof v2 !== "number") {
+        midProps[k2] = v2;
+        continue;
+      }
+      const fromVal = typeof fromSource[k2] === "number" ? fromSource[k2] : 0;
+      midProps[k2] = fromVal + (v2 - fromVal) * progress;
+    }
+    const firstHalfDuration = opts.splitTime - pos;
+    result = updateAnimationInScript(result, anim.id, {
+      duration: firstHalfDuration,
+      properties: midProps
+    });
+    const secondHalfDuration = animEnd - opts.splitTime;
+    const addResult = addAnimationToScript(result, {
+      targetSelector: newSelector,
+      method: "fromTo",
+      position: newElementStart,
+      duration: secondHalfDuration,
+      properties: { ...anim.properties },
+      fromProperties: { ...midProps },
+      ease: anim.ease,
+      extras: anim.extras
+    });
+    result = addResult.script;
+    for (const [k2, v2] of Object.entries(midProps)) {
+      inheritedProps[k2] = v2;
+    }
+  }
+  if (Object.keys(inheritedProps).length > 0) {
+    result = insertInheritedStateSet(result, newSelector, newElementStart, inheritedProps);
+  }
+  return { script: result, skippedSelectors };
+}
+function sortedKeyframes(kfs) {
+  return kfs.slice().sort((a, b2) => a.percentage - b2.percentage);
+}
+function keyframePropsToCode(kf) {
+  return Object.entries(kf.properties).map(([k2, v2]) => `${safeKey(k2)}: ${valueToCode(v2)}`);
+}
 function removeVarsKey(varsArg, key2) {
   if (varsArg?.type !== "ObjectExpression") return;
   varsArg.properties = varsArg.properties.filter(
@@ -48760,6 +48918,13 @@ function collapseKeyframesToFlat(varsArg, record) {
   removeVarsKey(varsArg, "keyframes");
   removeVarsKey(varsArg, "easeEach");
 }
+function locateKeyframeCtx(script, animationId, percentage) {
+  const loc = locateAnimation(script, animationId);
+  if (!loc) return null;
+  const kfNode = findKeyframesObjectNode(loc.target.call.varsArg);
+  if (!kfNode) return null;
+  return { loc, kfNode, pctKey: `${percentage}%` };
+}
 function addKeyframeToScript(script, animationId, percentage, properties, ease, backfillDefaults) {
   let loc = locateAnimation(script, animationId);
   if (!loc) {
@@ -48840,11 +49005,9 @@ function addKeyframeToScript(script, animationId, percentage, properties, ease,
   return recast.print(loc.parsed.ast).code;
 }
 function removeKeyframeFromScript(script, animationId, percentage) {
-  const loc = locateAnimation(script, animationId);
-  if (!loc) return script;
-  const kfNode = findKeyframesObjectNode(loc.target.call.varsArg);
-  if (!kfNode) return script;
-  const pctKey = `${percentage}%`;
+  const ctx = locateKeyframeCtx(script, animationId, percentage);
+  if (!ctx) return script;
+  const { loc, kfNode, pctKey } = ctx;
   const removeIdx = kfNode.properties.findIndex(
     (p2) => isObjectProperty(p2) && propKeyName(p2) === pctKey
   );
@@ -48858,11 +49021,9 @@ function removeKeyframeFromScript(script, animationId, percentage) {
   return recast.print(loc.parsed.ast).code;
 }
 function updateKeyframeInScript(script, animationId, percentage, properties, ease) {
-  const loc = locateAnimation(script, animationId);
-  if (!loc) return script;
-  const kfNode = findKeyframesObjectNode(loc.target.call.varsArg);
-  if (!kfNode) return script;
-  const pctKey = `${percentage}%`;
+  const ctx = locateKeyframeCtx(script, animationId, percentage);
+  if (!ctx) return script;
+  const { loc, kfNode, pctKey } = ctx;
   const existing = kfNode.properties.find(
     (p2) => isObjectProperty(p2) && propKeyName(p2) === pctKey
   );
@@ -48901,10 +49062,9 @@ function stripEditableAndEase(varsArg) {
   varsArg.properties = varsArg.properties.filter((p2) => {
     if (!isObjectProperty(p2)) return true;
     const key2 = propKeyName(p2);
-    if (typeof key2 !== "string") return true;
-    if (key2 === "ease" || key2 === "keyframes") return false;
-    return !isEditablePropertyKey(key2);
+    return key2 !== "ease" && key2 !== "keyframes";
   });
+  filterEditableKeys(varsArg, () => false);
 }
 function insertKeyframesProp(varsArg, fromProps, toProps, easeEach) {
   const fromEntries = Object.entries(fromProps).map(([k2, v2]) => `${safeKey(k2)}: ${valueToCode(v2)}`);
@@ -48955,11 +49115,8 @@ function materializeKeyframesInScript(script, animationId, keyframes, easeEach,
     loc.target.call.node.arguments[0] = parseExpr(JSON.stringify(resolvedSelector));
   }
   const entries2 = [];
-  const sorted = keyframes.slice().sort((a, b2) => a.percentage - b2.percentage);
-  for (const kf of sorted) {
-    const propEntries = Object.entries(kf.properties).map(
-      ([k2, v2]) => `${safeKey(k2)}: ${valueToCode(v2)}`
-    );
+  for (const kf of sortedKeyframes(keyframes)) {
+    const propEntries = keyframePropsToCode(kf);
     if (kf.ease) propEntries.push(`ease: ${JSON.stringify(kf.ease)}`);
     entries2.push(`${JSON.stringify(kf.percentage + "%")}: { ${propEntries.join(", ")} }`);
   }
@@ -49166,11 +49323,8 @@ function unrollDynamicAnimations(script, animationId, elements) {
   const calls = [];
   for (const el of elements) {
     const kfEntries = [];
-    const sorted = el.keyframes.slice().sort((a, b2) => a.percentage - b2.percentage);
-    for (const kf of sorted) {
-      const propEntries = Object.entries(kf.properties).map(
-        ([k2, v2]) => `${safeKey(k2)}: ${valueToCode(v2)}`
-      );
+    for (const kf of sortedKeyframes(el.keyframes)) {
+      const propEntries = keyframePropsToCode(kf);
       kfEntries.push(`${JSON.stringify(kf.percentage + "%")}: { ${propEntries.join(", ")} }`);
     }
     if (el.easeEach) {
@@ -49464,11 +49618,11 @@ function generateZoomGsapAnimations(zoomKeyframes, canvasWidth, canvasHeight) {
   if (!zoomKeyframes || zoomKeyframes.length === 0) {
     return "";
   }
-  const sortedKeyframes = [...zoomKeyframes].sort((a, b2) => a.time - b2.time);
+  const sortedKeyframes2 = [...zoomKeyframes].sort((a, b2) => a.time - b2.time);
   const animations = [];
   animations.push("    // Stage zoom animations");
-  for (let i2 = 0; i2 < sortedKeyframes.length; i2++) {
-    const kf = sortedKeyframes[i2];
+  for (let i2 = 0; i2 < sortedKeyframes2.length; i2++) {
+    const kf = sortedKeyframes2[i2];
     if (!kf) continue;
     const { x: x3, y } = calculateZoomTransform(
       kf.zoom.scale,
@@ -49482,7 +49636,7 @@ function generateZoomGsapAnimations(zoomKeyframes, canvasWidth, canvasHeight) {
         `    tl.set("#stage-zoom-container", { scale: ${kf.zoom.scale}, x: ${x3}, y: ${y} }, ${kf.time});`
       );
     } else {
-      const prevKf = sortedKeyframes[i2 - 1];
+      const prevKf = sortedKeyframes2[i2 - 1];
       if (!prevKf) continue;
       const duration = kf.time - prevKf.time;
       const ease = kf.ease ? `, ease: "${kf.ease}"` : "";
@@ -59635,7 +59789,3490 @@ var init_mediaValidation = __esm({
   }
 });
 
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/util/unesc.js
+var require_unesc = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/util/unesc.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = unesc;
+    function gobbleHex(str) {
+      var lower2 = str.toLowerCase();
+      var hex = "";
+      var spaceTerminated = false;
+      for (var i2 = 0; i2 < 6 && lower2[i2] !== void 0; i2++) {
+        var code = lower2.charCodeAt(i2);
+        var valid = code >= 97 && code <= 102 || code >= 48 && code <= 57;
+        spaceTerminated = code === 32;
+        if (!valid) {
+          break;
+        }
+        hex += lower2[i2];
+      }
+      if (hex.length === 0) {
+        return void 0;
+      }
+      var codePoint = parseInt(hex, 16);
+      var isSurrogate = codePoint >= 55296 && codePoint <= 57343;
+      if (isSurrogate || codePoint === 0 || codePoint > 1114111) {
+        return ["\uFFFD", hex.length + (spaceTerminated ? 1 : 0)];
+      }
+      return [String.fromCodePoint(codePoint), hex.length + (spaceTerminated ? 1 : 0)];
+    }
+    var CONTAINS_ESCAPE = /\\/;
+    function unesc(str) {
+      var needToProcess = CONTAINS_ESCAPE.test(str);
+      if (!needToProcess) {
+        return str;
+      }
+      var ret = "";
+      for (var i2 = 0; i2 < str.length; i2++) {
+        if (str[i2] === "\\") {
+          var gobbled = gobbleHex(str.slice(i2 + 1, i2 + 7));
+          if (gobbled !== void 0) {
+            ret += gobbled[0];
+            i2 += gobbled[1];
+            continue;
+          }
+          if (str[i2 + 1] === "\\") {
+            ret += "\\";
+            i2++;
+            continue;
+          }
+          if (str.length === i2 + 1) {
+            ret += str[i2];
+          }
+          continue;
+        }
+        ret += str[i2];
+      }
+      return ret;
+    }
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/util/getProp.js
+var require_getProp = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/util/getProp.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = getProp;
+    function getProp(obj) {
+      for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        props[_key - 1] = arguments[_key];
+      }
+      while (props.length > 0) {
+        var prop2 = props.shift();
+        if (!obj[prop2]) {
+          return void 0;
+        }
+        obj = obj[prop2];
+      }
+      return obj;
+    }
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/util/ensureObject.js
+var require_ensureObject = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/util/ensureObject.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = ensureObject;
+    function ensureObject(obj) {
+      for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        props[_key - 1] = arguments[_key];
+      }
+      while (props.length > 0) {
+        var prop2 = props.shift();
+        if (!obj[prop2]) {
+          obj[prop2] = {};
+        }
+        obj = obj[prop2];
+      }
+    }
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/util/stripComments.js
+var require_stripComments = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/util/stripComments.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = stripComments;
+    function stripComments(str) {
+      var s2 = "";
+      var commentStart = str.indexOf("/*");
+      var lastEnd = 0;
+      while (commentStart >= 0) {
+        s2 = s2 + str.slice(lastEnd, commentStart);
+        var commentEnd = str.indexOf("*/", commentStart + 2);
+        if (commentEnd < 0) {
+          return s2;
+        }
+        lastEnd = commentEnd + 2;
+        commentStart = str.indexOf("/*", lastEnd);
+      }
+      s2 = s2 + str.slice(lastEnd);
+      return s2;
+    }
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/util/maxNestingDepth.js
+var require_maxNestingDepth = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/util/maxNestingDepth.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.MAX_NESTING_DEPTH = void 0;
+    exports["default"] = resolveMaxNestingDepth;
+    var MAX_NESTING_DEPTH = exports.MAX_NESTING_DEPTH = 256;
+    function resolveMaxNestingDepth(value) {
+      return Number.isSafeInteger(value) && value >= 0 ? value : MAX_NESTING_DEPTH;
+    }
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/util/index.js
+var require_util3 = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/util/index.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.unesc = exports.stripComments = exports.resolveMaxNestingDepth = exports.getProp = exports.ensureObject = exports.MAX_NESTING_DEPTH = void 0;
+    var _unesc = _interopRequireDefault(require_unesc());
+    exports.unesc = _unesc["default"];
+    var _getProp = _interopRequireDefault(require_getProp());
+    exports.getProp = _getProp["default"];
+    var _ensureObject = _interopRequireDefault(require_ensureObject());
+    exports.ensureObject = _ensureObject["default"];
+    var _stripComments = _interopRequireDefault(require_stripComments());
+    exports.stripComments = _stripComments["default"];
+    var _maxNestingDepth = _interopRequireWildcard(require_maxNestingDepth());
+    exports.resolveMaxNestingDepth = _maxNestingDepth["default"];
+    exports.MAX_NESTING_DEPTH = _maxNestingDepth.MAX_NESTING_DEPTH;
+    function _interopRequireWildcard(e3, t2) {
+      if ("function" == typeof WeakMap) var r2 = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap();
+      return (_interopRequireWildcard = function _interopRequireWildcard2(e4, t3) {
+        if (!t3 && e4 && e4.__esModule) return e4;
+        var o, i2, f3 = { __proto__: null, "default": e4 };
+        if (null === e4 || "object" != typeof e4 && "function" != typeof e4) return f3;
+        if (o = t3 ? n : r2) {
+          if (o.has(e4)) return o.get(e4);
+          o.set(e4, f3);
+        }
+        for (var _t2 in e4) {
+          "default" !== _t2 && {}.hasOwnProperty.call(e4, _t2) && ((i2 = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e4, _t2)) && (i2.get || i2.set) ? o(f3, _t2, i2) : f3[_t2] = e4[_t2]);
+        }
+        return f3;
+      })(e3, t2);
+    }
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/node.js
+var require_node = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/node.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _util = require_util3();
+    function _defineProperties(e3, r2) {
+      for (var t2 = 0; t2 < r2.length; t2++) {
+        var o = r2[t2];
+        o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e3, _toPropertyKey(o.key), o);
+      }
+    }
+    function _createClass(e3, r2, t2) {
+      return r2 && _defineProperties(e3.prototype, r2), t2 && _defineProperties(e3, t2), Object.defineProperty(e3, "prototype", { writable: false }), e3;
+    }
+    function _toPropertyKey(t2) {
+      var i2 = _toPrimitive(t2, "string");
+      return "symbol" == typeof i2 ? i2 : i2 + "";
+    }
+    function _toPrimitive(t2, r2) {
+      if ("object" != typeof t2 || !t2) return t2;
+      var e3 = t2[Symbol.toPrimitive];
+      if (void 0 !== e3) {
+        var i2 = e3.call(t2, r2 || "default");
+        if ("object" != typeof i2) return i2;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return ("string" === r2 ? String : Number)(t2);
+    }
+    var cloneNode2 = function cloneNode3(obj, parent) {
+      if (typeof obj !== "object" || obj === null) {
+        return obj;
+      }
+      var cloned = new obj.constructor();
+      for (var i2 in obj) {
+        if (!obj.hasOwnProperty(i2)) {
+          continue;
+        }
+        var value = obj[i2];
+        var type = typeof value;
+        if (i2 === "parent" && type === "object") {
+          if (parent) {
+            cloned[i2] = parent;
+          }
+        } else if (value instanceof Array) {
+          cloned[i2] = value.map(function(j3) {
+            return cloneNode3(j3, cloned);
+          });
+        } else {
+          cloned[i2] = cloneNode3(value, cloned);
+        }
+      }
+      return cloned;
+    };
+    var Node4 = exports["default"] = /* @__PURE__ */ (function() {
+      function Node5(opts) {
+        if (opts === void 0) {
+          opts = {};
+        }
+        Object.assign(this, opts);
+        this.spaces = this.spaces || {};
+        this.spaces.before = this.spaces.before || "";
+        this.spaces.after = this.spaces.after || "";
+      }
+      var _proto = Node5.prototype;
+      _proto.remove = function remove2() {
+        if (this.parent) {
+          this.parent.removeChild(this);
+        }
+        this.parent = void 0;
+        return this;
+      };
+      _proto.replaceWith = function replaceWith2() {
+        if (this.parent) {
+          for (var index in arguments) {
+            this.parent.insertBefore(this, arguments[index]);
+          }
+          this.remove();
+        }
+        return this;
+      };
+      _proto.next = function next() {
+        return this.parent.at(this.parent.index(this) + 1);
+      };
+      _proto.prev = function prev() {
+        return this.parent.at(this.parent.index(this) - 1);
+      };
+      _proto.clone = function clone2(overrides) {
+        if (overrides === void 0) {
+          overrides = {};
+        }
+        var cloned = cloneNode2(this);
+        for (var name in overrides) {
+          cloned[name] = overrides[name];
+        }
+        return cloned;
+      };
+      _proto.appendToPropertyAndEscape = function appendToPropertyAndEscape(name, value, valueEscaped) {
+        if (!this.raws) {
+          this.raws = {};
+        }
+        var originalValue = this[name];
+        var originalEscaped = this.raws[name];
+        this[name] = originalValue + value;
+        if (originalEscaped || valueEscaped !== value) {
+          this.raws[name] = (originalEscaped || originalValue) + valueEscaped;
+        } else {
+          delete this.raws[name];
+        }
+      };
+      _proto.setPropertyAndEscape = function setPropertyAndEscape(name, value, valueEscaped) {
+        if (!this.raws) {
+          this.raws = {};
+        }
+        this[name] = value;
+        this.raws[name] = valueEscaped;
+      };
+      _proto.setPropertyWithoutEscape = function setPropertyWithoutEscape(name, value) {
+        this[name] = value;
+        if (this.raws) {
+          delete this.raws[name];
+        }
+      };
+      _proto.isAtPosition = function isAtPosition(line, column) {
+        if (this.source && this.source.start && this.source.end) {
+          if (this.source.start.line > line) {
+            return false;
+          }
+          if (this.source.end.line < line) {
+            return false;
+          }
+          if (this.source.start.line === line && this.source.start.column > column) {
+            return false;
+          }
+          if (this.source.end.line === line && this.source.end.column < column) {
+            return false;
+          }
+          return true;
+        }
+        return void 0;
+      };
+      _proto.stringifyProperty = function stringifyProperty(name) {
+        return this.raws && this.raws[name] || this[name];
+      };
+      _proto.valueToString = function valueToString() {
+        return String(this.stringifyProperty("value"));
+      };
+      _proto.toString = function toString2() {
+        return [this.rawSpaceBefore, this.valueToString(), this.rawSpaceAfter].join("");
+      };
+      _proto._stringify = function _stringify() {
+        return this.toString();
+      };
+      _createClass(Node5, [{
+        key: "rawSpaceBefore",
+        get: function get() {
+          var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before;
+          if (rawSpace === void 0) {
+            rawSpace = this.spaces && this.spaces.before;
+          }
+          return rawSpace || "";
+        },
+        set: function set(raw) {
+          (0, _util.ensureObject)(this, "raws", "spaces");
+          this.raws.spaces.before = raw;
+        }
+      }, {
+        key: "rawSpaceAfter",
+        get: function get() {
+          var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after;
+          if (rawSpace === void 0) {
+            rawSpace = this.spaces.after;
+          }
+          return rawSpace || "";
+        },
+        set: function set(raw) {
+          (0, _util.ensureObject)(this, "raws", "spaces");
+          this.raws.spaces.after = raw;
+        }
+      }]);
+      return Node5;
+    })();
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/types.js
+var require_types2 = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/types.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.UNIVERSAL = exports.TAG = exports.STRING = exports.SELECTOR = exports.ROOT = exports.PSEUDO = exports.NESTING = exports.ID = exports.COMMENT = exports.COMBINATOR = exports.CLASS = exports.ATTRIBUTE = void 0;
+    var TAG = exports.TAG = "tag";
+    var STRING = exports.STRING = "string";
+    var SELECTOR = exports.SELECTOR = "selector";
+    var ROOT = exports.ROOT = "root";
+    var PSEUDO = exports.PSEUDO = "pseudo";
+    var NESTING = exports.NESTING = "nesting";
+    var ID = exports.ID = "id";
+    var COMMENT = exports.COMMENT = "comment";
+    var COMBINATOR = exports.COMBINATOR = "combinator";
+    var CLASS = exports.CLASS = "class";
+    var ATTRIBUTE = exports.ATTRIBUTE = "attribute";
+    var UNIVERSAL = exports.UNIVERSAL = "universal";
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/container.js
+var require_container = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/container.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _util = require_util3();
+    var _node = _interopRequireDefault(require_node());
+    var types4 = _interopRequireWildcard(require_types2());
+    function _interopRequireWildcard(e3, t2) {
+      if ("function" == typeof WeakMap) var r2 = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap();
+      return (_interopRequireWildcard = function _interopRequireWildcard2(e4, t3) {
+        if (!t3 && e4 && e4.__esModule) return e4;
+        var o, i2, f3 = { __proto__: null, "default": e4 };
+        if (null === e4 || "object" != typeof e4 && "function" != typeof e4) return f3;
+        if (o = t3 ? n : r2) {
+          if (o.has(e4)) return o.get(e4);
+          o.set(e4, f3);
+        }
+        for (var _t2 in e4) {
+          "default" !== _t2 && {}.hasOwnProperty.call(e4, _t2) && ((i2 = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e4, _t2)) && (i2.get || i2.set) ? o(f3, _t2, i2) : f3[_t2] = e4[_t2]);
+        }
+        return f3;
+      })(e3, t2);
+    }
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _createForOfIteratorHelperLoose(r2, e3) {
+      var t2 = "undefined" != typeof Symbol && r2[Symbol.iterator] || r2["@@iterator"];
+      if (t2) return (t2 = t2.call(r2)).next.bind(t2);
+      if (Array.isArray(r2) || (t2 = _unsupportedIterableToArray(r2)) || e3 && r2 && "number" == typeof r2.length) {
+        t2 && (r2 = t2);
+        var o = 0;
+        return function() {
+          return o >= r2.length ? { done: true } : { done: false, value: r2[o++] };
+        };
+      }
+      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+    function _unsupportedIterableToArray(r2, a) {
+      if (r2) {
+        if ("string" == typeof r2) return _arrayLikeToArray(r2, a);
+        var t2 = {}.toString.call(r2).slice(8, -1);
+        return "Object" === t2 && r2.constructor && (t2 = r2.constructor.name), "Map" === t2 || "Set" === t2 ? Array.from(r2) : "Arguments" === t2 || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t2) ? _arrayLikeToArray(r2, a) : void 0;
+      }
+    }
+    function _arrayLikeToArray(r2, a) {
+      (null == a || a > r2.length) && (a = r2.length);
+      for (var e3 = 0, n = Array(a); e3 < a; e3++) {
+        n[e3] = r2[e3];
+      }
+      return n;
+    }
+    function _defineProperties(e3, r2) {
+      for (var t2 = 0; t2 < r2.length; t2++) {
+        var o = r2[t2];
+        o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e3, _toPropertyKey(o.key), o);
+      }
+    }
+    function _createClass(e3, r2, t2) {
+      return r2 && _defineProperties(e3.prototype, r2), t2 && _defineProperties(e3, t2), Object.defineProperty(e3, "prototype", { writable: false }), e3;
+    }
+    function _toPropertyKey(t2) {
+      var i2 = _toPrimitive(t2, "string");
+      return "symbol" == typeof i2 ? i2 : i2 + "";
+    }
+    function _toPrimitive(t2, r2) {
+      if ("object" != typeof t2 || !t2) return t2;
+      var e3 = t2[Symbol.toPrimitive];
+      if (void 0 !== e3) {
+        var i2 = e3.call(t2, r2 || "default");
+        if ("object" != typeof i2) return i2;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return ("string" === r2 ? String : Number)(t2);
+    }
+    function _inheritsLoose(t2, o) {
+      t2.prototype = Object.create(o.prototype), t2.prototype.constructor = t2, _setPrototypeOf(t2, o);
+    }
+    function _setPrototypeOf(t2, e3) {
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t3, e4) {
+        return t3.__proto__ = e4, t3;
+      }, _setPrototypeOf(t2, e3);
+    }
+    var Container = exports["default"] = /* @__PURE__ */ (function(_Node) {
+      _inheritsLoose(Container2, _Node);
+      function Container2(opts) {
+        var _this;
+        _this = _Node.call(this, opts) || this;
+        if (!_this.nodes) {
+          _this.nodes = [];
+        }
+        return _this;
+      }
+      var _proto = Container2.prototype;
+      _proto.append = function append3(selector) {
+        selector.parent = this;
+        this.nodes.push(selector);
+        return this;
+      };
+      _proto.prepend = function prepend2(selector) {
+        selector.parent = this;
+        this.nodes.unshift(selector);
+        for (var id in this.indexes) {
+          this.indexes[id]++;
+        }
+        return this;
+      };
+      _proto.at = function at3(index) {
+        return this.nodes[index];
+      };
+      _proto.index = function index(child) {
+        if (typeof child === "number") {
+          return child;
+        }
+        return this.nodes.indexOf(child);
+      };
+      _proto.removeChild = function removeChild(child) {
+        child = this.index(child);
+        this.at(child).parent = void 0;
+        this.nodes.splice(child, 1);
+        var index;
+        for (var id in this.indexes) {
+          index = this.indexes[id];
+          if (index >= child) {
+            this.indexes[id] = index - 1;
+          }
+        }
+        return this;
+      };
+      _proto.removeAll = function removeAll() {
+        for (var _iterator = _createForOfIteratorHelperLoose(this.nodes), _step; !(_step = _iterator()).done; ) {
+          var node = _step.value;
+          node.parent = void 0;
+        }
+        this.nodes = [];
+        return this;
+      };
+      _proto.empty = function empty() {
+        return this.removeAll();
+      };
+      _proto.insertAfter = function insertAfter(oldNode, newNode) {
+        var _this$nodes;
+        newNode.parent = this;
+        var oldIndex = this.index(oldNode);
+        var resetNode = [];
+        for (var i2 = 2; i2 < arguments.length; i2++) {
+          resetNode.push(arguments[i2]);
+        }
+        (_this$nodes = this.nodes).splice.apply(_this$nodes, [oldIndex + 1, 0, newNode].concat(resetNode));
+        newNode.parent = this;
+        var index;
+        for (var id in this.indexes) {
+          index = this.indexes[id];
+          if (oldIndex < index) {
+            this.indexes[id] = index + arguments.length - 1;
+          }
+        }
+        return this;
+      };
+      _proto.insertBefore = function insertBefore(oldNode, newNode) {
+        var _this$nodes2;
+        newNode.parent = this;
+        var oldIndex = this.index(oldNode);
+        var resetNode = [];
+        for (var i2 = 2; i2 < arguments.length; i2++) {
+          resetNode.push(arguments[i2]);
+        }
+        (_this$nodes2 = this.nodes).splice.apply(_this$nodes2, [oldIndex, 0, newNode].concat(resetNode));
+        newNode.parent = this;
+        var index;
+        for (var id in this.indexes) {
+          index = this.indexes[id];
+          if (index >= oldIndex) {
+            this.indexes[id] = index + arguments.length - 1;
+          }
+        }
+        return this;
+      };
+      _proto._findChildAtPosition = function _findChildAtPosition(line, col) {
+        var found = void 0;
+        this.each(function(node) {
+          if (node.atPosition) {
+            var foundChild = node.atPosition(line, col);
+            if (foundChild) {
+              found = foundChild;
+              return false;
+            }
+          } else if (node.isAtPosition(line, col)) {
+            found = node;
+            return false;
+          }
+        });
+        return found;
+      };
+      _proto.atPosition = function atPosition(line, col) {
+        if (this.isAtPosition(line, col)) {
+          return this._findChildAtPosition(line, col) || this;
+        } else {
+          return void 0;
+        }
+      };
+      _proto._inferEndPosition = function _inferEndPosition() {
+        if (this.last && this.last.source && this.last.source.end) {
+          this.source = this.source || {};
+          this.source.end = this.source.end || {};
+          Object.assign(this.source.end, this.last.source.end);
+        }
+      };
+      _proto.each = function each(callback) {
+        if (!this.lastEach) {
+          this.lastEach = 0;
+        }
+        if (!this.indexes) {
+          this.indexes = {};
+        }
+        this.lastEach++;
+        var id = this.lastEach;
+        this.indexes[id] = 0;
+        if (!this.length) {
+          return void 0;
+        }
+        var index, result;
+        while (this.indexes[id] < this.length) {
+          index = this.indexes[id];
+          result = callback(this.at(index), index);
+          if (result === false) {
+            break;
+          }
+          this.indexes[id] += 1;
+        }
+        delete this.indexes[id];
+        if (result === false) {
+          return false;
+        }
+      };
+      _proto.walk = function walk(callback) {
+        return this.each(function(node, i2) {
+          var result = callback(node, i2);
+          if (result !== false && node.length) {
+            result = node.walk(callback);
+          }
+          if (result === false) {
+            return false;
+          }
+        });
+      };
+      _proto.walkAttributes = function walkAttributes(callback) {
+        var _this2 = this;
+        return this.walk(function(selector) {
+          if (selector.type === types4.ATTRIBUTE) {
+            return callback.call(_this2, selector);
+          }
+        });
+      };
+      _proto.walkClasses = function walkClasses(callback) {
+        var _this3 = this;
+        return this.walk(function(selector) {
+          if (selector.type === types4.CLASS) {
+            return callback.call(_this3, selector);
+          }
+        });
+      };
+      _proto.walkCombinators = function walkCombinators(callback) {
+        var _this4 = this;
+        return this.walk(function(selector) {
+          if (selector.type === types4.COMBINATOR) {
+            return callback.call(_this4, selector);
+          }
+        });
+      };
+      _proto.walkComments = function walkComments(callback) {
+        var _this5 = this;
+        return this.walk(function(selector) {
+          if (selector.type === types4.COMMENT) {
+            return callback.call(_this5, selector);
+          }
+        });
+      };
+      _proto.walkIds = function walkIds(callback) {
+        var _this6 = this;
+        return this.walk(function(selector) {
+          if (selector.type === types4.ID) {
+            return callback.call(_this6, selector);
+          }
+        });
+      };
+      _proto.walkNesting = function walkNesting(callback) {
+        var _this7 = this;
+        return this.walk(function(selector) {
+          if (selector.type === types4.NESTING) {
+            return callback.call(_this7, selector);
+          }
+        });
+      };
+      _proto.walkPseudos = function walkPseudos(callback) {
+        var _this8 = this;
+        return this.walk(function(selector) {
+          if (selector.type === types4.PSEUDO) {
+            return callback.call(_this8, selector);
+          }
+        });
+      };
+      _proto.walkTags = function walkTags(callback) {
+        var _this9 = this;
+        return this.walk(function(selector) {
+          if (selector.type === types4.TAG) {
+            return callback.call(_this9, selector);
+          }
+        });
+      };
+      _proto.walkUniversals = function walkUniversals(callback) {
+        var _this0 = this;
+        return this.walk(function(selector) {
+          if (selector.type === types4.UNIVERSAL) {
+            return callback.call(_this0, selector);
+          }
+        });
+      };
+      _proto.split = function split(callback) {
+        var _this1 = this;
+        var current = [];
+        return this.reduce(function(memo, node, index) {
+          var split2 = callback.call(_this1, node);
+          current.push(node);
+          if (split2) {
+            memo.push(current);
+            current = [];
+          } else if (index === _this1.length - 1) {
+            memo.push(current);
+          }
+          return memo;
+        }, []);
+      };
+      _proto.map = function map(callback) {
+        return this.nodes.map(callback);
+      };
+      _proto.reduce = function reduce(callback, memo) {
+        return this.nodes.reduce(callback, memo);
+      };
+      _proto.every = function every(callback) {
+        return this.nodes.every(callback);
+      };
+      _proto.some = function some(callback) {
+        return this.nodes.some(callback);
+      };
+      _proto.filter = function filter2(callback) {
+        return this.nodes.filter(callback);
+      };
+      _proto.sort = function sort(callback) {
+        return this.nodes.sort(callback);
+      };
+      _proto.toString = function toString2(options) {
+        if (options === void 0) {
+          options = {};
+        }
+        return this._stringify(options, 0, (0, _util.resolveMaxNestingDepth)(options.maxNestingDepth));
+      };
+      _proto._stringify = function _stringify(options, depth, max) {
+        return this.map(function(child) {
+          return child._stringify(options, depth, max);
+        }).join("");
+      };
+      _createClass(Container2, [{
+        key: "first",
+        get: function get() {
+          return this.at(0);
+        }
+      }, {
+        key: "last",
+        get: function get() {
+          return this.at(this.length - 1);
+        }
+      }, {
+        key: "length",
+        get: function get() {
+          return this.nodes.length;
+        }
+      }]);
+      return Container2;
+    })(_node["default"]);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/root.js
+var require_root = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/root.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _container = _interopRequireDefault(require_container());
+    var _types = require_types2();
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _defineProperties(e3, r2) {
+      for (var t2 = 0; t2 < r2.length; t2++) {
+        var o = r2[t2];
+        o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e3, _toPropertyKey(o.key), o);
+      }
+    }
+    function _createClass(e3, r2, t2) {
+      return r2 && _defineProperties(e3.prototype, r2), t2 && _defineProperties(e3, t2), Object.defineProperty(e3, "prototype", { writable: false }), e3;
+    }
+    function _toPropertyKey(t2) {
+      var i2 = _toPrimitive(t2, "string");
+      return "symbol" == typeof i2 ? i2 : i2 + "";
+    }
+    function _toPrimitive(t2, r2) {
+      if ("object" != typeof t2 || !t2) return t2;
+      var e3 = t2[Symbol.toPrimitive];
+      if (void 0 !== e3) {
+        var i2 = e3.call(t2, r2 || "default");
+        if ("object" != typeof i2) return i2;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return ("string" === r2 ? String : Number)(t2);
+    }
+    function _inheritsLoose(t2, o) {
+      t2.prototype = Object.create(o.prototype), t2.prototype.constructor = t2, _setPrototypeOf(t2, o);
+    }
+    function _setPrototypeOf(t2, e3) {
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t3, e4) {
+        return t3.__proto__ = e4, t3;
+      }, _setPrototypeOf(t2, e3);
+    }
+    var Root2 = exports["default"] = /* @__PURE__ */ (function(_Container) {
+      _inheritsLoose(Root3, _Container);
+      function Root3(opts) {
+        var _this;
+        _this = _Container.call(this, opts) || this;
+        _this.type = _types.ROOT;
+        return _this;
+      }
+      var _proto = Root3.prototype;
+      _proto._stringify = function _stringify(options, depth, max) {
+        var str = this.reduce(function(memo, selector) {
+          memo.push(selector._stringify(options, depth, max));
+          return memo;
+        }, []).join(",");
+        return this.trailingComma ? str + "," : str;
+      };
+      _proto.error = function error(message, options) {
+        if (this._error) {
+          return this._error(message, options);
+        } else {
+          return new Error(message);
+        }
+      };
+      _createClass(Root3, [{
+        key: "errorGenerator",
+        set: function set(handler4) {
+          this._error = handler4;
+        }
+      }]);
+      return Root3;
+    })(_container["default"]);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/selector.js
+var require_selector = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/selector.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _container = _interopRequireDefault(require_container());
+    var _types = require_types2();
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _inheritsLoose(t2, o) {
+      t2.prototype = Object.create(o.prototype), t2.prototype.constructor = t2, _setPrototypeOf(t2, o);
+    }
+    function _setPrototypeOf(t2, e3) {
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t3, e4) {
+        return t3.__proto__ = e4, t3;
+      }, _setPrototypeOf(t2, e3);
+    }
+    var Selector = exports["default"] = /* @__PURE__ */ (function(_Container) {
+      _inheritsLoose(Selector2, _Container);
+      function Selector2(opts) {
+        var _this;
+        _this = _Container.call(this, opts) || this;
+        _this.type = _types.SELECTOR;
+        return _this;
+      }
+      return Selector2;
+    })(_container["default"]);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/cssesc@3.0.0/node_modules/cssesc/cssesc.js
+var require_cssesc = __commonJS({
+  "../../node_modules/.bun/cssesc@3.0.0/node_modules/cssesc/cssesc.js"(exports, module) {
+    "use strict";
+    var object = {};
+    var hasOwnProperty2 = object.hasOwnProperty;
+    var merge = function merge2(options, defaults) {
+      if (!options) {
+        return defaults;
+      }
+      var result = {};
+      for (var key2 in defaults) {
+        result[key2] = hasOwnProperty2.call(options, key2) ? options[key2] : defaults[key2];
+      }
+      return result;
+    };
+    var regexAnySingleEscape = /[ -,\.\/:-@\[-\^`\{-~]/;
+    var regexSingleEscape = /[ -,\.\/:-@\[\]\^`\{-~]/;
+    var regexExcessiveSpaces = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g;
+    var cssesc = function cssesc2(string, options) {
+      options = merge(options, cssesc2.options);
+      if (options.quotes != "single" && options.quotes != "double") {
+        options.quotes = "single";
+      }
+      var quote = options.quotes == "double" ? '"' : "'";
+      var isIdentifier = options.isIdentifier;
+      var firstChar = string.charAt(0);
+      var output = "";
+      var counter = 0;
+      var length = string.length;
+      while (counter < length) {
+        var character = string.charAt(counter++);
+        var codePoint = character.charCodeAt();
+        var value = void 0;
+        if (codePoint < 32 || codePoint > 126) {
+          if (codePoint >= 55296 && codePoint <= 56319 && counter < length) {
+            var extra = string.charCodeAt(counter++);
+            if ((extra & 64512) == 56320) {
+              codePoint = ((codePoint & 1023) << 10) + (extra & 1023) + 65536;
+            } else {
+              counter--;
+            }
+          }
+          value = "\\" + codePoint.toString(16).toUpperCase() + " ";
+        } else {
+          if (options.escapeEverything) {
+            if (regexAnySingleEscape.test(character)) {
+              value = "\\" + character;
+            } else {
+              value = "\\" + codePoint.toString(16).toUpperCase() + " ";
+            }
+          } else if (/[\t\n\f\r\x0B]/.test(character)) {
+            value = "\\" + codePoint.toString(16).toUpperCase() + " ";
+          } else if (character == "\\" || !isIdentifier && (character == '"' && quote == character || character == "'" && quote == character) || isIdentifier && regexSingleEscape.test(character)) {
+            value = "\\" + character;
+          } else {
+            value = character;
+          }
+        }
+        output += value;
+      }
+      if (isIdentifier) {
+        if (/^-[-\d]/.test(output)) {
+          output = "\\-" + output.slice(1);
+        } else if (/\d/.test(firstChar)) {
+          output = "\\3" + firstChar + " " + output.slice(1);
+        }
+      }
+      output = output.replace(regexExcessiveSpaces, function($0, $1, $22) {
+        if ($1 && $1.length % 2) {
+          return $0;
+        }
+        return ($1 || "") + $22;
+      });
+      if (!isIdentifier && options.wrap) {
+        return quote + output + quote;
+      }
+      return output;
+    };
+    cssesc.options = {
+      "escapeEverything": false,
+      "isIdentifier": false,
+      "quotes": "single",
+      "wrap": false
+    };
+    cssesc.version = "3.0.0";
+    module.exports = cssesc;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/className.js
+var require_className = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/className.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _cssesc = _interopRequireDefault(require_cssesc());
+    var _util = require_util3();
+    var _node = _interopRequireDefault(require_node());
+    var _types = require_types2();
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _defineProperties(e3, r2) {
+      for (var t2 = 0; t2 < r2.length; t2++) {
+        var o = r2[t2];
+        o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e3, _toPropertyKey(o.key), o);
+      }
+    }
+    function _createClass(e3, r2, t2) {
+      return r2 && _defineProperties(e3.prototype, r2), t2 && _defineProperties(e3, t2), Object.defineProperty(e3, "prototype", { writable: false }), e3;
+    }
+    function _toPropertyKey(t2) {
+      var i2 = _toPrimitive(t2, "string");
+      return "symbol" == typeof i2 ? i2 : i2 + "";
+    }
+    function _toPrimitive(t2, r2) {
+      if ("object" != typeof t2 || !t2) return t2;
+      var e3 = t2[Symbol.toPrimitive];
+      if (void 0 !== e3) {
+        var i2 = e3.call(t2, r2 || "default");
+        if ("object" != typeof i2) return i2;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return ("string" === r2 ? String : Number)(t2);
+    }
+    function _inheritsLoose(t2, o) {
+      t2.prototype = Object.create(o.prototype), t2.prototype.constructor = t2, _setPrototypeOf(t2, o);
+    }
+    function _setPrototypeOf(t2, e3) {
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t3, e4) {
+        return t3.__proto__ = e4, t3;
+      }, _setPrototypeOf(t2, e3);
+    }
+    var ClassName = exports["default"] = /* @__PURE__ */ (function(_Node) {
+      _inheritsLoose(ClassName2, _Node);
+      function ClassName2(opts) {
+        var _this;
+        _this = _Node.call(this, opts) || this;
+        _this.type = _types.CLASS;
+        _this._constructed = true;
+        return _this;
+      }
+      var _proto = ClassName2.prototype;
+      _proto.valueToString = function valueToString() {
+        return "." + _Node.prototype.valueToString.call(this);
+      };
+      _createClass(ClassName2, [{
+        key: "value",
+        get: function get() {
+          return this._value;
+        },
+        set: function set(v2) {
+          if (this._constructed) {
+            var escaped = (0, _cssesc["default"])(v2, {
+              isIdentifier: true
+            });
+            if (escaped !== v2) {
+              (0, _util.ensureObject)(this, "raws");
+              this.raws.value = escaped;
+            } else if (this.raws) {
+              delete this.raws.value;
+            }
+          }
+          this._value = v2;
+        }
+      }]);
+      return ClassName2;
+    })(_node["default"]);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/comment.js
+var require_comment = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/comment.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _node = _interopRequireDefault(require_node());
+    var _types = require_types2();
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _inheritsLoose(t2, o) {
+      t2.prototype = Object.create(o.prototype), t2.prototype.constructor = t2, _setPrototypeOf(t2, o);
+    }
+    function _setPrototypeOf(t2, e3) {
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t3, e4) {
+        return t3.__proto__ = e4, t3;
+      }, _setPrototypeOf(t2, e3);
+    }
+    var Comment5 = exports["default"] = /* @__PURE__ */ (function(_Node) {
+      _inheritsLoose(Comment6, _Node);
+      function Comment6(opts) {
+        var _this;
+        _this = _Node.call(this, opts) || this;
+        _this.type = _types.COMMENT;
+        return _this;
+      }
+      return Comment6;
+    })(_node["default"]);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/id.js
+var require_id = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/id.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _node = _interopRequireDefault(require_node());
+    var _types = require_types2();
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _inheritsLoose(t2, o) {
+      t2.prototype = Object.create(o.prototype), t2.prototype.constructor = t2, _setPrototypeOf(t2, o);
+    }
+    function _setPrototypeOf(t2, e3) {
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t3, e4) {
+        return t3.__proto__ = e4, t3;
+      }, _setPrototypeOf(t2, e3);
+    }
+    var ID = exports["default"] = /* @__PURE__ */ (function(_Node) {
+      _inheritsLoose(ID2, _Node);
+      function ID2(opts) {
+        var _this;
+        _this = _Node.call(this, opts) || this;
+        _this.type = _types.ID;
+        return _this;
+      }
+      var _proto = ID2.prototype;
+      _proto.valueToString = function valueToString() {
+        return "#" + _Node.prototype.valueToString.call(this);
+      };
+      return ID2;
+    })(_node["default"]);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/namespace.js
+var require_namespace = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/namespace.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _cssesc = _interopRequireDefault(require_cssesc());
+    var _util = require_util3();
+    var _node = _interopRequireDefault(require_node());
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _defineProperties(e3, r2) {
+      for (var t2 = 0; t2 < r2.length; t2++) {
+        var o = r2[t2];
+        o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e3, _toPropertyKey(o.key), o);
+      }
+    }
+    function _createClass(e3, r2, t2) {
+      return r2 && _defineProperties(e3.prototype, r2), t2 && _defineProperties(e3, t2), Object.defineProperty(e3, "prototype", { writable: false }), e3;
+    }
+    function _toPropertyKey(t2) {
+      var i2 = _toPrimitive(t2, "string");
+      return "symbol" == typeof i2 ? i2 : i2 + "";
+    }
+    function _toPrimitive(t2, r2) {
+      if ("object" != typeof t2 || !t2) return t2;
+      var e3 = t2[Symbol.toPrimitive];
+      if (void 0 !== e3) {
+        var i2 = e3.call(t2, r2 || "default");
+        if ("object" != typeof i2) return i2;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return ("string" === r2 ? String : Number)(t2);
+    }
+    function _inheritsLoose(t2, o) {
+      t2.prototype = Object.create(o.prototype), t2.prototype.constructor = t2, _setPrototypeOf(t2, o);
+    }
+    function _setPrototypeOf(t2, e3) {
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t3, e4) {
+        return t3.__proto__ = e4, t3;
+      }, _setPrototypeOf(t2, e3);
+    }
+    var Namespace = exports["default"] = /* @__PURE__ */ (function(_Node) {
+      _inheritsLoose(Namespace2, _Node);
+      function Namespace2() {
+        return _Node.apply(this, arguments) || this;
+      }
+      var _proto = Namespace2.prototype;
+      _proto.qualifiedName = function qualifiedName(value) {
+        if (this.namespace) {
+          return this.namespaceString + "|" + value;
+        } else {
+          return value;
+        }
+      };
+      _proto.valueToString = function valueToString() {
+        return this.qualifiedName(_Node.prototype.valueToString.call(this));
+      };
+      _createClass(Namespace2, [{
+        key: "namespace",
+        get: function get() {
+          return this._namespace;
+        },
+        set: function set(namespace) {
+          if (namespace === true || namespace === "*" || namespace === "&") {
+            this._namespace = namespace;
+            if (this.raws) {
+              delete this.raws.namespace;
+            }
+            return;
+          }
+          var escaped = (0, _cssesc["default"])(namespace, {
+            isIdentifier: true
+          });
+          this._namespace = namespace;
+          if (escaped !== namespace) {
+            (0, _util.ensureObject)(this, "raws");
+            this.raws.namespace = escaped;
+          } else if (this.raws) {
+            delete this.raws.namespace;
+          }
+        }
+      }, {
+        key: "ns",
+        get: function get() {
+          return this._namespace;
+        },
+        set: function set(namespace) {
+          this.namespace = namespace;
+        }
+      }, {
+        key: "namespaceString",
+        get: function get() {
+          if (this.namespace) {
+            var ns = this.stringifyProperty("namespace");
+            if (ns === true) {
+              return "";
+            } else {
+              return ns;
+            }
+          } else {
+            return "";
+          }
+        }
+      }]);
+      return Namespace2;
+    })(_node["default"]);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/tag.js
+var require_tag = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/tag.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _namespace = _interopRequireDefault(require_namespace());
+    var _types = require_types2();
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _inheritsLoose(t2, o) {
+      t2.prototype = Object.create(o.prototype), t2.prototype.constructor = t2, _setPrototypeOf(t2, o);
+    }
+    function _setPrototypeOf(t2, e3) {
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t3, e4) {
+        return t3.__proto__ = e4, t3;
+      }, _setPrototypeOf(t2, e3);
+    }
+    var Tag2 = exports["default"] = /* @__PURE__ */ (function(_Namespace) {
+      _inheritsLoose(Tag3, _Namespace);
+      function Tag3(opts) {
+        var _this;
+        _this = _Namespace.call(this, opts) || this;
+        _this.type = _types.TAG;
+        return _this;
+      }
+      return Tag3;
+    })(_namespace["default"]);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/string.js
+var require_string = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/string.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _node = _interopRequireDefault(require_node());
+    var _types = require_types2();
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _inheritsLoose(t2, o) {
+      t2.prototype = Object.create(o.prototype), t2.prototype.constructor = t2, _setPrototypeOf(t2, o);
+    }
+    function _setPrototypeOf(t2, e3) {
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t3, e4) {
+        return t3.__proto__ = e4, t3;
+      }, _setPrototypeOf(t2, e3);
+    }
+    var String2 = exports["default"] = /* @__PURE__ */ (function(_Node) {
+      _inheritsLoose(String3, _Node);
+      function String3(opts) {
+        var _this;
+        _this = _Node.call(this, opts) || this;
+        _this.type = _types.STRING;
+        return _this;
+      }
+      return String3;
+    })(_node["default"]);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/pseudo.js
+var require_pseudo = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/pseudo.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _container = _interopRequireDefault(require_container());
+    var _types = require_types2();
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _inheritsLoose(t2, o) {
+      t2.prototype = Object.create(o.prototype), t2.prototype.constructor = t2, _setPrototypeOf(t2, o);
+    }
+    function _setPrototypeOf(t2, e3) {
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t3, e4) {
+        return t3.__proto__ = e4, t3;
+      }, _setPrototypeOf(t2, e3);
+    }
+    var Pseudo = exports["default"] = /* @__PURE__ */ (function(_Container) {
+      _inheritsLoose(Pseudo2, _Container);
+      function Pseudo2(opts) {
+        var _this;
+        _this = _Container.call(this, opts) || this;
+        _this.type = _types.PSEUDO;
+        return _this;
+      }
+      var _proto = Pseudo2.prototype;
+      _proto._stringify = function _stringify(options, depth, max) {
+        if (depth >= max) {
+          throw new Error("Cannot serialize selector: nesting depth exceeds the maximum of " + max + ".");
+        }
+        var params = this.length ? "(" + this.map(function(child) {
+          return child._stringify(options, depth + 1, max);
+        }).join(",") + ")" : "";
+        return [this.rawSpaceBefore, this.stringifyProperty("value"), params, this.rawSpaceAfter].join("");
+      };
+      return Pseudo2;
+    })(_container["default"]);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/util-deprecate@1.0.2/node_modules/util-deprecate/node.js
+var require_node2 = __commonJS({
+  "../../node_modules/.bun/util-deprecate@1.0.2/node_modules/util-deprecate/node.js"(exports, module) {
+    "use strict";
+    module.exports = __require("util").deprecate;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/attribute.js
+var require_attribute = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/attribute.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    exports.unescapeValue = unescapeValue;
+    var _cssesc = _interopRequireDefault(require_cssesc());
+    var _unesc = _interopRequireDefault(require_unesc());
+    var _namespace = _interopRequireDefault(require_namespace());
+    var _types = require_types2();
+    var _CSSESC_QUOTE_OPTIONS;
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _defineProperties(e3, r2) {
+      for (var t2 = 0; t2 < r2.length; t2++) {
+        var o = r2[t2];
+        o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e3, _toPropertyKey(o.key), o);
+      }
+    }
+    function _createClass(e3, r2, t2) {
+      return r2 && _defineProperties(e3.prototype, r2), t2 && _defineProperties(e3, t2), Object.defineProperty(e3, "prototype", { writable: false }), e3;
+    }
+    function _toPropertyKey(t2) {
+      var i2 = _toPrimitive(t2, "string");
+      return "symbol" == typeof i2 ? i2 : i2 + "";
+    }
+    function _toPrimitive(t2, r2) {
+      if ("object" != typeof t2 || !t2) return t2;
+      var e3 = t2[Symbol.toPrimitive];
+      if (void 0 !== e3) {
+        var i2 = e3.call(t2, r2 || "default");
+        if ("object" != typeof i2) return i2;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return ("string" === r2 ? String : Number)(t2);
+    }
+    function _inheritsLoose(t2, o) {
+      t2.prototype = Object.create(o.prototype), t2.prototype.constructor = t2, _setPrototypeOf(t2, o);
+    }
+    function _setPrototypeOf(t2, e3) {
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t3, e4) {
+        return t3.__proto__ = e4, t3;
+      }, _setPrototypeOf(t2, e3);
+    }
+    var deprecate3 = require_node2();
+    var WRAPPED_IN_QUOTES = /^('|")([^]*)\1$/;
+    var warnOfDeprecatedValueAssignment = deprecate3(function() {
+    }, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. Call attribute.setValue() instead.");
+    var warnOfDeprecatedQuotedAssignment = deprecate3(function() {
+    }, "Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead.");
+    var warnOfDeprecatedConstructor = deprecate3(function() {
+    }, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.");
+    function unescapeValue(value) {
+      var deprecatedUsage = false;
+      var quoteMark = null;
+      var unescaped = value;
+      var m2 = unescaped.match(WRAPPED_IN_QUOTES);
+      if (m2) {
+        quoteMark = m2[1];
+        unescaped = m2[2];
+      }
+      unescaped = (0, _unesc["default"])(unescaped);
+      if (unescaped !== value) {
+        deprecatedUsage = true;
+      }
+      return {
+        deprecatedUsage,
+        unescaped,
+        quoteMark
+      };
+    }
+    function handleDeprecatedContructorOpts(opts) {
+      if (opts.quoteMark !== void 0) {
+        return opts;
+      }
+      if (opts.value === void 0) {
+        return opts;
+      }
+      warnOfDeprecatedConstructor();
+      var _unescapeValue = unescapeValue(opts.value), quoteMark = _unescapeValue.quoteMark, unescaped = _unescapeValue.unescaped;
+      if (!opts.raws) {
+        opts.raws = {};
+      }
+      if (opts.raws.value === void 0) {
+        opts.raws.value = opts.value;
+      }
+      opts.value = unescaped;
+      opts.quoteMark = quoteMark;
+      return opts;
+    }
+    var Attribute = exports["default"] = /* @__PURE__ */ (function(_Namespace) {
+      _inheritsLoose(Attribute2, _Namespace);
+      function Attribute2(opts) {
+        var _this;
+        if (opts === void 0) {
+          opts = {};
+        }
+        _this = _Namespace.call(this, handleDeprecatedContructorOpts(opts)) || this;
+        _this.type = _types.ATTRIBUTE;
+        _this.raws = _this.raws || {};
+        Object.defineProperty(_this.raws, "unquoted", {
+          get: deprecate3(function() {
+            return _this.value;
+          }, "attr.raws.unquoted is deprecated. Call attr.value instead."),
+          set: deprecate3(function() {
+            return _this.value;
+          }, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now.")
+        });
+        _this._constructed = true;
+        return _this;
+      }
+      var _proto = Attribute2.prototype;
+      _proto.getQuotedValue = function getQuotedValue(options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var quoteMark = this._determineQuoteMark(options);
+        var cssescopts = CSSESC_QUOTE_OPTIONS[quoteMark];
+        var escaped = (0, _cssesc["default"])(this._value, cssescopts);
+        return escaped;
+      };
+      _proto._determineQuoteMark = function _determineQuoteMark(options) {
+        return options.smart ? this.smartQuoteMark(options) : this.preferredQuoteMark(options);
+      };
+      _proto.setValue = function setValue(value, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        this._value = value;
+        this._quoteMark = this._determineQuoteMark(options);
+        this._syncRawValue();
+      };
+      _proto.smartQuoteMark = function smartQuoteMark(options) {
+        var v2 = this.value;
+        var numSingleQuotes = v2.replace(/[^']/g, "").length;
+        var numDoubleQuotes = v2.replace(/[^"]/g, "").length;
+        if (numSingleQuotes + numDoubleQuotes === 0) {
+          var escaped = (0, _cssesc["default"])(v2, {
+            isIdentifier: true
+          });
+          if (escaped === v2) {
+            return Attribute2.NO_QUOTE;
+          } else {
+            var pref = this.preferredQuoteMark(options);
+            if (pref === Attribute2.NO_QUOTE) {
+              var quote = this.quoteMark || options.quoteMark || Attribute2.DOUBLE_QUOTE;
+              var opts = CSSESC_QUOTE_OPTIONS[quote];
+              var quoteValue = (0, _cssesc["default"])(v2, opts);
+              if (quoteValue.length < escaped.length) {
+                return quote;
+              }
+            }
+            return pref;
+          }
+        } else if (numDoubleQuotes === numSingleQuotes) {
+          return this.preferredQuoteMark(options);
+        } else if (numDoubleQuotes < numSingleQuotes) {
+          return Attribute2.DOUBLE_QUOTE;
+        } else {
+          return Attribute2.SINGLE_QUOTE;
+        }
+      };
+      _proto.preferredQuoteMark = function preferredQuoteMark(options) {
+        var quoteMark = options.preferCurrentQuoteMark ? this.quoteMark : options.quoteMark;
+        if (quoteMark === void 0) {
+          quoteMark = options.preferCurrentQuoteMark ? options.quoteMark : this.quoteMark;
+        }
+        if (quoteMark === void 0) {
+          quoteMark = Attribute2.DOUBLE_QUOTE;
+        }
+        return quoteMark;
+      };
+      _proto._syncRawValue = function _syncRawValue() {
+        var rawValue = (0, _cssesc["default"])(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]);
+        if (rawValue === this._value) {
+          if (this.raws) {
+            delete this.raws.value;
+          }
+        } else {
+          this.raws.value = rawValue;
+        }
+      };
+      _proto._handleEscapes = function _handleEscapes(prop2, value) {
+        if (this._constructed) {
+          var escaped = (0, _cssesc["default"])(value, {
+            isIdentifier: true
+          });
+          if (escaped !== value) {
+            this.raws[prop2] = escaped;
+          } else {
+            delete this.raws[prop2];
+          }
+        }
+      };
+      _proto._spacesFor = function _spacesFor(name) {
+        var attrSpaces = {
+          before: "",
+          after: ""
+        };
+        var spaces = this.spaces[name] || {};
+        var rawSpaces = this.raws.spaces && this.raws.spaces[name] || {};
+        return Object.assign(attrSpaces, spaces, rawSpaces);
+      };
+      _proto._stringFor = function _stringFor(name, spaceName, concat) {
+        if (spaceName === void 0) {
+          spaceName = name;
+        }
+        if (concat === void 0) {
+          concat = defaultAttrConcat;
+        }
+        var attrSpaces = this._spacesFor(spaceName);
+        return concat(this.stringifyProperty(name), attrSpaces);
+      };
+      _proto.offsetOf = function offsetOf(name) {
+        var count = 1;
+        var attributeSpaces = this._spacesFor("attribute");
+        count += attributeSpaces.before.length;
+        if (name === "namespace" || name === "ns") {
+          return this.namespace ? count : -1;
+        }
+        if (name === "attributeNS") {
+          return count;
+        }
+        count += this.namespaceString.length;
+        if (this.namespace) {
+          count += 1;
+        }
+        if (name === "attribute") {
+          return count;
+        }
+        count += this.stringifyProperty("attribute").length;
+        count += attributeSpaces.after.length;
+        var operatorSpaces = this._spacesFor("operator");
+        count += operatorSpaces.before.length;
+        var operator = this.stringifyProperty("operator");
+        if (name === "operator") {
+          return operator ? count : -1;
+        }
+        count += operator.length;
+        count += operatorSpaces.after.length;
+        var valueSpaces = this._spacesFor("value");
+        count += valueSpaces.before.length;
+        var value = this.stringifyProperty("value");
+        if (name === "value") {
+          return value ? count : -1;
+        }
+        count += value.length;
+        count += valueSpaces.after.length;
+        var insensitiveSpaces = this._spacesFor("insensitive");
+        count += insensitiveSpaces.before.length;
+        if (name === "insensitive") {
+          return this.insensitive ? count : -1;
+        }
+        return -1;
+      };
+      _proto.toString = function toString2() {
+        var _this2 = this;
+        var selector = [this.rawSpaceBefore, "["];
+        selector.push(this._stringFor("qualifiedAttribute", "attribute"));
+        if (this.operator && (this.value || this.value === "")) {
+          selector.push(this._stringFor("operator"));
+          selector.push(this._stringFor("value"));
+          selector.push(this._stringFor("insensitiveFlag", "insensitive", function(attrValue, attrSpaces) {
+            if (attrValue.length > 0 && !_this2.quoted && attrSpaces.before.length === 0 && !(_this2.spaces.value && _this2.spaces.value.after)) {
+              attrSpaces.before = " ";
+            }
+            return defaultAttrConcat(attrValue, attrSpaces);
+          }));
+        }
+        selector.push("]");
+        selector.push(this.rawSpaceAfter);
+        return selector.join("");
+      };
+      _createClass(Attribute2, [{
+        key: "quoted",
+        get: function get() {
+          var qm = this.quoteMark;
+          return qm === "'" || qm === '"';
+        },
+        set: function set(value) {
+          warnOfDeprecatedQuotedAssignment();
+        }
+        /**
+         * returns a single (`'`) or double (`"`) quote character if the value is quoted.
+         * returns `null` if the value is not quoted.
+         * returns `undefined` if the quotation state is unknown (this can happen when
+         * the attribute is constructed without specifying a quote mark.)
+         */
+      }, {
+        key: "quoteMark",
+        get: function get() {
+          return this._quoteMark;
+        },
+        set: function set(quoteMark) {
+          if (!this._constructed) {
+            this._quoteMark = quoteMark;
+            return;
+          }
+          if (this._quoteMark !== quoteMark) {
+            this._quoteMark = quoteMark;
+            this._syncRawValue();
+          }
+        }
+      }, {
+        key: "qualifiedAttribute",
+        get: function get() {
+          return this.qualifiedName(this.raws.attribute || this.attribute);
+        }
+      }, {
+        key: "insensitiveFlag",
+        get: function get() {
+          return this.insensitive ? "i" : "";
+        }
+      }, {
+        key: "value",
+        get: function get() {
+          return this._value;
+        },
+        set: (
+          /**
+           * Before 3.0, the value had to be set to an escaped value including any wrapped
+           * quote marks. In 3.0, the semantics of `Attribute.value` changed so that the value
+           * is unescaped during parsing and any quote marks are removed.
+           *
+           * Because the ambiguity of this semantic change, if you set `attr.value = newValue`,
+           * a deprecation warning is raised when the new value contains any characters that would
+           * require escaping (including if it contains wrapped quotes).
+           *
+           * Instead, you should call `attr.setValue(newValue, opts)` and pass options that describe
+           * how the new value is quoted.
+           */
+          function set(v2) {
+            if (this._constructed) {
+              var _unescapeValue2 = unescapeValue(v2), deprecatedUsage = _unescapeValue2.deprecatedUsage, unescaped = _unescapeValue2.unescaped, quoteMark = _unescapeValue2.quoteMark;
+              if (deprecatedUsage) {
+                warnOfDeprecatedValueAssignment();
+              }
+              if (unescaped === this._value && quoteMark === this._quoteMark) {
+                return;
+              }
+              this._value = unescaped;
+              this._quoteMark = quoteMark;
+              this._syncRawValue();
+            } else {
+              this._value = v2;
+            }
+          }
+        )
+      }, {
+        key: "insensitive",
+        get: function get() {
+          return this._insensitive;
+        },
+        set: function set(insensitive) {
+          if (!insensitive) {
+            this._insensitive = false;
+            if (this.raws && (this.raws.insensitiveFlag === "I" || this.raws.insensitiveFlag === "i")) {
+              this.raws.insensitiveFlag = void 0;
+            }
+          }
+          this._insensitive = insensitive;
+        }
+      }, {
+        key: "attribute",
+        get: function get() {
+          return this._attribute;
+        },
+        set: function set(name) {
+          this._handleEscapes("attribute", name);
+          this._attribute = name;
+        }
+      }]);
+      return Attribute2;
+    })(_namespace["default"]);
+    Attribute.NO_QUOTE = null;
+    Attribute.SINGLE_QUOTE = "'";
+    Attribute.DOUBLE_QUOTE = '"';
+    var CSSESC_QUOTE_OPTIONS = (_CSSESC_QUOTE_OPTIONS = {
+      "'": {
+        quotes: "single",
+        wrap: true
+      },
+      '"': {
+        quotes: "double",
+        wrap: true
+      }
+    }, _CSSESC_QUOTE_OPTIONS[null] = {
+      isIdentifier: true
+    }, _CSSESC_QUOTE_OPTIONS);
+    function defaultAttrConcat(attrValue, attrSpaces) {
+      return "" + attrSpaces.before + attrValue + attrSpaces.after;
+    }
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/universal.js
+var require_universal = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/universal.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _namespace = _interopRequireDefault(require_namespace());
+    var _types = require_types2();
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _inheritsLoose(t2, o) {
+      t2.prototype = Object.create(o.prototype), t2.prototype.constructor = t2, _setPrototypeOf(t2, o);
+    }
+    function _setPrototypeOf(t2, e3) {
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t3, e4) {
+        return t3.__proto__ = e4, t3;
+      }, _setPrototypeOf(t2, e3);
+    }
+    var Universal = exports["default"] = /* @__PURE__ */ (function(_Namespace) {
+      _inheritsLoose(Universal2, _Namespace);
+      function Universal2(opts) {
+        var _this;
+        _this = _Namespace.call(this, opts) || this;
+        _this.type = _types.UNIVERSAL;
+        _this.value = "*";
+        return _this;
+      }
+      return Universal2;
+    })(_namespace["default"]);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/combinator.js
+var require_combinator = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/combinator.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _node = _interopRequireDefault(require_node());
+    var _types = require_types2();
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _inheritsLoose(t2, o) {
+      t2.prototype = Object.create(o.prototype), t2.prototype.constructor = t2, _setPrototypeOf(t2, o);
+    }
+    function _setPrototypeOf(t2, e3) {
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t3, e4) {
+        return t3.__proto__ = e4, t3;
+      }, _setPrototypeOf(t2, e3);
+    }
+    var Combinator = exports["default"] = /* @__PURE__ */ (function(_Node) {
+      _inheritsLoose(Combinator2, _Node);
+      function Combinator2(opts) {
+        var _this;
+        _this = _Node.call(this, opts) || this;
+        _this.type = _types.COMBINATOR;
+        return _this;
+      }
+      return Combinator2;
+    })(_node["default"]);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/nesting.js
+var require_nesting = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/nesting.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _node = _interopRequireDefault(require_node());
+    var _types = require_types2();
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _inheritsLoose(t2, o) {
+      t2.prototype = Object.create(o.prototype), t2.prototype.constructor = t2, _setPrototypeOf(t2, o);
+    }
+    function _setPrototypeOf(t2, e3) {
+      return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t3, e4) {
+        return t3.__proto__ = e4, t3;
+      }, _setPrototypeOf(t2, e3);
+    }
+    var Nesting = exports["default"] = /* @__PURE__ */ (function(_Node) {
+      _inheritsLoose(Nesting2, _Node);
+      function Nesting2(opts) {
+        var _this;
+        _this = _Node.call(this, opts) || this;
+        _this.type = _types.NESTING;
+        _this.value = "&";
+        return _this;
+      }
+      return Nesting2;
+    })(_node["default"]);
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/sortAscending.js
+var require_sortAscending = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/sortAscending.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = sortAscending;
+    function sortAscending(list) {
+      return list.sort(function(a, b2) {
+        return a - b2;
+      });
+    }
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/tokenTypes.js
+var require_tokenTypes = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/tokenTypes.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.word = exports.tilde = exports.tab = exports.str = exports.space = exports.slash = exports.singleQuote = exports.semicolon = exports.plus = exports.pipe = exports.openSquare = exports.openParenthesis = exports.newline = exports.greaterThan = exports.feed = exports.equals = exports.doubleQuote = exports.dollar = exports.cr = exports.comment = exports.comma = exports.combinator = exports.colon = exports.closeSquare = exports.closeParenthesis = exports.caret = exports.bang = exports.backslash = exports.at = exports.asterisk = exports.ampersand = void 0;
+    var ampersand = exports.ampersand = 38;
+    var asterisk = exports.asterisk = 42;
+    var at3 = exports.at = 64;
+    var comma = exports.comma = 44;
+    var colon = exports.colon = 58;
+    var semicolon = exports.semicolon = 59;
+    var openParenthesis = exports.openParenthesis = 40;
+    var closeParenthesis = exports.closeParenthesis = 41;
+    var openSquare = exports.openSquare = 91;
+    var closeSquare = exports.closeSquare = 93;
+    var dollar = exports.dollar = 36;
+    var tilde = exports.tilde = 126;
+    var caret = exports.caret = 94;
+    var plus = exports.plus = 43;
+    var equals = exports.equals = 61;
+    var pipe = exports.pipe = 124;
+    var greaterThan = exports.greaterThan = 62;
+    var space = exports.space = 32;
+    var singleQuote = exports.singleQuote = 39;
+    var doubleQuote = exports.doubleQuote = 34;
+    var slash = exports.slash = 47;
+    var bang = exports.bang = 33;
+    var backslash = exports.backslash = 92;
+    var cr = exports.cr = 13;
+    var feed = exports.feed = 12;
+    var newline = exports.newline = 10;
+    var tab = exports.tab = 9;
+    var str = exports.str = singleQuote;
+    var comment = exports.comment = -1;
+    var word = exports.word = -2;
+    var combinator = exports.combinator = -3;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/tokenize.js
+var require_tokenize = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/tokenize.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.FIELDS = void 0;
+    exports["default"] = tokenize;
+    var t2 = _interopRequireWildcard(require_tokenTypes());
+    var _unescapable;
+    var _wordDelimiters;
+    function _interopRequireWildcard(e3, t3) {
+      if ("function" == typeof WeakMap) var r2 = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap();
+      return (_interopRequireWildcard = function _interopRequireWildcard2(e4, t4) {
+        if (!t4 && e4 && e4.__esModule) return e4;
+        var o, i3, f3 = { __proto__: null, "default": e4 };
+        if (null === e4 || "object" != typeof e4 && "function" != typeof e4) return f3;
+        if (o = t4 ? n : r2) {
+          if (o.has(e4)) return o.get(e4);
+          o.set(e4, f3);
+        }
+        for (var _t2 in e4) {
+          "default" !== _t2 && {}.hasOwnProperty.call(e4, _t2) && ((i3 = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e4, _t2)) && (i3.get || i3.set) ? o(f3, _t2, i3) : f3[_t2] = e4[_t2]);
+        }
+        return f3;
+      })(e3, t3);
+    }
+    var unescapable = (_unescapable = {}, _unescapable[t2.tab] = true, _unescapable[t2.newline] = true, _unescapable[t2.cr] = true, _unescapable[t2.feed] = true, _unescapable);
+    var wordDelimiters = (_wordDelimiters = {}, _wordDelimiters[t2.space] = true, _wordDelimiters[t2.tab] = true, _wordDelimiters[t2.newline] = true, _wordDelimiters[t2.cr] = true, _wordDelimiters[t2.feed] = true, _wordDelimiters[t2.ampersand] = true, _wordDelimiters[t2.asterisk] = true, _wordDelimiters[t2.bang] = true, _wordDelimiters[t2.comma] = true, _wordDelimiters[t2.colon] = true, _wordDelimiters[t2.semicolon] = true, _wordDelimiters[t2.openParenthesis] = true, _wordDelimiters[t2.closeParenthesis] = true, _wordDelimiters[t2.openSquare] = true, _wordDelimiters[t2.closeSquare] = true, _wordDelimiters[t2.singleQuote] = true, _wordDelimiters[t2.doubleQuote] = true, _wordDelimiters[t2.plus] = true, _wordDelimiters[t2.pipe] = true, _wordDelimiters[t2.tilde] = true, _wordDelimiters[t2.greaterThan] = true, _wordDelimiters[t2.equals] = true, _wordDelimiters[t2.dollar] = true, _wordDelimiters[t2.caret] = true, _wordDelimiters[t2.slash] = true, _wordDelimiters);
+    var hex = {};
+    var hexChars = "0123456789abcdefABCDEF";
+    for (i2 = 0; i2 < hexChars.length; i2++) {
+      hex[hexChars.charCodeAt(i2)] = true;
+    }
+    var i2;
+    function consumeWord(css, start) {
+      var next = start;
+      var code;
+      do {
+        code = css.charCodeAt(next);
+        if (wordDelimiters[code]) {
+          return next - 1;
+        } else if (code === t2.backslash) {
+          next = consumeEscape(css, next) + 1;
+        } else {
+          next++;
+        }
+      } while (next < css.length);
+      return next - 1;
+    }
+    function consumeEscape(css, start) {
+      var next = start;
+      var code = css.charCodeAt(next + 1);
+      if (unescapable[code]) {
+      } else if (hex[code]) {
+        var hexDigits = 0;
+        do {
+          next++;
+          hexDigits++;
+          code = css.charCodeAt(next + 1);
+        } while (hex[code] && hexDigits < 6);
+        if (hexDigits < 6 && code === t2.space) {
+          next++;
+        }
+      } else {
+        next++;
+      }
+      return next;
+    }
+    var FIELDS = exports.FIELDS = {
+      TYPE: 0,
+      START_LINE: 1,
+      START_COL: 2,
+      END_LINE: 3,
+      END_COL: 4,
+      START_POS: 5,
+      END_POS: 6
+    };
+    function tokenize(input2) {
+      var tokens = [];
+      var css = input2.css.valueOf();
+      var _css = css, length = _css.length;
+      var offset = -1;
+      var line = 1;
+      var start = 0;
+      var end = 0;
+      var code, content, endColumn, endLine, escaped, escapePos, last, lines, next, nextLine, nextOffset, quote, tokenType;
+      function unclosed(what, fix) {
+        if (input2.safe) {
+          css += fix;
+          next = css.length - 1;
+        } else {
+          throw input2.error("Unclosed " + what, line, start - offset, start);
+        }
+      }
+      while (start < length) {
+        code = css.charCodeAt(start);
+        if (code === t2.newline) {
+          offset = start;
+          line += 1;
+        }
+        switch (code) {
+          case t2.space:
+          case t2.tab:
+          case t2.newline:
+          case t2.cr:
+          case t2.feed:
+            next = start;
+            do {
+              next += 1;
+              code = css.charCodeAt(next);
+              if (code === t2.newline) {
+                offset = next;
+                line += 1;
+              }
+            } while (code === t2.space || code === t2.newline || code === t2.tab || code === t2.cr || code === t2.feed);
+            tokenType = t2.space;
+            endLine = line;
+            endColumn = next - offset - 1;
+            end = next;
+            break;
+          case t2.plus:
+          case t2.greaterThan:
+          case t2.tilde:
+          case t2.pipe:
+            next = start;
+            do {
+              next += 1;
+              code = css.charCodeAt(next);
+            } while (code === t2.plus || code === t2.greaterThan || code === t2.tilde || code === t2.pipe);
+            tokenType = t2.combinator;
+            endLine = line;
+            endColumn = start - offset;
+            end = next;
+            break;
+          // Consume these characters as single tokens.
+          case t2.asterisk:
+          case t2.ampersand:
+          case t2.bang:
+          case t2.comma:
+          case t2.equals:
+          case t2.dollar:
+          case t2.caret:
+          case t2.openSquare:
+          case t2.closeSquare:
+          case t2.colon:
+          case t2.semicolon:
+          case t2.openParenthesis:
+          case t2.closeParenthesis:
+            next = start;
+            tokenType = code;
+            endLine = line;
+            endColumn = start - offset;
+            end = next + 1;
+            break;
+          case t2.singleQuote:
+          case t2.doubleQuote:
+            quote = code === t2.singleQuote ? "'" : '"';
+            next = start;
+            do {
+              escaped = false;
+              next = css.indexOf(quote, next + 1);
+              if (next === -1) {
+                unclosed("quote", quote);
+              }
+              escapePos = next;
+              while (css.charCodeAt(escapePos - 1) === t2.backslash) {
+                escapePos -= 1;
+                escaped = !escaped;
+              }
+            } while (escaped);
+            tokenType = t2.str;
+            endLine = line;
+            endColumn = start - offset;
+            end = next + 1;
+            break;
+          default:
+            if (code === t2.slash && css.charCodeAt(start + 1) === t2.asterisk) {
+              next = css.indexOf("*/", start + 2) + 1;
+              if (next === 0) {
+                unclosed("comment", "*/");
+              }
+              content = css.slice(start, next + 1);
+              lines = content.split("\n");
+              last = lines.length - 1;
+              if (last > 0) {
+                nextLine = line + last;
+                nextOffset = next - lines[last].length;
+              } else {
+                nextLine = line;
+                nextOffset = offset;
+              }
+              tokenType = t2.comment;
+              line = nextLine;
+              endLine = nextLine;
+              endColumn = next - nextOffset;
+            } else if (code === t2.slash) {
+              next = start;
+              tokenType = code;
+              endLine = line;
+              endColumn = start - offset;
+              end = next + 1;
+            } else {
+              next = consumeWord(css, start);
+              tokenType = t2.word;
+              endLine = line;
+              endColumn = next - offset;
+            }
+            end = next + 1;
+            break;
+        }
+        tokens.push([
+          tokenType,
+          // [0] Token type
+          line,
+          // [1] Starting line
+          start - offset,
+          // [2] Starting column
+          endLine,
+          // [3] Ending line
+          endColumn,
+          // [4] Ending column
+          start,
+          // [5] Start position / Source index
+          end
+          // [6] End position
+        ]);
+        if (nextOffset) {
+          offset = nextOffset;
+          nextOffset = null;
+        }
+        start = end;
+      }
+      return tokens;
+    }
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/parser.js
+var require_parser2 = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/parser.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _root = _interopRequireDefault(require_root());
+    var _selector = _interopRequireDefault(require_selector());
+    var _className = _interopRequireDefault(require_className());
+    var _comment = _interopRequireDefault(require_comment());
+    var _id = _interopRequireDefault(require_id());
+    var _tag = _interopRequireDefault(require_tag());
+    var _string = _interopRequireDefault(require_string());
+    var _pseudo = _interopRequireDefault(require_pseudo());
+    var _attribute = _interopRequireWildcard(require_attribute());
+    var _universal = _interopRequireDefault(require_universal());
+    var _combinator = _interopRequireDefault(require_combinator());
+    var _nesting = _interopRequireDefault(require_nesting());
+    var _sortAscending = _interopRequireDefault(require_sortAscending());
+    var _tokenize = _interopRequireWildcard(require_tokenize());
+    var tokens = _interopRequireWildcard(require_tokenTypes());
+    var types4 = _interopRequireWildcard(require_types2());
+    var _util = require_util3();
+    var _WHITESPACE_TOKENS;
+    var _Object$assign;
+    function _interopRequireWildcard(e3, t2) {
+      if ("function" == typeof WeakMap) var r2 = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap();
+      return (_interopRequireWildcard = function _interopRequireWildcard2(e4, t3) {
+        if (!t3 && e4 && e4.__esModule) return e4;
+        var o, i2, f3 = { __proto__: null, "default": e4 };
+        if (null === e4 || "object" != typeof e4 && "function" != typeof e4) return f3;
+        if (o = t3 ? n : r2) {
+          if (o.has(e4)) return o.get(e4);
+          o.set(e4, f3);
+        }
+        for (var _t2 in e4) {
+          "default" !== _t2 && {}.hasOwnProperty.call(e4, _t2) && ((i2 = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e4, _t2)) && (i2.get || i2.set) ? o(f3, _t2, i2) : f3[_t2] = e4[_t2]);
+        }
+        return f3;
+      })(e3, t2);
+    }
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    function _defineProperties(e3, r2) {
+      for (var t2 = 0; t2 < r2.length; t2++) {
+        var o = r2[t2];
+        o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e3, _toPropertyKey(o.key), o);
+      }
+    }
+    function _createClass(e3, r2, t2) {
+      return r2 && _defineProperties(e3.prototype, r2), t2 && _defineProperties(e3, t2), Object.defineProperty(e3, "prototype", { writable: false }), e3;
+    }
+    function _toPropertyKey(t2) {
+      var i2 = _toPrimitive(t2, "string");
+      return "symbol" == typeof i2 ? i2 : i2 + "";
+    }
+    function _toPrimitive(t2, r2) {
+      if ("object" != typeof t2 || !t2) return t2;
+      var e3 = t2[Symbol.toPrimitive];
+      if (void 0 !== e3) {
+        var i2 = e3.call(t2, r2 || "default");
+        if ("object" != typeof i2) return i2;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return ("string" === r2 ? String : Number)(t2);
+    }
+    var WHITESPACE_TOKENS = (_WHITESPACE_TOKENS = {}, _WHITESPACE_TOKENS[tokens.space] = true, _WHITESPACE_TOKENS[tokens.cr] = true, _WHITESPACE_TOKENS[tokens.feed] = true, _WHITESPACE_TOKENS[tokens.newline] = true, _WHITESPACE_TOKENS[tokens.tab] = true, _WHITESPACE_TOKENS);
+    var WHITESPACE_EQUIV_TOKENS = Object.assign({}, WHITESPACE_TOKENS, (_Object$assign = {}, _Object$assign[tokens.comment] = true, _Object$assign));
+    function tokenStart(token) {
+      return {
+        line: token[_tokenize.FIELDS.START_LINE],
+        column: token[_tokenize.FIELDS.START_COL]
+      };
+    }
+    function tokenEnd(token) {
+      return {
+        line: token[_tokenize.FIELDS.END_LINE],
+        column: token[_tokenize.FIELDS.END_COL]
+      };
+    }
+    function getSource(startLine, startColumn, endLine, endColumn) {
+      return {
+        start: {
+          line: startLine,
+          column: startColumn
+        },
+        end: {
+          line: endLine,
+          column: endColumn
+        }
+      };
+    }
+    function getTokenSource(token) {
+      return getSource(token[_tokenize.FIELDS.START_LINE], token[_tokenize.FIELDS.START_COL], token[_tokenize.FIELDS.END_LINE], token[_tokenize.FIELDS.END_COL]);
+    }
+    function getTokenSourceSpan(startToken, endToken) {
+      if (!startToken) {
+        return void 0;
+      }
+      return getSource(startToken[_tokenize.FIELDS.START_LINE], startToken[_tokenize.FIELDS.START_COL], endToken[_tokenize.FIELDS.END_LINE], endToken[_tokenize.FIELDS.END_COL]);
+    }
+    function unescapeProp(node, prop2) {
+      var value = node[prop2];
+      if (typeof value !== "string") {
+        return;
+      }
+      if (value.indexOf("\\") !== -1) {
+        (0, _util.ensureObject)(node, "raws");
+        node[prop2] = (0, _util.unesc)(value);
+        if (node.raws[prop2] === void 0) {
+          node.raws[prop2] = value;
+        }
+      }
+      return node;
+    }
+    function indexesOf(array, item) {
+      var i2 = -1;
+      var indexes = [];
+      while ((i2 = array.indexOf(item, i2 + 1)) !== -1) {
+        indexes.push(i2);
+      }
+      return indexes;
+    }
+    function uniqs() {
+      var list = Array.prototype.concat.apply([], arguments);
+      return list.filter(function(item, i2) {
+        return i2 === list.indexOf(item);
+      });
+    }
+    var Parser3 = exports["default"] = /* @__PURE__ */ (function() {
+      function Parser4(rule, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        this.rule = rule;
+        this.options = Object.assign({
+          lossy: false,
+          safe: false
+        }, options);
+        this.position = 0;
+        this.nestingDepth = 0;
+        this.maxNestingDepth = (0, _util.resolveMaxNestingDepth)(this.options.maxNestingDepth);
+        this.css = typeof this.rule === "string" ? this.rule : this.rule.selector;
+        this.tokens = (0, _tokenize["default"])({
+          css: this.css,
+          error: this._errorGenerator(),
+          safe: this.options.safe
+        });
+        var rootSource = getTokenSourceSpan(this.tokens[0], this.tokens[this.tokens.length - 1]);
+        this.root = new _root["default"]({
+          source: rootSource
+        });
+        this.root.errorGenerator = this._errorGenerator();
+        var selector = new _selector["default"]({
+          source: {
+            start: {
+              line: 1,
+              column: 1
+            }
+          },
+          sourceIndex: 0
+        });
+        this.root.append(selector);
+        this.current = selector;
+        this.loop();
+      }
+      var _proto = Parser4.prototype;
+      _proto._errorGenerator = function _errorGenerator() {
+        var _this = this;
+        return function(message, errorOptions) {
+          if (typeof _this.rule === "string") {
+            return new Error(message);
+          }
+          return _this.rule.error(message, errorOptions);
+        };
+      };
+      _proto.attribute = function attribute2() {
+        var attr = [];
+        var startingToken = this.currToken;
+        this.position++;
+        while (this.position < this.tokens.length && this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
+          attr.push(this.currToken);
+          this.position++;
+        }
+        if (this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
+          return this.expected("closing square bracket", this.currToken[_tokenize.FIELDS.START_POS]);
+        }
+        var len = attr.length;
+        var node = {
+          source: getSource(startingToken[1], startingToken[2], this.currToken[3], this.currToken[4]),
+          sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
+        };
+        if (len === 1 && !~[tokens.word].indexOf(attr[0][_tokenize.FIELDS.TYPE])) {
+          return this.expected("attribute", attr[0][_tokenize.FIELDS.START_POS]);
+        }
+        var pos = 0;
+        var spaceBefore = "";
+        var commentBefore = "";
+        var lastAdded = null;
+        var spaceAfterMeaningfulToken = false;
+        while (pos < len) {
+          var token = attr[pos];
+          var content = this.content(token);
+          var next = attr[pos + 1];
+          switch (token[_tokenize.FIELDS.TYPE]) {
+            case tokens.space:
+              spaceAfterMeaningfulToken = true;
+              if (this.options.lossy) {
+                break;
+              }
+              if (lastAdded) {
+                (0, _util.ensureObject)(node, "spaces", lastAdded);
+                var prevContent = node.spaces[lastAdded].after || "";
+                node.spaces[lastAdded].after = prevContent + content;
+                var existingComment = (0, _util.getProp)(node, "raws", "spaces", lastAdded, "after") || null;
+                if (existingComment) {
+                  node.raws.spaces[lastAdded].after = existingComment + content;
+                }
+              } else {
+                spaceBefore = spaceBefore + content;
+                commentBefore = commentBefore + content;
+              }
+              break;
+            case tokens.asterisk:
+              if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+                node.operator = content;
+                lastAdded = "operator";
+              } else if ((!node.namespace || lastAdded === "namespace" && !spaceAfterMeaningfulToken) && next) {
+                if (spaceBefore) {
+                  (0, _util.ensureObject)(node, "spaces", "attribute");
+                  node.spaces.attribute.before = spaceBefore;
+                  spaceBefore = "";
+                }
+                if (commentBefore) {
+                  (0, _util.ensureObject)(node, "raws", "spaces", "attribute");
+                  node.raws.spaces.attribute.before = spaceBefore;
+                  commentBefore = "";
+                }
+                node.namespace = (node.namespace || "") + content;
+                var rawValue = (0, _util.getProp)(node, "raws", "namespace") || null;
+                if (rawValue) {
+                  node.raws.namespace += content;
+                }
+                lastAdded = "namespace";
+              }
+              spaceAfterMeaningfulToken = false;
+              break;
+            case tokens.dollar:
+              if (lastAdded === "value") {
+                var oldRawValue = (0, _util.getProp)(node, "raws", "value");
+                node.value += "$";
+                if (oldRawValue) {
+                  node.raws.value = oldRawValue + "$";
+                }
+                break;
+              }
+            // Falls through
+            case tokens.caret:
+              if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+                node.operator = content;
+                lastAdded = "operator";
+              }
+              spaceAfterMeaningfulToken = false;
+              break;
+            case tokens.combinator:
+              if (content === "~" && next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+                node.operator = content;
+                lastAdded = "operator";
+              }
+              if (content !== "|") {
+                spaceAfterMeaningfulToken = false;
+                break;
+              }
+              if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+                node.operator = content;
+                lastAdded = "operator";
+              } else if (!node.namespace && !node.attribute) {
+                node.namespace = true;
+              }
+              spaceAfterMeaningfulToken = false;
+              break;
+            case tokens.word:
+              if (next && this.content(next) === "|" && attr[pos + 2] && attr[pos + 2][_tokenize.FIELDS.TYPE] !== tokens.equals && // this look-ahead probably fails with comment nodes involved.
+              !node.operator && !node.namespace) {
+                node.namespace = content;
+                lastAdded = "namespace";
+              } else if (!node.attribute || lastAdded === "attribute" && !spaceAfterMeaningfulToken) {
+                if (spaceBefore) {
+                  (0, _util.ensureObject)(node, "spaces", "attribute");
+                  node.spaces.attribute.before = spaceBefore;
+                  spaceBefore = "";
+                }
+                if (commentBefore) {
+                  (0, _util.ensureObject)(node, "raws", "spaces", "attribute");
+                  node.raws.spaces.attribute.before = commentBefore;
+                  commentBefore = "";
+                }
+                node.attribute = (node.attribute || "") + content;
+                var _rawValue = (0, _util.getProp)(node, "raws", "attribute") || null;
+                if (_rawValue) {
+                  node.raws.attribute += content;
+                }
+                lastAdded = "attribute";
+              } else if (!node.value && node.value !== "" || lastAdded === "value" && !(spaceAfterMeaningfulToken || node.quoteMark)) {
+                var _unescaped = (0, _util.unesc)(content);
+                var _oldRawValue = (0, _util.getProp)(node, "raws", "value") || "";
+                var oldValue = node.value || "";
+                node.value = oldValue + _unescaped;
+                node.quoteMark = null;
+                if (_unescaped !== content || _oldRawValue) {
+                  (0, _util.ensureObject)(node, "raws");
+                  node.raws.value = (_oldRawValue || oldValue) + content;
+                }
+                lastAdded = "value";
+              } else {
+                var insensitive = content === "i" || content === "I";
+                if ((node.value || node.value === "") && (node.quoteMark || spaceAfterMeaningfulToken)) {
+                  node.insensitive = insensitive;
+                  if (!insensitive || content === "I") {
+                    (0, _util.ensureObject)(node, "raws");
+                    node.raws.insensitiveFlag = content;
+                  }
+                  lastAdded = "insensitive";
+                  if (spaceBefore) {
+                    (0, _util.ensureObject)(node, "spaces", "insensitive");
+                    node.spaces.insensitive.before = spaceBefore;
+                    spaceBefore = "";
+                  }
+                  if (commentBefore) {
+                    (0, _util.ensureObject)(node, "raws", "spaces", "insensitive");
+                    node.raws.spaces.insensitive.before = commentBefore;
+                    commentBefore = "";
+                  }
+                } else if (node.value || node.value === "") {
+                  lastAdded = "value";
+                  node.value += content;
+                  if (node.raws.value) {
+                    node.raws.value += content;
+                  }
+                }
+              }
+              spaceAfterMeaningfulToken = false;
+              break;
+            case tokens.str:
+              if (!node.attribute || !node.operator) {
+                return this.error("Expected an attribute followed by an operator preceding the string.", {
+                  index: token[_tokenize.FIELDS.START_POS]
+                });
+              }
+              var _unescapeValue = (0, _attribute.unescapeValue)(content), unescaped = _unescapeValue.unescaped, quoteMark = _unescapeValue.quoteMark;
+              node.value = unescaped;
+              node.quoteMark = quoteMark;
+              lastAdded = "value";
+              (0, _util.ensureObject)(node, "raws");
+              node.raws.value = content;
+              spaceAfterMeaningfulToken = false;
+              break;
+            case tokens.equals:
+              if (!node.attribute) {
+                return this.expected("attribute", token[_tokenize.FIELDS.START_POS], content);
+              }
+              if (node.value) {
+                return this.error('Unexpected "=" found; an operator was already defined.', {
+                  index: token[_tokenize.FIELDS.START_POS]
+                });
+              }
+              node.operator = node.operator ? node.operator + content : content;
+              lastAdded = "operator";
+              spaceAfterMeaningfulToken = false;
+              break;
+            case tokens.comment:
+              if (lastAdded) {
+                if (spaceAfterMeaningfulToken || next && next[_tokenize.FIELDS.TYPE] === tokens.space || lastAdded === "insensitive") {
+                  var lastComment = (0, _util.getProp)(node, "spaces", lastAdded, "after") || "";
+                  var rawLastComment = (0, _util.getProp)(node, "raws", "spaces", lastAdded, "after") || lastComment;
+                  (0, _util.ensureObject)(node, "raws", "spaces", lastAdded);
+                  node.raws.spaces[lastAdded].after = rawLastComment + content;
+                } else {
+                  var lastValue = node[lastAdded] || "";
+                  var rawLastValue = (0, _util.getProp)(node, "raws", lastAdded) || lastValue;
+                  (0, _util.ensureObject)(node, "raws");
+                  node.raws[lastAdded] = rawLastValue + content;
+                }
+              } else {
+                commentBefore = commentBefore + content;
+              }
+              break;
+            default:
+              return this.error('Unexpected "' + content + '" found.', {
+                index: token[_tokenize.FIELDS.START_POS]
+              });
+          }
+          pos++;
+        }
+        unescapeProp(node, "attribute");
+        unescapeProp(node, "namespace");
+        this.newNode(new _attribute["default"](node));
+        this.position++;
+      };
+      _proto.parseWhitespaceEquivalentTokens = function parseWhitespaceEquivalentTokens(stopPosition) {
+        if (stopPosition < 0) {
+          stopPosition = this.tokens.length;
+        }
+        var startPosition = this.position;
+        var nodes = [];
+        var space = "";
+        var lastComment = void 0;
+        do {
+          if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {
+            if (!this.options.lossy) {
+              space += this.content();
+            }
+          } else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.comment) {
+            var spaces = {};
+            if (space) {
+              spaces.before = space;
+              space = "";
+            }
+            lastComment = new _comment["default"]({
+              value: this.content(),
+              source: getTokenSource(this.currToken),
+              sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
+              spaces
+            });
+            nodes.push(lastComment);
+          }
+        } while (++this.position < stopPosition);
+        if (space) {
+          if (lastComment) {
+            lastComment.spaces.after = space;
+          } else if (!this.options.lossy) {
+            var firstToken = this.tokens[startPosition];
+            var lastToken = this.tokens[this.position - 1];
+            nodes.push(new _string["default"]({
+              value: "",
+              source: getSource(firstToken[_tokenize.FIELDS.START_LINE], firstToken[_tokenize.FIELDS.START_COL], lastToken[_tokenize.FIELDS.END_LINE], lastToken[_tokenize.FIELDS.END_COL]),
+              sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
+              spaces: {
+                before: space,
+                after: ""
+              }
+            }));
+          }
+        }
+        return nodes;
+      };
+      _proto.convertWhitespaceNodesToSpace = function convertWhitespaceNodesToSpace(nodes, requiredSpace) {
+        var _this2 = this;
+        if (requiredSpace === void 0) {
+          requiredSpace = false;
+        }
+        var space = "";
+        var rawSpace = "";
+        nodes.forEach(function(n) {
+          var spaceBefore = _this2.lossySpace(n.spaces.before, requiredSpace);
+          var rawSpaceBefore = _this2.lossySpace(n.rawSpaceBefore, requiredSpace);
+          space += spaceBefore + _this2.lossySpace(n.spaces.after, requiredSpace && spaceBefore.length === 0);
+          rawSpace += spaceBefore + n.value + _this2.lossySpace(n.rawSpaceAfter, requiredSpace && rawSpaceBefore.length === 0);
+        });
+        if (rawSpace === space) {
+          rawSpace = void 0;
+        }
+        var result = {
+          space,
+          rawSpace
+        };
+        return result;
+      };
+      _proto.isNamedCombinator = function isNamedCombinator(position) {
+        if (position === void 0) {
+          position = this.position;
+        }
+        return this.tokens[position + 0] && this.tokens[position + 0][_tokenize.FIELDS.TYPE] === tokens.slash && this.tokens[position + 1] && this.tokens[position + 1][_tokenize.FIELDS.TYPE] === tokens.word && this.tokens[position + 2] && this.tokens[position + 2][_tokenize.FIELDS.TYPE] === tokens.slash;
+      };
+      _proto.namedCombinator = function namedCombinator() {
+        if (this.isNamedCombinator()) {
+          var nameRaw = this.content(this.tokens[this.position + 1]);
+          var name = (0, _util.unesc)(nameRaw).toLowerCase();
+          var raws = {};
+          if (name !== nameRaw) {
+            raws.value = "/" + nameRaw + "/";
+          }
+          var node = new _combinator["default"]({
+            value: "/" + name + "/",
+            source: getSource(this.currToken[_tokenize.FIELDS.START_LINE], this.currToken[_tokenize.FIELDS.START_COL], this.tokens[this.position + 2][_tokenize.FIELDS.END_LINE], this.tokens[this.position + 2][_tokenize.FIELDS.END_COL]),
+            sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
+            raws
+          });
+          this.position = this.position + 3;
+          return node;
+        } else {
+          this.unexpected();
+        }
+      };
+      _proto.combinator = function combinator() {
+        var _this3 = this;
+        if (this.content() === "|") {
+          return this.namespace();
+        }
+        var nextSigTokenPos = this.locateNextMeaningfulToken(this.position);
+        if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+          var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
+          if (nodes.length > 0) {
+            var last = this.current.last;
+            if (last) {
+              var _this$convertWhitespa = this.convertWhitespaceNodesToSpace(nodes), space = _this$convertWhitespa.space, rawSpace = _this$convertWhitespa.rawSpace;
+              if (rawSpace !== void 0) {
+                last.rawSpaceAfter += rawSpace;
+              }
+              last.spaces.after += space;
+            } else {
+              nodes.forEach(function(n) {
+                return _this3.newNode(n);
+              });
+            }
+          }
+          return;
+        }
+        var firstToken = this.currToken;
+        var spaceOrDescendantSelectorNodes = void 0;
+        if (nextSigTokenPos > this.position) {
+          spaceOrDescendantSelectorNodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
+        }
+        var node;
+        if (this.isNamedCombinator()) {
+          node = this.namedCombinator();
+        } else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.combinator) {
+          node = new _combinator["default"]({
+            value: this.content(),
+            source: getTokenSource(this.currToken),
+            sourceIndex: this.currToken[_tokenize.FIELDS.START_POS]
+          });
+          this.position++;
+        } else if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {
+        } else if (!spaceOrDescendantSelectorNodes) {
+          this.unexpected();
+        }
+        if (node) {
+          if (spaceOrDescendantSelectorNodes) {
+            var _this$convertWhitespa2 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes), _space = _this$convertWhitespa2.space, _rawSpace = _this$convertWhitespa2.rawSpace;
+            node.spaces.before = _space;
+            node.rawSpaceBefore = _rawSpace;
+          }
+        } else {
+          var _this$convertWhitespa3 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes, true), _space2 = _this$convertWhitespa3.space, _rawSpace2 = _this$convertWhitespa3.rawSpace;
+          if (!_rawSpace2) {
+            _rawSpace2 = _space2;
+          }
+          var spaces = {};
+          var raws = {
+            spaces: {}
+          };
+          if (_space2.endsWith(" ") && _rawSpace2.endsWith(" ")) {
+            spaces.before = _space2.slice(0, _space2.length - 1);
+            raws.spaces.before = _rawSpace2.slice(0, _rawSpace2.length - 1);
+          } else if (_space2[0] === " " && _rawSpace2[0] === " ") {
+            spaces.after = _space2.slice(1);
+            raws.spaces.after = _rawSpace2.slice(1);
+          } else {
+            raws.value = _rawSpace2;
+          }
+          node = new _combinator["default"]({
+            value: " ",
+            source: getTokenSourceSpan(firstToken, this.tokens[this.position - 1]),
+            sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
+            spaces,
+            raws
+          });
+        }
+        if (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.space) {
+          node.spaces.after = this.optionalSpace(this.content());
+          this.position++;
+        }
+        return this.newNode(node);
+      };
+      _proto.comma = function comma() {
+        if (this.position === this.tokens.length - 1) {
+          this.root.trailingComma = true;
+          this.position++;
+          return;
+        }
+        this.current._inferEndPosition();
+        var selector = new _selector["default"]({
+          source: {
+            start: tokenStart(this.tokens[this.position + 1])
+          },
+          sourceIndex: this.tokens[this.position + 1][_tokenize.FIELDS.START_POS]
+        });
+        this.current.parent.append(selector);
+        this.current = selector;
+        this.position++;
+      };
+      _proto.comment = function comment() {
+        var current = this.currToken;
+        this.newNode(new _comment["default"]({
+          value: this.content(),
+          source: getTokenSource(current),
+          sourceIndex: current[_tokenize.FIELDS.START_POS]
+        }));
+        this.position++;
+      };
+      _proto.error = function error(message, opts) {
+        throw this.root.error(message, opts);
+      };
+      _proto.missingBackslash = function missingBackslash() {
+        return this.error("Expected a backslash preceding the semicolon.", {
+          index: this.currToken[_tokenize.FIELDS.START_POS]
+        });
+      };
+      _proto.missingParenthesis = function missingParenthesis() {
+        return this.expected("opening parenthesis", this.currToken[_tokenize.FIELDS.START_POS]);
+      };
+      _proto.missingSquareBracket = function missingSquareBracket() {
+        return this.expected("opening square bracket", this.currToken[_tokenize.FIELDS.START_POS]);
+      };
+      _proto.unexpected = function unexpected() {
+        return this.error("Unexpected '" + this.content() + "'. Escaping special characters with \\ may help.", this.currToken[_tokenize.FIELDS.START_POS]);
+      };
+      _proto.unexpectedPipe = function unexpectedPipe() {
+        return this.error("Unexpected '|'.", this.currToken[_tokenize.FIELDS.START_POS]);
+      };
+      _proto.namespace = function namespace() {
+        var before2 = this.prevToken && this.content(this.prevToken) || true;
+        if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.word) {
+          this.position++;
+          return this.word(before2);
+        } else if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.asterisk) {
+          this.position++;
+          return this.universal(before2);
+        }
+        this.unexpectedPipe();
+      };
+      _proto.nesting = function nesting() {
+        if (this.nextToken) {
+          var nextContent = this.content(this.nextToken);
+          if (nextContent === "|") {
+            this.position++;
+            return;
+          }
+        }
+        var current = this.currToken;
+        this.newNode(new _nesting["default"]({
+          value: this.content(),
+          source: getTokenSource(current),
+          sourceIndex: current[_tokenize.FIELDS.START_POS]
+        }));
+        this.position++;
+      };
+      _proto.parentheses = function parentheses() {
+        var last = this.current.last;
+        var unbalanced = 1;
+        this.position++;
+        if (last && last.type === types4.PSEUDO) {
+          var selector = new _selector["default"]({
+            source: {
+              start: tokenStart(this.tokens[this.position])
+            },
+            sourceIndex: this.tokens[this.position][_tokenize.FIELDS.START_POS]
+          });
+          var cache2 = this.current;
+          last.append(selector);
+          this.current = selector;
+          this.nestingDepth++;
+          try {
+            if (this.nestingDepth > this.maxNestingDepth) {
+              this.error("Cannot parse selector: nesting depth exceeds the maximum of " + this.maxNestingDepth + ".", {
+                index: this.currToken[_tokenize.FIELDS.START_POS]
+              });
+            }
+            while (this.position < this.tokens.length && unbalanced) {
+              if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+                unbalanced++;
+              }
+              if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+                unbalanced--;
+              }
+              if (unbalanced) {
+                this.parse();
+              } else {
+                this.current.source.end = tokenEnd(this.currToken);
+                this.current.parent.source.end = tokenEnd(this.currToken);
+                this.position++;
+              }
+            }
+          } finally {
+            this.nestingDepth--;
+          }
+          this.current = cache2;
+        } else {
+          var parenStart = this.currToken;
+          var parenValue = "(";
+          var parenEnd;
+          while (this.position < this.tokens.length && unbalanced) {
+            if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+              unbalanced++;
+            }
+            if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+              unbalanced--;
+            }
+            parenEnd = this.currToken;
+            parenValue += this.parseParenthesisToken(this.currToken);
+            this.position++;
+          }
+          if (last) {
+            last.appendToPropertyAndEscape("value", parenValue, parenValue);
+          } else {
+            this.newNode(new _string["default"]({
+              value: parenValue,
+              source: getSource(parenStart[_tokenize.FIELDS.START_LINE], parenStart[_tokenize.FIELDS.START_COL], parenEnd[_tokenize.FIELDS.END_LINE], parenEnd[_tokenize.FIELDS.END_COL]),
+              sourceIndex: parenStart[_tokenize.FIELDS.START_POS]
+            }));
+          }
+        }
+        if (unbalanced) {
+          return this.expected("closing parenthesis", this.currToken[_tokenize.FIELDS.START_POS]);
+        }
+      };
+      _proto.pseudo = function pseudo() {
+        var _this4 = this;
+        var pseudoStr = "";
+        var startingToken = this.currToken;
+        while (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.colon) {
+          pseudoStr += this.content();
+          this.position++;
+        }
+        if (!this.currToken) {
+          return this.expected(["pseudo-class", "pseudo-element"], this.position - 1);
+        }
+        if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.word) {
+          this.splitWord(false, function(first, length) {
+            pseudoStr += first;
+            _this4.newNode(new _pseudo["default"]({
+              value: pseudoStr,
+              source: getTokenSourceSpan(startingToken, _this4.currToken),
+              sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
+            }));
+            if (length > 1 && _this4.nextToken && _this4.nextToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+              _this4.error("Misplaced parenthesis.", {
+                index: _this4.nextToken[_tokenize.FIELDS.START_POS]
+              });
+            }
+          });
+        } else {
+          return this.expected(["pseudo-class", "pseudo-element"], this.currToken[_tokenize.FIELDS.START_POS]);
+        }
+      };
+      _proto.space = function space() {
+        var content = this.content();
+        if (this.position === 0 || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis || this.current.nodes.every(function(node) {
+          return node.type === "comment";
+        })) {
+          this.spaces = this.optionalSpace(content);
+          this.position++;
+        } else if (this.position === this.tokens.length - 1 || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+          this.current.last.spaces.after = this.optionalSpace(content);
+          this.position++;
+        } else {
+          this.combinator();
+        }
+      };
+      _proto.string = function string() {
+        var current = this.currToken;
+        this.newNode(new _string["default"]({
+          value: this.content(),
+          source: getTokenSource(current),
+          sourceIndex: current[_tokenize.FIELDS.START_POS]
+        }));
+        this.position++;
+      };
+      _proto.universal = function universal(namespace) {
+        var nextToken = this.nextToken;
+        if (nextToken && this.content(nextToken) === "|") {
+          this.position++;
+          return this.namespace();
+        }
+        var current = this.currToken;
+        this.newNode(new _universal["default"]({
+          value: this.content(),
+          source: getTokenSource(current),
+          sourceIndex: current[_tokenize.FIELDS.START_POS]
+        }), namespace);
+        this.position++;
+      };
+      _proto.splitWord = function splitWord(namespace, firstCallback) {
+        var _this5 = this;
+        var nextToken = this.nextToken;
+        var word = this.content();
+        while (nextToken && ~[tokens.dollar, tokens.caret, tokens.equals, tokens.word].indexOf(nextToken[_tokenize.FIELDS.TYPE])) {
+          this.position++;
+          var current = this.content();
+          word += current;
+          if (current.lastIndexOf("\\") === current.length - 1) {
+            var next = this.nextToken;
+            if (next && next[_tokenize.FIELDS.TYPE] === tokens.space) {
+              word += this.requiredSpace(this.content(next));
+              this.position++;
+            }
+          }
+          nextToken = this.nextToken;
+        }
+        var hasClass = indexesOf(word, ".").filter(function(i2) {
+          var escapedDot = word[i2 - 1] === "\\";
+          var isKeyframesPercent = /^\d+\.\d+%$/.test(word);
+          return !escapedDot && !isKeyframesPercent;
+        });
+        var hasId = indexesOf(word, "#").filter(function(i2) {
+          return word[i2 - 1] !== "\\";
+        });
+        var interpolations = indexesOf(word, "#{");
+        if (interpolations.length) {
+          hasId = hasId.filter(function(hashIndex) {
+            return !~interpolations.indexOf(hashIndex);
+          });
+        }
+        var indices = (0, _sortAscending["default"])(uniqs([0].concat(hasClass, hasId)));
+        indices.forEach(function(ind, i2) {
+          var index = indices[i2 + 1] || word.length;
+          var value = word.slice(ind, index);
+          if (i2 === 0 && firstCallback) {
+            return firstCallback.call(_this5, value, indices.length);
+          }
+          var node;
+          var current2 = _this5.currToken;
+          var sourceIndex = current2[_tokenize.FIELDS.START_POS] + indices[i2];
+          var source = getSource(current2[1], current2[2] + ind, current2[3], current2[2] + (index - 1));
+          if (~hasClass.indexOf(ind)) {
+            var classNameOpts = {
+              value: value.slice(1),
+              source,
+              sourceIndex
+            };
+            node = new _className["default"](unescapeProp(classNameOpts, "value"));
+          } else if (~hasId.indexOf(ind)) {
+            var idOpts = {
+              value: value.slice(1),
+              source,
+              sourceIndex
+            };
+            node = new _id["default"](unescapeProp(idOpts, "value"));
+          } else {
+            var tagOpts = {
+              value,
+              source,
+              sourceIndex
+            };
+            unescapeProp(tagOpts, "value");
+            node = new _tag["default"](tagOpts);
+          }
+          _this5.newNode(node, namespace);
+          namespace = null;
+        });
+        this.position++;
+      };
+      _proto.word = function word(namespace) {
+        var nextToken = this.nextToken;
+        if (nextToken && this.content(nextToken) === "|") {
+          this.position++;
+          return this.namespace();
+        }
+        return this.splitWord(namespace);
+      };
+      _proto.loop = function loop() {
+        while (this.position < this.tokens.length) {
+          this.parse(true);
+        }
+        this.current._inferEndPosition();
+        return this.root;
+      };
+      _proto.parse = function parse6(throwOnParenthesis) {
+        switch (this.currToken[_tokenize.FIELDS.TYPE]) {
+          case tokens.space:
+            this.space();
+            break;
+          case tokens.comment:
+            this.comment();
+            break;
+          case tokens.openParenthesis:
+            this.parentheses();
+            break;
+          case tokens.closeParenthesis:
+            if (throwOnParenthesis) {
+              this.missingParenthesis();
+            }
+            break;
+          case tokens.openSquare:
+            this.attribute();
+            break;
+          case tokens.dollar:
+          case tokens.caret:
+          case tokens.equals:
+          case tokens.word:
+            this.word();
+            break;
+          case tokens.colon:
+            this.pseudo();
+            break;
+          case tokens.comma:
+            this.comma();
+            break;
+          case tokens.asterisk:
+            this.universal();
+            break;
+          case tokens.ampersand:
+            this.nesting();
+            break;
+          case tokens.slash:
+          case tokens.combinator:
+            this.combinator();
+            break;
+          case tokens.str:
+            this.string();
+            break;
+          // These cases throw; no break needed.
+          case tokens.closeSquare:
+            this.missingSquareBracket();
+          case tokens.semicolon:
+            this.missingBackslash();
+          default:
+            this.unexpected();
+        }
+      };
+      _proto.expected = function expected(description, index, found) {
+        if (Array.isArray(description)) {
+          var last = description.pop();
+          description = description.join(", ") + " or " + last;
+        }
+        var an = /^[aeiou]/.test(description[0]) ? "an" : "a";
+        if (!found) {
+          return this.error("Expected " + an + " " + description + ".", {
+            index
+          });
+        }
+        return this.error("Expected " + an + " " + description + ', found "' + found + '" instead.', {
+          index
+        });
+      };
+      _proto.requiredSpace = function requiredSpace(space) {
+        return this.options.lossy ? " " : space;
+      };
+      _proto.optionalSpace = function optionalSpace(space) {
+        return this.options.lossy ? "" : space;
+      };
+      _proto.lossySpace = function lossySpace(space, required) {
+        if (this.options.lossy) {
+          return required ? " " : "";
+        } else {
+          return space;
+        }
+      };
+      _proto.parseParenthesisToken = function parseParenthesisToken(token) {
+        var content = this.content(token);
+        if (token[_tokenize.FIELDS.TYPE] === tokens.space) {
+          return this.requiredSpace(content);
+        } else {
+          return content;
+        }
+      };
+      _proto.newNode = function newNode(node, namespace) {
+        if (namespace) {
+          if (/^ +$/.test(namespace)) {
+            if (!this.options.lossy) {
+              this.spaces = (this.spaces || "") + namespace;
+            }
+            namespace = true;
+          }
+          node.namespace = namespace;
+          unescapeProp(node, "namespace");
+        }
+        if (this.spaces) {
+          node.spaces.before = this.spaces;
+          this.spaces = "";
+        }
+        return this.current.append(node);
+      };
+      _proto.content = function content(token) {
+        if (token === void 0) {
+          token = this.currToken;
+        }
+        return this.css.slice(token[_tokenize.FIELDS.START_POS], token[_tokenize.FIELDS.END_POS]);
+      };
+      _proto.locateNextMeaningfulToken = function locateNextMeaningfulToken(startPosition) {
+        if (startPosition === void 0) {
+          startPosition = this.position + 1;
+        }
+        var searchPosition = startPosition;
+        while (searchPosition < this.tokens.length) {
+          if (WHITESPACE_EQUIV_TOKENS[this.tokens[searchPosition][_tokenize.FIELDS.TYPE]]) {
+            searchPosition++;
+            continue;
+          } else {
+            return searchPosition;
+          }
+        }
+        return -1;
+      };
+      _createClass(Parser4, [{
+        key: "currToken",
+        get: function get() {
+          return this.tokens[this.position];
+        }
+      }, {
+        key: "nextToken",
+        get: function get() {
+          return this.tokens[this.position + 1];
+        }
+      }, {
+        key: "prevToken",
+        get: function get() {
+          return this.tokens[this.position - 1];
+        }
+      }]);
+      return Parser4;
+    })();
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/processor.js
+var require_processor = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/processor.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _parser = _interopRequireDefault(require_parser2());
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    var Processor = exports["default"] = /* @__PURE__ */ (function() {
+      function Processor2(func, options) {
+        this.func = func || function noop3() {
+        };
+        this.funcRes = null;
+        this.options = options;
+      }
+      var _proto = Processor2.prototype;
+      _proto._shouldUpdateSelector = function _shouldUpdateSelector(rule, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var merged = Object.assign({}, this.options, options);
+        if (merged.updateSelector === false) {
+          return false;
+        } else {
+          return typeof rule !== "string";
+        }
+      };
+      _proto._isLossy = function _isLossy(options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var merged = Object.assign({}, this.options, options);
+        if (merged.lossless === false) {
+          return true;
+        } else {
+          return false;
+        }
+      };
+      _proto._root = function _root(rule, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var parser = new _parser["default"](rule, this._parseOptions(options));
+        return parser.root;
+      };
+      _proto._parseOptions = function _parseOptions(options) {
+        var merged = Object.assign({}, this.options, options);
+        return {
+          lossy: this._isLossy(merged),
+          maxNestingDepth: merged.maxNestingDepth
+        };
+      };
+      _proto._stringifyOptions = function _stringifyOptions(options) {
+        var merged = Object.assign({}, this.options, options);
+        return {
+          maxNestingDepth: merged.maxNestingDepth
+        };
+      };
+      _proto._run = function _run(rule, options) {
+        var _this = this;
+        if (options === void 0) {
+          options = {};
+        }
+        return new Promise(function(resolve52, reject) {
+          try {
+            var root = _this._root(rule, options);
+            Promise.resolve(_this.func(root)).then(function(transform) {
+              var string = void 0;
+              if (_this._shouldUpdateSelector(rule, options)) {
+                string = root.toString(_this._stringifyOptions(options));
+                rule.selector = string;
+              }
+              return {
+                transform,
+                root,
+                string
+              };
+            }).then(resolve52, reject);
+          } catch (e3) {
+            reject(e3);
+            return;
+          }
+        });
+      };
+      _proto._runSync = function _runSync(rule, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var root = this._root(rule, options);
+        var transform = this.func(root);
+        if (transform && typeof transform.then === "function") {
+          throw new Error("Selector processor returned a promise to a synchronous call.");
+        }
+        var string = void 0;
+        if (options.updateSelector && typeof rule !== "string") {
+          string = root.toString(this._stringifyOptions(options));
+          rule.selector = string;
+        }
+        return {
+          transform,
+          root,
+          string
+        };
+      };
+      _proto.ast = function ast(rule, options) {
+        return this._run(rule, options).then(function(result) {
+          return result.root;
+        });
+      };
+      _proto.astSync = function astSync(rule, options) {
+        return this._runSync(rule, options).root;
+      };
+      _proto.transform = function transform(rule, options) {
+        return this._run(rule, options).then(function(result) {
+          return result.transform;
+        });
+      };
+      _proto.transformSync = function transformSync2(rule, options) {
+        return this._runSync(rule, options).transform;
+      };
+      _proto.process = function process2(rule, options) {
+        var _this2 = this;
+        return this._run(rule, options).then(function(result) {
+          return result.string || result.root.toString(_this2._stringifyOptions(options));
+        });
+      };
+      _proto.processSync = function processSync(rule, options) {
+        var result = this._runSync(rule, options);
+        return result.string || result.root.toString(this._stringifyOptions(options));
+      };
+      return Processor2;
+    })();
+    module.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/constructors.js
+var require_constructors = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/constructors.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.universal = exports.tag = exports.string = exports.selector = exports.root = exports.pseudo = exports.nesting = exports.id = exports.comment = exports.combinator = exports.className = exports.attribute = void 0;
+    var _attribute = _interopRequireDefault(require_attribute());
+    var _className = _interopRequireDefault(require_className());
+    var _combinator = _interopRequireDefault(require_combinator());
+    var _comment = _interopRequireDefault(require_comment());
+    var _id = _interopRequireDefault(require_id());
+    var _nesting = _interopRequireDefault(require_nesting());
+    var _pseudo = _interopRequireDefault(require_pseudo());
+    var _root = _interopRequireDefault(require_root());
+    var _selector = _interopRequireDefault(require_selector());
+    var _string = _interopRequireDefault(require_string());
+    var _tag = _interopRequireDefault(require_tag());
+    var _universal = _interopRequireDefault(require_universal());
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    var attribute2 = exports.attribute = function attribute3(opts) {
+      return new _attribute["default"](opts);
+    };
+    var className = exports.className = function className2(opts) {
+      return new _className["default"](opts);
+    };
+    var combinator = exports.combinator = function combinator2(opts) {
+      return new _combinator["default"](opts);
+    };
+    var comment = exports.comment = function comment2(opts) {
+      return new _comment["default"](opts);
+    };
+    var id = exports.id = function id2(opts) {
+      return new _id["default"](opts);
+    };
+    var nesting = exports.nesting = function nesting2(opts) {
+      return new _nesting["default"](opts);
+    };
+    var pseudo = exports.pseudo = function pseudo2(opts) {
+      return new _pseudo["default"](opts);
+    };
+    var root = exports.root = function root2(opts) {
+      return new _root["default"](opts);
+    };
+    var selector = exports.selector = function selector2(opts) {
+      return new _selector["default"](opts);
+    };
+    var string = exports.string = function string2(opts) {
+      return new _string["default"](opts);
+    };
+    var tag = exports.tag = function tag2(opts) {
+      return new _tag["default"](opts);
+    };
+    var universal = exports.universal = function universal2(opts) {
+      return new _universal["default"](opts);
+    };
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/guards.js
+var require_guards = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/guards.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.isComment = exports.isCombinator = exports.isClassName = exports.isAttribute = void 0;
+    exports.isContainer = isContainer;
+    exports.isIdentifier = void 0;
+    exports.isNamespace = isNamespace;
+    exports.isNesting = void 0;
+    exports.isNode = isNode2;
+    exports.isPseudo = void 0;
+    exports.isPseudoClass = isPseudoClass;
+    exports.isPseudoElement = isPseudoElement;
+    exports.isUniversal = exports.isTag = exports.isString = exports.isSelector = exports.isRoot = void 0;
+    var _types = require_types2();
+    var _IS_TYPE;
+    var IS_TYPE = (_IS_TYPE = {}, _IS_TYPE[_types.ATTRIBUTE] = true, _IS_TYPE[_types.CLASS] = true, _IS_TYPE[_types.COMBINATOR] = true, _IS_TYPE[_types.COMMENT] = true, _IS_TYPE[_types.ID] = true, _IS_TYPE[_types.NESTING] = true, _IS_TYPE[_types.PSEUDO] = true, _IS_TYPE[_types.ROOT] = true, _IS_TYPE[_types.SELECTOR] = true, _IS_TYPE[_types.STRING] = true, _IS_TYPE[_types.TAG] = true, _IS_TYPE[_types.UNIVERSAL] = true, _IS_TYPE);
+    function isNode2(node) {
+      return typeof node === "object" && IS_TYPE[node.type];
+    }
+    function isNodeType(type, node) {
+      return isNode2(node) && node.type === type;
+    }
+    var isAttribute = exports.isAttribute = isNodeType.bind(null, _types.ATTRIBUTE);
+    var isClassName = exports.isClassName = isNodeType.bind(null, _types.CLASS);
+    var isCombinator = exports.isCombinator = isNodeType.bind(null, _types.COMBINATOR);
+    var isComment2 = exports.isComment = isNodeType.bind(null, _types.COMMENT);
+    var isIdentifier = exports.isIdentifier = isNodeType.bind(null, _types.ID);
+    var isNesting = exports.isNesting = isNodeType.bind(null, _types.NESTING);
+    var isPseudo = exports.isPseudo = isNodeType.bind(null, _types.PSEUDO);
+    var isRoot = exports.isRoot = isNodeType.bind(null, _types.ROOT);
+    var isSelector = exports.isSelector = isNodeType.bind(null, _types.SELECTOR);
+    var isString = exports.isString = isNodeType.bind(null, _types.STRING);
+    var isTag4 = exports.isTag = isNodeType.bind(null, _types.TAG);
+    var isUniversal = exports.isUniversal = isNodeType.bind(null, _types.UNIVERSAL);
+    function isPseudoElement(node) {
+      return isPseudo(node) && node.value && (node.value.startsWith("::") || node.value.toLowerCase() === ":before" || node.value.toLowerCase() === ":after" || node.value.toLowerCase() === ":first-letter" || node.value.toLowerCase() === ":first-line");
+    }
+    function isPseudoClass(node) {
+      return isPseudo(node) && !isPseudoElement(node);
+    }
+    function isContainer(node) {
+      return !!(isNode2(node) && node.walk);
+    }
+    function isNamespace(node) {
+      return isAttribute(node) || isTag4(node);
+    }
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/index.js
+var require_selectors = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/selectors/index.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    var _types = require_types2();
+    Object.keys(_types).forEach(function(key2) {
+      if (key2 === "default" || key2 === "__esModule") return;
+      if (key2 in exports && exports[key2] === _types[key2]) return;
+      exports[key2] = _types[key2];
+    });
+    var _constructors = require_constructors();
+    Object.keys(_constructors).forEach(function(key2) {
+      if (key2 === "default" || key2 === "__esModule") return;
+      if (key2 in exports && exports[key2] === _constructors[key2]) return;
+      exports[key2] = _constructors[key2];
+    });
+    var _guards = require_guards();
+    Object.keys(_guards).forEach(function(key2) {
+      if (key2 === "default" || key2 === "__esModule") return;
+      if (key2 in exports && exports[key2] === _guards[key2]) return;
+      exports[key2] = _guards[key2];
+    });
+  }
+});
+
+// ../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/.bun/postcss-selector-parser@7.1.2/node_modules/postcss-selector-parser/dist/index.js"(exports, module) {
+    "use strict";
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _processor = _interopRequireDefault(require_processor());
+    var selectors = _interopRequireWildcard(require_selectors());
+    function _interopRequireWildcard(e3, t2) {
+      if ("function" == typeof WeakMap) var r2 = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap();
+      return (_interopRequireWildcard = function _interopRequireWildcard2(e4, t3) {
+        if (!t3 && e4 && e4.__esModule) return e4;
+        var o, i2, f3 = { __proto__: null, "default": e4 };
+        if (null === e4 || "object" != typeof e4 && "function" != typeof e4) return f3;
+        if (o = t3 ? n : r2) {
+          if (o.has(e4)) return o.get(e4);
+          o.set(e4, f3);
+        }
+        for (var _t2 in e4) {
+          "default" !== _t2 && {}.hasOwnProperty.call(e4, _t2) && ((i2 = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e4, _t2)) && (i2.get || i2.set) ? o(f3, _t2, i2) : f3[_t2] = e4[_t2]);
+        }
+        return f3;
+      })(e3, t2);
+    }
+    function _interopRequireDefault(e3) {
+      return e3 && e3.__esModule ? e3 : { "default": e3 };
+    }
+    var parser = function parser2(processor) {
+      return new _processor["default"](processor);
+    };
+    Object.assign(parser, selectors);
+    delete parser.__esModule;
+    var _default = exports["default"] = parser;
+    module.exports = exports.default;
+  }
+});
+
 // ../core/src/studio-api/helpers/sourceMutation.ts
+import postcss3 from "postcss";
 function parseSourceDocument(source) {
   const hasDocumentShell = /<!doctype|<html[\s>]/i.test(source);
   if (hasDocumentShell) {
@@ -59646,6 +63283,35 @@ function parseSourceDocument(source) {
     wrappedFragment: true
   };
 }
+function duplicateCssRulesForId(document2, originalId, newId) {
+  const idToken = `#${originalId}`;
+  const transform = (0, import_postcss_selector_parser.default)((selectors) => {
+    selectors.walkIds((node) => {
+      if (node.value === originalId) node.value = newId;
+    });
+  });
+  for (const styleEl of document2.querySelectorAll("style")) {
+    const css = styleEl.textContent ?? "";
+    let root;
+    try {
+      root = postcss3.parse(css);
+    } catch {
+      continue;
+    }
+    const clones = [];
+    root.walkRules((rule) => {
+      if (!rule.selector.includes(idToken)) return;
+      const newSelector = transform.processSync(rule.selector);
+      if (newSelector === rule.selector) return;
+      const clone2 = rule.clone({ selector: newSelector });
+      clones.push(clone2);
+    });
+    if (clones.length > 0) {
+      for (const c3 of clones) root.append(c3);
+      styleEl.textContent = root.toString();
+    }
+  }
+}
 function querySelectorAllWithTemplates(root, selector) {
   const matches2 = Array.from(root.querySelectorAll(selector));
   if (matches2.length > 0) return matches2;
@@ -59796,6 +63462,13 @@ function splitElementInHtml(source, target, splitTime, newId) {
   if (duration <= 0 || splitTime <= start || splitTime >= start + duration) {
     return { html: source, matched: false, newId: null };
   }
+  if (document2.getElementById(newId)) {
+    let suffix = 2;
+    const base = newId;
+    while (document2.getElementById(newId)) {
+      newId = `${base}-${suffix++}`;
+    }
+  }
   const firstDuration = splitTime - start;
   const secondDuration = duration - firstDuration;
   const clone2 = el.cloneNode(true);
@@ -59813,6 +63486,10 @@ function splitElementInHtml(source, target, splitTime, newId) {
       String(Math.round((currentTrim + firstDuration * rate) * 1e3) / 1e3)
     );
   }
+  const originalId = el.getAttribute("id");
+  if (originalId) {
+    duplicateCssRulesForId(document2, originalId, newId);
+  }
   setElementDuration(el, start, firstDuration, usesDataEnd);
   if (el.nextSibling) {
     el.parentElement.insertBefore(clone2, el.nextSibling);
@@ -59825,11 +63502,12 @@ function splitElementInHtml(source, target, splitTime, newId) {
     newId
   };
 }
-var ALLOWED_HTML_ATTRS, DANGEROUS_URI_SCHEMES, DANGEROUS_DATA_URI, URI_ATTRS;
+var import_postcss_selector_parser, ALLOWED_HTML_ATTRS, DANGEROUS_URI_SCHEMES, DANGEROUS_DATA_URI, URI_ATTRS;
 var init_sourceMutation = __esm({
   "../core/src/studio-api/helpers/sourceMutation.ts"() {
     "use strict";
     init_esm10();
+    import_postcss_selector_parser = __toESM(require_dist(), 1);
     ALLOWED_HTML_ATTRS = /* @__PURE__ */ new Set([
       // Identity & structure
       "id",
@@ -60101,7 +63779,8 @@ async function executeGsapMutation(body, block, respond2) {
     setArcPathInScript: setArcPathInScript2,
     updateArcSegmentInScript: updateArcSegmentInScript2,
     removeArcPathFromScript: removeArcPathFromScript2,
-    addAnimationWithKeyframesToScript: addAnimationWithKeyframesToScript2
+    addAnimationWithKeyframesToScript: addAnimationWithKeyframesToScript2,
+    splitAnimationsInScript: splitAnimationsInScript2
   } = parser;
   function requireAnimation(scriptText, animationId) {
     const parsed = parseGsapScript2(scriptText);
@@ -60265,6 +63944,23 @@ async function executeGsapMutation(body, block, respond2) {
       );
       return result.script;
     }
+    case "split-animations": {
+      if (typeof body.originalId !== "string" || !body.originalId || typeof body.newId !== "string" || !body.newId || typeof body.splitTime !== "number" || !Number.isFinite(body.splitTime) || typeof body.elementStart !== "number" || !Number.isFinite(body.elementStart) || typeof body.elementDuration !== "number" || !Number.isFinite(body.elementDuration) || body.elementDuration <= 0) {
+        return respond2(
+          {
+            error: "split-animations requires originalId, newId (non-empty strings), splitTime, elementStart (finite numbers), and elementDuration (positive number)"
+          },
+          400
+        );
+      }
+      return splitAnimationsInScript2(block.scriptText, {
+        originalId: body.originalId,
+        newId: body.newId,
+        splitTime: body.splitTime,
+        elementStart: body.elementStart,
+        elementDuration: body.elementDuration
+      });
+    }
     default:
       return respond2({ error: `unknown mutation type: ${body.type}` }, 400);
   }
@@ -60562,20 +64258,24 @@ ${bootstrap}`;
     );
     const result = await executeGsapMutation(body, block, respond2);
     if (result instanceof Response) return result;
-    const newScript = result;
+    const newScript = typeof result === "string" ? result : result.script;
     const newHtml = block.replaceScript(newScript);
     if (newHtml !== html) {
       writeFileSync8(res.absPath, newHtml, "utf-8");
     }
     const { parseGsapScript: parseGsapScript2 } = await loadGsapParser();
     const freshParsed = parseGsapScript2(newScript);
-    return c3.json({
+    const responsePayload = {
       ok: true,
       parsed: freshParsed,
       before: html,
       after: newHtml,
       scriptText: newScript
-    });
+    };
+    if (typeof result !== "string" && result.skippedSelectors.length > 0) {
+      responsePayload.skippedSelectors = result.skippedSelectors;
+    }
+    return c3.json(responsePayload);
   });
 }
 var init_files = __esm({
@@ -66828,7 +70528,7 @@ var init_htmlCompiler = __esm({
 });
 
 // ../core/src/compiler/compositionScoping.ts
-import postcss3 from "postcss";
+import postcss4 from "postcss";
 function escapeRegExp3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -66954,7 +70654,7 @@ function scopeCssToComposition(css, compositionId, scopeSelectorOverride, author
   const trimmedCompositionId = compositionId.trim();
   if (!css || !trimmedCompositionId) return css;
   const scope = scopeSelectorOverride || `[data-composition-id="${escapeCssAttributeValue(trimmedCompositionId)}"]`;
-  const root = postcss3.parse(css);
+  const root = postcss4.parse(css);
   root.walkRules((rule) => {
     if (isInsideGlobalAtRule(rule)) return;
     rule.selectors = rule.selectors.map(
@@ -94307,7 +98007,7 @@ var require_package = __commonJS({
 });
 
 // ../../node_modules/.bun/gaxios@7.1.4/node_modules/gaxios/build/cjs/src/util.cjs
-var require_util3 = __commonJS({
+var require_util4 = __commonJS({
   "../../node_modules/.bun/gaxios@7.1.4/node_modules/gaxios/build/cjs/src/util.cjs"(exports, module) {
     "use strict";
     var pkg = require_package();
@@ -94326,7 +98026,7 @@ var require_common = __commonJS({
     exports.GaxiosError = exports.GAXIOS_ERROR_SYMBOL = void 0;
     exports.defaultErrorRedactor = defaultErrorRedactor;
     var extend_1 = __importDefault2(require_extend());
-    var util_cjs_1 = __importDefault2(require_util3());
+    var util_cjs_1 = __importDefault2(require_util4());
     var pkg = util_cjs_1.default.pkg;
     exports.GAXIOS_ERROR_SYMBOL = /* @__PURE__ */ Symbol.for(`${pkg.name}-gaxios-error`);
     var GaxiosError = class _GaxiosError extends Error {
@@ -94745,7 +98445,7 @@ var require_helpers = __commonJS({
 });
 
 // ../../node_modules/.bun/agent-base@7.1.4/node_modules/agent-base/dist/index.js
-var require_dist = __commonJS({
+var require_dist2 = __commonJS({
   "../../node_modules/.bun/agent-base@7.1.4/node_modules/agent-base/dist/index.js"(exports) {
     "use strict";
     var __createBinding2 = exports && exports.__createBinding || (Object.create ? (function(o, m2, k2, k22) {
@@ -94997,7 +98697,7 @@ var require_parse_proxy_response = __commonJS({
 });
 
 // ../../node_modules/.bun/https-proxy-agent@7.0.6/node_modules/https-proxy-agent/dist/index.js
-var require_dist2 = __commonJS({
+var require_dist3 = __commonJS({
   "../../node_modules/.bun/https-proxy-agent@7.0.6/node_modules/https-proxy-agent/dist/index.js"(exports) {
     "use strict";
     var __createBinding2 = exports && exports.__createBinding || (Object.create ? (function(o, m2, k2, k22) {
@@ -95036,7 +98736,7 @@ var require_dist2 = __commonJS({
     var tls = __importStar2(__require("tls"));
     var assert_1 = __importDefault2(__require("assert"));
     var debug_1 = __importDefault2(__require("debug"));
-    var agent_base_1 = require_dist();
+    var agent_base_1 = require_dist2();
     var url_1 = __require("url");
     var parse_proxy_response_1 = require_parse_proxy_response();
     var debug = (0, debug_1.default)("https-proxy-agent");
@@ -102088,7 +105788,7 @@ Content-Type: ${partContentType}\r
        * @returns A proxy agent
        */
       static async #getProxyAgent() {
-        this.#proxyAgent ||= (await Promise.resolve().then(() => __toESM(require_dist2()))).HttpsProxyAgent;
+        this.#proxyAgent ||= (await Promise.resolve().then(() => __toESM(require_dist3()))).HttpsProxyAgent;
         return this.#proxyAgent;
       }
       static async #getFetch() {
@@ -105160,7 +108860,7 @@ var require_ecdsa_sig_formatter = __commonJS({
 });
 
 // ../../node_modules/.bun/google-auth-library@10.6.2/node_modules/google-auth-library/build/src/util.js
-var require_util4 = __commonJS({
+var require_util5 = __commonJS({
   "../../node_modules/.bun/google-auth-library@10.6.2/node_modules/google-auth-library/build/src/util.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -105395,7 +109095,7 @@ var require_authclient = __commonJS({
     exports.AuthClient = exports.DEFAULT_EAGER_REFRESH_THRESHOLD_MILLIS = exports.DEFAULT_UNIVERSE = void 0;
     var events_1 = __require("events");
     var gaxios_1 = require_src2();
-    var util_1 = require_util4();
+    var util_1 = require_util5();
     var google_logging_utils_1 = require_src3();
     var shared_cjs_1 = require_shared3();
     exports.DEFAULT_UNIVERSE = "googleapis.com";
@@ -105684,7 +109384,7 @@ var require_oauth2client = __commonJS({
     var querystring = __require("querystring");
     var stream = __require("stream");
     var formatEcdsa = require_ecdsa_sig_formatter();
-    var util_1 = require_util4();
+    var util_1 = require_util5();
     var crypto_1 = require_crypto3();
     var authclient_1 = require_authclient();
     var loginticket_1 = require_loginticket();
@@ -107537,7 +111237,7 @@ var require_jwtaccess = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.JWTAccess = void 0;
     var jws = require_jws();
-    var util_1 = require_util4();
+    var util_1 = require_util5();
     var DEFAULT_HEADER = {
       alg: "RS256",
       typ: "JWT"
@@ -108108,7 +111808,7 @@ var require_impersonated = __commonJS({
     exports.Impersonated = exports.IMPERSONATED_ACCOUNT_TYPE = void 0;
     var oauth2client_1 = require_oauth2client();
     var gaxios_1 = require_src2();
-    var util_1 = require_util4();
+    var util_1 = require_util5();
     exports.IMPERSONATED_ACCOUNT_TYPE = "impersonated_service_account";
     var Impersonated = class _Impersonated extends oauth2client_1.OAuth2Client {
       sourceClient;
@@ -108436,7 +112136,7 @@ var require_stscredentials = __commonJS({
     var gaxios_1 = require_src2();
     var authclient_1 = require_authclient();
     var oauth2common_1 = require_oauth2common();
-    var util_1 = require_util4();
+    var util_1 = require_util5();
     var StsCredentials = class _StsCredentials extends oauth2common_1.OAuthClientAuthHandler {
       #tokenExchangeEndpoint;
       /**
@@ -108525,7 +112225,7 @@ var require_baseexternalclient = __commonJS({
     var stream = __require("stream");
     var authclient_1 = require_authclient();
     var sts = require_stscredentials();
-    var util_1 = require_util4();
+    var util_1 = require_util5();
     var shared_cjs_1 = require_shared3();
     var STS_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:token-exchange";
     var STS_REQUEST_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:access_token";
@@ -109023,7 +112723,7 @@ var require_certificatesubjecttokensupplier = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.CertificateSubjectTokenSupplier = exports.InvalidConfigurationError = exports.CertificateSourceUnavailableError = exports.CERTIFICATE_CONFIGURATION_ENV_VARIABLE = void 0;
-    var util_1 = require_util4();
+    var util_1 = require_util5();
     var fs5 = __require("fs");
     var crypto_1 = __require("crypto");
     var https2 = __require("https");
@@ -109208,7 +112908,7 @@ var require_identitypoolclient = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.IdentityPoolClient = void 0;
     var baseexternalclient_1 = require_baseexternalclient();
-    var util_1 = require_util4();
+    var util_1 = require_util5();
     var filesubjecttokensupplier_1 = require_filesubjecttokensupplier();
     var urlsubjecttokensupplier_1 = require_urlsubjecttokensupplier();
     var certificatesubjecttokensupplier_1 = require_certificatesubjecttokensupplier();
@@ -109627,7 +113327,7 @@ var require_awsclient = __commonJS({
     var awsrequestsigner_1 = require_awsrequestsigner();
     var baseexternalclient_1 = require_baseexternalclient();
     var defaultawssecuritycredentialssupplier_1 = require_defaultawssecuritycredentialssupplier();
-    var util_1 = require_util4();
+    var util_1 = require_util5();
     var gaxios_1 = require_src2();
     var AwsClient = class _AwsClient extends baseexternalclient_1.BaseExternalAccountClient {
       environmentId;
@@ -110390,7 +114090,7 @@ var require_googleauth = __commonJS({
     var baseexternalclient_1 = require_baseexternalclient();
     var authclient_1 = require_authclient();
     var externalAccountAuthorizedUserClient_1 = require_externalAccountAuthorizedUserClient();
-    var util_1 = require_util4();
+    var util_1 = require_util5();
     exports.GoogleAuthExceptionMessages = {
       API_KEY_WITH_CREDENTIALS: "API Keys and Credentials are mutually exclusive authentication methods and cannot be used together.",
       NO_PROJECT_ID_FOUND: "Unable to detect a Project Id in the current environment. \nTo learn more about authentication and Google APIs, visit: \nhttps://cloud.google.com/docs/authentication/getting-started",
@@ -143025,6 +146725,9 @@ async function showUsage3(cmd, parent) {
 runMain(main, { showUsage: showUsage3 });
 /*! Bundled license information:
 
+cssesc/cssesc.js:
+  (*! https://mths.be/cssesc v3.0.0 by @mathias *)
+
 web-streams-polyfill/dist/ponyfill.es2018.js:
   (**
    * @license