@fluentui/react-utilities 0.0.0-nightly-20230317-1454.1 → 0.0.0-nightly-20230321-0440.1

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

@@ -1 +1 @@
-{"version":3,"sources":["../../lib/utils/index.js"],"sourcesContent":["export * from \"./clamp\";\nexport * from \"./getNativeElementProps\";\nexport * from \"./getRTLSafeKey\";\nexport * from \"./mergeCallbacks\";\nexport * from \"./omit\";\nexport * from \"./properties\";\nexport * from \"./isHTMLElement\";\nexport * from \"./isInteractiveHTMLElement\";\n//# sourceMappingURL=index.js.map"],"names":[],"mappings":";;;;;oBAAc;oBACA;oBACA;oBACA;oBACA;oBACA;oBACA;oBACA;CACd,iCAAiC"}
+{"version":3,"names":["tslib_1","__exportStar","require","exports"],"sources":["../../../../../../../../packages/react-components/react-utilities/src/utils/index.ts"],"sourcesContent":["export * from './clamp';\nexport * from './getNativeElementProps';\nexport * from './getRTLSafeKey';\nexport * from './mergeCallbacks';\nexport * from './omit';\nexport * from './properties';\nexport * from './isHTMLElement';\nexport * from './isInteractiveHTMLElement';\n"],"mappings":";;;;;;AAAAA,OAAA,CAAAC,YAAA,CAAAC,OAAA,aAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,6BAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,qBAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,sBAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,YAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,kBAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,qBAAAC,OAAA;AACAH,OAAA,CAAAC,YAAA,CAAAC,OAAA,gCAAAC,OAAA"}

package/lib-commonjs/utils/isHTMLElement.js

@@ -1,3 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isHTMLElement = void 0;
 /**
  * Verifies if a given node is an HTMLElement,
  * this method works seamlessly with frames and elements from different documents
@@ -11,17 +17,11 @@
  * isHTMLElement(event.target, {constructorName: 'HTMLInputElement'}) && event.target.value // some value
  * ```
  *
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "isHTMLElement", {
-    enumerable: true,
-    get: ()=>isHTMLElement
-});
+ */
 function isHTMLElement(element, options) {
-    const typedElement = element;
-    return Boolean(typedElement?.ownerDocument?.defaultView && typedElement instanceof typedElement.ownerDocument.defaultView[options?.constructorName ?? "HTMLElement"]);
-} //# sourceMappingURL=isHTMLElement.js.map
-
+  var _a, _b;
+  const typedElement = element;
+  return Boolean(((_a = typedElement === null || typedElement === void 0 ? void 0 : typedElement.ownerDocument) === null || _a === void 0 ? void 0 : _a.defaultView) && typedElement instanceof typedElement.ownerDocument.defaultView[(_b = options === null || options === void 0 ? void 0 : options.constructorName) !== null && _b !== void 0 ? _b : 'HTMLElement']);
+}
+exports.isHTMLElement = isHTMLElement;
 //# sourceMappingURL=isHTMLElement.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../lib/utils/isHTMLElement.js"],"sourcesContent":["/**\n * Verifies if a given node is an HTMLElement,\n * this method works seamlessly with frames and elements from different documents\n *\n * This is preferred over simply using `instanceof`.\n * Since `instanceof` might be problematic while operating with [multiple realms](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms)\n *\n * @example\n * ```ts\n * isHTMLElement(event.target) && event.target.focus()\n * isHTMLElement(event.target, {constructorName: 'HTMLInputElement'}) && event.target.value // some value\n * ```\n *\n */export function isHTMLElement(element, options) {\n  const typedElement = element;\n  return Boolean(typedElement?.ownerDocument?.defaultView && typedElement instanceof typedElement.ownerDocument.defaultView[options?.constructorName ?? \"HTMLElement\"]);\n}\n//# sourceMappingURL=isHTMLElement.js.map"],"names":["isHTMLElement","element","options","typedElement","Boolean","ownerDocument","defaultView","constructorName"],"mappings":"AAAA;;;;;;;;;;;;;CAaC;;;;+BAAkBA;;aAAAA;;AAAT,SAASA,cAAcC,OAAO,EAAEC,OAAO,EAAE;IACjD,MAAMC,eAAeF;IACrB,OAAOG,QAAQD,cAAcE,eAAeC,eAAeH,wBAAwBA,aAAaE,aAAa,CAACC,WAAW,CAACJ,SAASK,mBAAmB,cAAc;AACtK,EACA,yCAAyC"}
