@carto/kepler.gl 0.1.0-alpha.0 → 0.1.0-next.0

package/dist/utils/table-utils/data-row.js

@@ -0,0 +1,124 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DataRow = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+/**
+ * Setting for shared row optimization.
+ * - False/undefined indicates that unique row objects should be used (default).
+ * - True indicates that a single temporary row object should be created and used without extra allocations.
+ * - A DataRow object indicates that the row should be used as a temporary shared row.
+ * When used, the content of the shared row isn't preserved between calls.
+ */
+/**
+ * Return type for createSharedRow:
+ * - DataRow object that should be used as shared row.
+ * - Falsy values indicate that shared row object shouldn't be used.
+ */
+var DataRow = exports.DataRow = /*#__PURE__*/function () {
+  /**
+   * Creates new DataRow.
+   * @param dataContainer Data container where data is stored. Can be initialized with null for shared rows.
+   * @param rowIndex Index of a row in the data container.
+   */
+  function DataRow(dataContainer, rowIndex) {
+    (0, _classCallCheck2["default"])(this, DataRow);
+    this._dataContainer = dataContainer;
+    this._rowIndex = rowIndex;
+  }
+
+  /**
+   * Conditionally creates a DataRow object.
+   * @param sharedRowDesc Accepts forllowing options:
+   * - true indicates that new DataRow should be created.
+   * - falsy value or a DataRow object is passed through without any change.
+   * @returns A new DataRow object or unchanged input argument.
+   */
+  return (0, _createClass2["default"])(DataRow, [{
+    key: "valueAt",
+    value:
+    /**
+     * Returns the value stored at the specified index in the row.
+     * @param columnIndex Index of the requested field in the row.
+     * @returns Value at the index.
+     */
+    function valueAt(columnIndex) {
+      var _this$_dataContainer;
+      return (_this$_dataContainer = this._dataContainer) === null || _this$_dataContainer === void 0 ? void 0 : _this$_dataContainer.valueAt(this._rowIndex, columnIndex);
+    }
+
+    /**
+     * Returns the row represented as an array.
+     * @returns The row represented as an array.
+     */
+  }, {
+    key: "values",
+    value: function values() {
+      return this._dataContainer ? this._dataContainer.rowAsArray(this._rowIndex) : [];
+    }
+
+    /**
+     * Setup a row object. The method is used by shared rows to prevent excessive allocations.
+     * @param dataContainer Data container.
+     * @param rowIndex Index of a row in the data container.
+     */
+  }, {
+    key: "setSource",
+    value: function setSource(dataContainer, rowIndex) {
+      this._dataContainer = dataContainer;
+      this._rowIndex = rowIndex;
+    }
+
+    /**
+     * Creates a new array populated with the results of calling the provided function
+     * on every element of the row.
+     * @param handler The callback is called with the following arguments:
+     * - elem: The current element being processed in the row.
+     * - index: The index of the current element being processed in the row.
+     * @returns A new array with each element being the result of the func callback.
+     */
+  }, {
+    key: "map",
+    value: function map(handler) {
+      var _this$_dataContainer2;
+      var numColumns = ((_this$_dataContainer2 = this._dataContainer) === null || _this$_dataContainer2 === void 0 ? void 0 : _this$_dataContainer2.numColumns()) || 0;
+      var out = [];
+      for (var column = 0; column < numColumns; ++column) {
+        out[column] = handler(this.valueAt(column), column);
+      }
+      return out;
+    }
+  }], [{
+    key: "createSharedRow",
+    value: function createSharedRow(sharedRowDesc) {
+      if (sharedRowDesc === true) {
+        return new DataRow(null, 0);
+      }
+      return sharedRowDesc;
+    }
+  }]);
+}();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DataRow","exports","dataContainer","rowIndex","_classCallCheck2","_dataContainer","_rowIndex","_createClass2","key","value","valueAt","columnIndex","_this$_dataContainer","values","rowAsArray","setSource","map","handler","_this$_dataContainer2","numColumns","out","column","createSharedRow","sharedRowDesc"],"sources":["../../../src/utils/table-utils/data-row.ts"],"sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {DataContainerInterface} from './data-container-interface';\n\n/**\n * Setting for shared row optimization.\n * - False/undefined indicates that unique row objects should be used (default).\n * - True indicates that a single temporary row object should be created and used without extra allocations.\n * - A DataRow object indicates that the row should be used as a temporary shared row.\n * When used, the content of the shared row isn't preserved between calls.\n */\nexport type SharedRowOptions = DataRow | boolean | undefined;\n/**\n * Return type for createSharedRow:\n * - DataRow object that should be used as shared row.\n * - Falsy values indicate that shared row object shouldn't be used.\n */\nexport type SharedRowOptionsResult = DataRow | false | undefined;\n\nexport class DataRow {\n  _dataContainer: DataContainerInterface | null;\n\n  _rowIndex: number;\n\n  /**\n   * Creates new DataRow.\n   * @param dataContainer Data container where data is stored. Can be initialized with null for shared rows.\n   * @param rowIndex Index of a row in the data container.\n   */\n  constructor(dataContainer: DataContainerInterface | null, rowIndex: number) {\n    this._dataContainer = dataContainer;\n    this._rowIndex = rowIndex;\n  }\n\n  /**\n   * Conditionally creates a DataRow object.\n   * @param sharedRowDesc Accepts forllowing options:\n   * - true indicates that new DataRow should be created.\n   * - falsy value or a DataRow object is passed through without any change.\n   * @returns A new DataRow object or unchanged input argument.\n   */\n  static createSharedRow(sharedRowDesc: SharedRowOptions): SharedRowOptionsResult {\n    if (sharedRowDesc === true) {\n      return new DataRow(null, 0);\n    }\n    return sharedRowDesc;\n  }\n\n  /**\n   * Returns the value stored at the specified index in the row.\n   * @param columnIndex Index of the requested field in the row.\n   * @returns Value at the index.\n   */\n  valueAt(columnIndex: number): any {\n    return this._dataContainer?.valueAt(this._rowIndex, columnIndex);\n  }\n\n  /**\n   * Returns the row represented as an array.\n   * @returns The row represented as an array.\n   */\n  values(): any[] {\n    return this._dataContainer ? this._dataContainer.rowAsArray(this._rowIndex) : [];\n  }\n\n  /**\n   * Setup a row object. The method is used by shared rows to prevent excessive allocations.\n   * @param dataContainer Data container.\n   * @param rowIndex Index of a row in the data container.\n   */\n  setSource(dataContainer: DataContainerInterface, rowIndex: number): void {\n    this._dataContainer = dataContainer;\n    this._rowIndex = rowIndex;\n  }\n\n  /**\n   * Creates a new array populated with the results of calling the provided function\n   * on every element of the row.\n   * @param handler The callback is called with the following arguments:\n   * - elem: The current element being processed in the row.\n   * - index: The index of the current element being processed in the row.\n   * @returns A new array with each element being the result of the func callback.\n   */\n  map(handler: (elem: any, index: number) => any): any[] {\n    const numColumns = this._dataContainer?.numColumns() || 0;\n    const out: any[] = [];\n    for (let column = 0; column < numColumns; ++column) {\n      out[column] = handler(this.valueAt(column), column);\n    }\n    return out;\n  }\n}\n"],"mappings":";;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAJA,IAOaA,OAAO,GAAAC,OAAA,CAAAD,OAAA;EAKlB;AACF;AACA;AACA;AACA;EACE,SAAAA,QAAYE,aAA4C,EAAEC,QAAgB,EAAE;IAAA,IAAAC,gBAAA,mBAAAJ,OAAA;IAC1E,IAAI,CAACK,cAAc,GAAGH,aAAa;IACnC,IAAI,CAACI,SAAS,GAAGH,QAAQ;EAC3B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;EANE,WAAAI,aAAA,aAAAP,OAAA;IAAAQ,GAAA;IAAAC,KAAA;IAcA;AACF;AACA;AACA;AACA;IACE,SAAAC,OAAOA,CAACC,WAAmB,EAAO;MAAA,IAAAC,oBAAA;MAChC,QAAAA,oBAAA,GAAO,IAAI,CAACP,cAAc,cAAAO,oBAAA,uBAAnBA,oBAAA,CAAqBF,OAAO,CAAC,IAAI,CAACJ,SAAS,EAAEK,WAAW,CAAC;IAClE;;IAEA;AACF;AACA;AACA;EAHE;IAAAH,GAAA;IAAAC,KAAA,EAIA,SAAAI,MAAMA,CAAA,EAAU;MACd,OAAO,IAAI,CAACR,cAAc,GAAG,IAAI,CAACA,cAAc,CAACS,UAAU,CAAC,IAAI,CAACR,SAAS,CAAC,GAAG,EAAE;IAClF;;IAEA;AACF;AACA;AACA;AACA;EAJE;IAAAE,GAAA;IAAAC,KAAA,EAKA,SAAAM,SAASA,CAACb,aAAqC,EAAEC,QAAgB,EAAQ;MACvE,IAAI,CAACE,cAAc,GAAGH,aAAa;MACnC,IAAI,CAACI,SAAS,GAAGH,QAAQ;IAC3B;;IAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EAPE;IAAAK,GAAA;IAAAC,KAAA,EAQA,SAAAO,GAAGA,CAACC,OAA0C,EAAS;MAAA,IAAAC,qBAAA;MACrD,IAAMC,UAAU,GAAG,EAAAD,qBAAA,OAAI,CAACb,cAAc,cAAAa,qBAAA,uBAAnBA,qBAAA,CAAqBC,UAAU,CAAC,CAAC,KAAI,CAAC;MACzD,IAAMC,GAAU,GAAG,EAAE;MACrB,KAAK,IAAIC,MAAM,GAAG,CAAC,EAAEA,MAAM,GAAGF,UAAU,EAAE,EAAEE,MAAM,EAAE;QAClDD,GAAG,CAACC,MAAM,CAAC,GAAGJ,OAAO,CAAC,IAAI,CAACP,OAAO,CAACW,MAAM,CAAC,EAAEA,MAAM,CAAC;MACrD;MACA,OAAOD,GAAG;IACZ;EAAC;IAAAZ,GAAA;IAAAC,KAAA,EAjDD,SAAOa,eAAeA,CAACC,aAA+B,EAA0B;MAC9E,IAAIA,aAAa,KAAK,IAAI,EAAE;QAC1B,OAAO,IAAIvB,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;MAC7B;MACA,OAAOuB,aAAa;IACtB;EAAC;AAAA","ignoreList":[]}

