@elliemae/ds-legacy-accordion 1.0.0-rc.1

package/dist/cjs/DSAccordion.js

@@ -0,0 +1,52 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DSAccordion_exports = {};
+__export(DSAccordion_exports, {
+  DSAccordion: () => DSAccordion,
+  DSAccordionWithSchema: () => DSAccordionWithSchema,
+  default: () => DSAccordion_default
+});
+module.exports = __toCommonJS(DSAccordion_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_ds_legacy_props_helpers = require("@elliemae/ds-legacy-props-helpers");
+var import_AccordionContent = require("./parts/accordionContent/AccordionContent.js");
+var import_useAccordion = require("./config/useAccordion.js");
+var import_DSAccordionCTX = require("./DSAccordionCTX.js");
+var import_react_desc_prop_types = require("./react-desc-prop-types.js");
+var import_exported_related = require("./exported-related/index.js");
+const DSAccordion = (props) => {
+  const ctx = (0, import_useAccordion.useAccordion)(props);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_DSAccordionCTX.DSAccordionContext.Provider, { value: ctx, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_AccordionContent.AccordionContent, {}) });
+};
+DSAccordion.displayName = import_exported_related.DSAccordionName;
+const DSAccordionWithSchema = (0, import_ds_legacy_props_helpers.describe)(DSAccordion);
+DSAccordionWithSchema.propTypes = import_react_desc_prop_types.accordionPropTypes;
+var DSAccordion_default = DSAccordion;
+//# sourceMappingURL=DSAccordion.js.map

package/dist/cjs/DSAccordion.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/DSAccordion.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import type { WeakValidationMap } from 'react';\nimport React from 'react';\nimport { describe } from '@elliemae/ds-legacy-props-helpers';\nimport { AccordionContent } from './parts/accordionContent/AccordionContent.js';\nimport { useAccordion } from './config/useAccordion.js';\nimport { DSAccordionContext } from './DSAccordionCTX.js';\nimport { accordionPropTypes } from './react-desc-prop-types.js';\nimport type { DSAccordionT } from './react-desc-prop-types.js';\nimport { DSAccordionName } from './exported-related/index.js';\n\nconst DSAccordion = (props: DSAccordionT.Props): JSX.Element => {\n  const ctx = useAccordion(props);\n\n  return (\n    <DSAccordionContext.Provider value={ctx}>\n      <AccordionContent />\n    </DSAccordionContext.Provider>\n  );\n};\n\nDSAccordion.displayName = DSAccordionName;\nconst DSAccordionWithSchema = describe(DSAccordion);\nDSAccordionWithSchema.propTypes = accordionPropTypes as WeakValidationMap<unknown>;\n\nexport { DSAccordion, DSAccordionWithSchema };\n\nexport default DSAccordion;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADejB;AAbN,qCAAyB;AACzB,8BAAiC;AACjC,0BAA6B;AAC7B,4BAAmC;AACnC,mCAAmC;AAEnC,8BAAgC;AAEhC,MAAM,cAAc,CAAC,UAA2C;AAC9D,QAAM,UAAM,kCAAa,KAAK;AAE9B,SACE,4CAAC,yCAAmB,UAAnB,EAA4B,OAAO,KAClC,sDAAC,4CAAiB,GACpB;AAEJ;AAEA,YAAY,cAAc;AAC1B,MAAM,4BAAwB,yCAAS,WAAW;AAClD,sBAAsB,YAAY;AAIlC,IAAO,sBAAQ;",
+  "names": []
+}

package/dist/cjs/DSAccordionCTX.js

