@elliemae/ds-system 3.18.0-next.0 → 3.18.0-next.2

package/dist/cjs/globalStyles.js

@@ -32,18 +32,22 @@ __export(globalStyles_exports, {
 });
 module.exports = __toCommonJS(globalStyles_exports);
 var React = __toESM(require("react"));
-var import_ds_styled = require("./ds-styled/index.js");
+var import_styled = require("./styled/index.js");
 var import_th = require("./th.js");
-const GlobalStyles = import_ds_styled.createGlobalStyle`
-  :root, body {
-    overscroll-behavior-y: none;
-
-    font-size: ${(props) => props.device === "desktop" ? "13px" : "16px"};
+const GlobalStyles = import_styled.createGlobalStyle`
+  // Here we setup the root font-sizes for mobile vs desktop
+  :root {
+    font-size: ${(props) => props.device === "desktop" ? "81.25%" : "100%"};
 
     @media(min-width: ${({ theme }) => theme.breakpoints.small}) {
-      font-size: ${(props) => props.device === "mobile" ? "16px" : "13px"};
+      font-size: ${(props) => props.device === "mobile" ? "100%" : "81.25%"};
     }
+  }
+
+  body {
+    overscroll-behavior-y: none;
 
+    font-size: 1rem; // since we correctly have set up the root font-sizes, we can use 1rem
   }
 
   /* fix sanitize */

package/dist/cjs/globalStyles.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/globalStyles.tsx", "../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["import { createGlobalStyle } from './ds-styled/index.js';\nimport { th } from './th.js';\n\nexport const GlobalStyles = createGlobalStyle<{ device: 'desktop' | 'mobile' }>`\n  :root, body {\n    overscroll-behavior-y: none;\n\n    font-size: ${(props) => (props.device === 'desktop' ? '13px' : '16px')};\n\n    @media(min-width: ${({ theme }) => theme.breakpoints.small}) {\n      font-size: ${(props) => (props.device === 'mobile' ? '16px' : '13px')};\n    }\n\n  }\n\n  /* fix sanitize */\n  ::placeholder {\n    font-weight: ${th.fontWeight('regular')};\n    color: ${th.color('neutral-500')};\n  }\n  ::-webkit-input-placeholder {\n    opacity: 1;\n  }\n\n  :where(svg:not([fill])) {\n    fill: unset;\n  }\n`;\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,uBAAkC;AAClC,gBAAmB;AAEZ,MAAM,eAAe;AAAA;AAAA;AAAA;AAAA,iBAIX,CAAC,UAAW,MAAM,WAAW,YAAY,SAAS;AAAA;AAAA,wBAE3C,CAAC,EAAE,MAAM,MAAM,MAAM,YAAY;AAAA,mBACtC,CAAC,UAAW,MAAM,WAAW,WAAW,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAOjD,aAAG,WAAW,SAAS;AAAA,aAC7B,aAAG,MAAM,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "sourcesContent": ["import { createGlobalStyle } from './styled/index.js';\nimport { th } from './th.js';\n\nexport const GlobalStyles = createGlobalStyle<{ device: 'desktop' | 'mobile' }>`\n  // Here we setup the root font-sizes for mobile vs desktop\n  :root {\n    font-size: ${(props) => (props.device === 'desktop' ? '81.25%' : '100%')};\n\n    @media(min-width: ${({ theme }) => theme.breakpoints.small}) {\n      font-size: ${(props) => (props.device === 'mobile' ? '100%' : '81.25%')};\n    }\n  }\n\n  body {\n    overscroll-behavior-y: none;\n\n    font-size: 1rem; // since we correctly have set up the root font-sizes, we can use 1rem\n  }\n\n  /* fix sanitize */\n  ::placeholder {\n    font-weight: ${th.fontWeight('regular')};\n    color: ${th.color('neutral-500')};\n  }\n  ::-webkit-input-placeholder {\n    opacity: 1;\n  }\n\n  :where(svg:not([fill])) {\n    fill: unset;\n  }\n`;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,oBAAkC;AAClC,gBAAmB;AAEZ,MAAM,eAAe;AAAA;AAAA;AAAA,iBAGX,CAAC,UAAW,MAAM,WAAW,YAAY,WAAW;AAAA;AAAA,wBAE7C,CAAC,EAAE,MAAM,MAAM,MAAM,YAAY;AAAA,mBACtC,CAAC,UAAW,MAAM,WAAW,WAAW,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAYjD,aAAG,WAAW,SAAS;AAAA,aAC7B,aAAG,MAAM,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;",
   "names": []
 }