package/dist/utils/table-utils/index.d.ts

@@ -1 +1 @@
-export { createDataContainer, createIndexedDataContainer } from './data-container-utils';
+export { createDataContainer, createIndexedDataContainer } from './data-container-utils';

package/dist/utils/table-utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createDataContainer", {
+  enumerable: true,
+  get: function get() {
+    return _dataContainerUtils.createDataContainer;
+  }
+});
+Object.defineProperty(exports, "createIndexedDataContainer", {
+  enumerable: true,
+  get: function get() {
+    return _dataContainerUtils.createIndexedDataContainer;
+  }
+});
+var _dataContainerUtils = require("./data-container-utils");
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfZGF0YUNvbnRhaW5lclV0aWxzIiwicmVxdWlyZSJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy90YWJsZS11dGlscy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgKGMpIDIwMjIgVWJlciBUZWNobm9sb2dpZXMsIEluYy5cbi8vXG4vLyBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYSBjb3B5XG4vLyBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSBcIlNvZnR3YXJlXCIpLCB0byBkZWFsXG4vLyBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbiB0aGUgcmlnaHRzXG4vLyB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsIGFuZC9vciBzZWxsXG4vLyBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUgaXNcbi8vIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6XG4vL1xuLy8gVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW5cbi8vIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLlxuLy9cbi8vIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCBcIkFTIElTXCIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1Jcbi8vIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLFxuLy8gRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFXG4vLyBBVVRIT1JTIE9SIENPUFlSSUdIVCBIT0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSXG4vLyBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORyBGUk9NLFxuLy8gT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTlxuLy8gVEhFIFNPRlRXQVJFLlxuXG5leHBvcnQge2NyZWF0ZURhdGFDb250YWluZXIsIGNyZWF0ZUluZGV4ZWREYXRhQ29udGFpbmVyfSBmcm9tICcuL2RhdGEtY29udGFpbmVyLXV0aWxzJztcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFvQkEsSUFBQUEsbUJBQUEsR0FBQUMsT0FBQSIsImlnbm9yZUxpc3QiOltdfQ==

