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

package/dist/esm/commands/command-wrappers.js

@@ -0,0 +1,114 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Generic utility for converting an existing AI SDK tool into a sqlrooms
+ * `RoomCommand`. Kept dependency-light (only `zod` + `RoomCommand` type) so it
+ * can be reused by any in-browser skill system that wants to expose its
+ * existing AI SDK tools as commands without rewriting them.
+ *
+ * The demo-app's own command factories return `RoomCommand` directly (preferred
+ * when you own the command — see `basemap-command.ts` for the reference shape). This
+ * wrapper is the fallback path for hosts that cannot rewrite their tools:
+ * it folds the tool's `execute`, `inputSchema`, and `toModelOutput` (the
+ * token-trim logic the AI SDK applies between tool call and model) into a
+ * single `RoomCommand.execute` so the registry-stored result already carries
+ * the model-facing subset.
+ */
+
+/** A built AI SDK tool, treated loosely for dynamic dispatch. */
+
+/** Metadata that the AI SDK tool does not carry but a `RoomCommand` requires. */
+
+/**
+ * Cast a concrete zod schema (e.g. `z.object({...})`, which is `ZodObject<...>`)
+ * to the `ZodType<unknown>` that `RoomCommand.inputSchema` expects. The
+ * installed zod `ZodObject` is not structurally assignable to sqlrooms'
+ * `ZodType<unknown>` (covariance on the output type), so a cast is required at
+ * the assignment site. This helper centralizes that cast.
+ */
+export function asInputSchema(schema) {
+  return schema;
+}
+
+/**
+ * Wrap an existing AI SDK tool as a sqlrooms `RoomCommand`. The command's
+ * `execute` calls the tool's `execute` and then applies the tool's
+ * `toModelOutput` (if any) so the trimmed, model-facing shape is what the
+ * registry stores and downstream surfaces (AI skill, palette, CLI, MCP) see.
+ */
+export function toolToCommand(tool, meta) {
+  return {
+    id: meta.id,
+    name: meta.name,
+    description: tool.description,
+    group: meta.group,
+    keywords: meta.keywords,
+    inputSchema: tool.inputSchema,
+    execute: function () {
+      var _execute = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(ctx, input) {
+        var _rawOutput$success, _ref, _ref2, rawOutput, trimmed;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (!(!tool.execute || typeof tool.execute !== 'function')) {
+                _context.next = 2;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: meta.id,
+                error: 'Tool has no execute function.'
+              });
+            case 2:
+              _context.prev = 2;
+              _context.next = 5;
+              return tool.execute(input !== null && input !== void 0 ? input : {}, {
+                toolCallId: meta.id,
+                signal: ctx.signal
+              });
+            case 5:
+              rawOutput = _context.sent;
+              trimmed = typeof tool.toModelOutput === 'function' ? tool.toModelOutput({
+                output: rawOutput,
+                toolCallId: meta.id
+              }) : rawOutput;
+              return _context.abrupt("return", {
+                success: (_rawOutput$success = rawOutput === null || rawOutput === void 0 ? void 0 : rawOutput.success) !== null && _rawOutput$success !== void 0 ? _rawOutput$success : true,
+                commandId: meta.id,
+                // A structured failure (success:false) that didn't throw must still
+                // carry an error message — otherwise callers see {success:false,
+                // error:undefined} and downstream formatters misreport it as a
+                // success. Many tool/result shapes (including RoomCommandResult)
+                // carry the failure in a `message` field rather than `error`, so
+                // fall back to that before the generic message.
+                error: (rawOutput === null || rawOutput === void 0 ? void 0 : rawOutput.success) === false ? (_ref = (_ref2 = rawOutput === null || rawOutput === void 0 ? void 0 : rawOutput.error) !== null && _ref2 !== void 0 ? _ref2 : rawOutput === null || rawOutput === void 0 ? void 0 : rawOutput.message) !== null && _ref !== void 0 ? _ref : 'Tool execution failed.' : undefined,
+                data: _typeof(trimmed) === 'object' && trimmed !== null ? trimmed : {
+                  details: trimmed
+                }
+              });
+            case 10:
+              _context.prev = 10;
+              _context.t0 = _context["catch"](2);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: meta.id,
+                error: _context.t0 instanceof Error ? _context.t0.message : String(_context.t0)
+              });
+            case 13:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[2, 10]]);
+      }));
+      function execute(_x, _x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["asInputSchema","schema","toolToCommand","tool","meta","id","name","description","group","keywords","inputSchema","execute","_execute","_asyncToGenerator","_regeneratorRuntime","mark","_callee","ctx","input","_rawOutput$success","_ref","_ref2","rawOutput","trimmed","wrap","_callee$","_context","prev","next","abrupt","success","commandId","error","toolCallId","signal","sent","toModelOutput","output","message","undefined","data","_typeof","details","t0","Error","String","stop","_x","_x2","apply","arguments"],"sources":["../../../src/commands/command-wrappers.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n/**\n * Generic utility for converting an existing AI SDK tool into a sqlrooms\n * `RoomCommand`. Kept dependency-light (only `zod` + `RoomCommand` type) so it\n * can be reused by any in-browser skill system that wants to expose its\n * existing AI SDK tools as commands without rewriting them.\n *\n * The demo-app's own command factories return `RoomCommand` directly (preferred\n * when you own the command — see `basemap-command.ts` for the reference shape). This\n * wrapper is the fallback path for hosts that cannot rewrite their tools:\n * it folds the tool's `execute`, `inputSchema`, and `toModelOutput` (the\n * token-trim logic the AI SDK applies between tool call and model) into a\n * single `RoomCommand.execute` so the registry-stored result already carries\n * the model-facing subset.\n */\n\nimport type {RoomCommand} from './types';\nimport type {ZodType} from 'zod';\n\n/** A built AI SDK tool, treated loosely for dynamic dispatch. */\nexport type AnyTool = {\n  execute?: (args: any, options: any) => Promise<any>;\n  toModelOutput?: (params: {output: any; toolCallId?: string}) => any;\n  description?: string;\n  inputSchema?: ZodType;\n};\n\n/** Metadata that the AI SDK tool does not carry but a `RoomCommand` requires. */\nexport type CommandMeta = {\n  /** Stable, namespaced command id, e.g. `map.set-basemap`. */\n  id: string;\n  /** Human-readable name shown in the command palette / listings. */\n  name: string;\n  /** Optional grouping label, e.g. `Map`, `Data`, `GeoDa`. */\n  group?: string;\n  /** Optional search keywords. */\n  keywords?: string[];\n};\n\n/**\n * Cast a concrete zod schema (e.g. `z.object({...})`, which is `ZodObject<...>`)\n * to the `ZodType<unknown>` that `RoomCommand.inputSchema` expects. The\n * installed zod `ZodObject` is not structurally assignable to sqlrooms'\n * `ZodType<unknown>` (covariance on the output type), so a cast is required at\n * the assignment site. This helper centralizes that cast.\n */\nexport function asInputSchema(schema: ZodType): ZodType<unknown> {\n  return schema as unknown as ZodType<unknown>;\n}\n\n/**\n * Wrap an existing AI SDK tool as a sqlrooms `RoomCommand`. The command's\n * `execute` calls the tool's `execute` and then applies the tool's\n * `toModelOutput` (if any) so the trimmed, model-facing shape is what the\n * registry stores and downstream surfaces (AI skill, palette, CLI, MCP) see.\n */\nexport function toolToCommand(tool: AnyTool, meta: CommandMeta): RoomCommand {\n  return {\n    id: meta.id,\n    name: meta.name,\n    description: tool.description,\n    group: meta.group,\n    keywords: meta.keywords,\n    inputSchema: tool.inputSchema as any,\n    execute: async (ctx, input) => {\n      if (!tool.execute || typeof tool.execute !== 'function') {\n        return {\n          success: false,\n          commandId: meta.id,\n          error: 'Tool has no execute function.'\n        };\n      }\n      try {\n        // Thread the caller's AbortSignal through so hosts (WebMCP / bridge)\n        // can cancel long-running wrapped tools when the agent aborts. Tools\n        // that don't use a signal ignore it.\n        const rawOutput = await tool.execute(input ?? {}, {\n          toolCallId: meta.id,\n          signal: ctx.signal\n        });\n        const trimmed =\n          typeof tool.toModelOutput === 'function'\n            ? tool.toModelOutput({output: rawOutput, toolCallId: meta.id})\n            : rawOutput;\n        return {\n          success: rawOutput?.success ?? true,\n          commandId: meta.id,\n          // A structured failure (success:false) that didn't throw must still\n          // carry an error message — otherwise callers see {success:false,\n          // error:undefined} and downstream formatters misreport it as a\n          // success. Many tool/result shapes (including RoomCommandResult)\n          // carry the failure in a `message` field rather than `error`, so\n          // fall back to that before the generic message.\n          error:\n            rawOutput?.success === false\n              ? (rawOutput?.error as string | undefined) ??\n                (rawOutput?.message as string | undefined) ??\n                'Tool execution failed.'\n              : undefined,\n          data: typeof trimmed === 'object' && trimmed !== null ? trimmed : {details: trimmed}\n        };\n      } catch (error) {\n        return {\n          success: false,\n          commandId: meta.id,\n          error: error instanceof Error ? error.message : String(error)\n        };\n      }\n    }\n  };\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/commands/dataset-context-command.js

@@ -0,0 +1,79 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { z } from 'zod';
+export var datasetContextCommandId = 'map.get-dataset-context';
+export function getDatasetContextCommand(ctx) {
+  return {
+    id: datasetContextCommandId,
+    name: 'Get dataset context',
+    group: 'Map',
+    description: 'Get all loaded kepler.gl datasets with their fields and layer configurations. ' + 'Returns each dataset name, id, field name→type mappings, and the layers ' + '(id, label, type, geometryMode, geometryColumns) bound to it.',
+    metadata: {
+      readOnly: true,
+      riskLevel: 'low',
+      idempotent: true
+    },
+    inputSchema: z.object({}),
+    execute: function () {
+      var _execute = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var context, trimmed, datasets, count;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              context = ctx.getDatasetContext();
+              if (context) {
+                _context.next = 4;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: datasetContextCommandId,
+                error: 'No datasets or layers available.',
+                data: {
+                  instruction: 'Please ensure the kepler.gl map has loaded datasets and try again.'
+                }
+              });
+            case 4:
+              // Accept either a pure-JSON context or the two-part "human line + JSON"
+              // format: hosts may return either, so don't assume the first line is a
+              // preface.
+              trimmed = context.trim();
+              datasets = JSON.parse(trimmed.startsWith('[') || trimmed.startsWith('{') ? trimmed : context.split('\n').slice(1).join('\n'));
+              count = Array.isArray(datasets) ? datasets.length : Object.keys(datasets).length;
+              return _context.abrupt("return", {
+                success: true,
+                commandId: datasetContextCommandId,
+                data: {
+                  details: "".concat(count, " dataset(s) loaded."),
+                  datasets: datasets
+                }
+              });
+            case 10:
+              _context.prev = 10;
+              _context.t0 = _context["catch"](0);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: datasetContextCommandId,
+                error: _context.t0 instanceof Error ? _context.t0.message : 'Unknown error',
+                data: {
+                  instruction: 'Please ensure the kepler.gl map is properly loaded and try again.'
+                }
+              });
+            case 13:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[0, 10]]);
+      }));
+      function execute() {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/commands/index.js

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { getBasemapCommand } from './basemap-command';
+import { getViewModeCommand } from './view-mode-command';
+import { getMapBoundaryCommand } from './boundary-command';
+import { getAddLayerCommand } from './layer-creation-command';
+import { getUpdateLayerColorCommand } from './layer-style-command';
+import { getLoadDataCommand } from './load-data-command';
+import { getSaveDataCommand } from './save-data-command';
+import { getTableCommand } from './table-command';
+import { getAddColumnCommand } from './add-column-command';
+import { getAddTimeFilterCommand } from './time-filter-command';
+import { getToggleTimeFilterCommand } from './toggle-time-filter-command';
+import { getSplitViewCommand } from './split-view-command';
+import { getDatasetContextCommand } from './dataset-context-command';
+
+/**
+ * Owner string under which all kepler-ai commands are registered in the
+ * room-store command registry. Used by `registerCommandsForOwner` /
+ * `unregisterCommandsForOwner` in the host's store wiring.
+ */
+export var KEPLER_COMMAND_OWNER = 'kepler-ai';
+
+/**
+ * Build the kepler-gl map-mutation commands for a given `KeplerContext`.
+ * Returns a map keyed by command id (e.g. `map.set-basemap`) so the registry
+ * registration is a flat merge.
+ */
+export function getKeplerCommands(ctx) {
+  var commands = [getBasemapCommand(ctx), getViewModeCommand(ctx), getMapBoundaryCommand(ctx), getAddLayerCommand(ctx), getUpdateLayerColorCommand(ctx), getLoadDataCommand(ctx), getSaveDataCommand(ctx), getTableCommand(ctx), getAddColumnCommand(ctx), getAddTimeFilterCommand(ctx), getToggleTimeFilterCommand(ctx), getSplitViewCommand(ctx), getDatasetContextCommand(ctx)];
+  return Object.fromEntries(commands.map(function (c) {
+    return [c.id, c];
+  }));
+}
+export { getBasemapCommand } from './basemap-command';
+export { getViewModeCommand } from './view-mode-command';
+export { getMapBoundaryCommand } from './boundary-command';
+export { getAddLayerCommand, guessDefaultLayer } from './layer-creation-command';
+export { getUpdateLayerColorCommand } from './layer-style-command';
+export { getLoadDataCommand } from './load-data-command';
+export { getSaveDataCommand } from './save-data-command';
+export { getTableCommand } from './table-command';
+export { getAddColumnCommand } from './add-column-command';
+export { getAddTimeFilterCommand } from './time-filter-command';
+export { getToggleTimeFilterCommand } from './toggle-time-filter-command';
+export { getSplitViewCommand } from './split-view-command';
+export { getDatasetContextCommand } from './dataset-context-command';
+export { toolToCommand, asInputSchema } from './command-wrappers';
+export { datasetNameToTableName, convertArrowRowToObject, arrowTableToObjects, tableToLLMResult, formatResultsForLLM, NUMBER_OF_ROWS_RETURN_TO_LLM, LLM_PREVIEW_MAX_TOTAL_LENGTH, LLM_PREVIEW_MAX_VALUE_LENGTH, getValuesFromDataset, getValuesFromVectorTileLayer, isObjectColumn, isVectorTileLayer, stringifyObjectColumn, restoreObjectColumns, buildAddColumnPayload } from './utils';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["getBasemapCommand","getViewModeCommand","getMapBoundaryCommand","getAddLayerCommand","getUpdateLayerColorCommand","getLoadDataCommand","getSaveDataCommand","getTableCommand","getAddColumnCommand","getAddTimeFilterCommand","getToggleTimeFilterCommand","getSplitViewCommand","getDatasetContextCommand","KEPLER_COMMAND_OWNER","getKeplerCommands","ctx","commands","Object","fromEntries","map","c","id","guessDefaultLayer","toolToCommand","asInputSchema","datasetNameToTableName","convertArrowRowToObject","arrowTableToObjects","tableToLLMResult","formatResultsForLLM","NUMBER_OF_ROWS_RETURN_TO_LLM","LLM_PREVIEW_MAX_TOTAL_LENGTH","LLM_PREVIEW_MAX_VALUE_LENGTH","getValuesFromDataset","getValuesFromVectorTileLayer","isObjectColumn","isVectorTileLayer","stringifyObjectColumn","restoreObjectColumns","buildAddColumnPayload"],"sources":["../../../src/commands/index.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport type {RoomCommand} from './types';\nimport type {KeplerContext} from './types';\nimport {getBasemapCommand} from './basemap-command';\nimport {getViewModeCommand} from './view-mode-command';\nimport {getMapBoundaryCommand} from './boundary-command';\nimport {getAddLayerCommand} from './layer-creation-command';\nimport {getUpdateLayerColorCommand} from './layer-style-command';\nimport {getLoadDataCommand} from './load-data-command';\nimport {getSaveDataCommand} from './save-data-command';\nimport {getTableCommand} from './table-command';\nimport {getAddColumnCommand} from './add-column-command';\nimport {getAddTimeFilterCommand} from './time-filter-command';\nimport {getToggleTimeFilterCommand} from './toggle-time-filter-command';\nimport {getSplitViewCommand} from './split-view-command';\nimport {getDatasetContextCommand} from './dataset-context-command';\n\n/**\n * Owner string under which all kepler-ai commands are registered in the\n * room-store command registry. Used by `registerCommandsForOwner` /\n * `unregisterCommandsForOwner` in the host's store wiring.\n */\nexport const KEPLER_COMMAND_OWNER = 'kepler-ai';\n\n/**\n * Build the kepler-gl map-mutation commands for a given `KeplerContext`.\n * Returns a map keyed by command id (e.g. `map.set-basemap`) so the registry\n * registration is a flat merge.\n */\nexport function getKeplerCommands(ctx: KeplerContext): Record<string, RoomCommand> {\n  const commands = [\n    getBasemapCommand(ctx),\n    getViewModeCommand(ctx),\n    getMapBoundaryCommand(ctx),\n    getAddLayerCommand(ctx),\n    getUpdateLayerColorCommand(ctx),\n    getLoadDataCommand(ctx),\n    getSaveDataCommand(ctx),\n    getTableCommand(ctx),\n    getAddColumnCommand(ctx),\n    getAddTimeFilterCommand(ctx),\n    getToggleTimeFilterCommand(ctx),\n    getSplitViewCommand(ctx),\n    getDatasetContextCommand(ctx)\n  ];\n  return Object.fromEntries(commands.map(c => [c.id, c]));\n}\n\nexport {getBasemapCommand} from './basemap-command';\nexport {getViewModeCommand} from './view-mode-command';\nexport {getMapBoundaryCommand} from './boundary-command';\nexport {getAddLayerCommand, guessDefaultLayer} from './layer-creation-command';\nexport {getUpdateLayerColorCommand} from './layer-style-command';\nexport {getLoadDataCommand} from './load-data-command';\nexport {getSaveDataCommand} from './save-data-command';\nexport {getTableCommand} from './table-command';\nexport {getAddColumnCommand} from './add-column-command';\nexport {getAddTimeFilterCommand} from './time-filter-command';\nexport {getToggleTimeFilterCommand} from './toggle-time-filter-command';\nexport {getSplitViewCommand} from './split-view-command';\nexport {getDatasetContextCommand} from './dataset-context-command';\nexport {toolToCommand, asInputSchema} from './command-wrappers';\nexport type {AnyTool, CommandMeta} from './command-wrappers';\nexport type {\n  KeplerContext,\n  KeplerStateAccessors,\n  VisState,\n  RoomCommandResult,\n  RoomCommandExecuteOutput,\n  ToolDescriptor\n} from './types';\nexport {\n  datasetNameToTableName,\n  convertArrowRowToObject,\n  arrowTableToObjects,\n  tableToLLMResult,\n  formatResultsForLLM,\n  NUMBER_OF_ROWS_RETURN_TO_LLM,\n  LLM_PREVIEW_MAX_TOTAL_LENGTH,\n  LLM_PREVIEW_MAX_VALUE_LENGTH,\n  getValuesFromDataset,\n  getValuesFromVectorTileLayer,\n  isObjectColumn,\n  isVectorTileLayer,\n  stringifyObjectColumn,\n  restoreObjectColumns,\n  buildAddColumnPayload\n} from './utils';\n"],"mappings":"AAAA;AACA;;AAIA,SAAQA,iBAAiB,QAAO,mBAAmB;AACnD,SAAQC,kBAAkB,QAAO,qBAAqB;AACtD,SAAQC,qBAAqB,QAAO,oBAAoB;AACxD,SAAQC,kBAAkB,QAAO,0BAA0B;AAC3D,SAAQC,0BAA0B,QAAO,uBAAuB;AAChE,SAAQC,kBAAkB,QAAO,qBAAqB;AACtD,SAAQC,kBAAkB,QAAO,qBAAqB;AACtD,SAAQC,eAAe,QAAO,iBAAiB;AAC/C,SAAQC,mBAAmB,QAAO,sBAAsB;AACxD,SAAQC,uBAAuB,QAAO,uBAAuB;AAC7D,SAAQC,0BAA0B,QAAO,8BAA8B;AACvE,SAAQC,mBAAmB,QAAO,sBAAsB;AACxD,SAAQC,wBAAwB,QAAO,2BAA2B;;AAElE;AACA;AACA;AACA;AACA;AACA,OAAO,IAAMC,oBAAoB,GAAG,WAAW;;AAE/C;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,iBAAiBA,CAACC,GAAkB,EAA+B;EACjF,IAAMC,QAAQ,GAAG,CACfhB,iBAAiB,CAACe,GAAG,CAAC,EACtBd,kBAAkB,CAACc,GAAG,CAAC,EACvBb,qBAAqB,CAACa,GAAG,CAAC,EAC1BZ,kBAAkB,CAACY,GAAG,CAAC,EACvBX,0BAA0B,CAACW,GAAG,CAAC,EAC/BV,kBAAkB,CAACU,GAAG,CAAC,EACvBT,kBAAkB,CAACS,GAAG,CAAC,EACvBR,eAAe,CAACQ,GAAG,CAAC,EACpBP,mBAAmB,CAACO,GAAG,CAAC,EACxBN,uBAAuB,CAACM,GAAG,CAAC,EAC5BL,0BAA0B,CAACK,GAAG,CAAC,EAC/BJ,mBAAmB,CAACI,GAAG,CAAC,EACxBH,wBAAwB,CAACG,GAAG,CAAC,CAC9B;EACD,OAAOE,MAAM,CAACC,WAAW,CAACF,QAAQ,CAACG,GAAG,CAAC,UAAAC,CAAC;IAAA,OAAI,CAACA,CAAC,CAACC,EAAE,EAAED,CAAC,CAAC;EAAA,EAAC,CAAC;AACzD;AAEA,SAAQpB,iBAAiB,QAAO,mBAAmB;AACnD,SAAQC,kBAAkB,QAAO,qBAAqB;AACtD,SAAQC,qBAAqB,QAAO,oBAAoB;AACxD,SAAQC,kBAAkB,EAAEmB,iBAAiB,QAAO,0BAA0B;AAC9E,SAAQlB,0BAA0B,QAAO,uBAAuB;AAChE,SAAQC,kBAAkB,QAAO,qBAAqB;AACtD,SAAQC,kBAAkB,QAAO,qBAAqB;AACtD,SAAQC,eAAe,QAAO,iBAAiB;AAC/C,SAAQC,mBAAmB,QAAO,sBAAsB;AACxD,SAAQC,uBAAuB,QAAO,uBAAuB;AAC7D,SAAQC,0BAA0B,QAAO,8BAA8B;AACvE,SAAQC,mBAAmB,QAAO,sBAAsB;AACxD,SAAQC,wBAAwB,QAAO,2BAA2B;AAClE,SAAQW,aAAa,EAAEC,aAAa,QAAO,oBAAoB;AAU/D,SACEC,sBAAsB,EACtBC,uBAAuB,EACvBC,mBAAmB,EACnBC,gBAAgB,EAChBC,mBAAmB,EACnBC,4BAA4B,EAC5BC,4BAA4B,EAC5BC,4BAA4B,EAC5BC,oBAAoB,EACpBC,4BAA4B,EAC5BC,cAAc,EACdC,iBAAiB,EACjBC,qBAAqB,EACrBC,oBAAoB,EACpBC,qBAAqB,QAChB,SAAS","ignoreList":[]}