@@ -0,0 +1,38 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DSAccordionCTX_exports = {};
+__export(DSAccordionCTX_exports, {
+  DSAccordionContext: () => DSAccordionContext
+});
+module.exports = __toCommonJS(DSAccordionCTX_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+const defaultContext = {};
+const DSAccordionContext = (0, import_react.createContext)(defaultContext);
+//# sourceMappingURL=DSAccordionCTX.js.map

package/dist/cjs/DSAccordionCTX.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/DSAccordionCTX.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { createContext } from 'react';\nimport type { DSAccordionT } from './react-desc-prop-types.js';\nimport type { DSAccordionInternalsT } from './sharedTypes.js';\n\ninterface DSAccordionContextT {\n  props: DSAccordionT.InternalProps;\n  actualActiveValue: DSAccordionInternalsT.InternalActiveValue;\n  setActiveValues: (value: string | number, e: React.MouseEvent | React.KeyboardEvent) => void;\n  focusableChildrenReferences: DSAccordionInternalsT.FocusableChildrenReferences[];\n  allChildrenReferences: DSAccordionInternalsT.AllChildrenReferences;\n}\n\nconst defaultContext = {} as DSAccordionContextT;\n\nexport const DSAccordionContext = createContext<DSAccordionContextT>(defaultContext);\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAA8B;AAY9B,MAAM,iBAAiB,CAAC;AAEjB,MAAM,yBAAqB,4BAAmC,cAAc;",
+  "names": []
+}

package/dist/cjs/config/useAccordion.js

