feat: Fluent UI Outlook Lite + connections mockup

node_modules/@griffel/react/LICENSE.md

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

node_modules/@griffel/react/README.md

@@ -0,0 +1,533 @@
+# Griffel for React.js
+
+A package with wrappers and APIs to be used with React.js.
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
+- [Install](#install)
+- [`makeStyles()`](#makestyles)
+  - [Pseudo & class selectors, at-rules, global styles](#pseudo--class-selectors-at-rules-global-styles)
+  - [Keyframes (animations)](#keyframes-animations)
+  - [CSS Fallback Properties](#css-fallback-properties)
+  - [RTL support](#rtl-support)
+- [`mergeClasses()`](#mergeclasses)
+- [`makeStaticStyles()`](#makestaticstyles)
+- [`makeResetStyles()`](#makeresetstyles)
+- [`createDOMRenderer()`, `RendererProvider`](#createdomrenderer-rendererprovider)
+  - [compareMediaQueries](#comparemediaqueries)
+  - [insertionPoint](#insertionpoint)
+  - [styleElementAttributes](#styleelementattributes)
+- [`TextDirectionProvider`](#textdirectionprovider)
+- [Shorthands](#shorthands)
+  - [`shorthands.borderColor`](#shorthandsbordercolor)
+  - [`shorthands.borderStyle`](#shorthandsborderstyle)
+  - [`shorthands.borderWidth`](#shorthandsborderwidth)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Install
+
+```bash
+npm install @griffel/react
+# or
+yarn add @griffel/react
+```
+
+## `makeStyles()`
+
+Is used to define styles, returns a React hook that should be called inside a component:
+
+```tsx
+import { makeStyles } from '@griffel/react';
+
+const useClasses = makeStyles({
+  button: { color: 'red' },
+  icon: { paddingLeft: '5px' },
+});
+
+function Component() {
+  const classes = useClasses();
+
+  return (
+    <div>
+      <button className={classes.button} />
+      <span className={classes.icon} />
+    </div>
+  );
+}
+```
+
+### Pseudo & class selectors, at-rules, global styles
+
+`makeStyles()` supports pseudo, class selectors and at-rules.
+
+```ts
+import { makeStyles } from '@griffel/react';
+
+const useClasses = makeStyles({
+  root: {
+    ':active': { color: 'pink' },
+    ':hover': { color: 'blue' },
+    // :link, :focus, etc.
+
+    '.foo': { color: 'black' },
+    ':nth-child(2n)': { backgroundColor: '#fafafa' },
+
+    '@media screen and (max-width: 992px)': { color: 'orange' },
+    '@container (max-width: 992px)': { color: 'orange' },
+    '@container foo (max-width: 992px)': { color: 'orange' },
+    '@supports (display: grid)': { color: 'red' },
+    '@layer utility': { marginBottom: '1em' },
+  },
+});
+```
+
+Another useful feature is `:global()` selector, it allows connecting local styles with global selectors.
+
+```ts
+import { makeStyles } from '@griffel/react';
+
+const useClasses = makeStyles({
+  root: {
+    ':global(html[data-whatintent="mouse"])': { backgroundColor: 'yellow' },
+    // outputs: html[data-whatintent="mouse"] .abcd { background-color: yellow }
+  },
+});
+```
+
+### Keyframes (animations)
+
+`keyframes` are supported via `animationName` property that can be defined as an object or an array of objects:
+
+```tsx
+import { makeStyles } from '@griffel/react';
+
+const useClasses = makeStyles({
+  root: {
+    animationIterationCount: 'infinite',
+    animationDuration: '3s',
+    animationName: {
+      from: { transform: 'rotate(0deg)' },
+      to: { transform: 'rotate(360deg)' },
+    },
+  },
+  array: {
+    animationIterationCount: 'infinite',
+    animationDuration: '3s',
+    animationName: [
+      {
+        from: { transform: 'rotate(0deg)' },
+        to: { transform: 'rotate(360deg)' },
+      },
+      {
+        from: { height: '100px' },
+        to: { height: '200px' },
+      },
+    ],
+  },
+});
+```
+
+### CSS Fallback Properties
+
+Any CSS property accepts an array of values which are all added to the styles.
+Every browser will use the latest valid value (which might be a different one in different browsers, based on supported CSS in that browser):
+
+```js
+import { makeStyles } from '@griffel/react';
+
+const useClasses = makeStyles({
+  root: {
+    overflowY: ['scroll', 'overlay'],
+  },
+});
+```
+
+### RTL support
+
+Griffel uses [rtl-css-js](https://github.com/kentcdodds/rtl-css-js) to perform automatic flipping of properties and values in Right-To-Left (RTL) text direction defined by `TextDirectionProvider`.
+
+```js
+import { makeStyles } from '@griffel/react';
+
+const useClasses = makeStyles({
+  root: {
+    paddingLeft: '10px',
+  },
+});
+```
+
+⬇️⬇️⬇️
+
+```css
+/* Will be applied in LTR */
+.frdkuqy {
+  padding-left: 10px;
+}
+/* Will be applied in RTL */
+.f81rol6 {
+  padding-right: 10px;
+}
+```
+
+You can also control which rules you don't want to flip by adding a `/* @noflip */` CSS comment to your rule:
+
+```js
+import { makeStyles } from '@griffel/react';
+
+const useClasses = makeStyles({
+  root: {
+    paddingLeft: '10px /* @noflip */',
+  },
+});
+```
+
+⬇️⬇️⬇️
+
+```css
+/* Will be applied in LTR & RTL */
+.f6x5cb6 {
+  padding-left: 10px;
+}
+```
+
+## `mergeClasses()`
+
+> 💡 **It is not possible to simply concatenate classes returned by `useClasses()`.**
+
+There are cases where you need to merge classes from multiple `useClasses` calls.
+
+To properly merge the classes, you need to use `mergeClasses()` function, which performs merge and deduplication of atomic classes generated by `makeStyles()`.
+
+```tsx
+import { mergeClasses, makeStyles } from '@griffel/react';
+
+const useClasses = makeStyles({
+  blueBold: {
+    color: 'blue',
+    fontWeight: 'bold',
+  },
+  red: {
+    color: 'red',
+  },
+});
+
+function Component() {
+  const classes = useClasses();
+
+  const firstClassName = mergeClasses(classes.blueBold, classes.red); // { color: 'red', fontWeight: 'bold' }
+  const secondClassName = mergeClasses(classes.red, classes.blueBold); // { color: 'blue', fontWeight: 'bold' }
+
+  return (
+    <>
+      <div className={firstClassName} />
+      <div className={secondClassName} />
+    </>
+  );
+}
+```
+
+## `makeStaticStyles()`
+
+Creates styles attached to a global selector. Styles can be defined via objects:
+
+```tsx
+import { makeStaticStyles } from '@griffel/react';
+
+const useStaticStyles = makeStaticStyles({
+  '@font-face': {
+    fontFamily: 'Open Sans',
+    src: `url("/fonts/OpenSans-Regular-webfont.woff2") format("woff2"),
+         url("/fonts/OpenSans-Regular-webfont.woff") format("woff")`,
+  },
+  body: {
+    background: 'red',
+  },
+
+  /**
+   * ⚠️ nested and pseudo selectors are not supported for this scenario via nesting
+   *
+   * Not supported:
+   * .some {
+   *   .class { ... },
+   *   ':hover': { ... }
+   * }
+   *
+   * Supported:
+   * '.some.class': { ... }
+   * '.some.class:hover': { ... }
+   */
+});
+
+function App() {
+  useStaticStyles();
+
+  return <div />;
+}
+```
+
+Or with string & arrays of strings/objects:
+
+```tsx
+import { makeStaticStyles } from '@griffel/react';
+
+const useStaticStyles1 = makeStaticStyles('body { background: red; } .foo { color: green; }');
+const useStaticStyles2 = makeStaticStyles([
+  {
+    '@font-face': {
+      fontFamily: 'My Font',
+      src: `url(my_font.woff)`,
+    },
+  },
+  'html { line-height: 20px; }',
+]);
+
+function App() {
+  useStaticStyles1();
+  useStaticStyles2();
+
+  return <div />;
+}
+```
+
+## `makeResetStyles()`
+
+Atomic CSS has [tradeoffs](https://griffel.js.org/react/guides/atomic-css#trade-offs).
+Once an element has many HTML class names each pointing to different CSS rules, browser layout times slow down.
+
+There are cases when it's reasonable to flatten multiple declarations into monolithic CSS. For example, base styles for components in a UI library.
+Rules generated by `makeResetStyles()` are inserted into the CSS style sheet before all the Atomic CSS, so styles from `makeStyles()` will always override these rules.
+
+`makeResetStyles` returns a React hook that should be called inside a component:
+
+```jsx
+import { makeStyles, makeResetStyles } from '@griffel/react';
+import { mergeClasses } from './mergeClasses';
+
+const useBaseClass = makeResetStyles({
+  color: 'red',
+  padding: 0,
+  // etc.
+});
+
+const useClasses = makeStyles({
+  primary: { color: 'blue' },
+  circular: {
+    padding: '5px',
+    borderRadius: '5px',
+  },
+});
+
+function Component(props) {
+  const baseClass = useBaseClass();
+  const classes = useClasses();
+
+  return (
+    <button className={mergeClasses(baseClass, props.primary && classes.primary, props.circular && classes.circular)} />
+  );
+}
+```
+
+> ⚠️ Only one class generated by `makeResetStyles()` can be applied to an element. Otherwise, behavior will be non-deterministic as classes merging will not be done for this case and results depend on order of insertion.
+
+```jsx
+import { makeStyles } from '@griffel/react';
+
+const useClassA = makeResetStyles({
+  /* styles */
+});
+const useClassB = makeResetStyles({
+  /* styles */
+});
+
+function Component(props) {
+  /* 💣 Never apply multiple rules from makeResetStyles() to the same element */
+  return <button className={mergeClasses(useClassA(), useClassB())} />;
+}
+```
+
+## `createDOMRenderer()`, `RendererProvider`
+
+`createDOMRenderer` is paired with `RendererProvider` component and is useful for child window rendering and SSR scenarios. This is the default renderer for web, and will make sure that styles are injected to a document.
+
+```jsx
+import { createDOMRenderer, RendererProvider } from '@griffel/react';
+
+function App(props) {
+  const { targetDocument } = props;
+  const renderer = React.useMemo(() => createDOMRenderer(targetDocument), [targetDocument]);
+
+  return (
+    <RendererProvider renderer={renderer} targetDocument={targetDocument}>
+      {/* Children components */}
+      {/* ... */}
+    </RendererProvider>
+  );
+}
+```
+
+### compareMediaQueries
+
+A function with the same signature as sort functions in e.g. `Array.prototype.sort` for dynamically sorting media queries. Maps over an array of media query strings.
+
+Griffel does not provide an opinionated default to sort media queries as the order may vary depending on the specific needs of the application.
+
+```js
+import { createDOMRenderer } from '@griffel/react';
+
+const mediaQueryOrder = [
+  'only screen and (min-width: 1366px)',
+  'only screen and (min-width: 1366px)',
+  'only screen and (min-width: 1920px)',
+];
+
+function sortMediaQueries(a, b) {
+  return mediaQueryOrder.indexOf(a) - mediaQueryOrder.indexOf(b);
+}
+
+const renderer = createDOMRenderer(document, {
+  compareMediaQueries,
+});
+```
+
+```html
+<html>
+  <head>
+    <style media="only screen and (min-width: 1024px)" data-make-styles-bucket="m"></style>
+    <style media="only screen and (min-width: 1366px)" data-make-styles-bucket="m"></style>
+    <style media="only screen and (min-width: 1920px)" data-make-styles-bucket="m"></style>
+  </head>
+</html>
+```
+
+For mobile-first methodology, you can consider using [`sort-css-media-queries`](https://github.com/dutchenkoOleg/sort-css-media-queries):
+
+```js
+import { createDOMRenderer } from '@griffel/react';
+import sortCSSmq from 'sort-css-media-queries';
+
+const renderer = createDOMRenderer(document, {
+  compareMediaQueries: sortCSSmq,
+});
+```
+
+```html
+<html>
+  <head>
+    <style media="only screen and (min-width: 1px)" data-make-styles-bucket="m"></style>
+    <style media="only screen and (min-width: 480px)" data-make-styles-bucket="m"></style>
+    <style media="only screen and (min-width: 640px)" data-make-styles-bucket="m"></style>
+  </head>
+</html>
+```
+
+### insertionPoint
+
+If specified, a renderer will insert created style tags after this element:
+
+```js
+import { createDOMRenderer } from '@griffel/react';
+
+const insertionPoint = document.head.querySelector('#foo');
+const renderer = createDOMRenderer(document, {
+  insertionPoint,
+});
+```
+
+```html
+<html>
+  <head>
+    <style id="foo" />
+    <!-- Style elements created by Griffel will be inserted after "#foo" element -->
+    <style data-make-styles-bucket="d" />
+    <style id="bar" />
+  </head>
+</html>
+```
+
+### styleElementAttributes
+
+A map of attributes that's passed to the generated style elements. For example, is useful to set ["nonce" attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/nonce).
+
+```js
+import { createDOMRenderer } from '@griffel/react';
+
+const renderer = createDOMRenderer(document, {
+  styleElementAttributes: {
+    nonce: 'random',
+  },
+});
+```
+
+## `TextDirectionProvider`
+
+`TextDirectionProvider` is used to determine the text direction for style computation. The default text direction is Left-To-Right (LTR).
+
+```jsx
+import { TextDirectionProvider } from '@griffel/react';
+
+function App() {
+  return (
+    <>
+      <TextDirectionProvider>
+        {/* Inner components will have styles for LTR */}
+        {/* ... */}
+      </TextDirectionProvider>
+      <TextDirectionProvider dir="rtl">
+        {/* Inner components will have styles for RTL */}
+        {/* ... */}
+      </TextDirectionProvider>
+    </>
+  );
+}
+```
+
+## Shorthands
+
+`shorthands` provides a set of functions to mimic [CSS shorthands](https://developer.mozilla.org/en-US/docs/Web/CSS/Shorthand_properties) and improve developer experience as [some of CSS shorthands are not supported](https://griffel.js.org/react/guides/limitations#css-shorthands-are-not-supported) by Griffel.
+
+### `shorthands.borderColor`
+
+```js
+import { makeStyles, shorthands } from '@griffel/react';
+
+const useClasses = makeStyles({
+  root: {
+    ...shorthands.borderColor('red'),
+    ...shorthands.borderColor('red', 'blue'),
+    ...shorthands.borderColor('red', 'blue', 'green'),
+    ...shorthands.borderColor('red', 'blue', 'green', 'yellow'),
+  },
+});
+```
+
+### `shorthands.borderStyle`
+
+```js
+import { makeStyles, shorthands } from '@griffel/react';
+
+const useClasses = makeStyles({
+  root: {
+    ...shorthands.borderStyle('solid'),
+    ...shorthands.borderStyle('solid', 'dashed'),
+    ...shorthands.borderStyle('solid', 'dashed', 'dotted'),
+    ...shorthands.borderStyle('solid', 'dashed', 'dotted', 'double'),
+  },
+});
+```
+
+### `shorthands.borderWidth`
+
+```js
+import { makeStyles, shorthands } from '@griffel/react';
+
+const useClasses = makeStyles({
+  root: {
+    ...shorthands.borderWidth('12px'),
+    ...shorthands.borderWidth('12px', '24px'),
+    ...shorthands.borderWidth('12px', '24px', '36px'),
+    ...shorthands.borderWidth('12px', '24px', '36px', '48px'),
+  },
+});
+```

node_modules/@griffel/react/RendererContext.cjs.js

@@ -0,0 +1,62 @@
+"use client";
+'use strict';
+
+var core = require('@griffel/core');
+var React = require('react');
+var canUseDOM = require('./utils/canUseDOM.cjs.js');
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceCompat(React);
+
+/**
+ * @private
+ */
+const RendererContext = /*#__PURE__*/React__namespace.createContext(/*#__PURE__*/core.createDOMRenderer());
+/**
+ * @public
+ */
+const RendererProvider = ({
+  children,
+  renderer,
+  targetDocument
+}) => {
+  React__namespace.useMemo(() => {
+    if (canUseDOM.canUseDOM()) {
+      // "rehydrateCache()" can't be called in effects as it needs to be called before any component will be rendered to
+      // avoid double insertion of classes
+      core.rehydrateRendererCache(renderer, targetDocument);
+    }
+  }, [renderer, targetDocument]);
+  return /*#__PURE__*/React__namespace.createElement(RendererContext.Provider, {
+    value: renderer
+  }, children);
+};
+/**
+ * Returns an instance of current makeStyles() renderer.
+ *
+ * @private Exported as "useRenderer_unstable" use it on own risk. Can be changed or removed without a notice.
+ */
+function useRenderer() {
+  return React__namespace.useContext(RendererContext);
+}
+
+exports.RendererProvider = RendererProvider;
+exports.useRenderer = useRenderer;
+//# sourceMappingURL=RendererContext.cjs.js.map

node_modules/@griffel/react/RendererContext.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RendererContext.cjs.js","sources":["../../../packages/react/src/RendererContext.tsx"],"sourcesContent":["'use client';\n\nimport { createDOMRenderer, rehydrateRendererCache } from '@griffel/core';\nimport type { GriffelRenderer } from '@griffel/core';\nimport * as React from 'react';\n\nimport { canUseDOM } from './utils/canUseDOM';\n\nexport interface RendererProviderProps {\n  /** An instance of Griffel renderer. */\n  renderer: GriffelRenderer;\n\n  /**\n   * Document used to insert CSS variables to head\n   */\n  targetDocument?: Document;\n\n  /**\n   * Content wrapped by the RendererProvider\n   */\n  children: React.ReactNode;\n}\n\n/**\n * @private\n */\nconst RendererContext = React.createContext<GriffelRenderer>(createDOMRenderer());\n\n/**\n * @public\n */\nexport const RendererProvider: React.FC<RendererProviderProps> = ({ children, renderer, targetDocument }) => {\n  React.useMemo(() => {\n    if (canUseDOM()) {\n      // \"rehydrateCache()\" can't be called in effects as it needs to be called before any component will be rendered to\n      // avoid double insertion of classes\n      rehydrateRendererCache(renderer, targetDocument);\n    }\n  }, [renderer, targetDocument]);\n\n  return <RendererContext.Provider value={renderer}>{children}</RendererContext.Provider>;\n};\n\n/**\n * Returns an instance of current makeStyles() renderer.\n *\n * @private Exported as \"useRenderer_unstable\" use it on own risk. Can be changed or removed without a notice.\n */\nexport function useRenderer(): GriffelRenderer {\n  return React.useContext(RendererContext);\n}\n"],"names":["targetDocument","rehydrateRendererCache","value"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA;;AAEG;AACH;AAEA;;AAEG;AACI;;;AAAiFA;AAAc;;;AAGhG;AACA;AACAC;AACF;AACF;AAEA;AAAiCC;;AACnC;AAEA;;;;AAIG;;AAED;AACF;;;"}

node_modules/@griffel/react/RendererContext.esm.js

@@ -0,0 +1,39 @@
+"use client";
+import { rehydrateRendererCache, createDOMRenderer } from '@griffel/core';
+import * as React from 'react';
+import { canUseDOM } from './utils/canUseDOM.esm.js';
+
+/**
+ * @private
+ */
+const RendererContext = /*#__PURE__*/React.createContext(/*#__PURE__*/createDOMRenderer());
+/**
+ * @public
+ */
+const RendererProvider = ({
+  children,
+  renderer,
+  targetDocument
+}) => {
+  React.useMemo(() => {
+    if (canUseDOM()) {
+      // "rehydrateCache()" can't be called in effects as it needs to be called before any component will be rendered to
+      // avoid double insertion of classes
+      rehydrateRendererCache(renderer, targetDocument);
+    }
+  }, [renderer, targetDocument]);
+  return /*#__PURE__*/React.createElement(RendererContext.Provider, {
+    value: renderer
+  }, children);
+};
+/**
+ * Returns an instance of current makeStyles() renderer.
+ *
+ * @private Exported as "useRenderer_unstable" use it on own risk. Can be changed or removed without a notice.
+ */
+function useRenderer() {
+  return React.useContext(RendererContext);
+}
+
+export { RendererProvider, useRenderer };
+//# sourceMappingURL=RendererContext.esm.js.map

node_modules/@griffel/react/RendererContext.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RendererContext.esm.js","sources":["../../../packages/react/src/RendererContext.tsx"],"sourcesContent":["'use client';\n\nimport { createDOMRenderer, rehydrateRendererCache } from '@griffel/core';\nimport type { GriffelRenderer } from '@griffel/core';\nimport * as React from 'react';\n\nimport { canUseDOM } from './utils/canUseDOM';\n\nexport interface RendererProviderProps {\n  /** An instance of Griffel renderer. */\n  renderer: GriffelRenderer;\n\n  /**\n   * Document used to insert CSS variables to head\n   */\n  targetDocument?: Document;\n\n  /**\n   * Content wrapped by the RendererProvider\n   */\n  children: React.ReactNode;\n}\n\n/**\n * @private\n */\nconst RendererContext = React.createContext<GriffelRenderer>(createDOMRenderer());\n\n/**\n * @public\n */\nexport const RendererProvider: React.FC<RendererProviderProps> = ({ children, renderer, targetDocument }) => {\n  React.useMemo(() => {\n    if (canUseDOM()) {\n      // \"rehydrateCache()\" can't be called in effects as it needs to be called before any component will be rendered to\n      // avoid double insertion of classes\n      rehydrateRendererCache(renderer, targetDocument);\n    }\n  }, [renderer, targetDocument]);\n\n  return <RendererContext.Provider value={renderer}>{children}</RendererContext.Provider>;\n};\n\n/**\n * Returns an instance of current makeStyles() renderer.\n *\n * @private Exported as \"useRenderer_unstable\" use it on own risk. Can be changed or removed without a notice.\n */\nexport function useRenderer(): GriffelRenderer {\n  return React.useContext(RendererContext);\n}\n"],"names":["targetDocument","rehydrateRendererCache","value"],"mappings":";;;;;AAuBA;;AAEG;AACH;AAEA;;AAEG;AACI;;;AAAiFA;AAAc;;;AAGhG;AACA;AACAC;AACF;AACF;AAEA;AAAiCC;;AACnC;AAEA;;;;AAIG;;AAED;AACF;;"}

node_modules/@griffel/react/TextDirectionContext.cjs.js

@@ -0,0 +1,52 @@
+"use client";
+'use strict';
+
+var React = require('react');
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceCompat(React);
+
+/**
+ * @private
+ */
+const TextDirectionContext = /*#__PURE__*/React__namespace.createContext('ltr');
+/**
+ * @public
+ */
+const TextDirectionProvider = ({
+  children,
+  dir
+}) => {
+  return /*#__PURE__*/React__namespace.createElement(TextDirectionContext.Provider, {
+    value: dir
+  }, children);
+};
+/**
+ * Returns current directionality of the element's text.
+ *
+ * @private
+ */
+function useTextDirection() {
+  return React__namespace.useContext(TextDirectionContext);
+}
+
+exports.TextDirectionProvider = TextDirectionProvider;
+exports.useTextDirection = useTextDirection;
+//# sourceMappingURL=TextDirectionContext.cjs.js.map

node_modules/@griffel/react/TextDirectionContext.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextDirectionContext.cjs.js","sources":["../../../packages/react/src/TextDirectionContext.tsx"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\n\nexport interface TextDirectionProviderProps {\n  /** Indicates the directionality of the element's text. */\n  dir: 'ltr' | 'rtl';\n\n  /**\n   * Content wrapped by the TextDirectionProvider.\n   */\n  children: React.ReactNode;\n}\n\n/**\n * @private\n */\nconst TextDirectionContext = React.createContext<'ltr' | 'rtl'>('ltr');\n\n/**\n * @public\n */\nexport const TextDirectionProvider: React.FC<TextDirectionProviderProps> = ({ children, dir }) => {\n  return <TextDirectionContext.Provider value={dir}>{children}</TextDirectionContext.Provider>;\n};\n\n/**\n * Returns current directionality of the element's text.\n *\n * @private\n */\nexport function useTextDirection() {\n  return React.useContext(TextDirectionContext);\n}\n"],"names":["dir","value"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAcA;;AAEG;AACH;AAEA;;AAEG;AACI;;AAAiFA;AAAG;AACzF;AAAsCC;;AACxC;AAEA;;;;AAIG;;AAED;AACF;;;"}

node_modules/@griffel/react/TextDirectionContext.esm.js

@@ -0,0 +1,29 @@
+"use client";
+import * as React from 'react';
+
+/**
+ * @private
+ */
+const TextDirectionContext = /*#__PURE__*/React.createContext('ltr');
+/**
+ * @public
+ */
+const TextDirectionProvider = ({
+  children,
+  dir
+}) => {
+  return /*#__PURE__*/React.createElement(TextDirectionContext.Provider, {
+    value: dir
+  }, children);
+};
+/**
+ * Returns current directionality of the element's text.
+ *
+ * @private
+ */
+function useTextDirection() {
+  return React.useContext(TextDirectionContext);
+}
+
+export { TextDirectionProvider, useTextDirection };
+//# sourceMappingURL=TextDirectionContext.esm.js.map

node_modules/@griffel/react/TextDirectionContext.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextDirectionContext.esm.js","sources":["../../../packages/react/src/TextDirectionContext.tsx"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\n\nexport interface TextDirectionProviderProps {\n  /** Indicates the directionality of the element's text. */\n  dir: 'ltr' | 'rtl';\n\n  /**\n   * Content wrapped by the TextDirectionProvider.\n   */\n  children: React.ReactNode;\n}\n\n/**\n * @private\n */\nconst TextDirectionContext = React.createContext<'ltr' | 'rtl'>('ltr');\n\n/**\n * @public\n */\nexport const TextDirectionProvider: React.FC<TextDirectionProviderProps> = ({ children, dir }) => {\n  return <TextDirectionContext.Provider value={dir}>{children}</TextDirectionContext.Provider>;\n};\n\n/**\n * Returns current directionality of the element's text.\n *\n * @private\n */\nexport function useTextDirection() {\n  return React.useContext(TextDirectionContext);\n}\n"],"names":["dir","value"],"mappings":";;;AAcA;;AAEG;AACH;AAEA;;AAEG;AACI;;AAAiFA;AAAG;AACzF;AAAsCC;;AACxC;AAEA;;;;AAIG;;AAED;AACF;;"}

node_modules/@griffel/react/__css.cjs.js

@@ -0,0 +1,24 @@
+"use client";
+'use strict';
+
+var core = require('@griffel/core');
+var TextDirectionContext = require('./TextDirectionContext.cjs.js');
+
+/**
+ * A version of makeStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function __css(classesMapBySlot) {
+  const getStyles = core.__css(classesMapBySlot);
+  return function useClasses() {
+    const dir = TextDirectionContext.useTextDirection();
+    return getStyles({
+      dir
+    });
+  };
+}
+
+exports.__css = __css;
+//# sourceMappingURL=__css.cjs.js.map

node_modules/@griffel/react/__css.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__css.cjs.js","sources":["../../../packages/react/src/__css.ts"],"sourcesContent":["'use client';\n\nimport { __css as vanillaCSS } from '@griffel/core';\nimport type { CSSClassesMapBySlot } from '@griffel/core';\n\nimport { useTextDirection } from './TextDirectionContext';\n\n/**\n * A version of makeStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function __css<Slots extends string>(classesMapBySlot: CSSClassesMapBySlot<Slots>) {\n  const getStyles = vanillaCSS(classesMapBySlot);\n\n  return function useClasses(): Record<Slots, string> {\n    const dir = useTextDirection();\n\n    return getStyles({ dir });\n  };\n}\n"],"names":["dir"],"mappings":";;;;;;AAOA;;;;AAIG;AACH;AACM;AACJ;;AAGE;AAEA;AAAmBA;AAAG;;AAE1B;;"}

node_modules/@griffel/react/__css.esm.js

@@ -0,0 +1,22 @@
+"use client";
+import { __css as __css$1 } from '@griffel/core';
+import { useTextDirection } from './TextDirectionContext.esm.js';
+
+/**
+ * A version of makeStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function __css(classesMapBySlot) {
+  const getStyles = __css$1(classesMapBySlot);
+  return function useClasses() {
+    const dir = useTextDirection();
+    return getStyles({
+      dir
+    });
+  };
+}
+
+export { __css };
+//# sourceMappingURL=__css.esm.js.map

node_modules/@griffel/react/__css.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__css.esm.js","sources":["../../../packages/react/src/__css.ts"],"sourcesContent":["'use client';\n\nimport { __css as vanillaCSS } from '@griffel/core';\nimport type { CSSClassesMapBySlot } from '@griffel/core';\n\nimport { useTextDirection } from './TextDirectionContext';\n\n/**\n * A version of makeStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function __css<Slots extends string>(classesMapBySlot: CSSClassesMapBySlot<Slots>) {\n  const getStyles = vanillaCSS(classesMapBySlot);\n\n  return function useClasses(): Record<Slots, string> {\n    const dir = useTextDirection();\n\n    return getStyles({ dir });\n  };\n}\n"],"names":["dir"],"mappings":";;;;AAOA;;;;AAIG;AACH;AACM;AACJ;;AAGE;AAEA;AAAmBA;AAAG;;AAE1B;;"}

node_modules/@griffel/react/__resetCSS.cjs.js

@@ -0,0 +1,24 @@
+"use client";
+'use strict';
+
+var core = require('@griffel/core');
+var TextDirectionContext = require('./TextDirectionContext.cjs.js');
+
+/**
+ * A version of makeResetStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function __resetCSS(ltrClassName, rtlClassName) {
+  const getStyles = core.__resetCSS(ltrClassName, rtlClassName);
+  return function useClasses() {
+    const dir = TextDirectionContext.useTextDirection();
+    return getStyles({
+      dir
+    });
+  };
+}
+
+exports.__resetCSS = __resetCSS;
+//# sourceMappingURL=__resetCSS.cjs.js.map

node_modules/@griffel/react/__resetCSS.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__resetCSS.cjs.js","sources":["../../../packages/react/src/__resetCSS.ts"],"sourcesContent":["'use client';\n\nimport { __resetCSS as vanillaResetCSS } from '@griffel/core';\nimport { useTextDirection } from './TextDirectionContext';\n\n/**\n * A version of makeResetStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function __resetCSS(ltrClassName: string, rtlClassName: string | null) {\n  const getStyles = vanillaResetCSS(ltrClassName, rtlClassName);\n\n  return function useClasses(): string {\n    const dir = useTextDirection();\n\n    return getStyles({ dir });\n  };\n}\n"],"names":["dir"],"mappings":";;;;;;AAKA;;;;AAIG;AACH;AACM;AACJ;;AAGE;AAEA;AAAmBA;AAAG;;AAE1B;;"}

node_modules/@griffel/react/__resetCSS.esm.js

@@ -0,0 +1,22 @@
+"use client";
+import { __resetCSS as __resetCSS$1 } from '@griffel/core';
+import { useTextDirection } from './TextDirectionContext.esm.js';
+
+/**
+ * A version of makeResetStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function __resetCSS(ltrClassName, rtlClassName) {
+  const getStyles = __resetCSS$1(ltrClassName, rtlClassName);
+  return function useClasses() {
+    const dir = useTextDirection();
+    return getStyles({
+      dir
+    });
+  };
+}
+
+export { __resetCSS };
+//# sourceMappingURL=__resetCSS.esm.js.map

node_modules/@griffel/react/__resetCSS.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__resetCSS.esm.js","sources":["../../../packages/react/src/__resetCSS.ts"],"sourcesContent":["'use client';\n\nimport { __resetCSS as vanillaResetCSS } from '@griffel/core';\nimport { useTextDirection } from './TextDirectionContext';\n\n/**\n * A version of makeResetStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function __resetCSS(ltrClassName: string, rtlClassName: string | null) {\n  const getStyles = vanillaResetCSS(ltrClassName, rtlClassName);\n\n  return function useClasses(): string {\n    const dir = useTextDirection();\n\n    return getStyles({ dir });\n  };\n}\n"],"names":["dir"],"mappings":";;;;AAKA;;;;AAIG;AACH;AACM;AACJ;;AAGE;AAEA;AAAmBA;AAAG;;AAE1B;;"}

node_modules/@griffel/react/__resetStyles.cjs.js

@@ -0,0 +1,28 @@
+"use client";
+'use strict';
+
+var core = require('@griffel/core');
+var insertionFactory = require('./insertionFactory.cjs.js');
+var RendererContext = require('./RendererContext.cjs.js');
+var TextDirectionContext = require('./TextDirectionContext.cjs.js');
+
+/**
+ * A version of makeResetStyles() that accepts build output as an input and skips all runtime transforms.
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function __resetStyles(ltrClassName, rtlClassName, cssRules) {
+  const getStyles = core.__resetStyles(ltrClassName, rtlClassName, cssRules, insertionFactory.insertionFactory);
+  return function useClasses() {
+    const dir = TextDirectionContext.useTextDirection();
+    const renderer = RendererContext.useRenderer();
+    return getStyles({
+      dir,
+      renderer
+    });
+  };
+}
+
+exports.__resetStyles = __resetStyles;
+//# sourceMappingURL=__resetStyles.cjs.js.map

node_modules/@griffel/react/__resetStyles.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__resetStyles.cjs.js","sources":["../../../packages/react/src/__resetStyles.ts"],"sourcesContent":["'use client';\n\nimport { __resetStyles as vanillaResetStyles } from '@griffel/core';\nimport type { CSSRulesByBucket } from '@griffel/core';\n\nimport { insertionFactory } from './insertionFactory';\nimport { useRenderer } from './RendererContext';\nimport { useTextDirection } from './TextDirectionContext';\n\n/**\n * A version of makeResetStyles() that accepts build output as an input and skips all runtime transforms.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function __resetStyles(\n  ltrClassName: string,\n  rtlClassName: string | null,\n  cssRules: CSSRulesByBucket | string[],\n) {\n  const getStyles = vanillaResetStyles(ltrClassName, rtlClassName, cssRules, insertionFactory);\n\n  return function useClasses(): string {\n    const dir = useTextDirection();\n    const renderer = useRenderer();\n\n    return getStyles({ dir, renderer });\n  };\n}\n"],"names":["renderer"],"mappings":";;;;;;;;AASA;;;;AAIG;AACH;;;;AASI;AACA;AAEA;;AAAwBA;AAAQ;;AAEpC;;"}

node_modules/@griffel/react/__resetStyles.esm.js

@@ -0,0 +1,26 @@
+"use client";
+import { __resetStyles as __resetStyles$1 } from '@griffel/core';
+import { insertionFactory } from './insertionFactory.esm.js';
+import { useRenderer } from './RendererContext.esm.js';
+import { useTextDirection } from './TextDirectionContext.esm.js';
+
+/**
+ * A version of makeResetStyles() that accepts build output as an input and skips all runtime transforms.
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function __resetStyles(ltrClassName, rtlClassName, cssRules) {
+  const getStyles = __resetStyles$1(ltrClassName, rtlClassName, cssRules, insertionFactory);
+  return function useClasses() {
+    const dir = useTextDirection();
+    const renderer = useRenderer();
+    return getStyles({
+      dir,
+      renderer
+    });
+  };
+}
+
+export { __resetStyles };
+//# sourceMappingURL=__resetStyles.esm.js.map

node_modules/@griffel/react/__resetStyles.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__resetStyles.esm.js","sources":["../../../packages/react/src/__resetStyles.ts"],"sourcesContent":["'use client';\n\nimport { __resetStyles as vanillaResetStyles } from '@griffel/core';\nimport type { CSSRulesByBucket } from '@griffel/core';\n\nimport { insertionFactory } from './insertionFactory';\nimport { useRenderer } from './RendererContext';\nimport { useTextDirection } from './TextDirectionContext';\n\n/**\n * A version of makeResetStyles() that accepts build output as an input and skips all runtime transforms.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function __resetStyles(\n  ltrClassName: string,\n  rtlClassName: string | null,\n  cssRules: CSSRulesByBucket | string[],\n) {\n  const getStyles = vanillaResetStyles(ltrClassName, rtlClassName, cssRules, insertionFactory);\n\n  return function useClasses(): string {\n    const dir = useTextDirection();\n    const renderer = useRenderer();\n\n    return getStyles({ dir, renderer });\n  };\n}\n"],"names":["renderer"],"mappings":";;;;;;AASA;;;;AAIG;AACH;;;;AASI;AACA;AAEA;;AAAwBA;AAAQ;;AAEpC;;"}

node_modules/@griffel/react/__staticCSS.cjs.js

@@ -0,0 +1,20 @@
+"use client";
+'use strict';
+
+var core = require('@griffel/core');
+
+/**
+ * A version of makeStaticStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function __staticCSS() {
+  const getStyles = core.__staticCSS();
+  return function useStaticStyles() {
+    return getStyles();
+  };
+}
+
+exports.__staticCSS = __staticCSS;
+//# sourceMappingURL=__staticCSS.cjs.js.map

node_modules/@griffel/react/__staticCSS.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__staticCSS.cjs.js","sources":["../../../packages/react/src/__staticCSS.ts"],"sourcesContent":["'use client';\n\nimport { __staticCSS as vanillaStaticCSS } from '@griffel/core';\n\n/**\n * A version of makeStaticStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function __staticCSS() {\n  const getStyles = vanillaStaticCSS();\n\n  return function useStaticStyles(): void {\n    return getStyles();\n  };\n}\n"],"names":[],"mappings":";;;;;AAIA;;;;AAIG;AACH;;AAEE;;;;AAKF;;"}

node_modules/@griffel/react/__staticCSS.esm.js

@@ -0,0 +1,18 @@
+"use client";
+import { __staticCSS as __staticCSS$1 } from '@griffel/core';
+
+/**
+ * A version of makeStaticStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function __staticCSS() {
+  const getStyles = __staticCSS$1();
+  return function useStaticStyles() {
+    return getStyles();
+  };
+}
+
+export { __staticCSS };
+//# sourceMappingURL=__staticCSS.esm.js.map

node_modules/@griffel/react/__staticCSS.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__staticCSS.esm.js","sources":["../../../packages/react/src/__staticCSS.ts"],"sourcesContent":["'use client';\n\nimport { __staticCSS as vanillaStaticCSS } from '@griffel/core';\n\n/**\n * A version of makeStaticStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function __staticCSS() {\n  const getStyles = vanillaStaticCSS();\n\n  return function useStaticStyles(): void {\n    return getStyles();\n  };\n}\n"],"names":[],"mappings":";;;AAIA;;;;AAIG;AACH;;AAEE;;;;AAKF;;"}

node_modules/@griffel/react/__staticStyles.cjs.js

@@ -0,0 +1,25 @@
+"use client";
+'use strict';
+
+var core = require('@griffel/core');
+var insertionFactory = require('./insertionFactory.cjs.js');
+var RendererContext = require('./RendererContext.cjs.js');
+
+/**
+ * A version of makeStaticStyles() that accepts build output as an input and skips all runtime transforms.
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function __staticStyles(cssRules) {
+  const getStyles = core.__staticStyles(cssRules, insertionFactory.insertionFactory);
+  return function useStaticStyles() {
+    const renderer = RendererContext.useRenderer();
+    return getStyles({
+      renderer
+    });
+  };
+}
+
+exports.__staticStyles = __staticStyles;
+//# sourceMappingURL=__staticStyles.cjs.js.map

node_modules/@griffel/react/__staticStyles.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__staticStyles.cjs.js","sources":["../../../packages/react/src/__staticStyles.ts"],"sourcesContent":["'use client';\n\nimport { __staticStyles as vanillaStaticStyles } from '@griffel/core';\nimport type { CSSRulesByBucket } from '@griffel/core';\n\nimport { insertionFactory } from './insertionFactory';\nimport { useRenderer } from './RendererContext';\n\n/**\n * A version of makeStaticStyles() that accepts build output as an input and skips all runtime transforms.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function __staticStyles(cssRules: CSSRulesByBucket) {\n  const getStyles = vanillaStaticStyles(cssRules, insertionFactory);\n\n  return function useStaticStyles(): void {\n    const renderer = useRenderer();\n\n    return getStyles({ renderer });\n  };\n}\n"],"names":["renderer"],"mappings":";;;;;;;AAQA;;;;AAIG;AACH;AACM;AACJ;;AAGE;AAEA;AAAmBA;AAAQ;;AAE/B;;"}

node_modules/@griffel/react/__staticStyles.esm.js

@@ -0,0 +1,23 @@
+"use client";
+import { __staticStyles as __staticStyles$1 } from '@griffel/core';
+import { insertionFactory } from './insertionFactory.esm.js';
+import { useRenderer } from './RendererContext.esm.js';
+
+/**
+ * A version of makeStaticStyles() that accepts build output as an input and skips all runtime transforms.
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function __staticStyles(cssRules) {
+  const getStyles = __staticStyles$1(cssRules, insertionFactory);
+  return function useStaticStyles() {
+    const renderer = useRenderer();
+    return getStyles({
+      renderer
+    });
+  };
+}
+
+export { __staticStyles };
+//# sourceMappingURL=__staticStyles.esm.js.map

node_modules/@griffel/react/__staticStyles.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__staticStyles.esm.js","sources":["../../../packages/react/src/__staticStyles.ts"],"sourcesContent":["'use client';\n\nimport { __staticStyles as vanillaStaticStyles } from '@griffel/core';\nimport type { CSSRulesByBucket } from '@griffel/core';\n\nimport { insertionFactory } from './insertionFactory';\nimport { useRenderer } from './RendererContext';\n\n/**\n * A version of makeStaticStyles() that accepts build output as an input and skips all runtime transforms.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function __staticStyles(cssRules: CSSRulesByBucket) {\n  const getStyles = vanillaStaticStyles(cssRules, insertionFactory);\n\n  return function useStaticStyles(): void {\n    const renderer = useRenderer();\n\n    return getStyles({ renderer });\n  };\n}\n"],"names":["renderer"],"mappings":";;;;;AAQA;;;;AAIG;AACH;AACM;AACJ;;AAGE;AAEA;AAAmBA;AAAQ;;AAE/B;;"}

node_modules/@griffel/react/__styles.cjs.js

@@ -0,0 +1,28 @@
+"use client";
+'use strict';
+
+var core = require('@griffel/core');
+var insertionFactory = require('./insertionFactory.cjs.js');
+var RendererContext = require('./RendererContext.cjs.js');
+var TextDirectionContext = require('./TextDirectionContext.cjs.js');
+
+/**
+ * A version of makeStyles() that accepts build output as an input and skips all runtime transforms.
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function __styles(classesMapBySlot, cssRules) {
+  const getStyles = core.__styles(classesMapBySlot, cssRules, insertionFactory.insertionFactory);
+  return function useClasses() {
+    const dir = TextDirectionContext.useTextDirection();
+    const renderer = RendererContext.useRenderer();
+    return getStyles({
+      dir,
+      renderer
+    });
+  };
+}
+
+exports.__styles = __styles;
+//# sourceMappingURL=__styles.cjs.js.map

node_modules/@griffel/react/__styles.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__styles.cjs.js","sources":["../../../packages/react/src/__styles.ts"],"sourcesContent":["'use client';\n\nimport { __styles as vanillaStyles } from '@griffel/core';\nimport type { CSSClassesMapBySlot, CSSRulesByBucket } from '@griffel/core';\n\nimport { insertionFactory } from './insertionFactory';\nimport { useRenderer } from './RendererContext';\nimport { useTextDirection } from './TextDirectionContext';\n\n/**\n * A version of makeStyles() that accepts build output as an input and skips all runtime transforms.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function __styles<Slots extends string>(\n  classesMapBySlot: CSSClassesMapBySlot<Slots>,\n  cssRules: CSSRulesByBucket,\n) {\n  const getStyles = vanillaStyles(classesMapBySlot, cssRules, insertionFactory);\n\n  return function useClasses(): Record<Slots, string> {\n    const dir = useTextDirection();\n    const renderer = useRenderer();\n\n    return getStyles({ dir, renderer });\n  };\n}\n"],"names":["renderer"],"mappings":";;;;;;;;AASA;;;;AAIG;AACH;AACM;;;AAOF;AACA;AAEA;;AAAwBA;AAAQ;;AAEpC;;"}

node_modules/@griffel/react/__styles.esm.js

@@ -0,0 +1,26 @@
+"use client";
+import { __styles as __styles$1 } from '@griffel/core';
+import { insertionFactory } from './insertionFactory.esm.js';
+import { useRenderer } from './RendererContext.esm.js';
+import { useTextDirection } from './TextDirectionContext.esm.js';
+
+/**
+ * A version of makeStyles() that accepts build output as an input and skips all runtime transforms.
+ *
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+function __styles(classesMapBySlot, cssRules) {
+  const getStyles = __styles$1(classesMapBySlot, cssRules, insertionFactory);
+  return function useClasses() {
+    const dir = useTextDirection();
+    const renderer = useRenderer();
+    return getStyles({
+      dir,
+      renderer
+    });
+  };
+}
+
+export { __styles };
+//# sourceMappingURL=__styles.esm.js.map

node_modules/@griffel/react/__styles.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__styles.esm.js","sources":["../../../packages/react/src/__styles.ts"],"sourcesContent":["'use client';\n\nimport { __styles as vanillaStyles } from '@griffel/core';\nimport type { CSSClassesMapBySlot, CSSRulesByBucket } from '@griffel/core';\n\nimport { insertionFactory } from './insertionFactory';\nimport { useRenderer } from './RendererContext';\nimport { useTextDirection } from './TextDirectionContext';\n\n/**\n * A version of makeStyles() that accepts build output as an input and skips all runtime transforms.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function __styles<Slots extends string>(\n  classesMapBySlot: CSSClassesMapBySlot<Slots>,\n  cssRules: CSSRulesByBucket,\n) {\n  const getStyles = vanillaStyles(classesMapBySlot, cssRules, insertionFactory);\n\n  return function useClasses(): Record<Slots, string> {\n    const dir = useTextDirection();\n    const renderer = useRenderer();\n\n    return getStyles({ dir, renderer });\n  };\n}\n"],"names":["renderer"],"mappings":";;;;;;AASA;;;;AAIG;AACH;AACM;;;AAOF;AACA;AAEA;;AAAwBA;AAAQ;;AAEpC;;"}

node_modules/@griffel/react/index.cjs.js

@@ -0,0 +1,49 @@
+"use client";
+'use strict';
+
+var core = require('@griffel/core');
+var makeStyles = require('./makeStyles.cjs.js');
+var makeResetStyles = require('./makeResetStyles.cjs.js');
+var makeStaticStyles = require('./makeStaticStyles.cjs.js');
+var renderToStyleElements = require('./renderToStyleElements.cjs.js');
+var RendererContext = require('./RendererContext.cjs.js');
+var TextDirectionContext = require('./TextDirectionContext.cjs.js');
+var __css = require('./__css.cjs.js');
+var __styles = require('./__styles.cjs.js');
+var __resetCSS = require('./__resetCSS.cjs.js');
+var __resetStyles = require('./__resetStyles.cjs.js');
+var __staticCSS = require('./__staticCSS.cjs.js');
+var __staticStyles = require('./__staticStyles.cjs.js');
+
+
+
+Object.defineProperty(exports, "RESET", {
+	enumerable: true,
+	get: function () { return core.RESET; }
+});
+Object.defineProperty(exports, "createDOMRenderer", {
+	enumerable: true,
+	get: function () { return core.createDOMRenderer; }
+});
+Object.defineProperty(exports, "mergeClasses", {
+	enumerable: true,
+	get: function () { return core.mergeClasses; }
+});
+Object.defineProperty(exports, "shorthands", {
+	enumerable: true,
+	get: function () { return core.shorthands; }
+});
+exports.makeStyles = makeStyles.makeStyles;
+exports.makeResetStyles = makeResetStyles.makeResetStyles;
+exports.makeStaticStyles = makeStaticStyles.makeStaticStyles;
+exports.renderToStyleElements = renderToStyleElements.renderToStyleElements;
+exports.RendererProvider = RendererContext.RendererProvider;
+exports.useRenderer_unstable = RendererContext.useRenderer;
+exports.TextDirectionProvider = TextDirectionContext.TextDirectionProvider;
+exports.__css = __css.__css;
+exports.__styles = __styles.__styles;
+exports.__resetCSS = __resetCSS.__resetCSS;
+exports.__resetStyles = __resetStyles.__resetStyles;
+exports.__staticCSS = __staticCSS.__staticCSS;
+exports.__staticStyles = __staticStyles.__staticStyles;
+//# sourceMappingURL=index.cjs.js.map

node_modules/@griffel/react/index.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

node_modules/@griffel/react/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

node_modules/@griffel/react/index.esm.js

@@ -0,0 +1,15 @@
+"use client";
+export { RESET, createDOMRenderer, mergeClasses, shorthands } from '@griffel/core';
+export { makeStyles } from './makeStyles.esm.js';
+export { makeResetStyles } from './makeResetStyles.esm.js';
+export { makeStaticStyles } from './makeStaticStyles.esm.js';
+export { renderToStyleElements } from './renderToStyleElements.esm.js';
+export { RendererProvider, useRenderer as useRenderer_unstable } from './RendererContext.esm.js';
+export { TextDirectionProvider } from './TextDirectionContext.esm.js';
+export { __css } from './__css.esm.js';
+export { __styles } from './__styles.esm.js';
+export { __resetCSS } from './__resetCSS.esm.js';
+export { __resetStyles } from './__resetStyles.esm.js';
+export { __staticCSS } from './__staticCSS.esm.js';
+export { __staticStyles } from './__staticStyles.esm.js';
+//# sourceMappingURL=index.esm.js.map

node_modules/@griffel/react/index.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}

node_modules/@griffel/react/insertionFactory.cjs.js

@@ -0,0 +1,26 @@
+"use client";
+'use strict';
+
+var canUseDOM = require('./utils/canUseDOM.cjs.js');
+var useInsertionEffect = require('./useInsertionEffect.cjs.js');
+
+const insertionFactory = () => {
+  const insertionCache = {};
+  return function insert(renderer, cssRules) {
+    // Even if `useInsertionEffect` is available, we can use it on a client only as it will not be executed in SSR
+    if (useInsertionEffect.useInsertionEffect && canUseDOM.canUseDOM()) {
+      // eslint-disable-next-line react-hooks/rules-of-hooks
+      useInsertionEffect.useInsertionEffect(() => {
+        renderer.insertCSSRules(cssRules);
+      }, [renderer, cssRules]);
+      return;
+    }
+    if (insertionCache[renderer.id] === undefined) {
+      renderer.insertCSSRules(cssRules);
+      insertionCache[renderer.id] = true;
+    }
+  };
+};
+
+exports.insertionFactory = insertionFactory;
+//# sourceMappingURL=insertionFactory.cjs.js.map

node_modules/@griffel/react/insertionFactory.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"insertionFactory.cjs.js","sources":["../../../packages/react/src/insertionFactory.ts"],"sourcesContent":["'use client';\n\nimport type { CSSRulesByBucket, GriffelInsertionFactory, GriffelRenderer } from '@griffel/core';\n\nimport { canUseDOM } from './utils/canUseDOM';\nimport { useInsertionEffect } from './useInsertionEffect';\n\nexport const insertionFactory: GriffelInsertionFactory = () => {\n  const insertionCache: Record<string, boolean> = {};\n\n  return function insert(renderer: GriffelRenderer, cssRules: CSSRulesByBucket) {\n    // Even if `useInsertionEffect` is available, we can use it on a client only as it will not be executed in SSR\n    if (useInsertionEffect && canUseDOM()) {\n      // eslint-disable-next-line react-hooks/rules-of-hooks\n      useInsertionEffect(() => {\n        renderer.insertCSSRules(cssRules!);\n      }, [renderer, cssRules]);\n\n      return;\n    }\n\n    if (insertionCache[renderer.id] === undefined) {\n      renderer.insertCSSRules(cssRules!);\n      insertionCache[renderer.id] = true;\n    }\n  };\n};\n"],"names":["useInsertionEffect","renderer","insertionCache"],"mappings":";;;;;;AAOO;;AAGL;AACE;AACA;AACE;AACAA;AACEC;AACF;AAEA;AACF;;AAGEA;AACAC;AACF;;AAEJ;;"}

node_modules/@griffel/react/insertionFactory.esm.js

@@ -0,0 +1,24 @@
+"use client";
+import { canUseDOM } from './utils/canUseDOM.esm.js';
+import { useInsertionEffect } from './useInsertionEffect.esm.js';
+
+const insertionFactory = () => {
+  const insertionCache = {};
+  return function insert(renderer, cssRules) {
+    // Even if `useInsertionEffect` is available, we can use it on a client only as it will not be executed in SSR
+    if (useInsertionEffect && canUseDOM()) {
+      // eslint-disable-next-line react-hooks/rules-of-hooks
+      useInsertionEffect(() => {
+        renderer.insertCSSRules(cssRules);
+      }, [renderer, cssRules]);
+      return;
+    }
+    if (insertionCache[renderer.id] === undefined) {
+      renderer.insertCSSRules(cssRules);
+      insertionCache[renderer.id] = true;
+    }
+  };
+};
+
+export { insertionFactory };
+//# sourceMappingURL=insertionFactory.esm.js.map

node_modules/@griffel/react/insertionFactory.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"insertionFactory.esm.js","sources":["../../../packages/react/src/insertionFactory.ts"],"sourcesContent":["'use client';\n\nimport type { CSSRulesByBucket, GriffelInsertionFactory, GriffelRenderer } from '@griffel/core';\n\nimport { canUseDOM } from './utils/canUseDOM';\nimport { useInsertionEffect } from './useInsertionEffect';\n\nexport const insertionFactory: GriffelInsertionFactory = () => {\n  const insertionCache: Record<string, boolean> = {};\n\n  return function insert(renderer: GriffelRenderer, cssRules: CSSRulesByBucket) {\n    // Even if `useInsertionEffect` is available, we can use it on a client only as it will not be executed in SSR\n    if (useInsertionEffect && canUseDOM()) {\n      // eslint-disable-next-line react-hooks/rules-of-hooks\n      useInsertionEffect(() => {\n        renderer.insertCSSRules(cssRules!);\n      }, [renderer, cssRules]);\n\n      return;\n    }\n\n    if (insertionCache[renderer.id] === undefined) {\n      renderer.insertCSSRules(cssRules!);\n      insertionCache[renderer.id] = true;\n    }\n  };\n};\n"],"names":["useInsertionEffect","renderer","insertionCache"],"mappings":";;;;AAOO;;AAGL;AACE;AACA;AACE;AACAA;AACEC;AACF;AAEA;AACF;;AAGEA;AACAC;AACF;;AAEJ;;"}

node_modules/@griffel/react/makeResetStyles.cjs.js

@@ -0,0 +1,28 @@
+"use client";
+'use strict';
+
+var core = require('@griffel/core');
+var insertionFactory = require('./insertionFactory.cjs.js');
+var RendererContext = require('./RendererContext.cjs.js');
+var TextDirectionContext = require('./TextDirectionContext.cjs.js');
+var isInsideComponent = require('./utils/isInsideComponent.cjs.js');
+
+function makeResetStyles(styles) {
+  const getStyles = core.makeResetStyles(styles, insertionFactory.insertionFactory);
+  if (process.env.NODE_ENV !== 'production') {
+    if (isInsideComponent.isInsideComponent()) {
+      throw new Error(["makeResetStyles(): this function cannot be called in component's scope.", 'All makeResetStyles() calls should be top level i.e. in a root scope of a file.'].join(' '));
+    }
+  }
+  return function useClassName() {
+    const dir = TextDirectionContext.useTextDirection();
+    const renderer = RendererContext.useRenderer();
+    return getStyles({
+      dir,
+      renderer
+    });
+  };
+}
+
+exports.makeResetStyles = makeResetStyles;
+//# sourceMappingURL=makeResetStyles.cjs.js.map

node_modules/@griffel/react/makeResetStyles.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeResetStyles.cjs.js","sources":["../../../packages/react/src/makeResetStyles.ts"],"sourcesContent":["'use client';\n\nimport { makeResetStyles as vanillaMakeResetStyles } from '@griffel/core';\nimport type { GriffelResetStyle } from '@griffel/core';\n\nimport { insertionFactory } from './insertionFactory';\nimport { useRenderer } from './RendererContext';\nimport { useTextDirection } from './TextDirectionContext';\nimport { isInsideComponent } from './utils/isInsideComponent';\n\nexport function makeResetStyles(styles: GriffelResetStyle) {\n  const getStyles = vanillaMakeResetStyles(styles, insertionFactory);\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (isInsideComponent()) {\n      throw new Error(\n        [\n          \"makeResetStyles(): this function cannot be called in component's scope.\",\n          'All makeResetStyles() calls should be top level i.e. in a root scope of a file.',\n        ].join(' '),\n      );\n    }\n  }\n\n  return function useClassName(): string {\n    const dir = useTextDirection();\n    const renderer = useRenderer();\n\n    return getStyles({ dir, renderer });\n  };\n}\n"],"names":["renderer"],"mappings":";;;;;;;;;AAUM;AACJ;AAEA;;AAEI;AAMF;AACF;;AAGE;AACA;AAEA;;AAAwBA;AAAQ;;AAEpC;;"}

node_modules/@griffel/react/makeResetStyles.esm.js

@@ -0,0 +1,26 @@
+"use client";
+import { makeResetStyles as makeResetStyles$1 } from '@griffel/core';
+import { insertionFactory } from './insertionFactory.esm.js';
+import { useRenderer } from './RendererContext.esm.js';
+import { useTextDirection } from './TextDirectionContext.esm.js';
+import { isInsideComponent } from './utils/isInsideComponent.esm.js';
+
+function makeResetStyles(styles) {
+  const getStyles = makeResetStyles$1(styles, insertionFactory);
+  if (process.env.NODE_ENV !== 'production') {
+    if (isInsideComponent()) {
+      throw new Error(["makeResetStyles(): this function cannot be called in component's scope.", 'All makeResetStyles() calls should be top level i.e. in a root scope of a file.'].join(' '));
+    }
+  }
+  return function useClassName() {
+    const dir = useTextDirection();
+    const renderer = useRenderer();
+    return getStyles({
+      dir,
+      renderer
+    });
+  };
+}
+
+export { makeResetStyles };
+//# sourceMappingURL=makeResetStyles.esm.js.map

node_modules/@griffel/react/makeResetStyles.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeResetStyles.esm.js","sources":["../../../packages/react/src/makeResetStyles.ts"],"sourcesContent":["'use client';\n\nimport { makeResetStyles as vanillaMakeResetStyles } from '@griffel/core';\nimport type { GriffelResetStyle } from '@griffel/core';\n\nimport { insertionFactory } from './insertionFactory';\nimport { useRenderer } from './RendererContext';\nimport { useTextDirection } from './TextDirectionContext';\nimport { isInsideComponent } from './utils/isInsideComponent';\n\nexport function makeResetStyles(styles: GriffelResetStyle) {\n  const getStyles = vanillaMakeResetStyles(styles, insertionFactory);\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (isInsideComponent()) {\n      throw new Error(\n        [\n          \"makeResetStyles(): this function cannot be called in component's scope.\",\n          'All makeResetStyles() calls should be top level i.e. in a root scope of a file.',\n        ].join(' '),\n      );\n    }\n  }\n\n  return function useClassName(): string {\n    const dir = useTextDirection();\n    const renderer = useRenderer();\n\n    return getStyles({ dir, renderer });\n  };\n}\n"],"names":["renderer"],"mappings":";;;;;;;AAUM;AACJ;AAEA;;AAEI;AAMF;AACF;;AAGE;AACA;AAEA;;AAAwBA;AAAQ;;AAEpC;;"}

node_modules/@griffel/react/makeStaticStyles.cjs.js

@@ -0,0 +1,24 @@
+"use client";
+'use strict';
+
+var core = require('@griffel/core');
+var insertionFactory = require('./insertionFactory.cjs.js');
+var RendererContext = require('./RendererContext.cjs.js');
+
+function makeStaticStyles(styles) {
+  const getStyles = core.makeStaticStyles(styles, insertionFactory.insertionFactory);
+  if (process.env.NODE_ENV === 'test') {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    return () => {};
+  }
+  return function useStaticStyles() {
+    const renderer = RendererContext.useRenderer();
+    const options = {
+      renderer
+    };
+    return getStyles(options);
+  };
+}
+
+exports.makeStaticStyles = makeStaticStyles;
+//# sourceMappingURL=makeStaticStyles.cjs.js.map

node_modules/@griffel/react/makeStaticStyles.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeStaticStyles.cjs.js","sources":["../../../packages/react/src/makeStaticStyles.ts"],"sourcesContent":["'use client';\n\nimport { makeStaticStyles as vanillaMakeStaticStyles } from '@griffel/core';\nimport type { GriffelStaticStyles, MakeStaticStylesOptions } from '@griffel/core';\n\nimport { insertionFactory } from './insertionFactory';\nimport { useRenderer } from './RendererContext';\n\nexport function makeStaticStyles(styles: GriffelStaticStyles | GriffelStaticStyles[]) {\n  const getStyles = vanillaMakeStaticStyles(styles, insertionFactory);\n\n  if (process.env.NODE_ENV === 'test') {\n    // eslint-disable-next-line @typescript-eslint/no-empty-function\n    return () => {};\n  }\n\n  return function useStaticStyles(): void {\n    const renderer = useRenderer();\n    const options: MakeStaticStylesOptions = { renderer };\n\n    return getStyles(options);\n  };\n}\n"],"names":["renderer"],"mappings":";;;;;;;AAQM;AACJ;AAEA;AACE;;AAEF;;AAGE;AACA;AAA2CA;;;;AAI/C;;"}

node_modules/@griffel/react/makeStaticStyles.esm.js

@@ -0,0 +1,22 @@
+"use client";
+import { makeStaticStyles as makeStaticStyles$1 } from '@griffel/core';
+import { insertionFactory } from './insertionFactory.esm.js';
+import { useRenderer } from './RendererContext.esm.js';
+
+function makeStaticStyles(styles) {
+  const getStyles = makeStaticStyles$1(styles, insertionFactory);
+  if (process.env.NODE_ENV === 'test') {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    return () => {};
+  }
+  return function useStaticStyles() {
+    const renderer = useRenderer();
+    const options = {
+      renderer
+    };
+    return getStyles(options);
+  };
+}
+
+export { makeStaticStyles };
+//# sourceMappingURL=makeStaticStyles.esm.js.map

node_modules/@griffel/react/makeStaticStyles.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeStaticStyles.esm.js","sources":["../../../packages/react/src/makeStaticStyles.ts"],"sourcesContent":["'use client';\n\nimport { makeStaticStyles as vanillaMakeStaticStyles } from '@griffel/core';\nimport type { GriffelStaticStyles, MakeStaticStylesOptions } from '@griffel/core';\n\nimport { insertionFactory } from './insertionFactory';\nimport { useRenderer } from './RendererContext';\n\nexport function makeStaticStyles(styles: GriffelStaticStyles | GriffelStaticStyles[]) {\n  const getStyles = vanillaMakeStaticStyles(styles, insertionFactory);\n\n  if (process.env.NODE_ENV === 'test') {\n    // eslint-disable-next-line @typescript-eslint/no-empty-function\n    return () => {};\n  }\n\n  return function useStaticStyles(): void {\n    const renderer = useRenderer();\n    const options: MakeStaticStylesOptions = { renderer };\n\n    return getStyles(options);\n  };\n}\n"],"names":["renderer"],"mappings":";;;;;AAQM;AACJ;AAEA;AACE;;AAEF;;AAGE;AACA;AAA2CA;;;;AAI/C;;"}

node_modules/@griffel/react/makeStyles.cjs.js

@@ -0,0 +1,28 @@
+"use client";
+'use strict';
+
+var core = require('@griffel/core');
+var insertionFactory = require('./insertionFactory.cjs.js');
+var RendererContext = require('./RendererContext.cjs.js');
+var TextDirectionContext = require('./TextDirectionContext.cjs.js');
+var isInsideComponent = require('./utils/isInsideComponent.cjs.js');
+
+function makeStyles(stylesBySlots) {
+  const getStyles = core.makeStyles(stylesBySlots, insertionFactory.insertionFactory);
+  if (process.env.NODE_ENV !== 'production') {
+    if (isInsideComponent.isInsideComponent()) {
+      throw new Error(["makeStyles(): this function cannot be called in component's scope.", 'All makeStyles() calls should be top level i.e. in a root scope of a file.'].join(' '));
+    }
+  }
+  return function useClasses() {
+    const dir = TextDirectionContext.useTextDirection();
+    const renderer = RendererContext.useRenderer();
+    return getStyles({
+      dir,
+      renderer
+    });
+  };
+}
+
+exports.makeStyles = makeStyles;
+//# sourceMappingURL=makeStyles.cjs.js.map

node_modules/@griffel/react/makeStyles.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeStyles.cjs.js","sources":["../../../packages/react/src/makeStyles.ts"],"sourcesContent":["'use client';\n\nimport { makeStyles as vanillaMakeStyles } from '@griffel/core';\nimport type { GriffelStyle } from '@griffel/core';\n\nimport { insertionFactory } from './insertionFactory';\nimport { useRenderer } from './RendererContext';\nimport { useTextDirection } from './TextDirectionContext';\nimport { isInsideComponent } from './utils/isInsideComponent';\n\nexport function makeStyles<Slots extends string | number>(stylesBySlots: Record<Slots, GriffelStyle>) {\n  const getStyles = vanillaMakeStyles(stylesBySlots, insertionFactory);\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (isInsideComponent()) {\n      throw new Error(\n        [\n          \"makeStyles(): this function cannot be called in component's scope.\",\n          'All makeStyles() calls should be top level i.e. in a root scope of a file.',\n        ].join(' '),\n      );\n    }\n  }\n\n  return function useClasses(): Record<Slots, string> {\n    const dir = useTextDirection();\n    const renderer = useRenderer();\n\n    return getStyles({ dir, renderer });\n  };\n}\n"],"names":["renderer"],"mappings":";;;;;;;;;AAUM;AACJ;AAEA;;AAEI;AAMF;AACF;;AAGE;AACA;AAEA;;AAAwBA;AAAQ;;AAEpC;;"}

node_modules/@griffel/react/makeStyles.esm.js

@@ -0,0 +1,26 @@
+"use client";
+import { makeStyles as makeStyles$1 } from '@griffel/core';
+import { insertionFactory } from './insertionFactory.esm.js';
+import { useRenderer } from './RendererContext.esm.js';
+import { useTextDirection } from './TextDirectionContext.esm.js';
+import { isInsideComponent } from './utils/isInsideComponent.esm.js';
+
+function makeStyles(stylesBySlots) {
+  const getStyles = makeStyles$1(stylesBySlots, insertionFactory);
+  if (process.env.NODE_ENV !== 'production') {
+    if (isInsideComponent()) {
+      throw new Error(["makeStyles(): this function cannot be called in component's scope.", 'All makeStyles() calls should be top level i.e. in a root scope of a file.'].join(' '));
+    }
+  }
+  return function useClasses() {
+    const dir = useTextDirection();
+    const renderer = useRenderer();
+    return getStyles({
+      dir,
+      renderer
+    });
+  };
+}
+
+export { makeStyles };
+//# sourceMappingURL=makeStyles.esm.js.map

node_modules/@griffel/react/makeStyles.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeStyles.esm.js","sources":["../../../packages/react/src/makeStyles.ts"],"sourcesContent":["'use client';\n\nimport { makeStyles as vanillaMakeStyles } from '@griffel/core';\nimport type { GriffelStyle } from '@griffel/core';\n\nimport { insertionFactory } from './insertionFactory';\nimport { useRenderer } from './RendererContext';\nimport { useTextDirection } from './TextDirectionContext';\nimport { isInsideComponent } from './utils/isInsideComponent';\n\nexport function makeStyles<Slots extends string | number>(stylesBySlots: Record<Slots, GriffelStyle>) {\n  const getStyles = vanillaMakeStyles(stylesBySlots, insertionFactory);\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (isInsideComponent()) {\n      throw new Error(\n        [\n          \"makeStyles(): this function cannot be called in component's scope.\",\n          'All makeStyles() calls should be top level i.e. in a root scope of a file.',\n        ].join(' '),\n      );\n    }\n  }\n\n  return function useClasses(): Record<Slots, string> {\n    const dir = useTextDirection();\n    const renderer = useRenderer();\n\n    return getStyles({ dir, renderer });\n  };\n}\n"],"names":["renderer"],"mappings":";;;;;;;AAUM;AACJ;AAEA;;AAEI;AAMF;AACF;;AAGE;AACA;AAEA;;AAAwBA;AAAQ;;AAEpC;;"}

node_modules/@griffel/react/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@griffel/react",
+  "version": "1.6.1",
+  "description": "React implementation of Atomic CSS-in-JS",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/microsoft/griffel"
+  },
+  "sideEffects": false,
+  "wyw-in-js": {
+    "tags": {
+      "makeStyles": "@griffel/tag-processor/make-styles",
+      "makeResetStyles": "@griffel/tag-processor/make-reset-styles"
+    }
+  },
+  "dependencies": {
+    "@griffel/core": "^1.20.1",
+    "tslib": "^2.1.0"
+  },
+  "peerDependencies": {
+    "react": ">=16.8.0 <20.0.0"
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "types": "./index.d.ts"
+}

node_modules/@griffel/react/renderToStyleElements.cjs.js

@@ -0,0 +1,72 @@
+"use client";
+'use strict';
+
+var core = require('@griffel/core');
+var React = require('react');
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceCompat(React);
+
+/**
+ * This method returns a list of <style> React elements with the rendered CSS. This is useful for Server-Side rendering.
+ *
+ * @public
+ */
+function renderToStyleElements(renderer) {
+  const stylesheets = Object.values(renderer.stylesheets)
+  // first sort: bucket by order [data-priority]
+  .sort((a, b) => {
+    return Number(a.elementAttributes['data-priority']) - Number(b.elementAttributes['data-priority']);
+  })
+  // second sort: bucket by bucket name
+  .sort((a, b) => {
+    return core.styleBucketOrdering.indexOf(a.bucketName) - core.styleBucketOrdering.indexOf(b.bucketName);
+  })
+  // third sort: media queries
+  .sort((a, b) => {
+    const mediaA = a.elementAttributes['media'];
+    const mediaB = b.elementAttributes['media'];
+    if (mediaA && mediaB) {
+      return renderer.compareMediaQueries(mediaA, mediaB);
+    }
+    if (mediaA || mediaB) {
+      return mediaA ? 1 : -1;
+    }
+    return 0;
+  });
+  return stylesheets.map(stylesheet => {
+    const cssRules = stylesheet.cssRules();
+    // don't want to create any empty style elements
+    if (!cssRules.length) {
+      return null;
+    }
+    return /*#__PURE__*/React__namespace.createElement('style', Object.assign({
+      key: stylesheet.bucketName
+    }, stylesheet.elementAttributes, {
+      'data-make-styles-rehydration': 'true',
+      dangerouslySetInnerHTML: {
+        __html: cssRules.join('')
+      }
+    }));
+  }).filter(Boolean);
+}
+
+exports.renderToStyleElements = renderToStyleElements;
+//# sourceMappingURL=renderToStyleElements.cjs.js.map

node_modules/@griffel/react/renderToStyleElements.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderToStyleElements.cjs.js","sources":["../../../packages/react/src/renderToStyleElements.ts"],"sourcesContent":["'use client';\n\nimport { styleBucketOrdering } from '@griffel/core';\nimport * as React from 'react';\nimport type { GriffelRenderer } from '@griffel/core';\n\n/**\n * This method returns a list of <style> React elements with the rendered CSS. This is useful for Server-Side rendering.\n *\n * @public\n */\nexport function renderToStyleElements(renderer: GriffelRenderer): React.ReactElement[] {\n  const stylesheets = Object.values(renderer.stylesheets)\n    // first sort: bucket by order [data-priority]\n    .sort((a, b) => {\n      return Number(a.elementAttributes['data-priority']) - Number(b.elementAttributes['data-priority']);\n    })\n    // second sort: bucket by bucket name\n    .sort((a, b) => {\n      return styleBucketOrdering.indexOf(a.bucketName) - styleBucketOrdering.indexOf(b.bucketName);\n    })\n    // third sort: media queries\n    .sort((a, b) => {\n      const mediaA = a.elementAttributes['media'];\n      const mediaB = b.elementAttributes['media'];\n\n      if (mediaA && mediaB) {\n        return renderer.compareMediaQueries(mediaA, mediaB);\n      }\n\n      if (mediaA || mediaB) {\n        return mediaA ? 1 : -1;\n      }\n\n      return 0;\n    });\n\n  return stylesheets\n    .map(stylesheet => {\n      const cssRules = stylesheet.cssRules();\n      // don't want to create any empty style elements\n      if (!cssRules.length) {\n        return null;\n      }\n\n      return React.createElement('style', {\n        key: stylesheet.bucketName,\n\n        // TODO: support \"nonce\"\n        // ...renderer.styleNodeAttributes,\n        ...stylesheet.elementAttributes,\n        'data-make-styles-rehydration': 'true',\n\n        dangerouslySetInnerHTML: {\n          __html: cssRules.join(''),\n        },\n      });\n    })\n    .filter(Boolean) as React.ReactElement[];\n}\n"],"names":["dangerouslySetInnerHTML","__html"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAMA;;;;AAIG;AACG;;AAEF;AAAA;AAEE;;AAEF;AAAA;AAEE;;AAEF;AAAA;AAEE;AACA;;AAGE;AACF;;AAGE;AACF;AAEA;AACF;AAEF;AAEI;AACA;AACA;AACE;AACF;;;;AAQE;AAEAA;AACEC;AACD;AAAA;AAEL;AAEJ;;"}

node_modules/@griffel/react/renderToStyleElements.esm.js

@@ -0,0 +1,50 @@
+"use client";
+import { styleBucketOrdering } from '@griffel/core';
+import * as React from 'react';
+
+/**
+ * This method returns a list of <style> React elements with the rendered CSS. This is useful for Server-Side rendering.
+ *
+ * @public
+ */
+function renderToStyleElements(renderer) {
+  const stylesheets = Object.values(renderer.stylesheets)
+  // first sort: bucket by order [data-priority]
+  .sort((a, b) => {
+    return Number(a.elementAttributes['data-priority']) - Number(b.elementAttributes['data-priority']);
+  })
+  // second sort: bucket by bucket name
+  .sort((a, b) => {
+    return styleBucketOrdering.indexOf(a.bucketName) - styleBucketOrdering.indexOf(b.bucketName);
+  })
+  // third sort: media queries
+  .sort((a, b) => {
+    const mediaA = a.elementAttributes['media'];
+    const mediaB = b.elementAttributes['media'];
+    if (mediaA && mediaB) {
+      return renderer.compareMediaQueries(mediaA, mediaB);
+    }
+    if (mediaA || mediaB) {
+      return mediaA ? 1 : -1;
+    }
+    return 0;
+  });
+  return stylesheets.map(stylesheet => {
+    const cssRules = stylesheet.cssRules();
+    // don't want to create any empty style elements
+    if (!cssRules.length) {
+      return null;
+    }
+    return /*#__PURE__*/React.createElement('style', Object.assign({
+      key: stylesheet.bucketName
+    }, stylesheet.elementAttributes, {
+      'data-make-styles-rehydration': 'true',
+      dangerouslySetInnerHTML: {
+        __html: cssRules.join('')
+      }
+    }));
+  }).filter(Boolean);
+}
+
+export { renderToStyleElements };
+//# sourceMappingURL=renderToStyleElements.esm.js.map

node_modules/@griffel/react/renderToStyleElements.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderToStyleElements.esm.js","sources":["../../../packages/react/src/renderToStyleElements.ts"],"sourcesContent":["'use client';\n\nimport { styleBucketOrdering } from '@griffel/core';\nimport * as React from 'react';\nimport type { GriffelRenderer } from '@griffel/core';\n\n/**\n * This method returns a list of <style> React elements with the rendered CSS. This is useful for Server-Side rendering.\n *\n * @public\n */\nexport function renderToStyleElements(renderer: GriffelRenderer): React.ReactElement[] {\n  const stylesheets = Object.values(renderer.stylesheets)\n    // first sort: bucket by order [data-priority]\n    .sort((a, b) => {\n      return Number(a.elementAttributes['data-priority']) - Number(b.elementAttributes['data-priority']);\n    })\n    // second sort: bucket by bucket name\n    .sort((a, b) => {\n      return styleBucketOrdering.indexOf(a.bucketName) - styleBucketOrdering.indexOf(b.bucketName);\n    })\n    // third sort: media queries\n    .sort((a, b) => {\n      const mediaA = a.elementAttributes['media'];\n      const mediaB = b.elementAttributes['media'];\n\n      if (mediaA && mediaB) {\n        return renderer.compareMediaQueries(mediaA, mediaB);\n      }\n\n      if (mediaA || mediaB) {\n        return mediaA ? 1 : -1;\n      }\n\n      return 0;\n    });\n\n  return stylesheets\n    .map(stylesheet => {\n      const cssRules = stylesheet.cssRules();\n      // don't want to create any empty style elements\n      if (!cssRules.length) {\n        return null;\n      }\n\n      return React.createElement('style', {\n        key: stylesheet.bucketName,\n\n        // TODO: support \"nonce\"\n        // ...renderer.styleNodeAttributes,\n        ...stylesheet.elementAttributes,\n        'data-make-styles-rehydration': 'true',\n\n        dangerouslySetInnerHTML: {\n          __html: cssRules.join(''),\n        },\n      });\n    })\n    .filter(Boolean) as React.ReactElement[];\n}\n"],"names":["dangerouslySetInnerHTML","__html"],"mappings":";;;;AAMA;;;;AAIG;AACG;;AAEF;AAAA;AAEE;;AAEF;AAAA;AAEE;;AAEF;AAAA;AAEE;AACA;;AAGE;AACF;;AAGE;AACF;AAEA;AACF;AAEF;AAEI;AACA;AACA;AACE;AACF;;;;AAQE;AAEAA;AACEC;AACD;AAAA;AAEL;AAEJ;;"}

node_modules/@griffel/react/src/RendererContext.d.ts

@@ -0,0 +1,24 @@
+import type { GriffelRenderer } from '@griffel/core';
+import * as React from 'react';
+export interface RendererProviderProps {
+    /** An instance of Griffel renderer. */
+    renderer: GriffelRenderer;
+    /**
+     * Document used to insert CSS variables to head
+     */
+    targetDocument?: Document;
+    /**
+     * Content wrapped by the RendererProvider
+     */
+    children: React.ReactNode;
+}
+/**
+ * @public
+ */
+export declare const RendererProvider: React.FC<RendererProviderProps>;
+/**
+ * Returns an instance of current makeStyles() renderer.
+ *
+ * @private Exported as "useRenderer_unstable" use it on own risk. Can be changed or removed without a notice.
+ */
+export declare function useRenderer(): GriffelRenderer;

node_modules/@griffel/react/src/TextDirectionContext.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+export interface TextDirectionProviderProps {
+    /** Indicates the directionality of the element's text. */
+    dir: 'ltr' | 'rtl';
+    /**
+     * Content wrapped by the TextDirectionProvider.
+     */
+    children: React.ReactNode;
+}
+/**
+ * @public
+ */
+export declare const TextDirectionProvider: React.FC<TextDirectionProviderProps>;
+/**
+ * Returns current directionality of the element's text.
+ *
+ * @private
+ */
+export declare function useTextDirection(): "ltr" | "rtl";

node_modules/@griffel/react/src/__css.d.ts

@@ -0,0 +1,7 @@
+import type { CSSClassesMapBySlot } from '@griffel/core';
+/**
+ * A version of makeStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.
+ *
+ * @internal
+ */
+export declare function __css<Slots extends string>(classesMapBySlot: CSSClassesMapBySlot<Slots>): () => Record<Slots, string>;

node_modules/@griffel/react/src/__resetCSS.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A version of makeResetStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.
+ *
+ * @internal
+ */
+export declare function __resetCSS(ltrClassName: string, rtlClassName: string | null): () => string;

node_modules/@griffel/react/src/__resetStyles.d.ts

@@ -0,0 +1,7 @@
+import type { CSSRulesByBucket } from '@griffel/core';
+/**
+ * A version of makeResetStyles() that accepts build output as an input and skips all runtime transforms.
+ *
+ * @internal
+ */
+export declare function __resetStyles(ltrClassName: string, rtlClassName: string | null, cssRules: CSSRulesByBucket | string[]): () => string;

node_modules/@griffel/react/src/__staticCSS.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A version of makeStaticStyles() that accepts build output as an input and skips all runtime transforms & DOM insertion.
+ *
+ * @internal
+ */
+export declare function __staticCSS(): () => void;

node_modules/@griffel/react/src/__staticStyles.d.ts

@@ -0,0 +1,7 @@
+import type { CSSRulesByBucket } from '@griffel/core';
+/**
+ * A version of makeStaticStyles() that accepts build output as an input and skips all runtime transforms.
+ *
+ * @internal
+ */
+export declare function __staticStyles(cssRules: CSSRulesByBucket): () => void;

node_modules/@griffel/react/src/__styles.d.ts

@@ -0,0 +1,7 @@
+import type { CSSClassesMapBySlot, CSSRulesByBucket } from '@griffel/core';
+/**
+ * A version of makeStyles() that accepts build output as an input and skips all runtime transforms.
+ *
+ * @internal
+ */
+export declare function __styles<Slots extends string>(classesMapBySlot: CSSClassesMapBySlot<Slots>, cssRules: CSSRulesByBucket): () => Record<Slots, string>;

node_modules/@griffel/react/src/index.d.ts

@@ -0,0 +1,14 @@
+export { RESET, shorthands, mergeClasses, createDOMRenderer } from '@griffel/core';
+export type { GriffelStyle, GriffelResetStyle, CreateDOMRendererOptions, GriffelRenderer } from '@griffel/core';
+export { makeStyles } from './makeStyles';
+export { makeResetStyles } from './makeResetStyles';
+export { makeStaticStyles } from './makeStaticStyles';
+export { renderToStyleElements } from './renderToStyleElements';
+export { RendererProvider, useRenderer as useRenderer_unstable } from './RendererContext';
+export { TextDirectionProvider } from './TextDirectionContext';
+export { __css } from './__css';
+export { __styles } from './__styles';
+export { __resetCSS } from './__resetCSS';
+export { __resetStyles } from './__resetStyles';
+export { __staticCSS } from './__staticCSS';
+export { __staticStyles } from './__staticStyles';

node_modules/@griffel/react/src/insertionFactory.d.ts

@@ -0,0 +1,2 @@
+import type { GriffelInsertionFactory } from '@griffel/core';
+export declare const insertionFactory: GriffelInsertionFactory;

node_modules/@griffel/react/src/makeResetStyles.d.ts

@@ -0,0 +1,2 @@
+import type { GriffelResetStyle } from '@griffel/core';
+export declare function makeResetStyles(styles: GriffelResetStyle): () => string;

node_modules/@griffel/react/src/makeStaticStyles.d.ts

@@ -0,0 +1,2 @@
+import type { GriffelStaticStyles } from '@griffel/core';
+export declare function makeStaticStyles(styles: GriffelStaticStyles | GriffelStaticStyles[]): () => void;

node_modules/@griffel/react/src/makeStyles.d.ts

@@ -0,0 +1,2 @@
+import type { GriffelStyle } from '@griffel/core';
+export declare function makeStyles<Slots extends string | number>(stylesBySlots: Record<Slots, GriffelStyle>): () => Record<Slots, string>;

node_modules/@griffel/react/src/renderToStyleElements.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import type { GriffelRenderer } from '@griffel/core';
+/**
+ * This method returns a list of <style> React elements with the rendered CSS. This is useful for Server-Side rendering.
+ *
+ * @public
+ */
+export declare function renderToStyleElements(renderer: GriffelRenderer): React.ReactElement[];

node_modules/@griffel/react/src/useInsertionEffect.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare const useInsertionEffect: typeof React.useInsertionEffect | undefined;

node_modules/@griffel/react/src/utils/canUseDOM.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Verifies if an application can use DOM.
+ */
+export declare function canUseDOM(): boolean;

node_modules/@griffel/react/src/utils/isInsideComponent.d.ts

@@ -0,0 +1 @@
+export declare function isInsideComponent(): boolean;

node_modules/@griffel/react/useInsertionEffect.cjs.js

@@ -0,0 +1,32 @@
+"use client";
+'use strict';
+
+var React = require('react');
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceCompat(React);
+
+const useInsertionEffect =
+// @ts-expect-error Hack to make sure that `useInsertionEffect` will not cause bundling issues in older React versions
+// eslint-disable-next-line no-useless-concat
+React__namespace['useInsertion' + 'Effect'] ? React__namespace['useInsertion' + 'Effect'] : undefined;
+
+exports.useInsertionEffect = useInsertionEffect;
+//# sourceMappingURL=useInsertionEffect.cjs.js.map

node_modules/@griffel/react/useInsertionEffect.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInsertionEffect.cjs.js","sources":["../../../packages/react/src/useInsertionEffect.ts"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\n\nexport const useInsertionEffect: typeof React.useInsertionEffect | undefined =\n  // @ts-expect-error Hack to make sure that `useInsertionEffect` will not cause bundling issues in older React versions\n  // eslint-disable-next-line no-useless-concat\n  React['useInsertion' + 'Effect'] ? React['useInsertion' + 'Effect'] : undefined;\n"],"names":["React"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAKE;AACA;AACAA;;"}

node_modules/@griffel/react/useInsertionEffect.esm.js

@@ -0,0 +1,10 @@
+"use client";
+import * as React from 'react';
+
+const useInsertionEffect =
+// @ts-expect-error Hack to make sure that `useInsertionEffect` will not cause bundling issues in older React versions
+// eslint-disable-next-line no-useless-concat
+React['useInsertion' + 'Effect'] ? React['useInsertion' + 'Effect'] : undefined;
+
+export { useInsertionEffect };
+//# sourceMappingURL=useInsertionEffect.esm.js.map

node_modules/@griffel/react/useInsertionEffect.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInsertionEffect.esm.js","sources":["../../../packages/react/src/useInsertionEffect.ts"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\n\nexport const useInsertionEffect: typeof React.useInsertionEffect | undefined =\n  // @ts-expect-error Hack to make sure that `useInsertionEffect` will not cause bundling issues in older React versions\n  // eslint-disable-next-line no-useless-concat\n  React['useInsertion' + 'Effect'] ? React['useInsertion' + 'Effect'] : undefined;\n"],"names":["React"],"mappings":";;;;AAKE;AACA;AACAA;;"}

node_modules/@griffel/react/utils/canUseDOM.cjs.js

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * Verifies if an application can use DOM.
+ */
+function canUseDOM() {
+  return typeof window !== 'undefined' && !!(window.document && window.document.createElement);
+}
+
+exports.canUseDOM = canUseDOM;
+//# sourceMappingURL=canUseDOM.cjs.js.map

node_modules/@griffel/react/utils/canUseDOM.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canUseDOM.cjs.js","sources":["../../../../packages/react/src/utils/canUseDOM.ts"],"sourcesContent":["/**\n * Verifies if an application can use DOM.\n */\nexport function canUseDOM(): boolean {\n  return typeof window !== 'undefined' && !!(window.document && window.document.createElement);\n}\n"],"names":["canUseDOM","window","document","createElement"],"mappings":";;AAAA;;AAEG;SACaA,SAASA,GAAA;AACvB,EAAA,OAAO,OAAOC,MAAM,KAAK,WAAW,IAAI,CAAC,EAAEA,MAAM,CAACC,QAAQ,IAAID,MAAM,CAACC,QAAQ,CAACC,aAAa,CAAC;AAC9F;;;;"}

node_modules/@griffel/react/utils/canUseDOM.esm.js

@@ -0,0 +1,9 @@
+/**
+ * Verifies if an application can use DOM.
+ */
+function canUseDOM() {
+  return typeof window !== 'undefined' && !!(window.document && window.document.createElement);
+}
+
+export { canUseDOM };
+//# sourceMappingURL=canUseDOM.esm.js.map

node_modules/@griffel/react/utils/canUseDOM.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canUseDOM.esm.js","sources":["../../../../packages/react/src/utils/canUseDOM.ts"],"sourcesContent":["/**\n * Verifies if an application can use DOM.\n */\nexport function canUseDOM(): boolean {\n  return typeof window !== 'undefined' && !!(window.document && window.document.createElement);\n}\n"],"names":["canUseDOM","window","document","createElement"],"mappings":"AAAA;;AAEG;SACaA,SAASA,GAAA;AACvB,EAAA,OAAO,OAAOC,MAAM,KAAK,WAAW,IAAI,CAAC,EAAEA,MAAM,CAACC,QAAQ,IAAID,MAAM,CAACC,QAAQ,CAACC,aAAa,CAAC;AAC9F;;;;"}

node_modules/@griffel/react/utils/isInsideComponent.cjs.js

@@ -0,0 +1,57 @@
+"use client";
+'use strict';
+
+var React = require('react');
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceCompat(React);
+
+function getDispatcher() {
+  try {
+    return React__namespace[''.concat('__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE')].H;
+  } catch (_unused) {
+    // React 19+
+  }
+  try {
+    return React__namespace[''.concat('__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED')].ReactCurrentDispatcher.current;
+  } catch (_unused2) {
+    // React 18 and below
+  }
+}
+function isInsideComponent() {
+  // React 18 always logs errors if a dispatcher is not present:
+  // https://github.com/facebook/react/blob/42f15b324f50d0fd98322c21646ac3013e30344a/packages/react/src/ReactHooks.js#L26-L36
+  try {
+    const dispatcher = getDispatcher();
+    // Before any React component was rendered "dispatcher" will be "null"
+    if (dispatcher === null || dispatcher === undefined) {
+      return false;
+    }
+    // A check with hooks call (i.e. call "React.useContext()" outside a component) will always produce errors, but
+    // a call on the dispatcher wont
+    dispatcher.useContext({});
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+exports.isInsideComponent = isInsideComponent;
+//# sourceMappingURL=isInsideComponent.cjs.js.map

node_modules/@griffel/react/utils/isInsideComponent.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isInsideComponent.cjs.js","sources":["../../../../packages/react/src/utils/isInsideComponent.ts"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\n\nfunction getDispatcher() {\n  try {\n    return (React as any)[''.concat('__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE')].H;\n  } catch {\n    // React 19+\n  }\n\n  try {\n    return (React as any)[''.concat('__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED')].ReactCurrentDispatcher\n      .current;\n  } catch {\n    // React 18 and below\n  }\n}\n\nexport function isInsideComponent() {\n  // React 18 always logs errors if a dispatcher is not present:\n  // https://github.com/facebook/react/blob/42f15b324f50d0fd98322c21646ac3013e30344a/packages/react/src/ReactHooks.js#L26-L36\n  try {\n    const dispatcher = getDispatcher();\n\n    // Before any React component was rendered \"dispatcher\" will be \"null\"\n    if (dispatcher === null || dispatcher === undefined) {\n      return false;\n    }\n\n    // A check with hooks call (i.e. call \"React.useContext()\" outside a component) will always produce errors, but\n    // a call on the dispatcher wont\n    dispatcher.useContext({});\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n"],"names":["dispatcher"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAIA;;;;AAII;AAAA;;AAIA;;AAGA;AAAA;AAEJ;;AAGE;AACA;;AAEE;AAEA;AACA;AACE;AACF;AAEA;AACA;AACAA;AACA;;AAEA;AACF;AACF;;"}

node_modules/@griffel/react/utils/isInsideComponent.esm.js

@@ -0,0 +1,35 @@
+"use client";
+import * as React from 'react';
+
+function getDispatcher() {
+  try {
+    return React[''.concat('__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE')].H;
+  } catch (_unused) {
+    // React 19+
+  }
+  try {
+    return React[''.concat('__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED')].ReactCurrentDispatcher.current;
+  } catch (_unused2) {
+    // React 18 and below
+  }
+}
+function isInsideComponent() {
+  // React 18 always logs errors if a dispatcher is not present:
+  // https://github.com/facebook/react/blob/42f15b324f50d0fd98322c21646ac3013e30344a/packages/react/src/ReactHooks.js#L26-L36
+  try {
+    const dispatcher = getDispatcher();
+    // Before any React component was rendered "dispatcher" will be "null"
+    if (dispatcher === null || dispatcher === undefined) {
+      return false;
+    }
+    // A check with hooks call (i.e. call "React.useContext()" outside a component) will always produce errors, but
+    // a call on the dispatcher wont
+    dispatcher.useContext({});
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+export { isInsideComponent };
+//# sourceMappingURL=isInsideComponent.esm.js.map

node_modules/@griffel/react/utils/isInsideComponent.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isInsideComponent.esm.js","sources":["../../../../packages/react/src/utils/isInsideComponent.ts"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\n\nfunction getDispatcher() {\n  try {\n    return (React as any)[''.concat('__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE')].H;\n  } catch {\n    // React 19+\n  }\n\n  try {\n    return (React as any)[''.concat('__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED')].ReactCurrentDispatcher\n      .current;\n  } catch {\n    // React 18 and below\n  }\n}\n\nexport function isInsideComponent() {\n  // React 18 always logs errors if a dispatcher is not present:\n  // https://github.com/facebook/react/blob/42f15b324f50d0fd98322c21646ac3013e30344a/packages/react/src/ReactHooks.js#L26-L36\n  try {\n    const dispatcher = getDispatcher();\n\n    // Before any React component was rendered \"dispatcher\" will be \"null\"\n    if (dispatcher === null || dispatcher === undefined) {\n      return false;\n    }\n\n    // A check with hooks call (i.e. call \"React.useContext()\" outside a component) will always produce errors, but\n    // a call on the dispatcher wont\n    dispatcher.useContext({});\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n"],"names":["dispatcher"],"mappings":";;;AAIA;;;;AAII;AAAA;;AAIA;;AAGA;AAAA;AAEJ;;AAGE;AACA;;AAEE;AAEA;AACA;AACE;AACF;AAEA;AACA;AACAA;AACA;;AAEA;AACF;AACF;;"}