import {
  __commonJS,
  __esm,
  __export,
  __toCommonJS,
  __toESM
} from "./chunk-V4OQ3NZ2.js";

// ../../../node_modules/.pnpm/css-in-js-utils@2.0.1/node_modules/css-in-js-utils/lib/isPrefixedValue.js
var require_isPrefixedValue = __commonJS({
  "../../../node_modules/.pnpm/css-in-js-utils@2.0.1/node_modules/css-in-js-utils/lib/isPrefixedValue.js"(exports, module) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isPrefixedValue6;
    var regex = /-webkit-|-moz-|-ms-/;
    function isPrefixedValue6(value) {
      return typeof value === "string" && regex.test(value);
    }
    module.exports = exports["default"];
  }
});

// ../../../node_modules/.pnpm/hyphenate-style-name@1.1.0/node_modules/hyphenate-style-name/index.js
var hyphenate_style_name_exports = {};
__export(hyphenate_style_name_exports, {
  default: () => hyphenate_style_name_default
});
function toHyphenLower(match) {
  return "-" + match.toLowerCase();
}
function hyphenateStyleName2(name) {
  if (cache2.hasOwnProperty(name)) {
    return cache2[name];
  }
  var hName = name.replace(uppercasePattern2, toHyphenLower);
  return cache2[name] = msPattern2.test(hName) ? "-" + hName : hName;
}
var uppercasePattern2, msPattern2, cache2, hyphenate_style_name_default;
var init_hyphenate_style_name = __esm({
  "../../../node_modules/.pnpm/hyphenate-style-name@1.1.0/node_modules/hyphenate-style-name/index.js"() {
    uppercasePattern2 = /[A-Z]/g;
    msPattern2 = /^ms-/;
    cache2 = {};
    hyphenate_style_name_default = hyphenateStyleName2;
  }
});

// ../../../node_modules/.pnpm/css-in-js-utils@2.0.1/node_modules/css-in-js-utils/lib/hyphenateProperty.js
var require_hyphenateProperty = __commonJS({
  "../../../node_modules/.pnpm/css-in-js-utils@2.0.1/node_modules/css-in-js-utils/lib/hyphenateProperty.js"(exports, module) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = hyphenateProperty2;
    var _hyphenateStyleName = (init_hyphenate_style_name(), __toCommonJS(hyphenate_style_name_exports));
    var _hyphenateStyleName2 = _interopRequireDefault(_hyphenateStyleName);
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
    function hyphenateProperty2(property) {
      return (0, _hyphenateStyleName2.default)(property);
    }
    module.exports = exports["default"];
  }
});

// ../../../node_modules/.pnpm/styletron-engine-atomic@1.6.2/node_modules/styletron-engine-atomic/dist-browser-esm/sequential-id-generator.js
var SequentialIDGenerator = class {
  constructor(prefix2 = "") {
    this.prefix = prefix2;
    this.count = 0;
    this.offset = 374;
    this.msb = 1295;
    this.power = 2;
  }
  next() {
    const id = this.increment().toString(36);
    return this.prefix ? `${this.prefix}${id}` : id;
  }
  increment() {
    const id = this.count + this.offset;
    if (id === this.msb) {
      this.offset += (this.msb + 1) * 9;
      this.msb = Math.pow(36, ++this.power) - 1;
    }
    this.count++;
    return id;
  }
};