+{"version":3,"names":["isHTMLElement","element","options","typedElement","Boolean","_a","ownerDocument","defaultView","_b","constructorName","exports"],"sources":["../../../../../../../../packages/react-components/react-utilities/src/utils/isHTMLElement.ts"],"sourcesContent":["/**\n * Verifies if a given node is an HTMLElement,\n * this method works seamlessly with frames and elements from different documents\n *\n * This is preferred over simply using `instanceof`.\n * Since `instanceof` might be problematic while operating with [multiple realms](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms)\n *\n * @example\n * ```ts\n * isHTMLElement(event.target) && event.target.focus()\n * isHTMLElement(event.target, {constructorName: 'HTMLInputElement'}) && event.target.value // some value\n * ```\n *\n */\nexport function isHTMLElement<ConstructorName extends HTMLElementConstructorName = 'HTMLElement'>(\n  element?: unknown,\n  options?: {\n    /**\n     * Can be used to provide a custom constructor instead of `HTMLElement`,\n     * Like `HTMLInputElement` for example.\n     */\n    constructorName?: ConstructorName;\n  },\n): element is InstanceType<(typeof globalThis)[ConstructorName]> {\n  const typedElement = element as Node | null | undefined;\n  return Boolean(\n    typedElement?.ownerDocument?.defaultView &&\n      typedElement instanceof typedElement.ownerDocument.defaultView[options?.constructorName ?? 'HTMLElement'],\n  );\n}\n\n/**\n * @internal\n */\nexport type HTMLElementConstructorName =\n  | 'HTMLElement'\n  | 'HTMLAnchorElement'\n  | 'HTMLAreaElement'\n  | 'HTMLAudioElement'\n  | 'HTMLBaseElement'\n  | 'HTMLBodyElement'\n  | 'HTMLBRElement'\n  | 'HTMLButtonElement'\n  | 'HTMLCanvasElement'\n  | 'HTMLDataElement'\n  | 'HTMLDataListElement'\n  | 'HTMLDetailsElement'\n  | 'HTMLDialogElement'\n  | 'HTMLDivElement'\n  | 'HTMLDListElement'\n  | 'HTMLEmbedElement'\n  | 'HTMLFieldSetElement'\n  | 'HTMLFormElement'\n  | 'HTMLHeadingElement'\n  | 'HTMLHeadElement'\n  | 'HTMLHRElement'\n  | 'HTMLHtmlElement'\n  | 'HTMLIFrameElement'\n  | 'HTMLImageElement'\n  | 'HTMLInputElement'\n  | 'HTMLModElement'\n  | 'HTMLLabelElement'\n  | 'HTMLLegendElement'\n  | 'HTMLLIElement'\n  | 'HTMLLinkElement'\n  | 'HTMLMapElement'\n  | 'HTMLMetaElement'\n  | 'HTMLMeterElement'\n  | 'HTMLObjectElement'\n  | 'HTMLOListElement'\n  | 'HTMLOptGroupElement'\n  | 'HTMLOptionElement'\n  | 'HTMLOutputElement'\n  | 'HTMLParagraphElement'\n  | 'HTMLParamElement'\n  | 'HTMLPreElement'\n  | 'HTMLProgressElement'\n  | 'HTMLQuoteElement'\n  | 'HTMLSlotElement'\n  | 'HTMLScriptElement'\n  | 'HTMLSelectElement'\n  | 'HTMLSourceElement'\n  | 'HTMLSpanElement'\n  | 'HTMLStyleElement'\n  | 'HTMLTableElement'\n  | 'HTMLTableColElement'\n  | 'HTMLTableRowElement'\n  | 'HTMLTableSectionElement'\n  | 'HTMLTemplateElement'\n  | 'HTMLTextAreaElement'\n  | 'HTMLTimeElement'\n  | 'HTMLTitleElement'\n  | 'HTMLTrackElement'\n  | 'HTMLUListElement'\n  | 'HTMLVideoElement';\n"],"mappings":";;;;;;AAAA;;;;;;;;;;;;;;AAcA,SAAgBA,aAAaA,CAC3BC,OAAiB,EACjBC,OAMC;;EAED,MAAMC,YAAY,GAAGF,OAAkC;EACvD,OAAOG,OAAO,CACZ,EAAAC,EAAA,GAAAF,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEG,aAAa,cAAAD,EAAA,uBAAAA,EAAA,CAAEE,WAAW,KACtCJ,YAAY,YAAYA,YAAY,CAACG,aAAa,CAACC,WAAW,CAAC,CAAAC,EAAA,GAAAN,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEO,eAAe,cAAAD,EAAA,cAAAA,EAAA,GAAI,aAAa,CAAC,CAC5G;AACH;AAfAE,OAAA,CAAAV,aAAA,GAAAA,aAAA"}

