feat: Fluent UI Outlook Lite + connections mockup

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

@@ -0,0 +1,8 @@
+import type { MakeStylesOptions } from './makeStyles';
+import type { CSSClassesMapBySlot } from './types';
+/**
+ * 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>): (options: Pick<MakeStylesOptions, "dir">) => Record<Slots, string>;

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

@@ -0,0 +1,5 @@
+import type { MakeResetStylesOptions } from './makeResetStyles';
+/**
+ * @internal
+ */
+export declare function __resetCSS(ltrClassName: string, rtlClassName: string | null): (options: Pick<MakeResetStylesOptions, "dir">) => string;

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

@@ -0,0 +1,6 @@
+import type { MakeResetStylesOptions } from './makeResetStyles';
+import type { CSSRulesByBucket, GriffelInsertionFactory } from './types';
+/**
+ * @internal
+ */
+export declare function __resetStyles(ltrClassName: string, rtlClassName: string | null, cssRules: CSSRulesByBucket | string[], factory?: GriffelInsertionFactory): (options: MakeResetStylesOptions) => string;

node_modules/@griffel/core/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/core/src/__staticStyles.d.ts

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

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

@@ -0,0 +1,8 @@
+import type { CSSClassesMapBySlot, CSSRulesByBucket, GriffelInsertionFactory } from './types';
+import type { MakeStylesOptions } from './makeStyles';
+/**
+ * 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, factory?: GriffelInsertionFactory): (options: Pick<MakeStylesOptions, "dir" | "renderer">) => Record<Slots, string>;

node_modules/@griffel/core/src/common/snapshotSerializers.d.ts

@@ -0,0 +1,3 @@
+export declare const griffelRendererSerializer: jest.SnapshotSerializerPlugin;
+export declare const griffelRulesSerializer: jest.SnapshotSerializerPlugin;
+export declare const griffelResetRulesSerializer: jest.SnapshotSerializerPlugin;

node_modules/@griffel/core/src/constants.d.ts

@@ -0,0 +1,36 @@
+import type { GriffelStylesUnsupportedCSSProperties } from '@griffel/style-types';
+import type { LookupItem } from './types';
+/** @internal */
+export declare const DEBUG_RESET_CLASSES: Record<string, 1>;
+/** @internal */
+export declare const DEFINITION_LOOKUP_TABLE: Record<string, LookupItem>;
+/** @internal */
+export declare const DATA_BUCKET_ATTR = "data-make-styles-bucket";
+/** @internal */
+export declare const DATA_PRIORITY_ATTR = "data-priority";
+/** @internal */
+export declare const HASH_PREFIX = "f";
+/** @internal */
+export declare const RESET_HASH_PREFIX = "r";
+/** @internal */
+export declare const SEQUENCE_HASH_LENGTH = 7;
+/** @internal */
+export declare const SEQUENCE_PREFIX = "___";
+/** @internal */
+export declare const DEBUG_SEQUENCE_SEPARATOR = "_";
+/** @internal */
+export declare const SEQUENCE_SIZE: number;
+/** @internal */
+export declare const LOOKUP_DEFINITIONS_INDEX = 0;
+/** @internal */
+export declare const LOOKUP_DIR_INDEX = 1;
+/** @internal */
+export declare const UNSUPPORTED_CSS_PROPERTIES: Record<keyof GriffelStylesUnsupportedCSSProperties, 1>;
+/**
+ * Removes a CSS property from the style object.
+ *
+ * @link https://griffel.js.org/react/api/make-styles
+ *
+ * Do not use the value directly, use `RESET` constant instead.
+ */
+export declare const RESET: "unset";

node_modules/@griffel/core/src/devtools/getAtomicDebugSequenceTree.d.ts

@@ -0,0 +1,3 @@
+import type { SequenceHash } from '../types';
+import type { DebugSequence } from './types';
+export declare function getAtomicDebugSequenceTree(debugSequenceHash: SequenceHash, parentNode?: DebugSequence): DebugSequence | undefined;

node_modules/@griffel/core/src/devtools/getResetDebugSequence.d.ts

@@ -0,0 +1,3 @@
+import type { SequenceHash } from '../types';
+import type { DebugSequence } from './types';
+export declare function getResetDebugSequence(debugSequenceHash: SequenceHash): DebugSequence | undefined;

node_modules/@griffel/core/src/devtools/getSourceURLfromError.d.ts

@@ -0,0 +1 @@
+export declare function getSourceURLfromError(): string | undefined;

node_modules/@griffel/core/src/devtools/index.d.ts

@@ -0,0 +1,5 @@
+export { injectDevTools } from './injectDevTools';
+export { isDevToolsEnabled } from './isDevToolsEnabled';
+export { debugData } from './store';
+export { getSourceURLfromError } from './getSourceURLfromError';
+export type { DebugCSSRules, DebugSequence, DebugResult } from './types';

node_modules/@griffel/core/src/devtools/injectDevTools.d.ts

@@ -0,0 +1 @@
+export declare function injectDevTools(document: Document): void;

node_modules/@griffel/core/src/devtools/isDevToolsEnabled.d.ts

@@ -0,0 +1 @@
+export declare const isDevToolsEnabled: boolean;

node_modules/@griffel/core/src/devtools/mergeDebugSequence.d.ts

@@ -0,0 +1,2 @@
+import type { DebugSequence } from './types';
+export declare function mergeDebugSequence(atomicClases: string | undefined, resetClassName: string | undefined): DebugSequence | undefined;

node_modules/@griffel/core/src/devtools/react-render-tracker/stackTrace.d.ts

@@ -0,0 +1,6 @@
+type LineParseResult = null | {
+    name: string;
+    loc: string | null;
+};
+export declare function parseStackTraceLine(line: string): LineParseResult;
+export {};

node_modules/@griffel/core/src/devtools/store.d.ts

@@ -0,0 +1,13 @@
+import type { SequenceHash } from '../types';
+declare const sequenceDetails: Record<SequenceHash, {
+    slotName: string;
+    sourceURL?: string;
+}>;
+export declare const debugData: {
+    getChildrenSequences: (debugSequenceHash: SequenceHash) => SequenceHash[];
+    addCSSRule: (rule: string) => void;
+    addSequenceDetails: <Slots extends string | number>(classNamesForSlots: Record<Slots, string>, sourceURL?: string) => void;
+    getCSSRules: () => string[];
+    getSequenceDetails: (sequenceHash: SequenceHash) => (typeof sequenceDetails)[string] | undefined;
+};
+export {};

node_modules/@griffel/core/src/devtools/types.d.ts

@@ -0,0 +1,23 @@
+import type { SequenceHash } from '../types';
+declare global {
+    interface Window {
+        __GRIFFEL_DEVTOOLS__: {
+            getInfo: (el: HTMLElement) => DebugResult | undefined;
+        };
+    }
+}
+export type DebugAtomicClassName = {
+    className: string;
+    overriddenBy?: string;
+};
+export type DebugCSSRules = Record<string, string>;
+export type DebugSequence = {
+    sequenceHash: SequenceHash;
+    direction: 'ltr' | 'rtl';
+    children: DebugSequence[];
+    debugClassNames: DebugAtomicClassName[];
+    slot?: string;
+    rules?: DebugCSSRules;
+    sourceURL?: string;
+};
+export type DebugResult = DebugSequence;

node_modules/@griffel/core/src/devtools/utils.d.ts

@@ -0,0 +1,3 @@
+import type { LookupItem } from '../types';
+import type { DebugAtomicClassName, DebugSequence } from './types';
+export declare function getDebugClassNames(lookupItem: LookupItem, parentLookupItem?: LookupItem, parentDebugClassNames?: DebugAtomicClassName[], overridingSiblings?: DebugSequence[]): DebugAtomicClassName[];

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