// ../../../node_modules/.pnpm/styletron-engine-atomic@1.6.2/node_modules/styletron-engine-atomic/dist-browser-esm/sort-css-media-queries.js
var minMaxWidth = /(!?\(\s*min(-device-)?-width).+\(\s*max(-device)?-width/i;
var minWidth = /\(\s*min(-device)?-width/i;
var maxMinWidth = /(!?\(\s*max(-device)?-width).+\(\s*min(-device)?-width/i;
var maxWidth = /\(\s*max(-device)?-width/i;
var isMinWidth = _testQuery(minMaxWidth, maxMinWidth, minWidth);
var isMaxWidth = _testQuery(maxMinWidth, minMaxWidth, maxWidth);
var minMaxHeight = /(!?\(\s*min(-device)?-height).+\(\s*max(-device)?-height/i;
var minHeight = /\(\s*min(-device)?-height/i;
var maxMinHeight = /(!?\(\s*max(-device)?-height).+\(\s*min(-device)?-height/i;
var maxHeight = /\(\s*max(-device)?-height/i;
var isMinHeight = _testQuery(minMaxHeight, maxMinHeight, minHeight);
var isMaxHeight = _testQuery(maxMinHeight, minMaxHeight, maxHeight);
var isPrint = /print/i;
var isPrintOnly = /^print$/i;
var maxValue = Number.MAX_VALUE;
function _getQueryLength(length) {
  const matches = /(-?\d*\.?\d+)(ch|em|ex|px|rem)/.exec(length);
  if (matches === null) {
    return maxValue;
  }
  let number = matches[1];
  const unit = matches[2];
  switch (unit) {
    case "ch":
      number = parseFloat(number) * 8.8984375;
      break;
    case "em":
    case "rem":
      number = parseFloat(number) * 16;
      break;
    case "ex":
      number = parseFloat(number) * 8.296875;
      break;
    case "px":
      number = parseFloat(number);
      break;
  }
  return +number;
}
function _testQuery(doubleTestTrue, doubleTestFalse, singleTest) {
  return function(query) {
    if (doubleTestTrue.test(query)) {
      return true;
    } else if (doubleTestFalse.test(query)) {
      return false;
    }
    return singleTest.test(query);
  };
}
function _testIsPrint(a, b) {
  const isPrintA = isPrint.test(a);
  const isPrintOnlyA = isPrintOnly.test(a);
  const isPrintB = isPrint.test(b);
  const isPrintOnlyB = isPrintOnly.test(b);
  if (isPrintA && isPrintB) {
    if (!isPrintOnlyA && isPrintOnlyB) {
      return 1;
    }
    if (isPrintOnlyA && !isPrintOnlyB) {
      return -1;
    }
    return a.localeCompare(b);
  }
  if (isPrintA) {
    return 1;
  }
  if (isPrintB) {
    return -1;
  }
  return null;
}
function sortCSSmq(a, b) {
  if (a === "") {
    return -1;
  }
  if (b === "") {
    return 1;
  }
  const testIsPrint = _testIsPrint(a, b);
  if (testIsPrint !== null) {
    return testIsPrint;
  }
  const minA = isMinWidth(a) || isMinHeight(a);
  const maxA = isMaxWidth(a) || isMaxHeight(a);
  const minB = isMinWidth(b) || isMinHeight(b);
  const maxB = isMaxWidth(b) || isMaxHeight(b);
  if (minA && maxB) {
    return -1;
  }
  if (maxA && minB) {
    return 1;
  }
  const lengthA = _getQueryLength(a);
  const lengthB = _getQueryLength(b);
  if (lengthA === maxValue && lengthB === maxValue) {
    return a.localeCompare(b);
  } else if (lengthA === maxValue) {
    return 1;
  } else if (lengthB === maxValue) {
    return -1;
  }
  if (lengthA > lengthB) {
    if (maxA) {
      return -1;
    }
    return 1;
  }
  if (lengthA < lengthB) {
    if (maxA) {
      return 1;
    }
    return -1;
  }
  return a.localeCompare(b);
}

// ../../../node_modules/.pnpm/styletron-engine-atomic@1.6.2/node_modules/styletron-engine-atomic/dist-browser-esm/cache.js
var MultiCache = class {
  constructor(idGenerator, onNewCache, onNewValue) {
    this.idGenerator = idGenerator;
    this.onNewCache = onNewCache;
    this.onNewValue = onNewValue;
    this.sortedCacheKeys = [];
    this.caches = {};
  }
  getCache(key) {
    if (!this.caches[key]) {
      const cache3 = new Cache(this.idGenerator, this.onNewValue);
      cache3.key = key;
      this.sortedCacheKeys.push(key);
      this.sortedCacheKeys.sort(sortCSSmq);
      const keyIndex = this.sortedCacheKeys.indexOf(key);
      const insertBeforeMedia = keyIndex < this.sortedCacheKeys.length - 1 ? this.sortedCacheKeys[keyIndex + 1] : void 0;
      this.caches[key] = cache3;
      this.onNewCache(key, cache3, insertBeforeMedia);
    }
    return this.caches[key];
  }
  getSortedCacheKeys() {
    return this.sortedCacheKeys;
  }
};
var Cache = class {
  constructor(idGenerator, onNewValue) {
    this.cache = {};
    this.idGenerator = idGenerator;
    this.onNewValue = onNewValue;
  }
  addValue(key, value) {
    const cached = this.cache[key];
    if (cached) {
      return cached;
    }
    const id = this.idGenerator.next();
    this.cache[key] = id;
    this.onNewValue(this, id, value);
    return id;
  }
};

// ../../../node_modules/.pnpm/styletron-engine-atomic@1.6.2/node_modules/styletron-engine-atomic/dist-browser-esm/hyphenate-style-name.js
var uppercasePattern = /[A-Z]/g;
var msPattern = /^ms-/;
var cache = {};
function hyphenateStyleName(prop) {
  return prop in cache ? cache[prop] : cache[prop] = prop.replace(uppercasePattern, "-$&").toLowerCase().replace(msPattern, "-ms-");
}

// ../../../node_modules/.pnpm/styletron-engine-atomic@1.6.2/node_modules/styletron-engine-atomic/dist-browser-esm/validate-no-mixed-hand.js
var shorthandMap = {
  // CSS 2.1: https://www.w3.org/TR/CSS2/propidx.html
  "list-style": ["list-style-type", "list-style-position", "list-style-image"],
  margin: ["margin-top", "margin-right", "margin-bottom", "margin-left"],
  outline: ["outline-width", "outline-style", "outline-color"],
  padding: ["padding-top", "padding-right", "padding-bottom", "padding-left"],
  // CSS Backgrounds and Borders Module Level 3: https://www.w3.org/TR/css3-background/
  background: ["background-image", "background-position", "background-size", "background-repeat", "background-origin", "background-clip", "background-attachment", "background-color"],
  border: ["border-top-width", "border-right-width", "border-bottom-width", "border-left-width", "border-width", "border-top-style", "border-right-style", "border-bottom-style", "border-left-style", "border-style", "border-top-color", "border-right-color", "border-bottom-color", "border-left-color", "border-color"],
  "border-color": ["border-top-color", "border-right-color", "border-bottom-color", "border-left-color"],
  "border-style": ["border-top-style", "border-right-style", "border-bottom-style", "border-left-style"],
  "border-width": ["border-top-width", "border-right-width", "border-bottom-width", "border-left-width"],
  "border-top": ["border-top-width", "border-top-style", "border-top-color"],
  "border-right": ["border-right-width", "border-right-style", "border-right-color"],
  "border-bottom": ["border-bottom-width", "border-bottom-style", "border-bottom-color"],
  "border-left": ["border-left-width", "border-left-style", "border-left-color"],
  "border-radius": ["border-top-left-radius", "border-top-right-radius", "border-bottom-right-radius", "border-bottom-left-radius"],
  "border-image": ["border-image-source", "border-image-slice", "border-image-width", "border-image-outset", "border-image-repeat"],
  // CSS Fonts Module Level 3: https://www.w3.org/TR/css3-fonts/
  font: ["font-style", "font-variant-ligatures", "font-variant-alternates", "font-variant-caps", "font-variant-numeric", "font-variant-east-asian", "font-variant", "font-weight", "font-stretch", "font-size", "line-height", "font-family"],
  "font-variant": ["font-variant-ligatures", "font-variant-alternates", "font-variant-caps", "font-variant-numeric", "font-variant-east-asian"],
  // CSS Flexible Box Layout Module Level 1: https://www.w3.org/TR/css3-flexbox-1/
  flex: ["flex-grow", "flex-shrink", "flex-basis"],
  "flex-flow": ["flex-direction", "flex-wrap"],
  // CSS Grid Layout Module Level 1: https://www.w3.org/TR/css-grid-1/
  grid: ["grid-template-rows", "grid-template-columns", "grid-template-areas", "grid-auto-rows", "grid-auto-columns", "grid-auto-flow"],
  "grid-template": ["grid-template-rows", "grid-template-columns", "grid-template-areas"],
  "grid-row": ["grid-row-start", "grid-row-end"],
  "grid-column": ["grid-column-start", "grid-column-end"],
  "grid-area": ["grid-row-start", "grid-column-start", "grid-row-end", "grid-column-end"],
  "grid-gap": ["grid-row-gap", "grid-column-gap"],
  // CSS Masking Module Level 1: https://www.w3.org/TR/css-masking/
  mask: ["mask-image", "mask-mode", "mask-position", "mask-size", "mask-repeat", "mask-origin", "mask-clip"],
  "mask-border": ["mask-border-source", "mask-border-slice", "mask-border-width", "mask-border-outset", "mask-border-repeat", "mask-border-mode"],
  // CSS Multi-column Layout Module: https://www.w3.org/TR/css3-multicol/
  columns: ["column-width", "column-count"],
  "column-rule": ["column-rule-width", "column-rule-style", "column-rule-color"],
  // CSS Scroll Snap Module Level 1: https://www.w3.org/TR/css-scroll-snap-1/
  "scroll-padding": ["scroll-padding-top", "scroll-padding-right", "scroll-padding-bottom", "scroll-padding-left"],
  "scroll-padding-block": ["scroll-padding-block-start", "scroll-padding-block-end"],
  "scroll-padding-inline": ["scroll-padding-inline-start", "scroll-padding-inline-end"],
  "scroll-snap-margin": ["scroll-snap-margin-top", "scroll-snap-margin-right", "scroll-snap-margin-bottom", "scroll-snap-margin-left"],
  "scroll-snap-margin-block": ["scroll-snap-margin-block-start", "scroll-snap-margin-block-end"],
  "scroll-snap-margin-inline": ["scroll-snap-margin-inline-start", "scroll-snap-margin-inline-end"],
  // CSS Speech Module: https://www.w3.org/TR/css3-speech/
  cue: ["cue-before", "cue-after"],
  pause: ["pause-before", "pause-after"],
  rest: ["rest-before", "rest-after"],
  // CSS Text Decoration Module Level 3: https://www.w3.org/TR/css-text-decor-3/
  "text-decoration": ["text-decoration-line", "text-decoration-style", "text-decoration-color"],
  "text-emphasis": ["text-emphasis-style", "text-emphasis-color"],
  // CSS Animations (WD): https://www.w3.org/TR/css3-animations
  animation: ["animation-name", "animation-duration", "animation-timing-function", "animation-delay", "animation-iteration-count", "animation-direction", "animation-fill-mode", "animation-play-state"],
  // CSS Transitions (WD): https://www.w3.org/TR/css3-transitions/
  transition: ["transition-property", "transition-duration", "transition-timing-function", "transition-delay"]
};
function validateNoMixedHand(style) {
  const hyphenatedProperties = Object.keys(style).reduce((acc, property) => {
    acc[hyphenateStyleName(property)] = property;
    return acc;
  }, {});
  const mixed = [];
  for (const property in hyphenatedProperties) {
    if (property in shorthandMap) {
      for (const longhand of shorthandMap[property]) {
        if (longhand in hyphenatedProperties) {
          const long = hyphenatedProperties[longhand];
          const short = hyphenatedProperties[property];
          mixed.push({
            shorthand: {
              property: short,
              value: style[short]
            },
            longhand: {
              property: long,
              value: style[long]
            }
          });
        }
      }
    }
  }
  return mixed;
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/utils/capitalizeString.js
function capitalizeString(str) {
  return str.charAt(0).toUpperCase() + str.slice(1);
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/utils/prefixProperty.js
function prefixProperty(prefixProperties, property, style) {
  if (prefixProperties.hasOwnProperty(property)) {
    var newStyle = {};
    var requiredPrefixes = prefixProperties[property];
    var capitalizedProperty = capitalizeString(property);
    var keys = Object.keys(style);
    for (var i = 0; i < keys.length; i++) {
      var styleProperty = keys[i];
      if (styleProperty === property) {
        for (var j = 0; j < requiredPrefixes.length; j++) {
          newStyle[requiredPrefixes[j] + capitalizedProperty] = style[property];
        }
      }
      newStyle[styleProperty] = style[styleProperty];
    }
    return newStyle;
  }
  return style;
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/utils/prefixValue.js
function prefixValue(plugins2, property, value, style, metaData) {
  for (var i = 0, len = plugins2.length; i < len; ++i) {
    var processedValue = plugins2[i](property, value, style, metaData);
    if (processedValue) {
      return processedValue;
    }
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/utils/addNewValuesOnly.js
function addIfNew(list, value) {
  if (list.indexOf(value) === -1) {
    list.push(value);
  }
}
function addNewValuesOnly(list, values5) {
  if (Array.isArray(values5)) {
    for (var i = 0, len = values5.length; i < len; ++i) {
      addIfNew(list, values5[i]);
    }
  } else {
    addIfNew(list, values5);
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/utils/isObject.js
function isObject(value) {
  return value instanceof Object && !Array.isArray(value);
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/createPrefixer.js
function createPrefixer(_ref) {
  var prefixMap = _ref.prefixMap, plugins2 = _ref.plugins;
  return function prefix2(style) {
    for (var property in style) {
      var value = style[property];
      if (isObject(value)) {
        style[property] = prefix2(value);
      } else if (Array.isArray(value)) {
        var combinedValue = [];
        for (var i = 0, len = value.length; i < len; ++i) {
          var processedValue = prefixValue(plugins2, property, value[i], style, prefixMap);
          addNewValuesOnly(combinedValue, processedValue || value[i]);
        }
        if (combinedValue.length > 0) {
          style[property] = combinedValue;
        }
      } else {
        var _processedValue = prefixValue(plugins2, property, value, style, prefixMap);
        if (_processedValue) {
          style[property] = _processedValue;
        }
        style = prefixProperty(prefixMap, property, style);
      }
    }
    return style;
  };
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/data.js
var w = ["Webkit"];
var m = ["Moz"];
var ms = ["ms"];
var wm = ["Webkit", "Moz"];
var wms = ["Webkit", "ms"];
var wmms = ["Webkit", "Moz", "ms"];
var data_default = {
  plugins: [],
  prefixMap: { "appearance": wm, "textEmphasisPosition": w, "textEmphasis": w, "textEmphasisStyle": w, "textEmphasisColor": w, "boxDecorationBreak": w, "maskImage": w, "maskMode": w, "maskRepeat": w, "maskPosition": w, "maskClip": w, "maskOrigin": w, "maskSize": w, "maskComposite": w, "mask": w, "maskBorderSource": w, "maskBorderMode": w, "maskBorderSlice": w, "maskBorderWidth": w, "maskBorderOutset": w, "maskBorderRepeat": w, "maskBorder": w, "maskType": w, "textDecorationStyle": w, "textDecorationSkip": w, "textDecorationLine": w, "textDecorationColor": w, "userSelect": wmms, "backdropFilter": w, "fontKerning": w, "scrollSnapType": wms, "scrollSnapPointsX": wms, "scrollSnapPointsY": wms, "scrollSnapDestination": wms, "scrollSnapCoordinate": wms, "clipPath": w, "shapeImageThreshold": w, "shapeImageMargin": w, "shapeImageOutside": w, "filter": w, "hyphens": wms, "flowInto": wms, "flowFrom": wms, "breakBefore": wms, "breakAfter": wms, "breakInside": wms, "regionFragment": wms, "writingMode": wms, "textOrientation": w, "tabSize": m, "fontFeatureSettings": w, "columnCount": w, "columnFill": w, "columnGap": w, "columnRule": w, "columnRuleColor": w, "columnRuleStyle": w, "columnRuleWidth": w, "columns": w, "columnSpan": w, "columnWidth": w, "wrapFlow": ms, "wrapThrough": ms, "wrapMargin": ms, "textSizeAdjust": wms }
};

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/plugins/backgroundClip.js
function backgroundClip(property, value) {
  if (typeof value === "string" && value === "text") {
    return ["-webkit-text", "text"];
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/plugins/cursor.js
var prefixes = ["-webkit-", "-moz-", ""];
var values = {
  "zoom-in": true,
  "zoom-out": true,
  grab: true,
  grabbing: true
};
function cursor(property, value) {
  if (property === "cursor" && values.hasOwnProperty(value)) {
    return prefixes.map(function(prefix2) {
      return prefix2 + value;
    });
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/plugins/crossFade.js
var import_isPrefixedValue = __toESM(require_isPrefixedValue());
var prefixes2 = ["-webkit-", ""];
function crossFade(property, value) {
  if (typeof value === "string" && !(0, import_isPrefixedValue.default)(value) && value.indexOf("cross-fade(") > -1) {
    return prefixes2.map(function(prefix2) {
      return value.replace(/cross-fade\(/g, prefix2 + "cross-fade(");
    });
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/plugins/filter.js
var import_isPrefixedValue2 = __toESM(require_isPrefixedValue());
var prefixes3 = ["-webkit-", ""];
function filter(property, value) {
  if (typeof value === "string" && !(0, import_isPrefixedValue2.default)(value) && value.indexOf("filter(") > -1) {
    return prefixes3.map(function(prefix2) {
      return value.replace(/filter\(/g, prefix2 + "filter(");
    });
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/plugins/flex.js
var values2 = {
  flex: ["-webkit-box", "-moz-box", "-ms-flexbox", "-webkit-flex", "flex"],
  "inline-flex": ["-webkit-inline-box", "-moz-inline-box", "-ms-inline-flexbox", "-webkit-inline-flex", "inline-flex"]
};
function flex(property, value) {
  if (property === "display" && values2.hasOwnProperty(value)) {
    return values2[value];
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/plugins/flexboxOld.js
var alternativeValues = {
  "space-around": "justify",
  "space-between": "justify",
  "flex-start": "start",
  "flex-end": "end",
  "wrap-reverse": "multiple",
  wrap: "multiple"
};
var alternativeProps = {
  alignItems: "WebkitBoxAlign",
  justifyContent: "WebkitBoxPack",
  flexWrap: "WebkitBoxLines",
  flexGrow: "WebkitBoxFlex"
};
function flexboxOld(property, value, style) {
  if (property === "flexDirection" && typeof value === "string") {
    if (value.indexOf("column") > -1) {
      style.WebkitBoxOrient = "vertical";
    } else {
      style.WebkitBoxOrient = "horizontal";
    }
    if (value.indexOf("reverse") > -1) {
      style.WebkitBoxDirection = "reverse";
    } else {
      style.WebkitBoxDirection = "normal";
    }
  }
  if (alternativeProps.hasOwnProperty(property)) {
    style[alternativeProps[property]] = alternativeValues[value] || value;
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/plugins/gradient.js
var import_isPrefixedValue3 = __toESM(require_isPrefixedValue());
var prefixes4 = ["-webkit-", "-moz-", ""];
var values3 = /linear-gradient|radial-gradient|repeating-linear-gradient|repeating-radial-gradient/gi;
function gradient(property, value) {
  if (typeof value === "string" && !(0, import_isPrefixedValue3.default)(value) && values3.test(value)) {
    return prefixes4.map(function(prefix2) {
      return value.replace(values3, function(grad) {
        return prefix2 + grad;
      });
    });
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/plugins/grid.js
var _slicedToArray = /* @__PURE__ */ (function() {
  function sliceIterator(arr, i) {
    var _arr = [];
    var _n = true;
    var _d = false;
    var _e = void 0;
    try {
      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);
        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"]) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }
    return _arr;
  }
  return function(arr, i) {
    if (Array.isArray(arr)) {
      return arr;
    } else if (Symbol.iterator in Object(arr)) {
      return sliceIterator(arr, i);
    } else {
      throw new TypeError("Invalid attempt to destructure non-iterable instance");
    }
  };
})();
function isSimplePositionValue(value) {
  return typeof value === "number" && !isNaN(value);
}
function isComplexSpanValue(value) {
  return typeof value === "string" && value.includes("/");
}
var alignmentValues = ["center", "end", "start", "stretch"];
var displayValues = {
  "inline-grid": ["-ms-inline-grid", "inline-grid"],
  grid: ["-ms-grid", "grid"]
};
var propertyConverters = {
  alignSelf: function alignSelf(value, style) {
    if (alignmentValues.indexOf(value) > -1) {
      style.msGridRowAlign = value;
    }
  },
  gridColumn: function gridColumn(value, style) {
    if (isSimplePositionValue(value)) {
      style.msGridColumn = value;
    } else if (isComplexSpanValue(value)) {
      var _value$split = value.split("/"), _value$split2 = _slicedToArray(_value$split, 2), start = _value$split2[0], end = _value$split2[1];
      propertyConverters.gridColumnStart(+start, style);
      var _end$split = end.split(/ ?span /), _end$split2 = _slicedToArray(_end$split, 2), maybeSpan = _end$split2[0], maybeNumber = _end$split2[1];
      if (maybeSpan === "") {
        propertyConverters.gridColumnEnd(+start + +maybeNumber, style);
      } else {
        propertyConverters.gridColumnEnd(+end, style);
      }
    } else {
      propertyConverters.gridColumnStart(value, style);
    }
  },
  gridColumnEnd: function gridColumnEnd(value, style) {
    var msGridColumn = style.msGridColumn;
    if (isSimplePositionValue(value) && isSimplePositionValue(msGridColumn)) {
      style.msGridColumnSpan = value - msGridColumn;
    }
  },
  gridColumnStart: function gridColumnStart(value, style) {
    if (isSimplePositionValue(value)) {
      style.msGridColumn = value;
    }
  },
  gridRow: function gridRow(value, style) {
    if (isSimplePositionValue(value)) {
      style.msGridRow = value;
    } else if (isComplexSpanValue(value)) {
      var _value$split3 = value.split("/"), _value$split4 = _slicedToArray(_value$split3, 2), start = _value$split4[0], end = _value$split4[1];
      propertyConverters.gridRowStart(+start, style);
      var _end$split3 = end.split(/ ?span /), _end$split4 = _slicedToArray(_end$split3, 2), maybeSpan = _end$split4[0], maybeNumber = _end$split4[1];
      if (maybeSpan === "") {
        propertyConverters.gridRowEnd(+start + +maybeNumber, style);
      } else {
        propertyConverters.gridRowEnd(+end, style);
      }
    } else {
      propertyConverters.gridRowStart(value, style);
    }
  },
  gridRowEnd: function gridRowEnd(value, style) {
    var msGridRow = style.msGridRow;
    if (isSimplePositionValue(value) && isSimplePositionValue(msGridRow)) {
      style.msGridRowSpan = value - msGridRow;
    }
  },
  gridRowStart: function gridRowStart(value, style) {
    if (isSimplePositionValue(value)) {
      style.msGridRow = value;
    }
  },
  gridTemplateColumns: function gridTemplateColumns(value, style) {
    style.msGridColumns = value;
  },
  gridTemplateRows: function gridTemplateRows(value, style) {
    style.msGridRows = value;
  },
  justifySelf: function justifySelf(value, style) {
    if (alignmentValues.indexOf(value) > -1) {
      style.msGridColumnAlign = value;
    }
  }
};
function grid(property, value, style) {
  if (property === "display" && value in displayValues) {
    return displayValues[value];
  }
  if (property in propertyConverters) {
    var propertyConverter = propertyConverters[property];
    propertyConverter(value, style);
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/plugins/imageSet.js
var import_isPrefixedValue4 = __toESM(require_isPrefixedValue());
var prefixes5 = ["-webkit-", ""];
function imageSet(property, value) {
  if (typeof value === "string" && !(0, import_isPrefixedValue4.default)(value) && value.indexOf("image-set(") > -1) {
    return prefixes5.map(function(prefix2) {
      return value.replace(/image-set\(/g, prefix2 + "image-set(");
    });
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/plugins/logical.js
var alternativeProps2 = {
  marginBlockStart: ["WebkitMarginBefore"],
  marginBlockEnd: ["WebkitMarginAfter"],
  marginInlineStart: ["WebkitMarginStart", "MozMarginStart"],
  marginInlineEnd: ["WebkitMarginEnd", "MozMarginEnd"],
  paddingBlockStart: ["WebkitPaddingBefore"],
  paddingBlockEnd: ["WebkitPaddingAfter"],
  paddingInlineStart: ["WebkitPaddingStart", "MozPaddingStart"],
  paddingInlineEnd: ["WebkitPaddingEnd", "MozPaddingEnd"],
  borderBlockStart: ["WebkitBorderBefore"],
  borderBlockStartColor: ["WebkitBorderBeforeColor"],
  borderBlockStartStyle: ["WebkitBorderBeforeStyle"],
  borderBlockStartWidth: ["WebkitBorderBeforeWidth"],
  borderBlockEnd: ["WebkitBorderAfter"],
  borderBlockEndColor: ["WebkitBorderAfterColor"],
  borderBlockEndStyle: ["WebkitBorderAfterStyle"],
  borderBlockEndWidth: ["WebkitBorderAfterWidth"],
  borderInlineStart: ["WebkitBorderStart", "MozBorderStart"],
  borderInlineStartColor: ["WebkitBorderStartColor", "MozBorderStartColor"],
  borderInlineStartStyle: ["WebkitBorderStartStyle", "MozBorderStartStyle"],
  borderInlineStartWidth: ["WebkitBorderStartWidth", "MozBorderStartWidth"],
  borderInlineEnd: ["WebkitBorderEnd", "MozBorderEnd"],
  borderInlineEndColor: ["WebkitBorderEndColor", "MozBorderEndColor"],
  borderInlineEndStyle: ["WebkitBorderEndStyle", "MozBorderEndStyle"],
  borderInlineEndWidth: ["WebkitBorderEndWidth", "MozBorderEndWidth"]
};
function logical(property, value, style) {
  if (Object.prototype.hasOwnProperty.call(alternativeProps2, property)) {
    var alternativePropList = alternativeProps2[property];
    for (var i = 0, len = alternativePropList.length; i < len; ++i) {
      style[alternativePropList[i]] = value;
    }
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/plugins/position.js
function position(property, value) {
  if (property === "position" && value === "sticky") {
    return ["-webkit-sticky", "sticky"];
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/plugins/sizing.js
var prefixes6 = ["-webkit-", "-moz-", ""];
var properties = {
  maxHeight: true,
  maxWidth: true,
  width: true,
  height: true,
  columnWidth: true,
  minWidth: true,
  minHeight: true
};
var values4 = {
  "min-content": true,
  "max-content": true,
  "fill-available": true,
  "fit-content": true,
  "contain-floats": true
};
function sizing(property, value) {
  if (properties.hasOwnProperty(property) && values4.hasOwnProperty(value)) {
    return prefixes6.map(function(prefix2) {
      return prefix2 + value;
    });
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/plugins/transition.js
var import_hyphenateProperty = __toESM(require_hyphenateProperty());
var import_isPrefixedValue5 = __toESM(require_isPrefixedValue());
var properties2 = {
  transition: true,
  transitionProperty: true,
  WebkitTransition: true,
  WebkitTransitionProperty: true,
  MozTransition: true,
  MozTransitionProperty: true
};
var prefixMapping = {
  Webkit: "-webkit-",
  Moz: "-moz-",
  ms: "-ms-"
};
function prefixValue2(value, propertyPrefixMap) {
  if ((0, import_isPrefixedValue5.default)(value)) {
    return value;
  }
  var multipleValues = value.split(/,(?![^()]*(?:\([^()]*\))?\))/g);
  for (var i = 0, len = multipleValues.length; i < len; ++i) {
    var singleValue = multipleValues[i];
    var values5 = [singleValue];
    for (var property in propertyPrefixMap) {
      var dashCaseProperty = (0, import_hyphenateProperty.default)(property);
      if (singleValue.indexOf(dashCaseProperty) > -1 && dashCaseProperty !== "order") {
        var prefixes7 = propertyPrefixMap[property];
        for (var j = 0, pLen = prefixes7.length; j < pLen; ++j) {
          values5.unshift(singleValue.replace(dashCaseProperty, prefixMapping[prefixes7[j]] + dashCaseProperty));
        }
      }
    }
    multipleValues[i] = values5.join(",");
  }
  return multipleValues.join(",");
}
function transition(property, value, style, propertyPrefixMap) {
  if (typeof value === "string" && properties2.hasOwnProperty(property)) {
    var outputValue = prefixValue2(value, propertyPrefixMap);
    var webkitOutput = outputValue.split(/,(?![^()]*(?:\([^()]*\))?\))/g).filter(function(val) {
      return !/-moz-|-ms-/.test(val);
    }).join(",");
    if (property.indexOf("Webkit") > -1) {
      return webkitOutput;
    }
    var mozOutput = outputValue.split(/,(?![^()]*(?:\([^()]*\))?\))/g).filter(function(val) {
      return !/-webkit-|-ms-/.test(val);
    }).join(",");
    if (property.indexOf("Moz") > -1) {
      return mozOutput;
    }
    style["Webkit" + capitalizeString(property)] = webkitOutput;
    style["Moz" + capitalizeString(property)] = mozOutput;
    return outputValue;
  }
}

// ../../../node_modules/.pnpm/inline-style-prefixer@5.1.2/node_modules/inline-style-prefixer/es/index.js
var plugins = [backgroundClip, crossFade, cursor, filter, flexboxOld, gradient, grid, imageSet, logical, position, sizing, transition, flex];
var prefix = createPrefixer({
  prefixMap: data_default.prefixMap,
  plugins
});

// ../../../node_modules/.pnpm/styletron-engine-atomic@1.6.2/node_modules/styletron-engine-atomic/dist-browser-esm/inject-style-prefixed.js
function injectStylePrefixed(styleCache, styles, media, pseudo) {
  const cache3 = styleCache.getCache(media);
  let classString = "";
  for (const originalKey in styles) {
    const originalVal = styles[originalKey];
    if (originalVal === void 0 || originalVal === null) {
      continue;
    }
    if (typeof originalVal !== "object") {
      if (true) {
        validateValueType(originalVal, originalKey);
      }
      const propValPair = `${hyphenateStyleName(originalKey)}:${originalVal}`;
      const key = `${pseudo}${propValPair}`;
      const cachedId = cache3.cache[key];
      if (cachedId !== void 0) {
        classString += " " + cachedId;
        continue;
      } else {
        let block = "";
        const prefixed = prefix({
          [originalKey]: originalVal
        });
        for (const prefixedKey in prefixed) {
          const prefixedVal = prefixed[prefixedKey];
          const prefixedValType = typeof prefixedVal;
          if (prefixedValType === "string" || prefixedValType === "number") {
            const prefixedPair = `${hyphenateStyleName(prefixedKey)}:${prefixedVal}`;
            if (prefixedPair !== propValPair) {
              block += `${prefixedPair};`;
            }
          } else if (Array.isArray(prefixedVal)) {
            const hyphenated = hyphenateStyleName(prefixedKey);
            for (let i = 0; i < prefixedVal.length; i++) {
              const prefixedPair = `${hyphenated}:${prefixedVal[i]}`;
              if (prefixedPair !== propValPair) {
                block += `${prefixedPair};`;
              }
            }
          }
        }
        block += propValPair;
        const id = cache3.addValue(key, {
          pseudo,
          block
        });
        classString += " " + id;
      }
    } else {
      if (originalKey[0] === ":") {
        classString += " " + injectStylePrefixed(styleCache, originalVal, media, pseudo + originalKey);
      } else if (originalKey.substring(0, 6) === "@media") {
        classString += " " + injectStylePrefixed(styleCache, originalVal, originalKey.substr(7), pseudo);
      }
    }
  }
  if (true) {
    const conflicts = validateNoMixedHand(styles);
    if (conflicts.length) {
      conflicts.forEach(({
        shorthand,
        longhand
      }) => {
        const short = JSON.stringify({
          [shorthand.property]: shorthand.value
        });
        const long = JSON.stringify({
          [longhand.property]: longhand.value
        });
        console.warn(`Styles \`${short}\` and \`${long}\` in object yielding class "${classString.slice(1)}" may result in unexpected behavior. Mixing shorthand and longhand properties within the same style object is unsupported with atomic rendering.`);
      });
    }
  }
  return classString.slice(1);
}
function validateValueType(value, key) {
  if (value === null || Array.isArray(value) || typeof value !== "number" && typeof value !== "string") {
    throw new Error(`Unsupported style value: ${JSON.stringify(value)} used in property ${JSON.stringify(key)}`);
  }
}

// ../../../node_modules/.pnpm/styletron-engine-atomic@1.6.2/node_modules/styletron-engine-atomic/dist-browser-esm/validate-keyframes-object.js
var validAnimationState = /^(from|to|\+?(\d*\.)?\d+%)(\s*,\s*(from|to|\+?(\d*\.)?\d+%))*$/;
function validateKeyframesObject(keyframes) {
  let valid = true;
  for (const animationState in keyframes) {
    const value = keyframes[animationState];
    if (!validAnimationState.test(animationState)) {
      valid = false;
      console.warn(`Warning: property "${animationState}" in keyframes object ${JSON.stringify(keyframes)} is not a valid. Must be "from", "to", or a percentage.`);
    }
    if (typeof value !== "object") {
      valid = false;
      console.warn(`Warning: value for "${animationState}" property in keyframes object ${JSON.stringify(keyframes)} must be an object. Instead it was a ${typeof value}.`);
    }
    if (!valid) {
      console.warn(`Warning: object used as value for "animationName" style is invalid:`, keyframes);
    }
  }
}

// ../../../node_modules/.pnpm/styletron-engine-atomic@1.6.2/node_modules/styletron-engine-atomic/dist-browser-esm/css.js
function atomicSelector(id, pseudo) {
  let selector = `.${id}`;
  if (pseudo) {
    selector += pseudo;
  }
  return selector;
}
function keyframesToBlock(keyframes) {
  if (true) {
    validateKeyframesObject(keyframes);
  }
  if (typeof Object.getPrototypeOf(keyframes) !== "undefined") {
    if (Object.getPrototypeOf(keyframes) !== Object.getPrototypeOf({})) {
      console.warn("Only plain objects should be used as animation values. Unexpectedly recieved:", keyframes);
    }
  }
  let result = "";
  for (const animationState in keyframes) {
    result += `${animationState}{${declarationsToBlock(keyframes[animationState])}}`;
  }
  return result;
}
function declarationsToBlock(style) {
  let css = "";
  for (const prop in style) {
    const val = style[prop];
    if (typeof val === "string" || typeof val === "number") {
      css += `${hyphenateStyleName(prop)}:${val};`;
    }
  }
  return css.slice(0, -1);
}
function keyframesBlockToRule(id, block) {
  return `@keyframes ${id}{${block}}`;
}
function fontFaceBlockToRule(id, block) {
  return `@font-face{font-family:${id};${block}}`;
}
function styleBlockToRule(selector, block) {
  return `${selector}{${block}}`;
}

// ../../../node_modules/.pnpm/styletron-engine-atomic@1.6.2/node_modules/styletron-engine-atomic/dist-browser-esm/dev-tool.js
var insertRuleIntoDevtools = (selector, block) => {
  const key = selector.substring(1, selector.indexOf(":") !== -1 ? selector.indexOf(":") : selector.length);
  const styles = {};
  for (const decl of block.split(";")) {
    if (decl.trim() !== "" && !window.__STYLETRON_DEVTOOLS__.atomicMap[key]) styles[decl.substring(0, decl.indexOf(":"))] = decl.substring(decl.indexOf(":") + 1, decl.length);
  }
  window.__STYLETRON_DEVTOOLS__.atomicMap[key] = styles;
};
var hydrateDevtoolsRule = (cssString) => {
  const id = cssString.substring(0, 3);
  const block = cssString.substring(4, cssString.length - 1);
  insertRuleIntoDevtools(id, block);
};

// ../../../node_modules/.pnpm/styletron-engine-atomic@1.6.2/node_modules/styletron-engine-atomic/dist-browser-esm/client/client.js
var STYLES_HYDRATOR = /\.([^{:]+)(:[^{]+)?{(?:[^}]*;)?([^}]*?)}/g;
var KEYFRAMES_HYRDATOR = /@keyframes ([^{]+){((?:(?:from|to|(?:\d+\.?\d*%))\{(?:[^}])*})*)}/g;
var FONT_FACE_HYDRATOR = /@font-face\{font-family:([^;]+);([^}]*)\}/g;
function hydrateStyles(cache3, hydrator, css) {
  let match;
  while (match = hydrator.exec(css)) {
    const [, id, pseudo, key] = match;
    if (window.__STYLETRON_DEVTOOLS__) {
      hydrateDevtoolsRule(match[0]);
    }
    const fullKey = pseudo ? `${pseudo}${key}` : key;
    cache3.cache[fullKey] = id;
    cache3.idGenerator.increment();
  }
}
function hydrate(cache3, hydrator, css) {
  let match;
  while (match = hydrator.exec(css)) {
    const [, id, key] = match;
    if (window.__STYLETRON_DEVTOOLS__) {
      hydrateDevtoolsRule(match[0]);
    }
    cache3.cache[key] = id;
    cache3.idGenerator.increment();
  }
}
var StyletronClient = class {
  constructor(opts = {}) {
    this.styleElements = {};
    const styleIdGenerator = new SequentialIDGenerator(opts.prefix);
    const onNewStyle = (cache3, id, value) => {
      const {
        pseudo,
        block
      } = value;
      const sheet = this.styleElements[cache3.key].sheet;
      const selector = atomicSelector(id, pseudo);
      const rule = styleBlockToRule(selector, block);
      try {
        sheet.insertRule(rule, sheet.cssRules.length);
        if (window.__STYLETRON_DEVTOOLS__) {
          insertRuleIntoDevtools(selector, block);
        }
      } catch (e) {
        if (true) {
          console.warn(`Failed to inject CSS: "${rule}". Perhaps this has invalid or un-prefixed properties?`);
        }
      }
    };
    this.styleCache = new MultiCache(styleIdGenerator, (media, _cache, insertBeforeMedia) => {
      const styleElement = document.createElement("style");
      styleElement.media = media;
      if (insertBeforeMedia === void 0) {
        this.container.appendChild(styleElement);
      } else {
        const insertBeforeIndex = findSheetIndexWithMedia(this.container.children, insertBeforeMedia);
        this.container.insertBefore(styleElement, this.container.children[insertBeforeIndex]);
      }
      this.styleElements[media] = styleElement;
    }, onNewStyle);
    this.keyframesCache = new Cache(new SequentialIDGenerator(opts.prefix), (cache3, id, value) => {
      this.styleCache.getCache("");
      const sheet = this.styleElements[""].sheet;
      const rule = keyframesBlockToRule(id, keyframesToBlock(value));
      try {
        sheet.insertRule(rule, sheet.cssRules.length);
      } catch (e) {
        if (true) {
          console.warn(`Failed to inject CSS: "${rule}". Perhaps this has invalid or un-prefixed properties?`);
        }
      }
    });
    this.fontFaceCache = new Cache(new SequentialIDGenerator(opts.prefix), (cache3, id, value) => {
      this.styleCache.getCache("");
      const sheet = this.styleElements[""].sheet;
      const rule = fontFaceBlockToRule(id, declarationsToBlock(value));
      try {
        sheet.insertRule(rule, sheet.cssRules.length);
      } catch (e) {
        if (true) {
          console.warn(`Failed to inject CSS: "${rule}". Perhaps this has invalid or un-prefixed properties?`);
        }
      }
    });
    if (opts.container) {
      this.container = opts.container;
    }
    if (opts.hydrate && opts.hydrate.length > 0) {
      if (!this.container) {
        const parentElement = opts.hydrate[0].parentElement;
        if (parentElement !== null && parentElement !== void 0) {
          this.container = parentElement;
        }
      }
      for (let i = 0; i < opts.hydrate.length; i++) {
        const element = opts.hydrate[i];
        const hydrateType = element.getAttribute("data-hydrate");
        if (hydrateType === "font-face") {
          hydrate(this.fontFaceCache, FONT_FACE_HYDRATOR, element.textContent);
          continue;
        }
        if (hydrateType === "keyframes") {
          hydrate(this.keyframesCache, KEYFRAMES_HYRDATOR, element.textContent);
          continue;
        }
        const key = element.media ? element.media : "";
        this.styleElements[key] = element;
        const cache3 = new Cache(styleIdGenerator, onNewStyle);
        cache3.key = key;
        hydrateStyles(cache3, STYLES_HYDRATOR, element.textContent);
        this.styleCache.sortedCacheKeys.push(key);
        this.styleCache.caches[key] = cache3;
      }
    }
    if (!this.container) {
      if (document.head === null) {
        throw new Error("No container provided and `document.head` was null");
      }
      this.container = document.head;
    }
  }
  renderStyle(style) {
    return injectStylePrefixed(this.styleCache, style, "", "");
  }
  renderFontFace(fontFace) {
    const key = declarationsToBlock(fontFace);
    return this.fontFaceCache.addValue(key, fontFace);
  }
  renderKeyframes(keyframes) {
    const key = keyframesToBlock(keyframes);
    return this.keyframesCache.addValue(key, keyframes);
  }
};
var client_default = StyletronClient;
function findSheetIndexWithMedia(children, media) {
  let index = 0;
  for (; index < children.length; index++) {
    const child = children[index];
    if (child.tagName === "STYLE" && child.media === media) {
      return index;
    }
  }
  return -1;
}

// ../../../node_modules/.pnpm/styletron-engine-atomic@1.6.2/node_modules/styletron-engine-atomic/dist-browser-esm/server/server.js
var StyletronServer = class {
  constructor(opts = {}) {
    this.styleRules = {
      "": ""
    };
    this.styleCache = new MultiCache(new SequentialIDGenerator(opts.prefix), (media) => {
      this.styleRules[media] = "";
    }, (cache3, id, value) => {
      const {
        pseudo,
        block
      } = value;
      this.styleRules[cache3.key] += styleBlockToRule(atomicSelector(id, pseudo), block);
    });
    this.fontFaceRules = "";
    this.fontFaceCache = new Cache(new SequentialIDGenerator(opts.prefix), (cache3, id, value) => {
      this.fontFaceRules += fontFaceBlockToRule(id, declarationsToBlock(value));
    });
    this.keyframesRules = "";
    this.keyframesCache = new Cache(new SequentialIDGenerator(opts.prefix), (cache3, id, value) => {
      this.keyframesRules += keyframesBlockToRule(id, keyframesToBlock(value));
    });
  }
  renderStyle(style) {
    return injectStylePrefixed(this.styleCache, style, "", "");
  }
  renderFontFace(fontFace) {
    const key = JSON.stringify(fontFace);
    return this.fontFaceCache.addValue(key, fontFace);
  }
  renderKeyframes(keyframes) {
    const key = JSON.stringify(keyframes);
    return this.keyframesCache.addValue(key, keyframes);
  }
  getStylesheets() {
    return [...this.keyframesRules.length ? [{
      css: this.keyframesRules,
      attrs: {
        "data-hydrate": "keyframes"
      }
    }] : [], ...this.fontFaceRules.length ? [{
      css: this.fontFaceRules,
      attrs: {
        "data-hydrate": "font-face"
      }
    }] : [], ...sheetify(this.styleRules, this.styleCache.getSortedCacheKeys())];
  }
  getStylesheetsHtml(className = "_styletron_hydrate_") {
    return generateHtmlString(this.getStylesheets(), className);
  }
  getCss() {
    return this.keyframesRules + this.fontFaceRules + stringify(this.styleRules, this.styleCache.getSortedCacheKeys());
  }
};
function generateHtmlString(sheets, className) {
  let html = "";
  for (let i = 0; i < sheets.length; i++) {
    const sheet = sheets[i];
    const {
      class: originalClassName,
      ...rest
    } = sheet.attrs;
    const attrs = {
      class: originalClassName ? `${className} ${originalClassName}` : className,
      ...rest
    };
    html += `<style${attrsToString(attrs)}>${sheet.css}</style>`;
  }
  return html;
}
function attrsToString(attrs) {
  let result = "";
  for (const attr in attrs) {
    const value = attrs[attr];
    if (value === true) {
      result += " " + attr;
    } else if (value !== false) {
      result += ` ${attr}="${value}"`;
    }
  }
  return result;
}
function stringify(styleRules, sortedCacheKeys) {
  let result = "";
  sortedCacheKeys.forEach((cacheKey) => {
    const rules = styleRules[cacheKey];
    if (cacheKey !== "") {
      result += `@media ${cacheKey}{${rules}}`;
    } else {
      result += rules;
    }
  });
  return result;
}
function sheetify(styleRules, sortedCacheKeys) {
  if (sortedCacheKeys.length === 0) {
    return [{
      css: "",
      attrs: {}
    }];
  }
  const sheets = [];
  sortedCacheKeys.forEach((cacheKey) => {
    const attrs = cacheKey === "" ? {} : {
      media: cacheKey
    };
    sheets.push({
      css: styleRules[cacheKey],
      attrs
    });
  });
  return sheets;
}
var server_default = StyletronServer;
export {
  client_default as Client,
  server_default as Server
};
//# sourceMappingURL=styletron-engine-atomic.js.map