package/lib-commonjs/utils/isInteractiveHTMLElement.js

@@ -1,25 +1,29 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "isInteractiveHTMLElement", {
-    enumerable: true,
-    get: ()=>isInteractiveHTMLElement
+  value: true
 });
-const _isHTMLElement = require("./isHTMLElement");
+exports.isInteractiveHTMLElement = void 0;
+const isHTMLElement_1 = /*#__PURE__*/require("./isHTMLElement");
+/**
+ * @internal
+ * Checks that the element has default behaviour from user input on click or 'Enter'/'Space' keys
+ */
 function isInteractiveHTMLElement(element) {
-    if (!(0, _isHTMLElement.isHTMLElement)(element)) {
-        return false;
-    }
-    const { tagName  } = element;
-    switch(tagName){
-        case "BUTTON":
-        case "A":
-        case "INPUT":
-        case "TEXTAREA":
-            return true;
-    }
-    return element.isContentEditable;
-} //# sourceMappingURL=isInteractiveHTMLElement.js.map
-
+  if (!isHTMLElement_1.isHTMLElement(element)) {
+    return false;
+  }
+  const {
+    tagName
+  } = element;
+  switch (tagName) {
+    case 'BUTTON':
+    case 'A':
+    case 'INPUT':
+    case 'TEXTAREA':
+      return true;
+  }
+  return element.isContentEditable;
+}
+exports.isInteractiveHTMLElement = isInteractiveHTMLElement;
 //# sourceMappingURL=isInteractiveHTMLElement.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../lib/utils/isInteractiveHTMLElement.js"],"sourcesContent":["import { isHTMLElement } from \"./isHTMLElement\";\n/**\n * @internal\n * Checks that the element has default behaviour from user input on click or 'Enter'/'Space' keys\n */\nexport function isInteractiveHTMLElement(element) {\n  if (!isHTMLElement(element)) {\n    return false;\n  }\n  const {\n    tagName\n  } = element;\n  switch (tagName) {\n    case \"BUTTON\":\n    case \"A\":\n    case \"INPUT\":\n    case \"TEXTAREA\":\n      return true;\n  }\n  return element.isContentEditable;\n}\n//# sourceMappingURL=isInteractiveHTMLElement.js.map"],"names":["isInteractiveHTMLElement","element","isHTMLElement","tagName","isContentEditable"],"mappings":";;;;+BAKgBA;;aAAAA;;+BALc;AAKvB,SAASA,yBAAyBC,OAAO,EAAE;IAChD,IAAI,CAACC,IAAAA,4BAAa,EAACD,UAAU;QAC3B,OAAO,KAAK;IACd,CAAC;IACD,MAAM,EACJE,QAAO,EACR,GAAGF;IACJ,OAAQE;QACN,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;YACH,OAAO,IAAI;IACf;IACA,OAAOF,QAAQG,iBAAiB;AAClC,EACA,oDAAoD"}