@@ -0,0 +1,55 @@
+import { border, borderLeft, borderBottom, borderRight, borderTop, borderColor, borderStyle, borderRadius, borderWidth, flex, gap, gridArea, margin, marginBlock, marginInline, padding, paddingBlock, paddingInline, overflow, inset, outline, transition, textDecoration } from './shorthands';
+export declare const shorthands: {
+    border: typeof border;
+    borderLeft: typeof borderLeft;
+    borderBottom: typeof borderBottom;
+    borderRight: typeof borderRight;
+    borderTop: typeof borderTop;
+    borderColor: typeof borderColor;
+    borderStyle: typeof borderStyle;
+    borderRadius: typeof borderRadius;
+    borderWidth: typeof borderWidth;
+    flex: typeof flex;
+    gap: typeof gap;
+    gridArea: typeof gridArea;
+    margin: typeof margin;
+    marginBlock: typeof marginBlock;
+    marginInline: typeof marginInline;
+    padding: typeof padding;
+    paddingBlock: typeof paddingBlock;
+    paddingInline: typeof paddingInline;
+    overflow: typeof overflow;
+    inset: typeof inset;
+    outline: typeof outline;
+    transition: typeof transition;
+    textDecoration: typeof textDecoration;
+};
+export { createDOMRenderer } from './renderer/createDOMRenderer';
+export type { CreateDOMRendererOptions } from './renderer/createDOMRenderer';
+export { rehydrateRendererCache } from './renderer/rehydrateRendererCache';
+export { safeInsertRule } from './renderer/safeInsertRule';
+export { mergeClasses } from './mergeClasses';
+export { makeStyles } from './makeStyles';
+export type { MakeStylesOptions } from './makeStyles';
+export { makeStaticStyles } from './makeStaticStyles';
+export type { MakeStaticStylesOptions } from './makeStaticStyles';
+export { makeResetStyles } from './makeResetStyles';
+export { resolveStyleRulesForSlots } from './resolveStyleRulesForSlots';
+export { __css } from './__css';
+export { __styles } from './__styles';
+export { __resetCSS } from './__resetCSS';
+export { __resetStyles } from './__resetStyles';
+export { __staticCSS } from './__staticCSS';
+export { __staticStyles } from './__staticStyles';
+export { normalizeCSSBucketEntry } from './runtime/utils/normalizeCSSBucketEntry';
+export { styleBucketOrdering, getStyleSheetKey } from './renderer/getStyleSheetForBucket';
+export { defaultCompareMediaQueries } from './renderer/createDOMRenderer';
+export { getStyleBucketName } from './runtime/getStyleBucketName';
+export { reduceToClassNameForSlots } from './runtime/reduceToClassNameForSlots';
+export { resolveStyleRules } from './runtime/resolveStyleRules';
+export { resolveResetStyleRules } from './runtime/resolveResetStyleRules';
+export { resolveStaticStyleRules } from './runtime/resolveStaticStyleRules';
+export * from './constants';
+export type { GriffelStaticStyle, GriffelStaticStyles, GriffelAnimation, GriffelStyle, GriffelResetStyle, } from '@griffel/style-types';
+export type { CSSClasses, CSSClassesMapBySlot, CSSBucketEntry, CSSRulesByBucket, StyleBucketName, GriffelRenderer, GriffelInsertionFactory, } from './types';
+export type { DebugCSSRules, DebugSequence, DebugResult } from './devtools';

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

@@ -0,0 +1,8 @@
+import type { GriffelInsertionFactory } from './types';
+/**
+ * Default implementation of insertion factory. Inserts styles only once per renderer and performs
+ * insertion immediately after styles computation.
+ *
+ * @internal
+ */
+export declare const insertionFactory: GriffelInsertionFactory;

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

@@ -0,0 +1,7 @@
+import type { GriffelResetStyle } from '@griffel/style-types';
+import type { GriffelRenderer, GriffelInsertionFactory } from './types';
+export interface MakeResetStylesOptions {
+    dir: 'ltr' | 'rtl';
+    renderer: GriffelRenderer;
+}
+export declare function makeResetStyles(styles: GriffelResetStyle, factory?: GriffelInsertionFactory): (options: MakeResetStylesOptions) => string;

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

@@ -0,0 +1,7 @@
+import type { GriffelStaticStyles } from '@griffel/style-types';
+import type { GriffelRenderer } from './types';
+import type { GriffelInsertionFactory } from './types';
+export interface MakeStaticStylesOptions {
+    renderer: GriffelRenderer;
+}
+export declare function makeStaticStyles(styles: GriffelStaticStyles | GriffelStaticStyles[], factory?: GriffelInsertionFactory): (options: MakeStaticStylesOptions) => void;

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

@@ -0,0 +1,7 @@
+import type { GriffelRenderer, StylesBySlots } from './types';
+import type { GriffelInsertionFactory } from './types';
+export interface MakeStylesOptions {
+    dir: 'ltr' | 'rtl';
+    renderer: GriffelRenderer;
+}
+export declare function makeStyles<Slots extends string | number>(stylesBySlots: StylesBySlots<Slots>, factory?: GriffelInsertionFactory): (options: MakeStylesOptions) => Record<Slots, string>;

node_modules/@griffel/core/src/mergeClasses.d.ts

@@ -0,0 +1,19 @@
+export declare const mergeClassesCachedResults: Record<string, string>;
+/**
+ * Function can take any number of arguments, joins classes together and deduplicates atomic declarations generated by
+ * `makeStyles()`. Handles scoped directional styles.
+ *
+ * Classnames can be of any length, this function can take both atomic declarations and class names.
+ *
+ * Input:
+ * ```
+ * // not real classes
+ * mergeClasses('ui-button', 'displayflex', 'displaygrid')
+ * ```
+ *
+ * Output:
+ * ```
+ * 'ui-button displaygrid'
+ * ```
+ */
+export declare function mergeClasses(...classNames: (string | false | undefined)[]): string;

node_modules/@griffel/core/src/renderer/createDOMRenderer.d.ts

@@ -0,0 +1,43 @@
+import type { GriffelRenderer } from '../types';
+export interface CreateDOMRendererOptions {
+    /**
+     * A salt that will be added for hashed classes. Should be the same for all renderers in the same application
+     * (bundle).
+     *
+     * @see https://github.com/microsoft/griffel/issues/453
+     */
+    classNameHashSalt?: string;
+    /**
+     * If specified, a renderer will insert created style tags after this element.
+     */
+    insertionPoint?: HTMLElement;
+    /**
+     * A map of attributes that's passed to the generated style elements. Is useful to set "nonce" attribute.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/nonce
+     */
+    styleElementAttributes?: Record<string, string>;
+    /**
+     * A filter run before CSS rule insertion to systematically remove CSS rules at render time.
+     * This can be used to forbid specific rules from being written to the style sheet at run time without
+     * affecting build time styles.
+     *
+     * ⚠️ Keep the filter as performant as possible to avoid negative performance impacts to your application.
+     * ⚠️ This API is unstable and can be removed from the library at any time.
+     */
+    unstable_filterCSSRule?: (cssRule: string) => boolean;
+    /**
+     * @param a - media query
+     * @param b - media query
+     * @returns positive number if a > b or negative number if a < b
+     */
+    compareMediaQueries?: (a: string, b: string) => number;
+}
+/** @internal */
+export declare const defaultCompareMediaQueries: (a: string, b: string) => 0 | 1 | -1;
+/**
+ * Creates a new instances of a renderer.
+ *
+ * @public
+ */
+export declare function createDOMRenderer(targetDocument?: Document | undefined, options?: CreateDOMRendererOptions): GriffelRenderer;

node_modules/@griffel/core/src/renderer/createIsomorphicStyleSheet.d.ts

@@ -0,0 +1,3 @@
+import type { IsomorphicStyleSheet, StyleBucketName } from '../types';
+export declare function createIsomorphicStyleSheet(styleElement: HTMLStyleElement | undefined, bucketName: StyleBucketName, priority: number, elementAttributes: Record<string, string>): IsomorphicStyleSheet;
+export declare function createIsomorphicStyleSheetFromElement(element: HTMLStyleElement): IsomorphicStyleSheet;

