@kepler.gl/mcp 0.0.0-stage → 3.3.0-alpha.20

package/dist/esm/commands/utils.js

@@ -0,0 +1,521 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Pure helpers shared by the map.* commands and the analysis shims. These are
+ * dependency-light (apache-arrow only) and free of kepler-app state, so they
+ * live in the map surface package and are re-exported for the analysis layer
+ * (kepler-assistant) to import.
+ */
+
+import { Type } from 'apache-arrow';
+import { LAYER_TYPES } from '@kepler.gl/constants';
+import { arrowSchemaToFields } from '@kepler.gl/processors';
+
+/** Type for a Redux dispatch function, used by tools that need to dispatch kepler actions */
+
+/**
+ * Deterministically convert a dataset name into a valid DuckDB table name.
+ * Replaces non-alphanumeric characters (except underscores) with underscores,
+ * collapses consecutive underscores, trims leading/trailing underscores,
+ * lowercases the result, and prepends 'tbl_' to avoid reserved-word collisions.
+ */
+export function datasetNameToTableName(datasetName) {
+  var sanitized = datasetName.replace(/[^a-zA-Z0-9_]/g, '_').replace(/_+/g, '_').replace(/^_+|_+$/g, '').toLowerCase();
+  return "tbl_".concat(sanitized || 'unnamed');
+}
+
+/**
+ * Recursively convert an Arrow row (which uses proxy objects) into a plain JS
+ * object. Handles nested toJSON(), arrays, and bigint values. Extracted from
+ * query-tool.ts so the stock @sqlrooms/ai query tool wrapper can share it.
+ */
+export function convertArrowRowToObject(row) {
+  if (row === null || _typeof(row) !== 'object') return row;
+  if (typeof row.toJSON === 'function') {
+    var json = row.toJSON();
+    for (var key in json) {
+      var val = json[key];
+      if (val && _typeof(val) === 'object' && typeof val.toJSON === 'function') {
+        json[key] = convertArrowRowToObject(val);
+      } else if (Array.isArray(val)) {
+        json[key] = val.map(function (v) {
+          return convertArrowRowToObject(v);
+        });
+      } else if (typeof val === 'bigint') {
+        json[key] = val.toString();
+      }
+    }
+    return json;
+  }
+  if (Array.isArray(row)) {
+    return row.map(convertArrowRowToObject);
+  }
+  return row;
+}
+
+/**
+ * Normalize a Decimal BigNum into an indexable word array. Arrow's
+ * DecimalBigNum is a Uint32Array (has `.length`); `row.toJSON()` can emit it as
+ * a plain numeric-key object ({0: low, 1: high, ...}) with no `.length`, which
+ * decimalBigNumToNumber would miscompute (the loop never runs, returning 0).
+ */
+function toWordArray(v) {
+  if (Array.isArray(v)) {
+    return v;
+  }
+  if (ArrayBuffer.isView(v)) {
+    return Array.from(v);
+  }
+  var words = [];
+  for (var i = 0; i < 4; i++) {
+    if (v[i] === undefined) break;
+    words.push(v[i]);
+  }
+  return words;
+}
+
+/**
+ * Convert an Arrow DecimalBigNum (128-bit signed, stored as a Uint32Array of
+ * words) to a JS number, applying the column's declared scale.
+ *
+ * Arrow's own `valueOf(scale)` divides the raw bigint by 10^scale and converts
+ * the intermediate denominator with bigIntToNumber, which throws for scale >= 16
+ * (10^16 > Number.MAX_SAFE_INTEGER). We instead reconstruct the bigint and
+ * insert the decimal point via string manipulation, which avoids that throw and
+ * is exact up to the final JS Number coercion — very large Decimal128 values can
+ * still lose precision or overflow when converted to a Number.
+ */
+function decimalBigNumToNumber(v, scale) {
+  var words = toWordArray(v);
+  // Only convert when at least one word exists — an empty word array is a
+  // zero value (or a non-BigNum object that shouldn't be here).
+  if (words.length === 0) return 0;
+  var big = 0n;
+  for (var i = words.length - 1; i >= 0; i--) {
+    big = big << 32n | BigInt(words[i] >>> 0);
+  }
+  // Two's complement sign (128-bit).
+  if (words[words.length - 1] & 0x80000000) {
+    big -= 1n << BigInt(32 * words.length);
+  }
+  var negative = big < 0n;
+  if (negative) big = -big;
+  var s = big.toString();
+  if (scale > 0) {
+    if (s.length <= scale) s = s.padStart(scale + 1, '0');
+    s = "".concat(s.slice(0, s.length - scale), ".").concat(s.slice(s.length - scale));
+  }
+  return Number("".concat(negative ? '-' : '').concat(s));
+}
+
+/**
+ * Convert an Arrow Table to an array of plain JS objects.
+ *
+ * Decimal columns are resolved to numbers using each column's declared scale.
+ * `row.toJSON()` passes Decimal values through as opaque BigNum objects
+ * ({0: low, 1: high, ...}), which kepler.gl then stores as `object`-typed
+ * fields and downstream commands (e.g. `data.merge-tables`) choke on when they
+ * try to re-materialize the dataset into DuckDB. The schema carries the scale,
+ * so we resolve the value here.
+ */
+export function arrowTableToObjects(table) {
+  var _table$schema$fields, _table$schema;
+  var scaleByColumn = new Map();
+  var _iterator = _createForOfIteratorHelper((_table$schema$fields = (_table$schema = table.schema) === null || _table$schema === void 0 ? void 0 : _table$schema.fields) !== null && _table$schema$fields !== void 0 ? _table$schema$fields : []),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _field$type;
+      var field = _step.value;
+      if (((_field$type = field.type) === null || _field$type === void 0 ? void 0 : _field$type.typeId) === Type.Decimal && typeof field.type.scale === 'number') {
+        scaleByColumn.set(field.name, field.type.scale);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return table.toArray().map(function (row) {
+    var json = row.toJSON();
+    var _iterator2 = _createForOfIteratorHelper(scaleByColumn),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _step2$value = _slicedToArray(_step2.value, 2),
+          name = _step2$value[0],
+          scale = _step2$value[1];
+        var v = json[name];
+        // The column is Decimal-typed, so object values are BigNums. (The old
+        // `typeof v.valueOf === 'function'` guard was always true for objects —
+        // every object inherits valueOf — and did not distinguish BigNums.)
+        if (v && _typeof(v) === 'object') {
+          json[name] = decimalBigNumToNumber(v, scale);
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    for (var key in json) {
+      var val = json[key];
+      if (val && _typeof(val) === 'object' && typeof val.toJSON === 'function') {
+        json[key] = convertArrowRowToObject(val);
+      } else if (typeof val === 'bigint') {
+        json[key] = val.toString();
+      }
+    }
+    return json;
+  });
+}
+
+/**
+ * Read a column's values from a kepler dataset (by dataset label + field name).
+ * Vectors through the vector-tile layer when the dataset is a vector-tile
+ * dataset (whose values live in the layer's tile set, not the kepler table).
+ *
+ * Moved in from kepler-assistant's `src/glue/utils.ts` so this package is
+ * self-contained — the map.* commands that call this seam (via `KeplerContext`)
+ * cannot import from kepler-assistant (that would be circular).
+ */
+export function getValuesFromDataset(datasets, layers, datasetName, variableName) {
+  // Commands advertise accepting a dataset "name (label) or id", so match by
+  // either — a caller using the dataset id must not fail here.
+  var datasetId = Object.keys(datasets).find(function (dataId) {
+    return dataId === datasetName || datasets[dataId].label === datasetName;
+  });
+  if (!datasetId) {
+    throw new Error("Dataset ".concat(datasetName, " not found"));
+  }
+  var dataset = datasets[datasetId];
+  if (dataset) {
+    var field = dataset.fields.find(function (f) {
+      return f.name === variableName;
+    });
+    if (!field) {
+      throw new Error("Field ".concat(variableName, " not found in dataset ").concat(datasetName));
+    }
+    if (dataset.type === 'vector-tile') {
+      // Reuse the field resolved above — no need to re-find it by name.
+      return getValuesFromVectorTileLayer(datasetId, layers, field);
+    }
+    return Array.from({
+      length: dataset.length
+    }, function (_, i) {
+      return dataset.getValue(variableName, i);
+    });
+  }
+  return [];
+}
+export function isVectorTileLayer(layer) {
+  return layer.type === LAYER_TYPES.vectorTile;
+}
+export function getValuesFromVectorTileLayer(datasetId, layers, field) {
+  var _tileDataset$getTiles, _tileDataset, _tileDataset$getTiles2;
+  var layerIndex = layers.findIndex(function (layer) {
+    return layer.config.dataId === datasetId;
+  });
+  if (layerIndex === -1) return [];
+  var layer = layers[layerIndex];
+  if (!isVectorTileLayer(layer)) return [];
+  var accessor = layer.accessRowValue(field);
+  var values = [];
+  // Iterate the layer's tiles through the public `TileDataset.getTiles()` seam
+  // (the same tile->features unwrap the layer itself uses in renderLayer) —
+  // not the private `tileSet` field, which is an implementation detail that
+  // can change with internal refactors. `tileDataset` is protected, so it
+  // needs a cast, but `getTiles()` is a stable public method.
+  var tiles = (_tileDataset$getTiles = (_tileDataset = layer.tileDataset) === null || _tileDataset === void 0 || (_tileDataset$getTiles2 = _tileDataset.getTiles) === null || _tileDataset$getTiles2 === void 0 ? void 0 : _tileDataset$getTiles2.call(_tileDataset)) !== null && _tileDataset$getTiles !== void 0 ? _tileDataset$getTiles : [];
+  var _iterator3 = _createForOfIteratorHelper(tiles),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var tile = _step3.value;
+      var content = tile === null || tile === void 0 ? void 0 : tile.content;
+      var features = (content === null || content === void 0 ? void 0 : content.shape) === 'geojson-table' ? content.features : content;
+      if (!Array.isArray(features)) continue;
+      var _iterator4 = _createForOfIteratorHelper(features),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var row = _step4.value;
+          var value = accessor(field, row);
+          // Nulls mean "skip this row" (as in kepler's own TileDataset iteration),
+          // not "end of data" — breaking here would truncate the values array.
+          if (value === null) continue;
+          values.push(value);
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return values;
+}
+
+/**
+ * Whether a column holds any non-null object value — e.g. the `_geojson` column,
+ * which stores whole GeoJSON Feature objects. Such columns must NOT be handed to
+ * `tableFromArrays` raw: Arrow infers ONE type per column from the first value,
+ * and a dataset mixing Polygon (depth-3 `coordinates`) and MultiPolygon (depth-4)
+ * features gets the shallower type, so the MultiPolygon coordinates come back as
+ * `null` and the geometry disappears. Serialize them to JSON strings for the
+ * DuckDB round-trip and restore with `restoreObjectColumns`.
+ */
+export function isObjectColumn(values) {
+  return values.some(function (v) {
+    return v !== null && v !== undefined && _typeof(v) === 'object';
+  });
+}
+
+/**
+ * Serialize object values to JSON strings (nulls/primitives pass through
+ * unchanged) so `tableFromArrays` never has to infer a nested-struct type.
+ */
+export function stringifyObjectColumn(values) {
+  if (!isObjectColumn(values)) return values;
+  return values.map(function (v) {
+    if (v === null || v === undefined) return null;
+    return _typeof(v) === 'object' ? JSON.stringify(v) : v;
+  });
+}
+
+/**
+ * Restore object-valued columns that `stringifyObjectColumn` serialized back to
+ * their object form, in place. Used after a DuckDB query returns those columns
+ * as JSON strings (e.g. `_geojson` after `SELECT *`).
+ */
+export function restoreObjectColumns(rows, columnNames) {
+  if (columnNames.length === 0) return;
+  var _iterator5 = _createForOfIteratorHelper(rows),
+    _step5;
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var row = _step5.value;
+      var _iterator6 = _createForOfIteratorHelper(columnNames),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var name = _step6.value;
+          var value = row[name];
+          if (typeof value === 'string') {
+            try {
+              var parsed = JSON.parse(value);
+              // Only restore object/array values. A column may mix objects with
+              // primitives (e.g. a string "1" alongside real objects), and
+              // JSON-parsing those would coerce "1" → 1 / "true" → true, silently
+              // changing their types. Leave primitives as the original string.
+              if (parsed !== null && _typeof(parsed) === 'object') {
+                row[name] = parsed;
+              }
+            } catch (_unused) {
+              // Not JSON — leave the string as-is.
+            }
+          }
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+}
+
+/**
+ * Build an `updateDataset` payload that appends ONE new column to an existing
+ * kepler dataset, keeping every existing column byte-for-byte identical.
+ *
+ * Existing columns are read straight from the kepler dataset (via
+ * `getValuesFromDataset`) and NEVER round-tripped through Arrow/DuckDB. That
+ * matters for `_geojson`: `tableFromArrays` infers a single Arrow type for the
+ * whole column, and a dataset mixing Polygon and MultiPolygon features gets the
+ * shallower type — the MultiPolygon's deeper coordinate nesting comes back as
+ * nulls and the geometry disappears. Only the NEW column's values come from the
+ * computation (DuckDB expression / copy, or geoda write-back).
+ *
+ * @param datasets kepler datasets (visState.datasets)
+ * @param layers kepler layers (visState.layers) — needed for vector-tile datasets
+ * @param datasetName the dataset label
+ * @param newColumnName name of the column being appended
+ * @param newColumnArrow single-column arrow table holding the new column's values
+ * @returns an `updateDataset` `data` payload: `{rows, fields}`
+ */
+export function buildAddColumnPayload(datasets, layers, datasetName, newColumnName, newColumnArrow) {
+  // Match by id or label, consistent with getValuesFromDataset and the
+  // commands' "name (label) or id" contract.
+  var datasetId = Object.keys(datasets).find(function (id) {
+    return id === datasetName || datasets[id].label === datasetName;
+  });
+  if (!datasetId) {
+    throw new Error("Dataset \"".concat(datasetName, "\" not found."));
+  }
+  var dataset = datasets[datasetId];
+  var originalFields = dataset.fields;
+
+  // The new column's values + field descriptor come from the computation's
+  // arrow result (DuckDB expression / copy, or geoda write-back).
+  var newColumnValues = arrowTableToObjects(newColumnArrow).map(function (o) {
+    return o[newColumnName];
+  });
+  if (newColumnValues.length !== dataset.length) {
+    throw new Error("Computed column \"".concat(newColumnName, "\" produced ").concat(newColumnValues.length, " rows, but dataset ") + "\"".concat(datasetName, "\" has ").concat(dataset.length, " rows. The expression must produce exactly one ") + "value per row \u2014 check for filters, joins, or a non-1:1 query.");
+  }
+  var newField = arrowSchemaToFields(newColumnArrow)[0];
+
+  // Existing columns come from the original kepler dataset, never Arrow/DuckDB.
+  var columns = originalFields.map(function (f) {
+    return {
+      name: f.name,
+      values: getValuesFromDataset(datasets, layers, datasetName, f.name)
+    };
+  });
+
+  // RowDataContainer format: one array per row, indexed by field position.
+  var rows = Array.from({
+    length: dataset.length
+  }, function (_, i) {
+    return [].concat(_toConsumableArray(columns.map(function (c) {
+      return c.values[i];
+    })), [newColumnValues[i]]);
+  });
+  var fields = [].concat(_toConsumableArray(originalFields), [newField]);
+  return {
+    rows: rows,
+    fields: fields
+  };
+}
+
+/**
+ * Default number of first rows to format and return to the LLM as a preview.
+ * Mirrors spatial-agent's NUMBER_OF_ROWS_RETURN_TO_LLM.
+ */
+export var NUMBER_OF_ROWS_RETURN_TO_LLM = 5;
+
+/**
+ * Default total character budget for the LLM-facing preview. Capped at ~1000
+ * chars so the preview stays small in context, matching spatial-agent's
+ * formatResultsForLLM default.
+ */
+export var LLM_PREVIEW_MAX_TOTAL_LENGTH = 1000;
+export var LLM_PREVIEW_MAX_VALUE_LENGTH = 80;
+
+/**
+ * Format a query result table as a pipe-delimited string suitable for LLM
+ * consumption. Truncates individual cell values and total output to stay within
+ * a token budget. Shared by the stock @sqlrooms/ai query tool wrapper and the
+ * skill executeApi data.query path.
+ */
+export function tableToLLMResult(table) {
+  var maxTotalLength = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : LLM_PREVIEW_MAX_TOTAL_LENGTH;
+  var maxValueLength = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : LLM_PREVIEW_MAX_VALUE_LENGTH;
+  if (table.length === 0) return 'No rows returned';
+  var _truncateValue = function truncateValue(value) {
+    if (value === null || value === undefined) return '';
+    var str;
+    if (typeof value === 'bigint') {
+      str = value.toString();
+    } else if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+      var byteLen = value instanceof ArrayBuffer ? value.byteLength : value.byteLength;
+      str = "<".concat(byteLen, " bytes>");
+    } else if (Array.isArray(value)) {
+      // Format each element through truncateValue so object elements render
+      // as JSON (not "[object Object]") and bigints/typed values stay
+      // consistent with the scalar branches — String(v) would lose that
+      // structure and bypass the bigint-safe stringify.
+      str = value.map(function (v) {
+        return _truncateValue(v);
+      }).join(', ');
+    } else if (_typeof(value) === 'object') {
+      try {
+        str = JSON.stringify(value, function (_k, v) {
+          return typeof v === 'bigint' ? v.toString() : v;
+        });
+      } catch (_unused2) {
+        str = String(value);
+      }
+    } else {
+      str = String(value);
+    }
+    return str.length > maxValueLength ? "".concat(str.slice(0, maxValueLength), "...") : str;
+  };
+  var columns = Object.keys(table[0] || {});
+  var headerRow = "| ".concat(columns.join(' | '), " |");
+  var separatorRow = "| ".concat(columns.map(function () {
+    return '---';
+  }).join(' | '), " |");
+  var lines = [headerRow, separatorRow];
+  // Track the joined length incrementally instead of re-joining the whole
+  // array on every row (O(n²) in the number of preview rows).
+  var currentLength = headerRow.length + separatorRow.length + 1; // +1 for the '\n' between them
+  var _iterator7 = _createForOfIteratorHelper(table),
+    _step7;
+  try {
+    var _loop = function _loop() {
+      var row = _step7.value;
+      var values = columns.map(function (col) {
+        return _truncateValue(row[col]);
+      });
+      var line = "| ".concat(values.join(' | '), " |");
+      lines.push(line);
+      currentLength += line.length + 1; // +1 for the '\n' separator
+
+      if (currentLength > maxTotalLength - 100) {
+        lines.push('...');
+        return 1; // break
+      }
+    };
+    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+      if (_loop()) break;
+    }
+  } catch (err) {
+    _iterator7.e(err);
+  } finally {
+    _iterator7.f();
+  }
+  var result = lines.join('\n');
+  if (result.length > maxTotalLength) {
+    result = "".concat(result.slice(0, maxTotalLength), "\n...");
+  }
+  return result;
+}
+
+/**
+ * Format the first N rows of an Arrow result as a pipe-delimited string for the
+ * LLM, capped at maxTotalLength chars. Convenience wrapper combining
+ * arrowTableToObjects + tableToLLMResult: slices the first `numberOfRows`
+ * rows, normalizes Decimal columns via arrowTableToObjects (applying each
+ * column's declared scale so previews don't leak opaque BigNum word objects),
+ * then renders the pipe table.
+ */
+export function formatResultsForLLM(result) {
+  var _options$maxTotalLeng, _options$maxValueLeng;
+  var numberOfRows = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : NUMBER_OF_ROWS_RETURN_TO_LLM;
+  var options = arguments.length > 2 ? arguments[2] : undefined;
+  var rows = arrowTableToObjects({
+    toArray: function toArray() {
+      return result.toArray().slice(0, numberOfRows);
+    },
+    schema: result.schema
+  });
+  return tableToLLMResult(rows, (_options$maxTotalLeng = options === null || options === void 0 ? void 0 : options.maxTotalLength) !== null && _options$maxTotalLeng !== void 0 ? _options$maxTotalLeng : LLM_PREVIEW_MAX_TOTAL_LENGTH, (_options$maxValueLeng = options === null || options === void 0 ? void 0 : options.maxValueLength) !== null && _options$maxValueLeng !== void 0 ? _options$maxValueLeng : LLM_PREVIEW_MAX_VALUE_LENGTH);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Type","LAYER_TYPES","arrowSchemaToFields","datasetNameToTableName","datasetName","sanitized","replace","toLowerCase","concat","convertArrowRowToObject","row","_typeof","toJSON","json","key","val","Array","isArray","map","v","toString","toWordArray","ArrayBuffer","isView","from","words","i","undefined","push","decimalBigNumToNumber","scale","length","big","BigInt","negative","s","padStart","slice","Number","arrowTableToObjects","table","_table$schema$fields","_table$schema","scaleByColumn","Map","_iterator","_createForOfIteratorHelper","schema","fields","_step","n","done","_field$type","field","value","type","typeId","Decimal","set","name","err","e","f","toArray","_iterator2","_step2","_step2$value","_slicedToArray","getValuesFromDataset","datasets","layers","variableName","datasetId","Object","keys","find","dataId","label","Error","dataset","getValuesFromVectorTileLayer","_","getValue","isVectorTileLayer","layer","vectorTile","_tileDataset$getTiles","_tileDataset","_tileDataset$getTiles2","layerIndex","findIndex","config","accessor","accessRowValue","values","tiles","tileDataset","getTiles","call","_iterator3","_step3","tile","content","features","shape","_iterator4","_step4","isObjectColumn","some","stringifyObjectColumn","JSON","stringify","restoreObjectColumns","rows","columnNames","_iterator5","_step5","_iterator6","_step6","parsed","parse","_unused","buildAddColumnPayload","newColumnName","newColumnArrow","id","originalFields","newColumnValues","o","newField","columns","_toConsumableArray","c","NUMBER_OF_ROWS_RETURN_TO_LLM","LLM_PREVIEW_MAX_TOTAL_LENGTH","LLM_PREVIEW_MAX_VALUE_LENGTH","tableToLLMResult","maxTotalLength","arguments","maxValueLength","truncateValue","str","byteLen","byteLength","join","_k","_unused2","String","headerRow","separatorRow","lines","currentLength","_iterator7","_step7","_loop","col","line","result","formatResultsForLLM","_options$maxTotalLeng","_options$maxValueLeng","numberOfRows","options"],"sources":["../../../src/commands/utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n/**\n * Pure helpers shared by the map.* commands and the analysis shims. These are\n * dependency-light (apache-arrow only) and free of kepler-app state, so they\n * live in the map surface package and are re-exported for the analysis layer\n * (kepler-assistant) to import.\n */\n\nimport {Type} from 'apache-arrow';\nimport {LAYER_TYPES} from '@kepler.gl/constants';\nimport {arrowSchemaToFields} from '@kepler.gl/processors';\nimport type {Layer, VectorTileLayer} from '@kepler.gl/layers';\nimport type {Datasets} from '@kepler.gl/table';\nimport type {Field} from '@kepler.gl/types';\n\n/** Type for a Redux dispatch function, used by tools that need to dispatch kepler actions */\nexport type KeplerDispatch = (action: any) => void;\n\n/**\n * Deterministically convert a dataset name into a valid DuckDB table name.\n * Replaces non-alphanumeric characters (except underscores) with underscores,\n * collapses consecutive underscores, trims leading/trailing underscores,\n * lowercases the result, and prepends 'tbl_' to avoid reserved-word collisions.\n */\nexport function datasetNameToTableName(datasetName: string): string {\n  const sanitized = datasetName\n    .replace(/[^a-zA-Z0-9_]/g, '_')\n    .replace(/_+/g, '_')\n    .replace(/^_+|_+$/g, '')\n    .toLowerCase();\n  return `tbl_${sanitized || 'unnamed'}`;\n}\n\n/**\n * Recursively convert an Arrow row (which uses proxy objects) into a plain JS\n * object. Handles nested toJSON(), arrays, and bigint values. Extracted from\n * query-tool.ts so the stock @sqlrooms/ai query tool wrapper can share it.\n */\nexport function convertArrowRowToObject(row: any): unknown {\n  if (row === null || typeof row !== 'object') return row;\n\n  if (typeof row.toJSON === 'function') {\n    const json = row.toJSON();\n    for (const key in json) {\n      const val = json[key];\n      if (val && typeof val === 'object' && typeof val.toJSON === 'function') {\n        json[key] = convertArrowRowToObject(val);\n      } else if (Array.isArray(val)) {\n        json[key] = val.map(v => convertArrowRowToObject(v));\n      } else if (typeof val === 'bigint') {\n        json[key] = val.toString();\n      }\n    }\n    return json;\n  }\n\n  if (Array.isArray(row)) {\n    return row.map(convertArrowRowToObject) as any;\n  }\n\n  return row;\n}\n\n/**\n * Normalize a Decimal BigNum into an indexable word array. Arrow's\n * DecimalBigNum is a Uint32Array (has `.length`); `row.toJSON()` can emit it as\n * a plain numeric-key object ({0: low, 1: high, ...}) with no `.length`, which\n * decimalBigNumToNumber would miscompute (the loop never runs, returning 0).\n */\nfunction toWordArray(v: any): number[] {\n  if (Array.isArray(v)) {\n    return v;\n  }\n  if (ArrayBuffer.isView(v)) {\n    return Array.from(v as unknown as ArrayLike<number>);\n  }\n  const words: number[] = [];\n  for (let i = 0; i < 4; i++) {\n    if (v[i] === undefined) break;\n    words.push(v[i]);\n  }\n  return words;\n}\n\n/**\n * Convert an Arrow DecimalBigNum (128-bit signed, stored as a Uint32Array of\n * words) to a JS number, applying the column's declared scale.\n *\n * Arrow's own `valueOf(scale)` divides the raw bigint by 10^scale and converts\n * the intermediate denominator with bigIntToNumber, which throws for scale >= 16\n * (10^16 > Number.MAX_SAFE_INTEGER). We instead reconstruct the bigint and\n * insert the decimal point via string manipulation, which avoids that throw and\n * is exact up to the final JS Number coercion — very large Decimal128 values can\n * still lose precision or overflow when converted to a Number.\n */\nfunction decimalBigNumToNumber(v: any, scale: number): number {\n  const words = toWordArray(v);\n  // Only convert when at least one word exists — an empty word array is a\n  // zero value (or a non-BigNum object that shouldn't be here).\n  if (words.length === 0) return 0;\n  let big = 0n;\n  for (let i = words.length - 1; i >= 0; i--) {\n    big = (big << 32n) | BigInt(words[i] >>> 0);\n  }\n  // Two's complement sign (128-bit).\n  if (words[words.length - 1] & 0x80000000) {\n    big -= 1n << BigInt(32 * words.length);\n  }\n  const negative = big < 0n;\n  if (negative) big = -big;\n  let s = big.toString();\n  if (scale > 0) {\n    if (s.length <= scale) s = s.padStart(scale + 1, '0');\n    s = `${s.slice(0, s.length - scale)}.${s.slice(s.length - scale)}`;\n  }\n  return Number(`${negative ? '-' : ''}${s}`);\n}\n\n/**\n * Convert an Arrow Table to an array of plain JS objects.\n *\n * Decimal columns are resolved to numbers using each column's declared scale.\n * `row.toJSON()` passes Decimal values through as opaque BigNum objects\n * ({0: low, 1: high, ...}), which kepler.gl then stores as `object`-typed\n * fields and downstream commands (e.g. `data.merge-tables`) choke on when they\n * try to re-materialize the dataset into DuckDB. The schema carries the scale,\n * so we resolve the value here.\n */\nexport function arrowTableToObjects(table: {\n  toArray: () => any[];\n  schema?: {fields: {name: string; type?: {typeId?: number; scale?: number}}[]};\n}): Record<string, unknown>[] {\n  const scaleByColumn = new Map<string, number>();\n  for (const field of table.schema?.fields ?? []) {\n    if (field.type?.typeId === Type.Decimal && typeof field.type.scale === 'number') {\n      scaleByColumn.set(field.name, field.type.scale);\n    }\n  }\n  return table.toArray().map((row: any) => {\n    const json = row.toJSON();\n    for (const [name, scale] of scaleByColumn) {\n      const v = json[name];\n      // The column is Decimal-typed, so object values are BigNums. (The old\n      // `typeof v.valueOf === 'function'` guard was always true for objects —\n      // every object inherits valueOf — and did not distinguish BigNums.)\n      if (v && typeof v === 'object') {\n        json[name] = decimalBigNumToNumber(v, scale);\n      }\n    }\n    for (const key in json) {\n      const val = json[key];\n      if (val && typeof val === 'object' && typeof val.toJSON === 'function') {\n        json[key] = convertArrowRowToObject(val);\n      } else if (typeof val === 'bigint') {\n        json[key] = val.toString();\n      }\n    }\n    return json;\n  });\n}\n\n/**\n * Read a column's values from a kepler dataset (by dataset label + field name).\n * Vectors through the vector-tile layer when the dataset is a vector-tile\n * dataset (whose values live in the layer's tile set, not the kepler table).\n *\n * Moved in from kepler-assistant's `src/glue/utils.ts` so this package is\n * self-contained — the map.* commands that call this seam (via `KeplerContext`)\n * cannot import from kepler-assistant (that would be circular).\n */\nexport function getValuesFromDataset(\n  datasets: Datasets,\n  layers: Layer[],\n  datasetName: string,\n  variableName: string\n): unknown[] {\n  // Commands advertise accepting a dataset \"name (label) or id\", so match by\n  // either — a caller using the dataset id must not fail here.\n  const datasetId = Object.keys(datasets).find(\n    dataId => dataId === datasetName || datasets[dataId].label === datasetName\n  );\n  if (!datasetId) {\n    throw new Error(`Dataset ${datasetName} not found`);\n  }\n  const dataset = datasets[datasetId];\n  if (dataset) {\n    const field = dataset.fields.find(f => f.name === variableName);\n    if (!field) {\n      throw new Error(`Field ${variableName} not found in dataset ${datasetName}`);\n    }\n    if (dataset.type === 'vector-tile') {\n      // Reuse the field resolved above — no need to re-find it by name.\n      return getValuesFromVectorTileLayer(datasetId, layers, field);\n    }\n    return Array.from({length: dataset.length}, (_, i) => dataset.getValue(variableName, i));\n  }\n  return [];\n}\n\nexport function isVectorTileLayer(layer: Layer): layer is VectorTileLayer {\n  return layer.type === LAYER_TYPES.vectorTile;\n}\n\nexport function getValuesFromVectorTileLayer(datasetId: string, layers: Layer[], field: Field) {\n  const layerIndex = layers.findIndex(layer => layer.config.dataId === datasetId);\n  if (layerIndex === -1) return [];\n  const layer = layers[layerIndex];\n  if (!isVectorTileLayer(layer)) return [];\n  const accessor = layer.accessRowValue(field);\n  const values: unknown[] = [];\n  // Iterate the layer's tiles through the public `TileDataset.getTiles()` seam\n  // (the same tile->features unwrap the layer itself uses in renderLayer) —\n  // not the private `tileSet` field, which is an implementation detail that\n  // can change with internal refactors. `tileDataset` is protected, so it\n  // needs a cast, but `getTiles()` is a stable public method.\n  const tiles = (layer as any).tileDataset?.getTiles?.() ?? [];\n  for (const tile of tiles) {\n    const content = (tile as any)?.content;\n    const features = content?.shape === 'geojson-table' ? content.features : content;\n    if (!Array.isArray(features)) continue;\n    for (const row of features) {\n      const value = accessor(field, row);\n      // Nulls mean \"skip this row\" (as in kepler's own TileDataset iteration),\n      // not \"end of data\" — breaking here would truncate the values array.\n      if (value === null) continue;\n      values.push(value);\n    }\n  }\n  return values;\n}\n\n/**\n * Whether a column holds any non-null object value — e.g. the `_geojson` column,\n * which stores whole GeoJSON Feature objects. Such columns must NOT be handed to\n * `tableFromArrays` raw: Arrow infers ONE type per column from the first value,\n * and a dataset mixing Polygon (depth-3 `coordinates`) and MultiPolygon (depth-4)\n * features gets the shallower type, so the MultiPolygon coordinates come back as\n * `null` and the geometry disappears. Serialize them to JSON strings for the\n * DuckDB round-trip and restore with `restoreObjectColumns`.\n */\nexport function isObjectColumn(values: unknown[]): boolean {\n  return values.some(v => v !== null && v !== undefined && typeof v === 'object');\n}\n\n/**\n * Serialize object values to JSON strings (nulls/primitives pass through\n * unchanged) so `tableFromArrays` never has to infer a nested-struct type.\n */\nexport function stringifyObjectColumn(values: unknown[]): unknown[] {\n  if (!isObjectColumn(values)) return values;\n  return values.map(v => {\n    if (v === null || v === undefined) return null;\n    return typeof v === 'object' ? JSON.stringify(v) : v;\n  });\n}\n\n/**\n * Restore object-valued columns that `stringifyObjectColumn` serialized back to\n * their object form, in place. Used after a DuckDB query returns those columns\n * as JSON strings (e.g. `_geojson` after `SELECT *`).\n */\nexport function restoreObjectColumns(rows: Record<string, unknown>[], columnNames: string[]): void {\n  if (columnNames.length === 0) return;\n  for (const row of rows) {\n    for (const name of columnNames) {\n      const value = row[name];\n      if (typeof value === 'string') {\n        try {\n          const parsed = JSON.parse(value);\n          // Only restore object/array values. A column may mix objects with\n          // primitives (e.g. a string \"1\" alongside real objects), and\n          // JSON-parsing those would coerce \"1\" → 1 / \"true\" → true, silently\n          // changing their types. Leave primitives as the original string.\n          if (parsed !== null && typeof parsed === 'object') {\n            row[name] = parsed;\n          }\n        } catch {\n          // Not JSON — leave the string as-is.\n        }\n      }\n    }\n  }\n}\n\n/**\n * Build an `updateDataset` payload that appends ONE new column to an existing\n * kepler dataset, keeping every existing column byte-for-byte identical.\n *\n * Existing columns are read straight from the kepler dataset (via\n * `getValuesFromDataset`) and NEVER round-tripped through Arrow/DuckDB. That\n * matters for `_geojson`: `tableFromArrays` infers a single Arrow type for the\n * whole column, and a dataset mixing Polygon and MultiPolygon features gets the\n * shallower type — the MultiPolygon's deeper coordinate nesting comes back as\n * nulls and the geometry disappears. Only the NEW column's values come from the\n * computation (DuckDB expression / copy, or geoda write-back).\n *\n * @param datasets kepler datasets (visState.datasets)\n * @param layers kepler layers (visState.layers) — needed for vector-tile datasets\n * @param datasetName the dataset label\n * @param newColumnName name of the column being appended\n * @param newColumnArrow single-column arrow table holding the new column's values\n * @returns an `updateDataset` `data` payload: `{rows, fields}`\n */\nexport function buildAddColumnPayload(\n  datasets: Datasets,\n  layers: Layer[],\n  datasetName: string,\n  newColumnName: string,\n  newColumnArrow: any\n): {rows: unknown[][]; fields: any[]} {\n  // Match by id or label, consistent with getValuesFromDataset and the\n  // commands' \"name (label) or id\" contract.\n  const datasetId = Object.keys(datasets).find(\n    id => id === datasetName || datasets[id].label === datasetName\n  );\n  if (!datasetId) {\n    throw new Error(`Dataset \"${datasetName}\" not found.`);\n  }\n  const dataset = datasets[datasetId];\n  const originalFields = dataset.fields;\n\n  // The new column's values + field descriptor come from the computation's\n  // arrow result (DuckDB expression / copy, or geoda write-back).\n  const newColumnValues = arrowTableToObjects(newColumnArrow).map(o => o[newColumnName]);\n  if (newColumnValues.length !== dataset.length) {\n    throw new Error(\n      `Computed column \"${newColumnName}\" produced ${newColumnValues.length} rows, but dataset ` +\n        `\"${datasetName}\" has ${dataset.length} rows. The expression must produce exactly one ` +\n        `value per row — check for filters, joins, or a non-1:1 query.`\n    );\n  }\n  const newField = arrowSchemaToFields(newColumnArrow)[0];\n\n  // Existing columns come from the original kepler dataset, never Arrow/DuckDB.\n  const columns = originalFields.map(f => ({\n    name: f.name,\n    values: getValuesFromDataset(datasets, layers, datasetName, f.name)\n  }));\n\n  // RowDataContainer format: one array per row, indexed by field position.\n  const rows = Array.from({length: dataset.length}, (_, i) => [\n    ...columns.map(c => c.values[i]),\n    newColumnValues[i]\n  ]);\n\n  const fields = [...originalFields, newField];\n  return {rows, fields};\n}\n\n/**\n * Default number of first rows to format and return to the LLM as a preview.\n * Mirrors spatial-agent's NUMBER_OF_ROWS_RETURN_TO_LLM.\n */\nexport const NUMBER_OF_ROWS_RETURN_TO_LLM = 5;\n\n/**\n * Default total character budget for the LLM-facing preview. Capped at ~1000\n * chars so the preview stays small in context, matching spatial-agent's\n * formatResultsForLLM default.\n */\nexport const LLM_PREVIEW_MAX_TOTAL_LENGTH = 1000;\nexport const LLM_PREVIEW_MAX_VALUE_LENGTH = 80;\n\n/**\n * Format a query result table as a pipe-delimited string suitable for LLM\n * consumption. Truncates individual cell values and total output to stay within\n * a token budget. Shared by the stock @sqlrooms/ai query tool wrapper and the\n * skill executeApi data.query path.\n */\nexport function tableToLLMResult(\n  table: Record<string, unknown>[],\n  maxTotalLength: number = LLM_PREVIEW_MAX_TOTAL_LENGTH,\n  maxValueLength: number = LLM_PREVIEW_MAX_VALUE_LENGTH\n): string {\n  if (table.length === 0) return 'No rows returned';\n\n  const truncateValue = (value: unknown): string => {\n    if (value === null || value === undefined) return '';\n    let str: string;\n    if (typeof value === 'bigint') {\n      str = value.toString();\n    } else if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {\n      const byteLen =\n        value instanceof ArrayBuffer ? value.byteLength : (value as ArrayBufferView).byteLength;\n      str = `<${byteLen} bytes>`;\n    } else if (Array.isArray(value)) {\n      // Format each element through truncateValue so object elements render\n      // as JSON (not \"[object Object]\") and bigints/typed values stay\n      // consistent with the scalar branches — String(v) would lose that\n      // structure and bypass the bigint-safe stringify.\n      str = value.map(v => truncateValue(v)).join(', ');\n    } else if (typeof value === 'object') {\n      try {\n        str = JSON.stringify(value, (_k, v) => (typeof v === 'bigint' ? v.toString() : v));\n      } catch {\n        str = String(value);\n      }\n    } else {\n      str = String(value);\n    }\n    return str.length > maxValueLength ? `${str.slice(0, maxValueLength)}...` : str;\n  };\n\n  const columns = Object.keys(table[0] || {});\n  const headerRow = `| ${columns.join(' | ')} |`;\n  const separatorRow = `| ${columns.map(() => '---').join(' | ')} |`;\n  const lines = [headerRow, separatorRow];\n  // Track the joined length incrementally instead of re-joining the whole\n  // array on every row (O(n²) in the number of preview rows).\n  let currentLength = headerRow.length + separatorRow.length + 1; // +1 for the '\\n' between them\n\n  for (const row of table) {\n    const values = columns.map(col => truncateValue(row[col]));\n    const line = `| ${values.join(' | ')} |`;\n    lines.push(line);\n    currentLength += line.length + 1; // +1 for the '\\n' separator\n\n    if (currentLength > maxTotalLength - 100) {\n      lines.push('...');\n      break;\n    }\n  }\n\n  let result = lines.join('\\n');\n  if (result.length > maxTotalLength) {\n    result = `${result.slice(0, maxTotalLength)}\\n...`;\n  }\n  return result;\n}\n\n/**\n * Format the first N rows of an Arrow result as a pipe-delimited string for the\n * LLM, capped at maxTotalLength chars. Convenience wrapper combining\n * arrowTableToObjects + tableToLLMResult: slices the first `numberOfRows`\n * rows, normalizes Decimal columns via arrowTableToObjects (applying each\n * column's declared scale so previews don't leak opaque BigNum word objects),\n * then renders the pipe table.\n */\nexport function formatResultsForLLM(\n  result: {\n    toArray: () => any[];\n    schema?: {fields: {name: string; type?: {typeId?: number; scale?: number}}[]};\n  },\n  numberOfRows: number = NUMBER_OF_ROWS_RETURN_TO_LLM,\n  options?: {maxTotalLength?: number; maxValueLength?: number}\n): string {\n  const rows = arrowTableToObjects({\n    toArray: () => result.toArray().slice(0, numberOfRows),\n    schema: result.schema\n  });\n  return tableToLLMResult(\n    rows,\n    options?.maxTotalLength ?? LLM_PREVIEW_MAX_TOTAL_LENGTH,\n    options?.maxValueLength ?? LLM_PREVIEW_MAX_VALUE_LENGTH\n  );\n}\n"],"mappings":";;;;;;AAAA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAAQA,IAAI,QAAO,cAAc;AACjC,SAAQC,WAAW,QAAO,sBAAsB;AAChD,SAAQC,mBAAmB,QAAO,uBAAuB;;AAKzD;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,sBAAsBA,CAACC,WAAmB,EAAU;EAClE,IAAMC,SAAS,GAAGD,WAAW,CAC1BE,OAAO,CAAC,gBAAgB,EAAE,GAAG,CAAC,CAC9BA,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CACnBA,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CACvBC,WAAW,CAAC,CAAC;EAChB,cAAAC,MAAA,CAAcH,SAAS,IAAI,SAAS;AACtC;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASI,uBAAuBA,CAACC,GAAQ,EAAW;EACzD,IAAIA,GAAG,KAAK,IAAI,IAAIC,OAAA,CAAOD,GAAG,MAAK,QAAQ,EAAE,OAAOA,GAAG;EAEvD,IAAI,OAAOA,GAAG,CAACE,MAAM,KAAK,UAAU,EAAE;IACpC,IAAMC,IAAI,GAAGH,GAAG,CAACE,MAAM,CAAC,CAAC;IACzB,KAAK,IAAME,GAAG,IAAID,IAAI,EAAE;MACtB,IAAME,GAAG,GAAGF,IAAI,CAACC,GAAG,CAAC;MACrB,IAAIC,GAAG,IAAIJ,OAAA,CAAOI,GAAG,MAAK,QAAQ,IAAI,OAAOA,GAAG,CAACH,MAAM,KAAK,UAAU,EAAE;QACtEC,IAAI,CAACC,GAAG,CAAC,GAAGL,uBAAuB,CAACM,GAAG,CAAC;MAC1C,CAAC,MAAM,IAAIC,KAAK,CAACC,OAAO,CAACF,GAAG,CAAC,EAAE;QAC7BF,IAAI,CAACC,GAAG,CAAC,GAAGC,GAAG,CAACG,GAAG,CAAC,UAAAC,CAAC;UAAA,OAAIV,uBAAuB,CAACU,CAAC,CAAC;QAAA,EAAC;MACtD,CAAC,MAAM,IAAI,OAAOJ,GAAG,KAAK,QAAQ,EAAE;QAClCF,IAAI,CAACC,GAAG,CAAC,GAAGC,GAAG,CAACK,QAAQ,CAAC,CAAC;MAC5B;IACF;IACA,OAAOP,IAAI;EACb;EAEA,IAAIG,KAAK,CAACC,OAAO,CAACP,GAAG,CAAC,EAAE;IACtB,OAAOA,GAAG,CAACQ,GAAG,CAACT,uBAAuB,CAAC;EACzC;EAEA,OAAOC,GAAG;AACZ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAASW,WAAWA,CAACF,CAAM,EAAY;EACrC,IAAIH,KAAK,CAACC,OAAO,CAACE,CAAC,CAAC,EAAE;IACpB,OAAOA,CAAC;EACV;EACA,IAAIG,WAAW,CAACC,MAAM,CAACJ,CAAC,CAAC,EAAE;IACzB,OAAOH,KAAK,CAACQ,IAAI,CAACL,CAAiC,CAAC;EACtD;EACA,IAAMM,KAAe,GAAG,EAAE;EAC1B,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG,CAAC,EAAEA,CAAC,EAAE,EAAE;IAC1B,IAAIP,CAAC,CAACO,CAAC,CAAC,KAAKC,SAAS,EAAE;IACxBF,KAAK,CAACG,IAAI,CAACT,CAAC,CAACO,CAAC,CAAC,CAAC;EAClB;EACA,OAAOD,KAAK;AACd;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASI,qBAAqBA,CAACV,CAAM,EAAEW,KAAa,EAAU;EAC5D,IAAML,KAAK,GAAGJ,WAAW,CAACF,CAAC,CAAC;EAC5B;EACA;EACA,IAAIM,KAAK,CAACM,MAAM,KAAK,CAAC,EAAE,OAAO,CAAC;EAChC,IAAIC,GAAG,GAAG,EAAE;EACZ,KAAK,IAAIN,CAAC,GAAGD,KAAK,CAACM,MAAM,GAAG,CAAC,EAAEL,CAAC,IAAI,CAAC,EAAEA,CAAC,EAAE,EAAE;IAC1CM,GAAG,GAAIA,GAAG,IAAI,GAAG,GAAIC,MAAM,CAACR,KAAK,CAACC,CAAC,CAAC,KAAK,CAAC,CAAC;EAC7C;EACA;EACA,IAAID,KAAK,CAACA,KAAK,CAACM,MAAM,GAAG,CAAC,CAAC,GAAG,UAAU,EAAE;IACxCC,GAAG,IAAI,EAAE,IAAIC,MAAM,CAAC,EAAE,GAAGR,KAAK,CAACM,MAAM,CAAC;EACxC;EACA,IAAMG,QAAQ,GAAGF,GAAG,GAAG,EAAE;EACzB,IAAIE,QAAQ,EAAEF,GAAG,GAAG,CAACA,GAAG;EACxB,IAAIG,CAAC,GAAGH,GAAG,CAACZ,QAAQ,CAAC,CAAC;EACtB,IAAIU,KAAK,GAAG,CAAC,EAAE;IACb,IAAIK,CAAC,CAACJ,MAAM,IAAID,KAAK,EAAEK,CAAC,GAAGA,CAAC,CAACC,QAAQ,CAACN,KAAK,GAAG,CAAC,EAAE,GAAG,CAAC;IACrDK,CAAC,MAAA3B,MAAA,CAAM2B,CAAC,CAACE,KAAK,CAAC,CAAC,EAAEF,CAAC,CAACJ,MAAM,GAAGD,KAAK,CAAC,OAAAtB,MAAA,CAAI2B,CAAC,CAACE,KAAK,CAACF,CAAC,CAACJ,MAAM,GAAGD,KAAK,CAAC,CAAE;EACpE;EACA,OAAOQ,MAAM,IAAA9B,MAAA,CAAI0B,QAAQ,GAAG,GAAG,GAAG,EAAE,EAAA1B,MAAA,CAAG2B,CAAC,CAAE,CAAC;AAC7C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASI,mBAAmBA,CAACC,KAGnC,EAA6B;EAAA,IAAAC,oBAAA,EAAAC,aAAA;EAC5B,IAAMC,aAAa,GAAG,IAAIC,GAAG,CAAiB,CAAC;EAAC,IAAAC,SAAA,GAAAC,0BAAA,EAAAL,oBAAA,IAAAC,aAAA,GAC5BF,KAAK,CAACO,MAAM,cAAAL,aAAA,uBAAZA,aAAA,CAAcM,MAAM,cAAAP,oBAAA,cAAAA,oBAAA,GAAI,EAAE;IAAAQ,KAAA;EAAA;IAA9C,KAAAJ,SAAA,CAAAV,CAAA,MAAAc,KAAA,GAAAJ,SAAA,CAAAK,CAAA,IAAAC,IAAA,GAAgD;MAAA,IAAAC,WAAA;MAAA,IAArCC,KAAK,GAAAJ,KAAA,CAAAK,KAAA;MACd,IAAI,EAAAF,WAAA,GAAAC,KAAK,CAACE,IAAI,cAAAH,WAAA,uBAAVA,WAAA,CAAYI,MAAM,MAAKxD,IAAI,CAACyD,OAAO,IAAI,OAAOJ,KAAK,CAACE,IAAI,CAACzB,KAAK,KAAK,QAAQ,EAAE;QAC/Ea,aAAa,CAACe,GAAG,CAACL,KAAK,CAACM,IAAI,EAAEN,KAAK,CAACE,IAAI,CAACzB,KAAK,CAAC;MACjD;IACF;EAAC,SAAA8B,GAAA;IAAAf,SAAA,CAAAgB,CAAA,CAAAD,GAAA;EAAA;IAAAf,SAAA,CAAAiB,CAAA;EAAA;EACD,OAAOtB,KAAK,CAACuB,OAAO,CAAC,CAAC,CAAC7C,GAAG,CAAC,UAACR,GAAQ,EAAK;IACvC,IAAMG,IAAI,GAAGH,GAAG,CAACE,MAAM,CAAC,CAAC;IAAC,IAAAoD,UAAA,GAAAlB,0BAAA,CACEH,aAAa;MAAAsB,MAAA;IAAA;MAAzC,KAAAD,UAAA,CAAA7B,CAAA,MAAA8B,MAAA,GAAAD,UAAA,CAAAd,CAAA,IAAAC,IAAA,GAA2C;QAAA,IAAAe,YAAA,GAAAC,cAAA,CAAAF,MAAA,CAAAX,KAAA;UAA/BK,IAAI,GAAAO,YAAA;UAAEpC,KAAK,GAAAoC,YAAA;QACrB,IAAM/C,CAAC,GAAGN,IAAI,CAAC8C,IAAI,CAAC;QACpB;QACA;QACA;QACA,IAAIxC,CAAC,IAAIR,OAAA,CAAOQ,CAAC,MAAK,QAAQ,EAAE;UAC9BN,IAAI,CAAC8C,IAAI,CAAC,GAAG9B,qBAAqB,CAACV,CAAC,EAAEW,KAAK,CAAC;QAC9C;MACF;IAAC,SAAA8B,GAAA;MAAAI,UAAA,CAAAH,CAAA,CAAAD,GAAA;IAAA;MAAAI,UAAA,CAAAF,CAAA;IAAA;IACD,KAAK,IAAMhD,GAAG,IAAID,IAAI,EAAE;MACtB,IAAME,GAAG,GAAGF,IAAI,CAACC,GAAG,CAAC;MACrB,IAAIC,GAAG,IAAIJ,OAAA,CAAOI,GAAG,MAAK,QAAQ,IAAI,OAAOA,GAAG,CAACH,MAAM,KAAK,UAAU,EAAE;QACtEC,IAAI,CAACC,GAAG,CAAC,GAAGL,uBAAuB,CAACM,GAAG,CAAC;MAC1C,CAAC,MAAM,IAAI,OAAOA,GAAG,KAAK,QAAQ,EAAE;QAClCF,IAAI,CAACC,GAAG,CAAC,GAAGC,GAAG,CAACK,QAAQ,CAAC,CAAC;MAC5B;IACF;IACA,OAAOP,IAAI;EACb,CAAC,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASuD,oBAAoBA,CAClCC,QAAkB,EAClBC,MAAe,EACflE,WAAmB,EACnBmE,YAAoB,EACT;EACX;EACA;EACA,IAAMC,SAAS,GAAGC,MAAM,CAACC,IAAI,CAACL,QAAQ,CAAC,CAACM,IAAI,CAC1C,UAAAC,MAAM;IAAA,OAAIA,MAAM,KAAKxE,WAAW,IAAIiE,QAAQ,CAACO,MAAM,CAAC,CAACC,KAAK,KAAKzE,WAAW;EAAA,CAC5E,CAAC;EACD,IAAI,CAACoE,SAAS,EAAE;IACd,MAAM,IAAIM,KAAK,YAAAtE,MAAA,CAAYJ,WAAW,eAAY,CAAC;EACrD;EACA,IAAM2E,OAAO,GAAGV,QAAQ,CAACG,SAAS,CAAC;EACnC,IAAIO,OAAO,EAAE;IACX,IAAM1B,KAAK,GAAG0B,OAAO,CAAC/B,MAAM,CAAC2B,IAAI,CAAC,UAAAb,CAAC;MAAA,OAAIA,CAAC,CAACH,IAAI,KAAKY,YAAY;IAAA,EAAC;IAC/D,IAAI,CAAClB,KAAK,EAAE;MACV,MAAM,IAAIyB,KAAK,UAAAtE,MAAA,CAAU+D,YAAY,4BAAA/D,MAAA,CAAyBJ,WAAW,CAAE,CAAC;IAC9E;IACA,IAAI2E,OAAO,CAACxB,IAAI,KAAK,aAAa,EAAE;MAClC;MACA,OAAOyB,4BAA4B,CAACR,SAAS,EAAEF,MAAM,EAAEjB,KAAK,CAAC;IAC/D;IACA,OAAOrC,KAAK,CAACQ,IAAI,CAAC;MAACO,MAAM,EAAEgD,OAAO,CAAChD;IAAM,CAAC,EAAE,UAACkD,CAAC,EAAEvD,CAAC;MAAA,OAAKqD,OAAO,CAACG,QAAQ,CAACX,YAAY,EAAE7C,CAAC,CAAC;IAAA,EAAC;EAC1F;EACA,OAAO,EAAE;AACX;AAEA,OAAO,SAASyD,iBAAiBA,CAACC,KAAY,EAA4B;EACxE,OAAOA,KAAK,CAAC7B,IAAI,KAAKtD,WAAW,CAACoF,UAAU;AAC9C;AAEA,OAAO,SAASL,4BAA4BA,CAACR,SAAiB,EAAEF,MAAe,EAAEjB,KAAY,EAAE;EAAA,IAAAiC,qBAAA,EAAAC,YAAA,EAAAC,sBAAA;EAC7F,IAAMC,UAAU,GAAGnB,MAAM,CAACoB,SAAS,CAAC,UAAAN,KAAK;IAAA,OAAIA,KAAK,CAACO,MAAM,CAACf,MAAM,KAAKJ,SAAS;EAAA,EAAC;EAC/E,IAAIiB,UAAU,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE;EAChC,IAAML,KAAK,GAAGd,MAAM,CAACmB,UAAU,CAAC;EAChC,IAAI,CAACN,iBAAiB,CAACC,KAAK,CAAC,EAAE,OAAO,EAAE;EACxC,IAAMQ,QAAQ,GAAGR,KAAK,CAACS,cAAc,CAACxC,KAAK,CAAC;EAC5C,IAAMyC,MAAiB,GAAG,EAAE;EAC5B;EACA;EACA;EACA;EACA;EACA,IAAMC,KAAK,IAAAT,qBAAA,IAAAC,YAAA,GAAIH,KAAK,CAASY,WAAW,cAAAT,YAAA,gBAAAC,sBAAA,GAA1BD,YAAA,CAA4BU,QAAQ,cAAAT,sBAAA,uBAApCA,sBAAA,CAAAU,IAAA,CAAAX,YAAuC,CAAC,cAAAD,qBAAA,cAAAA,qBAAA,GAAI,EAAE;EAAC,IAAAa,UAAA,GAAArD,0BAAA,CAC1CiD,KAAK;IAAAK,MAAA;EAAA;IAAxB,KAAAD,UAAA,CAAAhE,CAAA,MAAAiE,MAAA,GAAAD,UAAA,CAAAjD,CAAA,IAAAC,IAAA,GAA0B;MAAA,IAAfkD,IAAI,GAAAD,MAAA,CAAA9C,KAAA;MACb,IAAMgD,OAAO,GAAID,IAAI,aAAJA,IAAI,uBAAJA,IAAI,CAAUC,OAAO;MACtC,IAAMC,QAAQ,GAAG,CAAAD,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEE,KAAK,MAAK,eAAe,GAAGF,OAAO,CAACC,QAAQ,GAAGD,OAAO;MAChF,IAAI,CAACtF,KAAK,CAACC,OAAO,CAACsF,QAAQ,CAAC,EAAE;MAAS,IAAAE,UAAA,GAAA3D,0BAAA,CACrByD,QAAQ;QAAAG,MAAA;MAAA;QAA1B,KAAAD,UAAA,CAAAtE,CAAA,MAAAuE,MAAA,GAAAD,UAAA,CAAAvD,CAAA,IAAAC,IAAA,GAA4B;UAAA,IAAjBzC,GAAG,GAAAgG,MAAA,CAAApD,KAAA;UACZ,IAAMA,KAAK,GAAGsC,QAAQ,CAACvC,KAAK,EAAE3C,GAAG,CAAC;UAClC;UACA;UACA,IAAI4C,KAAK,KAAK,IAAI,EAAE;UACpBwC,MAAM,CAAClE,IAAI,CAAC0B,KAAK,CAAC;QACpB;MAAC,SAAAM,GAAA;QAAA6C,UAAA,CAAA5C,CAAA,CAAAD,GAAA;MAAA;QAAA6C,UAAA,CAAA3C,CAAA;MAAA;IACH;EAAC,SAAAF,GAAA;IAAAuC,UAAA,CAAAtC,CAAA,CAAAD,GAAA;EAAA;IAAAuC,UAAA,CAAArC,CAAA;EAAA;EACD,OAAOgC,MAAM;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASa,cAAcA,CAACb,MAAiB,EAAW;EACzD,OAAOA,MAAM,CAACc,IAAI,CAAC,UAAAzF,CAAC;IAAA,OAAIA,CAAC,KAAK,IAAI,IAAIA,CAAC,KAAKQ,SAAS,IAAIhB,OAAA,CAAOQ,CAAC,MAAK,QAAQ;EAAA,EAAC;AACjF;;AAEA;AACA;AACA;AACA;AACA,OAAO,SAAS0F,qBAAqBA,CAACf,MAAiB,EAAa;EAClE,IAAI,CAACa,cAAc,CAACb,MAAM,CAAC,EAAE,OAAOA,MAAM;EAC1C,OAAOA,MAAM,CAAC5E,GAAG,CAAC,UAAAC,CAAC,EAAI;IACrB,IAAIA,CAAC,KAAK,IAAI,IAAIA,CAAC,KAAKQ,SAAS,EAAE,OAAO,IAAI;IAC9C,OAAOhB,OAAA,CAAOQ,CAAC,MAAK,QAAQ,GAAG2F,IAAI,CAACC,SAAS,CAAC5F,CAAC,CAAC,GAAGA,CAAC;EACtD,CAAC,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,SAAS6F,oBAAoBA,CAACC,IAA+B,EAAEC,WAAqB,EAAQ;EACjG,IAAIA,WAAW,CAACnF,MAAM,KAAK,CAAC,EAAE;EAAO,IAAAoF,UAAA,GAAArE,0BAAA,CACnBmE,IAAI;IAAAG,MAAA;EAAA;IAAtB,KAAAD,UAAA,CAAAhF,CAAA,MAAAiF,MAAA,GAAAD,UAAA,CAAAjE,CAAA,IAAAC,IAAA,GAAwB;MAAA,IAAbzC,GAAG,GAAA0G,MAAA,CAAA9D,KAAA;MAAA,IAAA+D,UAAA,GAAAvE,0BAAA,CACOoE,WAAW;QAAAI,MAAA;MAAA;QAA9B,KAAAD,UAAA,CAAAlF,CAAA,MAAAmF,MAAA,GAAAD,UAAA,CAAAnE,CAAA,IAAAC,IAAA,GAAgC;UAAA,IAArBQ,IAAI,GAAA2D,MAAA,CAAAhE,KAAA;UACb,IAAMA,KAAK,GAAG5C,GAAG,CAACiD,IAAI,CAAC;UACvB,IAAI,OAAOL,KAAK,KAAK,QAAQ,EAAE;YAC7B,IAAI;cACF,IAAMiE,MAAM,GAAGT,IAAI,CAACU,KAAK,CAAClE,KAAK,CAAC;cAChC;cACA;cACA;cACA;cACA,IAAIiE,MAAM,KAAK,IAAI,IAAI5G,OAAA,CAAO4G,MAAM,MAAK,QAAQ,EAAE;gBACjD7G,GAAG,CAACiD,IAAI,CAAC,GAAG4D,MAAM;cACpB;YACF,CAAC,CAAC,OAAAE,OAAA,EAAM;cACN;YAAA;UAEJ;QACF;MAAC,SAAA7D,GAAA;QAAAyD,UAAA,CAAAxD,CAAA,CAAAD,GAAA;MAAA;QAAAyD,UAAA,CAAAvD,CAAA;MAAA;IACH;EAAC,SAAAF,GAAA;IAAAuD,UAAA,CAAAtD,CAAA,CAAAD,GAAA;EAAA;IAAAuD,UAAA,CAAArD,CAAA;EAAA;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAAS4D,qBAAqBA,CACnCrD,QAAkB,EAClBC,MAAe,EACflE,WAAmB,EACnBuH,aAAqB,EACrBC,cAAmB,EACiB;EACpC;EACA;EACA,IAAMpD,SAAS,GAAGC,MAAM,CAACC,IAAI,CAACL,QAAQ,CAAC,CAACM,IAAI,CAC1C,UAAAkD,EAAE;IAAA,OAAIA,EAAE,KAAKzH,WAAW,IAAIiE,QAAQ,CAACwD,EAAE,CAAC,CAAChD,KAAK,KAAKzE,WAAW;EAAA,CAChE,CAAC;EACD,IAAI,CAACoE,SAAS,EAAE;IACd,MAAM,IAAIM,KAAK,cAAAtE,MAAA,CAAaJ,WAAW,kBAAc,CAAC;EACxD;EACA,IAAM2E,OAAO,GAAGV,QAAQ,CAACG,SAAS,CAAC;EACnC,IAAMsD,cAAc,GAAG/C,OAAO,CAAC/B,MAAM;;EAErC;EACA;EACA,IAAM+E,eAAe,GAAGxF,mBAAmB,CAACqF,cAAc,CAAC,CAAC1G,GAAG,CAAC,UAAA8G,CAAC;IAAA,OAAIA,CAAC,CAACL,aAAa,CAAC;EAAA,EAAC;EACtF,IAAII,eAAe,CAAChG,MAAM,KAAKgD,OAAO,CAAChD,MAAM,EAAE;IAC7C,MAAM,IAAI+C,KAAK,CACb,qBAAAtE,MAAA,CAAoBmH,aAAa,kBAAAnH,MAAA,CAAcuH,eAAe,CAAChG,MAAM,gCAAAvB,MAAA,CAC/DJ,WAAW,aAAAI,MAAA,CAASuE,OAAO,CAAChD,MAAM,oDAAiD,uEAE3F,CAAC;EACH;EACA,IAAMkG,QAAQ,GAAG/H,mBAAmB,CAAC0H,cAAc,CAAC,CAAC,CAAC,CAAC;;EAEvD;EACA,IAAMM,OAAO,GAAGJ,cAAc,CAAC5G,GAAG,CAAC,UAAA4C,CAAC;IAAA,OAAK;MACvCH,IAAI,EAAEG,CAAC,CAACH,IAAI;MACZmC,MAAM,EAAE1B,oBAAoB,CAACC,QAAQ,EAAEC,MAAM,EAAElE,WAAW,EAAE0D,CAAC,CAACH,IAAI;IACpE,CAAC;EAAA,CAAC,CAAC;;EAEH;EACA,IAAMsD,IAAI,GAAGjG,KAAK,CAACQ,IAAI,CAAC;IAACO,MAAM,EAAEgD,OAAO,CAAChD;EAAM,CAAC,EAAE,UAACkD,CAAC,EAAEvD,CAAC;IAAA,UAAAlB,MAAA,CAAA2H,kBAAA,CAClDD,OAAO,CAAChH,GAAG,CAAC,UAAAkH,CAAC;MAAA,OAAIA,CAAC,CAACtC,MAAM,CAACpE,CAAC,CAAC;IAAA,EAAC,IAChCqG,eAAe,CAACrG,CAAC,CAAC;EAAA,CACnB,CAAC;EAEF,IAAMsB,MAAM,MAAAxC,MAAA,CAAA2H,kBAAA,CAAOL,cAAc,IAAEG,QAAQ,EAAC;EAC5C,OAAO;IAAChB,IAAI,EAAJA,IAAI;IAAEjE,MAAM,EAANA;EAAM,CAAC;AACvB;;AAEA;AACA;AACA;AACA;AACA,OAAO,IAAMqF,4BAA4B,GAAG,CAAC;;AAE7C;AACA;AACA;AACA;AACA;AACA,OAAO,IAAMC,4BAA4B,GAAG,IAAI;AAChD,OAAO,IAAMC,4BAA4B,GAAG,EAAE;;AAE9C;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,gBAAgBA,CAC9BhG,KAAgC,EAGxB;EAAA,IAFRiG,cAAsB,GAAAC,SAAA,CAAA3G,MAAA,QAAA2G,SAAA,QAAA/G,SAAA,GAAA+G,SAAA,MAAGJ,4BAA4B;EAAA,IACrDK,cAAsB,GAAAD,SAAA,CAAA3G,MAAA,QAAA2G,SAAA,QAAA/G,SAAA,GAAA+G,SAAA,MAAGH,4BAA4B;EAErD,IAAI/F,KAAK,CAACT,MAAM,KAAK,CAAC,EAAE,OAAO,kBAAkB;EAEjD,IAAM6G,cAAa,GAAG,SAAhBA,aAAaA,CAAItF,KAAc,EAAa;IAChD,IAAIA,KAAK,KAAK,IAAI,IAAIA,KAAK,KAAK3B,SAAS,EAAE,OAAO,EAAE;IACpD,IAAIkH,GAAW;IACf,IAAI,OAAOvF,KAAK,KAAK,QAAQ,EAAE;MAC7BuF,GAAG,GAAGvF,KAAK,CAAClC,QAAQ,CAAC,CAAC;IACxB,CAAC,MAAM,IAAIE,WAAW,CAACC,MAAM,CAAC+B,KAAK,CAAC,IAAIA,KAAK,YAAYhC,WAAW,EAAE;MACpE,IAAMwH,OAAO,GACXxF,KAAK,YAAYhC,WAAW,GAAGgC,KAAK,CAACyF,UAAU,GAAIzF,KAAK,CAAqByF,UAAU;MACzFF,GAAG,OAAArI,MAAA,CAAOsI,OAAO,YAAS;IAC5B,CAAC,MAAM,IAAI9H,KAAK,CAACC,OAAO,CAACqC,KAAK,CAAC,EAAE;MAC/B;MACA;MACA;MACA;MACAuF,GAAG,GAAGvF,KAAK,CAACpC,GAAG,CAAC,UAAAC,CAAC;QAAA,OAAIyH,cAAa,CAACzH,CAAC,CAAC;MAAA,EAAC,CAAC6H,IAAI,CAAC,IAAI,CAAC;IACnD,CAAC,MAAM,IAAIrI,OAAA,CAAO2C,KAAK,MAAK,QAAQ,EAAE;MACpC,IAAI;QACFuF,GAAG,GAAG/B,IAAI,CAACC,SAAS,CAACzD,KAAK,EAAE,UAAC2F,EAAE,EAAE9H,CAAC;UAAA,OAAM,OAAOA,CAAC,KAAK,QAAQ,GAAGA,CAAC,CAACC,QAAQ,CAAC,CAAC,GAAGD,CAAC;QAAA,CAAC,CAAC;MACpF,CAAC,CAAC,OAAA+H,QAAA,EAAM;QACNL,GAAG,GAAGM,MAAM,CAAC7F,KAAK,CAAC;MACrB;IACF,CAAC,MAAM;MACLuF,GAAG,GAAGM,MAAM,CAAC7F,KAAK,CAAC;IACrB;IACA,OAAOuF,GAAG,CAAC9G,MAAM,GAAG4G,cAAc,MAAAnI,MAAA,CAAMqI,GAAG,CAACxG,KAAK,CAAC,CAAC,EAAEsG,cAAc,CAAC,WAAQE,GAAG;EACjF,CAAC;EAED,IAAMX,OAAO,GAAGzD,MAAM,CAACC,IAAI,CAAClC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;EAC3C,IAAM4G,SAAS,QAAA5I,MAAA,CAAQ0H,OAAO,CAACc,IAAI,CAAC,KAAK,CAAC,OAAI;EAC9C,IAAMK,YAAY,QAAA7I,MAAA,CAAQ0H,OAAO,CAAChH,GAAG,CAAC;IAAA,OAAM,KAAK;EAAA,EAAC,CAAC8H,IAAI,CAAC,KAAK,CAAC,OAAI;EAClE,IAAMM,KAAK,GAAG,CAACF,SAAS,EAAEC,YAAY,CAAC;EACvC;EACA;EACA,IAAIE,aAAa,GAAGH,SAAS,CAACrH,MAAM,GAAGsH,YAAY,CAACtH,MAAM,GAAG,CAAC,CAAC,CAAC;EAAA,IAAAyH,UAAA,GAAA1G,0BAAA,CAE9CN,KAAK;IAAAiH,MAAA;EAAA;IAAA,IAAAC,KAAA,YAAAA,MAAA,EAAE;MAAA,IAAdhJ,GAAG,GAAA+I,MAAA,CAAAnG,KAAA;MACZ,IAAMwC,MAAM,GAAGoC,OAAO,CAAChH,GAAG,CAAC,UAAAyI,GAAG;QAAA,OAAIf,cAAa,CAAClI,GAAG,CAACiJ,GAAG,CAAC,CAAC;MAAA,EAAC;MAC1D,IAAMC,IAAI,QAAApJ,MAAA,CAAQsF,MAAM,CAACkD,IAAI,CAAC,KAAK,CAAC,OAAI;MACxCM,KAAK,CAAC1H,IAAI,CAACgI,IAAI,CAAC;MAChBL,aAAa,IAAIK,IAAI,CAAC7H,MAAM,GAAG,CAAC,CAAC,CAAC;;MAElC,IAAIwH,aAAa,GAAGd,cAAc,GAAG,GAAG,EAAE;QACxCa,KAAK,CAAC1H,IAAI,CAAC,KAAK,CAAC;QAAC;MAEpB;IACF,CAAC;IAVD,KAAA4H,UAAA,CAAArH,CAAA,MAAAsH,MAAA,GAAAD,UAAA,CAAAtG,CAAA,IAAAC,IAAA;MAAA,IAAAuG,KAAA,IAQI;IAAM;EAET,SAAA9F,GAAA;IAAA4F,UAAA,CAAA3F,CAAA,CAAAD,GAAA;EAAA;IAAA4F,UAAA,CAAA1F,CAAA;EAAA;EAED,IAAI+F,MAAM,GAAGP,KAAK,CAACN,IAAI,CAAC,IAAI,CAAC;EAC7B,IAAIa,MAAM,CAAC9H,MAAM,GAAG0G,cAAc,EAAE;IAClCoB,MAAM,MAAArJ,MAAA,CAAMqJ,MAAM,CAACxH,KAAK,CAAC,CAAC,EAAEoG,cAAc,CAAC,UAAO;EACpD;EACA,OAAOoB,MAAM;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,mBAAmBA,CACjCD,MAGC,EAGO;EAAA,IAAAE,qBAAA,EAAAC,qBAAA;EAAA,IAFRC,YAAoB,GAAAvB,SAAA,CAAA3G,MAAA,QAAA2G,SAAA,QAAA/G,SAAA,GAAA+G,SAAA,MAAGL,4BAA4B;EAAA,IACnD6B,OAA4D,GAAAxB,SAAA,CAAA3G,MAAA,OAAA2G,SAAA,MAAA/G,SAAA;EAE5D,IAAMsF,IAAI,GAAG1E,mBAAmB,CAAC;IAC/BwB,OAAO,EAAE,SAATA,OAAOA,CAAA;MAAA,OAAQ8F,MAAM,CAAC9F,OAAO,CAAC,CAAC,CAAC1B,KAAK,CAAC,CAAC,EAAE4H,YAAY,CAAC;IAAA;IACtDlH,MAAM,EAAE8G,MAAM,CAAC9G;EACjB,CAAC,CAAC;EACF,OAAOyF,gBAAgB,CACrBvB,IAAI,GAAA8C,qBAAA,GACJG,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEzB,cAAc,cAAAsB,qBAAA,cAAAA,qBAAA,GAAIzB,4BAA4B,GAAA0B,qBAAA,GACvDE,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEvB,cAAc,cAAAqB,qBAAA,cAAAA,qBAAA,GAAIzB,4BAC7B,CAAC;AACH","ignoreList":[]}