+{"version":3,"names":["isHTMLElement_1","require","isInteractiveHTMLElement","element","isHTMLElement","tagName","isContentEditable","exports"],"sources":["../../../../../../../../packages/react-components/react-utilities/src/utils/isInteractiveHTMLElement.ts"],"sourcesContent":["import { isHTMLElement } from './isHTMLElement';\n\n/**\n * @internal\n * Checks that the element has default behaviour from user input on click or 'Enter'/'Space' keys\n */\nexport function isInteractiveHTMLElement(element: unknown) {\n  if (!isHTMLElement(element)) {\n    return false;\n  }\n\n  const { tagName } = element;\n  switch (tagName) {\n    case 'BUTTON':\n    case 'A':\n    case 'INPUT':\n    case 'TEXTAREA':\n      return true;\n  }\n\n  return element.isContentEditable;\n}\n"],"mappings":";;;;;;AAAA,MAAAA,eAAA,gBAAAC,OAAA;AAEA;;;;AAIA,SAAgBC,wBAAwBA,CAACC,OAAgB;EACvD,IAAI,CAACH,eAAA,CAAAI,aAAa,CAACD,OAAO,CAAC,EAAE;IAC3B,OAAO,KAAK;;EAGd,MAAM;IAAEE;EAAO,CAAE,GAAGF,OAAO;EAC3B,QAAQE,OAAO;IACb,KAAK,QAAQ;IACb,KAAK,GAAG;IACR,KAAK,OAAO;IACZ,KAAK,UAAU;MACb,OAAO,IAAI;EAAC;EAGhB,OAAOF,OAAO,CAACG,iBAAiB;AAClC;AAfAC,OAAA,CAAAL,wBAAA,GAAAA,wBAAA"}

package/lib-commonjs/utils/mergeCallbacks.js

@@ -1,3 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeCallbacks = void 0;
 /**
  * @internal
  * Combine two event callbacks into a single callback function that calls each one in order.
@@ -20,19 +26,12 @@
  * @param callback2 - The second callback to be called, or undefined
  *
  * @returns A function that that calls the provided functions in order
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "mergeCallbacks", {
-    enumerable: true,
-    get: ()=>mergeCallbacks
-});
+ */
 function mergeCallbacks(callback1, callback2) {
-    return (...args)=>{
-        callback1?.(...args);
-        callback2?.(...args);
-    };
-} //# sourceMappingURL=mergeCallbacks.js.map
-
+  return (...args) => {
+    callback1 === null || callback1 === void 0 ? void 0 : callback1(...args);
+    callback2 === null || callback2 === void 0 ? void 0 : callback2(...args);
+  };
+}
+exports.mergeCallbacks = mergeCallbacks;
 //# sourceMappingURL=mergeCallbacks.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../lib/utils/mergeCallbacks.js"],"sourcesContent":["/**\n * @internal\n * Combine two event callbacks into a single callback function that calls each one in order.\n *\n * Usage example:\n * ```ts\n * state.slot.onChange = mergeCallbacks(state.slot.onChange, ev => {\n *   // Handle onChange\n * });\n * ```\n *\n * The primary use is to avoid the need to capture an existing callback (`state.slot.onChange` in the example) to a\n * local variable before replacing with a new listener that calls the existing one. This helps avoid bugs like:\n * * Infinite recursion by calling the re-assigned state.slot.onChange if it's not captured to a local variable.\n * * Missing a call to the original onChange due to an early return or other conditional.\n *\n * If you need a callback that is stable between renders, wrap the result in {@link useEventCallback}.\n *\n * @param callback1 - The first callback to be called, or undefined\n * @param callback2 - The second callback to be called, or undefined\n *\n * @returns A function that that calls the provided functions in order\n */export function mergeCallbacks(callback1, callback2) {\n  return (...args) => {\n    callback1?.(...args);\n    callback2?.(...args);\n  };\n}\n//# sourceMappingURL=mergeCallbacks.js.map"],"names":["mergeCallbacks","callback1","callback2","args"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;CAsBC;;;;+BAAkBA;;aAAAA;;AAAT,SAASA,eAAeC,SAAS,EAAEC,SAAS,EAAE;IACtD,OAAO,CAAC,GAAGC,OAAS;QAClBF,eAAeE;QACfD,eAAeC;IACjB;AACF,EACA,0CAA0C"}