node_modules/@griffel/core/src/renderer/getStyleSheetForBucket.d.ts

@@ -0,0 +1,13 @@
+import type { GriffelRenderer, IsomorphicStyleSheet, StyleBucketName } from '../types';
+/**
+ * Ordered style buckets using their short pseudo name.
+ *
+ * @internal
+ */
+export declare const styleBucketOrdering: StyleBucketName[];
+export declare function getStyleSheetKey(bucketName: StyleBucketName, media: string, priority: number | string): string;
+export declare function getStyleSheetKeyFromElement(styleEl: HTMLStyleElement): string;
+/**
+ * Lazily adds a `<style>` bucket to the `<head>`. This will ensure that the style buckets are ordered.
+ */
+export declare function getStyleSheetForBucket(bucketName: StyleBucketName, targetDocument: Document | undefined, insertionPoint: HTMLElement | null, renderer: GriffelRenderer, metadata?: Record<string, unknown>): IsomorphicStyleSheet;

node_modules/@griffel/core/src/renderer/rehydrateRendererCache.d.ts

@@ -0,0 +1,8 @@
+import type { GriffelRenderer } from '../types';
+/**
+ * Should be called in a case of Server-Side rendering. Rehydrates cache from for a renderer to avoid double insertion
+ * of classes to DOM.
+ *
+ * @public
+ */
+export declare function rehydrateRendererCache(renderer: GriffelRenderer, target?: Document | undefined): void;

node_modules/@griffel/core/src/renderer/safeInsertRule.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ *
+ * Calls `sheet.insertRule` and catches errors related to browser prefixes.
+ */
+export declare function safeInsertRule(sheet: {
+    insertRule(rule: string): number | undefined;
+}, ruleCSS: string): void;

node_modules/@griffel/core/src/resolveStyleRulesForSlots.d.ts

@@ -0,0 +1,10 @@
+import type { CSSClassesMapBySlot, CSSRulesByBucket, StylesBySlots } from './types';
+/**
+ * Calls resolveStyleRules() for each slot, is also used by build time transform.
+ *
+ * @param stylesBySlots - An object with makeStyles rules where a key is a slot name
+ * @param classNameHashSalt - A salt for classes hash
+ *
+ * @return - A tuple with an object classnames mapping where a key is a slot name and an array with CSS rules
+ */
+export declare function resolveStyleRulesForSlots<Slots extends string | number>(stylesBySlots: StylesBySlots<Slots>, classNameHashSalt?: string): [CSSClassesMapBySlot<Slots>, CSSRulesByBucket];

node_modules/@griffel/core/src/runtime/compileAtomicCSSRule.d.ts

@@ -0,0 +1,21 @@
+import type { AtRules } from './utils/types';
+export interface CompileAtomicCSSOptions {
+    className: string;
+    selectors: string[];
+    property: string;
+    value: number | string | Array<number | string>;
+    rtlClassName?: string;
+    rtlProperty?: string;
+    rtlValue?: number | string | Array<number | string>;
+}
+/**
+ * Normalizes pseudo selectors to always contain &, requires to work properly with comma-separated selectors.
+ *
+ * @example
+ *   ":hover" => "&:hover"
+ *   " :hover" => "& :hover"
+ *   ":hover,:focus" => "&:hover,&:focus"
+ *   " :hover, :focus" => "& :hover,& :focus"
+ */
+export declare function normalizePseudoSelector(pseudoSelector: string): string;
+export declare function compileAtomicCSSRule(options: CompileAtomicCSSOptions, atRules: AtRules): [string?, string?];

node_modules/@griffel/core/src/runtime/compileCSSRules.d.ts

@@ -0,0 +1 @@
+export declare function compileCSSRules(cssRules: string, sortClassesInAtRules: boolean): string[];

node_modules/@griffel/core/src/runtime/compileKeyframeCSS.d.ts

@@ -0,0 +1,6 @@
+import type { GriffelAnimation } from '@griffel/style-types';
+export declare function compileKeyframeRule(keyframeObject: GriffelAnimation): string;
+/**
+ * Creates CSS rules for insertion from passed CSS.
+ */
+export declare function compileKeyframesCSS(keyframeName: string, keyframeCSS: string): string[];

node_modules/@griffel/core/src/runtime/compileResetCSSRules.d.ts

@@ -0,0 +1 @@
+export declare function compileResetCSSRules(cssRules: string): [string[], string[]];

node_modules/@griffel/core/src/runtime/compileStaticCSS.d.ts

@@ -0,0 +1,2 @@
+import type { GriffelStaticStyle } from '@griffel/style-types';
+export declare function compileStaticCSS(property: string, value: GriffelStaticStyle): string;

node_modules/@griffel/core/src/runtime/getStyleBucketName.d.ts

@@ -0,0 +1,22 @@
+import type { StyleBucketName } from '../types';
+import type { AtRules } from './utils/types';
+/**
+ * Gets the bucket depending on the pseudo.
+ *
+ * Input:
+ *
+ * ```
+ * ":hover"
+ * ":focus:hover"
+ * ```
+ *
+ * Output:
+ *
+ * ```
+ * "h"
+ * "f"
+ * ```
+ *
+ * @internal
+ */
+export declare function getStyleBucketName(selectors: string[], atRules: AtRules): StyleBucketName;

node_modules/@griffel/core/src/runtime/reduceToClassNameForSlots.d.ts

@@ -0,0 +1,14 @@
+import type { CSSClassesMapBySlot, CSSClassesMap } from '../types';
+/**
+ * Reduces a classname map for slot to a classname string. Uses classnames according to text directions.
+ *
+ * @private
+ */
+export declare function reduceToClassName(classMap: CSSClassesMap, dir: 'ltr' | 'rtl'): [string, string];
+/**
+ * Reduces classname maps for slots to classname strings. Registers them in a definition cache to be used by
+ * `mergeClasses()`.
+ *
+ * @internal
+ */
+export declare function reduceToClassNameForSlots<Slots extends string | number>(classesMapBySlot: CSSClassesMapBySlot<Slots>, dir: 'ltr' | 'rtl'): Record<Slots, string>;

node_modules/@griffel/core/src/runtime/resolveResetStyleRules.d.ts

@@ -0,0 +1,6 @@
+import type { GriffelResetStyle } from '@griffel/style-types';
+import type { CSSRulesByBucket } from '../types';
+/**
+ * @internal
+ */
+export declare function resolveResetStyleRules(styles: GriffelResetStyle, classNameHashSalt?: string): [string, string | null, CSSRulesByBucket | string[]];

node_modules/@griffel/core/src/runtime/resolveStaticStyleRules.d.ts

@@ -0,0 +1,3 @@
+import type { GriffelStaticStyles } from '@griffel/style-types';
+import type { CSSBucketEntry } from '../types';
+export declare function resolveStaticStyleRules(stylesSet: GriffelStaticStyles[]): CSSBucketEntry[];

node_modules/@griffel/core/src/runtime/resolveStyleRules.d.ts

@@ -0,0 +1,9 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { CSSClassesMap, CSSRulesByBucket } from '../types';
+import type { AtRules } from './utils/types';
+/**
+ * Transforms input styles to classes maps & CSS rules.
+ *
+ * @internal
+ */
+export declare function resolveStyleRules(styles: GriffelStyle, classNameHashSalt?: string, selectors?: string[], atRules?: AtRules, cssClassesMap?: CSSClassesMap, cssRulesByBucket?: CSSRulesByBucket, rtlValue?: string): [CSSClassesMap, CSSRulesByBucket];

node_modules/@griffel/core/src/runtime/shorthands.d.ts

@@ -0,0 +1,5 @@
+import type * as CSS from 'csstype';
+import type { GriffelStylesUnsupportedCSSProperties } from '@griffel/style-types';
+type AllowedShorthandProperties = keyof Omit<CSS.Properties, keyof GriffelStylesUnsupportedCSSProperties>;
+export declare const shorthands: Partial<Record<AllowedShorthandProperties, [number, string[]]>>;
+export {};