package/dist/cjs/index.js

@@ -45,7 +45,7 @@ __reExport(src_exports, require("./utils.js"), module.exports);
 __reExport(src_exports, require("./arithmetic.js"), module.exports);
 __reExport(src_exports, require("./th.js"), module.exports);
 __reExport(src_exports, require("./theme.js"), module.exports);
-__reExport(src_exports, require("./ds-styled/index.js"), module.exports);
+__reExport(src_exports, require("./styled/index.js"), module.exports);
 var import_system = require("@xstyled/system");
 var import_themeProviderHOC = require("./themeProviderHOC.js");
 var import_styled_components = require("@xstyled/styled-components");

package/dist/cjs/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/index.tsx", "../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["export * from './globalStyles.js';\nexport * from './spaceUtilities.js';\nexport * from './mobileUtilities.js';\nexport * from './utils.js';\nexport * from './arithmetic.js';\nexport * from './th.js';\nexport * from './theme.js';\nexport * from './ds-styled/index.js';\nexport { position, typography } from '@xstyled/system';\nexport { themeProviderHOC } from './themeProviderHOC.js';\nexport { ThemeContext } from '@xstyled/styled-components';\nexport { xStyledCommonProps, XStyledWrapper } from './xStyledWrapper.js';\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,wBAAc,8BAAd;AACA,wBAAc,gCADd;AAEA,wBAAc,iCAFd;AAGA,wBAAc,uBAHd;AAIA,wBAAc,4BAJd;AAKA,wBAAc,oBALd;AAMA,wBAAc,uBANd;AAOA,wBAAc,iCAPd;AAQA,oBAAqC;AACrC,8BAAiC;AACjC,+BAA6B;AAC7B,4BAAmD;",
+  "sourcesContent": ["export * from './globalStyles.js';\nexport * from './spaceUtilities.js';\nexport * from './mobileUtilities.js';\nexport * from './utils.js';\nexport * from './arithmetic.js';\nexport * from './th.js';\nexport * from './theme.js';\nexport * from './styled/index.js';\nexport { position, typography } from '@xstyled/system';\nexport { themeProviderHOC } from './themeProviderHOC.js';\nexport { ThemeContext } from '@xstyled/styled-components';\nexport { xStyledCommonProps, XStyledWrapper } from './xStyledWrapper.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,wBAAc,8BAAd;AACA,wBAAc,gCADd;AAEA,wBAAc,iCAFd;AAGA,wBAAc,uBAHd;AAIA,wBAAc,4BAJd;AAKA,wBAAc,oBALd;AAMA,wBAAc,uBANd;AAOA,wBAAc,8BAPd;AAQA,oBAAqC;AACrC,8BAAiC;AACjC,+BAA6B;AAC7B,4BAAmD;",
   "names": []
 }

package/dist/cjs/{ds-styled/utilities → styled}/checkNamingConvention.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../../../src/ds-styled/utilities/checkNamingConvention.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sources": ["../../../src/styled/checkNamingConvention.ts", "../../../../../scripts/build/transpile/react-shim.js"],
   "sourcesContent": ["/* eslint-disable no-console */\n\nexport const checkNamingConvention = (componentName: string | null, componentSlot: string | null): void => {\n  // We just check that the name is correctly written, should be removed in the future\n  if (componentName !== null) {\n    const matches = componentName.match(/DS([A-Z]|[a-z]|[0-9])*/);\n    if (!matches || matches.length === 0 || matches[0].length !== componentName.length) {\n      console.warn(`BAD FORMAT FOR COMPONENT NAME ${componentName}, use DSWhateverComponentTitled`);\n    }\n  }\n  if (componentSlot !== null) {\n    const isValid = /([a-z]-)*/.test(componentSlot);\n    if (!isValid) {\n      console.warn(`BAD FORMAT FOR COMPONENT SLOT ${componentSlot}, use any-component-slot`);\n    }\n  }\n};\n", "import * as React from 'react';\nexport { React };\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADEhB,MAAM,wBAAwB,CAAC,eAA8B,kBAAuC;AAEzG,MAAI,kBAAkB,MAAM;AAC1B,UAAM,UAAU,cAAc,MAAM,wBAAwB;AAC5D,QAAI,CAAC,WAAW,QAAQ,WAAW,KAAK,QAAQ,CAAC,EAAE,WAAW,cAAc,QAAQ;AAClF,cAAQ,KAAK,iCAAiC,8CAA8C;AAAA,IAC9F;AAAA,EACF;AACA,MAAI,kBAAkB,MAAM;AAC1B,UAAM,UAAU,YAAY,KAAK,aAAa;AAC9C,QAAI,CAAC,SAAS;AACZ,cAAQ,KAAK,iCAAiC,uCAAuC;AAAA,IACvF;AAAA,EACF;AACF;",
   "names": []

package/dist/cjs/styled/coerceWithDefaultTheme.js

@@ -0,0 +1,46 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var coerceWithDefaultTheme_exports = {};
+__export(coerceWithDefaultTheme_exports, {
+  coerceWithDefaultTheme: () => coerceWithDefaultTheme
+});
+module.exports = __toCommonJS(coerceWithDefaultTheme_exports);
+var React = __toESM(require("react"));
+var import_theme = require("../theme.js");
+const coerceSingleExpressionWithDefaultTheme = (expression) => {
+  if (typeof expression === "function") {
+    return (props) => expression({
+      ...props,
+      theme: props.theme ?? import_theme.theme
+    });
+  }
+  return expression;
+};
+const coerceWithDefaultTheme = (expressions) => expressions ? expressions.map(coerceSingleExpressionWithDefaultTheme) : [];
+//# sourceMappingURL=coerceWithDefaultTheme.js.map

package/dist/cjs/styled/coerceWithDefaultTheme.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/styled/coerceWithDefaultTheme.ts", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { theme as defaultTheme } from '../theme.js';\nimport type { Expressions, Expression, PropsWithTheme } from './types.js';\n\nconst coerceSingleExpressionWithDefaultTheme = (expression: Expression): Expression => {\n  if (typeof expression === 'function') {\n    return (props: PropsWithTheme) =>\n      expression({\n        ...props,\n        theme: props.theme ?? defaultTheme,\n      });\n  }\n  return expression;\n};\n\nexport const coerceWithDefaultTheme = (expressions: Expressions): Expressions =>\n  expressions ? expressions.map(coerceSingleExpressionWithDefaultTheme) : [];\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAsC;AAGtC,MAAM,yCAAyC,CAAC,eAAuC;AACrF,MAAI,OAAO,eAAe,YAAY;AACpC,WAAO,CAAC,UACN,WAAW;AAAA,MACT,GAAG;AAAA,MACH,OAAO,MAAM,SAAS,aAAAA;AAAA,IACxB,CAAC;AAAA,EACL;AACA,SAAO;AACT;AAEO,MAAM,yBAAyB,CAAC,gBACrC,cAAc,YAAY,IAAI,sCAAsC,IAAI,CAAC;",
+  "names": ["defaultTheme"]
+}

package/dist/cjs/styled/expressions/genStyleOverridesExpression.js

@@ -0,0 +1,44 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var genStyleOverridesExpression_exports = {};
+__export(genStyleOverridesExpression_exports, {
+  genStyleOverridesExpression: () => genStyleOverridesExpression
+});
+module.exports = __toCommonJS(genStyleOverridesExpression_exports);
+var React = __toESM(require("react"));
+var import_theme = require("../../theme.js");
+const getStyleOverrides = (name, theme) => theme.components?.[name]?.styleOverrides || null;
+const genStyleOverridesExpression = (componentName, componentSlot) => (props) => {
+  const styleOverrides = getStyleOverrides(componentName, props.theme ?? import_theme.theme);
+  if (styleOverrides) {
+    return [styleOverrides[componentSlot]];
+  }
+  return null;
+};
+//# sourceMappingURL=genStyleOverridesExpression.js.map

package/dist/cjs/styled/expressions/genStyleOverridesExpression.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/styled/expressions/genStyleOverridesExpression.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import type { PropsWithTheme, Theme } from '../types.js';\nimport { theme as defaultTheme } from '../../theme.js';\nimport type { CSSObject } from 'styled-components';\n\nconst getStyleOverrides = (name: string, theme: Theme): CSSObject | null =>\n  theme.components?.[name]?.styleOverrides || null;\n\nexport const genStyleOverridesExpression =\n  (componentName: string, componentSlot: string) => (props: PropsWithTheme) => {\n    const styleOverrides = getStyleOverrides(componentName, props.theme ?? defaultTheme);\n    if (styleOverrides) {\n      return [styleOverrides[componentSlot]];\n    }\n    return null;\n  };\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,mBAAsC;AAGtC,MAAM,oBAAoB,CAAC,MAAc,UACvC,MAAM,aAAa,IAAI,GAAG,kBAAkB;AAEvC,MAAM,8BACX,CAAC,eAAuB,kBAA0B,CAAC,UAA0B;AAC3E,QAAM,iBAAiB,kBAAkB,eAAe,MAAM,SAAS,aAAAA,KAAY;AACnF,MAAI,gBAAgB;AAClB,WAAO,CAAC,eAAe,aAAa,CAAC;AAAA,EACvC;AACA,SAAO;AACT;",
+  "names": ["defaultTheme"]
+}