+{"version":3,"names":["mergeCallbacks","callback1","callback2","args","exports"],"sources":["../../../../../../../../packages/react-components/react-utilities/src/utils/mergeCallbacks.ts"],"sourcesContent":["/**\n * @internal\n * Combine two event callbacks into a single callback function that calls each one in order.\n *\n * Usage example:\n * ```ts\n * state.slot.onChange = mergeCallbacks(state.slot.onChange, ev => {\n *   // Handle onChange\n * });\n * ```\n *\n * The primary use is to avoid the need to capture an existing callback (`state.slot.onChange` in the example) to a\n * local variable before replacing with a new listener that calls the existing one. This helps avoid bugs like:\n * * Infinite recursion by calling the re-assigned state.slot.onChange if it's not captured to a local variable.\n * * Missing a call to the original onChange due to an early return or other conditional.\n *\n * If you need a callback that is stable between renders, wrap the result in {@link useEventCallback}.\n *\n * @param callback1 - The first callback to be called, or undefined\n * @param callback2 - The second callback to be called, or undefined\n *\n * @returns A function that that calls the provided functions in order\n */\nexport function mergeCallbacks<Args extends unknown[]>(\n  callback1: ((...args: Args) => void) | undefined,\n  callback2: ((...args: Args) => void) | undefined,\n) {\n  return (...args: Args) => {\n    callback1?.(...args);\n    callback2?.(...args);\n  };\n}\n"],"mappings":";;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgBA,cAAcA,CAC5BC,SAAgD,EAChDC,SAAgD;EAEhD,OAAO,CAAC,GAAGC,IAAU,KAAI;IACvBF,SAAS,aAATA,SAAS,uBAATA,SAAS,CAAG,GAAGE,IAAI,CAAC;IACpBD,SAAS,aAATA,SAAS,uBAATA,SAAS,CAAG,GAAGC,IAAI,CAAC;EACtB,CAAC;AACH;AARAC,OAAA,CAAAJ,cAAA,GAAAA,cAAA"}

package/lib-commonjs/utils/omit.js