@@ -0,0 +1,80 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useAccordion_exports = {};
+__export(useAccordion_exports, {
+  useAccordion: () => useAccordion
+});
+module.exports = __toCommonJS(useAccordion_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_ds_legacy_props_helpers = require("@elliemae/ds-legacy-props-helpers");
+var import_useAccordionRefs = require("./useAccordionRefs.js");
+var import_defaultProps = require("../defaultProps.js");
+const useAccordion = (props) => {
+  const propsWithDefaults = (0, import_ds_legacy_props_helpers.useMemoMergePropsWithDefault)(props, import_defaultProps.defaultProps);
+  const { activeValue, allowMultipleOpen, onChange } = propsWithDefaults;
+  const { focusableChildrenReferences, allChildrenReferences } = (0, import_useAccordionRefs.useAccordionRefs)(propsWithDefaults);
+  const [internalActiveValue, setInternalActiveValue] = (0, import_react.useState)(activeValue);
+  const actualActiveValue = (0, import_react.useMemo)(() => {
+    if (activeValue === void 0)
+      return internalActiveValue;
+    return activeValue;
+  }, [activeValue, internalActiveValue]);
+  const setActiveValues = (0, import_react.useCallback)(
+    (value, e) => {
+      let newState;
+      if (allowMultipleOpen && (actualActiveValue === void 0 || actualActiveValue === null))
+        newState = [value];
+      else if (allowMultipleOpen && Array.isArray(actualActiveValue))
+        if (!actualActiveValue.some((currentValues) => currentValues === value))
+          newState = [...actualActiveValue, value];
+        else
+          newState = actualActiveValue.filter((currentValues) => currentValues !== value);
+      else if (actualActiveValue === value)
+        newState = null;
+      else
+        newState = value;
+      setInternalActiveValue(newState);
+      return onChange(newState, e);
+    },
+    [actualActiveValue, allowMultipleOpen, onChange]
+  );
+  const ctx = (0, import_react.useMemo)(
+    () => ({
+      props: propsWithDefaults,
+      actualActiveValue,
+      setActiveValues,
+      focusableChildrenReferences,
+      allChildrenReferences
+    }),
+    [actualActiveValue, allChildrenReferences, focusableChildrenReferences, propsWithDefaults, setActiveValues]
+  );
+  return ctx;
+};
+//# sourceMappingURL=useAccordion.js.map

package/dist/cjs/config/useAccordion.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/config/useAccordion.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import type React from 'react';\nimport { useMemo, useState, useCallback } from 'react';\nimport { useMemoMergePropsWithDefault } from '@elliemae/ds-legacy-props-helpers';\nimport { useAccordionRefs } from './useAccordionRefs.js';\nimport { defaultProps } from '../defaultProps.js';\nimport type { DSAccordionT } from '../react-desc-prop-types.js';\nimport type { DSAccordionInternalsT } from '../sharedTypes.js';\n\ninterface DSAccordionUseAccordionContextT {\n  props: DSAccordionT.InternalProps;\n  actualActiveValue: DSAccordionInternalsT.InternalActiveValue;\n  setActiveValues: (value: string | number, e: React.MouseEvent | React.KeyboardEvent) => void;\n  focusableChildrenReferences: DSAccordionInternalsT.FocusableChildrenReferences[];\n  allChildrenReferences: DSAccordionInternalsT.AllChildrenReferences;\n}\n\nexport const useAccordion = (props: DSAccordionT.Props): DSAccordionUseAccordionContextT => {\n  const propsWithDefaults = useMemoMergePropsWithDefault(props, defaultProps) as DSAccordionT.InternalProps;\n\n  const { activeValue, allowMultipleOpen, onChange } = propsWithDefaults;\n\n  const { focusableChildrenReferences, allChildrenReferences } = useAccordionRefs(propsWithDefaults);\n\n  const [internalActiveValue, setInternalActiveValue] =\n    useState<DSAccordionInternalsT.InternalActiveValue>(activeValue);\n\n  const actualActiveValue = useMemo(() => {\n    if (activeValue === undefined) return internalActiveValue;\n    return activeValue;\n  }, [activeValue, internalActiveValue]);\n\n  const setActiveValues = useCallback(\n    (value: string | number, e: React.MouseEvent | React.KeyboardEvent) => {\n      let newState: DSAccordionInternalsT.InternalActiveValue;\n      if (allowMultipleOpen && (actualActiveValue === undefined || actualActiveValue === null)) newState = [value];\n      else if (allowMultipleOpen && Array.isArray(actualActiveValue))\n        if (!actualActiveValue.some((currentValues: string | number) => currentValues === value))\n          newState = [...actualActiveValue, value];\n        else newState = actualActiveValue.filter((currentValues: string | number) => currentValues !== value);\n      else if (actualActiveValue === value) newState = null;\n      else newState = value;\n      setInternalActiveValue(newState);\n      return onChange(newState, e);\n    },\n    [actualActiveValue, allowMultipleOpen, onChange],\n  );\n  const ctx = useMemo(\n    () => ({\n      props: propsWithDefaults,\n      actualActiveValue,\n      setActiveValues,\n      focusableChildrenReferences,\n      allChildrenReferences,\n    }),\n    [actualActiveValue, allChildrenReferences, focusableChildrenReferences, propsWithDefaults, setActiveValues],\n  );\n\n  return ctx;\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,mBAA+C;AAC/C,qCAA6C;AAC7C,8BAAiC;AACjC,0BAA6B;AAYtB,MAAM,eAAe,CAAC,UAA+D;AAC1F,QAAM,wBAAoB,6DAA6B,OAAO,gCAAY;AAE1E,QAAM,EAAE,aAAa,mBAAmB,SAAS,IAAI;AAErD,QAAM,EAAE,6BAA6B,sBAAsB,QAAI,0CAAiB,iBAAiB;AAEjG,QAAM,CAAC,qBAAqB,sBAAsB,QAChD,uBAAoD,WAAW;AAEjE,QAAM,wBAAoB,sBAAQ,MAAM;AACtC,QAAI,gBAAgB;AAAW,aAAO;AACtC,WAAO;AAAA,EACT,GAAG,CAAC,aAAa,mBAAmB,CAAC;AAErC,QAAM,sBAAkB;AAAA,IACtB,CAAC,OAAwB,MAA8C;AACrE,UAAI;AACJ,UAAI,sBAAsB,sBAAsB,UAAa,sBAAsB;AAAO,mBAAW,CAAC,KAAK;AAAA,eAClG,qBAAqB,MAAM,QAAQ,iBAAiB;AAC3D,YAAI,CAAC,kBAAkB,KAAK,CAAC,kBAAmC,kBAAkB,KAAK;AACrF,qBAAW,CAAC,GAAG,mBAAmB,KAAK;AAAA;AACpC,qBAAW,kBAAkB,OAAO,CAAC,kBAAmC,kBAAkB,KAAK;AAAA,eAC7F,sBAAsB;AAAO,mBAAW;AAAA;AAC5C,mBAAW;AAChB,6BAAuB,QAAQ;AAC/B,aAAO,SAAS,UAAU,CAAC;AAAA,IAC7B;AAAA,IACA,CAAC,mBAAmB,mBAAmB,QAAQ;AAAA,EACjD;AACA,QAAM,UAAM;AAAA,IACV,OAAO;AAAA,MACL,OAAO;AAAA,MACP;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA,CAAC,mBAAmB,uBAAuB,6BAA6B,mBAAmB,eAAe;AAAA,EAC5G;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/cjs/config/useAccordionRefs.js

@@ -0,0 +1,51 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useAccordionRefs_exports = {};
+__export(useAccordionRefs_exports, {
+  useAccordionRefs: () => useAccordionRefs
+});
+module.exports = __toCommonJS(useAccordionRefs_exports);
+var React = __toESM(require("react"));
+var import_react = __toESM(require("react"));
+const useAccordionRefs = ({ children }) => (0, import_react.useMemo)(() => {
+  const focusableChildrenReferences = [];
+  const allChildrenReferences = {};
+  const filteredChildren = import_react.default.Children.toArray(children).filter(
+    (child) => child !== void 0 && child !== null
+  );
+  filteredChildren.map((child, index) => {
+    const { value, disabled } = child.props;
+    const currentRef = import_react.default.createRef();
+    allChildrenReferences[index] = currentRef;
+    if (!disabled)
+      focusableChildrenReferences.push({ index, value, ref: currentRef });
+  });
+  return { focusableChildrenReferences, allChildrenReferences };
+}, [children]);
+//# sourceMappingURL=useAccordionRefs.js.map

package/dist/cjs/config/useAccordionRefs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/config/useAccordionRefs.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React, { useMemo } from 'react';\nimport type { DSAccordionT } from '../react-desc-prop-types.js';\nimport type { DSAccordionInternalsT } from '../sharedTypes.js';\n\ninterface UseAccordionRefsPropsT {\n  children: React.ReactElement<DSAccordionT.InternalItemProps>[];\n}\n\ninterface UseAccordionRefsReturnTypeT {\n  focusableChildrenReferences: DSAccordionInternalsT.FocusableChildrenReferences[];\n  allChildrenReferences: DSAccordionInternalsT.AllChildrenReferences;\n}\n\nexport const useAccordionRefs = ({ children }: UseAccordionRefsPropsT): UseAccordionRefsReturnTypeT =>\n  useMemo(() => {\n    const focusableChildrenReferences: DSAccordionInternalsT.FocusableChildrenReferences[] = [];\n    const allChildrenReferences: DSAccordionInternalsT.AllChildrenReferences = {};\n\n    const filteredChildren = React.Children.toArray(children).filter(\n      (child) => child !== undefined && child !== null,\n    ) as React.ReactElement<DSAccordionT.InternalItemProps>[];\n\n    filteredChildren.map((child: React.ReactElement<DSAccordionT.InternalItemProps>, index) => {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n      const { value, disabled } = child.props;\n      const currentRef = React.createRef<HTMLButtonElement>();\n      allChildrenReferences[index] = currentRef;\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n      if (!disabled) focusableChildrenReferences.push({ index, value, ref: currentRef });\n    });\n    return { focusableChildrenReferences, allChildrenReferences };\n  }, [children]);\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAA+B;AAaxB,MAAM,mBAAmB,CAAC,EAAE,SAAS,UAC1C,sBAAQ,MAAM;AACZ,QAAM,8BAAmF,CAAC;AAC1F,QAAM,wBAAqE,CAAC;AAE5E,QAAM,mBAAmB,aAAAA,QAAM,SAAS,QAAQ,QAAQ,EAAE;AAAA,IACxD,CAAC,UAAU,UAAU,UAAa,UAAU;AAAA,EAC9C;AAEA,mBAAiB,IAAI,CAAC,OAA2D,UAAU;AAEzF,UAAM,EAAE,OAAO,SAAS,IAAI,MAAM;AAClC,UAAM,aAAa,aAAAA,QAAM,UAA6B;AACtD,0BAAsB,KAAK,IAAI;AAE/B,QAAI,CAAC;AAAU,kCAA4B,KAAK,EAAE,OAAO,OAAO,KAAK,WAAW,CAAC;AAAA,EACnF,CAAC;AACD,SAAO,EAAE,6BAA6B,sBAAsB;AAC9D,GAAG,CAAC,QAAQ,CAAC;",
+  "names": ["React"]
+}

package/dist/cjs/defaultProps.js

@@ -0,0 +1,63 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var defaultProps_exports = {};
+__export(defaultProps_exports, {
+  accordionItemDefaultProps: () => accordionItemDefaultProps,
+  defaultProps: () => defaultProps
+});
+module.exports = __toCommonJS(defaultProps_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_ds_legacy_icons = require("@elliemae/ds-legacy-icons");
+const DefaultIconClosed = (0, import_react.memo)(
+  ({ isDSMobile = false }) => isDSMobile ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ds_legacy_icons.ChevronRight, { width: "20px", color: ["brand-primary", "800"] }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ds_legacy_icons.ArrowheadRight, { width: "20px" })
+);
+const DefaultIconOpen = (0, import_react.memo)(
+  ({ isDSMobile = false }) => isDSMobile ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ds_legacy_icons.ChevronDown, { width: "20px", color: ["brand-primary", "800"] }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ds_legacy_icons.ArrowheadDown, { width: "20px" })
+);
+const noop = () => {
+};
+const defaultProps = {
+  containerProps: {},
+  allowMultipleOpen: false,
+  onChange: noop,
+  children: [],
+  isDSMobile: false
+};
+const accordionItemDefaultProps = {
+  iconClosed: DefaultIconClosed,
+  iconOpened: DefaultIconOpen,
+  title: "",
+  customActions: [],
+  disabled: false,
+  xStyledPropsContent: {},
+  keepContentMounted: false
+};
+//# sourceMappingURL=defaultProps.js.map