package/dist/cjs/{ds-styled/utilities/resolvers.js → styled/expressions/genVariantOverridesExpression.js}

@@ -26,16 +26,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var resolvers_exports = {};
-__export(resolvers_exports, {
-  getStyleOverrides: () => getStyleOverrides,
-  getVariantStyles: () => getVariantStyles,
-  variantsResolver: () => variantsResolver
+var genVariantOverridesExpression_exports = {};
+__export(genVariantOverridesExpression_exports, {
+  genVariantOverridesExpression: () => genVariantOverridesExpression
 });
-module.exports = __toCommonJS(resolvers_exports);
+module.exports = __toCommonJS(genVariantOverridesExpression_exports);
 var React = __toESM(require("react"));
-var import_helpers = require("./helpers.js");
-const getStyleOverrides = (name, theme) => theme.components?.[name]?.styleOverrides || null;
+var import_theme = require("../../theme.js");
+var import_helpers = require("../helpers.js");
 const getVariantStyles = (name, theme) => {
   const variants = theme.components?.[name]?.variants || [];
   return variants.reduce((styles, definition) => {
@@ -44,14 +42,16 @@ const getVariantStyles = (name, theme) => {
     return styles;
   }, {});
 };
-const variantsResolver = (props, styles, theme, name) => {
-  const themeVariants = theme?.components?.[name]?.variants || [];
-  return themeVariants.reduce((variantsStyles, themeVariant) => {
+const genVariantOverridesExpression = (componentName) => (props) => {
+  const theme = props.theme ?? import_theme.theme;
+  const variantStyles = getVariantStyles(componentName, theme);
+  const themeVariants = theme?.components?.[componentName]?.variants || [];
+  return themeVariants.reduce((resultingStyles, themeVariant) => {
     const isMatch = Object.keys(themeVariant.props).every((key) => props[key] === themeVariant.props[key]);
     if (isMatch) {
-      variantsStyles.push(styles[(0, import_helpers.propsToClassKey)(themeVariant.props)]);
+      resultingStyles.push(variantStyles[(0, import_helpers.propsToClassKey)(themeVariant.props)]);
     }
-    return variantsStyles;
+    return resultingStyles;
   }, []);
 };
-//# sourceMappingURL=resolvers.js.map
+//# sourceMappingURL=genVariantOverridesExpression.js.map

package/dist/cjs/styled/expressions/genVariantOverridesExpression.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/styled/expressions/genVariantOverridesExpression.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import type { PropsWithTheme, Theme } from '../types.js';\nimport { theme as defaultTheme } from '../../theme.js';\nimport type { CSSObject } from 'styled-components';\nimport { propsToClassKey } from '../helpers.js';\n\nconst getVariantStyles = (name: string, theme: Theme): Record<string, CSSObject> => {\n  const variants = theme.components?.[name]?.variants || [];\n\n  return variants.reduce((styles, definition) => {\n    const key = propsToClassKey(definition.props);\n    styles[key] = definition.style;\n    return styles;\n  }, {} as Record<string, CSSObject>);\n};\n\nexport const genVariantOverridesExpression = (componentName: string) => (props: PropsWithTheme) => {\n  const theme = props.theme ?? defaultTheme;\n  const variantStyles = getVariantStyles(componentName, theme);\n\n  const themeVariants = theme?.components?.[componentName]?.variants || [];\n\n  return themeVariants.reduce((resultingStyles, themeVariant) => {\n    const isMatch = Object.keys(themeVariant.props).every((key) => props[key] === themeVariant.props[key]);\n    if (isMatch) {\n      resultingStyles.push(variantStyles[propsToClassKey(themeVariant.props)]);\n    }\n    return resultingStyles;\n  }, [] as CSSObject[keyof CSSObject][]);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,mBAAsC;AAEtC,qBAAgC;AAEhC,MAAM,mBAAmB,CAAC,MAAc,UAA4C;AAClF,QAAM,WAAW,MAAM,aAAa,IAAI,GAAG,YAAY,CAAC;AAExD,SAAO,SAAS,OAAO,CAAC,QAAQ,eAAe;AAC7C,UAAM,UAAM,gCAAgB,WAAW,KAAK;AAC5C,WAAO,GAAG,IAAI,WAAW;AACzB,WAAO;AAAA,EACT,GAAG,CAAC,CAA8B;AACpC;AAEO,MAAM,gCAAgC,CAAC,kBAA0B,CAAC,UAA0B;AACjG,QAAM,QAAQ,MAAM,SAAS,aAAAA;AAC7B,QAAM,gBAAgB,iBAAiB,eAAe,KAAK;AAE3D,QAAM,gBAAgB,OAAO,aAAa,aAAa,GAAG,YAAY,CAAC;AAEvE,SAAO,cAAc,OAAO,CAAC,iBAAiB,iBAAiB;AAC7D,UAAM,UAAU,OAAO,KAAK,aAAa,KAAK,EAAE,MAAM,CAAC,QAAQ,MAAM,GAAG,MAAM,aAAa,MAAM,GAAG,CAAC;AACrG,QAAI,SAAS;AACX,sBAAgB,KAAK,kBAAc,gCAAgB,aAAa,KAAK,CAAC,CAAC;AAAA,IACzE;AACA,WAAO;AAAA,EACT,GAAG,CAAC,CAAiC;AACvC;",
+  "names": ["defaultTheme"]
+}

package/dist/cjs/styled/expressions/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var expressions_exports = {};
+__export(expressions_exports, {
+  genStyleOverridesExpression: () => import_genStyleOverridesExpression.genStyleOverridesExpression,
+  genVariantOverridesExpression: () => import_genVariantOverridesExpression.genVariantOverridesExpression
+});
+module.exports = __toCommonJS(expressions_exports);
+var React = __toESM(require("react"));
+var import_genStyleOverridesExpression = require("./genStyleOverridesExpression.js");
+var import_genVariantOverridesExpression = require("./genVariantOverridesExpression.js");
+//# sourceMappingURL=index.js.map

package/dist/cjs/styled/expressions/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/styled/expressions/index.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export { genStyleOverridesExpression } from './genStyleOverridesExpression.js';\nexport { genVariantOverridesExpression } from './genVariantOverridesExpression.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,yCAA4C;AAC5C,2CAA8C;",
+  "names": []
+}

package/dist/cjs/styled/fixStyleArg.js

@@ -0,0 +1,48 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fixStyleArg_exports = {};
+__export(fixStyleArg_exports, {
+  fixStyleArg: () => fixStyleArg
+});
+module.exports = __toCommonJS(fixStyleArg_exports);
+var React = __toESM(require("react"));
+var import_theme = require("../theme.js");
+const isTemplateStringsArray = (styleArg) => Array.isArray(styleArg);
+const fixStyleArg = (styleArg, numberOfNewExpressions) => {
+  if (isTemplateStringsArray(styleArg) && numberOfNewExpressions > 0) {
+    const placeholders = new Array(numberOfNewExpressions).fill("");
+    return Object.assign([...styleArg, ...placeholders], {
+      raw: [...styleArg.raw, ...placeholders]
+    });
+  } else if (typeof styleArg === "function") {
+    return (props) => styleArg({ ...props, theme: props.theme ?? import_theme.theme });
+  }
+  return styleArg;
+};
+//# sourceMappingURL=fixStyleArg.js.map

package/dist/cjs/styled/fixStyleArg.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/styled/fixStyleArg.ts", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { theme as defaultTheme } from '../theme.js';\nimport type { PropsWithTheme, StyleArg } from './types.js';\n\nconst isTemplateStringsArray = (styleArg: StyleArg): styleArg is TemplateStringsArray => Array.isArray(styleArg);\n\nexport const fixStyleArg = (styleArg: StyleArg, numberOfNewExpressions: number): StyleArg => {\n  if (isTemplateStringsArray(styleArg) && numberOfNewExpressions > 0) {\n    // Here we are adding placeholders for all the new functions that we are gonna call\n    const placeholders = new Array(numberOfNewExpressions).fill('') as string[];\n    return Object.assign([...styleArg, ...placeholders], {\n      raw: [...styleArg.raw, ...placeholders],\n    });\n  } else if (typeof styleArg === 'function') {\n    // Here we just coerce with the default theme\n    return (props: PropsWithTheme) => styleArg({ ...props, theme: props.theme ?? defaultTheme });\n  }\n  return styleArg;\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAsC;AAGtC,MAAM,yBAAyB,CAAC,aAAyD,MAAM,QAAQ,QAAQ;AAExG,MAAM,cAAc,CAAC,UAAoB,2BAA6C;AAC3F,MAAI,uBAAuB,QAAQ,KAAK,yBAAyB,GAAG;AAElE,UAAM,eAAe,IAAI,MAAM,sBAAsB,EAAE,KAAK,EAAE;AAC9D,WAAO,OAAO,OAAO,CAAC,GAAG,UAAU,GAAG,YAAY,GAAG;AAAA,MACnD,KAAK,CAAC,GAAG,SAAS,KAAK,GAAG,YAAY;AAAA,IACxC,CAAC;AAAA,EACH,WAAW,OAAO,aAAa,YAAY;AAEzC,WAAO,CAAC,UAA0B,SAAS,EAAE,GAAG,OAAO,OAAO,MAAM,SAAS,aAAAA,MAAa,CAAC;AAAA,EAC7F;AACA,SAAO;AACT;",
+  "names": ["defaultTheme"]
+}

package/dist/cjs/styled/generated-attributes/generateAttributes.js

@@ -0,0 +1,71 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generateAttributes_exports = {};
+__export(generateAttributes_exports, {
+  generateAttributes: () => generateAttributes
+});
+module.exports = __toCommonJS(generateAttributes_exports);
+var React = __toESM(require("react"));
+var import_helpers = require("../helpers.js");
+var import_callbackMerger = require("./utils/callbackMerger.js");
+var import_refMerger = require("./utils/refMerger.js");
+const generateClassName = (props, meta) => {
+  if (meta.displayName === null)
+    return {};
+  return {
+    className: meta.displayName
+  };
+};
+const generateDataTestId = (props, meta) => {
+  if (meta.displayName === null)
+    return {};
+  return {
+    "data-testid": props["data-testid"] ?? (0, import_helpers.displayNameToKebabCase)(meta.displayName)
+  };
+};
+const generateGlobalAttributes = (props) => {
+  const { getOwnerProps, getOwnerPropsArguments } = props;
+  if (getOwnerProps === void 0)
+    return {};
+  const ownerPropsValue = getOwnerProps();
+  const ownerPropsArgumentsValue = getOwnerPropsArguments?.() ?? {};
+  const elementProps = ownerPropsValue[props["data-testid"]];
+  if (elementProps === void 0 || elementProps === null)
+    return {};
+  const resultingObject = typeof elementProps === "function" ? elementProps(ownerPropsArgumentsValue) : elementProps;
+  const resultingObjectWithRefMerged = (0, import_refMerger.refMerger)(props, resultingObject);
+  const resultingObjectWithCallbackMerged = (0, import_callbackMerger.callbackMerger)(props, resultingObjectWithRefMerged);
+  return resultingObjectWithCallbackMerged;
+};
+const wrap = (func, meta) => (props) => func(props, meta);
+const generateAttributes = (options, displayName) => {
+  const meta = { options, displayName };
+  return [wrap(generateClassName, meta), wrap(generateDataTestId, meta), wrap(generateGlobalAttributes, meta)];
+};
+//# sourceMappingURL=generateAttributes.js.map

package/dist/cjs/styled/generated-attributes/generateAttributes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/styled/generated-attributes/generateAttributes.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { displayNameToKebabCase } from '../helpers.js';\nimport type { AttrsFunc, InternalAttrsFunc, Options, OwnerInterface, PartProps } from '../types.js';\nimport { callbackMerger } from './utils/callbackMerger.js';\nimport { refMerger } from './utils/refMerger.js';\n\nconst generateClassName: InternalAttrsFunc = (props, meta) => {\n  if (meta.displayName === null) return {};\n  return {\n    className: meta.displayName,\n  };\n};\n\nconst generateDataTestId: InternalAttrsFunc<{ 'data-testid': string }> = (props, meta) => {\n  if (meta.displayName === null) return {};\n  return {\n    'data-testid': props['data-testid'] ?? displayNameToKebabCase(meta.displayName),\n  };\n};\n\nconst generateGlobalAttributes: InternalAttrsFunc<{ 'data-testid': string } & OwnerInterface> = (props) => {\n  const { getOwnerProps, getOwnerPropsArguments } = props;\n\n  // If no ownerProps are provided, we won't add global attributes\n  if (getOwnerProps === undefined) return {};\n\n  const ownerPropsValue = getOwnerProps() as Record<string, PartProps>;\n  const ownerPropsArgumentsValue = getOwnerPropsArguments?.() ?? {};\n\n  const elementProps = ownerPropsValue[props['data-testid']];\n\n  // If no elementProps are present, we won't add global attributes either\n  if (elementProps === undefined || elementProps === null) return {};\n\n  // If elementProps is a function, we call it with the ownerPropsArguments\n  // Otherwise we assign it directly\n  const resultingObject = typeof elementProps === 'function' ? elementProps(ownerPropsArgumentsValue) : elementProps;\n\n  const resultingObjectWithRefMerged = refMerger(props, resultingObject);\n\n  const resultingObjectWithCallbackMerged = callbackMerger(props, resultingObjectWithRefMerged);\n\n  return resultingObjectWithCallbackMerged;\n};\n\nconst wrap =\n  <T extends object>(\n    func: InternalAttrsFunc<T>,\n    meta: { options: Options; displayName: string | null },\n  ): AttrsFunc<T> =>\n  (props) =>\n    func(props, meta);\n\nexport const generateAttributes = (options: Options, displayName: string | null): AttrsFunc<any>[] => {\n  const meta = { options, displayName };\n\n  // Comprehensive list of all the generators above\n  // ORDER MATTERS: the attributes returned by previous functions, are received as props by the next ones\n  return [wrap(generateClassName, meta), wrap(generateDataTestId, meta), wrap(generateGlobalAttributes, meta)];\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,qBAAuC;AAEvC,4BAA+B;AAC/B,uBAA0B;AAE1B,MAAM,oBAAuC,CAAC,OAAO,SAAS;AAC5D,MAAI,KAAK,gBAAgB;AAAM,WAAO,CAAC;AACvC,SAAO;AAAA,IACL,WAAW,KAAK;AAAA,EAClB;AACF;AAEA,MAAM,qBAAmE,CAAC,OAAO,SAAS;AACxF,MAAI,KAAK,gBAAgB;AAAM,WAAO,CAAC;AACvC,SAAO;AAAA,IACL,eAAe,MAAM,aAAa,SAAK,uCAAuB,KAAK,WAAW;AAAA,EAChF;AACF;AAEA,MAAM,2BAA0F,CAAC,UAAU;AACzG,QAAM,EAAE,eAAe,uBAAuB,IAAI;AAGlD,MAAI,kBAAkB;AAAW,WAAO,CAAC;AAEzC,QAAM,kBAAkB,cAAc;AACtC,QAAM,2BAA2B,yBAAyB,KAAK,CAAC;AAEhE,QAAM,eAAe,gBAAgB,MAAM,aAAa,CAAC;AAGzD,MAAI,iBAAiB,UAAa,iBAAiB;AAAM,WAAO,CAAC;AAIjE,QAAM,kBAAkB,OAAO,iBAAiB,aAAa,aAAa,wBAAwB,IAAI;AAEtG,QAAM,mCAA+B,4BAAU,OAAO,eAAe;AAErE,QAAM,wCAAoC,sCAAe,OAAO,4BAA4B;AAE5F,SAAO;AACT;AAEA,MAAM,OACJ,CACE,MACA,SAEF,CAAC,UACC,KAAK,OAAO,IAAI;AAEb,MAAM,qBAAqB,CAAC,SAAkB,gBAAiD;AACpG,QAAM,OAAO,EAAE,SAAS,YAAY;AAIpC,SAAO,CAAC,KAAK,mBAAmB,IAAI,GAAG,KAAK,oBAAoB,IAAI,GAAG,KAAK,0BAA0B,IAAI,CAAC;AAC7G;",
+  "names": []
+}

package/dist/cjs/styled/generated-attributes/generateAutoCalculated.js

@@ -0,0 +1,42 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generateAutoCalculated_exports = {};
+__export(generateAutoCalculated_exports, {
+  generateAutoCalculated: () => generateAutoCalculated
+});
+module.exports = __toCommonJS(generateAutoCalculated_exports);
+var React = __toESM(require("react"));
+var import_generateDisplayName = require("./generateDisplayName.js");
+var import_generateAttributes = require("./generateAttributes.js");
+const generateAutoCalculated = (options) => {
+  const displayName = (0, import_generateDisplayName.generateDisplayName)(options);
+  const attributes = (0, import_generateAttributes.generateAttributes)(options, displayName);
+  return [displayName, attributes];
+};
+//# sourceMappingURL=generateAutoCalculated.js.map

package/dist/cjs/styled/generated-attributes/generateAutoCalculated.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/styled/generated-attributes/generateAutoCalculated.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import type { Options } from '../types.js';\nimport { generateDisplayName } from './generateDisplayName.js';\nimport { generateAttributes } from './generateAttributes.js';\n\nexport const generateAutoCalculated = (options: Options) => {\n  const displayName = generateDisplayName(options);\n\n  const attributes = generateAttributes(options, displayName);\n\n  return [displayName, attributes] as const;\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,iCAAoC;AACpC,gCAAmC;AAE5B,MAAM,yBAAyB,CAAC,YAAqB;AAC1D,QAAM,kBAAc,gDAAoB,OAAO;AAE/C,QAAM,iBAAa,8CAAmB,SAAS,WAAW;AAE1D,SAAO,CAAC,aAAa,UAAU;AACjC;",
+  "names": []
+}

package/dist/cjs/styled/generated-attributes/generateDisplayName.js

@@ -0,0 +1,41 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generateDisplayName_exports = {};
+__export(generateDisplayName_exports, {
+  generateDisplayName: () => generateDisplayName
+});
+module.exports = __toCommonJS(generateDisplayName_exports);
+var React = __toESM(require("react"));
+const generateDisplayName = (options) => {
+  const { name: componentName, slot: componentSlot } = options;
+  if (componentName === null || componentSlot === null)
+    return null;
+  return `${componentName}-${componentSlot}`;
+};
+//# sourceMappingURL=generateDisplayName.js.map

package/dist/cjs/styled/generated-attributes/generateDisplayName.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/styled/generated-attributes/generateDisplayName.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import type { Options } from '../types.js';\n\nexport const generateDisplayName = (options: Options) => {\n  const { name: componentName, slot: componentSlot } = options;\n\n  if (componentName === null || componentSlot === null) return null;\n\n  return `${componentName}-${componentSlot}`;\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADEhB,MAAM,sBAAsB,CAAC,YAAqB;AACvD,QAAM,EAAE,MAAM,eAAe,MAAM,cAAc,IAAI;AAErD,MAAI,kBAAkB,QAAQ,kBAAkB;AAAM,WAAO;AAE7D,SAAO,GAAG,iBAAiB;AAC7B;",
+  "names": []
+}

package/dist/cjs/styled/generated-attributes/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generated_attributes_exports = {};
+__export(generated_attributes_exports, {
+  generateAutoCalculated: () => import_generateAutoCalculated.generateAutoCalculated
+});
+module.exports = __toCommonJS(generated_attributes_exports);
+var React = __toESM(require("react"));
+var import_generateAutoCalculated = require("./generateAutoCalculated.js");
+//# sourceMappingURL=index.js.map

package/dist/cjs/styled/generated-attributes/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/styled/generated-attributes/index.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export { generateAutoCalculated } from './generateAutoCalculated.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,oCAAuC;",
+  "names": []
+}