@fluentui/react-utilities 9.0.0-alpha.9 → 9.0.0-beta.4

package/lib/compose/getSlots.js

@@ -1,11 +1,11 @@
 import * as React from 'react';
-import { getNativeElementProps, omit } from '../utils/index';
 import { nullRender } from './nullRender';
+import { omit } from '../utils/omit';
 /**
  * Given the state and an array of slot names, will break out `slots` and `slotProps`
  * collections.
  *
- * The root is always derived from the `as` prop.
+ * The root is derived from a mix of `components` props and `as` prop.
  *
  * Slots will render as null if they are rendered as primitives with undefined children.
  *
@@ -17,34 +17,46 @@ import { nullRender } from './nullRender';
  * @param slotNames - Name of which props are slots
  * @returns An object containing the `slots` map and `slotProps` map.
  */
-export var getSlots = function (state, slotNames) {
-    var slots = {
-        root: state.as || 'div',
-    };
-    var slotProps = {
-        root: typeof slots.root === 'string' ? getNativeElementProps(slots.root, state) : omit(state, ['as']),
-    };
-    if (slotNames) {
-        for (var _i = 0, slotNames_1 = slotNames; _i < slotNames_1.length; _i++) {
-            var name_1 = slotNames_1[_i];
-            var slotDefinition = state[name_1] || {};
-            var _a = slotDefinition.as, slotAs = _a === void 0 ? 'span' : _a, children = slotDefinition.children;
-            var isSlotPrimitive = typeof slotAs === 'string';
-            var isSlotEmpty = isSlotPrimitive && slotDefinition.children === undefined;
-            slots[name_1] = isSlotEmpty ? nullRender : slotAs;
-            if (typeof children === 'function') {
-                slotProps[name_1] = {
-                    children: children(slots[name_1], omit(slotDefinition, ['as', 'children'])),
-                };
-                slots[name_1] = React.Fragment;
-            }
-            else if (slots[name_1] !== nullRender) {
-                slotProps[name_1] = isSlotPrimitive
-                    ? getNativeElementProps(slotAs, slotDefinition)
-                    : omit(slotDefinition, ['as']);
-            }
-        }
-    }
-    return { slots: slots, slotProps: slotProps };
-};
+
+export function getSlots(state, slotNames = ['root']) {
+  const slots = {};
+  const slotProps = {};
+
+  for (const slotName of slotNames) {
+    const [slot, props] = getSlot(state, slotName);
+    slots[slotName] = slot;
+    slotProps[slotName] = props;
+  }
+
+  return {
+    slots,
+    slotProps: slotProps
+  };
+}
+
+function getSlot(state, slotName) {
+  var _a, _b, _c;
+
+  if (state[slotName] === undefined) {
+    return [nullRender, undefined];
+  }
+
+  const {
+    children,
+    as: asProp,
+    ...rest
+  } = state[slotName];
+  const slot = ((_a = state.components) === null || _a === void 0 ? void 0 : _a[slotName]) === undefined || typeof state.components[slotName] === 'string' ? asProp || ((_b = state.components) === null || _b === void 0 ? void 0 : _b[slotName]) || 'div' : state.components[slotName];
+
+  if (typeof children === 'function') {
+    const render = children;
+    return [React.Fragment, {
+      children: render(slot, rest)
+    }];
+  }
+
+  const shouldOmitAsProp = typeof slot === 'string' && ((_c = state[slotName]) === null || _c === void 0 ? void 0 : _c.as);
+  const slotProps = shouldOmitAsProp ? omit(state[slotName], ['as']) : state[slotName];
+  return [slot, slotProps];
+}
 //# sourceMappingURL=getSlots.js.map

package/lib/compose/getSlots.js.map

