@fluentui/react-jsx-runtime 9.0.40 → 9.0.41

package/CHANGELOG.md

@@ -1,12 +1,22 @@
 # Change Log - @fluentui/react-jsx-runtime
 
-This log was last generated on Mon, 01 Jul 2024 20:26:07 GMT and should not be manually modified.
+This log was last generated on Mon, 15 Jul 2024 17:20:15 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## [9.0.41](https://github.com/microsoft/fluentui/tree/@fluentui/react-jsx-runtime_v9.0.41)
+
+Mon, 15 Jul 2024 17:20:15 GMT 
+[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-jsx-runtime_v9.0.40..@fluentui/react-jsx-runtime_v9.0.41)
+
+### Patches
+
+- fix: revert incorectly set npm versions in all packages ([PR #31937](https://github.com/microsoft/fluentui/pull/31937) by martinhochel@microsoft.com)
+- Bump @fluentui/react-utilities to v9.18.12 ([PR #31998](https://github.com/microsoft/fluentui/pull/31998) by beachball)
+
 ## [9.0.40](https://github.com/microsoft/fluentui/tree/@fluentui/react-jsx-runtime_v9.0.40)
 
-Mon, 01 Jul 2024 20:26:07 GMT 
+Mon, 01 Jul 2024 20:30:54 GMT 
 [Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-jsx-runtime_v9.0.39..@fluentui/react-jsx-runtime_v9.0.40)
 
 ### Patches

package/lib/createElement.js.map

@@ -1 +1 @@
-{"version":3,"sources":["createElement.ts"],"sourcesContent":["import * as React from 'react';\nimport { isSlot } from '@fluentui/react-utilities';\nimport { createElementFromSlotComponent } from './jsx/createElementFromSlotComponent';\nimport { createCompatSlotComponent } from './utils/createCompatSlotComponent';\n\nexport function createElement<P extends {}>(\n  type: React.ElementType<P>,\n  props?: P | null,\n  ...children: React.ReactNode[]\n): React.ReactElement<P> {\n  // TODO:\n  // this is for backwards compatibility with getSlotsNext\n  // it should be removed once getSlotsNext is obsolete\n  if (isSlot<P>(props)) {\n    return createElementFromSlotComponent(createCompatSlotComponent(type, props), children);\n  }\n  if (isSlot<P>(type)) {\n    return createElementFromSlotComponent(type, children);\n  }\n  return React.createElement(type, props, ...children);\n}\n"],"names":["React","isSlot","createElementFromSlotComponent","createCompatSlotComponent","createElement","type","props","children"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,MAAM,QAAQ,4BAA4B;AACnD,SAASC,8BAA8B,QAAQ,uCAAuC;AACtF,SAASC,yBAAyB,QAAQ,oCAAoC;AAE9E,OAAO,SAASC,cACdC,IAA0B,EAC1BC,KAAgB,EAChB,GAAGC,QAA2B;IAE9B,QAAQ;IACR,wDAAwD;IACxD,qDAAqD;IACrD,IAAIN,OAAUK,QAAQ;QACpB,OAAOJ,+BAA+BC,0BAA0BE,MAAMC,QAAQC;IAChF;IACA,IAAIN,OAAUI,OAAO;QACnB,OAAOH,+BAA+BG,MAAME;IAC9C;IACA,OAAOP,MAAMI,aAAa,CAACC,MAAMC,UAAUC;AAC7C"}
+{"version":3,"sources":["createElement.ts"],"sourcesContent":["import * as React from 'react';\nimport { isSlot } from '@fluentui/react-utilities';\nimport { createElementFromSlotComponent } from './jsx/createElementFromSlotComponent';\nimport { createCompatSlotComponent } from './utils/createCompatSlotComponent';\n\nexport function createElement<P extends {}>(\n  type: React.ElementType<P>,\n  props?: P | null,\n  ...children: React.ReactNode[]\n): React.ReactElement<P> {\n  // TODO:\n  // this is for backwards compatibility with getSlotsNext\n  // it should be removed once getSlotsNext is obsolete\n  if (isSlot<P>(props)) {\n    return createElementFromSlotComponent(createCompatSlotComponent(type, props), children);\n  }\n  if (isSlot<P>(type)) {\n    return createElementFromSlotComponent(type, children);\n  }\n  return React.createElement(type, props, ...children);\n}\n"],"names":["React","isSlot","createElementFromSlotComponent","createCompatSlotComponent","createElement","type","props","children"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,MAAM,QAAQ,4BAA4B;AACnD,SAASC,8BAA8B,QAAQ,uCAAuC;AACtF,SAASC,yBAAyB,QAAQ,oCAAoC;AAE9E,OAAO,SAASC,cACdC,IAA0B,EAC1BC,KAAgB,EAChB,GAAGC,QAA2B;IAE9B,QAAQ;IACR,wDAAwD;IACxD,qDAAqD;IACrD,IAAIN,OAAUK,QAAQ;QACpB,OAAOJ,+BAA+BC,0BAA0BE,MAAMC,QAAQC;IAChF;IACA,IAAIN,OAAUI,OAAO;QACnB,OAAOH,+BAA+BG,MAAME;IAC9C;IACA,OAAOP,MAAMI,aAAa,CAACC,MAAMC,UAAUC;AAC7C"}

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.ts"],"sourcesContent":["export { createElement } from './createElement';\nexport { Fragment } from 'react';\n"],"names":["createElement","Fragment"],"mappings":"AAAA,SAASA,aAAa,QAAQ,kBAAkB;AAChD,SAASC,QAAQ,QAAQ,QAAQ"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export { createElement } from './createElement';\nexport { Fragment } from 'react';\n"],"names":["createElement","Fragment"],"rangeMappings":";","mappings":"AAAA,SAASA,aAAa,QAAQ,kBAAkB;AAChD,SAASC,QAAQ,QAAQ,QAAQ"}

package/lib/jsx/createElementFromSlotComponent.js.map

@@ -1 +1 @@
-{"version":3,"sources":["createElementFromSlotComponent.ts"],"sourcesContent":["import * as React from 'react';\nimport type { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\n\n/**\n * @internal\n * creates a ReactElement from a slot declaration\n */\nexport function createElementFromSlotComponent<Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideChildren: React.ReactNode[],\n): React.ReactElement<Props> {\n  const { elementType, renderFunction, props } = getMetadataFromSlotComponent(type);\n\n  if (renderFunction) {\n    if (overrideChildren.length > 0) {\n      props.children = React.createElement(React.Fragment, {}, ...overrideChildren);\n    }\n\n    return React.createElement(\n      React.Fragment,\n      {},\n      renderFunction(elementType as React.ElementType<Props>, props),\n    ) as React.ReactElement<Props>;\n  }\n\n  return React.createElement(elementType, props, ...overrideChildren);\n}\n"],"names":["React","getMetadataFromSlotComponent","createElementFromSlotComponent","type","overrideChildren","elementType","renderFunction","props","length","children","createElement","Fragment"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,4BAA4B,QAAQ,wCAAwC;AAErF;;;CAGC,GACD,OAAO,SAASC,+BACdC,IAA8B,EAC9BC,gBAAmC;IAEnC,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,KAAK,EAAE,GAAGN,6BAA6BE;IAE5E,IAAIG,gBAAgB;QAClB,IAAIF,iBAAiBI,MAAM,GAAG,GAAG;YAC/BD,MAAME,QAAQ,GAAGT,MAAMU,aAAa,CAACV,MAAMW,QAAQ,EAAE,CAAC,MAAMP;QAC9D;QAEA,OAAOJ,MAAMU,aAAa,CACxBV,MAAMW,QAAQ,EACd,CAAC,GACDL,eAAeD,aAAyCE;IAE5D;IAEA,OAAOP,MAAMU,aAAa,CAACL,aAAaE,UAAUH;AACpD"}
+{"version":3,"sources":["createElementFromSlotComponent.ts"],"sourcesContent":["import * as React from 'react';\nimport type { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\n\n/**\n * @internal\n * creates a ReactElement from a slot declaration\n */\nexport function createElementFromSlotComponent<Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideChildren: React.ReactNode[],\n): React.ReactElement<Props> {\n  const { elementType, renderFunction, props } = getMetadataFromSlotComponent(type);\n\n  if (renderFunction) {\n    if (overrideChildren.length > 0) {\n      props.children = React.createElement(React.Fragment, {}, ...overrideChildren);\n    }\n\n    return React.createElement(\n      React.Fragment,\n      {},\n      renderFunction(elementType as React.ElementType<Props>, props),\n    ) as React.ReactElement<Props>;\n  }\n\n  return React.createElement(elementType, props, ...overrideChildren);\n}\n"],"names":["React","getMetadataFromSlotComponent","createElementFromSlotComponent","type","overrideChildren","elementType","renderFunction","props","length","children","createElement","Fragment"],"rangeMappings":";;;;;;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,4BAA4B,QAAQ,wCAAwC;AAErF;;;CAGC,GACD,OAAO,SAASC,+BACdC,IAA8B,EAC9BC,gBAAmC;IAEnC,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,KAAK,EAAE,GAAGN,6BAA6BE;IAE5E,IAAIG,gBAAgB;QAClB,IAAIF,iBAAiBI,MAAM,GAAG,GAAG;YAC/BD,MAAME,QAAQ,GAAGT,MAAMU,aAAa,CAACV,MAAMW,QAAQ,EAAE,CAAC,MAAMP;QAC9D;QAEA,OAAOJ,MAAMU,aAAa,CACxBV,MAAMW,QAAQ,EACd,CAAC,GACDL,eAAeD,aAAyCE;IAE5D;IAEA,OAAOP,MAAMU,aAAa,CAACL,aAAaE,UAAUH;AACpD"}

package/lib/jsx/createJSX.js.map

@@ -1 +1 @@
-{"version":3,"sources":["createJSX.ts"],"sourcesContent":["import { isSlot } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport { createCompatSlotComponent } from '../utils/createCompatSlotComponent';\nimport { JSXRuntime, JSXSlotRuntime } from '../utils/types';\nimport { warnIfElementTypeIsInvalid } from '../utils/warnIfElementTypeIsInvalid';\n\nexport function createJSX(runtime: JSXRuntime, slotRuntime: JSXSlotRuntime) {\n  return function jsx<Props extends {}>(\n    type: React.ElementType<Props>,\n    overrideProps: Props | null,\n    key?: React.Key,\n    source?: unknown,\n    self?: unknown,\n  ): React.ReactElement<Props> {\n    // TODO:\n    // this is for backwards compatibility with getSlotsNext\n    // it should be removed once getSlotsNext is obsolete\n    if (isSlot<Props>(overrideProps)) {\n      return slotRuntime<Props>(createCompatSlotComponent(type, overrideProps), null, key, source, self);\n    }\n    if (isSlot<Props>(type)) {\n      return slotRuntime(type, overrideProps, key, source, self);\n    }\n    warnIfElementTypeIsInvalid(type);\n    return runtime(type, overrideProps, key, source, self);\n  };\n}\n"],"names":["isSlot","React","createCompatSlotComponent","warnIfElementTypeIsInvalid","createJSX","runtime","slotRuntime","jsx","type","overrideProps","key","source","self"],"mappings":"AAAA,SAASA,MAAM,QAAQ,4BAA4B;AACnD,YAAYC,WAAW,QAAQ;AAC/B,SAASC,yBAAyB,QAAQ,qCAAqC;AAE/E,SAASC,0BAA0B,QAAQ,sCAAsC;AAEjF,OAAO,SAASC,UAAUC,OAAmB,EAAEC,WAA2B;IACxE,OAAO,SAASC,IACdC,IAA8B,EAC9BC,aAA2B,EAC3BC,GAAe,EACfC,MAAgB,EAChBC,IAAc;QAEd,QAAQ;QACR,wDAAwD;QACxD,qDAAqD;QACrD,IAAIZ,OAAcS,gBAAgB;YAChC,OAAOH,YAAmBJ,0BAA0BM,MAAMC,gBAAgB,MAAMC,KAAKC,QAAQC;QAC/F;QACA,IAAIZ,OAAcQ,OAAO;YACvB,OAAOF,YAAYE,MAAMC,eAAeC,KAAKC,QAAQC;QACvD;QACAT,2BAA2BK;QAC3B,OAAOH,QAAQG,MAAMC,eAAeC,KAAKC,QAAQC;IACnD;AACF"}
+{"version":3,"sources":["createJSX.ts"],"sourcesContent":["import { isSlot } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport { createCompatSlotComponent } from '../utils/createCompatSlotComponent';\nimport { JSXRuntime, JSXSlotRuntime } from '../utils/types';\nimport { warnIfElementTypeIsInvalid } from '../utils/warnIfElementTypeIsInvalid';\n\nexport function createJSX(runtime: JSXRuntime, slotRuntime: JSXSlotRuntime) {\n  return function jsx<Props extends {}>(\n    type: React.ElementType<Props>,\n    overrideProps: Props | null,\n    key?: React.Key,\n    source?: unknown,\n    self?: unknown,\n  ): React.ReactElement<Props> {\n    // TODO:\n    // this is for backwards compatibility with getSlotsNext\n    // it should be removed once getSlotsNext is obsolete\n    if (isSlot<Props>(overrideProps)) {\n      return slotRuntime<Props>(createCompatSlotComponent(type, overrideProps), null, key, source, self);\n    }\n    if (isSlot<Props>(type)) {\n      return slotRuntime(type, overrideProps, key, source, self);\n    }\n    warnIfElementTypeIsInvalid(type);\n    return runtime(type, overrideProps, key, source, self);\n  };\n}\n"],"names":["isSlot","React","createCompatSlotComponent","warnIfElementTypeIsInvalid","createJSX","runtime","slotRuntime","jsx","type","overrideProps","key","source","self"],"rangeMappings":";;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,MAAM,QAAQ,4BAA4B;AACnD,YAAYC,WAAW,QAAQ;AAC/B,SAASC,yBAAyB,QAAQ,qCAAqC;AAE/E,SAASC,0BAA0B,QAAQ,sCAAsC;AAEjF,OAAO,SAASC,UAAUC,OAAmB,EAAEC,WAA2B;IACxE,OAAO,SAASC,IACdC,IAA8B,EAC9BC,aAA2B,EAC3BC,GAAe,EACfC,MAAgB,EAChBC,IAAc;QAEd,QAAQ;QACR,wDAAwD;QACxD,qDAAqD;QACrD,IAAIZ,OAAcS,gBAAgB;YAChC,OAAOH,YAAmBJ,0BAA0BM,MAAMC,gBAAgB,MAAMC,KAAKC,QAAQC;QAC/F;QACA,IAAIZ,OAAcQ,OAAO;YACvB,OAAOF,YAAYE,MAAMC,eAAeC,KAAKC,QAAQC;QACvD;QACAT,2BAA2BK;QAC3B,OAAOH,QAAQG,MAAMC,eAAeC,KAAKC,QAAQC;IACnD;AACF"}

package/lib/jsx/jsxDEVSlot.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jsxDEVSlot.ts"],"sourcesContent":["import * as React from 'react';\nimport { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { DevRuntime } from '../utils/DevRuntime';\n\nexport const jsxDEVSlot = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n  source?: unknown,\n  self?: unknown,\n): React.ReactElement<Props> => {\n  const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n\n  const props: Props = { ...slotProps, ...overrideProps };\n\n  if (renderFunction) {\n    // if runtime is static\n    if (source === true) {\n      return DevRuntime.jsxDEV(\n        React.Fragment,\n        {\n          children: renderFunction(elementType, {\n            ...props,\n            /**\n             * If the runtime is static then children is an array and this array won't be keyed.\n             * Then we should wrap children by a static fragment\n             * as there's no way to know if renderFunction will render statically or dynamically\n             */\n            children: DevRuntime.jsxDEV(React.Fragment, { children: props.children }, undefined, true, self),\n          }),\n        },\n        key,\n        false, // by marking source as false we're declaring that this render is dynamic\n        self,\n      ) as React.ReactElement<Props>;\n    }\n    // if runtime is dynamic (source = false) things are simpler\n    return DevRuntime.jsxDEV(\n      React.Fragment,\n      { children: renderFunction(elementType, props) },\n      key,\n      source,\n      self,\n    ) as React.ReactElement<Props>;\n  }\n  return DevRuntime.jsxDEV(elementType, props, key, source, self);\n};\n"],"names":["React","getMetadataFromSlotComponent","DevRuntime","jsxDEVSlot","type","overrideProps","key","source","self","elementType","renderFunction","props","slotProps","jsxDEV","Fragment","children","undefined"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,4BAA4B,QAAQ,wCAAwC;AACrF,SAASC,UAAU,QAAQ,sBAAsB;AAEjD,OAAO,MAAMC,aAAa,CACxBC,MACAC,eACAC,KACAC,QACAC;IAEA,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGX,6BAA6BG;IAEvF,MAAMO,QAAe;QAAE,GAAGC,SAAS;QAAE,GAAGP,aAAa;IAAC;IAEtD,IAAIK,gBAAgB;QAClB,uBAAuB;QACvB,IAAIH,WAAW,MAAM;YACnB,OAAOL,WAAWW,MAAM,CACtBb,MAAMc,QAAQ,EACd;gBACEC,UAAUL,eAAeD,aAAa;oBACpC,GAAGE,KAAK;oBACR;;;;aAIC,GACDI,UAAUb,WAAWW,MAAM,CAACb,MAAMc,QAAQ,EAAE;wBAAEC,UAAUJ,MAAMI,QAAQ;oBAAC,GAAGC,WAAW,MAAMR;gBAC7F;YACF,GACAF,KACA,OACAE;QAEJ;QACA,4DAA4D;QAC5D,OAAON,WAAWW,MAAM,CACtBb,MAAMc,QAAQ,EACd;YAAEC,UAAUL,eAAeD,aAAaE;QAAO,GAC/CL,KACAC,QACAC;IAEJ;IACA,OAAON,WAAWW,MAAM,CAACJ,aAAaE,OAAOL,KAAKC,QAAQC;AAC5D,EAAE"}
+{"version":3,"sources":["jsxDEVSlot.ts"],"sourcesContent":["import * as React from 'react';\nimport { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { DevRuntime } from '../utils/DevRuntime';\n\nexport const jsxDEVSlot = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n  source?: unknown,\n  self?: unknown,\n): React.ReactElement<Props> => {\n  const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n\n  const props: Props = { ...slotProps, ...overrideProps };\n\n  if (renderFunction) {\n    // if runtime is static\n    if (source === true) {\n      return DevRuntime.jsxDEV(\n        React.Fragment,\n        {\n          children: renderFunction(elementType, {\n            ...props,\n            /**\n             * If the runtime is static then children is an array and this array won't be keyed.\n             * Then we should wrap children by a static fragment\n             * as there's no way to know if renderFunction will render statically or dynamically\n             */\n            children: DevRuntime.jsxDEV(React.Fragment, { children: props.children }, undefined, true, self),\n          }),\n        },\n        key,\n        false, // by marking source as false we're declaring that this render is dynamic\n        self,\n      ) as React.ReactElement<Props>;\n    }\n    // if runtime is dynamic (source = false) things are simpler\n    return DevRuntime.jsxDEV(\n      React.Fragment,\n      { children: renderFunction(elementType, props) },\n      key,\n      source,\n      self,\n    ) as React.ReactElement<Props>;\n  }\n  return DevRuntime.jsxDEV(elementType, props, key, source, self);\n};\n"],"names":["React","getMetadataFromSlotComponent","DevRuntime","jsxDEVSlot","type","overrideProps","key","source","self","elementType","renderFunction","props","slotProps","jsxDEV","Fragment","children","undefined"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,4BAA4B,QAAQ,wCAAwC;AACrF,SAASC,UAAU,QAAQ,sBAAsB;AAEjD,OAAO,MAAMC,aAAa,CACxBC,MACAC,eACAC,KACAC,QACAC;IAEA,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGX,6BAA6BG;IAEvF,MAAMO,QAAe;QAAE,GAAGC,SAAS;QAAE,GAAGP,aAAa;IAAC;IAEtD,IAAIK,gBAAgB;QAClB,uBAAuB;QACvB,IAAIH,WAAW,MAAM;YACnB,OAAOL,WAAWW,MAAM,CACtBb,MAAMc,QAAQ,EACd;gBACEC,UAAUL,eAAeD,aAAa;oBACpC,GAAGE,KAAK;oBACR;;;;aAIC,GACDI,UAAUb,WAAWW,MAAM,CAACb,MAAMc,QAAQ,EAAE;wBAAEC,UAAUJ,MAAMI,QAAQ;oBAAC,GAAGC,WAAW,MAAMR;gBAC7F;YACF,GACAF,KACA,OACAE;QAEJ;QACA,4DAA4D;QAC5D,OAAON,WAAWW,MAAM,CACtBb,MAAMc,QAAQ,EACd;YAAEC,UAAUL,eAAeD,aAAaE;QAAO,GAC/CL,KACAC,QACAC;IAEJ;IACA,OAAON,WAAWW,MAAM,CAACJ,aAAaE,OAAOL,KAAKC,QAAQC;AAC5D,EAAE"}

package/lib/jsx/jsxSlot.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jsxSlot.ts"],"sourcesContent":["import * as React from 'react';\nimport { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { Runtime } from '../utils/Runtime';\n\nexport const jsxSlot = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n): React.ReactElement<Props> => {\n  const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n\n  const props: Props = { ...slotProps, ...overrideProps };\n\n  if (renderFunction) {\n    return Runtime.jsx(\n      React.Fragment,\n      { children: renderFunction(elementType, props) },\n      key,\n    ) as React.ReactElement<Props>;\n  }\n  return Runtime.jsx(elementType, props, key);\n};\n"],"names":["React","getMetadataFromSlotComponent","Runtime","jsxSlot","type","overrideProps","key","elementType","renderFunction","props","slotProps","jsx","Fragment","children"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,4BAA4B,QAAQ,wCAAwC;AACrF,SAASC,OAAO,QAAQ,mBAAmB;AAE3C,OAAO,MAAMC,UAAU,CACrBC,MACAC,eACAC;IAEA,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGT,6BAA6BG;IAEvF,MAAMK,QAAe;QAAE,GAAGC,SAAS;QAAE,GAAGL,aAAa;IAAC;IAEtD,IAAIG,gBAAgB;QAClB,OAAON,QAAQS,GAAG,CAChBX,MAAMY,QAAQ,EACd;YAAEC,UAAUL,eAAeD,aAAaE;QAAO,GAC/CH;IAEJ;IACA,OAAOJ,QAAQS,GAAG,CAACJ,aAAaE,OAAOH;AACzC,EAAE"}
+{"version":3,"sources":["jsxSlot.ts"],"sourcesContent":["import * as React from 'react';\nimport { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { Runtime } from '../utils/Runtime';\n\nexport const jsxSlot = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n): React.ReactElement<Props> => {\n  const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n\n  const props: Props = { ...slotProps, ...overrideProps };\n\n  if (renderFunction) {\n    return Runtime.jsx(\n      React.Fragment,\n      { children: renderFunction(elementType, props) },\n      key,\n    ) as React.ReactElement<Props>;\n  }\n  return Runtime.jsx(elementType, props, key);\n};\n"],"names":["React","getMetadataFromSlotComponent","Runtime","jsxSlot","type","overrideProps","key","elementType","renderFunction","props","slotProps","jsx","Fragment","children"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,4BAA4B,QAAQ,wCAAwC;AACrF,SAASC,OAAO,QAAQ,mBAAmB;AAE3C,OAAO,MAAMC,UAAU,CACrBC,MACAC,eACAC;IAEA,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGT,6BAA6BG;IAEvF,MAAMK,QAAe;QAAE,GAAGC,SAAS;QAAE,GAAGL,aAAa;IAAC;IAEtD,IAAIG,gBAAgB;QAClB,OAAON,QAAQS,GAAG,CAChBX,MAAMY,QAAQ,EACd;YAAEC,UAAUL,eAAeD,aAAaE;QAAO,GAC/CH;IAEJ;IACA,OAAOJ,QAAQS,GAAG,CAACJ,aAAaE,OAAOH;AACzC,EAAE"}

package/lib/jsx/jsxsSlot.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jsxsSlot.ts"],"sourcesContent":["import * as React from 'react';\nimport { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { Runtime } from '../utils/Runtime';\n\nexport const jsxsSlot = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n): React.ReactElement<Props> => {\n  const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n\n  const props: Props = { ...slotProps, ...overrideProps };\n\n  if (renderFunction) {\n    /**\n     * In static runtime then children is an array and this array won't be keyed.\n     * We should wrap children by a static fragment\n     * as there's no way to know if renderFunction will render statically or dynamically\n     */\n    return Runtime.jsx(\n      React.Fragment,\n      {\n        children: renderFunction(elementType, {\n          ...props,\n          children: Runtime.jsxs(React.Fragment, { children: props.children }, undefined),\n        }),\n      },\n      key,\n    ) as React.ReactElement<Props>;\n  }\n  return Runtime.jsxs(elementType, props, key);\n};\n"],"names":["React","getMetadataFromSlotComponent","Runtime","jsxsSlot","type","overrideProps","key","elementType","renderFunction","props","slotProps","jsx","Fragment","children","jsxs","undefined"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,4BAA4B,QAAQ,wCAAwC;AACrF,SAASC,OAAO,QAAQ,mBAAmB;AAE3C,OAAO,MAAMC,WAAW,CACtBC,MACAC,eACAC;IAEA,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGT,6BAA6BG;IAEvF,MAAMK,QAAe;QAAE,GAAGC,SAAS;QAAE,GAAGL,aAAa;IAAC;IAEtD,IAAIG,gBAAgB;QAClB;;;;KAIC,GACD,OAAON,QAAQS,GAAG,CAChBX,MAAMY,QAAQ,EACd;YACEC,UAAUL,eAAeD,aAAa;gBACpC,GAAGE,KAAK;gBACRI,UAAUX,QAAQY,IAAI,CAACd,MAAMY,QAAQ,EAAE;oBAAEC,UAAUJ,MAAMI,QAAQ;gBAAC,GAAGE;YACvE;QACF,GACAT;IAEJ;IACA,OAAOJ,QAAQY,IAAI,CAACP,aAAaE,OAAOH;AAC1C,EAAE"}
+{"version":3,"sources":["jsxsSlot.ts"],"sourcesContent":["import * as React from 'react';\nimport { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { Runtime } from '../utils/Runtime';\n\nexport const jsxsSlot = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n): React.ReactElement<Props> => {\n  const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n\n  const props: Props = { ...slotProps, ...overrideProps };\n\n  if (renderFunction) {\n    /**\n     * In static runtime then children is an array and this array won't be keyed.\n     * We should wrap children by a static fragment\n     * as there's no way to know if renderFunction will render statically or dynamically\n     */\n    return Runtime.jsx(\n      React.Fragment,\n      {\n        children: renderFunction(elementType, {\n          ...props,\n          children: Runtime.jsxs(React.Fragment, { children: props.children }, undefined),\n        }),\n      },\n      key,\n    ) as React.ReactElement<Props>;\n  }\n  return Runtime.jsxs(elementType, props, key);\n};\n"],"names":["React","getMetadataFromSlotComponent","Runtime","jsxsSlot","type","overrideProps","key","elementType","renderFunction","props","slotProps","jsx","Fragment","children","jsxs","undefined"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,4BAA4B,QAAQ,wCAAwC;AACrF,SAASC,OAAO,QAAQ,mBAAmB;AAE3C,OAAO,MAAMC,WAAW,CACtBC,MACAC,eACAC;IAEA,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGT,6BAA6BG;IAEvF,MAAMK,QAAe;QAAE,GAAGC,SAAS;QAAE,GAAGL,aAAa;IAAC;IAEtD,IAAIG,gBAAgB;QAClB;;;;KAIC,GACD,OAAON,QAAQS,GAAG,CAChBX,MAAMY,QAAQ,EACd;YACEC,UAAUL,eAAeD,aAAa;gBACpC,GAAGE,KAAK;gBACRI,UAAUX,QAAQY,IAAI,CAACd,MAAMY,QAAQ,EAAE;oBAAEC,UAAUJ,MAAMI,QAAQ;gBAAC,GAAGE;YACvE;QACF,GACAT;IAEJ;IACA,OAAOJ,QAAQY,IAAI,CAACP,aAAaE,OAAOH;AAC1C,EAAE"}

package/lib/jsx-dev-runtime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jsx-dev-runtime.ts"],"sourcesContent":["import { createJSX } from './jsx/createJSX';\nimport { jsxDEVSlot } from './jsx/jsxDEVSlot';\nimport { DevRuntime } from './utils/DevRuntime';\n\nexport { Fragment } from 'react';\n\nexport const jsxDEV = createJSX(DevRuntime.jsxDEV, jsxDEVSlot);\n"],"names":["createJSX","jsxDEVSlot","DevRuntime","Fragment","jsxDEV"],"mappings":"AAAA,SAASA,SAAS,QAAQ,kBAAkB;AAC5C,SAASC,UAAU,QAAQ,mBAAmB;AAC9C,SAASC,UAAU,QAAQ,qBAAqB;AAEhD,SAASC,QAAQ,QAAQ,QAAQ;AAEjC,OAAO,MAAMC,SAASJ,UAAUE,WAAWE,MAAM,EAAEH,YAAY"}
+{"version":3,"sources":["jsx-dev-runtime.ts"],"sourcesContent":["import { createJSX } from './jsx/createJSX';\nimport { jsxDEVSlot } from './jsx/jsxDEVSlot';\nimport { DevRuntime } from './utils/DevRuntime';\n\nexport { Fragment } from 'react';\n\nexport const jsxDEV = createJSX(DevRuntime.jsxDEV, jsxDEVSlot);\n"],"names":["createJSX","jsxDEVSlot","DevRuntime","Fragment","jsxDEV"],"rangeMappings":";;;;","mappings":"AAAA,SAASA,SAAS,QAAQ,kBAAkB;AAC5C,SAASC,UAAU,QAAQ,mBAAmB;AAC9C,SAASC,UAAU,QAAQ,qBAAqB;AAEhD,SAASC,QAAQ,QAAQ,QAAQ;AAEjC,OAAO,MAAMC,SAASJ,UAAUE,WAAWE,MAAM,EAAEH,YAAY"}

package/lib/jsx-runtime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jsx-runtime.ts"],"sourcesContent":["import { createJSX } from './jsx/createJSX';\nimport { jsxSlot } from './jsx/jsxSlot';\nimport { jsxsSlot } from './jsx/jsxsSlot';\nimport { Runtime } from './utils/Runtime';\n\nexport { Fragment } from 'react';\n\nexport const jsx = createJSX(Runtime.jsx, jsxSlot);\nexport const jsxs = createJSX(Runtime.jsxs, jsxsSlot);\n"],"names":["createJSX","jsxSlot","jsxsSlot","Runtime","Fragment","jsx","jsxs"],"mappings":"AAAA,SAASA,SAAS,QAAQ,kBAAkB;AAC5C,SAASC,OAAO,QAAQ,gBAAgB;AACxC,SAASC,QAAQ,QAAQ,iBAAiB;AAC1C,SAASC,OAAO,QAAQ,kBAAkB;AAE1C,SAASC,QAAQ,QAAQ,QAAQ;AAEjC,OAAO,MAAMC,MAAML,UAAUG,QAAQE,GAAG,EAAEJ,SAAS;AACnD,OAAO,MAAMK,OAAON,UAAUG,QAAQG,IAAI,EAAEJ,UAAU"}
+{"version":3,"sources":["jsx-runtime.ts"],"sourcesContent":["import { createJSX } from './jsx/createJSX';\nimport { jsxSlot } from './jsx/jsxSlot';\nimport { jsxsSlot } from './jsx/jsxsSlot';\nimport { Runtime } from './utils/Runtime';\n\nexport { Fragment } from 'react';\n\nexport const jsx = createJSX(Runtime.jsx, jsxSlot);\nexport const jsxs = createJSX(Runtime.jsxs, jsxsSlot);\n"],"names":["createJSX","jsxSlot","jsxsSlot","Runtime","Fragment","jsx","jsxs"],"rangeMappings":";;;;;;","mappings":"AAAA,SAASA,SAAS,QAAQ,kBAAkB;AAC5C,SAASC,OAAO,QAAQ,gBAAgB;AACxC,SAASC,QAAQ,QAAQ,iBAAiB;AAC1C,SAASC,OAAO,QAAQ,kBAAkB;AAE1C,SAASC,QAAQ,QAAQ,QAAQ;AAEjC,OAAO,MAAMC,MAAML,UAAUG,QAAQE,GAAG,EAAEJ,SAAS;AACnD,OAAO,MAAMK,OAAON,UAAUG,QAAQG,IAAI,EAAEJ,UAAU"}

package/lib/utils/DevRuntime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["DevRuntime.ts"],"sourcesContent":["import * as ReactDevRuntime from 'react/jsx-dev-runtime';\nimport type { JSXRuntime } from './types';\n\nexport const DevRuntime = ReactDevRuntime as {\n  jsxDEV: JSXRuntime;\n};\n"],"names":["ReactDevRuntime","DevRuntime"],"mappings":"AAAA,YAAYA,qBAAqB,wBAAwB;AAGzD,OAAO,MAAMC,aAAaD,gBAExB"}
+{"version":3,"sources":["DevRuntime.ts"],"sourcesContent":["import * as ReactDevRuntime from 'react/jsx-dev-runtime';\nimport type { JSXRuntime } from './types';\n\nexport const DevRuntime = ReactDevRuntime as {\n  jsxDEV: JSXRuntime;\n};\n"],"names":["ReactDevRuntime","DevRuntime"],"rangeMappings":";","mappings":"AAAA,YAAYA,qBAAqB,wBAAwB;AAGzD,OAAO,MAAMC,aAAaD,gBAExB"}

package/lib/utils/Runtime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["Runtime.ts"],"sourcesContent":["import * as ReactRuntime from 'react/jsx-runtime';\nimport type { JSXRuntime } from './types';\n\nexport const Runtime = ReactRuntime as {\n  jsx: JSXRuntime;\n  jsxs: JSXRuntime;\n};\n"],"names":["ReactRuntime","Runtime"],"mappings":"AAAA,YAAYA,kBAAkB,oBAAoB;AAGlD,OAAO,MAAMC,UAAUD,aAGrB"}
+{"version":3,"sources":["Runtime.ts"],"sourcesContent":["import * as ReactRuntime from 'react/jsx-runtime';\nimport type { JSXRuntime } from './types';\n\nexport const Runtime = ReactRuntime as {\n  jsx: JSXRuntime;\n  jsxs: JSXRuntime;\n};\n"],"names":["ReactRuntime","Runtime"],"rangeMappings":";","mappings":"AAAA,YAAYA,kBAAkB,oBAAoB;AAGlD,OAAO,MAAMC,UAAUD,aAGrB"}

package/lib/utils/createCompatSlotComponent.js.map

@@ -1 +1 @@
-{"version":3,"sources":["createCompatSlotComponent.ts"],"sourcesContent":["import * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL } from '@fluentui/react-utilities';\nimport type { SlotComponentType } from '@fluentui/react-utilities';\n\n// TODO:\n// this is for backwards compatibility with getSlotsNext\n// it should be removed once getSlotsNext is obsolete\nexport function createCompatSlotComponent<P extends {}>(type: React.ElementType<P>, props: P): SlotComponentType<P> {\n  return {\n    ...props,\n    [SLOT_ELEMENT_TYPE_SYMBOL]: type,\n  } as SlotComponentType<P>;\n}\n"],"names":["React","SLOT_ELEMENT_TYPE_SYMBOL","createCompatSlotComponent","type","props"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,wBAAwB,QAAQ,4BAA4B;AAGrE,QAAQ;AACR,wDAAwD;AACxD,qDAAqD;AACrD,OAAO,SAASC,0BAAwCC,IAA0B,EAAEC,KAAQ;IAC1F,OAAO;QACL,GAAGA,KAAK;QACR,CAACH,yBAAyB,EAAEE;IAC9B;AACF"}
+{"version":3,"sources":["createCompatSlotComponent.ts"],"sourcesContent":["import * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL } from '@fluentui/react-utilities';\nimport type { SlotComponentType } from '@fluentui/react-utilities';\n\n// TODO:\n// this is for backwards compatibility with getSlotsNext\n// it should be removed once getSlotsNext is obsolete\nexport function createCompatSlotComponent<P extends {}>(type: React.ElementType<P>, props: P): SlotComponentType<P> {\n  return {\n    ...props,\n    [SLOT_ELEMENT_TYPE_SYMBOL]: type,\n  } as SlotComponentType<P>;\n}\n"],"names":["React","SLOT_ELEMENT_TYPE_SYMBOL","createCompatSlotComponent","type","props"],"rangeMappings":";;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,wBAAwB,QAAQ,4BAA4B;AAGrE,QAAQ;AACR,wDAAwD;AACxD,qDAAqD;AACrD,OAAO,SAASC,0BAAwCC,IAA0B,EAAEC,KAAQ;IAC1F,OAAO;QACL,GAAGA,KAAK;QACR,CAACH,yBAAyB,EAAEE;IAC9B;AACF"}

package/lib/utils/getMetadataFromSlotComponent.js.map

@@ -1 +1 @@
-{"version":3,"sources":["getMetadataFromSlotComponent.ts"],"sourcesContent":["import type * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL, SLOT_RENDER_FUNCTION_SYMBOL } from '@fluentui/react-utilities';\nimport type { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\n\n/**\n * @internal\n */\nexport function getMetadataFromSlotComponent<Props extends UnknownSlotProps>(type: SlotComponentType<Props>) {\n  const {\n    as,\n    [SLOT_ELEMENT_TYPE_SYMBOL]: baseElementType,\n    [SLOT_RENDER_FUNCTION_SYMBOL]: renderFunction,\n    ...propsWithoutMetadata\n  } = type;\n  const props = propsWithoutMetadata as UnknownSlotProps as Props;\n\n  const elementType = (\n    typeof baseElementType === 'string' ? as ?? baseElementType : baseElementType\n  ) as React.ElementType<Props>;\n\n  if (typeof elementType !== 'string' && as) {\n    props.as = as;\n  }\n  return { elementType, props, renderFunction };\n}\n"],"names":["SLOT_ELEMENT_TYPE_SYMBOL","SLOT_RENDER_FUNCTION_SYMBOL","getMetadataFromSlotComponent","type","as","baseElementType","renderFunction","propsWithoutMetadata","props","elementType"],"mappings":"AACA,SAASA,wBAAwB,EAAEC,2BAA2B,QAAQ,4BAA4B;AAGlG;;CAEC,GACD,OAAO,SAASC,6BAA6DC,IAA8B;IACzG,MAAM,EACJC,EAAE,EACF,CAACJ,yBAAyB,EAAEK,eAAe,EAC3C,CAACJ,4BAA4B,EAAEK,cAAc,EAC7C,GAAGC,sBACJ,GAAGJ;IACJ,MAAMK,QAAQD;IAEd,MAAME,cACJ,OAAOJ,oBAAoB,WAAWD,eAAAA,gBAAAA,KAAMC,kBAAkBA;IAGhE,IAAI,OAAOI,gBAAgB,YAAYL,IAAI;QACzCI,MAAMJ,EAAE,GAAGA;IACb;IACA,OAAO;QAAEK;QAAaD;QAAOF;IAAe;AAC9C"}
+{"version":3,"sources":["getMetadataFromSlotComponent.ts"],"sourcesContent":["import type * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL, SLOT_RENDER_FUNCTION_SYMBOL } from '@fluentui/react-utilities';\nimport type { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\n\n/**\n * @internal\n */\nexport function getMetadataFromSlotComponent<Props extends UnknownSlotProps>(type: SlotComponentType<Props>) {\n  const {\n    as,\n    [SLOT_ELEMENT_TYPE_SYMBOL]: baseElementType,\n    [SLOT_RENDER_FUNCTION_SYMBOL]: renderFunction,\n    ...propsWithoutMetadata\n  } = type;\n  const props = propsWithoutMetadata as UnknownSlotProps as Props;\n\n  const elementType = (\n    typeof baseElementType === 'string' ? as ?? baseElementType : baseElementType\n  ) as React.ElementType<Props>;\n\n  if (typeof elementType !== 'string' && as) {\n    props.as = as;\n  }\n  return { elementType, props, renderFunction };\n}\n"],"names":["SLOT_ELEMENT_TYPE_SYMBOL","SLOT_RENDER_FUNCTION_SYMBOL","getMetadataFromSlotComponent","type","as","baseElementType","renderFunction","propsWithoutMetadata","props","elementType"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":"AACA,SAASA,wBAAwB,EAAEC,2BAA2B,QAAQ,4BAA4B;AAGlG;;CAEC,GACD,OAAO,SAASC,6BAA6DC,IAA8B;IACzG,MAAM,EACJC,EAAE,EACF,CAACJ,yBAAyB,EAAEK,eAAe,EAC3C,CAACJ,4BAA4B,EAAEK,cAAc,EAC7C,GAAGC,sBACJ,GAAGJ;IACJ,MAAMK,QAAQD;IAEd,MAAME,cACJ,OAAOJ,oBAAoB,WAAWD,eAAAA,gBAAAA,KAAMC,kBAAkBA;IAGhE,IAAI,OAAOI,gBAAgB,YAAYL,IAAI;QACzCI,MAAMJ,EAAE,GAAGA;IACb;IACA,OAAO;QAAEK;QAAaD;QAAOF;IAAe;AAC9C"}

package/lib/utils/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["types.ts"],"sourcesContent":["import type * as React from 'react';\nimport type { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\n\nexport type JSXRuntime = <P extends {}>(\n  type: React.ElementType<P>,\n  props: P | null,\n  key?: React.Key,\n  source?: unknown,\n  self?: unknown,\n) => React.ReactElement<P>;\n\nexport type JSXSlotRuntime = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n  source?: unknown,\n  self?: unknown,\n) => React.ReactElement<Props>;\n"],"names":[],"mappings":"AAAA,WAiB+B"}
+{"version":3,"sources":["types.ts"],"sourcesContent":["import type * as React from 'react';\nimport type { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\n\nexport type JSXRuntime = <P extends {}>(\n  type: React.ElementType<P>,\n  props: P | null,\n  key?: React.Key,\n  source?: unknown,\n  self?: unknown,\n) => React.ReactElement<P>;\n\nexport type JSXSlotRuntime = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n  source?: unknown,\n  self?: unknown,\n) => React.ReactElement<Props>;\n"],"names":[],"rangeMappings":"","mappings":"AAWA,WAM+B"}

package/lib/utils/warnIfElementTypeIsInvalid.js.map

@@ -1 +1 @@
-{"version":3,"sources":["warnIfElementTypeIsInvalid.ts"],"sourcesContent":["import * as React from 'react';\nimport { isValidElementType } from 'react-is';\n\nexport function warnIfElementTypeIsInvalid(type: React.ElementType) {\n  if (process.env.NODE_ENV === 'development' && typeof type === 'object' && !isValidElementType(type)) {\n    // eslint-disable-next-line no-console\n    console.error(/** #__DE-INDENT__ */ `\n        @fluentui/react-jsx-runtime:\n        Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: ${type}.\n\n        If this happened in a slot of Fluent UI component, you might be facing package resolution issues.\n        Please make sure you don't have multiple versions of \"@fluentui/react-utilities\" installed in your dependencies or sub-dependencies.\n        You can check this by searching up for matching entries in a lockfile produced by your package manager (yarn.lock, pnpm-lock.yaml or package-lock.json).\n      `);\n  }\n}\n"],"names":["React","isValidElementType","warnIfElementTypeIsInvalid","type","process","env","NODE_ENV","console","error"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,kBAAkB,QAAQ,WAAW;AAE9C,OAAO,SAASC,2BAA2BC,IAAuB;IAChE,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,iBAAiB,OAAOH,SAAS,YAAY,CAACF,mBAAmBE,OAAO;QACnG,sCAAsC;QACtCI,QAAQC,KAAK,CAAuB,CAAC;6HAE4F,EAAEL,KAAK;;;;wJAKtI,CAAC;IACL;AACF"}
+{"version":3,"sources":["warnIfElementTypeIsInvalid.ts"],"sourcesContent":["import * as React from 'react';\nimport { isValidElementType } from 'react-is';\n\nexport function warnIfElementTypeIsInvalid(type: React.ElementType) {\n  if (process.env.NODE_ENV === 'development' && typeof type === 'object' && !isValidElementType(type)) {\n    // eslint-disable-next-line no-console\n    console.error(/** #__DE-INDENT__ */ `\n        @fluentui/react-jsx-runtime:\n        Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: ${type}.\n\n        If this happened in a slot of Fluent UI component, you might be facing package resolution issues.\n        Please make sure you don't have multiple versions of \"@fluentui/react-utilities\" installed in your dependencies or sub-dependencies.\n        You can check this by searching up for matching entries in a lockfile produced by your package manager (yarn.lock, pnpm-lock.yaml or package-lock.json).\n      `);\n  }\n}\n"],"names":["React","isValidElementType","warnIfElementTypeIsInvalid","type","process","env","NODE_ENV","console","error"],"rangeMappings":";;;;;;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,kBAAkB,QAAQ,WAAW;AAE9C,OAAO,SAASC,2BAA2BC,IAAuB;IAChE,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,iBAAiB,OAAOH,SAAS,YAAY,CAACF,mBAAmBE,OAAO;QACnG,sCAAsC;QACtCI,QAAQC,KAAK,CAAuB,CAAC;6HAE4F,EAAEL,KAAK;;;;wJAKtI,CAAC;IACL;AACF"}

package/lib-commonjs/createElement.js.map

@@ -1 +1 @@
-{"version":3,"sources":["createElement.js"],"sourcesContent":["import * as React from 'react';\nimport { isSlot } from '@fluentui/react-utilities';\nimport { createElementFromSlotComponent } from './jsx/createElementFromSlotComponent';\nimport { createCompatSlotComponent } from './utils/createCompatSlotComponent';\nexport function createElement(type, props, ...children) {\n    // TODO:\n    // this is for backwards compatibility with getSlotsNext\n    // it should be removed once getSlotsNext is obsolete\n    if (isSlot(props)) {\n        return createElementFromSlotComponent(createCompatSlotComponent(type, props), children);\n    }\n    if (isSlot(type)) {\n        return createElementFromSlotComponent(type, children);\n    }\n    return React.createElement(type, props, ...children);\n}\n"],"names":["createElement","type","props","children","isSlot","createElementFromSlotComponent","createCompatSlotComponent","React"],"mappings":";;;;+BAIgBA;;;eAAAA;;;;iEAJO;gCACA;gDACwB;2CACL;AACnC,SAASA,cAAcC,IAAI,EAAEC,KAAK,EAAE,GAAGC,QAAQ;IAClD,QAAQ;IACR,wDAAwD;IACxD,qDAAqD;IACrD,IAAIC,IAAAA,sBAAM,EAACF,QAAQ;QACf,OAAOG,IAAAA,8DAA8B,EAACC,IAAAA,oDAAyB,EAACL,MAAMC,QAAQC;IAClF;IACA,IAAIC,IAAAA,sBAAM,EAACH,OAAO;QACd,OAAOI,IAAAA,8DAA8B,EAACJ,MAAME;IAChD;IACA,qBAAOI,OAAMP,aAAa,CAACC,MAAMC,UAAUC;AAC/C"}
+{"version":3,"sources":["createElement.ts"],"sourcesContent":["import * as React from 'react';\nimport { isSlot } from '@fluentui/react-utilities';\nimport { createElementFromSlotComponent } from './jsx/createElementFromSlotComponent';\nimport { createCompatSlotComponent } from './utils/createCompatSlotComponent';\n\nexport function createElement<P extends {}>(\n  type: React.ElementType<P>,\n  props?: P | null,\n  ...children: React.ReactNode[]\n): React.ReactElement<P> {\n  // TODO:\n  // this is for backwards compatibility with getSlotsNext\n  // it should be removed once getSlotsNext is obsolete\n  if (isSlot<P>(props)) {\n    return createElementFromSlotComponent(createCompatSlotComponent(type, props), children);\n  }\n  if (isSlot<P>(type)) {\n    return createElementFromSlotComponent(type, children);\n  }\n  return React.createElement(type, props, ...children);\n}\n"],"names":["createElement","type","props","children","isSlot","createElementFromSlotComponent","createCompatSlotComponent","React"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAKgBA;;;eAAAA;;;;iEALO;gCACA;gDACwB;2CACL;AAEnC,SAASA,cACdC,IAA0B,EAC1BC,KAAgB,EAChB,GAAGC,QAA2B;IAE9B,QAAQ;IACR,wDAAwD;IACxD,qDAAqD;IACrD,IAAIC,IAAAA,sBAAAA,EAAUF,QAAQ;QACpB,OAAOG,IAAAA,8DAAAA,EAA+BC,IAAAA,oDAAAA,EAA0BL,MAAMC,QAAQC;IAChF;IACA,IAAIC,IAAAA,sBAAAA,EAAUH,OAAO;QACnB,OAAOI,IAAAA,8DAAAA,EAA+BJ,MAAME;IAC9C;IACA,qBAAOI,OAAMP,aAAa,CAACC,MAAMC,UAAUC;AAC7C"}

package/lib-commonjs/index.js

@@ -9,11 +9,11 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    createElement: function() {
-        return _createElement.createElement;
-    },
     Fragment: function() {
         return _react.Fragment;
+    },
+    createElement: function() {
+        return _createElement.createElement;
     }
 });
 const _createElement = require("./createElement");

package/lib-commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.js"],"sourcesContent":["export { createElement } from './createElement';\nexport { Fragment } from 'react';\n"],"names":["createElement","Fragment"],"mappings":";;;;;;;;;;;IAASA,aAAa;eAAbA,4BAAa;;IACbC,QAAQ;eAARA,eAAQ;;;+BADa;uBACL"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export { createElement } from './createElement';\nexport { Fragment } from 'react';\n"],"names":["Fragment","createElement"],"rangeMappings":";;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACSA,QAAQ;eAARA,eAAQ;;IADRC,aAAa;eAAbA,4BAAa;;;+BAAQ;uBACL"}

package/lib-commonjs/jsx/createElementFromSlotComponent.js.map

@@ -1 +1 @@
-{"version":3,"sources":["createElementFromSlotComponent.js"],"sourcesContent":["import * as React from 'react';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\n/**\n * @internal\n * creates a ReactElement from a slot declaration\n */ export function createElementFromSlotComponent(type, overrideChildren) {\n    const { elementType, renderFunction, props } = getMetadataFromSlotComponent(type);\n    if (renderFunction) {\n        if (overrideChildren.length > 0) {\n            props.children = React.createElement(React.Fragment, {}, ...overrideChildren);\n        }\n        return React.createElement(React.Fragment, {}, renderFunction(elementType, props));\n    }\n    return React.createElement(elementType, props, ...overrideChildren);\n}\n"],"names":["createElementFromSlotComponent","type","overrideChildren","elementType","renderFunction","props","getMetadataFromSlotComponent","length","children","React","createElement","Fragment"],"mappings":";;;;+BAKoBA;;;eAAAA;;;;iEALG;8CACsB;AAIlC,SAASA,+BAA+BC,IAAI,EAAEC,gBAAgB;IACrE,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,KAAK,EAAE,GAAGC,IAAAA,0DAA4B,EAACL;IAC5E,IAAIG,gBAAgB;QAChB,IAAIF,iBAAiBK,MAAM,GAAG,GAAG;YAC7BF,MAAMG,QAAQ,iBAAGC,OAAMC,aAAa,CAACD,OAAME,QAAQ,EAAE,CAAC,MAAMT;QAChE;QACA,qBAAOO,OAAMC,aAAa,CAACD,OAAME,QAAQ,EAAE,CAAC,GAAGP,eAAeD,aAAaE;IAC/E;IACA,qBAAOI,OAAMC,aAAa,CAACP,aAAaE,UAAUH;AACtD"}
+{"version":3,"sources":["createElementFromSlotComponent.ts"],"sourcesContent":["import * as React from 'react';\nimport type { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\n\n/**\n * @internal\n * creates a ReactElement from a slot declaration\n */\nexport function createElementFromSlotComponent<Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideChildren: React.ReactNode[],\n): React.ReactElement<Props> {\n  const { elementType, renderFunction, props } = getMetadataFromSlotComponent(type);\n\n  if (renderFunction) {\n    if (overrideChildren.length > 0) {\n      props.children = React.createElement(React.Fragment, {}, ...overrideChildren);\n    }\n\n    return React.createElement(\n      React.Fragment,\n      {},\n      renderFunction(elementType as React.ElementType<Props>, props),\n    ) as React.ReactElement<Props>;\n  }\n\n  return React.createElement(elementType, props, ...overrideChildren);\n}\n"],"names":["createElementFromSlotComponent","type","overrideChildren","elementType","renderFunction","props","getMetadataFromSlotComponent","length","children","React","createElement","Fragment"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAQgBA;;;eAAAA;;;;iEARO;8CAEsB;AAMtC,SAASA,+BACdC,IAA8B,EAC9BC,gBAAmC;IAEnC,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,KAAK,EAAE,GAAGC,IAAAA,0DAAAA,EAA6BL;IAE5E,IAAIG,gBAAgB;QAClB,IAAIF,iBAAiBK,MAAM,GAAG,GAAG;YAC/BF,MAAMG,QAAQ,iBAAGC,OAAMC,aAAa,CAACD,OAAME,QAAQ,EAAE,CAAC,MAAMT;QAC9D;QAEA,qBAAOO,OAAMC,aAAa,CACxBD,OAAME,QAAQ,EACd,CAAC,GACDP,eAAeD,aAAyCE;IAE5D;IAEA,qBAAOI,OAAMC,aAAa,CAACP,aAAaE,UAAUH;AACpD"}

package/lib-commonjs/jsx/createJSX.js.map

@@ -1 +1 @@
-{"version":3,"sources":["createJSX.js"],"sourcesContent":["import { isSlot } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport { createCompatSlotComponent } from '../utils/createCompatSlotComponent';\nimport { warnIfElementTypeIsInvalid } from '../utils/warnIfElementTypeIsInvalid';\nexport function createJSX(runtime, slotRuntime) {\n    return function jsx(type, overrideProps, key, source, self) {\n        // TODO:\n        // this is for backwards compatibility with getSlotsNext\n        // it should be removed once getSlotsNext is obsolete\n        if (isSlot(overrideProps)) {\n            return slotRuntime(createCompatSlotComponent(type, overrideProps), null, key, source, self);\n        }\n        if (isSlot(type)) {\n            return slotRuntime(type, overrideProps, key, source, self);\n        }\n        warnIfElementTypeIsInvalid(type);\n        return runtime(type, overrideProps, key, source, self);\n    };\n}\n"],"names":["createJSX","runtime","slotRuntime","jsx","type","overrideProps","key","source","self","isSlot","createCompatSlotComponent","warnIfElementTypeIsInvalid"],"mappings":";;;;+BAIgBA;;;eAAAA;;;;gCAJO;iEACA;2CACmB;4CACC;AACpC,SAASA,UAAUC,OAAO,EAAEC,WAAW;IAC1C,OAAO,SAASC,IAAIC,IAAI,EAAEC,aAAa,EAAEC,GAAG,EAAEC,MAAM,EAAEC,IAAI;QACtD,QAAQ;QACR,wDAAwD;QACxD,qDAAqD;QACrD,IAAIC,IAAAA,sBAAM,EAACJ,gBAAgB;YACvB,OAAOH,YAAYQ,IAAAA,oDAAyB,EAACN,MAAMC,gBAAgB,MAAMC,KAAKC,QAAQC;QAC1F;QACA,IAAIC,IAAAA,sBAAM,EAACL,OAAO;YACd,OAAOF,YAAYE,MAAMC,eAAeC,KAAKC,QAAQC;QACzD;QACAG,IAAAA,sDAA0B,EAACP;QAC3B,OAAOH,QAAQG,MAAMC,eAAeC,KAAKC,QAAQC;IACrD;AACJ"}
+{"version":3,"sources":["createJSX.ts"],"sourcesContent":["import { isSlot } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport { createCompatSlotComponent } from '../utils/createCompatSlotComponent';\nimport { JSXRuntime, JSXSlotRuntime } from '../utils/types';\nimport { warnIfElementTypeIsInvalid } from '../utils/warnIfElementTypeIsInvalid';\n\nexport function createJSX(runtime: JSXRuntime, slotRuntime: JSXSlotRuntime) {\n  return function jsx<Props extends {}>(\n    type: React.ElementType<Props>,\n    overrideProps: Props | null,\n    key?: React.Key,\n    source?: unknown,\n    self?: unknown,\n  ): React.ReactElement<Props> {\n    // TODO:\n    // this is for backwards compatibility with getSlotsNext\n    // it should be removed once getSlotsNext is obsolete\n    if (isSlot<Props>(overrideProps)) {\n      return slotRuntime<Props>(createCompatSlotComponent(type, overrideProps), null, key, source, self);\n    }\n    if (isSlot<Props>(type)) {\n      return slotRuntime(type, overrideProps, key, source, self);\n    }\n    warnIfElementTypeIsInvalid(type);\n    return runtime(type, overrideProps, key, source, self);\n  };\n}\n"],"names":["createJSX","runtime","slotRuntime","jsx","type","overrideProps","key","source","self","isSlot","createCompatSlotComponent","warnIfElementTypeIsInvalid"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAMgBA;;;eAAAA;;;;gCANO;iEACA;2CACmB;4CAEC;AAEpC,SAASA,UAAUC,OAAmB,EAAEC,WAA2B;IACxE,OAAO,SAASC,IACdC,IAA8B,EAC9BC,aAA2B,EAC3BC,GAAe,EACfC,MAAgB,EAChBC,IAAc;QAEd,QAAQ;QACR,wDAAwD;QACxD,qDAAqD;QACrD,IAAIC,IAAAA,sBAAAA,EAAcJ,gBAAgB;YAChC,OAAOH,YAAmBQ,IAAAA,oDAAAA,EAA0BN,MAAMC,gBAAgB,MAAMC,KAAKC,QAAQC;QAC/F;QACA,IAAIC,IAAAA,sBAAAA,EAAcL,OAAO;YACvB,OAAOF,YAAYE,MAAMC,eAAeC,KAAKC,QAAQC;QACvD;QACAG,IAAAA,sDAAAA,EAA2BP;QAC3B,OAAOH,QAAQG,MAAMC,eAAeC,KAAKC,QAAQC;IACnD;AACF"}

package/lib-commonjs/jsx/jsxDEVSlot.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jsxDEVSlot.js"],"sourcesContent":["import * as React from 'react';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { DevRuntime } from '../utils/DevRuntime';\nexport const jsxDEVSlot = (type, overrideProps, key, source, self)=>{\n    const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n    const props = {\n        ...slotProps,\n        ...overrideProps\n    };\n    if (renderFunction) {\n        // if runtime is static\n        if (source === true) {\n            return DevRuntime.jsxDEV(React.Fragment, {\n                children: renderFunction(elementType, {\n                    ...props,\n                    /**\n             * If the runtime is static then children is an array and this array won't be keyed.\n             * Then we should wrap children by a static fragment\n             * as there's no way to know if renderFunction will render statically or dynamically\n             */ children: DevRuntime.jsxDEV(React.Fragment, {\n                        children: props.children\n                    }, undefined, true, self)\n                })\n            }, key, false, self);\n        }\n        // if runtime is dynamic (source = false) things are simpler\n        return DevRuntime.jsxDEV(React.Fragment, {\n            children: renderFunction(elementType, props)\n        }, key, source, self);\n    }\n    return DevRuntime.jsxDEV(elementType, props, key, source, self);\n};\n"],"names":["jsxDEVSlot","type","overrideProps","key","source","self","elementType","renderFunction","props","slotProps","getMetadataFromSlotComponent","DevRuntime","jsxDEV","React","Fragment","children","undefined"],"mappings":";;;;+BAGaA;;;eAAAA;;;;iEAHU;8CACsB;4BAClB;AACpB,MAAMA,aAAa,CAACC,MAAMC,eAAeC,KAAKC,QAAQC;IACzD,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGC,IAAAA,0DAA4B,EAACT;IACvF,MAAMO,QAAQ;QACV,GAAGC,SAAS;QACZ,GAAGP,aAAa;IACpB;IACA,IAAIK,gBAAgB;QAChB,uBAAuB;QACvB,IAAIH,WAAW,MAAM;YACjB,OAAOO,sBAAU,CAACC,MAAM,CAACC,OAAMC,QAAQ,EAAE;gBACrCC,UAAUR,eAAeD,aAAa;oBAClC,GAAGE,KAAK;oBACR;;;;aAIP,GAAGO,UAAUJ,sBAAU,CAACC,MAAM,CAACC,OAAMC,QAAQ,EAAE;wBACpCC,UAAUP,MAAMO,QAAQ;oBAC5B,GAAGC,WAAW,MAAMX;gBACxB;YACJ,GAAGF,KAAK,OAAOE;QACnB;QACA,4DAA4D;QAC5D,OAAOM,sBAAU,CAACC,MAAM,CAACC,OAAMC,QAAQ,EAAE;YACrCC,UAAUR,eAAeD,aAAaE;QAC1C,GAAGL,KAAKC,QAAQC;IACpB;IACA,OAAOM,sBAAU,CAACC,MAAM,CAACN,aAAaE,OAAOL,KAAKC,QAAQC;AAC9D"}
+{"version":3,"sources":["jsxDEVSlot.ts"],"sourcesContent":["import * as React from 'react';\nimport { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { DevRuntime } from '../utils/DevRuntime';\n\nexport const jsxDEVSlot = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n  source?: unknown,\n  self?: unknown,\n): React.ReactElement<Props> => {\n  const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n\n  const props: Props = { ...slotProps, ...overrideProps };\n\n  if (renderFunction) {\n    // if runtime is static\n    if (source === true) {\n      return DevRuntime.jsxDEV(\n        React.Fragment,\n        {\n          children: renderFunction(elementType, {\n            ...props,\n            /**\n             * If the runtime is static then children is an array and this array won't be keyed.\n             * Then we should wrap children by a static fragment\n             * as there's no way to know if renderFunction will render statically or dynamically\n             */\n            children: DevRuntime.jsxDEV(React.Fragment, { children: props.children }, undefined, true, self),\n          }),\n        },\n        key,\n        false, // by marking source as false we're declaring that this render is dynamic\n        self,\n      ) as React.ReactElement<Props>;\n    }\n    // if runtime is dynamic (source = false) things are simpler\n    return DevRuntime.jsxDEV(\n      React.Fragment,\n      { children: renderFunction(elementType, props) },\n      key,\n      source,\n      self,\n    ) as React.ReactElement<Props>;\n  }\n  return DevRuntime.jsxDEV(elementType, props, key, source, self);\n};\n"],"names":["jsxDEVSlot","type","overrideProps","key","source","self","elementType","renderFunction","props","slotProps","getMetadataFromSlotComponent","DevRuntime","jsxDEV","React","Fragment","children","undefined"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAKaA;;;eAAAA;;;;iEALU;8CAEsB;4BAClB;AAEpB,MAAMA,aAAa,CACxBC,MACAC,eACAC,KACAC,QACAC;IAEA,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGC,IAAAA,0DAAAA,EAA6BT;IAEvF,MAAMO,QAAe;QAAE,GAAGC,SAAS;QAAE,GAAGP,aAAa;IAAC;IAEtD,IAAIK,gBAAgB;QAClB,uBAAuB;QACvB,IAAIH,WAAW,MAAM;YACnB,OAAOO,sBAAAA,CAAWC,MAAM,CACtBC,OAAMC,QAAQ,EACd;gBACEC,UAAUR,eAAeD,aAAa;oBACpC,GAAGE,KAAK;oBACR;;;;aAIC,GACDO,UAAUJ,sBAAAA,CAAWC,MAAM,CAACC,OAAMC,QAAQ,EAAE;wBAAEC,UAAUP,MAAMO,QAAQ;oBAAC,GAAGC,WAAW,MAAMX;gBAC7F;YACF,GACAF,KACA,OACAE;QAEJ;QACA,4DAA4D;QAC5D,OAAOM,sBAAAA,CAAWC,MAAM,CACtBC,OAAMC,QAAQ,EACd;YAAEC,UAAUR,eAAeD,aAAaE;QAAO,GAC/CL,KACAC,QACAC;IAEJ;IACA,OAAOM,sBAAAA,CAAWC,MAAM,CAACN,aAAaE,OAAOL,KAAKC,QAAQC;AAC5D"}

package/lib-commonjs/jsx/jsxSlot.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jsxSlot.js"],"sourcesContent":["import * as React from 'react';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { Runtime } from '../utils/Runtime';\nexport const jsxSlot = (type, overrideProps, key)=>{\n    const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n    const props = {\n        ...slotProps,\n        ...overrideProps\n    };\n    if (renderFunction) {\n        return Runtime.jsx(React.Fragment, {\n            children: renderFunction(elementType, props)\n        }, key);\n    }\n    return Runtime.jsx(elementType, props, key);\n};\n"],"names":["jsxSlot","type","overrideProps","key","elementType","renderFunction","props","slotProps","getMetadataFromSlotComponent","Runtime","jsx","React","Fragment","children"],"mappings":";;;;+BAGaA;;;eAAAA;;;;iEAHU;8CACsB;yBACrB;AACjB,MAAMA,UAAU,CAACC,MAAMC,eAAeC;IACzC,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGC,IAAAA,0DAA4B,EAACP;IACvF,MAAMK,QAAQ;QACV,GAAGC,SAAS;QACZ,GAAGL,aAAa;IACpB;IACA,IAAIG,gBAAgB;QAChB,OAAOI,gBAAO,CAACC,GAAG,CAACC,OAAMC,QAAQ,EAAE;YAC/BC,UAAUR,eAAeD,aAAaE;QAC1C,GAAGH;IACP;IACA,OAAOM,gBAAO,CAACC,GAAG,CAACN,aAAaE,OAAOH;AAC3C"}
+{"version":3,"sources":["jsxSlot.ts"],"sourcesContent":["import * as React from 'react';\nimport { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { Runtime } from '../utils/Runtime';\n\nexport const jsxSlot = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n): React.ReactElement<Props> => {\n  const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n\n  const props: Props = { ...slotProps, ...overrideProps };\n\n  if (renderFunction) {\n    return Runtime.jsx(\n      React.Fragment,\n      { children: renderFunction(elementType, props) },\n      key,\n    ) as React.ReactElement<Props>;\n  }\n  return Runtime.jsx(elementType, props, key);\n};\n"],"names":["jsxSlot","type","overrideProps","key","elementType","renderFunction","props","slotProps","getMetadataFromSlotComponent","Runtime","jsx","React","Fragment","children"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAKaA;;;eAAAA;;;;iEALU;8CAEsB;yBACrB;AAEjB,MAAMA,UAAU,CACrBC,MACAC,eACAC;IAEA,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGC,IAAAA,0DAAAA,EAA6BP;IAEvF,MAAMK,QAAe;QAAE,GAAGC,SAAS;QAAE,GAAGL,aAAa;IAAC;IAEtD,IAAIG,gBAAgB;QAClB,OAAOI,gBAAAA,CAAQC,GAAG,CAChBC,OAAMC,QAAQ,EACd;YAAEC,UAAUR,eAAeD,aAAaE;QAAO,GAC/CH;IAEJ;IACA,OAAOM,gBAAAA,CAAQC,GAAG,CAACN,aAAaE,OAAOH;AACzC"}

package/lib-commonjs/jsx/jsxsSlot.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jsxsSlot.js"],"sourcesContent":["import * as React from 'react';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { Runtime } from '../utils/Runtime';\nexport const jsxsSlot = (type, overrideProps, key)=>{\n    const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n    const props = {\n        ...slotProps,\n        ...overrideProps\n    };\n    if (renderFunction) {\n        /**\n     * In static runtime then children is an array and this array won't be keyed.\n     * We should wrap children by a static fragment\n     * as there's no way to know if renderFunction will render statically or dynamically\n     */ return Runtime.jsx(React.Fragment, {\n            children: renderFunction(elementType, {\n                ...props,\n                children: Runtime.jsxs(React.Fragment, {\n                    children: props.children\n                }, undefined)\n            })\n        }, key);\n    }\n    return Runtime.jsxs(elementType, props, key);\n};\n"],"names":["jsxsSlot","type","overrideProps","key","elementType","renderFunction","props","slotProps","getMetadataFromSlotComponent","Runtime","jsx","React","Fragment","children","jsxs","undefined"],"mappings":";;;;+BAGaA;;;eAAAA;;;;iEAHU;8CACsB;yBACrB;AACjB,MAAMA,WAAW,CAACC,MAAMC,eAAeC;IAC1C,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGC,IAAAA,0DAA4B,EAACP;IACvF,MAAMK,QAAQ;QACV,GAAGC,SAAS;QACZ,GAAGL,aAAa;IACpB;IACA,IAAIG,gBAAgB;QAChB;;;;KAIH,GAAG,OAAOI,gBAAO,CAACC,GAAG,CAACC,OAAMC,QAAQ,EAAE;YAC/BC,UAAUR,eAAeD,aAAa;gBAClC,GAAGE,KAAK;gBACRO,UAAUJ,gBAAO,CAACK,IAAI,CAACH,OAAMC,QAAQ,EAAE;oBACnCC,UAAUP,MAAMO,QAAQ;gBAC5B,GAAGE;YACP;QACJ,GAAGZ;IACP;IACA,OAAOM,gBAAO,CAACK,IAAI,CAACV,aAAaE,OAAOH;AAC5C"}
+{"version":3,"sources":["jsxsSlot.ts"],"sourcesContent":["import * as React from 'react';\nimport { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { Runtime } from '../utils/Runtime';\n\nexport const jsxsSlot = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n): React.ReactElement<Props> => {\n  const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n\n  const props: Props = { ...slotProps, ...overrideProps };\n\n  if (renderFunction) {\n    /**\n     * In static runtime then children is an array and this array won't be keyed.\n     * We should wrap children by a static fragment\n     * as there's no way to know if renderFunction will render statically or dynamically\n     */\n    return Runtime.jsx(\n      React.Fragment,\n      {\n        children: renderFunction(elementType, {\n          ...props,\n          children: Runtime.jsxs(React.Fragment, { children: props.children }, undefined),\n        }),\n      },\n      key,\n    ) as React.ReactElement<Props>;\n  }\n  return Runtime.jsxs(elementType, props, key);\n};\n"],"names":["jsxsSlot","type","overrideProps","key","elementType","renderFunction","props","slotProps","getMetadataFromSlotComponent","Runtime","jsx","React","Fragment","children","jsxs","undefined"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAKaA;;;eAAAA;;;;iEALU;8CAEsB;yBACrB;AAEjB,MAAMA,WAAW,CACtBC,MACAC,eACAC;IAEA,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGC,IAAAA,0DAAAA,EAA6BP;IAEvF,MAAMK,QAAe;QAAE,GAAGC,SAAS;QAAE,GAAGL,aAAa;IAAC;IAEtD,IAAIG,gBAAgB;QAClB;;;;KAIC,GACD,OAAOI,gBAAAA,CAAQC,GAAG,CAChBC,OAAMC,QAAQ,EACd;YACEC,UAAUR,eAAeD,aAAa;gBACpC,GAAGE,KAAK;gBACRO,UAAUJ,gBAAAA,CAAQK,IAAI,CAACH,OAAMC,QAAQ,EAAE;oBAAEC,UAAUP,MAAMO,QAAQ;gBAAC,GAAGE;YACvE;QACF,GACAZ;IAEJ;IACA,OAAOM,gBAAAA,CAAQK,IAAI,CAACV,aAAaE,OAAOH;AAC1C"}

package/lib-commonjs/jsx-dev-runtime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jsx-dev-runtime.js"],"sourcesContent":["import { createJSX } from './jsx/createJSX';\nimport { jsxDEVSlot } from './jsx/jsxDEVSlot';\nimport { DevRuntime } from './utils/DevRuntime';\nexport { Fragment } from 'react';\nexport const jsxDEV = createJSX(DevRuntime.jsxDEV, jsxDEVSlot);\n"],"names":["Fragment","jsxDEV","createJSX","DevRuntime","jsxDEVSlot"],"mappings":";;;;;;;;;;;IAGSA,QAAQ;eAARA,eAAQ;;IACJC,MAAM;eAANA;;;2BAJa;4BACC;4BACA;uBACF;AAClB,MAAMA,SAASC,IAAAA,oBAAS,EAACC,sBAAU,CAACF,MAAM,EAAEG,sBAAU"}
+{"version":3,"sources":["jsx-dev-runtime.ts"],"sourcesContent":["import { createJSX } from './jsx/createJSX';\nimport { jsxDEVSlot } from './jsx/jsxDEVSlot';\nimport { DevRuntime } from './utils/DevRuntime';\n\nexport { Fragment } from 'react';\n\nexport const jsxDEV = createJSX(DevRuntime.jsxDEV, jsxDEVSlot);\n"],"names":["Fragment","jsxDEV","createJSX","DevRuntime","jsxDEVSlot"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAISA,QAAQ;eAARA,eAAQ;;IAEJC,MAAAA;eAAAA;;;2BANa;4BACC;4BACA;uBAEF;AAElB,MAAMA,SAASC,IAAAA,oBAAAA,EAAUC,sBAAAA,CAAWF,MAAM,EAAEG,sBAAAA"}

package/lib-commonjs/jsx-runtime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jsx-runtime.js"],"sourcesContent":["import { createJSX } from './jsx/createJSX';\nimport { jsxSlot } from './jsx/jsxSlot';\nimport { jsxsSlot } from './jsx/jsxsSlot';\nimport { Runtime } from './utils/Runtime';\nexport { Fragment } from 'react';\nexport const jsx = createJSX(Runtime.jsx, jsxSlot);\nexport const jsxs = createJSX(Runtime.jsxs, jsxsSlot);\n"],"names":["Fragment","jsx","jsxs","createJSX","Runtime","jsxSlot","jsxsSlot"],"mappings":";;;;;;;;;;;IAISA,QAAQ;eAARA,eAAQ;;IACJC,GAAG;eAAHA;;IACAC,IAAI;eAAJA;;;2BANa;yBACF;0BACC;yBACD;uBACC;AAClB,MAAMD,MAAME,IAAAA,oBAAS,EAACC,gBAAO,CAACH,GAAG,EAAEI,gBAAO;AAC1C,MAAMH,OAAOC,IAAAA,oBAAS,EAACC,gBAAO,CAACF,IAAI,EAAEI,kBAAQ"}
+{"version":3,"sources":["jsx-runtime.ts"],"sourcesContent":["import { createJSX } from './jsx/createJSX';\nimport { jsxSlot } from './jsx/jsxSlot';\nimport { jsxsSlot } from './jsx/jsxsSlot';\nimport { Runtime } from './utils/Runtime';\n\nexport { Fragment } from 'react';\n\nexport const jsx = createJSX(Runtime.jsx, jsxSlot);\nexport const jsxs = createJSX(Runtime.jsxs, jsxsSlot);\n"],"names":["Fragment","jsx","jsxs","createJSX","Runtime","jsxSlot","jsxsSlot"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAKSA,QAAQ;eAARA,eAAQ;;IAEJC,GAAAA;eAAAA;;IACAC,IAAAA;eAAAA;;;2BARa;yBACF;0BACC;yBACD;uBAEC;AAElB,MAAMD,MAAME,IAAAA,oBAAAA,EAAUC,gBAAAA,CAAQH,GAAG,EAAEI,gBAAAA;AACnC,MAAMH,OAAOC,IAAAA,oBAAAA,EAAUC,gBAAAA,CAAQF,IAAI,EAAEI,kBAAAA"}

package/lib-commonjs/utils/DevRuntime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["DevRuntime.js"],"sourcesContent":["import * as ReactDevRuntime from 'react/jsx-dev-runtime';\nexport const DevRuntime = ReactDevRuntime;\n"],"names":["DevRuntime","ReactDevRuntime"],"mappings":";;;;+BACaA;;;eAAAA;;;;yEADoB;AAC1B,MAAMA,aAAaC"}
+{"version":3,"sources":["DevRuntime.ts"],"sourcesContent":["import * as ReactDevRuntime from 'react/jsx-dev-runtime';\nimport type { JSXRuntime } from './types';\n\nexport const DevRuntime = ReactDevRuntime as {\n  jsxDEV: JSXRuntime;\n};\n"],"names":["DevRuntime","ReactDevRuntime"],"rangeMappings":";;;;;;;;;;;;","mappings":";;;;+BAGaA;;;eAAAA;;;;yEAHoB;AAG1B,MAAMA,aAAaC"}

package/lib-commonjs/utils/Runtime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["Runtime.js"],"sourcesContent":["import * as ReactRuntime from 'react/jsx-runtime';\nexport const Runtime = ReactRuntime;\n"],"names":["Runtime","ReactRuntime"],"mappings":";;;;+BACaA;;;eAAAA;;;;sEADiB;AACvB,MAAMA,UAAUC"}
+{"version":3,"sources":["Runtime.ts"],"sourcesContent":["import * as ReactRuntime from 'react/jsx-runtime';\nimport type { JSXRuntime } from './types';\n\nexport const Runtime = ReactRuntime as {\n  jsx: JSXRuntime;\n  jsxs: JSXRuntime;\n};\n"],"names":["Runtime","ReactRuntime"],"rangeMappings":";;;;;;;;;;;;","mappings":";;;;+BAGaA;;;eAAAA;;;;sEAHiB;AAGvB,MAAMA,UAAUC"}

package/lib-commonjs/utils/createCompatSlotComponent.js.map

@@ -1 +1 @@
-{"version":3,"sources":["createCompatSlotComponent.js"],"sourcesContent":["import * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL } from '@fluentui/react-utilities';\n// TODO:\n// this is for backwards compatibility with getSlotsNext\n// it should be removed once getSlotsNext is obsolete\nexport function createCompatSlotComponent(type, props) {\n    return {\n        ...props,\n        [SLOT_ELEMENT_TYPE_SYMBOL]: type\n    };\n}\n"],"names":["createCompatSlotComponent","type","props","SLOT_ELEMENT_TYPE_SYMBOL"],"mappings":";;;;+BAKgBA;;;eAAAA;;;;iEALO;gCACkB;AAIlC,SAASA,0BAA0BC,IAAI,EAAEC,KAAK;IACjD,OAAO;QACH,GAAGA,KAAK;QACR,CAACC,wCAAwB,CAAC,EAAEF;IAChC;AACJ"}
+{"version":3,"sources":["createCompatSlotComponent.ts"],"sourcesContent":["import * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL } from '@fluentui/react-utilities';\nimport type { SlotComponentType } from '@fluentui/react-utilities';\n\n// TODO:\n// this is for backwards compatibility with getSlotsNext\n// it should be removed once getSlotsNext is obsolete\nexport function createCompatSlotComponent<P extends {}>(type: React.ElementType<P>, props: P): SlotComponentType<P> {\n  return {\n    ...props,\n    [SLOT_ELEMENT_TYPE_SYMBOL]: type,\n  } as SlotComponentType<P>;\n}\n"],"names":["createCompatSlotComponent","type","props","SLOT_ELEMENT_TYPE_SYMBOL"],"rangeMappings":";;;;;;;;;;;;;;;;;;","mappings":";;;;+BAOgBA;;;eAAAA;;;;iEAPO;gCACkB;AAMlC,SAASA,0BAAwCC,IAA0B,EAAEC,KAAQ;IAC1F,OAAO;QACL,GAAGA,KAAK;QACR,CAACC,wCAAAA,CAAyB,EAAEF;IAC9B;AACF"}

package/lib-commonjs/utils/getMetadataFromSlotComponent.js.map

@@ -1 +1 @@
-{"version":3,"sources":["getMetadataFromSlotComponent.js"],"sourcesContent":["import { SLOT_ELEMENT_TYPE_SYMBOL, SLOT_RENDER_FUNCTION_SYMBOL } from '@fluentui/react-utilities';\n/**\n * @internal\n */ export function getMetadataFromSlotComponent(type) {\n    const { as, [SLOT_ELEMENT_TYPE_SYMBOL]: baseElementType, [SLOT_RENDER_FUNCTION_SYMBOL]: renderFunction, ...propsWithoutMetadata } = type;\n    const props = propsWithoutMetadata;\n    const elementType = typeof baseElementType === 'string' ? as !== null && as !== void 0 ? as : baseElementType : baseElementType;\n    if (typeof elementType !== 'string' && as) {\n        props.as = as;\n    }\n    return {\n        elementType,\n        props,\n        renderFunction\n    };\n}\n"],"names":["getMetadataFromSlotComponent","type","as","SLOT_ELEMENT_TYPE_SYMBOL","baseElementType","SLOT_RENDER_FUNCTION_SYMBOL","renderFunction","propsWithoutMetadata","props","elementType"],"mappings":";;;;+BAGoBA;;;eAAAA;;;gCAHkD;AAG3D,SAASA,6BAA6BC,IAAI;IACjD,MAAM,EAAEC,EAAE,EAAE,CAACC,wCAAwB,CAAC,EAAEC,eAAe,EAAE,CAACC,2CAA2B,CAAC,EAAEC,cAAc,EAAE,GAAGC,sBAAsB,GAAGN;IACpI,MAAMO,QAAQD;IACd,MAAME,cAAc,OAAOL,oBAAoB,WAAWF,OAAO,QAAQA,OAAO,KAAK,IAAIA,KAAKE,kBAAkBA;IAChH,IAAI,OAAOK,gBAAgB,YAAYP,IAAI;QACvCM,MAAMN,EAAE,GAAGA;IACf;IACA,OAAO;QACHO;QACAD;QACAF;IACJ;AACJ"}
+{"version":3,"sources":["getMetadataFromSlotComponent.ts"],"sourcesContent":["import type * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL, SLOT_RENDER_FUNCTION_SYMBOL } from '@fluentui/react-utilities';\nimport type { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\n\n/**\n * @internal\n */\nexport function getMetadataFromSlotComponent<Props extends UnknownSlotProps>(type: SlotComponentType<Props>) {\n  const {\n    as,\n    [SLOT_ELEMENT_TYPE_SYMBOL]: baseElementType,\n    [SLOT_RENDER_FUNCTION_SYMBOL]: renderFunction,\n    ...propsWithoutMetadata\n  } = type;\n  const props = propsWithoutMetadata as UnknownSlotProps as Props;\n\n  const elementType = (\n    typeof baseElementType === 'string' ? as ?? baseElementType : baseElementType\n  ) as React.ElementType<Props>;\n\n  if (typeof elementType !== 'string' && as) {\n    props.as = as;\n  }\n  return { elementType, props, renderFunction };\n}\n"],"names":["getMetadataFromSlotComponent","type","as","SLOT_ELEMENT_TYPE_SYMBOL","baseElementType","SLOT_RENDER_FUNCTION_SYMBOL","renderFunction","propsWithoutMetadata","props","elementType"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAOgBA;;;eAAAA;;;gCANsD;AAM/D,SAASA,6BAA6DC,IAA8B;IACzG,MAAM,EACJC,EAAE,EACF,CAACC,wCAAAA,CAAyB,EAAEC,eAAe,EAC3C,CAACC,2CAAAA,CAA4B,EAAEC,cAAc,EAC7C,GAAGC,sBACJ,GAAGN;IACJ,MAAMO,QAAQD;IAEd,MAAME,cACJ,OAAOL,oBAAoB,WAAWF,OAAAA,QAAAA,OAAAA,KAAAA,IAAAA,KAAME,kBAAkBA;IAGhE,IAAI,OAAOK,gBAAgB,YAAYP,IAAI;QACzCM,MAAMN,EAAE,GAAGA;IACb;IACA,OAAO;QAAEO;QAAaD;QAAOF;IAAe;AAC9C"}

package/lib-commonjs/utils/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":""}
+{"version":3,"sources":["types.ts"],"sourcesContent":["import type * as React from 'react';\nimport type { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\n\nexport type JSXRuntime = <P extends {}>(\n  type: React.ElementType<P>,\n  props: P | null,\n  key?: React.Key,\n  source?: unknown,\n  self?: unknown,\n) => React.ReactElement<P>;\n\nexport type JSXSlotRuntime = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n  source?: unknown,\n  self?: unknown,\n) => React.ReactElement<Props>;\n"],"names":[],"rangeMappings":"","mappings":""}

package/lib-commonjs/utils/warnIfElementTypeIsInvalid.js.map

@@ -1 +1 @@
-{"version":3,"sources":["warnIfElementTypeIsInvalid.js"],"sourcesContent":["import * as React from 'react';\nimport { isValidElementType } from 'react-is';\nexport function warnIfElementTypeIsInvalid(type) {\n    if (process.env.NODE_ENV === 'development' && typeof type === 'object' && !isValidElementType(type)) {\n        // eslint-disable-next-line no-console\n        console.error(`@fluentui/react-jsx-runtime:\nElement type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: ${type}.\n\nIf this happened in a slot of Fluent UI component, you might be facing package resolution issues.\nPlease make sure you don't have multiple versions of \"@fluentui/react-utilities\" installed in your dependencies or sub-dependencies.\nYou can check this by searching up for matching entries in a lockfile produced by your package manager (yarn.lock, pnpm-lock.yaml or package-lock.json).`);\n    }\n}\n"],"names":["warnIfElementTypeIsInvalid","type","process","env","NODE_ENV","isValidElementType","console","error"],"mappings":";;;;+BAEgBA;;;eAAAA;;;;iEAFO;yBACY;AAC5B,SAASA,2BAA2BC,IAAI;IAC3C,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,iBAAiB,OAAOH,SAAS,YAAY,CAACI,IAAAA,2BAAkB,EAACJ,OAAO;QACjG,sCAAsC;QACtCK,QAAQC,KAAK,CAAC,CAAC;6HACsG,EAAEN,KAAK;;;;wJAIoB,CAAC;IACrJ;AACJ"}
+{"version":3,"sources":["warnIfElementTypeIsInvalid.ts"],"sourcesContent":["import * as React from 'react';\nimport { isValidElementType } from 'react-is';\n\nexport function warnIfElementTypeIsInvalid(type: React.ElementType) {\n  if (process.env.NODE_ENV === 'development' && typeof type === 'object' && !isValidElementType(type)) {\n    // eslint-disable-next-line no-console\n    console.error(/** #__DE-INDENT__ */ `\n        @fluentui/react-jsx-runtime:\n        Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: ${type}.\n\n        If this happened in a slot of Fluent UI component, you might be facing package resolution issues.\n        Please make sure you don't have multiple versions of \"@fluentui/react-utilities\" installed in your dependencies or sub-dependencies.\n        You can check this by searching up for matching entries in a lockfile produced by your package manager (yarn.lock, pnpm-lock.yaml or package-lock.json).\n      `);\n  }\n}\n"],"names":["warnIfElementTypeIsInvalid","type","process","env","NODE_ENV","isValidElementType","console","error"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAGgBA;;;eAAAA;;;;iEAHO;yBACY;AAE5B,SAASA,2BAA2BC,IAAuB;IAChE,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,iBAAiB,OAAOH,SAAS,YAAY,CAACI,IAAAA,2BAAAA,EAAmBJ,OAAO;QACnG,sCAAsC;QACtCK,QAAQC,KAAK,CAAuB,CAAC;6HAE4F,EAAEN,KAAK;;;;wJAKtI,CAAC;IACL;AACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluentui/react-jsx-runtime",
-  "version": "9.0.40",
+  "version": "9.0.41",
   "description": "Custom JSX runtime for @fluentui/react-components",
   "main": "lib-commonjs/index.js",
   "module": "lib/index.js",
@@ -31,7 +31,7 @@
     "@fluentui/scripts-tasks": "*"
   },
   "dependencies": {
-    "@fluentui/react-utilities": "^9.18.11",
+    "@fluentui/react-utilities": "^9.18.12",
     "react-is": "^17.0.2",
     "@swc/helpers": "^0.5.1"
   },