@mui/system 6.4.3 → 7.0.0-alpha.1

package/createTheme/createTheme.d.ts

@@ -1,25 +1,17 @@
 import { CSSObject } from '@mui/styled-engine';
-import { Breakpoints, BreakpointsOptions } from '../createBreakpoints/createBreakpoints';
-import { Shape, ShapeOptions } from './shape';
-import { Spacing, SpacingOptions } from './createSpacing';
-import { SxConfig, SxProps } from '../styleFunctionSx';
-import { ApplyStyles } from './applyStyles';
-import { CssContainerQueries } from '../cssContainerQueries';
-
-export {
-  Breakpoint,
-  Breakpoints,
-  BreakpointOverrides,
-} from '../createBreakpoints/createBreakpoints';
-
+import { Breakpoints, BreakpointsOptions } from "../createBreakpoints/createBreakpoints.js";
+import { Shape, ShapeOptions } from "./shape.js";
+import { Spacing, SpacingOptions } from "./createSpacing.js";
+import { SxConfig, SxProps } from "../styleFunctionSx/index.js";
+import { ApplyStyles } from "./applyStyles.js";
+import { CssContainerQueries } from "../cssContainerQueries/index.js";
+export { Breakpoint, Breakpoints, BreakpointOverrides } from "../createBreakpoints/createBreakpoints.js";
 export type Direction = 'ltr' | 'rtl';
-
 export interface Typography {}
 export interface Mixins {}
 export interface Shadows {}
 export interface Transitions {}
 export interface ZIndex {}