node_modules/@griffel/core/src/runtime/stylis/globalPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware } from 'stylis';
+export declare const globalPlugin: Middleware;

node_modules/@griffel/core/src/runtime/stylis/isAtRuleElement.d.ts

@@ -0,0 +1,2 @@
+import type { Element } from 'stylis';
+export declare function isAtRuleElement(element: Element): boolean;

node_modules/@griffel/core/src/runtime/stylis/prefixerPlugin.d.ts

@@ -0,0 +1,9 @@
+import type { Element, Middleware } from 'stylis';
+export declare function prefix(value: string, length: number, children?: Element[]): string;
+/**
+ * @param {object} element
+ * @param {number} index
+ * @param {object[]} children
+ * @param {function} callback
+ */
+export declare function prefixerPlugin(element: Element, index: number, children: Element[], callback: Middleware): string | undefined;

node_modules/@griffel/core/src/runtime/stylis/rulesheetPlugin.d.ts

@@ -0,0 +1,6 @@
+import type { Element, Middleware } from 'stylis';
+export type RulesheetPluginCallback = (type: Element, rule: string) => void;
+/**
+ * The same plugin as in stylis, but this version also has "element" argument.
+ */
+export declare function rulesheetPlugin(callback: RulesheetPluginCallback): Middleware;

node_modules/@griffel/core/src/runtime/stylis/sortClassesInAtRulesPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware } from 'stylis';
+export declare const sortClassesInAtRulesPlugin: Middleware;

node_modules/@griffel/core/src/runtime/utils/cssifyObject.d.ts

@@ -0,0 +1,2 @@
+import type { GriffelStaticStyle, GriffelStyle } from '@griffel/style-types';
+export declare function cssifyObject(style: GriffelStyle | GriffelStaticStyle): string;

node_modules/@griffel/core/src/runtime/utils/generateCombinedMediaQuery.d.ts

@@ -0,0 +1 @@
+export declare function generateCombinedQuery(currentMediaQuery: string, nestedMediaQuery: string): string;

node_modules/@griffel/core/src/runtime/utils/hashClassName.d.ts

@@ -0,0 +1,9 @@
+import type { AtRules } from './types';
+interface HashedClassNameParts {
+    property: string;
+    value: string;
+    salt: string;
+    selector: string;
+}
+export declare function hashClassName({ property, selector, salt, value }: HashedClassNameParts, atRules: AtRules): string;
+export {};

node_modules/@griffel/core/src/runtime/utils/hashPropertyKey.d.ts

@@ -0,0 +1,4 @@
+import type { PropertyHash } from '../../types';
+import type { AtRules } from './types';
+export declare function atRulesToString(atRules: AtRules): string;
+export declare function hashPropertyKey(selector: string, property: string, atRules: AtRules): PropertyHash;

node_modules/@griffel/core/src/runtime/utils/hashSequence.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceHash } from '../../types';
+export declare function hashSequence(classes: string, dir: 'ltr' | 'rtl', sequenceIds?: (SequenceHash | undefined)[]): SequenceHash;

node_modules/@griffel/core/src/runtime/utils/hyphenateProperty.d.ts

@@ -0,0 +1 @@
+export declare function hyphenateProperty(name: string): string;

node_modules/@griffel/core/src/runtime/utils/isContainerQuerySelector.d.ts

@@ -0,0 +1 @@
+export declare function isContainerQuerySelector(property: string): boolean;

node_modules/@griffel/core/src/runtime/utils/isLayerSelector.d.ts

@@ -0,0 +1 @@
+export declare function isLayerSelector(property: string): boolean;

node_modules/@griffel/core/src/runtime/utils/isMediaQuerySelector.d.ts

@@ -0,0 +1 @@
+export declare function isMediaQuerySelector(property: string): boolean;

node_modules/@griffel/core/src/runtime/utils/isNestedSelector.d.ts

@@ -0,0 +1 @@
+export declare function isNestedSelector(property: string): boolean;

node_modules/@griffel/core/src/runtime/utils/isObject.d.ts

@@ -0,0 +1 @@
+export declare function isObject(val: any): val is Record<string, unknown>;

node_modules/@griffel/core/src/runtime/utils/isResetValue.d.ts

@@ -0,0 +1 @@
+export declare function isResetValue(value: unknown): value is "unset";

node_modules/@griffel/core/src/runtime/utils/isSupportQuerySelector.d.ts

@@ -0,0 +1 @@
+export declare function isSupportQuerySelector(property: string): boolean;

node_modules/@griffel/core/src/runtime/utils/normalizeCSSBucketEntry.d.ts

@@ -0,0 +1,8 @@
+import type { CSSBucketEntry } from '../../types';
+/**
+ * @internal
+ *
+ * @param entry - CSS bucket entry that can be either a string or an array
+ * @returns An array where the first element is the CSS rule
+ */
+export declare function normalizeCSSBucketEntry(entry: CSSBucketEntry): [string] | [string, Record<string, unknown>];

node_modules/@griffel/core/src/runtime/utils/normalizeNestedProperty.d.ts

@@ -0,0 +1 @@
+export declare function normalizeNestedProperty(nestedProperty: string): string;

node_modules/@griffel/core/src/runtime/utils/trimSelector.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Trims selectors to generate consistent hashes.
+ */
+export declare function trimSelector(selector: string): string;

node_modules/@griffel/core/src/runtime/utils/types.d.ts

@@ -0,0 +1,6 @@
+export type AtRules = {
+    container: string;
+    media: string;
+    layer: string;
+    supports: string;
+};

node_modules/@griffel/core/src/runtime/warnings/logError.d.ts

@@ -0,0 +1 @@
+export declare function logError(...args: unknown[]): void;

node_modules/@griffel/core/src/runtime/warnings/warnAboutUnresolvedRule.d.ts

@@ -0,0 +1,2 @@
+import type { GriffelResetStyle, GriffelStyle } from '@griffel/style-types';
+export declare function warnAboutUnresolvedRule(property: string, value: GriffelStyle | GriffelResetStyle): void;

node_modules/@griffel/core/src/runtime/warnings/warnAboutUnsupportedProperties.d.ts

@@ -0,0 +1,2 @@
+import type { GriffelStyle } from '@griffel/style-types';
+export declare function warnAboutUnsupportedProperties(property: string, value: GriffelStyle[keyof GriffelStyle]): void;

node_modules/@griffel/core/src/shorthands/border.d.ts

@@ -0,0 +1,10 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { BorderColorInput, BorderStyleInput, BorderWidthInput } from './types';
+type BorderStyle = Pick<GriffelStyle, 'borderTopColor' | 'borderTopStyle' | 'borderTopWidth' | 'borderRightColor' | 'borderRightStyle' | 'borderRightWidth' | 'borderBottomColor' | 'borderBottomStyle' | 'borderBottomWidth' | 'borderLeftColor' | 'borderLeftStyle' | 'borderLeftWidth'>;
+/** @deprecated Use `{ border: '2px' }` instead as Griffel supports CSS shorthands now */
+export declare function border(width: BorderWidthInput): BorderStyle;
+/** @deprecated Use `{ border: '2px solid' }` instead as Griffel supports CSS shorthands now */
+export declare function border(width: BorderWidthInput, style: BorderStyleInput): BorderStyle;
+/** @deprecated Use `{ border: '2px solid red' }` instead as Griffel supports CSS shorthands now */
+export declare function border(width: BorderWidthInput, style: BorderStyleInput, color: BorderColorInput): BorderStyle;
+export {};

node_modules/@griffel/core/src/shorthands/borderBottom.d.ts