package/dist/cjs/defaultProps.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/defaultProps.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React, { memo } from 'react';\nimport { ArrowheadRight, ArrowheadDown, ChevronRight, ChevronDown } from '@elliemae/ds-legacy-icons';\nimport type { DSAccordionInternalsT } from './sharedTypes.js';\nimport type { DSAccordionT } from './react-desc-prop-types.js';\n\nconst DefaultIconClosed = memo(({ isDSMobile = false }: DSAccordionInternalsT.DefaultIconProps) =>\n  isDSMobile ? <ChevronRight width=\"20px\" color={['brand-primary', '800']} /> : <ArrowheadRight width=\"20px\" />,\n);\n\nconst DefaultIconOpen = memo(({ isDSMobile = false }: DSAccordionInternalsT.DefaultIconProps) =>\n  isDSMobile ? <ChevronDown width=\"20px\" color={['brand-primary', '800']} /> : <ArrowheadDown width=\"20px\" />,\n);\n\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nconst noop = (): void => {};\n\nexport const defaultProps: DSAccordionT.DefaultProps = {\n  containerProps: {},\n  allowMultipleOpen: false,\n  onChange: noop,\n  children: [],\n  isDSMobile: false,\n};\n\nexport const accordionItemDefaultProps: DSAccordionT.ItemDefaultProps = {\n  iconClosed: DefaultIconClosed,\n  iconOpened: DefaultIconOpen,\n  title: '',\n  customActions: [],\n  disabled: false,\n  xStyledPropsContent: {},\n  keepContentMounted: false,\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADMR;AANf,mBAA4B;AAC5B,6BAAyE;AAIzE,MAAM,wBAAoB;AAAA,EAAK,CAAC,EAAE,aAAa,MAAM,MACnD,aAAa,4CAAC,uCAAa,OAAM,QAAO,OAAO,CAAC,iBAAiB,KAAK,GAAG,IAAK,4CAAC,yCAAe,OAAM,QAAO;AAC7G;AAEA,MAAM,sBAAkB;AAAA,EAAK,CAAC,EAAE,aAAa,MAAM,MACjD,aAAa,4CAAC,sCAAY,OAAM,QAAO,OAAO,CAAC,iBAAiB,KAAK,GAAG,IAAK,4CAAC,wCAAc,OAAM,QAAO;AAC3G;AAGA,MAAM,OAAO,MAAY;AAAC;AAEnB,MAAM,eAA0C;AAAA,EACrD,gBAAgB,CAAC;AAAA,EACjB,mBAAmB;AAAA,EACnB,UAAU;AAAA,EACV,UAAU,CAAC;AAAA,EACX,YAAY;AACd;AAEO,MAAM,4BAA2D;AAAA,EACtE,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,OAAO;AAAA,EACP,eAAe,CAAC;AAAA,EAChB,UAAU;AAAA,EACV,qBAAqB,CAAC;AAAA,EACtB,oBAAoB;AACtB;",
+  "names": []
+}

