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

package/dist/cjs/commands/split-view-command.js

@@ -0,0 +1,261 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSplitViewCommand = getSplitViewCommand;
+exports.splitViewCommandId = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _zod = require("zod");
+var _actions = require("@kepler.gl/actions");
+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
+var sleep = function sleep(ms) {
+  return new Promise(function (resolve) {
+    return setTimeout(resolve, ms);
+  });
+};
+var splitViewCommandId = exports.splitViewCommandId = 'map.split-view';
+function getSplitViewCommand(ctx) {
+  return {
+    id: splitViewCommandId,
+    name: 'Toggle split map view',
+    group: 'Map',
+    description: "Enable or disable the dual-map (split view) comparison mode.\n\nWhen enabled, the map splits into two panels for side-by-side comparison. Pass layerIdsForMap0 / layerIdsForMap1 to assign which layers show ONLY in the left / right panel; without these, all layers show on both panels (no comparison).\n\nWhen disabled, the map returns to a single panel.\n\nUse the SAME colorBy / colorType for the layers being compared, so the comparison is fair.",
+    metadata: {
+      readOnly: false,
+      riskLevel: 'low',
+      idempotent: true
+    },
+    inputSchema: _zod.z.object({
+      action: _zod.z["enum"](['enable', 'disable']).describe('"enable" activates dual map mode; "disable" returns to a single map.'),
+      layerIdsForMap0: _zod.z.array(_zod.z.string()).optional().describe('Layer IDs to show ONLY in the LEFT panel. Layers not listed are hidden from the left panel.'),
+      layerIdsForMap1: _zod.z.array(_zod.z.string()).optional().describe('Layer IDs to show ONLY in the RIGHT panel. Layers not listed are hidden from the right panel.')
+    }),
+    execute: function () {
+      var _execute = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(_execCtx, input) {
+        var _ref, action, layerIdsForMap0, layerIdsForMap1, _iterator, _step, _step$value, name, _ids, visState, isSplit, hasLayerAssignment, updatedVis, splitMaps, allLayers, allLayerIds, allLayerIdSet, _iterator2, _step2, _step2$value, panel, ids, unknown, _splitMaps$, map0Layers, desiredSet0, _iterator3, _step3, layerId, isVisible, shouldBeVisible, _freshSplitMaps$, freshSplitMaps, map1Layers, desiredSet1, _iterator4, _step4, _layerId, _isVisible, _shouldBeVisible, finalVis, layers;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _ref = input !== null && input !== void 0 ? input : {}, action = _ref.action, layerIdsForMap0 = _ref.layerIdsForMap0, layerIdsForMap1 = _ref.layerIdsForMap1;
+              _context.prev = 1;
+              if (!(action !== 'enable' && action !== 'disable')) {
+                _context.next = 4;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: splitViewCommandId,
+                error: "Invalid action \"".concat(String(action), "\". Must be \"enable\" or \"disable\"."),
+                data: {
+                  instruction: 'Pass action: "enable" to activate dual map mode, or "disable" to return to a single map.'
+                }
+              });
+            case 4:
+              // Runtime guard: the bridge/webMCP call execute without zod parsing, so
+              // a string/object passed as layerIdsForMap0/1 must not be treated as
+              // iterable (`.length`, `.filter`) and produce surprising layer toggles.
+              // Reject non-array or non-string entries when these fields are provided.
+              _iterator = _createForOfIteratorHelper([['layerIdsForMap0', layerIdsForMap0], ['layerIdsForMap1', layerIdsForMap1]]);
+              _context.prev = 5;
+              _iterator.s();
+            case 7:
+              if ((_step = _iterator.n()).done) {
+                _context.next = 13;
+                break;
+              }
+              _step$value = (0, _slicedToArray2["default"])(_step.value, 2), name = _step$value[0], _ids = _step$value[1];
+              if (!(_ids !== undefined && (!Array.isArray(_ids) || _ids.some(function (id) {
+                return typeof id !== 'string' || id.length === 0;
+              })))) {
+                _context.next = 11;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: splitViewCommandId,
+                error: "Invalid ".concat(name, ". Must be an array of non-empty layer id strings."),
+                data: {
+                  instruction: "Pass ".concat(name, " as an array of layer id strings, or omit it to show all layers on that panel.")
+                }
+              });
+            case 11:
+              _context.next = 7;
+              break;
+            case 13:
+              _context.next = 18;
+              break;
+            case 15:
+              _context.prev = 15;
+              _context.t0 = _context["catch"](5);
+              _iterator.e(_context.t0);
+            case 18:
+              _context.prev = 18;
+              _iterator.f();
+              return _context.finish(18);
+            case 21:
+              visState = ctx.getVisState();
+              isSplit = visState.splitMaps && visState.splitMaps.length > 1;
+              if (!(action === 'disable')) {
+                _context.next = 26;
+                break;
+              }
+              if (isSplit) {
+                // Close the RIGHT panel (index 1) so the LEFT panel (map0) survives:
+                // `closeSpecificMapAtIndex` keeps `1 - payload`, so closing 0 would
+                // keep the right panel and flip layer visibility to map1's config.
+                ctx.dispatch((0, _actions.toggleSplitMap)(1));
+              }
+              return _context.abrupt("return", {
+                success: true,
+                commandId: splitViewCommandId,
+                data: {
+                  details: 'Split map view disabled. Returned to single map view.'
+                }
+              });
+            case 26:
+              // enable
+              if (!isSplit) {
+                ctx.dispatch((0, _actions.toggleSplitMap)(0));
+              }
+              hasLayerAssignment = layerIdsForMap0 && layerIdsForMap0.length > 0 || layerIdsForMap1 && layerIdsForMap1.length > 0;
+              if (!hasLayerAssignment) {
+                _context.next = 58;
+                break;
+              }
+              _context.next = 31;
+              return sleep(200);
+            case 31:
+              updatedVis = ctx.getVisState();
+              splitMaps = updatedVis.splitMaps;
+              if (!(splitMaps && splitMaps.length > 1)) {
+                _context.next = 58;
+                break;
+              }
+              allLayers = updatedVis.layers || [];
+              allLayerIds = allLayers.map(function (l) {
+                return l.id;
+              }); // Fail fast on unknown layer ids — silently ignoring them would
+              // hide every real layer not listed and produce an unexpected blank
+              // panel.
+              allLayerIdSet = new Set(allLayerIds);
+              _iterator2 = _createForOfIteratorHelper([['left (map0)', layerIdsForMap0], ['right (map1)', layerIdsForMap1]]);
+              _context.prev = 38;
+              _iterator2.s();
+            case 40:
+              if ((_step2 = _iterator2.n()).done) {
+                _context.next = 48;
+                break;
+              }
+              _step2$value = (0, _slicedToArray2["default"])(_step2.value, 2), panel = _step2$value[0], ids = _step2$value[1];
+              if (!(ids && ids.length > 0)) {
+                _context.next = 46;
+                break;
+              }
+              unknown = ids.filter(function (id) {
+                return !allLayerIdSet.has(id);
+              });
+              if (!(unknown.length > 0)) {
+                _context.next = 46;
+                break;
+              }
+              throw new Error("Unknown layer id(s) for the ".concat(panel, " panel: ").concat(unknown.join(', '), ". ") + "Available layer ids: ".concat(allLayerIds.join(', ')));
+            case 46:
+              _context.next = 40;
+              break;
+            case 48:
+              _context.next = 53;
+              break;
+            case 50:
+              _context.prev = 50;
+              _context.t1 = _context["catch"](38);
+              _iterator2.e(_context.t1);
+            case 53:
+              _context.prev = 53;
+              _iterator2.f();
+              return _context.finish(53);
+            case 56:
+              if (layerIdsForMap0 && layerIdsForMap0.length > 0) {
+                map0Layers = ((_splitMaps$ = splitMaps[0]) === null || _splitMaps$ === void 0 ? void 0 : _splitMaps$.layers) || {};
+                desiredSet0 = new Set(layerIdsForMap0);
+                _iterator3 = _createForOfIteratorHelper(allLayerIds);
+                try {
+                  for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                    layerId = _step3.value;
+                    // Coerce to boolean: a missing entry means "hidden", and
+                    // `toggleLayerForMapUpdater` toggles missing entries to visible.
+                    isVisible = Boolean(map0Layers[layerId]);
+                    shouldBeVisible = desiredSet0.has(layerId);
+                    if (isVisible !== shouldBeVisible) {
+                      ctx.dispatch((0, _actions.toggleLayerForMap)(0, layerId));
+                    }
+                  }
+                } catch (err) {
+                  _iterator3.e(err);
+                } finally {
+                  _iterator3.f();
+                }
+              }
+              if (layerIdsForMap1 && layerIdsForMap1.length > 0) {
+                freshSplitMaps = ctx.getVisState().splitMaps;
+                map1Layers = (freshSplitMaps === null || freshSplitMaps === void 0 || (_freshSplitMaps$ = freshSplitMaps[1]) === null || _freshSplitMaps$ === void 0 ? void 0 : _freshSplitMaps$.layers) || {};
+                desiredSet1 = new Set(layerIdsForMap1);
+                _iterator4 = _createForOfIteratorHelper(allLayerIds);
+                try {
+                  for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                    _layerId = _step4.value;
+                    // Coerce to boolean: a missing entry means "hidden", and
+                    // `toggleLayerForMapUpdater` toggles missing entries to visible.
+                    _isVisible = Boolean(map1Layers[_layerId]);
+                    _shouldBeVisible = desiredSet1.has(_layerId);
+                    if (_isVisible !== _shouldBeVisible) {
+                      ctx.dispatch((0, _actions.toggleLayerForMap)(1, _layerId));
+                    }
+                  }
+                } catch (err) {
+                  _iterator4.e(err);
+                } finally {
+                  _iterator4.f();
+                }
+              }
+            case 58:
+              finalVis = ctx.getVisState();
+              layers = finalVis.layers || [];
+              return _context.abrupt("return", {
+                success: true,
+                commandId: splitViewCommandId,
+                data: {
+                  details: "Split map view enabled. ".concat(layers.length, " layer(s) available.").concat(hasLayerAssignment ? " Left panel: ".concat((layerIdsForMap0 || []).length, " layer(s), Right panel: ").concat((layerIdsForMap1 || []).length, " layer(s).") : ' All layers visible on both panels. Provide layerIdsForMap0/layerIdsForMap1 to assign layers to each panel.')
+                }
+              });
+            case 63:
+              _context.prev = 63;
+              _context.t2 = _context["catch"](1);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: splitViewCommandId,
+                error: _context.t2 instanceof Error ? _context.t2.message : 'Unknown error',
+                data: {
+                  instruction: 'Check that a map is loaded and layers exist. If the error persists, ask the user to try with different parameters.'
+                }
+              });
+            case 66:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 63], [5, 15, 18, 21], [38, 50, 53, 56]]);
+      }));
+      function execute(_x, _x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_zod","require","_actions","_createForOfIteratorHelper","r","e","t","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","length","_n","F","s","n","done","value","f","TypeError","o","a","u","call","next","_arrayLikeToArray","toString","slice","constructor","name","from","test","sleep","ms","Promise","resolve","setTimeout","splitViewCommandId","exports","getSplitViewCommand","ctx","id","group","description","metadata","readOnly","riskLevel","idempotent","inputSchema","z","object","action","describe","layerIdsForMap0","array","string","optional","layerIdsForMap1","execute","_execute","_asyncToGenerator2","_regenerator","mark","_callee","_execCtx","input","_ref","_iterator","_step","_step$value","_ids","visState","isSplit","hasLayerAssignment","updatedVis","splitMaps","allLayers","allLayerIds","allLayerIdSet","_iterator2","_step2","_step2$value","panel","ids","unknown","_splitMaps$","map0Layers","desiredSet0","_iterator3","_step3","layerId","isVisible","shouldBeVisible","_freshSplitMaps$","freshSplitMaps","map1Layers","desiredSet1","_iterator4","_step4","_layerId","_isVisible","_shouldBeVisible","finalVis","layers","wrap","_callee$","_context","prev","abrupt","success","commandId","error","concat","String","data","instruction","_slicedToArray2","undefined","some","t0","finish","getVisState","dispatch","toggleSplitMap","details","map","l","Set","filter","has","Error","join","t1","Boolean","toggleLayerForMap","err","t2","message","stop","_x","_x2","apply","arguments"],"sources":["../../../src/commands/split-view-command.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport type {RoomCommand} from './types';\nimport {z} from 'zod';\nimport {toggleSplitMap, toggleLayerForMap} from '@kepler.gl/actions';\nimport type {KeplerContext} from './types';\n\nconst sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));\n\nexport const splitViewCommandId = 'map.split-view' as const;\n\nexport function getSplitViewCommand(ctx: KeplerContext): RoomCommand {\n  return {\n    id: splitViewCommandId,\n    name: 'Toggle split map view',\n    group: 'Map',\n    description: `Enable or disable the dual-map (split view) comparison mode.\n\nWhen enabled, the map splits into two panels for side-by-side comparison. Pass layerIdsForMap0 / layerIdsForMap1 to assign which layers show ONLY in the left / right panel; without these, all layers show on both panels (no comparison).\n\nWhen disabled, the map returns to a single panel.\n\nUse the SAME colorBy / colorType for the layers being compared, so the comparison is fair.`,\n    metadata: {readOnly: false, riskLevel: 'low', idempotent: true},\n    inputSchema: z.object({\n      action: z\n        .enum(['enable', 'disable'])\n        .describe('\"enable\" activates dual map mode; \"disable\" returns to a single map.'),\n      layerIdsForMap0: z\n        .array(z.string())\n        .optional()\n        .describe(\n          'Layer IDs to show ONLY in the LEFT panel. Layers not listed are hidden from the left panel.'\n        ),\n      layerIdsForMap1: z\n        .array(z.string())\n        .optional()\n        .describe(\n          'Layer IDs to show ONLY in the RIGHT panel. Layers not listed are hidden from the right panel.'\n        )\n    }) as any,\n    execute: async (_execCtx, input) => {\n      const {action, layerIdsForMap0, layerIdsForMap1} = (input ?? {}) as {\n        action: 'enable' | 'disable';\n        layerIdsForMap0?: string[];\n        layerIdsForMap1?: string[];\n      };\n      try {\n        // Runtime guard: the bridge/webMCP call execute without zod parsing, so\n        // a missing/invalid action must not fall through to the enable path and\n        // toggle split view unexpectedly.\n        if (action !== 'enable' && action !== 'disable') {\n          return {\n            success: false,\n            commandId: splitViewCommandId,\n            error: `Invalid action \"${String(action)}\". Must be \"enable\" or \"disable\".`,\n            data: {\n              instruction:\n                'Pass action: \"enable\" to activate dual map mode, or \"disable\" to return to a single map.'\n            }\n          };\n        }\n\n        // Runtime guard: the bridge/webMCP call execute without zod parsing, so\n        // a string/object passed as layerIdsForMap0/1 must not be treated as\n        // iterable (`.length`, `.filter`) and produce surprising layer toggles.\n        // Reject non-array or non-string entries when these fields are provided.\n        for (const [name, ids] of [\n          ['layerIdsForMap0', layerIdsForMap0],\n          ['layerIdsForMap1', layerIdsForMap1]\n        ] as const) {\n          if (\n            ids !== undefined &&\n            (!Array.isArray(ids) || ids.some(id => typeof id !== 'string' || id.length === 0))\n          ) {\n            return {\n              success: false,\n              commandId: splitViewCommandId,\n              error: `Invalid ${name}. Must be an array of non-empty layer id strings.`,\n              data: {\n                instruction: `Pass ${name} as an array of layer id strings, or omit it to show all layers on that panel.`\n              }\n            };\n          }\n        }\n\n        const visState = ctx.getVisState();\n        const isSplit = visState.splitMaps && visState.splitMaps.length > 1;\n\n        if (action === 'disable') {\n          if (isSplit) {\n            // Close the RIGHT panel (index 1) so the LEFT panel (map0) survives:\n            // `closeSpecificMapAtIndex` keeps `1 - payload`, so closing 0 would\n            // keep the right panel and flip layer visibility to map1's config.\n            ctx.dispatch(toggleSplitMap(1));\n          }\n          return {\n            success: true,\n            commandId: splitViewCommandId,\n            data: {details: 'Split map view disabled. Returned to single map view.'}\n          };\n        }\n\n        // enable\n        if (!isSplit) {\n          ctx.dispatch(toggleSplitMap(0));\n        }\n\n        const hasLayerAssignment =\n          (layerIdsForMap0 && layerIdsForMap0.length > 0) ||\n          (layerIdsForMap1 && layerIdsForMap1.length > 0);\n\n        if (hasLayerAssignment) {\n          await sleep(200);\n          const updatedVis = ctx.getVisState();\n          const splitMaps = updatedVis.splitMaps;\n\n          if (splitMaps && splitMaps.length > 1) {\n            const allLayers = updatedVis.layers || [];\n            const allLayerIds = allLayers.map((l: any) => l.id);\n\n            // Fail fast on unknown layer ids — silently ignoring them would\n            // hide every real layer not listed and produce an unexpected blank\n            // panel.\n            const allLayerIdSet = new Set(allLayerIds);\n            for (const [panel, ids] of [\n              ['left (map0)', layerIdsForMap0],\n              ['right (map1)', layerIdsForMap1]\n            ] as const) {\n              if (ids && ids.length > 0) {\n                const unknown = ids.filter(id => !allLayerIdSet.has(id));\n                if (unknown.length > 0) {\n                  throw new Error(\n                    `Unknown layer id(s) for the ${panel} panel: ${unknown.join(', ')}. ` +\n                      `Available layer ids: ${allLayerIds.join(', ')}`\n                  );\n                }\n              }\n            }\n\n            if (layerIdsForMap0 && layerIdsForMap0.length > 0) {\n              const map0Layers = splitMaps[0]?.layers || {};\n              const desiredSet0 = new Set(layerIdsForMap0);\n              for (const layerId of allLayerIds) {\n                // Coerce to boolean: a missing entry means \"hidden\", and\n                // `toggleLayerForMapUpdater` toggles missing entries to visible.\n                const isVisible = Boolean(map0Layers[layerId]);\n                const shouldBeVisible = desiredSet0.has(layerId);\n                if (isVisible !== shouldBeVisible) {\n                  ctx.dispatch(toggleLayerForMap(0, layerId));\n                }\n              }\n            }\n\n            if (layerIdsForMap1 && layerIdsForMap1.length > 0) {\n              const freshSplitMaps = ctx.getVisState().splitMaps;\n              const map1Layers = freshSplitMaps?.[1]?.layers || {};\n              const desiredSet1 = new Set(layerIdsForMap1);\n              for (const layerId of allLayerIds) {\n                // Coerce to boolean: a missing entry means \"hidden\", and\n                // `toggleLayerForMapUpdater` toggles missing entries to visible.\n                const isVisible = Boolean(map1Layers[layerId]);\n                const shouldBeVisible = desiredSet1.has(layerId);\n                if (isVisible !== shouldBeVisible) {\n                  ctx.dispatch(toggleLayerForMap(1, layerId));\n                }\n              }\n            }\n          }\n        }\n\n        const finalVis = ctx.getVisState();\n        const layers = finalVis.layers || [];\n\n        return {\n          success: true,\n          commandId: splitViewCommandId,\n          data: {\n            details: `Split map view enabled. ${layers.length} layer(s) available.${\n              hasLayerAssignment\n                ? ` Left panel: ${(layerIdsForMap0 || []).length} layer(s), Right panel: ${\n                    (layerIdsForMap1 || []).length\n                  } layer(s).`\n                : ' All layers visible on both panels. Provide layerIdsForMap0/layerIdsForMap1 to assign layers to each panel.'\n            }`\n          }\n        };\n      } catch (error) {\n        return {\n          success: false,\n          commandId: splitViewCommandId,\n          error: error instanceof Error ? error.message : 'Unknown error',\n          data: {\n            instruction:\n              'Check that a map is loaded and layers exist. If the error persists, ask the user to try with different parameters.'\n          }\n        };\n      }\n    }\n  };\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/commands/table-command.js

@@ -0,0 +1,199 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTableCommand = getTableCommand;
+exports.tableCommandId = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _zod = require("zod");
+var _apacheArrow = require("apache-arrow");
+var _actions = require("@kepler.gl/actions");
+var _processors = require("@kepler.gl/processors");
+var _utils = require("./utils");
+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
+var tableCommandId = exports.tableCommandId = 'map.create-table';
+function getTableCommand(ctx) {
+  return {
+    id: tableCommandId,
+    name: 'Create map dataset via SQL',
+    group: 'Map',
+    description: "Create a NEW dataset in kepler.gl from a SQL query. The result becomes a SEPARATE new dataset (resultDatasetName); the ORIGINAL dataset and its layers/filters are left untouched. Use it to build a new table with different columns \u2014 e.g. add, delete, or rename columns, or change a column's type (CAST(col AS <type>)) \u2014 inside the new dataset.\nNOTE: To modify an EXISTING dataset in place, do NOT use this command \u2014 use map.add-column instead (add a column that copies an existing one to \"rename\", or casts it via expression to change its type). Only reach for map.create-table when the user wants a NEW, separate dataset.\nPlease note:\n1. Do not use * to select all columns, instead use all the column names in dataset.\n2. List all column names the new table or dataset will have.\nIMPORTANT: Use __TABLE__ as the table name placeholder in SQL. It will be replaced with the actual DuckDB table name at runtime.",
+    metadata: {
+      readOnly: false,
+      riskLevel: 'high',
+      idempotent: false,
+      requiresConfirmation: true
+    },
+    inputSchema: _zod.z.object({
+      datasetName: _zod.z.string().describe('The name of the source dataset'),
+      variableNames: _zod.z.array(_zod.z.string()).describe('Only use variable names that already exist in the dataset.'),
+      sql: _zod.z.string().describe('The SQL query to execute. Use __TABLE__ as the table name placeholder.'),
+      resultDatasetName: _zod.z.string().describe('The name for the new dataset')
+    }),
+    execute: function () {
+      var _execute = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(_execCtx, input) {
+        var _ref, datasetName, variableNames, sql, resultDatasetName, visState, datasets, dataId, dbTableName, resolvedSql, uniqueVariableNames, columnData, objectColumns, _iterator, _step, varName, values, arrowTable, db, arrowResult, jsonResult, parsedData, firstFiveRows;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _ref = input !== null && input !== void 0 ? input : {}, datasetName = _ref.datasetName, variableNames = _ref.variableNames, sql = _ref.sql, resultDatasetName = _ref.resultDatasetName;
+              _context.prev = 1;
+              if (!(typeof datasetName !== 'string' || datasetName.length === 0)) {
+                _context.next = 4;
+                break;
+              }
+              throw new Error('datasetName must be a non-empty string.');
+            case 4:
+              if (!(!Array.isArray(variableNames) || variableNames.length === 0 || variableNames.some(function (v) {
+                return typeof v !== 'string' || v.length === 0;
+              }))) {
+                _context.next = 6;
+                break;
+              }
+              throw new Error('variableNames must be a non-empty array of non-empty strings.');
+            case 6:
+              if (!(typeof sql !== 'string' || sql.length === 0)) {
+                _context.next = 8;
+                break;
+              }
+              throw new Error('sql must be a non-empty string.');
+            case 8:
+              if (!(typeof resultDatasetName !== 'string' || resultDatasetName.length === 0)) {
+                _context.next = 10;
+                break;
+              }
+              throw new Error('resultDatasetName must be a non-empty string.');
+            case 10:
+              visState = ctx.getVisState();
+              datasets = visState.datasets;
+              dataId = Object.keys(datasets).find(function (id) {
+                return id === datasetName || datasets[id].label === datasetName;
+              });
+              if (dataId) {
+                _context.next = 15;
+                break;
+              }
+              throw new Error("Dataset \"".concat(datasetName, "\" not found."));
+            case 15:
+              // Derive the DuckDB table name from the resolved dataset id, not the
+              // user-provided label: different labels can sanitize to the same table
+              // name (e.g. "A-B" vs "A B"), which would clobber another dataset's
+              // temp table inside DuckDB and run the SQL against unintended data.
+              dbTableName = (0, _utils.datasetNameToTableName)(dataId); // The contract requires the __TABLE__ placeholder — without it the
+              // query would run against whatever table names appear in the SQL (or
+              // return unrelated results), which is especially risky for a
+              // high-risk, confirmation-gated command. Fail fast with an actionable
+              // error instead.
+              if (sql.includes('__TABLE__')) {
+                _context.next = 18;
+                break;
+              }
+              throw new Error('The SQL query must use the __TABLE__ placeholder as the table name, ' + 'e.g. `SELECT * FROM __TABLE__`.');
+            case 18:
+              resolvedSql = sql.replace(/__TABLE__/g, "\"".concat(dbTableName, "\"")); // Dedupe variableNames: duplicate names would silently overwrite
+              // earlier entries in columnData, producing an Arrow table that doesn't
+              // match the requested column list.
+              uniqueVariableNames = (0, _toConsumableArray2["default"])(new Set(variableNames));
+              columnData = {}; // Object-valued columns (the `_geojson` Feature objects) must not be
+              // round-tripped through Arrow raw: `tableFromArrays` infers ONE Arrow
+              // type per column from the first value, so a dataset mixing Polygon and
+              // MultiPolygon features gets the shallower (Polygon) coordinate nesting
+              // and the MultiPolygon coordinates come back as nulls. Stringify them
+              // for the DuckDB round-trip and restore the objects afterwards.
+              objectColumns = [];
+              _iterator = _createForOfIteratorHelper(uniqueVariableNames);
+              try {
+                for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                  varName = _step.value;
+                  // Pass the user-provided datasetName (label or id) — the documented
+                  // KeplerContext contract — not the resolved id; getValuesFromDataset
+                  // matches by label or id either way.
+                  values = ctx.getValuesFromDataset(datasetName, varName);
+                  if ((0, _utils.isObjectColumn)(values)) objectColumns.push(varName);
+                  columnData[varName] = (0, _utils.stringifyObjectColumn)(values);
+                }
+              } catch (err) {
+                _iterator.e(err);
+              } finally {
+                _iterator.f();
+              }
+              arrowTable = (0, _apacheArrow.tableFromArrays)(columnData);
+              _context.next = 27;
+              return ctx.getConnector();
+            case 27:
+              db = _context.sent;
+              _context.next = 30;
+              return db.execute("DROP TABLE IF EXISTS \"".concat(dbTableName, "\""));
+            case 30:
+              _context.next = 32;
+              return db.loadArrow(arrowTable, dbTableName);
+            case 32:
+              _context.next = 34;
+              return db.query(resolvedSql);
+            case 34:
+              arrowResult = _context.sent;
+              jsonResult = (0, _utils.arrowTableToObjects)(arrowResult);
+              (0, _utils.restoreObjectColumns)(jsonResult, objectColumns);
+              _context.next = 39;
+              return (0, _processors.processFileData)({
+                content: {
+                  data: jsonResult,
+                  fileName: resultDatasetName
+                },
+                fileCache: []
+              });
+            case 39:
+              parsedData = _context.sent;
+              ctx.dispatch((0, _actions.addDataToMap)({
+                datasets: parsedData,
+                // No auto-create — the assistant creates the layer explicitly via
+                // `map.add-layer` to avoid duplicate default layers.
+                options: {
+                  autoCreateLayers: false,
+                  centerMap: true
+                }
+              }));
+
+              // Trimmed, model-facing subset (ported from the old `toModelOutput`).
+              firstFiveRows = jsonResult.slice(0, 5);
+              return _context.abrupt("return", {
+                success: true,
+                commandId: tableCommandId,
+                data: {
+                  details: "Table created as ".concat(resultDatasetName, " (").concat(jsonResult.length, " rows) and added to kepler.gl."),
+                  resultDatasetName: resultDatasetName,
+                  firstFiveRows: firstFiveRows
+                }
+              });
+            case 45:
+              _context.prev = 45;
+              _context.t0 = _context["catch"](1);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: tableCommandId,
+                error: _context.t0 instanceof Error ? _context.t0.message : String(_context.t0),
+                data: {
+                  instruction: 'Please explain the error and give a plan to fix it. Then try again with a different query.'
+                }
+              });
+            case 48:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 45]]);
+      }));
+      function execute(_x, _x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_zod","require","_apacheArrow","_actions","_processors","_utils","_createForOfIteratorHelper","r","e","t","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","length","_n","F","s","n","done","value","f","TypeError","o","a","u","call","next","_arrayLikeToArray","toString","slice","constructor","name","from","test","tableCommandId","exports","getTableCommand","ctx","id","group","description","metadata","readOnly","riskLevel","idempotent","requiresConfirmation","inputSchema","z","object","datasetName","string","describe","variableNames","array","sql","resultDatasetName","execute","_execute","_asyncToGenerator2","_regenerator","mark","_callee","_execCtx","input","_ref","visState","datasets","dataId","dbTableName","resolvedSql","uniqueVariableNames","columnData","objectColumns","_iterator","_step","varName","values","arrowTable","db","arrowResult","jsonResult","parsedData","firstFiveRows","wrap","_callee$","_context","prev","Error","some","v","getVisState","Object","keys","find","label","concat","datasetNameToTableName","includes","replace","_toConsumableArray2","Set","getValuesFromDataset","isObjectColumn","push","stringifyObjectColumn","err","tableFromArrays","getConnector","sent","loadArrow","query","arrowTableToObjects","restoreObjectColumns","processFileData","content","data","fileName","fileCache","dispatch","addDataToMap","options","autoCreateLayers","centerMap","abrupt","success","commandId","details","t0","error","message","String","instruction","stop","_x","_x2","apply","arguments"],"sources":["../../../src/commands/table-command.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport type {RoomCommand} from './types';\nimport {z} from 'zod';\nimport {tableFromArrays, Table as ArrowTable} from 'apache-arrow';\nimport {addDataToMap} from '@kepler.gl/actions';\nimport {processFileData} from '@kepler.gl/processors';\nimport type {KeplerContext} from './types';\nimport {datasetNameToTableName, arrowTableToObjects} from './utils';\nimport {isObjectColumn, stringifyObjectColumn, restoreObjectColumns} from './utils';\n\nexport const tableCommandId = 'map.create-table' as const;\n\nexport function getTableCommand(ctx: KeplerContext): RoomCommand {\n  return {\n    id: tableCommandId,\n    name: 'Create map dataset via SQL',\n    group: 'Map',\n    description: `Create a NEW dataset in kepler.gl from a SQL query. The result becomes a SEPARATE new dataset (resultDatasetName); the ORIGINAL dataset and its layers/filters are left untouched. Use it to build a new table with different columns — e.g. add, delete, or rename columns, or change a column's type (CAST(col AS <type>)) — inside the new dataset.\nNOTE: To modify an EXISTING dataset in place, do NOT use this command — use map.add-column instead (add a column that copies an existing one to \"rename\", or casts it via expression to change its type). Only reach for map.create-table when the user wants a NEW, separate dataset.\nPlease note:\n1. Do not use * to select all columns, instead use all the column names in dataset.\n2. List all column names the new table or dataset will have.\nIMPORTANT: Use __TABLE__ as the table name placeholder in SQL. It will be replaced with the actual DuckDB table name at runtime.`,\n    metadata: {readOnly: false, riskLevel: 'high', idempotent: false, requiresConfirmation: true},\n    inputSchema: z.object({\n      datasetName: z.string().describe('The name of the source dataset'),\n      variableNames: z\n        .array(z.string())\n        .describe('Only use variable names that already exist in the dataset.'),\n      sql: z\n        .string()\n        .describe('The SQL query to execute. Use __TABLE__ as the table name placeholder.'),\n      resultDatasetName: z.string().describe('The name for the new dataset')\n    }) as any,\n    execute: async (_execCtx, input) => {\n      const {datasetName, variableNames, sql, resultDatasetName} = (input ?? {}) as {\n        datasetName: string;\n        variableNames: string[];\n        sql: string;\n        resultDatasetName: string;\n      };\n      try {\n        // Runtime guard: the bridge/webMCP call execute without zod parsing, so\n        // missing/wrong-typed inputs must not fall through to TypeErrors (e.g.\n        // `sql.includes` on a non-string) that surface as confusing errors.\n        if (typeof datasetName !== 'string' || datasetName.length === 0) {\n          throw new Error('datasetName must be a non-empty string.');\n        }\n        if (\n          !Array.isArray(variableNames) ||\n          variableNames.length === 0 ||\n          variableNames.some(v => typeof v !== 'string' || v.length === 0)\n        ) {\n          throw new Error('variableNames must be a non-empty array of non-empty strings.');\n        }\n        if (typeof sql !== 'string' || sql.length === 0) {\n          throw new Error('sql must be a non-empty string.');\n        }\n        if (typeof resultDatasetName !== 'string' || resultDatasetName.length === 0) {\n          throw new Error('resultDatasetName must be a non-empty string.');\n        }\n\n        const visState = ctx.getVisState();\n        const datasets = visState.datasets;\n        const dataId = Object.keys(datasets).find(\n          id => id === datasetName || datasets[id].label === datasetName\n        );\n        if (!dataId) {\n          throw new Error(`Dataset \"${datasetName}\" not found.`);\n        }\n        // Derive the DuckDB table name from the resolved dataset id, not the\n        // user-provided label: different labels can sanitize to the same table\n        // name (e.g. \"A-B\" vs \"A B\"), which would clobber another dataset's\n        // temp table inside DuckDB and run the SQL against unintended data.\n        const dbTableName = datasetNameToTableName(dataId);\n        // The contract requires the __TABLE__ placeholder — without it the\n        // query would run against whatever table names appear in the SQL (or\n        // return unrelated results), which is especially risky for a\n        // high-risk, confirmation-gated command. Fail fast with an actionable\n        // error instead.\n        if (!sql.includes('__TABLE__')) {\n          throw new Error(\n            'The SQL query must use the __TABLE__ placeholder as the table name, ' +\n              'e.g. `SELECT * FROM __TABLE__`.'\n          );\n        }\n        const resolvedSql = sql.replace(/__TABLE__/g, `\"${dbTableName}\"`);\n        // Dedupe variableNames: duplicate names would silently overwrite\n        // earlier entries in columnData, producing an Arrow table that doesn't\n        // match the requested column list.\n        const uniqueVariableNames = [...new Set(variableNames)];\n        const columnData: Record<string, unknown[]> = {};\n        // Object-valued columns (the `_geojson` Feature objects) must not be\n        // round-tripped through Arrow raw: `tableFromArrays` infers ONE Arrow\n        // type per column from the first value, so a dataset mixing Polygon and\n        // MultiPolygon features gets the shallower (Polygon) coordinate nesting\n        // and the MultiPolygon coordinates come back as nulls. Stringify them\n        // for the DuckDB round-trip and restore the objects afterwards.\n        const objectColumns: string[] = [];\n        for (const varName of uniqueVariableNames) {\n          // Pass the user-provided datasetName (label or id) — the documented\n          // KeplerContext contract — not the resolved id; getValuesFromDataset\n          // matches by label or id either way.\n          const values = ctx.getValuesFromDataset(datasetName, varName);\n          if (isObjectColumn(values)) objectColumns.push(varName);\n          columnData[varName] = stringifyObjectColumn(values);\n        }\n\n        const arrowTable: ArrowTable = tableFromArrays(columnData);\n        const db = await ctx.getConnector();\n\n        await db.execute(`DROP TABLE IF EXISTS \"${dbTableName}\"`);\n        await db.loadArrow(arrowTable, dbTableName);\n\n        const arrowResult = await db.query(resolvedSql);\n\n        const jsonResult: Record<string, unknown>[] = arrowTableToObjects(arrowResult);\n        restoreObjectColumns(jsonResult, objectColumns);\n\n        const parsedData = await processFileData({\n          content: {data: jsonResult, fileName: resultDatasetName},\n          fileCache: []\n        });\n\n        ctx.dispatch(\n          addDataToMap({\n            datasets: parsedData,\n            // No auto-create — the assistant creates the layer explicitly via\n            // `map.add-layer` to avoid duplicate default layers.\n            options: {autoCreateLayers: false, centerMap: true}\n          })\n        );\n\n        // Trimmed, model-facing subset (ported from the old `toModelOutput`).\n        const firstFiveRows = jsonResult.slice(0, 5);\n        return {\n          success: true,\n          commandId: tableCommandId,\n          data: {\n            details: `Table created as ${resultDatasetName} (${jsonResult.length} rows) and added to kepler.gl.`,\n            resultDatasetName,\n            firstFiveRows\n          }\n        };\n      } catch (error) {\n        return {\n          success: false,\n          commandId: tableCommandId,\n          error: error instanceof Error ? error.message : String(error),\n          data: {\n            instruction:\n              'Please explain the error and give a plan to fix it. Then try again with a different query.'\n          }\n        };\n      }\n    }\n  };\n}\n"],"mappings":";;;;;;;;;;;AAIA,IAAAA,IAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AACA,IAAAE,QAAA,GAAAF,OAAA;AACA,IAAAG,WAAA,GAAAH,OAAA;AAEA,IAAAI,MAAA,GAAAJ,OAAA;AAAoE,SAAAK,2BAAAC,CAAA,EAAAC,CAAA,QAAAC,CAAA,yBAAAC,MAAA,IAAAH,CAAA,CAAAG,MAAA,CAAAC,QAAA,KAAAJ,CAAA,qBAAAE,CAAA,QAAAG,KAAA,CAAAC,OAAA,CAAAN,CAAA,MAAAE,CAAA,GAAAK,2BAAA,CAAAP,CAAA,MAAAC,CAAA,IAAAD,CAAA,uBAAAA,CAAA,CAAAQ,MAAA,IAAAN,CAAA,KAAAF,CAAA,GAAAE,CAAA,OAAAO,EAAA,MAAAC,CAAA,YAAAA,EAAA,eAAAC,CAAA,EAAAD,CAAA,EAAAE,CAAA,WAAAA,EAAA,WAAAH,EAAA,IAAAT,CAAA,CAAAQ,MAAA,KAAAK,IAAA,WAAAA,IAAA,MAAAC,KAAA,EAAAd,CAAA,CAAAS,EAAA,UAAAR,CAAA,WAAAA,EAAAD,CAAA,UAAAA,CAAA,KAAAe,CAAA,EAAAL,CAAA,gBAAAM,SAAA,iJAAAC,CAAA,EAAAC,CAAA,OAAAC,CAAA,gBAAAR,CAAA,WAAAA,EAAA,IAAAT,CAAA,GAAAA,CAAA,CAAAkB,IAAA,CAAApB,CAAA,MAAAY,CAAA,WAAAA,EAAA,QAAAZ,CAAA,GAAAE,CAAA,CAAAmB,IAAA,WAAAH,CAAA,GAAAlB,CAAA,CAAAa,IAAA,EAAAb,CAAA,KAAAC,CAAA,WAAAA,EAAAD,CAAA,IAAAmB,CAAA,OAAAF,CAAA,GAAAjB,CAAA,KAAAe,CAAA,WAAAA,EAAA,UAAAG,CAAA,YAAAhB,CAAA,cAAAA,CAAA,8BAAAiB,CAAA,QAAAF,CAAA;AAAA,SAAAV,4BAAAP,CAAA,EAAAkB,CAAA,QAAAlB,CAAA,2BAAAA,CAAA,SAAAsB,iBAAA,CAAAtB,CAAA,EAAAkB,CAAA,OAAAhB,CAAA,MAAAqB,QAAA,CAAAH,IAAA,CAAApB,CAAA,EAAAwB,KAAA,6BAAAtB,CAAA,IAAAF,CAAA,CAAAyB,WAAA,KAAAvB,CAAA,GAAAF,CAAA,CAAAyB,WAAA,CAAAC,IAAA,aAAAxB,CAAA,cAAAA,CAAA,GAAAG,KAAA,CAAAsB,IAAA,CAAA3B,CAAA,oBAAAE,CAAA,+CAAA0B,IAAA,CAAA1B,CAAA,IAAAoB,iBAAA,CAAAtB,CAAA,EAAAkB,CAAA;AAAA,SAAAI,kBAAAtB,CAAA,EAAAkB,CAAA,aAAAA,CAAA,IAAAA,CAAA,GAAAlB,CAAA,CAAAQ,MAAA,MAAAU,CAAA,GAAAlB,CAAA,CAAAQ,MAAA,YAAAP,CAAA,MAAAW,CAAA,GAAAP,KAAA,CAAAa,CAAA,GAAAjB,CAAA,GAAAiB,CAAA,EAAAjB,CAAA,IAAAW,CAAA,CAAAX,CAAA,IAAAD,CAAA,CAAAC,CAAA,UAAAW,CAAA,IATpE;AACA;AAWO,IAAMiB,cAAc,GAAAC,OAAA,CAAAD,cAAA,GAAG,kBAA2B;AAElD,SAASE,eAAeA,CAACC,GAAkB,EAAe;EAC/D,OAAO;IACLC,EAAE,EAAEJ,cAAc;IAClBH,IAAI,EAAE,4BAA4B;IAClCQ,KAAK,EAAE,KAAK;IACZC,WAAW,s6BAKkH;IAC7HC,QAAQ,EAAE;MAACC,QAAQ,EAAE,KAAK;MAAEC,SAAS,EAAE,MAAM;MAAEC,UAAU,EAAE,KAAK;MAAEC,oBAAoB,EAAE;IAAI,CAAC;IAC7FC,WAAW,EAAEC,MAAC,CAACC,MAAM,CAAC;MACpBC,WAAW,EAAEF,MAAC,CAACG,MAAM,CAAC,CAAC,CAACC,QAAQ,CAAC,gCAAgC,CAAC;MAClEC,aAAa,EAAEL,MAAC,CACbM,KAAK,CAACN,MAAC,CAACG,MAAM,CAAC,CAAC,CAAC,CACjBC,QAAQ,CAAC,4DAA4D,CAAC;MACzEG,GAAG,EAAEP,MAAC,CACHG,MAAM,CAAC,CAAC,CACRC,QAAQ,CAAC,wEAAwE,CAAC;MACrFI,iBAAiB,EAAER,MAAC,CAACG,MAAM,CAAC,CAAC,CAACC,QAAQ,CAAC,8BAA8B;IACvE,CAAC,CAAQ;IACTK,OAAO;MAAA,IAAAC,QAAA,OAAAC,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAAE,SAAAC,QAAOC,QAAQ,EAAEC,KAAK;QAAA,IAAAC,IAAA,EAAAf,WAAA,EAAAG,aAAA,EAAAE,GAAA,EAAAC,iBAAA,EAAAU,QAAA,EAAAC,QAAA,EAAAC,MAAA,EAAAC,WAAA,EAAAC,WAAA,EAAAC,mBAAA,EAAAC,UAAA,EAAAC,aAAA,EAAAC,SAAA,EAAAC,KAAA,EAAAC,OAAA,EAAAC,MAAA,EAAAC,UAAA,EAAAC,EAAA,EAAAC,WAAA,EAAAC,UAAA,EAAAC,UAAA,EAAAC,aAAA;QAAA,OAAAvB,YAAA,YAAAwB,IAAA,UAAAC,SAAAC,QAAA;UAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAA3D,IAAA;YAAA;cAAAsC,IAAA,GACiCD,KAAK,aAALA,KAAK,cAALA,KAAK,GAAI,CAAC,CAAC,EAAlEd,WAAW,GAAAe,IAAA,CAAXf,WAAW,EAAEG,aAAa,GAAAY,IAAA,CAAbZ,aAAa,EAAEE,GAAG,GAAAU,IAAA,CAAHV,GAAG,EAAEC,iBAAiB,GAAAS,IAAA,CAAjBT,iBAAiB;cAAA8B,QAAA,CAAAC,IAAA;cAAA,MAUnD,OAAOrC,WAAW,KAAK,QAAQ,IAAIA,WAAW,CAACpC,MAAM,KAAK,CAAC;gBAAAwE,QAAA,CAAA3D,IAAA;gBAAA;cAAA;cAAA,MACvD,IAAI6D,KAAK,CAAC,yCAAyC,CAAC;YAAA;cAAA,MAG1D,CAAC7E,KAAK,CAACC,OAAO,CAACyC,aAAa,CAAC,IAC7BA,aAAa,CAACvC,MAAM,KAAK,CAAC,IAC1BuC,aAAa,CAACoC,IAAI,CAAC,UAAAC,CAAC;gBAAA,OAAI,OAAOA,CAAC,KAAK,QAAQ,IAAIA,CAAC,CAAC5E,MAAM,KAAK,CAAC;cAAA,EAAC;gBAAAwE,QAAA,CAAA3D,IAAA;gBAAA;cAAA;cAAA,MAE1D,IAAI6D,KAAK,CAAC,+DAA+D,CAAC;YAAA;cAAA,MAE9E,OAAOjC,GAAG,KAAK,QAAQ,IAAIA,GAAG,CAACzC,MAAM,KAAK,CAAC;gBAAAwE,QAAA,CAAA3D,IAAA;gBAAA;cAAA;cAAA,MACvC,IAAI6D,KAAK,CAAC,iCAAiC,CAAC;YAAA;cAAA,MAEhD,OAAOhC,iBAAiB,KAAK,QAAQ,IAAIA,iBAAiB,CAAC1C,MAAM,KAAK,CAAC;gBAAAwE,QAAA,CAAA3D,IAAA;gBAAA;cAAA;cAAA,MACnE,IAAI6D,KAAK,CAAC,+CAA+C,CAAC;YAAA;cAG5DtB,QAAQ,GAAG5B,GAAG,CAACqD,WAAW,CAAC,CAAC;cAC5BxB,QAAQ,GAAGD,QAAQ,CAACC,QAAQ;cAC5BC,MAAM,GAAGwB,MAAM,CAACC,IAAI,CAAC1B,QAAQ,CAAC,CAAC2B,IAAI,CACvC,UAAAvD,EAAE;gBAAA,OAAIA,EAAE,KAAKW,WAAW,IAAIiB,QAAQ,CAAC5B,EAAE,CAAC,CAACwD,KAAK,KAAK7C,WAAW;cAAA,CAChE,CAAC;cAAA,IACIkB,MAAM;gBAAAkB,QAAA,CAAA3D,IAAA;gBAAA;cAAA;cAAA,MACH,IAAI6D,KAAK,cAAAQ,MAAA,CAAa9C,WAAW,kBAAc,CAAC;YAAA;cAExD;cACA;cACA;cACA;cACMmB,WAAW,GAAG,IAAA4B,6BAAsB,EAAC7B,MAAM,CAAC,EAClD;cACA;cACA;cACA;cACA;cAAA,IACKb,GAAG,CAAC2C,QAAQ,CAAC,WAAW,CAAC;gBAAAZ,QAAA,CAAA3D,IAAA;gBAAA;cAAA;cAAA,MACtB,IAAI6D,KAAK,CACb,sEAAsE,GACpE,iCACJ,CAAC;YAAA;cAEGlB,WAAW,GAAGf,GAAG,CAAC4C,OAAO,CAAC,YAAY,OAAAH,MAAA,CAAM3B,WAAW,OAAG,CAAC,EACjE;cACA;cACA;cACME,mBAAmB,OAAA6B,mBAAA,aAAO,IAAIC,GAAG,CAAChD,aAAa,CAAC;cAChDmB,UAAqC,GAAG,CAAC,CAAC,EAChD;cACA;cACA;cACA;cACA;cACA;cACMC,aAAuB,GAAG,EAAE;cAAAC,SAAA,GAAArE,0BAAA,CACZkE,mBAAmB;cAAA;gBAAzC,KAAAG,SAAA,CAAAzD,CAAA,MAAA0D,KAAA,GAAAD,SAAA,CAAAxD,CAAA,IAAAC,IAAA,GAA2C;kBAAhCyD,OAAO,GAAAD,KAAA,CAAAvD,KAAA;kBAChB;kBACA;kBACA;kBACMyD,MAAM,GAAGvC,GAAG,CAACgE,oBAAoB,CAACpD,WAAW,EAAE0B,OAAO,CAAC;kBAC7D,IAAI,IAAA2B,qBAAc,EAAC1B,MAAM,CAAC,EAAEJ,aAAa,CAAC+B,IAAI,CAAC5B,OAAO,CAAC;kBACvDJ,UAAU,CAACI,OAAO,CAAC,GAAG,IAAA6B,4BAAqB,EAAC5B,MAAM,CAAC;gBACrD;cAAC,SAAA6B,GAAA;gBAAAhC,SAAA,CAAAnE,CAAA,CAAAmG,GAAA;cAAA;gBAAAhC,SAAA,CAAArD,CAAA;cAAA;cAEKyD,UAAsB,GAAG,IAAA6B,4BAAe,EAACnC,UAAU,CAAC;cAAAc,QAAA,CAAA3D,IAAA;cAAA,OACzCW,GAAG,CAACsE,YAAY,CAAC,CAAC;YAAA;cAA7B7B,EAAE,GAAAO,QAAA,CAAAuB,IAAA;cAAAvB,QAAA,CAAA3D,IAAA;cAAA,OAEFoD,EAAE,CAACtB,OAAO,2BAAAuC,MAAA,CAA0B3B,WAAW,OAAG,CAAC;YAAA;cAAAiB,QAAA,CAAA3D,IAAA;cAAA,OACnDoD,EAAE,CAAC+B,SAAS,CAAChC,UAAU,EAAET,WAAW,CAAC;YAAA;cAAAiB,QAAA,CAAA3D,IAAA;cAAA,OAEjBoD,EAAE,CAACgC,KAAK,CAACzC,WAAW,CAAC;YAAA;cAAzCU,WAAW,GAAAM,QAAA,CAAAuB,IAAA;cAEX5B,UAAqC,GAAG,IAAA+B,0BAAmB,EAAChC,WAAW,CAAC;cAC9E,IAAAiC,2BAAoB,EAAChC,UAAU,EAAER,aAAa,CAAC;cAACa,QAAA,CAAA3D,IAAA;cAAA,OAEvB,IAAAuF,2BAAe,EAAC;gBACvCC,OAAO,EAAE;kBAACC,IAAI,EAAEnC,UAAU;kBAAEoC,QAAQ,EAAE7D;gBAAiB,CAAC;gBACxD8D,SAAS,EAAE;cACb,CAAC,CAAC;YAAA;cAHIpC,UAAU,GAAAI,QAAA,CAAAuB,IAAA;cAKhBvE,GAAG,CAACiF,QAAQ,CACV,IAAAC,qBAAY,EAAC;gBACXrD,QAAQ,EAAEe,UAAU;gBACpB;gBACA;gBACAuC,OAAO,EAAE;kBAACC,gBAAgB,EAAE,KAAK;kBAAEC,SAAS,EAAE;gBAAI;cACpD,CAAC,CACH,CAAC;;cAED;cACMxC,aAAa,GAAGF,UAAU,CAACnD,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;cAAA,OAAAwD,QAAA,CAAAsC,MAAA,WACrC;gBACLC,OAAO,EAAE,IAAI;gBACbC,SAAS,EAAE3F,cAAc;gBACzBiF,IAAI,EAAE;kBACJW,OAAO,sBAAA/B,MAAA,CAAsBxC,iBAAiB,QAAAwC,MAAA,CAAKf,UAAU,CAACnE,MAAM,mCAAgC;kBACpG0C,iBAAiB,EAAjBA,iBAAiB;kBACjB2B,aAAa,EAAbA;gBACF;cACF,CAAC;YAAA;cAAAG,QAAA,CAAAC,IAAA;cAAAD,QAAA,CAAA0C,EAAA,GAAA1C,QAAA;cAAA,OAAAA,QAAA,CAAAsC,MAAA,WAEM;gBACLC,OAAO,EAAE,KAAK;gBACdC,SAAS,EAAE3F,cAAc;gBACzB8F,KAAK,EAAE3C,QAAA,CAAA0C,EAAA,YAAiBxC,KAAK,GAAGF,QAAA,CAAA0C,EAAA,CAAME,OAAO,GAAGC,MAAM,CAAA7C,QAAA,CAAA0C,EAAM,CAAC;gBAC7DZ,IAAI,EAAE;kBACJgB,WAAW,EACT;gBACJ;cACF,CAAC;YAAA;YAAA;cAAA,OAAA9C,QAAA,CAAA+C,IAAA;UAAA;QAAA,GAAAvE,OAAA;MAAA,CAEJ;MAAA,SAzHDL,OAAOA,CAAA6E,EAAA,EAAAC,GAAA;QAAA,OAAA7E,QAAA,CAAA8E,KAAA,OAAAC,SAAA;MAAA;MAAA,OAAPhF,OAAO;IAAA;EA0HT,CAAC;AACH","ignoreList":[]}