@@ -0,0 +1,16 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { BorderColorInput, BorderStyleInput, BorderWidthInput } from './types';
+type BorderBottomStyle = Pick<GriffelStyle, 'borderBottomColor' | 'borderBottomStyle' | 'borderBottomWidth'>;
+/** @deprecated Use `{ borderBottom: '2px' }` instead as Griffel supports CSS shorthands now */
+export declare function borderBottom(width: BorderWidthInput): BorderBottomStyle;
+/** @deprecated Use `{ borderBottom: 'solid' }` instead as Griffel supports CSS shorthands now */
+export declare function borderBottom(style: BorderStyleInput): BorderBottomStyle;
+/** @deprecated Use `{ borderBottom: '2px solid' }` instead as Griffel supports CSS shorthands now */
+export declare function borderBottom(width: BorderWidthInput, style: BorderStyleInput): BorderBottomStyle;
+/** @deprecated Use `{ borderBottom: 'solid 2px' }` instead as Griffel supports CSS shorthands now */
+export declare function borderBottom(style: BorderStyleInput, width: BorderWidthInput): BorderBottomStyle;
+/** @deprecated Use `{ borderBottom: '2px solid red' }` instead as Griffel supports CSS shorthands now */
+export declare function borderBottom(width: BorderWidthInput, style: BorderStyleInput, color: BorderColorInput): BorderBottomStyle;
+/** @deprecated Use `{ borderBottom: 'solid 2px red' }` instead as Griffel supports CSS shorthands now */
+export declare function borderBottom(style: BorderStyleInput, width: BorderWidthInput, color: BorderColorInput): BorderBottomStyle;
+export {};

node_modules/@griffel/core/src/shorthands/borderColor.d.ts

@@ -0,0 +1,8 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { BorderColorInput } from './types';
+type BorderColorStyle = Pick<GriffelStyle, 'borderTopColor' | 'borderRightColor' | 'borderBottomColor' | 'borderLeftColor'>;
+export declare function borderColor(all: BorderColorInput): BorderColorStyle;
+export declare function borderColor(vertical: BorderColorInput, horizontal: BorderColorInput): BorderColorStyle;
+export declare function borderColor(top: BorderColorInput, horizontal: BorderColorInput, bottom: BorderColorInput): BorderColorStyle;
+export declare function borderColor(top: BorderColorInput, right: BorderColorInput, bottom: BorderColorInput, left: BorderColorInput): BorderColorStyle;
+export {};

node_modules/@griffel/core/src/shorthands/borderLeft.d.ts

@@ -0,0 +1,16 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { BorderColorInput, BorderStyleInput, BorderWidthInput } from './types';
+type BorderLeftStyle = Pick<GriffelStyle, 'borderLeftColor' | 'borderLeftStyle' | 'borderLeftWidth'>;
+/** @deprecated Use `{ borderLeft: '2px' }` instead as Griffel supports CSS shorthands now */
+export declare function borderLeft(width: BorderWidthInput): BorderLeftStyle;
+/** @deprecated Use `{ borderLeft: 'solid' }` instead as Griffel supports CSS shorthands now */
+export declare function borderLeft(style: BorderStyleInput): BorderLeftStyle;
+/** @deprecated Use `{ borderLeft: '2px solid' }` instead as Griffel supports CSS shorthands now */
+export declare function borderLeft(width: BorderWidthInput, style: BorderStyleInput): BorderLeftStyle;
+/** @deprecated Use `{ borderLeft: 'solid 2px' }` instead as Griffel supports CSS shorthands now */
+export declare function borderLeft(style: BorderStyleInput, width: BorderWidthInput): BorderLeftStyle;
+/** @deprecated Use `{ borderLeft: '2px solid red' }` instead as Griffel supports CSS shorthands now */
+export declare function borderLeft(width: BorderWidthInput, style: BorderStyleInput, color: BorderColorInput): BorderLeftStyle;
+/** @deprecated Use `{ borderLeft: 'solid 2px red' }` instead as Griffel supports CSS shorthands now */
+export declare function borderLeft(style: BorderStyleInput, width: BorderWidthInput, color: BorderColorInput): BorderLeftStyle;
+export {};

node_modules/@griffel/core/src/shorthands/borderRadius.d.ts

@@ -0,0 +1,19 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { BorderRadiusInput } from './types';
+type BorderRadiusStyle = Pick<GriffelStyle, 'borderBottomRightRadius' | 'borderBottomLeftRadius' | 'borderTopRightRadius' | 'borderTopLeftRadius'>;
+/**
+ * A function that implements CSS spec conformant expansion for "borderRadius". "/" is not supported, please use CSS
+ * longhands directly.
+ *
+ * @example
+ *   borderRadius('10px')
+ *   borderRadius('10px', '5%')
+ *   borderRadius('2px', '4px', '8px')
+ *   borderRadius('1px', 0, '3px', '4px')
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/CSS/border-radius
+ *
+ * @deprecated Just use `{ borderRadius: '10px 5% 8px 4px' }` instead as Griffel supports CSS shorthands now
+ */
+export declare function borderRadius(value1: BorderRadiusInput, value2?: BorderRadiusInput, value3?: BorderRadiusInput, value4?: BorderRadiusInput): BorderRadiusStyle;
+export {};

node_modules/@griffel/core/src/shorthands/borderRight.d.ts

@@ -0,0 +1,16 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { BorderColorInput, BorderStyleInput, BorderWidthInput } from './types';
+type BorderRightStyle = Pick<GriffelStyle, 'borderRightWidth' | 'borderRightStyle' | 'borderRightColor'>;
+/** @deprecated Use `{ borderRight: '2px' }` instead as Griffel supports CSS shorthands now */
+export declare function borderRight(width: BorderWidthInput): BorderRightStyle;
+/** @deprecated Use `{ borderRight: 'solid' }` instead as Griffel supports CSS shorthands now */
+export declare function borderRight(style: BorderStyleInput): BorderRightStyle;
+/** @deprecated Use `{ borderRight: '2px solid' }` instead as Griffel supports CSS shorthands now */
+export declare function borderRight(width: BorderWidthInput, style: BorderStyleInput): BorderRightStyle;
+/** @deprecated Use `{ borderRight: 'solid 2px' }` instead as Griffel supports CSS shorthands now */
+export declare function borderRight(style: BorderStyleInput, width: BorderWidthInput): BorderRightStyle;
+/** @deprecated Use `{ borderRight: '2px solid red' }` instead as Griffel supports CSS shorthands now */
+export declare function borderRight(width: BorderWidthInput, style: BorderStyleInput, color: BorderColorInput): BorderRightStyle;
+/** @deprecated Use `{ borderRight: 'solid 2px red' }` instead as Griffel supports CSS shorthands now */
+export declare function borderRight(style: BorderStyleInput, width: BorderWidthInput, color: BorderColorInput): BorderRightStyle;
+export {};

node_modules/@griffel/core/src/shorthands/borderStyle.d.ts

@@ -0,0 +1,8 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { BorderStyleInput } from './types';
+type BorderStyleStyle = Pick<GriffelStyle, 'borderTopStyle' | 'borderRightStyle' | 'borderBottomStyle' | 'borderLeftStyle'>;
+export declare function borderStyle(all: BorderStyleInput): BorderStyleStyle;
+export declare function borderStyle(vertical: BorderStyleInput, horizontal: BorderStyleInput): BorderStyleStyle;
+export declare function borderStyle(top: BorderStyleInput, horizontal: BorderStyleInput, bottom: BorderStyleInput): BorderStyleStyle;
+export declare function borderStyle(top: BorderStyleInput, right: BorderStyleInput, bottom: BorderStyleInput, left: BorderStyleInput): BorderStyleStyle;
+export {};

node_modules/@griffel/core/src/shorthands/borderTop.d.ts