package/dist/cjs/exported-related/DSAccordionDefinitions.js

@@ -0,0 +1,58 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DSAccordionDefinitions_exports = {};
+__export(DSAccordionDefinitions_exports, {
+  DSAccordionDataTestid: () => DSAccordionDataTestid,
+  DSAccordionName: () => DSAccordionName,
+  DSAccordionSlots: () => DSAccordionSlots
+});
+module.exports = __toCommonJS(DSAccordionDefinitions_exports);
+var React = __toESM(require("react"));
+var import_ds_legacy_system = require("@elliemae/ds-legacy-system");
+const DSAccordionName = "DSAccordion";
+const DSAccordionSlots = {
+  CONTAINER: "root",
+  ITEM_CONTAINER: "item-container",
+  ITEM_HEADER_CONTAINER: "item-header-container",
+  ITEM_HEADER_ADDON: "item-header-addon",
+  ITEM_HEADER_TITLE_CONTAINER: "item-header-titles-container",
+  ITEM_HEADER_PRIMARY_TITLE: "item-header-primary-title",
+  ITEM_HEADER_SECONDARY_TITLE: "item-header-secondary-title",
+  ITEM_HEADER_CUSTOM_ACTIONS_CONTAINER: "item-header-custom-actions-container",
+  ITEM_HEADER_TOOLTIP: "item-header-tooltip",
+  ITEM_CONTENT_CONTAINER: "item-content-container"
+};
+const DSAccordionDataTestid = {
+  ...(0, import_ds_legacy_system.slotObjectToDataTestIds)(DSAccordionName, DSAccordionSlots),
+  ITEM_CONTENT_CONTAINER: "ds-accordion_item-content",
+  ITEM_HEADER_CONTAINER: "ds-accordion_item-header",
+  ITEM_CONTAINER: "ds-accordion_item",
+  CONTAINER: "ds-accordion_group"
+};
+//# sourceMappingURL=DSAccordionDefinitions.js.map

