mirror of
https://github.com/harivansh-afk/sandbox-agent.git
synced 2026-04-15 23:01:37 +00:00
1247 lines
47 KiB
JavaScript
1247 lines
47 KiB
JavaScript
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
|