@@ -1,3 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.omit = void 0;
 /**
  * Tiny helper to do the minimal amount of work in duplicating an object but omitting some
  * props. This ends up faster than using object ...rest or reduce to filter.
@@ -10,24 +16,17 @@
  *
  * @param obj - The object to clone
  * @param exclusions - The array of keys to exclude
- */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "omit", {
-    enumerable: true,
-    get: ()=>omit
-});
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function omit(obj, exclusions) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const result = {};
-    for(const key in obj){
-        if (exclusions.indexOf(key) === -1 && obj.hasOwnProperty(key)) {
-            result[key] = obj[key];
-        }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const result = {};
+  for (const key in obj) {
+    if (exclusions.indexOf(key) === -1 && obj.hasOwnProperty(key)) {
+      result[key] = obj[key];
     }
-    return result;
-} //# sourceMappingURL=omit.js.map
-
+  }
+  return result;
+}
+exports.omit = omit;
 //# sourceMappingURL=omit.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../lib/utils/omit.js"],"sourcesContent":["/**\n * Tiny helper to do the minimal amount of work in duplicating an object but omitting some\n * props. This ends up faster than using object ...rest or reduce to filter.\n *\n * This behaves very much like filteredAssign, but does not merge many objects together,\n * uses an exclusion object map, and avoids spreads all for optimal performance.\n *\n * See perf test for background:\n * https://jsperf.com/omit-vs-rest-vs-reduce/1\n *\n * @param obj - The object to clone\n * @param exclusions - The array of keys to exclude\n */ // eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function omit(obj, exclusions) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const result = {};\n  for (const key in obj) {\n    if (exclusions.indexOf(key) === -1 && obj.hasOwnProperty(key)) {\n      result[key] = obj[key];\n    }\n  }\n  return result;\n}\n//# sourceMappingURL=omit.js.map"],"names":["omit","obj","exclusions","result","key","indexOf","hasOwnProperty"],"mappings":"AAAA;;;;;;;;;;;;CAYC,GAAG,8DAA8D;;;;;+BAClDA;;aAAAA;;AAAT,SAASA,KAAKC,GAAG,EAAEC,UAAU,EAAE;IACpC,8DAA8D;IAC9D,MAAMC,SAAS,CAAC;IAChB,IAAK,MAAMC,OAAOH,IAAK;QACrB,IAAIC,WAAWG,OAAO,CAACD,SAAS,CAAC,KAAKH,IAAIK,cAAc,CAACF,MAAM;YAC7DD,MAAM,CAACC,IAAI,GAAGH,GAAG,CAACG,IAAI;QACxB,CAAC;IACH;IACA,OAAOD;AACT,EACA,gCAAgC"}
+{"version":3,"names":["omit","obj","exclusions","result","key","indexOf","hasOwnProperty","exports"],"sources":["../../../../../../../../packages/react-components/react-utilities/src/utils/omit.ts"],"sourcesContent":["/**\n * Tiny helper to do the minimal amount of work in duplicating an object but omitting some\n * props. This ends up faster than using object ...rest or reduce to filter.\n *\n * This behaves very much like filteredAssign, but does not merge many objects together,\n * uses an exclusion object map, and avoids spreads all for optimal performance.\n *\n * See perf test for background:\n * https://jsperf.com/omit-vs-rest-vs-reduce/1\n *\n * @param obj - The object to clone\n * @param exclusions - The array of keys to exclude\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function omit<TObj extends Record<string, any>, Exclusions extends (keyof TObj)[]>(\n  obj: TObj,\n  exclusions: Exclusions,\n): Omit<TObj, Exclusions[number]> {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const result: Record<string, any> = {};\n\n  for (const key in obj) {\n    if (exclusions.indexOf(key) === -1 && obj.hasOwnProperty(key)) {\n      result[key] = obj[key];\n    }\n  }\n\n  return result as TObj;\n}\n"],"mappings":";;;;;;AAAA;;;;;;;;;;;;;AAaA;AACA,SAAgBA,IAAIA,CAClBC,GAAS,EACTC,UAAsB;EAEtB;EACA,MAAMC,MAAM,GAAwB,EAAE;EAEtC,KAAK,MAAMC,GAAG,IAAIH,GAAG,EAAE;IACrB,IAAIC,UAAU,CAACG,OAAO,CAACD,GAAG,CAAC,KAAK,CAAC,CAAC,IAAIH,GAAG,CAACK,cAAc,CAACF,GAAG,CAAC,EAAE;MAC7DD,MAAM,CAACC,GAAG,CAAC,GAAGH,GAAG,CAACG,GAAG,CAAC;;;EAI1B,OAAOD,MAAc;AACvB;AAdAI,OAAA,CAAAP,IAAA,GAAAA,IAAA"}