package/dist/cjs/exported-related/DSAccordionDefinitions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/exported-related/DSAccordionDefinitions.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { slotObjectToDataTestIds } from '@elliemae/ds-legacy-system';\n\nexport const DSAccordionName = 'DSAccordion';\n\nexport const DSAccordionSlots = {\n  CONTAINER: 'root',\n  ITEM_CONTAINER: 'item-container',\n  ITEM_HEADER_CONTAINER: 'item-header-container',\n  ITEM_HEADER_ADDON: 'item-header-addon',\n  ITEM_HEADER_TITLE_CONTAINER: 'item-header-titles-container',\n  ITEM_HEADER_PRIMARY_TITLE: 'item-header-primary-title',\n  ITEM_HEADER_SECONDARY_TITLE: 'item-header-secondary-title',\n  ITEM_HEADER_CUSTOM_ACTIONS_CONTAINER: 'item-header-custom-actions-container',\n  ITEM_HEADER_TOOLTIP: 'item-header-tooltip',\n  ITEM_CONTENT_CONTAINER: 'item-content-container',\n};\n\nexport const DSAccordionDataTestid = {\n  ...slotObjectToDataTestIds(DSAccordionName, DSAccordionSlots),\n  ITEM_CONTENT_CONTAINER: 'ds-accordion_item-content',\n  ITEM_HEADER_CONTAINER: 'ds-accordion_item-header',\n  ITEM_CONTAINER: 'ds-accordion_item',\n  CONTAINER: 'ds-accordion_group',\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,8BAAwC;AAEjC,MAAM,kBAAkB;AAExB,MAAM,mBAAmB;AAAA,EAC9B,WAAW;AAAA,EACX,gBAAgB;AAAA,EAChB,uBAAuB;AAAA,EACvB,mBAAmB;AAAA,EACnB,6BAA6B;AAAA,EAC7B,2BAA2B;AAAA,EAC3B,6BAA6B;AAAA,EAC7B,sCAAsC;AAAA,EACtC,qBAAqB;AAAA,EACrB,wBAAwB;AAC1B;AAEO,MAAM,wBAAwB;AAAA,EACnC,OAAG,iDAAwB,iBAAiB,gBAAgB;AAAA,EAC5D,wBAAwB;AAAA,EACxB,uBAAuB;AAAA,EACvB,gBAAgB;AAAA,EAChB,WAAW;AACb;",
+  "names": []
+}