-
 export interface ThemeOptions {
   shape?: ShapeOptions;
   breakpoints?: BreakpointsOptions;
@@ -34,12 +26,13 @@ export interface ThemeOptions {
   zIndex?: ZIndex;
   unstable_sxConfig?: SxConfig;
 }
-
 export interface Theme extends CssContainerQueries {
   shape: Shape;
   breakpoints: Breakpoints;
   direction: Direction;
-  palette: Record<string, any> & { mode: 'light' | 'dark' };
+  palette: Record<string, any> & {
+    mode: 'light' | 'dark';
+  };
   shadows?: Shadows;
   spacing: Spacing;
   transitions?: Transitions;
@@ -58,4 +51,4 @@ export interface Theme extends CssContainerQueries {
  * @param args Deep merge the arguments with the about to be returned theme.
  * @returns A complete, ready-to-use theme object.
  */
-export default function createTheme(options?: ThemeOptions, ...args: object[]): Theme;
+export default function createTheme(options?: ThemeOptions, ...args: object[]): Theme;

package/createTheme/index.d.ts

@@ -1,4 +1,4 @@
-export { default } from './createTheme';
-export * from './createTheme';
-export { default as unstable_applyStyles } from './applyStyles';
-export * from './applyStyles';
+export { default } from "./createTheme.js";
+export * from "./createTheme.js";
+export { default as unstable_applyStyles } from "./applyStyles.js";
+export * from "./applyStyles.js";

package/createTheme/shape.d.ts

@@ -1,9 +1,6 @@
 export interface Shape {
   borderRadius: number;
 }
-
 export type ShapeOptions = Partial<Shape>;
-
 declare const shape: Shape;
-
-export default shape;
+export default shape;

package/cssContainerQueries/cssContainerQueries.d.ts

@@ -1,13 +1,13 @@
-import { Breakpoints } from '../createBreakpoints/createBreakpoints';
+import { Breakpoints } from "../createBreakpoints/createBreakpoints.js";
 export interface ContainerQueries {
-    up: Breakpoints['up'];
-    down: Breakpoints['down'];
-    between: Breakpoints['between'];
-    only: Breakpoints['only'];
-    not: Breakpoints['not'];
+  up: Breakpoints['up'];
+  down: Breakpoints['down'];
+  between: Breakpoints['between'];
+  only: Breakpoints['only'];
+  not: Breakpoints['not'];
 }
 export interface CssContainerQueries {
-    containerQueries: ((name: string) => ContainerQueries) & ContainerQueries;
+  containerQueries: ((name: string) => ContainerQueries) & ContainerQueries;
 }
 /**
  * For using in `sx` prop to sort the breakpoint from low to high.
@@ -19,5 +19,5 @@ export declare function sortContainerQueries(theme: Partial<CssContainerQueries>
 export declare function isCqShorthand(breakpointKeys: string[], value: string): boolean;
 export declare function getContainerQuery(theme: CssContainerQueries, shorthand: string): string | null;
 export default function cssContainerQueries<T extends {
-    breakpoints: Breakpoints;
-}>(themeInput: T): T & CssContainerQueries;
+  breakpoints: Breakpoints;
+}>(themeInput: T): T & CssContainerQueries;

package/cssContainerQueries/index.d.ts

@@ -1,3 +1,3 @@
-export { default } from './cssContainerQueries';
-export { isCqShorthand, getContainerQuery, sortContainerQueries } from './cssContainerQueries';
-export type { CssContainerQueries } from './cssContainerQueries';
+export { default } from "./cssContainerQueries.js";
+export { isCqShorthand, getContainerQuery, sortContainerQueries } from "./cssContainerQueries.js";
+export type { CssContainerQueries } from "./cssContainerQueries.js";

package/cssGrid/cssGrid.d.ts

@@ -1,3 +1,2 @@
-import { PropsFor, grid } from '../Box';
-
-export type CssGridProps = PropsFor<typeof grid>;
+import { PropsFor, grid } from "../Box/index.js";
+export type CssGridProps = PropsFor<typeof grid>;

package/cssGrid/index.d.ts

@@ -1,2 +1,2 @@
-export { default } from './cssGrid';
-export * from './cssGrid';
+export { default } from "./cssGrid.js";
+export * from "./cssGrid.js";

package/cssVars/createCssVarsProvider.d.ts

@@ -1,12 +1,9 @@
 import * as React from 'react';
-import InitColorSchemeScript from '../InitColorSchemeScript';
-import { Result } from './useCurrentColorScheme';
-
-export interface ColorSchemeContextValue<SupportedColorScheme extends string>
-  extends Result<SupportedColorScheme> {
+import InitColorSchemeScript from "../InitColorSchemeScript/index.js";
+import { Result } from "./useCurrentColorScheme.js";
+export interface ColorSchemeContextValue<SupportedColorScheme extends string> extends Result<SupportedColorScheme> {
   allColorSchemes: SupportedColorScheme[];
 }
-
 export interface CssVarsProviderConfig<ColorScheme extends string> {
   /**
    * DOM attribute for applying color scheme
@@ -28,120 +25,105 @@ export interface CssVarsProviderConfig<ColorScheme extends string> {
    * - provides string if the design system has one default color scheme (either light or dark)
    * - provides object if the design system has default light & dark color schemes
    */
-  defaultColorScheme: ColorScheme | { light: ColorScheme; dark: ColorScheme };
+  defaultColorScheme: ColorScheme | {
+    light: ColorScheme;
+    dark: ColorScheme;
+  };
   /**
    * Disable CSS transitions when switching between modes or color schemes
    * @default false
    */
   disableTransitionOnChange?: boolean;
 }
-
 type Identify<I extends string | undefined, T> = I extends string ? T | { [k in I]: T } : T;
-
-export interface CreateCssVarsProviderResult<
-  ColorScheme extends string,
-  Identifier extends string | undefined = undefined,
-> {
-  CssVarsProvider: (
-    props: React.PropsWithChildren<
-      Partial<CssVarsProviderConfig<ColorScheme>> & {
-        theme?: Identify<
-          Identifier,
-          {
-            cssVariables?: false;
-            cssVarPrefix?: string;
-            colorSchemes: Partial<Record<ColorScheme, any>>;
-            colorSchemeSelector?: 'media' | 'class' | 'data' | string;
-          }
-        >;
-        /**
-         * The default mode when the storage is empty,
-         * require the theme to have `colorSchemes` with light and dark.
-         * @default 'system'
-         */
-        defaultMode?: 'light' | 'dark' | 'system';
-        /**
-         * The document used to perform `disableTransitionOnChange` feature
-         * @default document
-         */
-        documentNode?: Document | null;
-        /**
-         * The node used to attach the color-scheme attribute
-         * @default document
-         */
-        colorSchemeNode?: Element | null;
-        /**
-         * The window that attaches the 'storage' event listener
-         * @default window
-         */
-        storageWindow?: Window | null;
-        /**
-         * If `true`, the provider creates its own context and generate stylesheet as if it is a root `CssVarsProvider`.
-         */
-        disableNestedContext?: boolean;
-        /**
-         * If `true`, the style sheet won't be generated.
-         *
-         * This is useful for controlling nested CssVarsProvider behavior.
-         * @default false
-         */
-        disableStyleSheetGeneration?: boolean;
-      }
-    >,
-  ) => React.JSX.Element;
-  useColorScheme: () => ColorSchemeContextValue<ColorScheme>;
-  getInitColorSchemeScript: typeof InitColorSchemeScript;
-}
-
-export default function createCssVarsProvider<
-  ColorScheme extends string,
-  Identifier extends string | undefined = undefined,
->(
-  options: CssVarsProviderConfig<ColorScheme> & {
+export interface CreateCssVarsProviderResult<ColorScheme extends string, Identifier extends string | undefined = undefined> {
+  CssVarsProvider: (props: React.PropsWithChildren<Partial<CssVarsProviderConfig<ColorScheme>> & {
+    theme?: Identify<Identifier, {
+      cssVariables?: false;
+      cssVarPrefix?: string;
+      colorSchemes: Partial<Record<ColorScheme, any>>;
+      colorSchemeSelector?: 'media' | 'class' | 'data' | string;
+    }>;
     /**
-     * The design system's unique id for getting the corresponded theme when there are multiple design systems.
+     * The default mode when the storage is empty,
+     * require the theme to have `colorSchemes` with light and dark.
+     * @default 'system'
      */
-    themeId?: Identifier;
+    defaultMode?: 'light' | 'dark' | 'system';
     /**
-     * Design system default theme
-     *
-     * - The structure inside `theme.colorSchemes[colorScheme]` should be exactly the same in all color schemes because
-     * those object of the color scheme will be used when the color scheme is active.
-     *
-     *  {
-     *    colorSchemes: {
-     *      light: { ...lightColorSchemeValues },
-     *      dark: { ...darkColorSchemeValues }
-     *    }
-     *  }
-     *
-     * - If colorScheme is 'light', the `lightColorSchemeValues` will be merged to theme as `{ ...theme, ...lightColorSchemeValues }`
-     *   likewise, if colorScheme is 'dark', the `darkColorSchemeValues` will be merged to theme as `{ ...theme, ...darkColorSchemeValues }`
-     *
-     * - If the theme contains the same keys as the color scheme, their values will be merged.
-     *  Ex. {
-     *    colorSchemes: {
-     *      light: { palette: { primary: { ... } } },
-     *      dark: { palette: { primary: { ...} } }
-     *    },
-     *    palette: { shared: { ... } }
-     *  }
-     *
-     *  becomes: {
-     *    colorSchemes: { ... },
-     *    palette: { shared: { ... }, primary: { ... } }
-     *  }
+     * The document used to perform `disableTransitionOnChange` feature
+     * @default document
+     */
+    documentNode?: Document | null;
+    /**
+     * The node used to attach the color-scheme attribute
+     * @default document
+     */
+    colorSchemeNode?: Element | null;
+    /**
+     * The window that attaches the 'storage' event listener
+     * @default window
      */
-    theme: any;
+    storageWindow?: Window | null;
     /**
-     * A function to be called after the CSS variables are attached. The result of this function will be the final theme pass to ThemeProvider.
+     * If `true`, the provider creates its own context and generate stylesheet as if it is a root `CssVarsProvider`.
+     */
+    disableNestedContext?: boolean;
+    /**
+     * If `true`, the style sheet won't be generated.
      *
-     * The example usage is the variant generation in Joy. We need to combine the token from user-input and the default theme first, then generate
-     * variants from those tokens.
+     * This is useful for controlling nested CssVarsProvider behavior.
+     * @default false
      */
-    resolveTheme?: (theme: any) => any; // the type is any because it depends on the design system.
-  },
-): CreateCssVarsProviderResult<ColorScheme, Identifier>;
+    disableStyleSheetGeneration?: boolean;
+  }>) => React.JSX.Element;
+  useColorScheme: () => ColorSchemeContextValue<ColorScheme>;
+  getInitColorSchemeScript: typeof InitColorSchemeScript;
+}
+export default function createCssVarsProvider<ColorScheme extends string, Identifier extends string | undefined = undefined>(options: CssVarsProviderConfig<ColorScheme> & {
+  /**
+   * The design system's unique id for getting the corresponded theme when there are multiple design systems.
+   */
+  themeId?: Identifier;
+  /**
+   * Design system default theme
+   *
+   * - The structure inside `theme.colorSchemes[colorScheme]` should be exactly the same in all color schemes because
+   * those object of the color scheme will be used when the color scheme is active.
+   *
+   *  {
+   *    colorSchemes: {
+   *      light: { ...lightColorSchemeValues },
+   *      dark: { ...darkColorSchemeValues }
+   *    }
+   *  }
+   *
+   * - If colorScheme is 'light', the `lightColorSchemeValues` will be merged to theme as `{ ...theme, ...lightColorSchemeValues }`
+   *   likewise, if colorScheme is 'dark', the `darkColorSchemeValues` will be merged to theme as `{ ...theme, ...darkColorSchemeValues }`
+   *
+   * - If the theme contains the same keys as the color scheme, their values will be merged.
+   *  Ex. {
+   *    colorSchemes: {
+   *      light: { palette: { primary: { ... } } },
+   *      dark: { palette: { primary: { ...} } }
+   *    },
+   *    palette: { shared: { ... } }
+   *  }
+   *
+   *  becomes: {
+   *    colorSchemes: { ... },
+   *    palette: { shared: { ... }, primary: { ... } }
+   *  }
+   */
+  theme: any;
+  /**
+   * A function to be called after the CSS variables are attached. The result of this function will be the final theme pass to ThemeProvider.
+   *
+   * The example usage is the variant generation in Joy. We need to combine the token from user-input and the default theme first, then generate
+   * variants from those tokens.
+   */
+  resolveTheme?: (theme: any) => any; // the type is any because it depends on the design system.
+}): CreateCssVarsProviderResult<ColorScheme, Identifier>;
 
 // disable automatic export
-export {};
+export {};

package/cssVars/createCssVarsTheme.d.ts

@@ -1,12 +1,15 @@
-import { DefaultCssVarsTheme } from './prepareCssVars';
+import { DefaultCssVarsTheme } from "./prepareCssVars.js";
 interface Theme extends DefaultCssVarsTheme {
-    cssVarPrefix?: string;
-    colorSchemeSelector?: 'media' | string;
-    shouldSkipGeneratingVar?: (objectPathKeys: Array<string>, value: string | number) => boolean;
+  cssVarPrefix?: string;
+  colorSchemeSelector?: 'media' | string;
+  shouldSkipGeneratingVar?: (objectPathKeys: Array<string>, value: string | number) => boolean;
 }
-declare function createCssVarsTheme<T extends Theme, ThemeVars extends Record<string, any>>({ colorSchemeSelector, ...theme }: T): T & {
-    vars: ThemeVars;
-    generateThemeVars: () => ThemeVars;
-    generateStyleSheets: () => Record<string, any>[];
+declare function createCssVarsTheme<T extends Theme, ThemeVars extends Record<string, any>>({
+  colorSchemeSelector,
+  ...theme
+}: T): T & {
+  vars: ThemeVars;
+  generateThemeVars: () => ThemeVars;
+  generateStyleSheets: () => Record<string, any>[];
 };
-export default createCssVarsTheme;
+export default createCssVarsTheme;

package/cssVars/createGetCssVar.d.ts

@@ -2,4 +2,4 @@
  * The benefit of this function is to help developers get CSS var from theme without specifying the whole variable
  * and they does not need to remember the prefix (defined once).
  */
-export default function createGetCssVar<T extends string = string>(prefix?: string): <AdditionalVars extends string = never>(field: T | AdditionalVars, ...fallbacks: (T | AdditionalVars)[]) => string;
+export default function createGetCssVar<T extends string = string>(prefix?: string): <AdditionalVars extends string = never>(field: T | AdditionalVars, ...fallbacks: (T | AdditionalVars)[]) => string;

package/cssVars/cssVarsParser.d.ts

@@ -1,5 +1,5 @@
 type NestedRecord<V = any> = {
-    [k: string | number]: NestedRecord<V> | V;
+  [k: string | number]: NestedRecord<V> | V;
 };
 /**
  * This function create an object from keys, value and then assign to target
@@ -54,11 +54,11 @@ export declare const walkObjectDeep: <Value, T = Record<string, any>>(obj: T, ca
  * console.log(vars) // { fontSize: 'var(--foo-fontSize)', lineHeight: 'var(--foo-lineHeight)', palette: { primary: { 500: 'var(--foo-palette-primary-500)' } } }
  */
 export default function cssVarsParser<T extends Record<string, any>>(theme: Record<string, any>, options?: {
-    prefix?: string;
-    shouldSkipGeneratingVar?: (objectPathKeys: Array<string>, value: string | number) => boolean;
+  prefix?: string;
+  shouldSkipGeneratingVar?: (objectPathKeys: Array<string>, value: string | number) => boolean;
 }): {
-    css: Record<string, string | number>;
-    vars: T;
-    varsWithDefaults: {};
+  css: Record<string, string | number>;
+  vars: T;
+  varsWithDefaults: {};
 };
-export {};
+export {};

package/cssVars/getColorSchemeSelector.d.ts

@@ -1 +1 @@
-export declare function createGetColorSchemeSelector<T extends string>(selector: 'media' | 'class' | 'data' | string): (colorScheme: T) => string;
+export declare function createGetColorSchemeSelector<T extends string>(selector: 'media' | 'class' | 'data' | string): (colorScheme: T) => string;

package/cssVars/index.d.ts

@@ -1,7 +1,7 @@
-export { default } from './createCssVarsProvider';
-export type { CreateCssVarsProviderResult, CssVarsProviderConfig, ColorSchemeContextValue, } from './createCssVarsProvider';
-export { default as prepareCssVars } from './prepareCssVars';
-export { default as prepareTypographyVars } from './prepareTypographyVars';
-export type { ExtractTypographyTokens } from './prepareTypographyVars';
-export { default as createCssVarsTheme } from './createCssVarsTheme';
-export { createGetColorSchemeSelector } from './getColorSchemeSelector';
+export { default } from "./createCssVarsProvider.js";
+export type { CreateCssVarsProviderResult, CssVarsProviderConfig, ColorSchemeContextValue } from "./createCssVarsProvider.js";
+export { default as prepareCssVars } from "./prepareCssVars.js";
+export { default as prepareTypographyVars } from "./prepareTypographyVars.js";
+export type { ExtractTypographyTokens } from "./prepareTypographyVars.js";
+export { default as createCssVarsTheme } from "./createCssVarsTheme.js";
+export { createGetColorSchemeSelector } from "./getColorSchemeSelector.js";

package/cssVars/prepareCssVars.d.ts

@@ -1,16 +1,16 @@
 export interface DefaultCssVarsTheme {
-    colorSchemes?: Record<string, any>;
-    defaultColorScheme?: string;
+  colorSchemes?: Record<string, any>;
+  defaultColorScheme?: string;
 }
 declare function prepareCssVars<T extends DefaultCssVarsTheme, ThemeVars extends Record<string, any>>(theme: T, parserConfig?: {
-    prefix?: string;
-    colorSchemeSelector?: 'media' | 'class' | 'data' | string;
-    disableCssColorScheme?: boolean;
-    shouldSkipGeneratingVar?: (objectPathKeys: Array<string>, value: string | number) => boolean;
-    getSelector?: (colorScheme: keyof T['colorSchemes'] | undefined, css: Record<string, any>) => string | Record<string, any>;
+  prefix?: string;
+  colorSchemeSelector?: 'media' | 'class' | 'data' | string;
+  disableCssColorScheme?: boolean;
+  shouldSkipGeneratingVar?: (objectPathKeys: Array<string>, value: string | number) => boolean;
+  getSelector?: (colorScheme: keyof T['colorSchemes'] | undefined, css: Record<string, any>) => string | Record<string, any>;
 }): {
-    vars: ThemeVars;
-    generateThemeVars: () => ThemeVars;
-    generateStyleSheets: () => Record<string, any>[];
+  vars: ThemeVars;
+  generateThemeVars: () => ThemeVars;
+  generateStyleSheets: () => Record<string, any>[];
 };
-export default prepareCssVars;
+export default prepareCssVars;

package/cssVars/prepareTypographyVars.d.ts

@@ -1,8 +1,4 @@
-type RecordPropertyNames<T> = {
-    [K in keyof T]: T[K] extends Function ? never : T[K] extends Record<string, any> ? K : never;
-}[keyof T];
-export type ExtractTypographyTokens<T> = {
-    [K in RecordPropertyNames<T>]: string;
-};
+type RecordPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? never : T[K] extends Record<string, any> ? K : never }[keyof T];
+export type ExtractTypographyTokens<T> = { [K in RecordPropertyNames<T>]: string };
 export default function prepareTypographyVars<T extends Record<string, any>>(typography: T): ExtractTypographyTokens<T>;
-export {};
+export {};

package/cssVars/useCurrentColorScheme.d.ts

@@ -1,54 +1,54 @@
 export type Mode = 'light' | 'dark' | 'system';
 export type SystemMode = Exclude<Mode, 'system'>;
 export interface State<SupportedColorScheme extends string> {
-    /**
-     * User selected mode.
-     * Note: on the server, mode is always undefined
-     */
-    mode: 'light' | 'dark' | 'system' | undefined;
-    /**
-     * Only valid if `mode: 'system'`, either 'light' | 'dark'.
-     */
-    systemMode: 'light' | 'dark' | undefined;
-    /**
-     * The color scheme for the light mode.
-     */
-    lightColorScheme: SupportedColorScheme;
-    /**
-     * The color scheme for the dark mode.
-     */
-    darkColorScheme: SupportedColorScheme;
+  /**
+   * User selected mode.
+   * Note: on the server, mode is always undefined
+   */
+  mode: 'light' | 'dark' | 'system' | undefined;
+  /**
+   * Only valid if `mode: 'system'`, either 'light' | 'dark'.
+   */
+  systemMode: 'light' | 'dark' | undefined;
+  /**
+   * The color scheme for the light mode.
+   */
+  lightColorScheme: SupportedColorScheme;
+  /**
+   * The color scheme for the dark mode.
+   */
+  darkColorScheme: SupportedColorScheme;
 }
 export type Result<SupportedColorScheme extends string> = State<SupportedColorScheme> & {
-    /**
-     * The current application color scheme. It is always `undefined` on the server.
-     */
-    colorScheme: SupportedColorScheme | undefined;
-    /**
-     * `mode` is saved to internal state and localStorage
-     * If `mode` is null, it will be reset to the defaultMode
-     */
-    setMode: (mode: Mode | null) => void;
-    /**
-     * `colorScheme` is saved to internal state and localStorage
-     * If `colorScheme` is null, it will be reset to the defaultColorScheme (light | dark)
-     */
-    setColorScheme: (colorScheme: SupportedColorScheme | Partial<{
-        light: SupportedColorScheme | null;
-        dark: SupportedColorScheme | null;
-    }> | null) => void;
+  /**
+   * The current application color scheme. It is always `undefined` on the server.
+   */
+  colorScheme: SupportedColorScheme | undefined;
+  /**
+   * `mode` is saved to internal state and localStorage
+   * If `mode` is null, it will be reset to the defaultMode
+   */
+  setMode: (mode: Mode | null) => void;
+  /**
+   * `colorScheme` is saved to internal state and localStorage
+   * If `colorScheme` is null, it will be reset to the defaultColorScheme (light | dark)
+   */
+  setColorScheme: (colorScheme: SupportedColorScheme | Partial<{
+    light: SupportedColorScheme | null;
+    dark: SupportedColorScheme | null;
+  }> | null) => void;
 };
 export declare function getSystemMode(mode: undefined | string): SystemMode | undefined;
 export declare function getColorScheme<SupportedColorScheme extends string>(state: State<SupportedColorScheme>): SupportedColorScheme | undefined;
 interface UseCurrentColoSchemeOptions<SupportedColorScheme extends string> {
-    defaultLightColorScheme: SupportedColorScheme;
-    defaultDarkColorScheme: SupportedColorScheme;
-    supportedColorSchemes: Array<SupportedColorScheme>;
-    defaultMode?: Mode;
-    modeStorageKey?: string;
-    colorSchemeStorageKey?: string;
-    storageWindow?: Window | null;
-    noSsr?: boolean;
+  defaultLightColorScheme: SupportedColorScheme;
+  defaultDarkColorScheme: SupportedColorScheme;
+  supportedColorSchemes: Array<SupportedColorScheme>;
+  defaultMode?: Mode;
+  modeStorageKey?: string;
+  colorSchemeStorageKey?: string;
+  storageWindow?: Window | null;
+  noSsr?: boolean;
 }
 export default function useCurrentColorScheme<SupportedColorScheme extends string>(options: UseCurrentColoSchemeOptions<SupportedColorScheme>): Result<SupportedColorScheme>;
-export {};
+export {};

package/display/display.d.ts

@@ -1,3 +1,2 @@
-import { PropsFor, display } from '../Box';
-
-export type DisplayProps = PropsFor<typeof display>;
+import { PropsFor, display } from "../Box/index.js";
+export type DisplayProps = PropsFor<typeof display>;

package/display/index.d.ts

@@ -1,2 +1,2 @@
-export { default } from './display';
-export * from './display';
+export { default } from "./display.js";
+export * from "./display.js";