@@ -0,0 +1,16 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { BorderColorInput, BorderStyleInput, BorderWidthInput } from './types';
+type BorderTopStyle = Pick<GriffelStyle, 'borderTopColor' | 'borderTopStyle' | 'borderTopWidth'>;
+/** @deprecated Use `{ borderTop: '2px' }` instead as Griffel supports CSS shorthands now */
+export declare function borderTop(width: BorderWidthInput): BorderTopStyle;
+/** @deprecated Use `{ borderTop: 'solid' }` instead as Griffel supports CSS shorthands now */
+export declare function borderTop(style: BorderStyleInput): BorderTopStyle;
+/** @deprecated Use `{ borderTop: '2px solid' }` instead as Griffel supports CSS shorthands now */
+export declare function borderTop(width: BorderWidthInput, style: BorderStyleInput): BorderTopStyle;
+/** @deprecated Use `{ borderTop: 'solid 2px' }` instead as Griffel supports CSS shorthands now */
+export declare function borderTop(style: BorderStyleInput, width: BorderWidthInput): BorderTopStyle;
+/** @deprecated Use `{ borderTop: '2px solid red' }` instead as Griffel supports CSS shorthands now */
+export declare function borderTop(width: BorderWidthInput, style: BorderStyleInput, color: BorderColorInput): BorderTopStyle;
+/** @deprecated Use `{ borderTop: 'solid 2px red' }` instead as Griffel supports CSS shorthands now */
+export declare function borderTop(style: BorderStyleInput, width: BorderWidthInput, color: BorderColorInput): BorderTopStyle;
+export {};

node_modules/@griffel/core/src/shorthands/borderWidth.d.ts

@@ -0,0 +1,8 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { BorderWidthInput } from './types';
+type BorderWidthStyle = Pick<GriffelStyle, 'borderTopStyle' | 'borderRightStyle' | 'borderBottomStyle' | 'borderLeftStyle'>;
+export declare function borderWidth(all: BorderWidthInput): BorderWidthStyle;
+export declare function borderWidth(vertical: BorderWidthInput, horizontal: BorderWidthInput): BorderWidthStyle;
+export declare function borderWidth(top: BorderWidthInput, horizontal: BorderWidthInput, bottom: BorderWidthInput): BorderWidthStyle;
+export declare function borderWidth(top: BorderWidthInput, right: BorderWidthInput, bottom: BorderWidthInput, left: BorderWidthInput): BorderWidthStyle;
+export {};

node_modules/@griffel/core/src/shorthands/flex.d.ts

@@ -0,0 +1,17 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { FlexInput } from './types';
+type FlexStyle = Pick<GriffelStyle, 'flexGrow' | 'flexShrink' | 'flexBasis'>;
+/**
+ * A function that implements CSS spec conformant expansion for "flex".
+ *
+ * @example
+ *   flex('auto')
+ *   flex(1, '2.5rem')
+ *   flex(0, 0, 'auto')
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/flex
+ *
+ * @deprecated Just use `{ flex: '1 1 0' }` instead as Griffel supports CSS shorthands now
+ */
+export declare function flex(...values: FlexInput): FlexStyle;
+export {};

node_modules/@griffel/core/src/shorthands/gap.d.ts

@@ -0,0 +1,16 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { GapInput } from './types';
+type GapStyle = Pick<GriffelStyle, 'columnGap' | 'rowGap'>;
+/**
+ * A function that implements CSS spec conformant expansion for "gap"
+ *
+ * @example
+ *   gap('10px')
+ *   gap('10px', '5px')
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/CSS/gap
+ *
+ * @deprecated Just use `{ gap: '10px 5px' }` instead as Griffel supports CSS shorthands now
+ */
+export declare function gap(columnGap: GapInput, rowGap?: GapInput): GapStyle;
+export {};

node_modules/@griffel/core/src/shorthands/generateStyles.d.ts

@@ -0,0 +1,4 @@
+import type { GriffelStylesCSSValue, ValueOrArray, GriffelStyle } from '@griffel/style-types';
+type DirectionalProperties = 'border' | 'padding' | 'margin';
+export declare function generateStyles<Styles extends GriffelStyle>(property: DirectionalProperties, suffix: '' | 'Color' | 'Style' | 'Width', ...values: ValueOrArray<GriffelStylesCSSValue>[]): Styles;
+export {};

node_modules/@griffel/core/src/shorthands/gridArea.d.ts

@@ -0,0 +1,13 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { GridAreaInput } from './types';
+type GridAreaStyle = Pick<GriffelStyle, 'gridRowStart' | 'gridRowEnd' | 'gridColumnStart' | 'gridColumnEnd'>;
+export declare function isCustomIdent(value: GridAreaInput | undefined): boolean;
+/** @deprecated Use `{ gridArea: '2' }` instead as Griffel supports CSS shorthands now */
+export declare function gridArea(all: GridAreaInput): GridAreaStyle;
+/** @deprecated Use `{ gridArea: '2 / 4' }` instead as Griffel supports CSS shorthands now */
+export declare function gridArea(rowStart: GridAreaInput, columnStart: GridAreaInput): GridAreaStyle;
+/** @deprecated Use `{ gridArea: '2 / 4 / 4' }` instead as Griffel supports CSS shorthands now */
+export declare function gridArea(rowStart: GridAreaInput, columnStart: GridAreaInput, rowEnd: GridAreaInput): GridAreaStyle;
+/** @deprecated Use `{ gridArea: '2 / 4 / 1 / 3' }` instead as Griffel supports CSS shorthands now */
+export declare function gridArea(rowStart: GridAreaInput, columnStart: GridAreaInput, rowEnd: GridAreaInput, columnEnd: GridAreaInput): GridAreaStyle;
+export {};

node_modules/@griffel/core/src/shorthands/index.d.ts

@@ -0,0 +1,23 @@
+export { border } from './border';
+export { borderLeft } from './borderLeft';
+export { borderBottom } from './borderBottom';
+export { borderRight } from './borderRight';
+export { borderTop } from './borderTop';
+export { borderColor } from './borderColor';
+export { borderStyle } from './borderStyle';
+export { borderRadius } from './borderRadius';
+export { borderWidth } from './borderWidth';
+export { flex } from './flex';
+export { gap } from './gap';
+export { gridArea } from './gridArea';
+export { margin } from './margin';
+export { marginBlock } from './marginBlock';
+export { marginInline } from './marginInline';
+export { padding } from './padding';
+export { paddingBlock } from './paddingBlock';
+export { paddingInline } from './paddingInline';
+export { overflow } from './overflow';
+export { inset } from './inset';
+export { outline } from './outline';
+export { transition } from './transition';
+export { textDecoration } from './textDecoration';

node_modules/@griffel/core/src/shorthands/inset.d.ts

@@ -0,0 +1,12 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { InsetInput } from './types';
+type InsetStyle = Pick<GriffelStyle, 'top' | 'right' | 'bottom' | 'left'>;
+/** @deprecated Use `{ inset: '10px' }` instead as Griffel supports CSS shorthands now */
+export declare function inset(all: InsetInput): InsetStyle;
+/** @deprecated Use `{ inset: '10px 5px' }` instead as Griffel supports CSS shorthands now */
+export declare function inset(vertical: InsetInput, horizontal: InsetInput): InsetStyle;
+/** @deprecated Use `{ inset: '10px 5px 8px' }` instead as Griffel supports CSS shorthands now */
+export declare function inset(top: InsetInput, horizontal: InsetInput, bottom: InsetInput): InsetStyle;
+/** @deprecated Use `{ inset: '10px 5px 8px 4px' }` instead as Griffel supports CSS shorthands now */
+export declare function inset(top: InsetInput, right: InsetInput, bottom: InsetInput, left: InsetInput): InsetStyle;
+export {};

node_modules/@griffel/core/src/shorthands/margin.d.ts

@@ -0,0 +1,12 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { MarginInput } from './types';
+type MarginStyle = Pick<GriffelStyle, 'marginTop' | 'marginRight' | 'marginBottom' | 'marginLeft'>;
+/** @deprecated Use `{ margin: '10px 5px 8px 4px' }` instead as Griffel supports CSS shorthands now */
+export declare function margin(all: MarginInput): MarginStyle;
+/** @deprecated Use `{ margin: '10px 5px' }` instead as Griffel supports CSS shorthands now */
+export declare function margin(vertical: MarginInput, horizontal: MarginInput): MarginStyle;
+/** @deprecated Use `{ margin: '10px 5px 8px' }` instead as Griffel supports CSS shorthands now */
+export declare function margin(top: MarginInput, horizontal: MarginInput, bottom: MarginInput): MarginStyle;
+/** @deprecated Use `{ margin: '10px 5px 8px 4px' }` instead as Griffel supports CSS shorthands now */
+export declare function margin(top: MarginInput, right: MarginInput, bottom: MarginInput, left: MarginInput): MarginStyle;
+export {};