package/dist/cjs/exported-related/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var exported_related_exports = {};
+module.exports = __toCommonJS(exported_related_exports);
+var React = __toESM(require("react"));
+__reExport(exported_related_exports, require("./DSAccordionDefinitions.js"), module.exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/exported-related/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/exported-related/index.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export * from './DSAccordionDefinitions.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;ACAA,YAAuB;ADAvB,qCAAc,wCAAd;",
+  "names": []
+}

package/dist/cjs/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  default: () => import_DSAccordion.default
+});
+module.exports = __toCommonJS(src_exports);
+var React = __toESM(require("react"));
+__reExport(src_exports, require("./DSAccordion.js"), module.exports);
+__reExport(src_exports, require("./parts/accordionItem/DSAccordionItem.js"), module.exports);
+__reExport(src_exports, require("./exported-related/index.js"), module.exports);
+var import_DSAccordion = __toESM(require("./DSAccordion.js"));
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import {} from '@xstyled/system';\nimport {} from '@xstyled/util';\nexport * from './DSAccordion.js';\nexport * from './parts/accordionItem/DSAccordionItem.js';\nexport * from './exported-related/index.js';\n\nexport { default } from './DSAccordion.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADEvB,wBAAc,6BAFd;AAGA,wBAAc,qDAHd;AAIA,wBAAc,wCAJd;AAMA,yBAAwB;",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1,7 @@
+{
+  "type": "commonjs",
+  "sideEffects": [
+    "*.css",
+    "*.scss"
+  ]
+}

package/dist/cjs/parts/accordionContent/AccordionContent.js