package/dist/utils/table-utils/indexed-data-container.d.ts

@@ -1,34 +1,34 @@
-import { DataContainerInterface, RangeOptions } from './data-container-interface';
-import { DataRow, SharedRowOptions } from './data-row';
-/**
- * A data container wrapper around another data container.
- * You have to pass an array of indices to reference rows in the parent data container.
- * For example indices [3, 4, 6, 8] means that IndexedDataContainer is going to have
- * 4 rows and row(2) points to 6th row in the referenced data container.
- */
-export declare class IndexedDataContainer implements DataContainerInterface {
-    _parentDataContainer: DataContainerInterface;
-    _indices: number[];
-    constructor(parentDataContainer: DataContainerInterface, indices: number[]);
-    numRows(): number;
-    numColumns(): number;
-    /**
-     * Remaps a local index to an index in the parent dataset
-     * @param rowIndex
-     * @returns number
-     */
-    _mappedRowIndex(rowIndex: number): number;
-    valueAt(rowIndex: number, columnIndex: number): any;
-    row(rowIndex: number, sharedRow?: SharedRowOptions): DataRow;
-    rowAsArray(rowIndex: number): any[];
-    rows(sharedRow?: SharedRowOptions): Generator<DataRow, any, unknown>;
-    column(columnIndex: number): Generator<any, any, unknown>;
-    getPlainIndex(): number[];
-    flattenData(): any[][];
-    map<T>(func: (row: DataRow, index: number) => T, sharedRow?: SharedRowOptions, options?: RangeOptions): T[];
-    mapIndex<T>(func: ({ index }: {
-        index: number;
-    }, dc: DataContainerInterface) => T, options?: RangeOptions): T[];
-    find(func: (row: DataRow, index: number) => boolean, sharedRow?: SharedRowOptions): DataRow | undefined;
-    reduce<T>(func: (acc: T, row: DataRow, index: number) => T, initialValue: T, sharedRow?: SharedRowOptions): T;
-}
+import { DataContainerInterface, RangeOptions } from './data-container-interface';
+import { DataRow, SharedRowOptions } from './data-row';
+/**
+ * A data container wrapper around another data container.
+ * You have to pass an array of indices to reference rows in the parent data container.
+ * For example indices [3, 4, 6, 8] means that IndexedDataContainer is going to have
+ * 4 rows and row(2) points to 6th row in the referenced data container.
+ */
+export declare class IndexedDataContainer implements DataContainerInterface {
+    _parentDataContainer: DataContainerInterface;
+    _indices: number[];
+    constructor(parentDataContainer: DataContainerInterface, indices: number[]);
+    numRows(): number;
+    numColumns(): number;
+    /**
+     * Remaps a local index to an index in the parent dataset
+     * @param rowIndex
+     * @returns number
+     */
+    _mappedRowIndex(rowIndex: number): number;
+    valueAt(rowIndex: number, columnIndex: number): any;
+    row(rowIndex: number, sharedRow?: SharedRowOptions): DataRow;
+    rowAsArray(rowIndex: number): any[];
+    rows(sharedRow?: SharedRowOptions): Generator<DataRow, any, unknown>;
+    column(columnIndex: number): Generator<any, any, unknown>;
+    getPlainIndex(): number[];
+    flattenData(): any[][];
+    map<T>(func: (row: DataRow, index: number) => T, sharedRow?: SharedRowOptions, options?: RangeOptions): T[];
+    mapIndex<T>(func: ({ index }: {
+        index: number;
+    }, dc: DataContainerInterface) => T, options?: RangeOptions): T[];
+    find(func: (row: DataRow, index: number) => boolean, sharedRow?: SharedRowOptions): DataRow | undefined;
+    reduce<T>(func: (acc: T, row: DataRow, index: number) => T, initialValue: T, sharedRow?: SharedRowOptions): T;
+}