node_modules/@griffel/core/src/shorthands/marginBlock.d.ts

@@ -0,0 +1,16 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { MarginBlockInput } from './types';
+type MarginBlockStyle = Pick<GriffelStyle, 'marginBlockStart' | 'marginBlockEnd'>;
+/**
+ * A function that implements CSS spec conformant expansion for "margin-block"
+ *
+ * @example
+ *   marginBlock('10px')
+ *   marginBlock('10px', '5px')
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/CSS/margin-block
+ *
+ * @deprecated Just use `{ marginBlock: '10px' }` instead as Griffel supports CSS shorthands now
+ */
+export declare function marginBlock(start: MarginBlockInput, end?: MarginBlockInput): MarginBlockStyle;
+export {};

node_modules/@griffel/core/src/shorthands/marginInline.d.ts

@@ -0,0 +1,16 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { MarginInlineInput } from './types';
+type MarginInlineStyle = Pick<GriffelStyle, 'marginInlineStart' | 'marginInlineEnd'>;
+/**
+ * A function that implements CSS spec conformant expansion for "margin-inline"
+ *
+ * @example
+ *   marginInline('10px')
+ *   marginInline('10px', '5px')
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/CSS/margin-inline
+ *
+ * @deprecated Just use `{ marginInline: '10px' }` instead as Griffel supports CSS shorthands now
+ */
+export declare function marginInline(start: MarginInlineInput, end?: MarginInlineInput): MarginInlineStyle;
+export {};

node_modules/@griffel/core/src/shorthands/outline.d.ts

@@ -0,0 +1,10 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { OutlineColorInput, OutlineStyleInput, OutlineWidthInput } from './types';
+type OutlineStyle = Pick<GriffelStyle, 'outlineColor' | 'outlineStyle' | 'outlineWidth'>;
+/** @deprecated Use `{ outline: '2px' }` instead as Griffel supports CSS shorthands now */
+export declare function outline(width: OutlineWidthInput): OutlineStyle;
+/** @deprecated Use `{ outline: '2px solid' }` instead as Griffel supports CSS shorthands now */
+export declare function outline(width: OutlineWidthInput, style: OutlineStyleInput): OutlineStyle;
+/** @deprecated Use `{ outline: '2px solid red' }` instead as Griffel supports CSS shorthands now */
+export declare function outline(width: OutlineWidthInput, style: OutlineStyleInput, color: OutlineColorInput): OutlineStyle;
+export {};

node_modules/@griffel/core/src/shorthands/overflow.d.ts

@@ -0,0 +1,16 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { OverflowInput } from './types';
+type OverflowStyle = Pick<GriffelStyle, 'overflowX' | 'overflowY'>;
+/**
+ * A function that implements CSS spec conformant expansion for "overflow"
+ *
+ * @example
+ *   overflow('hidden')
+ *   overflow('hidden', 'scroll')
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/CSS/overflow
+ *
+ * @deprecated Just use `{ overflow: 'hidden scroll' }` instead as Griffel supports CSS shorthands now
+ */
+export declare function overflow(overflowX: OverflowInput, overflowY?: OverflowInput): OverflowStyle;
+export {};

node_modules/@griffel/core/src/shorthands/padding.d.ts

@@ -0,0 +1,12 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { PaddingInput } from './types';
+type PaddingStyle = Pick<GriffelStyle, 'paddingTop' | 'paddingRight' | 'paddingBottom' | 'paddingLeft'>;
+/** @deprecated Use `{ padding: '10px' }` instead as Griffel supports CSS shorthands now */
+export declare function padding(all: PaddingInput): PaddingStyle;
+/** @deprecated Use `{ padding: '10px 5px' }` instead as Griffel supports CSS shorthands now */
+export declare function padding(vertical: PaddingInput, horizontal: PaddingInput): PaddingStyle;
+/** @deprecated Use `{ padding: '10px 5px 8px' }` instead as Griffel supports CSS shorthands now */
+export declare function padding(top: PaddingInput, horizontal: PaddingInput, bottom: PaddingInput): PaddingStyle;
+/** @deprecated Use `{ padding: '10px 5px 8px 4px' }` instead as Griffel supports CSS shorthands now */
+export declare function padding(top: PaddingInput, right: PaddingInput, bottom: PaddingInput, left: PaddingInput): PaddingStyle;
+export {};

node_modules/@griffel/core/src/shorthands/paddingBlock.d.ts

@@ -0,0 +1,16 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { PaddingBlockInput } from './types';
+type PaddingBlockStyle = Pick<GriffelStyle, 'paddingBlockStart' | 'paddingBlockEnd'>;
+/**
+ * A function that implements CSS spec conformant expansion for "padding-block"
+ *
+ * @example
+ *   paddingBlock('10px')
+ *   paddingBlock('10px', '5px')
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/CSS/padding-block
+ *
+ * @deprecated Just use `{ paddingBlock: '10px' }` instead as Griffel supports CSS shorthands now
+ */
+export declare function paddingBlock(start: PaddingBlockInput, end?: PaddingBlockInput): PaddingBlockStyle;
+export {};

node_modules/@griffel/core/src/shorthands/paddingInline.d.ts

@@ -0,0 +1,16 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { PaddingInlineInput } from './types';
+type PaddingInlineStyle = Pick<GriffelStyle, 'paddingInlineStart' | 'paddingInlineEnd'>;
+/**
+ * A function that implements CSS spec conformant expansion for "padding-inline"
+ *
+ * @example
+ *   paddingInline('10px')
+ *   paddingInline('10px', '5px')
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/CSS/padding-inline
+ *
+ * @deprecated Just use `{ paddingInline: '10px' }` instead as Griffel supports CSS shorthands now
+ */
+export declare function paddingInline(start: PaddingInlineInput, end?: PaddingInlineInput): PaddingInlineStyle;
+export {};

node_modules/@griffel/core/src/shorthands/textDecoration.d.ts

@@ -0,0 +1,14 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { TextDecorationColorInput, TextDecorationLineInput, TextDecorationStyleInput, TextDecorationThicknessInput } from './types';
+type TextDecorationStyle = Pick<GriffelStyle, 'textDecorationStyle' | 'textDecorationLine' | 'textDecorationColor' | 'textDecorationThickness'>;
+/** @deprecated Use `{ textDecoration: 'none' }` instead as Griffel supports CSS shorthands now */
+export declare function textDecoration(style: TextDecorationStyleInput): TextDecorationStyle;
+/** @deprecated Use `{ textDecoration: 'dotted' }` instead as Griffel supports CSS shorthands now */
+export declare function textDecoration(line: TextDecorationLineInput): TextDecorationStyle;
+/** @deprecated Use `{ textDecoration: 'underline dotted' }` instead as Griffel supports CSS shorthands now */
+export declare function textDecoration(line: TextDecorationLineInput, style: TextDecorationStyleInput): TextDecorationStyle;
+/** @deprecated Use `{ textDecoration: 'underline dotted red' }` instead as Griffel supports CSS shorthands now */
+export declare function textDecoration(line: TextDecorationLineInput, style: TextDecorationStyleInput, color: TextDecorationColorInput): TextDecorationStyle;
+/** @deprecated Use `{ textDecoration: 'underline dotted red 2px' }` instead as Griffel supports CSS shorthands now */
+export declare function textDecoration(line: TextDecorationLineInput, style: TextDecorationStyleInput, color: TextDecorationColorInput, thickness: TextDecorationThicknessInput): TextDecorationStyle;
+export {};

node_modules/@griffel/core/src/shorthands/transition.d.ts

