@tamagui/react-native-web-internals 1.116.0 → 1.116.2

package/dist/cjs/StyleSheet/compiler/index.js

@@ -0,0 +1,253 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var compiler_exports = {};
+__export(compiler_exports, {
+  atomic: () => atomic,
+  classic: () => classic,
+  inline: () => inline,
+  stringifyValueWithProperty: () => stringifyValueWithProperty
+});
+module.exports = __toCommonJS(compiler_exports);
+var import_simple_hash = require("@tamagui/simple-hash"), import_createReactDOMStyle = __toESM(require("./createReactDOMStyle")), import_hyphenateStyleName = __toESM(require("./hyphenateStyleName")), import_normalizeValueWithProperty = __toESM(require("./normalizeValueWithProperty"));
+const cache = /* @__PURE__ */ new Map(), emptyObject = {}, classicGroup = 1, atomicGroup = 2.2, customGroup = {
+  borderColor: 2,
+  borderRadius: 2,
+  borderStyle: 2,
+  borderWidth: 2,
+  display: 2,
+  flex: 2,
+  margin: 2,
+  overflow: 2,
+  overscrollBehavior: 2,
+  padding: 2,
+  marginHorizontal: 2.1,
+  marginVertical: 2.1,
+  paddingHorizontal: 2.1,
+  paddingVertical: 2.1
+}, borderTopLeftRadius = "borderTopLeftRadius", borderTopRightRadius = "borderTopRightRadius", borderBottomLeftRadius = "borderBottomLeftRadius", borderBottomRightRadius = "borderBottomRightRadius", borderLeftColor = "borderLeftColor", borderLeftStyle = "borderLeftStyle", borderLeftWidth = "borderLeftWidth", borderRightColor = "borderRightColor", borderRightStyle = "borderRightStyle", borderRightWidth = "borderRightWidth", right = "right", marginLeft = "marginLeft", marginRight = "marginRight", paddingLeft = "paddingLeft", paddingRight = "paddingRight", left = "left", PROPERTIES_FLIP = {
+  [borderTopLeftRadius]: borderTopRightRadius,
+  [borderTopRightRadius]: borderTopLeftRadius,
+  [borderBottomLeftRadius]: borderBottomRightRadius,
+  [borderBottomRightRadius]: borderBottomLeftRadius,
+  [borderLeftColor]: borderRightColor,
+  [borderLeftStyle]: borderRightStyle,
+  [borderLeftWidth]: borderRightWidth,
+  [borderRightColor]: borderLeftColor,
+  [borderRightStyle]: borderLeftStyle,
+  [borderRightWidth]: borderLeftWidth,
+  [left]: right,
+  [marginLeft]: marginRight,
+  [marginRight]: marginLeft,
+  [paddingLeft]: paddingRight,
+  [paddingRight]: paddingLeft,
+  [right]: left
+}, PROPERTIES_I18N = {
+  borderTopStartRadius: borderTopLeftRadius,
+  borderTopEndRadius: borderTopRightRadius,
+  borderBottomStartRadius: borderBottomLeftRadius,
+  borderBottomEndRadius: borderBottomRightRadius,
+  borderStartColor: borderLeftColor,
+  borderStartStyle: borderLeftStyle,
+  borderStartWidth: borderLeftWidth,
+  borderEndColor: borderRightColor,
+  borderEndStyle: borderRightStyle,
+  borderEndWidth: borderRightWidth,
+  end: right,
+  marginStart: marginLeft,
+  marginEnd: marginRight,
+  paddingStart: paddingLeft,
+  paddingEnd: paddingRight,
+  start: left
+}, PROPERTIES_VALUE = ["clear", "float", "textAlign"];
+function atomic(style) {
+  const compiledStyle = { $$css: !0 }, compiledRules = [];
+  function atomicCompile(prop, value) {
+    const valueString = stringifyValueWithProperty(value, prop), cacheKey = prop + valueString, cachedResult = cache.get(cacheKey);
+    let identifier;
+    if (cachedResult != null)
+      identifier = cachedResult[0], compiledRules.push(cachedResult[1]);
+    else {
+      identifier = createIdentifier("r", prop, value);
+      const order = customGroup[prop] || atomicGroup, orderedRules = [createAtomicRules(identifier, prop, value), order];
+      compiledRules.push(orderedRules), cache.set(cacheKey, [identifier, orderedRules]);
+    }
+    return identifier;
+  }
+  return Object.keys(style).sort().forEach((prop) => {
+    const value = style[prop];
+    if (value != null) {
+      let localizeableValue;
+      if (PROPERTIES_VALUE.indexOf(prop) > -1) {
+        const left2 = atomicCompile(prop, "left"), right2 = atomicCompile(prop, "right");
+        value === "start" ? localizeableValue = [left2, right2] : value === "end" && (localizeableValue = [right2, left2]);
+      }
+      const propPolyfill = PROPERTIES_I18N[prop];
+      if (propPolyfill != null) {
+        const ltr = atomicCompile(propPolyfill, value), rtl = atomicCompile(PROPERTIES_FLIP[propPolyfill], value);
+        localizeableValue = [ltr, rtl];
+      }
+      if (prop === "transitionProperty") {
+        const values = Array.isArray(value) ? value : [value], polyfillIndices = [];
+        for (let i = 0; i < values.length; i++) {
+          const val = values[i];
+          typeof val == "string" && PROPERTIES_I18N[val] != null && polyfillIndices.push(i);
+        }
+        if (polyfillIndices.length > 0) {
+          const ltrPolyfillValues = [...values], rtlPolyfillValues = [...values];
+          polyfillIndices.forEach((i) => {
+            const ltrVal = ltrPolyfillValues[i];
+            if (typeof ltrVal == "string") {
+              const ltrPolyfill = PROPERTIES_I18N[ltrVal], rtlPolyfill = PROPERTIES_FLIP[ltrPolyfill];
+              ltrPolyfillValues[i] = ltrPolyfill, rtlPolyfillValues[i] = rtlPolyfill;
+              const ltr = atomicCompile(prop, ltrPolyfillValues), rtl = atomicCompile(prop, rtlPolyfillValues);
+              localizeableValue = [ltr, rtl];
+            }
+          });
+        }
+      }
+      localizeableValue == null ? localizeableValue = atomicCompile(prop, value) : compiledStyle.$$css$localize = !0, compiledStyle[prop] = localizeableValue;
+    }
+  }), [compiledStyle, compiledRules];
+}
+function classic(style, name) {
+  const compiledStyle = { $$css: !0 }, compiledRules = [], { animationKeyframes, ...rest } = style, identifier = createIdentifier("css", name, style), selector = `.${identifier}`;
+  let animationName;
+  if (animationKeyframes != null) {
+    const [animationNames, keyframesRules] = processKeyframesValue(animationKeyframes);
+    animationName = animationNames.join(","), compiledRules.push(...keyframesRules);
+  }
+  const block = createDeclarationBlock({ ...rest, animationName });
+  return compiledRules.push(`${selector}${block}`), compiledStyle[identifier] = identifier, [compiledStyle, [[compiledRules, classicGroup]]];
+}
+function inline(originalStyle, isRTL) {
+  const style = originalStyle || emptyObject, frozenProps = {}, nextStyle = {};
+  for (const originalProp in style) {
+    const originalValue = style[originalProp];
+    let prop = originalProp, value = originalValue;
+    if (!Object.prototype.hasOwnProperty.call(style, originalProp) || originalValue == null)
+      continue;
+    PROPERTIES_VALUE.indexOf(originalProp) > -1 && (originalValue === "start" ? value = isRTL ? "right" : "left" : originalValue === "end" && (value = isRTL ? "left" : "right"));
+    const propPolyfill = PROPERTIES_I18N[originalProp];
+    if (propPolyfill != null && (prop = isRTL ? PROPERTIES_FLIP[propPolyfill] : propPolyfill), originalProp === "transitionProperty") {
+      const originalValues = Array.isArray(originalValue) ? originalValue : [originalValue];
+      originalValues.forEach((val, i) => {
+        if (typeof val == "string") {
+          const valuePolyfill = PROPERTIES_I18N[val];
+          valuePolyfill != null && (originalValues[i] = isRTL ? PROPERTIES_FLIP[valuePolyfill] : valuePolyfill);
+        }
+      });
+    }
+    frozenProps[prop] || (nextStyle[prop] = value), PROPERTIES_I18N.hasOwnProperty(originalProp) && (frozenProps[prop] = !0);
+  }
+  return (0, import_createReactDOMStyle.default)(nextStyle, !0);
+}
+function stringifyValueWithProperty(value, property) {
+  const normalizedValue = (0, import_normalizeValueWithProperty.default)(value, property);
+  return typeof normalizedValue != "string" ? JSON.stringify(normalizedValue || "") : normalizedValue;
+}
+function createAtomicRules(identifier, property, value) {
+  const rules = [], selector = `.${identifier}`;
+  switch (property) {
+    case "animationKeyframes": {
+      const [animationNames, keyframesRules] = processKeyframesValue(value), block = createDeclarationBlock({
+        animationName: animationNames.join(",")
+      });
+      rules.push(`${selector}${block}`, ...keyframesRules);
+      break;
+    }
+    // Equivalent to using '::placeholder'
+    case "placeholderTextColor": {
+      const block = createDeclarationBlock({ color: value, opacity: 1 });
+      rules.push(
+        `${selector}::-webkit-input-placeholder${block}`,
+        `${selector}::-moz-placeholder${block}`,
+        `${selector}:-ms-input-placeholder${block}`,
+        `${selector}::placeholder${block}`
+      );
+      break;
+    }
+    // Polyfill for additional 'pointer-events' values
+    // See d13f78622b233a0afc0c7a200c0a0792c8ca9e58
+    case "pointerEvents": {
+      let finalValue = value;
+      if (value === "auto" || value === "box-only") {
+        if (finalValue = "auto!important", value === "box-only") {
+          const block2 = createDeclarationBlock({ pointerEvents: "none" });
+          rules.push(`${selector}>*${block2}`);
+        }
+      } else if ((value === "none" || value === "box-none") && (finalValue = "none!important", value === "box-none")) {
+        const block2 = createDeclarationBlock({ pointerEvents: "auto" });
+        rules.push(`${selector}>*${block2}`);
+      }
+      const block = createDeclarationBlock({ pointerEvents: finalValue });
+      rules.push(`${selector}${block}`);
+      break;
+    }
+    // Polyfill for draft spec
+    // https://drafts.csswg.org/css-scrollbars-1/
+    case "scrollbarWidth": {
+      value === "none" && rules.push(`${selector}::-webkit-scrollbar{display:none}`);
+      const block = createDeclarationBlock({ scrollbarWidth: value });
+      rules.push(`${selector}${block}`);
+      break;
+    }
+    default: {
+      const block = createDeclarationBlock({ [property]: value });
+      rules.push(`${selector}${block}`);
+      break;
+    }
+  }
+  return rules;
+}
+function createDeclarationBlock(style) {
+  const domStyle = (0, import_createReactDOMStyle.default)(style);
+  return `{${Object.keys(domStyle).map((property) => {
+    const value = domStyle[property], prop = (0, import_hyphenateStyleName.default)(property);
+    return Array.isArray(value) ? value.map((v) => `${prop}:${v}`).join(";") : `${prop}:${value}`;
+  }).sort().join(";")};}`;
+}
+function createIdentifier(prefix, name, value) {
+  const hashedString = (0, import_simple_hash.simpleHash)(name + stringifyValueWithProperty(value, name));
+  return process.env.NODE_ENV !== "production" ? `${prefix}-${name}-${hashedString}` : `${prefix}-${hashedString}`;
+}
+function createKeyframes(keyframes) {
+  const prefixes = ["-webkit-", ""], identifier = createIdentifier("r", "animation", keyframes), steps = "{" + Object.keys(keyframes).map((stepName) => {
+    const rule = keyframes[stepName], block = createDeclarationBlock(rule);
+    return `${stepName}${block}`;
+  }).join("") + "}", rules = prefixes.map((prefix) => `@${prefix}keyframes ${identifier}${steps}`);
+  return [identifier, rules];
+}
+function processKeyframesValue(keyframesValue) {
+  if (typeof keyframesValue == "number")
+    throw new Error(`Invalid CSS keyframes type: ${typeof keyframesValue}`);
+  const animationNames = [], rules = [];
+  return (Array.isArray(keyframesValue) ? keyframesValue : [keyframesValue]).forEach((keyframes) => {
+    if (typeof keyframes == "string")
+      animationNames.push(keyframes);
+    else {
+      const [identifier, keyframesRules] = createKeyframes(keyframes);
+      animationNames.push(identifier), rules.push(...keyframesRules);
+    }
+  }), [animationNames, rules];
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/StyleSheet/compiler/normalizeColor.js

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var normalizeColor_exports = {};
+__export(normalizeColor_exports, {
+  default: () => normalizeColor_default
+});
+module.exports = __toCommonJS(normalizeColor_exports);
+var import_isWebColor = __toESM(require("../../modules/isWebColor")), import_processColor = require("../../modules/processColor");
+const normalizeColor = (color, opacity = 1) => {
+  if (color == null) return;
+  if (typeof color == "string" && (0, import_isWebColor.default)(color))
+    return color;
+  const colorInt = (0, import_processColor.processColor)(color);
+  if (colorInt != null) {
+    const r = colorInt >> 16 & 255, g = colorInt >> 8 & 255, b = colorInt & 255, alpha = ((colorInt >> 24 & 255) / 255 * opacity).toFixed(2);
+    return `rgba(${r},${g},${b},${alpha})`;
+  }
+  if (typeof color == "string")
+    return color;
+};
+var normalizeColor_default = normalizeColor;
+//# sourceMappingURL=normalizeColor.js.map

package/dist/cjs/StyleSheet/compiler/normalizeValueWithProperty.js

@@ -0,0 +1,45 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var normalizeValueWithProperty_exports = {};
+__export(normalizeValueWithProperty_exports, {
+  default: () => normalizeValueWithProperty
+});
+module.exports = __toCommonJS(normalizeValueWithProperty_exports);
+var import_unitlessNumbers = require("../../modules/unitlessNumbers/index"), import_normalizeColor = __toESM(require("./normalizeColor"));
+const colorProps = {
+  backgroundColor: !0,
+  borderColor: !0,
+  borderTopColor: !0,
+  borderRightColor: !0,
+  borderBottomColor: !0,
+  borderLeftColor: !0,
+  color: !0,
+  shadowColor: !0,
+  textDecorationColor: !0,
+  textShadowColor: !0
+};
+function normalizeValueWithProperty(value, property) {
+  let returnValue = value;
+  return (property == null || !import_unitlessNumbers.unitlessNumbers[property]) && typeof value == "number" ? returnValue = `${value}px` : property != null && colorProps[property] && (returnValue = (0, import_normalizeColor.default)(value)), returnValue;
+}
+//# sourceMappingURL=normalizeValueWithProperty.js.map

package/dist/cjs/StyleSheet/compiler/resolveShadowValue.js

@@ -0,0 +1,35 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var resolveShadowValue_exports = {};
+__export(resolveShadowValue_exports, {
+  default: () => resolveShadowValue_default
+});
+module.exports = __toCommonJS(resolveShadowValue_exports);
+var import_normalizeColor = __toESM(require("./normalizeColor")), import_normalizeValueWithProperty = __toESM(require("./normalizeValueWithProperty"));
+const defaultOffset = { height: 0, width: 0 }, resolveShadowValue = (style) => {
+  const { shadowColor, shadowOffset, shadowOpacity, shadowRadius } = style, { height, width } = shadowOffset || defaultOffset, offsetX = (0, import_normalizeValueWithProperty.default)(width), offsetY = (0, import_normalizeValueWithProperty.default)(height), blurRadius = (0, import_normalizeValueWithProperty.default)(shadowRadius || 0), color = (0, import_normalizeColor.default)(shadowColor || "black", shadowOpacity);
+  if (color != null && offsetX != null && offsetY != null && blurRadius != null)
+    return `${offsetX} ${offsetY} ${blurRadius} ${color}`;
+};
+var resolveShadowValue_default = resolveShadowValue;
+//# sourceMappingURL=resolveShadowValue.js.map

package/dist/cjs/StyleSheet/dom/createCSSStyleSheet.js

@@ -0,0 +1,44 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var createCSSStyleSheet_exports = {};
+__export(createCSSStyleSheet_exports, {
+  default: () => createCSSStyleSheet
+});
+module.exports = __toCommonJS(createCSSStyleSheet_exports);
+var import_canUseDOM = __toESM(require("../../modules/canUseDOM"));
+function createCSSStyleSheet(id, rootNode, textContent) {
+  if (import_canUseDOM.default) {
+    const root = rootNode ?? document;
+    let element = root.getElementById(id);
+    if (element == null)
+      if (element = document.createElement("style"), element.setAttribute("id", id), typeof textContent == "string" && element.appendChild(document.createTextNode(textContent)), root instanceof ShadowRoot)
+        root.insertBefore(element, root.firstChild);
+      else {
+        const head = root.head;
+        head && head.appendChild(element);
+      }
+    return element.sheet;
+  } else
+    return null;
+}
+//# sourceMappingURL=createCSSStyleSheet.js.map

package/dist/cjs/StyleSheet/dom/createOrderedCSSStyleSheet.js

@@ -0,0 +1,94 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var createOrderedCSSStyleSheet_exports = {};
+__export(createOrderedCSSStyleSheet_exports, {
+  default: () => createOrderedCSSStyleSheet
+});
+module.exports = __toCommonJS(createOrderedCSSStyleSheet_exports);
+const slice = Array.prototype.slice;
+function createOrderedCSSStyleSheet(sheet) {
+  const groups = {}, selectors = {};
+  if (sheet != null) {
+    let group;
+    slice.call(sheet.cssRules).forEach((cssRule, i) => {
+      const cssText = cssRule.cssText;
+      if (cssText.indexOf("stylesheet-group") > -1)
+        group = decodeGroupRule(cssRule), groups[group] = { start: i, rules: [cssText] };
+      else {
+        const selectorText = getSelectorText(cssText);
+        selectorText != null && (selectors[selectorText] = !0, groups[group].rules.push(cssText));
+      }
+    });
+  }
+  function sheetInsert(sheet2, group, text) {
+    const orderedGroups = getOrderedGroups(groups), nextGroupIndex = orderedGroups.indexOf(group) + 1, nextGroup = orderedGroups[nextGroupIndex], position = nextGroup != null && groups[nextGroup].start != null ? groups[nextGroup].start : sheet2.cssRules.length, isInserted = insertRuleAt(sheet2, text, position);
+    if (isInserted) {
+      groups[group].start == null && (groups[group].start = position);
+      for (let i = nextGroupIndex; i < orderedGroups.length; i += 1) {
+        const groupNumber = orderedGroups[i], previousStart = groups[groupNumber].start || 0;
+        groups[groupNumber].start = previousStart + 1;
+      }
+    }
+    return isInserted;
+  }
+  return {
+    /**
+     * The textContent of the style sheet.
+     */
+    getTextContent() {
+      return getOrderedGroups(groups).map((group) => {
+        const rules = groups[group].rules, marker = rules.shift();
+        return rules.sort(), rules.unshift(marker), rules.join(`
+`);
+      }).join(`
+`);
+    },
+    /**
+     * Insert a rule into the style sheet
+     */
+    insert(cssText, groupValue) {
+      const group = Number(groupValue);
+      if (groups[group] == null) {
+        const markerRule = encodeGroupRule(group);
+        groups[group] = { start: null, rules: [markerRule] }, sheet != null && sheetInsert(sheet, group, markerRule);
+      }
+      const selectorText = getSelectorText(cssText);
+      selectorText != null && selectors[selectorText] == null && (selectors[selectorText] = !0, groups[group].rules.push(cssText), sheet != null && (sheetInsert(sheet, group, cssText) || groups[group].rules.pop()));
+    }
+  };
+}
+function encodeGroupRule(group) {
+  return `[stylesheet-group="${group}"]{}`;
+}
+const groupPattern = /["']/g;
+function decodeGroupRule(cssRule) {
+  return Number(cssRule.selectorText.split(groupPattern)[1]);
+}
+function getOrderedGroups(obj) {
+  return Object.keys(obj).map(Number).sort((a, b) => a > b ? 1 : -1);
+}
+const selectorPattern = /\s*([,])\s*/g;
+function getSelectorText(cssText) {
+  const selector = cssText.split("{")[0].trim();
+  return selector !== "" ? selector.replace(selectorPattern, "$1") : null;
+}
+function insertRuleAt(root, cssText, position) {
+  try {
+    return root.insertRule(cssText, position), !0;
+  } catch {
+    return !1;
+  }
+}
+//# sourceMappingURL=createOrderedCSSStyleSheet.js.map

package/dist/cjs/StyleSheet/dom/index.js

@@ -0,0 +1,74 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var dom_exports = {};
+__export(dom_exports, {
+  createSheet: () => createSheet
+});
+module.exports = __toCommonJS(dom_exports);
+var import_canUseDOM = __toESM(require("../../modules/canUseDOM")), import_createCSSStyleSheet = __toESM(require("./createCSSStyleSheet")), import_createOrderedCSSStyleSheet = __toESM(require("./createOrderedCSSStyleSheet"));
+const defaultId = "react-native-stylesheet", roots = /* @__PURE__ */ new WeakMap(), sheets = [], initialRules = [
+  // minimal top-level reset
+  "html{-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%;-webkit-tap-highlight-color:rgba(0,0,0,0);}",
+  "body{margin:0;}",
+  // minimal form pseudo-element reset
+  "button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0;}",
+  "input::-webkit-search-cancel-button,input::-webkit-search-decoration,input::-webkit-search-results-button,input::-webkit-search-results-decoration{display:none;}"
+];
+function createSheet(root, id = defaultId) {
+  let sheet;
+  function createSheet2() {
+    if (!sheet)
+      if (import_canUseDOM.default) {
+        const rootNode = root != null ? root.getRootNode() : document;
+        if (sheets.length === 0)
+          sheet = (0, import_createOrderedCSSStyleSheet.default)((0, import_createCSSStyleSheet.default)(id)), initialRules.forEach((rule) => {
+            sheet.insert(rule, 0);
+          }), roots.set(rootNode, sheets.length), sheets.push(sheet);
+        else {
+          const index = roots.get(rootNode);
+          if (index == null) {
+            const initialSheet = sheets[0], textContent = initialSheet != null ? initialSheet.getTextContent() : "";
+            sheet = (0, import_createOrderedCSSStyleSheet.default)(
+              (0, import_createCSSStyleSheet.default)(id, rootNode, textContent)
+            ), roots.set(rootNode, sheets.length), sheets.push(sheet);
+          } else
+            sheet = sheets[index];
+        }
+      } else
+        sheets.length === 0 ? (sheet = (0, import_createOrderedCSSStyleSheet.default)((0, import_createCSSStyleSheet.default)(id)), initialRules.forEach((rule) => {
+          sheet.insert(rule, 0);
+        }), sheets.push(sheet)) : sheet = sheets[0];
+  }
+  return {
+    getTextContent() {
+      return createSheet2(), sheet.getTextContent();
+    },
+    id,
+    insert(cssText, groupValue) {
+      createSheet2(), sheets.forEach((s) => {
+        s.insert(cssText, groupValue);
+      });
+    }
+  };
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/StyleSheet/index.js

@@ -0,0 +1,52 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var StyleSheet_exports = {};
+__export(StyleSheet_exports, {
+  default: () => StyleSheet,
+  flatten: () => flatten
+});
+module.exports = __toCommonJS(StyleSheet_exports);
+const absoluteFillObject = {
+  position: "absolute",
+  left: 0,
+  right: 0,
+  top: 0,
+  bottom: 0
+}, absoluteFill = absoluteFillObject;
+function create(styles) {
+  return styles;
+}
+function compose(style1, style2) {
+  return flatten(style1, style2);
+}
+function flatten(...styles) {
+  return styles.flat().flat().flat().flat().reduce((acc, cur) => (cur && Object.assign(acc, cur), acc), {});
+}
+function getSheet() {
+  return {
+    id: "",
+    textContent: sheet.getTextContent()
+  };
+}
+function StyleSheet(styles, options) {
+}
+StyleSheet.absoluteFill = absoluteFill;
+StyleSheet.absoluteFillObject = absoluteFillObject;
+StyleSheet.create = create;
+StyleSheet.compose = compose;
+StyleSheet.flatten = flatten;
+StyleSheet.getSheet = getSheet;
+StyleSheet.hairlineWidth = 1;
+//# sourceMappingURL=index.js.map