package/dist/utils/table-utils/indexed-data-container.js

@@ -0,0 +1,228 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexedDataContainer = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _dataRow = require("./data-row");
+var _marked = /*#__PURE__*/_regenerator["default"].mark(rowsIterator),
+  _marked2 = /*#__PURE__*/_regenerator["default"].mark(columnIterator); // Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+/**
+ * @param dataContainer
+ * @param indices
+ * @param sharedRow
+ * @returns
+ */
+function rowsIterator(dataContainer, indices, sharedRow) {
+  var numRows, rowIndex, mappedRowIndex;
+  return _regenerator["default"].wrap(function rowsIterator$(_context) {
+    while (1) switch (_context.prev = _context.next) {
+      case 0:
+        numRows = indices.length;
+        rowIndex = 0;
+      case 2:
+        if (!(rowIndex < numRows)) {
+          _context.next = 9;
+          break;
+        }
+        mappedRowIndex = indices[rowIndex];
+        _context.next = 6;
+        return dataContainer.row(mappedRowIndex, sharedRow);
+      case 6:
+        ++rowIndex;
+        _context.next = 2;
+        break;
+      case 9:
+      case "end":
+        return _context.stop();
+    }
+  }, _marked);
+}
+
+/**
+ * @param dataContainer
+ * @param indices
+ * @param columnIndex
+ * @returns
+ */
+function columnIterator(dataContainer, indices, columnIndex) {
+  var numRows, rowIndex, mappedRowIndex;
+  return _regenerator["default"].wrap(function columnIterator$(_context2) {
+    while (1) switch (_context2.prev = _context2.next) {
+      case 0:
+        numRows = indices.length;
+        rowIndex = 0;
+      case 2:
+        if (!(rowIndex < numRows)) {
+          _context2.next = 9;
+          break;
+        }
+        mappedRowIndex = indices[rowIndex];
+        _context2.next = 6;
+        return dataContainer.valueAt(mappedRowIndex, columnIndex);
+      case 6:
+        ++rowIndex;
+        _context2.next = 2;
+        break;
+      case 9:
+      case "end":
+        return _context2.stop();
+    }
+  }, _marked2);
+}
+
+/**
+ * A data container wrapper around another data container.
+ * You have to pass an array of indices to reference rows in the parent data container.
+ * For example indices [3, 4, 6, 8] means that IndexedDataContainer is going to have
+ * 4 rows and row(2) points to 6th row in the referenced data container.
+ */
+var IndexedDataContainer = exports.IndexedDataContainer = /*#__PURE__*/function () {
+  function IndexedDataContainer(parentDataContainer, indices) {
+    (0, _classCallCheck2["default"])(this, IndexedDataContainer);
+    this._parentDataContainer = parentDataContainer;
+    this._indices = indices;
+  }
+  return (0, _createClass2["default"])(IndexedDataContainer, [{
+    key: "numRows",
+    value: function numRows() {
+      return this._indices.length;
+    }
+  }, {
+    key: "numColumns",
+    value: function numColumns() {
+      return this._parentDataContainer.numColumns();
+    }
+
+    /**
+     * Remaps a local index to an index in the parent dataset
+     * @param rowIndex
+     * @returns number
+     */
+  }, {
+    key: "_mappedRowIndex",
+    value: function _mappedRowIndex(rowIndex) {
+      return this._indices[rowIndex];
+    }
+  }, {
+    key: "valueAt",
+    value: function valueAt(rowIndex, columnIndex) {
+      return this._parentDataContainer.valueAt(this._mappedRowIndex(rowIndex), columnIndex);
+    }
+  }, {
+    key: "row",
+    value: function row(rowIndex, sharedRow) {
+      return this._parentDataContainer.row(this._mappedRowIndex(rowIndex), sharedRow);
+    }
+  }, {
+    key: "rowAsArray",
+    value: function rowAsArray(rowIndex) {
+      return this._parentDataContainer.rowAsArray(this._mappedRowIndex(rowIndex));
+    }
+  }, {
+    key: "rows",
+    value: function rows(sharedRow) {
+      return rowsIterator(this._parentDataContainer, this._indices, sharedRow);
+    }
+  }, {
+    key: "column",
+    value: function column(columnIndex) {
+      return columnIterator(this._parentDataContainer, this._indices, columnIndex);
+    }
+  }, {
+    key: "getPlainIndex",
+    value: function getPlainIndex() {
+      return this._indices.map(function (_, i) {
+        return i;
+      });
+    }
+  }, {
+    key: "flattenData",
+    value: function flattenData() {
+      var _this = this;
+      var tSharedRow = _dataRow.DataRow.createSharedRow(true);
+      return this._indices.map(function (_, i) {
+        return _this.row(i, tSharedRow).values();
+      }, this);
+    }
+  }, {
+    key: "map",
+    value: function map(func, sharedRow) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var _options$start = options.start,
+        start = _options$start === void 0 ? 0 : _options$start,
+        _options$end = options.end,
+        end = _options$end === void 0 ? this.numRows() : _options$end;
+      var endRow = Math.min(this.numRows(), end);
+      var tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+      var out = [];
+      for (var rowIndex = start; rowIndex < endRow; ++rowIndex) {
+        var row = this.row(rowIndex, tSharedRow);
+        out.push(func(row, rowIndex));
+      }
+      return out;
+    }
+  }, {
+    key: "mapIndex",
+    value: function mapIndex(func) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var _options$start2 = options.start,
+        start = _options$start2 === void 0 ? 0 : _options$start2,
+        _options$end2 = options.end,
+        end = _options$end2 === void 0 ? this.numRows() : _options$end2;
+      var endRow = Math.min(this.numRows(), end);
+      var out = [];
+      for (var rowIndex = start; rowIndex < endRow; ++rowIndex) {
+        out.push(func({
+          index: this._mappedRowIndex(rowIndex)
+        }, this._parentDataContainer));
+      }
+      return out;
+    }
+  }, {
+    key: "find",
+    value: function find(func, sharedRow) {
+      var tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+      for (var rowIndex = 0; rowIndex < this.numRows(); ++rowIndex) {
+        var row = this.row(rowIndex, tSharedRow);
+        if (func(row, rowIndex)) {
+          return row;
+        }
+      }
+      return undefined;
+    }
+  }, {
+    key: "reduce",
+    value: function reduce(func, initialValue, sharedRow) {
+      var tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+      for (var rowIndex = 0; rowIndex < this._indices.length; ++rowIndex) {
+        var row = this.row(rowIndex, tSharedRow);
+        initialValue = func(initialValue, row, rowIndex);
+      }
+      return initialValue;
+    }
+  }]);
+}();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_dataRow","require","_marked","_regenerator","mark","rowsIterator","_marked2","columnIterator","dataContainer","indices","sharedRow","numRows","rowIndex","mappedRowIndex","wrap","rowsIterator$","_context","prev","next","length","row","stop","columnIndex","columnIterator$","_context2","valueAt","IndexedDataContainer","exports","parentDataContainer","_classCallCheck2","_parentDataContainer","_indices","_createClass2","key","value","numColumns","_mappedRowIndex","rowAsArray","rows","column","getPlainIndex","map","_","i","flattenData","_this","tSharedRow","DataRow","createSharedRow","values","func","options","arguments","undefined","_options$start","start","_options$end","end","endRow","Math","min","out","push","mapIndex","_options$start2","_options$end2","index","find","reduce","initialValue"],"sources":["../../../src/utils/table-utils/indexed-data-container.ts"],"sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {DataContainerInterface, RangeOptions} from './data-container-interface';\nimport {DataRow, SharedRowOptions} from './data-row';\n\n/**\n * @param dataContainer\n * @param indices\n * @param sharedRow\n * @returns\n */\nfunction* rowsIterator(\n  dataContainer: DataContainerInterface,\n  indices: number[],\n  sharedRow: SharedRowOptions\n): Generator<DataRow> {\n  const numRows = indices.length;\n  for (let rowIndex = 0; rowIndex < numRows; ++rowIndex) {\n    const mappedRowIndex = indices[rowIndex];\n    yield dataContainer.row(mappedRowIndex, sharedRow);\n  }\n}\n\n/**\n * @param dataContainer\n * @param indices\n * @param columnIndex\n * @returns\n */\nfunction* columnIterator(\n  dataContainer: DataContainerInterface,\n  indices: number[],\n  columnIndex: number\n): Generator<any> {\n  const numRows = indices.length;\n  for (let rowIndex = 0; rowIndex < numRows; ++rowIndex) {\n    const mappedRowIndex = indices[rowIndex];\n    yield dataContainer.valueAt(mappedRowIndex, columnIndex);\n  }\n}\n\n/**\n * A data container wrapper around another data container.\n * You have to pass an array of indices to reference rows in the parent data container.\n * For example indices [3, 4, 6, 8] means that IndexedDataContainer is going to have\n * 4 rows and row(2) points to 6th row in the referenced data container.\n */\nexport class IndexedDataContainer implements DataContainerInterface {\n  _parentDataContainer: DataContainerInterface;\n  _indices: number[];\n\n  constructor(parentDataContainer: DataContainerInterface, indices: number[]) {\n    this._parentDataContainer = parentDataContainer;\n    this._indices = indices;\n  }\n\n  numRows(): number {\n    return this._indices.length;\n  }\n\n  numColumns(): number {\n    return this._parentDataContainer.numColumns();\n  }\n\n  /**\n   * Remaps a local index to an index in the parent dataset\n   * @param rowIndex\n   * @returns number\n   */\n  _mappedRowIndex(rowIndex: number): number {\n    return this._indices[rowIndex];\n  }\n\n  valueAt(rowIndex: number, columnIndex: number): any {\n    return this._parentDataContainer.valueAt(this._mappedRowIndex(rowIndex), columnIndex);\n  }\n\n  row(rowIndex: number, sharedRow?: SharedRowOptions): DataRow {\n    return this._parentDataContainer.row(this._mappedRowIndex(rowIndex), sharedRow);\n  }\n\n  rowAsArray(rowIndex: number): any[] {\n    return this._parentDataContainer.rowAsArray(this._mappedRowIndex(rowIndex));\n  }\n\n  rows(sharedRow?: SharedRowOptions) {\n    return rowsIterator(this._parentDataContainer, this._indices, sharedRow);\n  }\n\n  column(columnIndex: number) {\n    return columnIterator(this._parentDataContainer, this._indices, columnIndex);\n  }\n\n  getPlainIndex(): number[] {\n    return this._indices.map((_, i) => i);\n  }\n\n  flattenData(): any[][] {\n    const tSharedRow = DataRow.createSharedRow(true);\n\n    return this._indices.map((_, i) => {\n      return this.row(i, tSharedRow).values();\n    }, this);\n  }\n\n  map<T>(\n    func: (row: DataRow, index: number) => T,\n    sharedRow?: SharedRowOptions,\n    options: RangeOptions = {}\n  ): T[] {\n    const {start = 0, end = this.numRows()} = options;\n    const endRow = Math.min(this.numRows(), end);\n\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    const out: T[] = [];\n    for (let rowIndex = start; rowIndex < endRow; ++rowIndex) {\n      const row = this.row(rowIndex, tSharedRow);\n      out.push(func(row, rowIndex));\n    }\n    return out;\n  }\n\n  mapIndex<T>(\n    func: ({index}: {index: number}, dc: DataContainerInterface) => T,\n    options: RangeOptions = {}\n  ): T[] {\n    const {start = 0, end = this.numRows()} = options;\n    const endRow = Math.min(this.numRows(), end);\n\n    const out: T[] = [];\n    for (let rowIndex = start; rowIndex < endRow; ++rowIndex) {\n      out.push(func({index: this._mappedRowIndex(rowIndex)}, this._parentDataContainer));\n    }\n    return out;\n  }\n\n  find(\n    func: (row: DataRow, index: number) => boolean,\n    sharedRow?: SharedRowOptions\n  ): DataRow | undefined {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    for (let rowIndex = 0; rowIndex < this.numRows(); ++rowIndex) {\n      const row = this.row(rowIndex, tSharedRow);\n      if (func(row, rowIndex)) {\n        return row;\n      }\n    }\n    return undefined;\n  }\n\n  reduce<T>(\n    func: (acc: T, row: DataRow, index: number) => T,\n    initialValue: T,\n    sharedRow?: SharedRowOptions\n  ): T {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    for (let rowIndex = 0; rowIndex < this._indices.length; ++rowIndex) {\n      const row = this.row(rowIndex, tSharedRow);\n      initialValue = func(initialValue, row, rowIndex);\n    }\n    return initialValue;\n  }\n}\n"],"mappings":";;;;;;;;;;AAqBA,IAAAA,QAAA,GAAAC,OAAA;AAAqD,IAAAC,OAAA,gBAAAC,YAAA,YAAAC,IAAA,CAQ3CC,YAAY;EAAAC,QAAA,gBAAAH,YAAA,YAAAC,IAAA,CAkBZG,cAAc,GA/CxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAKA;AACA;AACA;AACA;AACA;AACA;AACA,SAAUF,YAAYA,CACpBG,aAAqC,EACrCC,OAAiB,EACjBC,SAA2B;EAAA,IAAAC,OAAA,EAAAC,QAAA,EAAAC,cAAA;EAAA,OAAAV,YAAA,YAAAW,IAAA,UAAAC,cAAAC,QAAA;IAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;MAAA;QAErBP,OAAO,GAAGF,OAAO,CAACU,MAAM;QACrBP,QAAQ,GAAG,CAAC;MAAA;QAAA,MAAEA,QAAQ,GAAGD,OAAO;UAAAK,QAAA,CAAAE,IAAA;UAAA;QAAA;QACjCL,cAAc,GAAGJ,OAAO,CAACG,QAAQ,CAAC;QAAAI,QAAA,CAAAE,IAAA;QACxC,OAAMV,aAAa,CAACY,GAAG,CAACP,cAAc,EAAEH,SAAS,CAAC;MAAA;QAFT,EAAEE,QAAQ;QAAAI,QAAA,CAAAE,IAAA;QAAA;MAAA;MAAA;QAAA,OAAAF,QAAA,CAAAK,IAAA;IAAA;EAAA,GAAAnB,OAAA;AAAA;;AAMvD;AACA;AACA;AACA;AACA;AACA;AACA,SAAUK,cAAcA,CACtBC,aAAqC,EACrCC,OAAiB,EACjBa,WAAmB;EAAA,IAAAX,OAAA,EAAAC,QAAA,EAAAC,cAAA;EAAA,OAAAV,YAAA,YAAAW,IAAA,UAAAS,gBAAAC,SAAA;IAAA,kBAAAA,SAAA,CAAAP,IAAA,GAAAO,SAAA,CAAAN,IAAA;MAAA;QAEbP,OAAO,GAAGF,OAAO,CAACU,MAAM;QACrBP,QAAQ,GAAG,CAAC;MAAA;QAAA,MAAEA,QAAQ,GAAGD,OAAO;UAAAa,SAAA,CAAAN,IAAA;UAAA;QAAA;QACjCL,cAAc,GAAGJ,OAAO,CAACG,QAAQ,CAAC;QAAAY,SAAA,CAAAN,IAAA;QACxC,OAAMV,aAAa,CAACiB,OAAO,CAACZ,cAAc,EAAES,WAAW,CAAC;MAAA;QAFf,EAAEV,QAAQ;QAAAY,SAAA,CAAAN,IAAA;QAAA;MAAA;MAAA;QAAA,OAAAM,SAAA,CAAAH,IAAA;IAAA;EAAA,GAAAf,QAAA;AAAA;;AAMvD;AACA;AACA;AACA;AACA;AACA;AALA,IAMaoB,oBAAoB,GAAAC,OAAA,CAAAD,oBAAA;EAI/B,SAAAA,qBAAYE,mBAA2C,EAAEnB,OAAiB,EAAE;IAAA,IAAAoB,gBAAA,mBAAAH,oBAAA;IAC1E,IAAI,CAACI,oBAAoB,GAAGF,mBAAmB;IAC/C,IAAI,CAACG,QAAQ,GAAGtB,OAAO;EACzB;EAAC,WAAAuB,aAAA,aAAAN,oBAAA;IAAAO,GAAA;IAAAC,KAAA,EAED,SAAAvB,OAAOA,CAAA,EAAW;MAChB,OAAO,IAAI,CAACoB,QAAQ,CAACZ,MAAM;IAC7B;EAAC;IAAAc,GAAA;IAAAC,KAAA,EAED,SAAAC,UAAUA,CAAA,EAAW;MACnB,OAAO,IAAI,CAACL,oBAAoB,CAACK,UAAU,CAAC,CAAC;IAC/C;;IAEA;AACF;AACA;AACA;AACA;EAJE;IAAAF,GAAA;IAAAC,KAAA,EAKA,SAAAE,eAAeA,CAACxB,QAAgB,EAAU;MACxC,OAAO,IAAI,CAACmB,QAAQ,CAACnB,QAAQ,CAAC;IAChC;EAAC;IAAAqB,GAAA;IAAAC,KAAA,EAED,SAAAT,OAAOA,CAACb,QAAgB,EAAEU,WAAmB,EAAO;MAClD,OAAO,IAAI,CAACQ,oBAAoB,CAACL,OAAO,CAAC,IAAI,CAACW,eAAe,CAACxB,QAAQ,CAAC,EAAEU,WAAW,CAAC;IACvF;EAAC;IAAAW,GAAA;IAAAC,KAAA,EAED,SAAAd,GAAGA,CAACR,QAAgB,EAAEF,SAA4B,EAAW;MAC3D,OAAO,IAAI,CAACoB,oBAAoB,CAACV,GAAG,CAAC,IAAI,CAACgB,eAAe,CAACxB,QAAQ,CAAC,EAAEF,SAAS,CAAC;IACjF;EAAC;IAAAuB,GAAA;IAAAC,KAAA,EAED,SAAAG,UAAUA,CAACzB,QAAgB,EAAS;MAClC,OAAO,IAAI,CAACkB,oBAAoB,CAACO,UAAU,CAAC,IAAI,CAACD,eAAe,CAACxB,QAAQ,CAAC,CAAC;IAC7E;EAAC;IAAAqB,GAAA;IAAAC,KAAA,EAED,SAAAI,IAAIA,CAAC5B,SAA4B,EAAE;MACjC,OAAOL,YAAY,CAAC,IAAI,CAACyB,oBAAoB,EAAE,IAAI,CAACC,QAAQ,EAAErB,SAAS,CAAC;IAC1E;EAAC;IAAAuB,GAAA;IAAAC,KAAA,EAED,SAAAK,MAAMA,CAACjB,WAAmB,EAAE;MAC1B,OAAOf,cAAc,CAAC,IAAI,CAACuB,oBAAoB,EAAE,IAAI,CAACC,QAAQ,EAAET,WAAW,CAAC;IAC9E;EAAC;IAAAW,GAAA;IAAAC,KAAA,EAED,SAAAM,aAAaA,CAAA,EAAa;MACxB,OAAO,IAAI,CAACT,QAAQ,CAACU,GAAG,CAAC,UAACC,CAAC,EAAEC,CAAC;QAAA,OAAKA,CAAC;MAAA,EAAC;IACvC;EAAC;IAAAV,GAAA;IAAAC,KAAA,EAED,SAAAU,WAAWA,CAAA,EAAY;MAAA,IAAAC,KAAA;MACrB,IAAMC,UAAU,GAAGC,gBAAO,CAACC,eAAe,CAAC,IAAI,CAAC;MAEhD,OAAO,IAAI,CAACjB,QAAQ,CAACU,GAAG,CAAC,UAACC,CAAC,EAAEC,CAAC,EAAK;QACjC,OAAOE,KAAI,CAACzB,GAAG,CAACuB,CAAC,EAAEG,UAAU,CAAC,CAACG,MAAM,CAAC,CAAC;MACzC,CAAC,EAAE,IAAI,CAAC;IACV;EAAC;IAAAhB,GAAA;IAAAC,KAAA,EAED,SAAAO,GAAGA,CACDS,IAAwC,EACxCxC,SAA4B,EAEvB;MAAA,IADLyC,OAAqB,GAAAC,SAAA,CAAAjC,MAAA,QAAAiC,SAAA,QAAAC,SAAA,GAAAD,SAAA,MAAG,CAAC,CAAC;MAE1B,IAAAE,cAAA,GAA0CH,OAAO,CAA1CI,KAAK;QAALA,KAAK,GAAAD,cAAA,cAAG,CAAC,GAAAA,cAAA;QAAAE,YAAA,GAA0BL,OAAO,CAA/BM,GAAG;QAAHA,GAAG,GAAAD,YAAA,cAAG,IAAI,CAAC7C,OAAO,CAAC,CAAC,GAAA6C,YAAA;MACtC,IAAME,MAAM,GAAGC,IAAI,CAACC,GAAG,CAAC,IAAI,CAACjD,OAAO,CAAC,CAAC,EAAE8C,GAAG,CAAC;MAE5C,IAAMX,UAAU,GAAGC,gBAAO,CAACC,eAAe,CAACtC,SAAS,CAAC;MAErD,IAAMmD,GAAQ,GAAG,EAAE;MACnB,KAAK,IAAIjD,QAAQ,GAAG2C,KAAK,EAAE3C,QAAQ,GAAG8C,MAAM,EAAE,EAAE9C,QAAQ,EAAE;QACxD,IAAMQ,GAAG,GAAG,IAAI,CAACA,GAAG,CAACR,QAAQ,EAAEkC,UAAU,CAAC;QAC1Ce,GAAG,CAACC,IAAI,CAACZ,IAAI,CAAC9B,GAAG,EAAER,QAAQ,CAAC,CAAC;MAC/B;MACA,OAAOiD,GAAG;IACZ;EAAC;IAAA5B,GAAA;IAAAC,KAAA,EAED,SAAA6B,QAAQA,CACNb,IAAiE,EAE5D;MAAA,IADLC,OAAqB,GAAAC,SAAA,CAAAjC,MAAA,QAAAiC,SAAA,QAAAC,SAAA,GAAAD,SAAA,MAAG,CAAC,CAAC;MAE1B,IAAAY,eAAA,GAA0Cb,OAAO,CAA1CI,KAAK;QAALA,KAAK,GAAAS,eAAA,cAAG,CAAC,GAAAA,eAAA;QAAAC,aAAA,GAA0Bd,OAAO,CAA/BM,GAAG;QAAHA,GAAG,GAAAQ,aAAA,cAAG,IAAI,CAACtD,OAAO,CAAC,CAAC,GAAAsD,aAAA;MACtC,IAAMP,MAAM,GAAGC,IAAI,CAACC,GAAG,CAAC,IAAI,CAACjD,OAAO,CAAC,CAAC,EAAE8C,GAAG,CAAC;MAE5C,IAAMI,GAAQ,GAAG,EAAE;MACnB,KAAK,IAAIjD,QAAQ,GAAG2C,KAAK,EAAE3C,QAAQ,GAAG8C,MAAM,EAAE,EAAE9C,QAAQ,EAAE;QACxDiD,GAAG,CAACC,IAAI,CAACZ,IAAI,CAAC;UAACgB,KAAK,EAAE,IAAI,CAAC9B,eAAe,CAACxB,QAAQ;QAAC,CAAC,EAAE,IAAI,CAACkB,oBAAoB,CAAC,CAAC;MACpF;MACA,OAAO+B,GAAG;IACZ;EAAC;IAAA5B,GAAA;IAAAC,KAAA,EAED,SAAAiC,IAAIA,CACFjB,IAA8C,EAC9CxC,SAA4B,EACP;MACrB,IAAMoC,UAAU,GAAGC,gBAAO,CAACC,eAAe,CAACtC,SAAS,CAAC;MAErD,KAAK,IAAIE,QAAQ,GAAG,CAAC,EAAEA,QAAQ,GAAG,IAAI,CAACD,OAAO,CAAC,CAAC,EAAE,EAAEC,QAAQ,EAAE;QAC5D,IAAMQ,GAAG,GAAG,IAAI,CAACA,GAAG,CAACR,QAAQ,EAAEkC,UAAU,CAAC;QAC1C,IAAII,IAAI,CAAC9B,GAAG,EAAER,QAAQ,CAAC,EAAE;UACvB,OAAOQ,GAAG;QACZ;MACF;MACA,OAAOiC,SAAS;IAClB;EAAC;IAAApB,GAAA;IAAAC,KAAA,EAED,SAAAkC,MAAMA,CACJlB,IAAgD,EAChDmB,YAAe,EACf3D,SAA4B,EACzB;MACH,IAAMoC,UAAU,GAAGC,gBAAO,CAACC,eAAe,CAACtC,SAAS,CAAC;MAErD,KAAK,IAAIE,QAAQ,GAAG,CAAC,EAAEA,QAAQ,GAAG,IAAI,CAACmB,QAAQ,CAACZ,MAAM,EAAE,EAAEP,QAAQ,EAAE;QAClE,IAAMQ,GAAG,GAAG,IAAI,CAACA,GAAG,CAACR,QAAQ,EAAEkC,UAAU,CAAC;QAC1CuB,YAAY,GAAGnB,IAAI,CAACmB,YAAY,EAAEjD,GAAG,EAAER,QAAQ,CAAC;MAClD;MACA,OAAOyD,YAAY;IACrB;EAAC;AAAA","ignoreList":[]}