@@ -1 +1 @@
-{"version":3,"file":"getSlots.js","sourceRoot":"../src/","sources":["compose/getSlots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAE,qBAAqB,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAE7D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,IAAM,QAAQ,GAAG,UAAC,KAAwB,EAAE,SAAgC;IACjF,IAAM,KAAK,GAAsB;QAC/B,IAAI,EAAE,KAAK,CAAC,EAAE,IAAI,KAAK;KACxB,CAAC;IAEF,IAAM,SAAS,GAAsB;QACnC,IAAI,EAAE,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,qBAAqB,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,CAAC;KACtG,CAAC;IAEF,IAAI,SAAS,EAAE;QACb,KAAmB,UAAS,EAAT,uBAAS,EAAT,uBAAS,EAAT,IAAS,EAAE;YAAzB,IAAM,MAAI,kBAAA;YACb,IAAM,cAAc,GAAG,KAAK,CAAC,MAAI,CAAC,IAAI,EAAE,CAAC;YACjC,IAAA,sBAAmB,EAAnB,oCAAmB,EAAE,kCAAQ,CAAoB;YACzD,IAAM,eAAe,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC;YACnD,IAAM,WAAW,GAAG,eAAe,IAAI,cAAc,CAAC,QAAQ,KAAK,SAAS,CAAC;YAE7E,KAAK,CAAC,MAAI,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC;YAEhD,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE;gBAClC,SAAS,CAAC,MAAI,CAAC,GAAG;oBAChB,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,MAAI,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC;iBAC1E,CAAC;gBACF,KAAK,CAAC,MAAI,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC;aAC9B;iBAAM,IAAI,KAAK,CAAC,MAAI,CAAC,KAAK,UAAU,EAAE;gBACrC,SAAS,CAAC,MAAI,CAAC,GAAG,eAAe;oBAC/B,CAAC,CAAC,qBAAqB,CAAC,MAAM,EAAE,cAAc,CAAC;oBAC/C,CAAC,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;aAClC;SACF;KACF;IAED,OAAO,EAAE,KAAK,OAAA,EAAE,SAAS,WAAA,EAAE,CAAC;AAC9B,CAAC,CAAC","sourcesContent":["import * as React from 'react';\n\nimport { getNativeElementProps, omit } from '../utils/index';\nimport { GenericDictionary } from './types';\nimport { nullRender } from './nullRender';\n\n/**\n * Given the state and an array of slot names, will break out `slots` and `slotProps`\n * collections.\n *\n * The root is always derived from the `as` prop.\n *\n * Slots will render as null if they are rendered as primitives with undefined children.\n *\n * The slotProps will always omit the `as` prop within them, and for slots that are string\n * primitives, the props will be filtered according the the slot type. For example, if the\n * slot is rendered `as: 'a'`, the props will be filtered for acceptable anchor props.\n *\n * @param state - State including slot definitions\n * @param slotNames - Name of which props are slots\n * @returns An object containing the `slots` map and `slotProps` map.\n */\nexport const getSlots = (state: GenericDictionary, slotNames?: string[] | undefined) => {\n  const slots: GenericDictionary = {\n    root: state.as || 'div',\n  };\n\n  const slotProps: GenericDictionary = {\n    root: typeof slots.root === 'string' ? getNativeElementProps(slots.root, state) : omit(state, ['as']),\n  };\n\n  if (slotNames) {\n    for (const name of slotNames) {\n      const slotDefinition = state[name] || {};\n      const { as: slotAs = 'span', children } = slotDefinition;\n      const isSlotPrimitive = typeof slotAs === 'string';\n      const isSlotEmpty = isSlotPrimitive && slotDefinition.children === undefined;\n\n      slots[name] = isSlotEmpty ? nullRender : slotAs;\n\n      if (typeof children === 'function') {\n        slotProps[name] = {\n          children: children(slots[name], omit(slotDefinition, ['as', 'children'])),\n        };\n        slots[name] = React.Fragment;\n      } else if (slots[name] !== nullRender) {\n        slotProps[name] = isSlotPrimitive\n          ? getNativeElementProps(slotAs, slotDefinition)\n          : omit(slotDefinition, ['as']);\n      }\n    }\n  }\n\n  return { slots, slotProps };\n};\n"]}
+{"version":3,"sources":["../../src/compose/getSlots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AAUA,SAAS,UAAT,QAA2B,cAA3B;AACA,SAAS,IAAT,QAAqB,eAArB;AAqBA;;;;;;;;;;;;;;;AAeG;;AACH,OAAM,SAAU,QAAV,CACJ,KADI,EAEJ,SAAA,GAAyB,CAAC,MAAD,CAFrB,EAE6B;AAKjC,QAAM,KAAK,GAAG,EAAd;AACA,QAAM,SAAS,GAAG,EAAlB;;AAEA,OAAK,MAAM,QAAX,IAAuB,SAAvB,EAAkC;AAChC,UAAM,CAAC,IAAD,EAAO,KAAP,IAAgB,OAAO,CAAC,KAAD,EAAQ,QAAR,CAA7B;AACA,IAAA,KAAK,CAAC,QAAD,CAAL,GAAkB,IAAlB;AACA,IAAA,SAAS,CAAC,QAAD,CAAT,GAAsB,KAAtB;AACD;;AACD,SAAO;AAAE,IAAA,KAAF;AAAS,IAAA,SAAS,EAAG;AAArB,GAAP;AACD;;AAED,SAAS,OAAT,CACE,KADF,EAEE,QAFF,EAEa;;;AAEX,MAAI,KAAK,CAAC,QAAD,CAAL,KAAoB,SAAxB,EAAmC;AACjC,WAAO,CAAC,UAAD,EAAa,SAAb,CAAP;AACD;;AACD,QAAM;AAAE,IAAA,QAAF;AAAY,IAAA,EAAE,EAAE,MAAhB;AAAwB,OAAG;AAA3B,MAAoC,KAAK,CAAC,QAAD,CAA/C;AAEA,QAAM,IAAI,GAAI,CAAA,CAAA,EAAA,GAAA,KAAK,CAAC,UAAN,MAAgB,IAAhB,IAAgB,EAAA,KAAA,KAAA,CAAhB,GAAgB,KAAA,CAAhB,GAAgB,EAAA,CAAG,QAAH,CAAhB,MAAiC,SAAjC,IAA8C,OAAO,KAAK,CAAC,UAAN,CAAiB,QAAjB,CAAP,KAAsC,QAApF,GACV,MAAM,KAAA,CAAA,EAAA,GAAI,KAAK,CAAC,UAAV,MAAoB,IAApB,IAAoB,EAAA,KAAA,KAAA,CAApB,GAAoB,KAAA,CAApB,GAAoB,EAAA,CAAG,QAAH,CAApB,CAAN,IAA0C,KADhC,GAEV,KAAK,CAAC,UAAN,CAAiB,QAAjB,CAFJ;;AAIA,MAAI,OAAO,QAAP,KAAoB,UAAxB,EAAoC;AAClC,UAAM,MAAM,GAAG,QAAf;AACA,WAAO,CACL,KAAK,CAAC,QADD,EAEJ;AACC,MAAA,QAAQ,EAAE,MAAM,CAAC,IAAD,EAAO,IAAP;AADjB,KAFI,CAAP;AAMD;;AAED,QAAM,gBAAgB,GAAG,OAAO,IAAP,KAAgB,QAAhB,KAAwB,CAAA,EAAA,GAAI,KAAK,CAAC,QAAD,CAAT,MAAmB,IAAnB,IAAmB,EAAA,KAAA,KAAA,CAAnB,GAAmB,KAAA,CAAnB,GAAmB,EAAA,CAAE,EAA7C,CAAzB;AACA,QAAM,SAAS,GAAI,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,QAAD,CAAN,EAAmB,CAAC,IAAD,CAAnB,CAAP,GAAoC,KAAK,CAAC,QAAD,CAA5E;AAEA,SAAO,CAAC,IAAD,EAAO,SAAP,CAAP;AACD","sourceRoot":""}

package/lib/compose/index.d.ts

@@ -1,5 +1,4 @@
 export * from './getSlots';
-export * from './makeMergeProps';
 export * from './nullRender';
-export * from './resolveShorthandProps';
+export * from './resolveShorthand';
 export * from './types';

package/lib/compose/index.js

@@ -1,5 +1,5 @@
 export * from './getSlots';
-export * from './makeMergeProps';
 export * from './nullRender';
-export * from './resolveShorthandProps';
+export * from './resolveShorthand';
+export * from './types';
 //# sourceMappingURL=index.js.map

package/lib/compose/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"../src/","sources":["compose/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC","sourcesContent":["export * from './getSlots';\nexport * from './makeMergeProps';\nexport * from './nullRender';\nexport * from './resolveShorthandProps';\nexport * from './types';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/compose/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,SAAS,CAAC"}

package/lib/compose/nullRender.js

@@ -1,5 +1,5 @@
 /**
  * Simple constant function for returning null, used to render empty templates in JSX.
  */
-export var nullRender = function () { return null; };
+export const nullRender = () => null;
 //# sourceMappingURL=nullRender.js.map

package/lib/compose/nullRender.js.map

@@ -1 +1 @@
-{"version":3,"file":"nullRender.js","sourceRoot":"../src/","sources":["compose/nullRender.tsx"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,IAAM,UAAU,GAAG,cAAM,OAAA,IAAI,EAAJ,CAAI,CAAC","sourcesContent":["/**\n * Simple constant function for returning null, used to render empty templates in JSX.\n */\nexport const nullRender = () => null;\n"]}
+{"version":3,"file":"nullRender.js","sourceRoot":"","sources":["../../src/compose/nullRender.tsx"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC"}

package/lib/compose/resolveShorthand.d.ts

@@ -0,0 +1,12 @@
+import type { DefaultObjectShorthandProps, ShorthandProps } from './types';
+export declare type ResolveShorthandOptions<Props extends Record<string, any>, Required extends boolean = false> = {
+    required?: Required;
+    defaultProps?: Props;
+};
+/**
+ * Resolves ShorthandProps into ObjectShorthandProps, to ensure normalization of the signature
+ * being passed down to getSlots method
+ * @param value - the base ShorthandProps
+ * @param options - options to resolve ShorthandProps
+ */
+export declare function resolveShorthand<Props extends DefaultObjectShorthandProps, Required extends boolean = false>(value: ShorthandProps<Props>, options?: ResolveShorthandOptions<Props, Required>): Required extends false ? Props | undefined : Props;

package/lib/compose/resolveShorthand.js

@@ -0,0 +1,31 @@
+import { isValidElement } from 'react';
+/**
+ * Resolves ShorthandProps into ObjectShorthandProps, to ensure normalization of the signature
+ * being passed down to getSlots method
+ * @param value - the base ShorthandProps
+ * @param options - options to resolve ShorthandProps
+ */
+
+export function resolveShorthand(value, options) {
+  const {
+    required = false,
+    defaultProps
+  } = options || {};
+
+  if (value === null || value === undefined && !required) {
+    return undefined;
+  }
+
+  let resolvedShorthand = {};
+
+  if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value) || /*#__PURE__*/isValidElement(value)) {
+    resolvedShorthand.children = value;
+  } else if (typeof value === 'object') {
+    resolvedShorthand = value;
+  }
+
+  return defaultProps ? { ...defaultProps,
+    ...resolvedShorthand
+  } : resolvedShorthand;
+}
+//# sourceMappingURL=resolveShorthand.js.map

package/lib/compose/resolveShorthand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/compose/resolveShorthand.ts"],"names":[],"mappings":"AAAA,SAAS,cAAT,QAA+B,OAA/B;AASA;;;;;AAKG;;AACH,OAAM,SAAU,gBAAV,CACJ,KADI,EAEJ,OAFI,EAE8C;AAElD,QAAM;AAAE,IAAA,QAAQ,GAAG,KAAb;AAAoB,IAAA;AAApB,MAAqC,OAAO,IAAI,EAAtD;;AACA,MAAI,KAAK,KAAK,IAAV,IAAmB,KAAK,KAAK,SAAV,IAAuB,CAAC,QAA/C,EAA0D;AACxD,WAAO,SAAP;AACD;;AAED,MAAI,iBAAiB,GAAG,EAAxB;;AAEA,MAAI,OAAO,KAAP,KAAiB,QAAjB,IAA6B,OAAO,KAAP,KAAiB,QAA9C,IAA0D,KAAK,CAAC,OAAN,CAAc,KAAd,CAA1D,iBAAkF,cAAc,CAAC,KAAD,CAApG,EAA6G;AAC3G,IAAA,iBAAiB,CAAC,QAAlB,GAA6B,KAA7B;AACD,GAFD,MAEO,IAAI,OAAO,KAAP,KAAiB,QAArB,EAA+B;AACpC,IAAA,iBAAiB,GAAG,KAApB;AACD;;AAED,SAAQ,YAAY,GAAG,EAAE,GAAG,YAAL;AAAmB,OAAG;AAAtB,GAAH,GAA+C,iBAAnE;AAGD","sourceRoot":""}

package/lib/compose/types.d.ts

@@ -1,29 +1,103 @@
 import * as React from 'react';
+export declare type ShorthandRenderFunction<Props> = (Component: React.ElementType<Props>, props: Omit<Props, 'children' | 'as'>) => React.ReactNode;
+export declare type ObjectShorthandPropsRecord = Record<string, DefaultObjectShorthandProps | undefined>;
+export declare type ShorthandProps<Props extends DefaultObjectShorthandProps> = React.ReactChild | React.ReactNodeArray | React.ReactPortal | number | null | undefined | Props;
 /**
- * Generic name to any dictionary.
+ * Matches any shorthand props type.
+ *
+ * This should ONLY be used in type templates as in `extends DefaultObjectShorthandProps`;
+ * it shouldn't be used as the type of a slot.
  */
-export declare type GenericDictionary = Record<string, any>;
+export declare type DefaultObjectShorthandProps = ObjectShorthandProps<Pick<React.HTMLAttributes<HTMLElement>, 'children' | 'className' | 'style'> & {
+    as?: keyof JSX.IntrinsicElements;
+}>;
 /**
- * Class dictionary.
+ * Defines the slot props for a slot that supports a Component type.
+ *
+ * For intrinsic elements like 'div', use {@link IntrinsicShorthandProps} instead.
  */
-export declare type ClassDictionary = Record<string, string>;
-export interface ComponentProps {
-    as?: React.ElementType;
-    className?: string;
+export declare type ObjectShorthandProps<Props extends {
     children?: React.ReactNode;
-}
-export declare type ShorthandRenderFunction<TProps> = (Component: React.ElementType<TProps>, props: TProps) => React.ReactNode;
-export declare type ShorthandProps<TProps extends ComponentProps = {}> = React.ReactChild | React.ReactNodeArray | React.ReactPortal | boolean | number | null | undefined | (TProps & ComponentProps & {
-    children?: TProps['children'] | ShorthandRenderFunction<TProps>;
-});
-export declare type ObjectShorthandProps<TProps extends ComponentProps = {}> = TProps & {
-    children?: TProps['children'] | ShorthandRenderFunction<TProps>;
+} = {}> = Props & {
+    children?: Props['children'] | ShorthandRenderFunction<Props>;
 };
-export interface BaseSlots {
-    root: React.ElementType;
-}
-export declare type SlotProps<TSlots extends BaseSlots, TProps, TRootProps extends React.HTMLAttributes<HTMLElement>> = {
-    [key in keyof Omit<TSlots, 'root'>]: key extends keyof TProps ? TProps[key] : any;
-} & {
-    root: TRootProps;
+/**
+ * Define the slot arguments for a slot that supports one or more intrinsic element types, such as 'div'.
+ * For slots that support custom components, use {@link ObjectShorthandProps} instead.
+ *
+ * The first param is the slot's default type if no `as` prop is specified.
+ * The second param is an optional union of alternative types that can be specified for the `as` prop.
+ *
+ * ```
+ * IntrinsicShorthandProps<'div'> // Slot is always div
+ * IntrinsicShorthandProps<'button', 'a'> // Defaults to button, but allows as="a" with anchor-specific props
+ * IntrinsicShorthandProps<'label', 'span' | 'div'>; // Defaults to label, but allows as="span" or as="div"
+ * ```
+ */
+export declare type IntrinsicShorthandProps<DefaultAs extends keyof JSX.IntrinsicElements, AlternateAs extends keyof JSX.IntrinsicElements = never> = IsSingleton<DefaultAs> extends false ? 'Error: first parameter to IntrinsicShorthandProps must be a single element type, not a union of types' : ({
+    as?: DefaultAs;
+} & ObjectShorthandProps<React.PropsWithRef<JSX.IntrinsicElements[DefaultAs]>>) | {
+    [As in AlternateAs]: {
+        as: As;
+    } & ObjectShorthandProps<React.PropsWithRef<JSX.IntrinsicElements[As]>>;
+}[AlternateAs];
+/**
+ * Evaluates to true if the given type contains exactly one string, or false if it is a union of strings.
+ *
+ * ```
+ * IsSingleton<'a'> // true
+ * IsSingleton<'a' | 'b' | 'c'> // false
+ * ```
+ */
+export declare type IsSingleton<T extends string> = {
+    [K in T]: Exclude<T, K> extends never ? true : false;
+}[T];
+/**
+ * Helper type for inferring the type of the as prop from a Props type.
+ *
+ * For example:
+ * ```
+ * type Example<T> = T extends AsIntrinsicElement<infer As> ? As : never;
+ * ```
+ */
+export declare type AsIntrinsicElement<As extends keyof JSX.IntrinsicElements> = {
+    as?: As;
 };
+/**
+ * Converts a union type (`A | B | C`) to an intersection type (`A & B & C`)
+ */
+export declare type UnionToIntersection<U> = (U extends unknown ? (x: U) => U : never) extends (x: infer I) => U ? I : never;
+/**
+ * Removes the 'ref' prop from the given Props type, leaving unions intact (such as the discriminated union created by
+ * IntrinsicShorthandProps). This allows IntrinsicShorthandProps to be used with React.forwardRef.
+ *
+ * The conditional "extends unknown" (always true) exploits a quirk in the way TypeScript handles conditional
+ * types, to prevent unions from being expanded.
+ */
+export declare type PropsWithoutRef<P> = 'ref' extends keyof P ? (P extends unknown ? Omit<P, 'ref'> : P) : P;
+export declare type ComponentProps<Shorthands extends ObjectShorthandPropsRecord, Primary extends keyof Shorthands = 'root'> = Omit<{
+    [Key in keyof Shorthands]?: ShorthandProps<NonNullable<Shorthands[Key]>>;
+}, Primary & 'root'> & PropsWithoutRef<Shorthands[Primary]>;
+export declare type ComponentState<Shorthands extends ObjectShorthandPropsRecord> = {
+    components?: {
+        [Key in keyof Shorthands]-?: React.ComponentType<NonNullable<Shorthands[Key]> extends ObjectShorthandProps<infer P> ? P : NonNullable<Shorthands[Key]>> | (NonNullable<Shorthands[Key]> extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);
+    };
+} & Shorthands;
+/**
+ * This is part of a hack to infer the element type from a native element *props* type.
+ * The only place the original element is found in a native props type (at least that's workable
+ * for inference) is in the event handlers, so some of the helper types use this event handler
+ * name to infer the original element type.
+ *
+ * Notes:
+ * - Using an extremely obscure event handler reduces the likelihood that its signature will be
+ *   modified in any component's props.
+ * - Inferring based on a single prop name instead of a larger type like `DOMAttributes<T>` should be
+ *   less expensive for typescript to evaluate and is less likely to result in type expansion in .d.ts.
+ */
+declare type ObscureEventName = 'onLostPointerCaptureCapture';
+/**
+ * Return type for `React.forwardRef`, including inference of the proper typing for the ref.
+ */
+export declare type ForwardRefComponent<Props> = ObscureEventName extends keyof Props ? Required<Props>[ObscureEventName] extends React.PointerEventHandler<infer Element> ? React.ForwardRefExoticComponent<Props & React.RefAttributes<Element>> : never : never;
+export {};

package/lib/compose/types.js

@@ -1 +1,6 @@
+export {}; // A definition like this would also work, but typescript is more likely to unnecessarily expand
+// the props type with this version (and it's likely much more expensive to evaluate)
+// export type ForwardRefComponent<Props> = Props extends React.DOMAttributes<infer Element>
+//   ? React.ForwardRefExoticComponent<Props> & React.RefAttributes<Element>
+//   : never;
 //# sourceMappingURL=types.js.map

package/lib/compose/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"../src/","sources":["compose/types.ts"],"names":[],"mappings":"","sourcesContent":["import * as React from 'react';\n\n/**\n * Generic name to any dictionary.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type GenericDictionary = Record<string, any>;\n\n/**\n * Class dictionary.\n */\nexport type ClassDictionary = Record<string, string>;\n\nexport interface ComponentProps {\n  as?: React.ElementType;\n  className?: string;\n  children?: React.ReactNode;\n}\n\n// Shorthand types\n\nexport type ShorthandRenderFunction<TProps> = (Component: React.ElementType<TProps>, props: TProps) => React.ReactNode;\n\nexport type ShorthandProps<TProps extends ComponentProps = {}> =\n  | React.ReactChild\n  | React.ReactNodeArray\n  | React.ReactPortal\n  | boolean\n  | number\n  | null\n  | undefined\n  | (TProps &\n      ComponentProps & {\n        children?: TProps['children'] | ShorthandRenderFunction<TProps>;\n      });\n\nexport type ObjectShorthandProps<TProps extends ComponentProps = {}> = TProps & {\n  children?: TProps['children'] | ShorthandRenderFunction<TProps>;\n};\n\nexport interface BaseSlots {\n  root: React.ElementType;\n}\n\nexport type SlotProps<TSlots extends BaseSlots, TProps, TRootProps extends React.HTMLAttributes<HTMLElement>> = {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [key in keyof Omit<TSlots, 'root'>]: key extends keyof TProps ? TProps[key] : any;\n} & {\n  root: TRootProps;\n};\n"]}
+{"version":3,"sources":["../../src/compose/types.ts"],"names":[],"mappings":"WAgJA;AACA;AACA;AACA;AACA","sourceRoot":""}

package/lib/hooks/index.d.ts

@@ -1,8 +1,16 @@
+export * from './useControllableState';
 export * from './useBoolean';
 export * from './useConst';
 export * from './useControllableValue';
 export * from './useEventCallback';
-export { useId } from './useId';
+export * from './useFirstMount';
+export * from './useId';
 export * from './useIsomorphicLayoutEffect';
 export * from './useMergedRefs';
+export * from './useMount';
 export * from './useOnClickOutside';
+export * from './useOnScrollOutside';
+export * from './usePrevious';
+export * from './useTimeout';
+export * from './useUnmount';
+export * from './useForceUpdate';

package/lib/hooks/index.js

@@ -1,9 +1,17 @@
+export * from './useControllableState';
 export * from './useBoolean';
 export * from './useConst';
 export * from './useControllableValue';
 export * from './useEventCallback';
-export { useId } from './useId';
+export * from './useFirstMount';
+export * from './useId';
 export * from './useIsomorphicLayoutEffect';
 export * from './useMergedRefs';
+export * from './useMount';
 export * from './useOnClickOutside';
+export * from './useOnScrollOutside';
+export * from './usePrevious';
+export * from './useTimeout';
+export * from './useUnmount';
+export * from './useForceUpdate';
 //# sourceMappingURL=index.js.map

package/lib/hooks/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"../src/","sources":["hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC","sourcesContent":["export * from './useBoolean';\nexport * from './useConst';\nexport * from './useControllableValue';\nexport * from './useEventCallback';\nexport { useId } from './useId';\nexport * from './useIsomorphicLayoutEffect';\nexport * from './useMergedRefs';\nexport * from './useOnClickOutside';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC"}

package/lib/hooks/useBoolean.d.ts

@@ -1,12 +1,12 @@
 /** Updater callbacks returned by `useBoolean`. */
-export interface UseBooleanCallbacks {
+export declare type UseBooleanCallbacks = {
     /** Set the value to true. Always has the same identity. */
     setTrue: () => void;
     /** Set the value to false. Always has the same identity. */
     setFalse: () => void;
     /** Toggle the value. Always has the same identity. */
     toggle: () => void;
-}
+};
 /**
  * Hook to store a value and generate callbacks for setting the value to true or false.
  * The identity of the callbacks will always stay the same.

package/lib/hooks/useBoolean.js

@@ -7,17 +7,22 @@ import { useConst } from './useConst';
  * @param initialState - Initial value
  * @returns Array with the current value and an object containing the updater callbacks.
  */
+
 export function useBoolean(initialState) {
-    var _a = React.useState(initialState), value = _a[0], setValue = _a[1];
-    var setTrue = useConst(function () { return function () {
-        setValue(true);
-    }; });
-    var setFalse = useConst(function () { return function () {
-        setValue(false);
-    }; });
-    var toggle = useConst(function () { return function () {
-        setValue(function (currentValue) { return !currentValue; });
-    }; });
-    return [value, { setTrue: setTrue, setFalse: setFalse, toggle: toggle }];
+  const [value, setValue] = React.useState(initialState);
+  const setTrue = useConst(() => () => {
+    setValue(true);
+  });
+  const setFalse = useConst(() => () => {
+    setValue(false);
+  });
+  const toggle = useConst(() => () => {
+    setValue(currentValue => !currentValue);
+  });
+  return [value, {
+    setTrue,
+    setFalse,
+    toggle
+  }];
 }
 //# sourceMappingURL=useBoolean.js.map

package/lib/hooks/useBoolean.js.map

@@ -1 +1 @@
-{"version":3,"file":"useBoolean.js","sourceRoot":"../src/","sources":["hooks/useBoolean.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAYtC;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAC,YAAqB;IACxC,IAAA,iCAAgD,EAA/C,aAAK,EAAE,gBAAwC,CAAC;IAEvD,IAAM,OAAO,GAAG,QAAQ,CAAC,cAAM,OAAA;QAC7B,QAAQ,CAAC,IAAI,CAAC,CAAC;IACjB,CAAC,EAF8B,CAE9B,CAAC,CAAC;IACH,IAAM,QAAQ,GAAG,QAAQ,CAAC,cAAM,OAAA;QAC9B,QAAQ,CAAC,KAAK,CAAC,CAAC;IAClB,CAAC,EAF+B,CAE/B,CAAC,CAAC;IACH,IAAM,MAAM,GAAG,QAAQ,CAAC,cAAM,OAAA;QAC5B,QAAQ,CAAC,UAAA,YAAY,IAAI,OAAA,CAAC,YAAY,EAAb,CAAa,CAAC,CAAC;IAC1C,CAAC,EAF6B,CAE7B,CAAC,CAAC;IAEH,OAAO,CAAC,KAAK,EAAE,EAAE,OAAO,SAAA,EAAE,QAAQ,UAAA,EAAE,MAAM,QAAA,EAAE,CAAC,CAAC;AAChD,CAAC","sourcesContent":["import * as React from 'react';\nimport { useConst } from './useConst';\n\n/** Updater callbacks returned by `useBoolean`. */\nexport interface UseBooleanCallbacks {\n  /** Set the value to true. Always has the same identity. */\n  setTrue: () => void;\n  /** Set the value to false. Always has the same identity. */\n  setFalse: () => void;\n  /** Toggle the value. Always has the same identity. */\n  toggle: () => void;\n}\n\n/**\n * Hook to store a value and generate callbacks for setting the value to true or false.\n * The identity of the callbacks will always stay the same.\n *\n * @param initialState - Initial value\n * @returns Array with the current value and an object containing the updater callbacks.\n */\nexport function useBoolean(initialState: boolean): [boolean, UseBooleanCallbacks] {\n  const [value, setValue] = React.useState(initialState);\n\n  const setTrue = useConst(() => () => {\n    setValue(true);\n  });\n  const setFalse = useConst(() => () => {\n    setValue(false);\n  });\n  const toggle = useConst(() => () => {\n    setValue(currentValue => !currentValue);\n  });\n\n  return [value, { setTrue, setFalse, toggle }];\n}\n"]}
+{"version":3,"sources":["../../src/hooks/useBoolean.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AACA,SAAS,QAAT,QAAyB,YAAzB;AAYA;;;;;;AAMG;;AACH,OAAM,SAAU,UAAV,CAAqB,YAArB,EAA0C;AAC9C,QAAM,CAAC,KAAD,EAAQ,QAAR,IAAoB,KAAK,CAAC,QAAN,CAAe,YAAf,CAA1B;AAEA,QAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,MAAK;AAClC,IAAA,QAAQ,CAAC,IAAD,CAAR;AACD,GAFuB,CAAxB;AAGA,QAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,MAAK;AACnC,IAAA,QAAQ,CAAC,KAAD,CAAR;AACD,GAFwB,CAAzB;AAGA,QAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,MAAK;AACjC,IAAA,QAAQ,CAAC,YAAY,IAAI,CAAC,YAAlB,CAAR;AACD,GAFsB,CAAvB;AAIA,SAAO,CAAC,KAAD,EAAQ;AAAE,IAAA,OAAF;AAAW,IAAA,QAAX;AAAqB,IAAA;AAArB,GAAR,CAAP;AACD","sourceRoot":""}

package/lib/hooks/useConst.js

@@ -10,18 +10,21 @@ import * as React from 'react';
  * only the value/function passed in the first time this is called is respected.
  * @returns The value. The identity of this value will always be the same.
  */
+
 export function useConst(initialValue) {
-    // Use useRef to store the value because it's the least expensive built-in hook that works here
-    // (we could also use `const [value] = React.useState(initialValue)` but that's more expensive
-    // internally due to reducer handling which we don't need)
-    var ref = React.useRef();
-    if (ref.current === undefined) {
-        // Box the value in an object so we can tell if it's initialized even if the initializer
-        // returns/is undefined
-        ref.current = {
-            value: typeof initialValue === 'function' ? initialValue() : initialValue,
-        };
-    }
-    return ref.current.value;
+  // Use useRef to store the value because it's the least expensive built-in hook that works here
+  // (we could also use `const [value] = React.useState(initialValue)` but that's more expensive
+  // internally due to reducer handling which we don't need)
+  const ref = React.useRef();
+
+  if (ref.current === undefined) {
+    // Box the value in an object so we can tell if it's initialized even if the initializer
+    // returns/is undefined
+    ref.current = {
+      value: typeof initialValue === 'function' ? initialValue() : initialValue
+    };
+  }
+
+  return ref.current.value;
 }
 //# sourceMappingURL=useConst.js.map

package/lib/hooks/useConst.js.map

@@ -1 +1 @@
-{"version":3,"file":"useConst.js","sourceRoot":"../src/","sources":["hooks/useConst.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;;;;;;;;GAUG;AACH,MAAM,UAAU,QAAQ,CAAI,YAA2B;IACrD,+FAA+F;IAC/F,8FAA8F;IAC9F,0DAA0D;IAC1D,IAAM,GAAG,GAAG,KAAK,CAAC,MAAM,EAAgB,CAAC;IACzC,IAAI,GAAG,CAAC,OAAO,KAAK,SAAS,EAAE;QAC7B,wFAAwF;QACxF,uBAAuB;QACvB,GAAG,CAAC,OAAO,GAAG;YACZ,KAAK,EAAE,OAAO,YAAY,KAAK,UAAU,CAAC,CAAC,CAAE,YAAyB,EAAE,CAAC,CAAC,CAAC,YAAY;SACxF,CAAC;KACH;IACD,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC;AAC3B,CAAC","sourcesContent":["import * as React from 'react';\n\n/**\n * Hook to initialize and return a constant value. Unlike `React.useMemo`, this is guaranteed to\n * always return the same value (and if the initializer is a function, only call it once).\n * This is similar to setting a private member in a class constructor.\n *\n * If the value should ever change based on dependencies, use `React.useMemo` instead.\n *\n * @param initialValue - Initial value, or function to get the initial value. Similar to `useState`,\n * only the value/function passed in the first time this is called is respected.\n * @returns The value. The identity of this value will always be the same.\n */\nexport function useConst<T>(initialValue: T | (() => T)): T {\n  // Use useRef to store the value because it's the least expensive built-in hook that works here\n  // (we could also use `const [value] = React.useState(initialValue)` but that's more expensive\n  // internally due to reducer handling which we don't need)\n  const ref = React.useRef<{ value: T }>();\n  if (ref.current === undefined) {\n    // Box the value in an object so we can tell if it's initialized even if the initializer\n    // returns/is undefined\n    ref.current = {\n      value: typeof initialValue === 'function' ? (initialValue as Function)() : initialValue,\n    };\n  }\n  return ref.current.value;\n}\n"]}
+{"version":3,"sources":["../../src/hooks/useConst.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AAEA;;;;;;;;;;AAUG;;AACH,OAAM,SAAU,QAAV,CAAsB,YAAtB,EAAiD;AACrD;AACA;AACA;AACA,QAAM,GAAG,GAAG,KAAK,CAAC,MAAN,EAAZ;;AACA,MAAI,GAAG,CAAC,OAAJ,KAAgB,SAApB,EAA+B;AAC7B;AACA;AACA,IAAA,GAAG,CAAC,OAAJ,GAAc;AACZ,MAAA,KAAK,EAAE,OAAO,YAAP,KAAwB,UAAxB,GAAsC,YAAyB,EAA/D,GAAoE;AAD/D,KAAd;AAGD;;AACD,SAAO,GAAG,CAAC,OAAJ,CAAY,KAAnB;AACD","sourceRoot":""}

package/lib/hooks/useControllableState.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+export declare type UseControllableStateOptions<State> = {
+    /**
+     * User provided default state or factory initializer
+     */
+    defaultState?: State | (() => State);
+    /**
+     * User provided controllable state, undefined state means internal state will be used
+     */
+    state: State | undefined;
+    /**
+     * Used to initialize state if all user provided states are undefined
+     */
+    initialState: State;
+};
+/**
+ * A useState 'like' hook that allows optional user control
+ * Useful for components which allow uncontrolled and controlled behaviour for users
+ * @returns - https://reactjs.org/docs/hooks-state.html
+ */
+export declare const useControllableState: <State>(options: UseControllableStateOptions<State>) => [State, React.Dispatch<React.SetStateAction<State>>];

package/lib/hooks/useControllableState.js

@@ -0,0 +1,68 @@
+import * as React from 'react';
+import { useConst } from './useConst';
+
+function isUndefined(state) {
+  return typeof state === 'undefined';
+}
+
+function isFactoryDispatch(newState) {
+  return typeof newState === 'function';
+}
+/**
+ * A useState 'like' hook that allows optional user control
+ * Useful for components which allow uncontrolled and controlled behaviour for users
+ * @returns - https://reactjs.org/docs/hooks-state.html
+ */
+
+
+export const useControllableState = options => {
+  const isControlled = useIsControlled(options.state);
+  const initialState = isUndefined(options.defaultState) ? options.initialState : options.defaultState;
+  const [internalState, setInternalState] = React.useState(initialState);
+  const state = isControlled ? options.state : internalState;
+  const stateRef = React.useRef(state);
+  React.useEffect(() => {
+    stateRef.current = state;
+  }, [state]); // To match the behavior of the setter returned by React.useState, this callback's identity
+  // should never change. This means it MUST NOT directly reference variables that can change.
+
+  const setState = React.useCallback(newState => {
+    // React dispatch can use a factory
+    // https://reactjs.org/docs/hooks-reference.html#functional-updates
+    if (isFactoryDispatch(newState)) {
+      stateRef.current = newState(stateRef.current);
+    } else {
+      stateRef.current = newState;
+    }
+
+    setInternalState(stateRef.current);
+  }, []);
+  return [state, setState];
+};
+/**
+ * Helper hook to handle previous comparison of controlled/uncontrolled
+ * Prints an error when isControlled value switches between subsequent renders
+ * @returns - whether the value is controlled
+ */
+
+const useIsControlled = controlledValue => {
+  const isControlled = useConst(controlledValue !== undefined);
+
+  if (process.env.NODE_ENV !== 'production') {
+    // We don't want these warnings in production even though it is against native behaviour
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    React.useEffect(() => {
+      if (isControlled !== (controlledValue !== undefined)) {
+        const error = new Error();
+        const controlWarning = isControlled ? 'a controlled value to be uncontrolled' : 'an uncontrolled value to be controlled';
+        const undefinedWarning = isControlled ? 'defined to an undefined' : 'undefined to a defined'; // eslint-disable-next-line no-console
+
+        console.error([// Default react error
+        'A component is changing ' + controlWarning + '. This is likely caused by the value', 'changing from ' + undefinedWarning + ' value, which should not happen.', 'Decide between using a controlled or uncontrolled input element for the lifetime of the component.', 'More info: https://reactjs.org/link/controlled-components', error.stack].join(' '));
+      }
+    }, [isControlled, controlledValue]);
+  }
+
+  return isControlled;
+};
+//# sourceMappingURL=useControllableState.js.map

package/lib/hooks/useControllableState.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/useControllableState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAZ,MAAuB,OAAvB;AACA,SAAS,QAAT,QAAyB,YAAzB;;AAiBA,SAAS,WAAT,CAAqB,KAArB,EAAmC;AACjC,SAAO,OAAO,KAAP,KAAiB,WAAxB;AACD;;AAED,SAAS,iBAAT,CAAkC,QAAlC,EAAuE;AACrE,SAAO,OAAO,QAAP,KAAoB,UAA3B;AACD;AAED;;;;AAIG;;;AACH,OAAO,MAAM,oBAAoB,GAC/B,OADkC,IAEsB;AACxD,QAAM,YAAY,GAAG,eAAe,CAAC,OAAO,CAAC,KAAT,CAApC;AACA,QAAM,YAAY,GAAG,WAAW,CAAC,OAAO,CAAC,YAAT,CAAX,GAAoC,OAAO,CAAC,YAA5C,GAA2D,OAAO,CAAC,YAAxF;AACA,QAAM,CAAC,aAAD,EAAgB,gBAAhB,IAAoC,KAAK,CAAC,QAAN,CAAsB,YAAtB,CAA1C;AAEA,QAAM,KAAK,GAAG,YAAY,GAAI,OAAO,CAAC,KAAZ,GAA8B,aAAxD;AAEA,QAAM,QAAQ,GAAG,KAAK,CAAC,MAAN,CAAa,KAAb,CAAjB;AACA,EAAA,KAAK,CAAC,SAAN,CAAgB,MAAK;AACnB,IAAA,QAAQ,CAAC,OAAT,GAAmB,KAAnB;AACD,GAFD,EAEG,CAAC,KAAD,CAFH,EARwD,CAYxD;AACA;;AACA,QAAM,QAAQ,GAAG,KAAK,CAAC,WAAN,CAAmB,QAAD,IAA0C;AAC3E;AACA;AACA,QAAI,iBAAiB,CAAC,QAAD,CAArB,EAAiC;AAC/B,MAAA,QAAQ,CAAC,OAAT,GAAmB,QAAQ,CAAC,QAAQ,CAAC,OAAV,CAA3B;AACD,KAFD,MAEO;AACL,MAAA,QAAQ,CAAC,OAAT,GAAmB,QAAnB;AACD;;AAED,IAAA,gBAAgB,CAAC,QAAQ,CAAC,OAAV,CAAhB;AACD,GAVgB,EAUd,EAVc,CAAjB;AAYA,SAAO,CAAC,KAAD,EAAQ,QAAR,CAAP;AACD,CA7BM;AA+BP;;;;AAIG;;AACH,MAAM,eAAe,GAAI,eAAD,IAA6B;AACnD,QAAM,YAAY,GAAG,QAAQ,CAAU,eAAe,KAAK,SAA9B,CAA7B;;AAEA,MAAI,OAAO,CAAC,GAAR,CAAY,QAAZ,KAAyB,YAA7B,EAA2C;AACzC;AACA;AACA,IAAA,KAAK,CAAC,SAAN,CAAgB,MAAK;AACnB,UAAI,YAAY,MAAM,eAAe,KAAK,SAA1B,CAAhB,EAAsD;AACpD,cAAM,KAAK,GAAG,IAAI,KAAJ,EAAd;AAEA,cAAM,cAAc,GAAG,YAAY,GAC/B,uCAD+B,GAE/B,wCAFJ;AAIA,cAAM,gBAAgB,GAAG,YAAY,GAAG,yBAAH,GAA+B,wBAApE,CAPoD,CASpD;;AACA,QAAA,OAAO,CAAC,KAAR,CACE,CACE;AACA,qCAA6B,cAA7B,GAA8C,sCAFhD,EAGE,mBAAmB,gBAAnB,GAAsC,kCAHxC,EAIE,oGAJF,EAKE,2DALF,EAME,KAAK,CAAC,KANR,EAOE,IAPF,CAOO,GAPP,CADF;AAUD;AACF,KAtBD,EAsBG,CAAC,YAAD,EAAe,eAAf,CAtBH;AAuBD;;AAED,SAAO,YAAP;AACD,CAhCD","sourceRoot":""}