@@ -0,0 +1,71 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AccordionContent_exports = {};
+__export(AccordionContent_exports, {
+  AccordionContent: () => AccordionContent
+});
+module.exports = __toCommonJS(AccordionContent_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = __toESM(require("react"));
+var import_ds_legacy_props_helpers = require("@elliemae/ds-legacy-props-helpers");
+var import_DSAccordionCTX = require("../../DSAccordionCTX.js");
+var import_DSAccordionDefinitions = require("../../exported-related/DSAccordionDefinitions.js");
+var import_styles = require("./styles.js");
+var import_lodash = require("lodash");
+const AccordionContent = () => {
+  const { props } = (0, import_react.useContext)(import_DSAccordionCTX.DSAccordionContext);
+  const getOwnerProps = (0, import_react.useCallback)(() => props, [props]);
+  const getOwnerPropsArguments = (0, import_react.useCallback)(() => ({}), []);
+  const { containerProps, children, ...rest } = props;
+  const restWithoutOnChange = (0, import_lodash.omit)(rest, "onChange");
+  const childrenWithIndex = [];
+  const xstyledAttrs = (0, import_ds_legacy_props_helpers.useGetXstyledProps)(restWithoutOnChange);
+  const globalAttrs = (0, import_ds_legacy_props_helpers.useGetGlobalAttributes)(restWithoutOnChange);
+  import_react.default.Children.toArray(children).filter((child) => child !== void 0 && child !== null).forEach(
+    (child, index) => childrenWithIndex.push(
+      import_react.default.cloneElement(child, {
+        dsIndex: index
+      })
+    )
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_styles.StyledContainer,
+    {
+      "data-testid": import_DSAccordionDefinitions.DSAccordionDataTestid.CONTAINER,
+      ...containerProps,
+      ...globalAttrs,
+      ...xstyledAttrs,
+      getOwnerProps,
+      getOwnerPropsArguments,
+      children: childrenWithIndex
+    }
+  );
+};
+//# sourceMappingURL=AccordionContent.js.map

package/dist/cjs/parts/accordionContent/AccordionContent.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/parts/accordionContent/AccordionContent.tsx", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React, { useCallback, useContext } from 'react';\nimport { useGetGlobalAttributes, useGetXstyledProps } from '@elliemae/ds-legacy-props-helpers';\nimport { DSAccordionContext } from '../../DSAccordionCTX.js';\nimport { DSAccordionDataTestid } from '../../exported-related/DSAccordionDefinitions.js';\nimport { StyledContainer } from './styles.js';\nimport type { DSAccordionT } from '../../react-desc-prop-types.js';\nimport { omit } from 'lodash';\n\nexport const AccordionContent = (): JSX.Element => {\n  const { props } = useContext(DSAccordionContext);\n\n  const getOwnerProps = useCallback(() => props, [props]);\n  const getOwnerPropsArguments = useCallback(() => ({}), []);\n\n  const { containerProps, children, ...rest } = props;\n\n  const restWithoutOnChange = omit(rest, 'onChange');\n\n  const childrenWithIndex: React.ReactElement<DSAccordionT.InternalItemProps>[] = [];\n\n  const xstyledAttrs = useGetXstyledProps(restWithoutOnChange);\n\n  const globalAttrs = useGetGlobalAttributes(restWithoutOnChange);\n\n  React.Children.toArray(children)\n    .filter((child) => child !== undefined && child !== null)\n    .forEach((child, index) =>\n      childrenWithIndex.push(\n        React.cloneElement(child, {\n          dsIndex: index,\n        }),\n      ),\n    );\n\n  return (\n    <StyledContainer\n      data-testid={DSAccordionDataTestid.CONTAINER}\n      {...containerProps}\n      {...globalAttrs}\n      {...xstyledAttrs}\n      getOwnerProps={getOwnerProps}\n      getOwnerPropsArguments={getOwnerPropsArguments}\n    >\n      {childrenWithIndex}\n    </StyledContainer>\n  );\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADmCnB;AAnCJ,mBAA+C;AAC/C,qCAA2D;AAC3D,4BAAmC;AACnC,oCAAsC;AACtC,oBAAgC;AAEhC,oBAAqB;AAEd,MAAM,mBAAmB,MAAmB;AACjD,QAAM,EAAE,MAAM,QAAI,yBAAW,wCAAkB;AAE/C,QAAM,oBAAgB,0BAAY,MAAM,OAAO,CAAC,KAAK,CAAC;AACtD,QAAM,6BAAyB,0BAAY,OAAO,CAAC,IAAI,CAAC,CAAC;AAEzD,QAAM,EAAE,gBAAgB,UAAU,GAAG,KAAK,IAAI;AAE9C,QAAM,0BAAsB,oBAAK,MAAM,UAAU;AAEjD,QAAM,oBAA0E,CAAC;AAEjF,QAAM,mBAAe,mDAAmB,mBAAmB;AAE3D,QAAM,kBAAc,uDAAuB,mBAAmB;AAE9D,eAAAA,QAAM,SAAS,QAAQ,QAAQ,EAC5B,OAAO,CAAC,UAAU,UAAU,UAAa,UAAU,IAAI,EACvD;AAAA,IAAQ,CAAC,OAAO,UACf,kBAAkB;AAAA,MAChB,aAAAA,QAAM,aAAa,OAAO;AAAA,QACxB,SAAS;AAAA,MACX,CAAC;AAAA,IACH;AAAA,EACF;AAEF,SACE;AAAA,IAAC;AAAA;AAAA,MACC,eAAa,oDAAsB;AAAA,MAClC,GAAG;AAAA,MACH,GAAG;AAAA,MACH,GAAG;AAAA,MACJ;AAAA,MACA;AAAA,MAEC;AAAA;AAAA,EACH;AAEJ;",
+  "names": ["React"]
+}