@@ -0,0 +1,22 @@
+import type { GriffelStyle } from '@griffel/style-types';
+import type { TransitionDelayInput, TransitionDurationInput, TransitionPropertyInput, TransitionTimingFunctionInput, TransitionGlobalInput } from './types';
+type TransitionInputs = [
+    TransitionPropertyInput,
+    TransitionDurationInput?,
+    TransitionDelayInput?,
+    TransitionTimingFunctionInput?
+];
+type TransitionStyle = Pick<GriffelStyle, 'transitionProperty' | 'transitionDelay' | 'transitionDuration' | 'transitionTimingFunction'>;
+/** @deprecated Use `{ transition: 'inherit' }` instead as Griffel supports CSS shorthands now */
+export declare function transition(globalValue: TransitionGlobalInput): TransitionStyle;
+/** @deprecated Use `{ transition: 'margin-right 4s' }` instead as Griffel supports CSS shorthands now */
+export declare function transition(property: TransitionPropertyInput, duration: TransitionDurationInput): TransitionStyle;
+/** @deprecated Use `{ transition: 'margin-right 4s 1s' }` instead as Griffel supports CSS shorthands now */
+export declare function transition(property: TransitionPropertyInput, duration: TransitionDurationInput, delay: TransitionDelayInput): TransitionStyle;
+/** @deprecated Use `{ transition: 'margin-right 4s 1s ease-in' }` instead as Griffel supports CSS shorthands now */
+export declare function transition(property: TransitionPropertyInput, duration: TransitionDurationInput, delay: TransitionDelayInput, easingFunction: TransitionTimingFunctionInput): TransitionStyle;
+/**
+ * @deprecated Use `{ transition: 'margin-right 4s 1s ease-in, padding 3s 2s ease-out' }` instead as Griffel supports CSS shorthands now
+ * */
+export declare function transition(values: TransitionInputs[]): TransitionStyle;
+export {};

node_modules/@griffel/core/src/shorthands/types.d.ts

@@ -0,0 +1,29 @@
+import type { GriffelStylesCSSValue, ValueOrArray } from '@griffel/style-types';
+import type * as CSS from 'csstype';
+export type BorderWidthInput = ValueOrArray<CSS.Property.BorderWidth<GriffelStylesCSSValue>>;
+export type BorderStyleInput = ValueOrArray<CSS.Property.BorderStyle>;
+export type BorderColorInput = ValueOrArray<CSS.Property.BorderColor>;
+export type OutlineWidthInput = ValueOrArray<CSS.Property.OutlineWidth<GriffelStylesCSSValue>>;
+export type OutlineStyleInput = ValueOrArray<CSS.Property.OutlineStyle>;
+export type OutlineColorInput = ValueOrArray<CSS.Property.OutlineColor>;
+export type BorderRadiusInput = ValueOrArray<CSS.Property.BorderRadius<GriffelStylesCSSValue>>;
+export type GapInput = ValueOrArray<CSS.Property.Gap<GriffelStylesCSSValue>>;
+export type GridAreaInput = CSS.Property.GridArea;
+export type MarginInput = ValueOrArray<CSS.Property.Margin<GriffelStylesCSSValue>>;
+export type MarginBlockInput = ValueOrArray<CSS.Property.MarginBlock<GriffelStylesCSSValue>>;
+export type MarginInlineInput = ValueOrArray<CSS.Property.MarginInline<GriffelStylesCSSValue>>;
+export type OverflowInput = ValueOrArray<CSS.Property.Overflow>;
+export type PaddingInput = ValueOrArray<CSS.Property.Padding<GriffelStylesCSSValue>>;
+export type PaddingBlockInput = ValueOrArray<CSS.Property.MarginBlock<GriffelStylesCSSValue>>;
+export type PaddingInlineInput = ValueOrArray<CSS.Property.MarginInline<GriffelStylesCSSValue>>;
+export type InsetInput = ValueOrArray<CSS.Property.Inset<GriffelStylesCSSValue>>;
+export type FlexInput = [CSS.Property.Flex, CSS.Property.Flex?, CSS.Property.Flex?];
+export type TransitionPropertyInput = CSS.Property.TransitionProperty;
+export type TransitionDurationInput = CSS.Property.TransitionDuration;
+export type TransitionDelayInput = CSS.Property.TransitionDelay;
+export type TransitionTimingFunctionInput = CSS.Property.TransitionTimingFunction;
+export type TransitionGlobalInput = CSS.Globals;
+export type TextDecorationStyleInput = CSS.Property.TextDecorationStyle;
+export type TextDecorationLineInput = ValueOrArray<CSS.Property.TextDecorationLine>;
+export type TextDecorationColorInput = ValueOrArray<CSS.Property.TextDecorationColor>;
+export type TextDecorationThicknessInput = ValueOrArray<CSS.Property.TextDecorationThickness>;

node_modules/@griffel/core/src/shorthands/utils.d.ts

@@ -0,0 +1,3 @@
+import type { GriffelStylesCSSValue } from '@griffel/style-types';
+import type * as CSS from 'csstype';
+export declare function isBorderStyle(value: GriffelStylesCSSValue | GriffelStylesCSSValue[]): value is CSS.DataType.LineStyle;

node_modules/@griffel/core/src/types.d.ts

@@ -0,0 +1,76 @@
+import type { GriffelStyle } from '@griffel/style-types';
+export interface IsomorphicStyleSheet {
+    /**
+     * Attributes applied to the underlying HTMLStyleElement
+     */
+    elementAttributes: Record<string, string>;
+    /**
+     * Underlying HTMLStyleElement
+     */
+    element: HTMLStyleElement | undefined;
+    bucketName: StyleBucketName;
+    /**
+     * Returns all CSS rules on the stylesheet
+     */
+    cssRules(): string[];
+    insertRule(rule: string): number | undefined;
+}
+export interface GriffelRenderer {
+    id: string;
+    /**
+     * @private
+     */
+    classNameHashSalt?: string;
+    /**
+     * @private
+     */
+    insertionCache: Record<string, StyleBucketName>;
+    /**
+     * @private
+     */
+    stylesheets: {
+        [key in StyleBucketName]?: IsomorphicStyleSheet;
+    } & Record<string, IsomorphicStyleSheet>;
+    /**
+     * @private
+     */
+    styleElementAttributes?: Readonly<Record<string, string>>;
+    /**
+     * @private
+     */
+    insertCSSRules(cssRules: CSSRulesByBucket): void;
+    /**
+     * @private
+     */
+    compareMediaQueries(a: string, b: string): number;
+}
+/**
+ * Buckets under which we will group our stylesheets.
+ */
+export type StyleBucketName = keyof CSSRulesByBucket;
+export type SequenceHash = string;
+export type PropertyHash = string;
+export type CSSClasses = string | 0 | [string, string];
+export type CSSClassesMap = Record<PropertyHash, CSSClasses>;
+export type CSSClassesMapBySlot<Slots extends string | number> = Record<Slots, CSSClassesMap>;
+export type CSSRulesByBucket = {
+    r?: CSSBucketEntry[];
+    d?: CSSBucketEntry[];
+    l?: CSSBucketEntry[];
+    v?: CSSBucketEntry[];
+    w?: CSSBucketEntry[];
+    f?: CSSBucketEntry[];
+    i?: CSSBucketEntry[];
+    h?: CSSBucketEntry[];
+    a?: CSSBucketEntry[];
+    s?: CSSBucketEntry[];
+    k?: CSSBucketEntry[];
+    t?: CSSBucketEntry[];
+    m?: CSSBucketEntry[];
+    c?: CSSBucketEntry[];
+};
+export type GriffelInsertionFactory = () => (renderer: GriffelRenderer, cssRules: CSSRulesByBucket) => void;
+/** @internal */
+export type CSSBucketEntry = string | [string, Record<string, unknown>];
+export type StylesBySlots<Slots extends string | number> = Record<Slots, GriffelStyle>;
+export type LookupItem = [/* definitions */ CSSClassesMap, /* dir */ /* dir */ 'rtl' | 'ltr'];