@kepler.gl/duckdb 3.3.0-alpha.1 → 3.3.0-alpha.10

package/dist/esm/adapters/duckdb-wasm-adapter.js

@@ -0,0 +1,251 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import * as duckdb from '@duckdb/duckdb-wasm';
+import { AsyncDuckDB } from '@duckdb/duckdb-wasm';
+import { logElapsedTime } from '../utils/perf';
+var Connection = /*#__PURE__*/function () {
+  function Connection(connection) {
+    _classCallCheck(this, Connection);
+    _defineProperty(this, "connection", void 0);
+    this.connection = connection;
+  }
+  return _createClass(Connection, [{
+    key: "query",
+    value: function () {
+      var _query = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(statement) {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", this.connection.query(statement));
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function query(_x) {
+        return _query.apply(this, arguments);
+      }
+      return query;
+    }()
+  }, {
+    key: "insertArrowTable",
+    value: function () {
+      var _insertArrowTable = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(arrowTable, params) {
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return this.connection.insertArrowTable(arrowTable, params);
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function insertArrowTable(_x2, _x3) {
+        return _insertArrowTable.apply(this, arguments);
+      }
+      return insertArrowTable;
+    }()
+  }, {
+    key: "close",
+    value: function () {
+      var _close = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return this.connection.close();
+            case 2:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function close() {
+        return _close.apply(this, arguments);
+      }
+      return close;
+    }()
+  }]);
+}();
+export var DuckDBWasmAdapter = /*#__PURE__*/function () {
+  function DuckDBWasmAdapter(options) {
+    _classCallCheck(this, DuckDBWasmAdapter);
+    _defineProperty(this, "duckDB", void 0);
+    // pass existing AsyncDuckDB object created elsewhere
+    if (options instanceof Promise || options instanceof AsyncDuckDB) {
+      this.duckDB = options;
+      return;
+    }
+
+    // or create a new AsyncDuckDB object
+    var _ref = options || {},
+      _ref$debug = _ref.debug,
+      debug = _ref$debug === void 0 ? false : _ref$debug,
+      config = _ref.config;
+    this.duckDB = initializeDuckDbWasm(config, debug);
+  }
+  return _createClass(DuckDBWasmAdapter, [{
+    key: "connect",
+    value: function () {
+      var _connect = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+        var db, c;
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return this.duckDB;
+            case 2:
+              db = _context4.sent;
+              _context4.next = 5;
+              return db.connect();
+            case 5:
+              c = _context4.sent;
+              return _context4.abrupt("return", new Connection(c));
+            case 7:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function connect() {
+        return _connect.apply(this, arguments);
+      }
+      return connect;
+    }()
+  }, {
+    key: "registerFileText",
+    value: function () {
+      var _registerFileText = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5(filename, content) {
+        var db;
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 2;
+              return this.duckDB;
+            case 2:
+              db = _context5.sent;
+              _context5.next = 5;
+              return db.registerFileText(filename, content);
+            case 5:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function registerFileText(_x4, _x5) {
+        return _registerFileText.apply(this, arguments);
+      }
+      return registerFileText;
+    }()
+  }, {
+    key: "registerFileHandle",
+    value: function () {
+      var _registerFileHandle = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6(name, handle, protocol, directIO) {
+        var db;
+        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              _context6.next = 2;
+              return this.duckDB;
+            case 2:
+              db = _context6.sent;
+              _context6.next = 5;
+              return db.registerFileHandle(name, handle, protocol, directIO);
+            case 5:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function registerFileHandle(_x6, _x7, _x8, _x9) {
+        return _registerFileHandle.apply(this, arguments);
+      }
+      return registerFileHandle;
+    }()
+  }]);
+}();
+
+/**
+ * Initialize DuckDB with a browser-specific Wasm bundle.
+ */
+var initializeDuckDbWasm = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7(config, debug) {
+    var start, JSDELIVR_BUNDLES, bundle, worker_url, worker, logger, db, res, buffer, fileNameMatch;
+    return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          start = performance.now(); // Select a bundle based on browser checks
+          JSDELIVR_BUNDLES = duckdb.getJsDelivrBundles();
+          _context7.next = 4;
+          return duckdb.selectBundle(JSDELIVR_BUNDLES);
+        case 4:
+          bundle = _context7.sent;
+          if (bundle.mainWorker) {
+            _context7.next = 7;
+            break;
+          }
+          throw new Error('Failed to initialize DuckDB');
+        case 7:
+          worker_url = URL.createObjectURL(new Blob(["importScripts(\"".concat(bundle.mainWorker, "\");")], {
+            type: 'text/javascript'
+          })); // Instantiate the async version of DuckDB-wasm
+          worker = new Worker(worker_url);
+          logger = debug ? new duckdb.ConsoleLogger() : new duckdb.VoidLogger();
+          db = new AsyncDuckDB(logger, worker);
+          _context7.next = 13;
+          return db.instantiate(bundle.mainModule, bundle.pthreadWorker);
+        case 13:
+          URL.revokeObjectURL(worker_url);
+          if (!config) {
+            _context7.next = 28;
+            break;
+          }
+          if (!config.path) {
+            _context7.next = 26;
+            break;
+          }
+          _context7.next = 18;
+          return fetch(config.path);
+        case 18:
+          res = _context7.sent;
+          _context7.next = 21;
+          return res.arrayBuffer();
+        case 21:
+          buffer = _context7.sent;
+          fileNameMatch = config.path.match(/[^/]*$/);
+          if (fileNameMatch) {
+            config.path = fileNameMatch[0];
+          }
+          _context7.next = 26;
+          return db.registerFileBuffer(config.path, new Uint8Array(buffer));
+        case 26:
+          _context7.next = 28;
+          return db.open(config);
+        case 28:
+          if (debug) {
+            logElapsedTime('DuckDB initialized', start);
+            if (config) {
+              console.debug("DuckDbConfig: ".concat(JSON.stringify(config, null, 2)));
+            }
+          }
+          return _context7.abrupt("return", db);
+        case 30:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7);
+  }));
+  return function initializeDuckDbWasm(_x0, _x1) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["duckdb","AsyncDuckDB","logElapsedTime","Connection","connection","_classCallCheck","_defineProperty","_createClass","key","value","_query","_asyncToGenerator","_regeneratorRuntime","mark","_callee","statement","wrap","_callee$","_context","prev","next","abrupt","query","stop","_x","apply","arguments","_insertArrowTable","_callee2","arrowTable","params","_callee2$","_context2","insertArrowTable","_x2","_x3","_close","_callee3","_callee3$","_context3","close","DuckDBWasmAdapter","options","Promise","duckDB","_ref","_ref$debug","debug","config","initializeDuckDbWasm","_connect","_callee4","db","c","_callee4$","_context4","sent","connect","_registerFileText","_callee5","filename","content","_callee5$","_context5","registerFileText","_x4","_x5","_registerFileHandle","_callee6","name","handle","protocol","directIO","_callee6$","_context6","registerFileHandle","_x6","_x7","_x8","_x9","_ref2","_callee7","start","JSDELIVR_BUNDLES","bundle","worker_url","worker","logger","res","buffer","fileNameMatch","_callee7$","_context7","performance","now","getJsDelivrBundles","selectBundle","mainWorker","Error","URL","createObjectURL","Blob","concat","type","Worker","ConsoleLogger","VoidLogger","instantiate","mainModule","pthreadWorker","revokeObjectURL","path","fetch","arrayBuffer","match","registerFileBuffer","Uint8Array","open","console","JSON","stringify","_x0","_x1"],"sources":["../../../src/adapters/duckdb-wasm-adapter.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport * as arrow from 'apache-arrow';\nimport * as duckdb from '@duckdb/duckdb-wasm';\nimport {AsyncDuckDB, DuckDBConfig, AsyncDuckDBConnection} from '@duckdb/duckdb-wasm';\n\nimport {DatabaseAdapter, DatabaseConnection} from '@kepler.gl/utils';\n\nimport {logElapsedTime} from '../utils/perf';\n\nclass Connection implements DatabaseConnection {\n  private connection: AsyncDuckDBConnection;\n\n  constructor(connection: AsyncDuckDBConnection) {\n    this.connection = connection;\n  }\n\n  async query(statement: string): Promise<arrow.Table> {\n    return this.connection.query(statement);\n  }\n\n  async insertArrowTable(arrowTable: arrow.Table, params: {name: string}): Promise<void> {\n    await this.connection.insertArrowTable(arrowTable, params);\n  }\n\n  async close() {\n    await this.connection.close();\n  }\n}\n\ntype DuckDBWasmAdapterProps =\n  | {\n      debug?: boolean;\n      config?: DuckDBConfig;\n    }\n  | Promise<AsyncDuckDB>;\n\nexport class DuckDBWasmAdapter implements DatabaseAdapter {\n  private duckDB: Promise<AsyncDuckDB>;\n\n  constructor(options: DuckDBWasmAdapterProps) {\n    // pass existing AsyncDuckDB object created elsewhere\n    if (options instanceof Promise || options instanceof AsyncDuckDB) {\n      this.duckDB = options as any;\n      return;\n    }\n\n    // or create a new AsyncDuckDB object\n    const {debug = false, config} = options || {};\n    this.duckDB = initializeDuckDbWasm(config, debug);\n  }\n\n  async connect() {\n    const db = await this.duckDB;\n    const c = await db.connect();\n    return new Connection(c);\n  }\n\n  async registerFileText(filename: string, content) {\n    const db = await this.duckDB;\n    await db.registerFileText(filename, content);\n  }\n\n  async registerFileHandle(\n    name: string,\n    handle: any,\n    protocol: duckdb.DuckDBDataProtocol,\n    directIO: boolean\n  ): Promise<void> {\n    const db = await this.duckDB;\n    await db.registerFileHandle(name, handle, protocol, directIO);\n  }\n}\n\n/**\n * Initialize DuckDB with a browser-specific Wasm bundle.\n */\nconst initializeDuckDbWasm = async (\n  config?: DuckDBConfig,\n  debug?: boolean\n): Promise<AsyncDuckDB> => {\n  const start = performance.now();\n\n  // Select a bundle based on browser checks\n  const JSDELIVR_BUNDLES = duckdb.getJsDelivrBundles();\n  const bundle = await duckdb.selectBundle(JSDELIVR_BUNDLES);\n  if (!bundle.mainWorker) {\n    throw new Error('Failed to initialize DuckDB');\n  }\n\n  const worker_url = URL.createObjectURL(\n    new Blob([`importScripts(\"${bundle.mainWorker}\");`], {\n      type: 'text/javascript'\n    })\n  );\n\n  // Instantiate the async version of DuckDB-wasm\n  const worker = new Worker(worker_url);\n  const logger = debug ? new duckdb.ConsoleLogger() : new duckdb.VoidLogger();\n  const db = new AsyncDuckDB(logger, worker);\n  await db.instantiate(bundle.mainModule, bundle.pthreadWorker);\n  URL.revokeObjectURL(worker_url);\n\n  if (config) {\n    if (config.path) {\n      const res = await fetch(config.path);\n      const buffer = await res.arrayBuffer();\n      const fileNameMatch = config.path.match(/[^/]*$/);\n      if (fileNameMatch) {\n        config.path = fileNameMatch[0];\n      }\n      await db.registerFileBuffer(config.path, new Uint8Array(buffer));\n    }\n    await db.open(config);\n  }\n\n  if (debug) {\n    logElapsedTime('DuckDB initialized', start);\n    if (config) {\n      console.debug(`DuckDbConfig: ${JSON.stringify(config, null, 2)}`);\n    }\n  }\n  return db;\n};\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/components/index.js

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+export { SqlPanel } from './sql-panel';
+export { SchemaPanel, SchemaPanelDropMessage } from './schema-panel';
+export { PreviewDataPanel } from './preview-data-panel';
+export { Tree, DatasetNode, ColumnNode } from './tree';
+export { default as MonacoEditor } from './monaco-editor';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJTcWxQYW5lbCIsIlNjaGVtYVBhbmVsIiwiU2NoZW1hUGFuZWxEcm9wTWVzc2FnZSIsIlByZXZpZXdEYXRhUGFuZWwiLCJUcmVlIiwiRGF0YXNldE5vZGUiLCJDb2x1bW5Ob2RlIiwiZGVmYXVsdCIsIk1vbmFjb0VkaXRvciJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21wb25lbnRzL2luZGV4LnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUXG4vLyBDb3B5cmlnaHQgY29udHJpYnV0b3JzIHRvIHRoZSBrZXBsZXIuZ2wgcHJvamVjdFxuXG5leHBvcnQge1NxbFBhbmVsfSBmcm9tICcuL3NxbC1wYW5lbCc7XG5leHBvcnQge1NjaGVtYVBhbmVsLCBTY2hlbWFQYW5lbERyb3BNZXNzYWdlfSBmcm9tICcuL3NjaGVtYS1wYW5lbCc7XG5leHBvcnQge1ByZXZpZXdEYXRhUGFuZWx9IGZyb20gJy4vcHJldmlldy1kYXRhLXBhbmVsJztcbmV4cG9ydCB7VHJlZSwgRGF0YXNldE5vZGUsIENvbHVtbk5vZGV9IGZyb20gJy4vdHJlZSc7XG5leHBvcnQge2RlZmF1bHQgYXMgTW9uYWNvRWRpdG9yfSBmcm9tICcuL21vbmFjby1lZGl0b3InO1xuXG5leHBvcnQgdHlwZSB7U2NoZW1hU3VnZ2VzdGlvbn0gZnJvbSAnLi9zY2hlbWEtcGFuZWwnO1xuZXhwb3J0IHR5cGUge1ByZXZpZXdEYXRhUGFuZWxQcm9wcywgUXVlcnlSZXN1bHQsIERhdGFUYWJsZVN0eWxlfSBmcm9tICcuL3ByZXZpZXctZGF0YS1wYW5lbCc7XG5leHBvcnQgdHlwZSB7VHJlZU5vZGVEYXRhLCBUcmVlTm9kZVByb3BzLCBUcmVlUHJvcHN9IGZyb20gJy4vdHJlZSc7XG4iXSwibWFwcGluZ3MiOiJBQUFBO0FBQ0E7O0FBRUEsU0FBUUEsUUFBUSxRQUFPLGFBQWE7QUFDcEMsU0FBUUMsV0FBVyxFQUFFQyxzQkFBc0IsUUFBTyxnQkFBZ0I7QUFDbEUsU0FBUUMsZ0JBQWdCLFFBQU8sc0JBQXNCO0FBQ3JELFNBQVFDLElBQUksRUFBRUMsV0FBVyxFQUFFQyxVQUFVLFFBQU8sUUFBUTtBQUNwRCxTQUFRQyxPQUFPLElBQUlDLFlBQVksUUFBTyxpQkFBaUIiLCJpZ25vcmVMaXN0IjpbXX0=

package/dist/esm/components/monaco-editor.js

@@ -0,0 +1,167 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useMemo, useRef } from 'react';
+import Editor from '@monaco-editor/react';
+import * as monaco from 'monaco-editor';
+// import {tableSchema as DEFAULT_SCHEMA} from './table-schema';
+import uniq from 'es-toolkit/compat/uniq';
+import uniqBy from 'es-toolkit/compat/uniqBy';
+var MONACO_OPTIONS = {
+  minimap: {
+    enabled: false
+  },
+  language: 'sql',
+  contextmenu: false,
+  renderLineHighlight: 'none',
+  scrollBeyondLastLine: false,
+  scrollbar: {
+    alwaysConsumeMouseWheel: false
+  },
+  overviewRulerLanes: 0,
+  automaticLayout: true,
+  acceptSuggestionOnEnter: 'on',
+  quickSuggestionsDelay: 400,
+  matchOnWordStartOnly: false,
+  tabCompletion: 'off',
+  lineNumbers: 'off'
+};
+function parseSqlAndFindTableNameAndAliases(sql) {
+  var regex = /\b(?:FROM|JOIN)\s+([^\s.]+(?:\.[^\s.]+)?)\s*(?:AS)?\s*([^\s,]+)?/gi;
+  var tables = [];
+  while (true) {
+    var match = regex.exec(sql);
+    if (!match) {
+      break;
+    }
+    var table_name = match[1];
+    if (!/\(/.test(table_name)) {
+      // exclude function calls
+      var alias = match[2];
+      if (alias && /on|where|inner|left|right|join/.test(alias)) {
+        alias = null;
+      }
+      tables.push({
+        table_name: table_name,
+        alias: alias || table_name
+      });
+    }
+  }
+  return tables;
+}
+var MonacoEditor = function MonacoEditor(_ref) {
+  var onRunQuery = _ref.onRunQuery,
+    onChange = _ref.onChange,
+    code = _ref.code,
+    tableSchema = _ref.tableSchema,
+    isReadOnly = _ref.isReadOnly;
+  // private editor?: monaco.editor.IStandaloneCodeEditor;
+  var schemaTableNames = useMemo(function () {
+    return tableSchema ? uniq(tableSchema.map(function (d) {
+      return d.table_name;
+    })) : [];
+  }, [tableSchema]);
+  var schemaTableNamesSet = useMemo(function () {
+    return new Set(schemaTableNames);
+  }, [schemaTableNames]);
+  var handleRunQueryRef = useRef(onRunQuery);
+  handleRunQueryRef.current = onRunQuery;
+  var handleEditorDidMount = useCallback(function (editor) {
+    // this.editor = editor;
+    editor.focus();
+    editor.addAction({
+      id: 'run-query',
+      label: 'Run Query',
+      keybindings: [monaco.KeyMod.CtrlCmd | monaco.KeyCode.Enter, monaco.KeyMod.Shift | monaco.KeyCode.Enter],
+      contextMenuGroupId: 'custom',
+      contextMenuOrder: 0,
+      run: function run() {
+        return handleRunQueryRef.current();
+      }
+    });
+    monaco.languages.registerCompletionItemProvider('*', {
+      provideCompletionItems: function provideCompletionItems(model, position, _context, _cancelationToken) {
+        var _thisLine$trim$split$, _exec, _exec2;
+        var suggestions = [{
+          label: 'myCustomSnippet',
+          kind: monaco.languages.CompletionItemKind.Snippet,
+          insertText: 'This is a piece of custom code',
+          insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+          documentation: 'This is a piece of custom code'
+          // TODO: range is missing
+        }];
+        var fullQueryText = model.getValue();
+        var tableNamesAndAliases = new Map(parseSqlAndFindTableNameAndAliases(fullQueryText).map(function (_ref2) {
+          var table_name = _ref2.table_name,
+            alias = _ref2.alias;
+          return [alias, table_name];
+        }));
+        var thisLine = model.getValueInRange({
+          startLineNumber: position.lineNumber,
+          startColumn: 1,
+          endLineNumber: position.lineNumber,
+          endColumn: position.column
+        });
+        var thisToken = ((_thisLine$trim$split$ = thisLine.trim().split(' ').slice(-1)) === null || _thisLine$trim$split$ === void 0 ? void 0 : _thisLine$trim$split$[0]) || '';
+        var lastTokenBeforeSpace = (_exec = /\s?(\w+)\s+\w+$/.exec(thisLine.trim())) === null || _exec === void 0 ? void 0 : _exec[1];
+        var lastTokenBeforeDot = (_exec2 = /(\w+)\.\w*$/.exec(thisToken)) === null || _exec2 === void 0 ? void 0 : _exec2[1];
+
+        // console.log(tableNamesAndAliases, thisToken, lastTokenBeforeSpace, lastTokenBeforeDot);
+
+        if (lastTokenBeforeSpace && /from|join|update|into/.test(lastTokenBeforeSpace)) {
+          suggestions.push.apply(suggestions, _toConsumableArray(schemaTableNames.map(function (table_name) {
+            return {
+              label: table_name,
+              kind: monaco.languages.CompletionItemKind.Field,
+              insertText: table_name
+              // TODO: range is missing
+            };
+          })));
+        }
+        if (lastTokenBeforeDot) {
+          var table_name = null;
+          if (schemaTableNamesSet.has(lastTokenBeforeDot)) {
+            table_name = lastTokenBeforeDot;
+          } else if (tableNamesAndAliases.get(lastTokenBeforeDot)) {
+            table_name = tableNamesAndAliases.get(lastTokenBeforeDot);
+          }
+          if (table_name && tableSchema) {
+            suggestions.push.apply(suggestions, _toConsumableArray(tableSchema.filter(function (d) {
+              return d.table_name === table_name;
+            }).map(function (_ref3) {
+              var column_name = _ref3.column_name;
+              return {
+                label: column_name,
+                kind: monaco.languages.CompletionItemKind.Field,
+                insertText: column_name
+                // TODO: range is missing
+              };
+            })));
+          }
+        }
+        return {
+          suggestions: uniqBy(suggestions, function (s) {
+            return s.insertText;
+          })
+        };
+      }
+    });
+  }, [tableSchema, schemaTableNames, schemaTableNamesSet]);
+  return /*#__PURE__*/React.createElement(Editor, {
+    height: "100%",
+    theme: "vs-dark",
+    defaultLanguage: "sql",
+    defaultValue: code,
+    onChange: onChange,
+    onMount: handleEditorDidMount,
+    options: _objectSpread(_objectSpread({}, MONACO_OPTIONS), {}, {
+      readOnly: isReadOnly
+    })
+  });
+};
+export default MonacoEditor;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useMemo","useRef","Editor","monaco","uniq","uniqBy","MONACO_OPTIONS","minimap","enabled","language","contextmenu","renderLineHighlight","scrollBeyondLastLine","scrollbar","alwaysConsumeMouseWheel","overviewRulerLanes","automaticLayout","acceptSuggestionOnEnter","quickSuggestionsDelay","matchOnWordStartOnly","tabCompletion","lineNumbers","parseSqlAndFindTableNameAndAliases","sql","regex","tables","match","exec","table_name","test","alias","push","MonacoEditor","_ref","onRunQuery","onChange","code","tableSchema","isReadOnly","schemaTableNames","map","d","schemaTableNamesSet","Set","handleRunQueryRef","current","handleEditorDidMount","editor","focus","addAction","id","label","keybindings","KeyMod","CtrlCmd","KeyCode","Enter","Shift","contextMenuGroupId","contextMenuOrder","run","languages","registerCompletionItemProvider","provideCompletionItems","model","position","_context","_cancelationToken","_thisLine$trim$split$","_exec","_exec2","suggestions","kind","CompletionItemKind","Snippet","insertText","insertTextRules","CompletionItemInsertTextRule","InsertAsSnippet","documentation","fullQueryText","getValue","tableNamesAndAliases","Map","_ref2","thisLine","getValueInRange","startLineNumber","lineNumber","startColumn","endLineNumber","endColumn","column","thisToken","trim","split","slice","lastTokenBeforeSpace","lastTokenBeforeDot","apply","_toConsumableArray","Field","has","get","filter","_ref3","column_name","s","createElement","height","theme","defaultLanguage","defaultValue","onMount","options","_objectSpread","readOnly"],"sources":["../../../src/components/monaco-editor.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useMemo, useRef} from 'react';\nimport Editor, {OnChange, OnMount} from '@monaco-editor/react';\nimport * as monaco from 'monaco-editor';\n// import {tableSchema as DEFAULT_SCHEMA} from './table-schema';\nimport uniq from 'es-toolkit/compat/uniq';\nimport uniqBy from 'es-toolkit/compat/uniqBy';\n\nconst MONACO_OPTIONS: monaco.editor.IStandaloneEditorConstructionOptions = {\n  minimap: {enabled: false},\n  language: 'sql',\n  contextmenu: false,\n  renderLineHighlight: 'none',\n  scrollBeyondLastLine: false,\n  scrollbar: {alwaysConsumeMouseWheel: false},\n  overviewRulerLanes: 0,\n  automaticLayout: true,\n  acceptSuggestionOnEnter: 'on',\n  quickSuggestionsDelay: 400,\n  matchOnWordStartOnly: false,\n  tabCompletion: 'off',\n  lineNumbers: 'off'\n};\n\nfunction parseSqlAndFindTableNameAndAliases(sql: string) {\n  const regex = /\\b(?:FROM|JOIN)\\s+([^\\s.]+(?:\\.[^\\s.]+)?)\\s*(?:AS)?\\s*([^\\s,]+)?/gi;\n  const tables: {table_name: string; alias: string}[] = [];\n\n  while (true) {\n    const match = regex.exec(sql);\n    if (!match) {\n      break;\n    }\n    const table_name = match[1];\n    if (!/\\(/.test(table_name)) {\n      // exclude function calls\n      let alias = match[2] as string | null;\n      if (alias && /on|where|inner|left|right|join/.test(alias)) {\n        alias = null;\n      }\n      tables.push({\n        table_name,\n        alias: alias || table_name\n      });\n    }\n  }\n\n  return tables;\n}\n\ninterface MonacoEditorProps {\n  code: string;\n  isReadOnly?: boolean;\n  onChange: OnChange;\n  onRunQuery: () => void;\n  tableSchema?: {table_name: string; column_name: string}[];\n}\n\nconst MonacoEditor: React.FC<MonacoEditorProps> = ({\n  onRunQuery,\n  onChange,\n  code,\n  tableSchema,\n  isReadOnly\n}) => {\n  // private editor?: monaco.editor.IStandaloneCodeEditor;\n  const schemaTableNames = useMemo(\n    () => (tableSchema ? uniq(tableSchema.map(d => d.table_name)) : []),\n    [tableSchema]\n  );\n  const schemaTableNamesSet = useMemo(() => new Set(schemaTableNames), [schemaTableNames]);\n  const handleRunQueryRef = useRef(onRunQuery);\n  handleRunQueryRef.current = onRunQuery;\n\n  const handleEditorDidMount: OnMount = useCallback(\n    editor => {\n      // this.editor = editor;\n      editor.focus();\n\n      editor.addAction({\n        id: 'run-query',\n        label: 'Run Query',\n        keybindings: [\n          monaco.KeyMod.CtrlCmd | monaco.KeyCode.Enter,\n          monaco.KeyMod.Shift | monaco.KeyCode.Enter\n        ],\n        contextMenuGroupId: 'custom',\n        contextMenuOrder: 0,\n        run: () => handleRunQueryRef.current()\n      });\n\n      monaco.languages.registerCompletionItemProvider('*', {\n        provideCompletionItems: (model, position, _context, _cancelationToken) => {\n          const suggestions: monaco.languages.CompletionItem[] = [\n            {\n              label: 'myCustomSnippet',\n              kind: monaco.languages.CompletionItemKind.Snippet,\n              insertText: 'This is a piece of custom code',\n              insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,\n              documentation: 'This is a piece of custom code'\n              // TODO: range is missing\n            } as monaco.languages.CompletionItem\n          ];\n\n          const fullQueryText = model.getValue();\n\n          const tableNamesAndAliases = new Map<string, string>(\n            parseSqlAndFindTableNameAndAliases(fullQueryText).map(({table_name, alias}) => [\n              alias,\n              table_name\n            ])\n          );\n\n          const thisLine = model.getValueInRange({\n            startLineNumber: position.lineNumber,\n            startColumn: 1,\n            endLineNumber: position.lineNumber,\n            endColumn: position.column\n          });\n          const thisToken = thisLine.trim().split(' ').slice(-1)?.[0] || '';\n\n          const lastTokenBeforeSpace = /\\s?(\\w+)\\s+\\w+$/.exec(thisLine.trim())?.[1];\n          const lastTokenBeforeDot = /(\\w+)\\.\\w*$/.exec(thisToken)?.[1];\n\n          // console.log(tableNamesAndAliases, thisToken, lastTokenBeforeSpace, lastTokenBeforeDot);\n\n          if (lastTokenBeforeSpace && /from|join|update|into/.test(lastTokenBeforeSpace)) {\n            suggestions.push(\n              ...schemaTableNames.map(\n                table_name =>\n                  ({\n                    label: table_name,\n                    kind: monaco.languages.CompletionItemKind.Field,\n                    insertText: table_name\n                    // TODO: range is missing\n                  } as monaco.languages.CompletionItem)\n              )\n            );\n          }\n\n          if (lastTokenBeforeDot) {\n            let table_name = null as string | null;\n            if (schemaTableNamesSet.has(lastTokenBeforeDot)) {\n              table_name = lastTokenBeforeDot;\n            } else if (tableNamesAndAliases.get(lastTokenBeforeDot)) {\n              table_name = tableNamesAndAliases.get(lastTokenBeforeDot) as string;\n            }\n            if (table_name && tableSchema) {\n              suggestions.push(\n                ...tableSchema\n                  .filter(d => d.table_name === table_name)\n                  .map(\n                    ({column_name}) =>\n                      ({\n                        label: column_name,\n                        kind: monaco.languages.CompletionItemKind.Field,\n                        insertText: column_name\n                        // TODO: range is missing\n                      } as monaco.languages.CompletionItem)\n                  )\n              );\n            }\n          }\n\n          return {\n            suggestions: uniqBy(suggestions, s => s.insertText)\n          };\n        }\n      });\n    },\n    [tableSchema, schemaTableNames, schemaTableNamesSet]\n  );\n\n  return (\n    <Editor\n      height=\"100%\"\n      theme=\"vs-dark\"\n      defaultLanguage=\"sql\"\n      defaultValue={code}\n      onChange={onChange}\n      onMount={handleEditorDidMount}\n      options={{\n        ...MONACO_OPTIONS,\n        readOnly: isReadOnly\n      }}\n    />\n  );\n};\n\nexport default MonacoEditor;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/components/preview-data-panel.js

@@ -0,0 +1,120 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useMemo, useState } from 'react';
+import { withTheme } from 'styled-components';
+import { DataTable, renderedSize } from '@kepler.gl/components';
+import { arrowSchemaToFields } from '@kepler.gl/processors';
+import { parseFieldValue, createDataContainer, DataForm } from '@kepler.gl/utils';
+var DEFAULT_ROWS_TO_CALCULATE_PREVIEW = 100;
+// min Cellsize should take into account option button and field token
+var minCellSize = 80;
+// option buttons and field token
+var optionButtonWidth = 20;
+var pinButton = 20;
+var cellPadding = 20;
+var PreviewDataPanelWOTheme = function PreviewDataPanelWOTheme(_ref) {
+  var result = _ref.result,
+    _ref$rowsToCalculateP = _ref.rowsToCalculatePreview,
+    rowsToCalculatePreview = _ref$rowsToCalculateP === void 0 ? DEFAULT_ROWS_TO_CALCULATE_PREVIEW : _ref$rowsToCalculateP,
+    _ref$defaultPinnedCol = _ref.defaultPinnedColumns,
+    defaultPinnedColumns = _ref$defaultPinnedCol === void 0 ? [] : _ref$defaultPinnedCol,
+    theme = _ref.theme;
+  var _useState = useState(defaultPinnedColumns),
+    _useState2 = _slicedToArray(_useState, 2),
+    pinnedColumns = _useState2[0],
+    setPinnedColumns = _useState2[1];
+  var fields = useMemo(function () {
+    return arrowSchemaToFields(result.table, result.tableDuckDBTypes);
+  }, [result]);
+  var dataContainer = useMemo(function () {
+    var cols = _toConsumableArray(Array(result.table.numCols).keys()).map(function (i) {
+      return result.table.getChildAt(i);
+    });
+    var dataContainer = createDataContainer(cols, {
+      fields: fields,
+      inputDataFormat: DataForm.COLS_ARRAY
+    });
+    return dataContainer;
+  }, [result, fields]);
+  var columns = useMemo(function () {
+    return fields.map(function (f) {
+      return f.name;
+    });
+  }, [fields]);
+  var colMeta = useMemo(function () {
+    return fields.reduce(function (acc, _ref2, colIdx) {
+      var name = _ref2.name,
+        displayName = _ref2.displayName,
+        type = _ref2.type,
+        displayFormat = _ref2.displayFormat;
+      return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, name, {
+        // because '' || 'aaa' = 'aaa'
+        name: displayName !== undefined ? displayName : name,
+        displayName: displayName,
+        displayFormat: displayFormat,
+        type: type,
+        colIdx: colIdx
+      }));
+    }, {});
+  }, [fields]);
+  var copyTableColumn = useCallback(function (column) {
+    var _navigator;
+    var _colMeta$column = colMeta[column],
+      colIdx = _colMeta$column.colIdx,
+      type = _colMeta$column.type;
+    var text = dataContainer.mapIndex(function (row) {
+      return parseFieldValue(dataContainer.valueAt(row.index, colIdx), type);
+    }).join('\n');
+    (_navigator = navigator) === null || _navigator === void 0 || _navigator.clipboard.writeText(text);
+  }, [colMeta, dataContainer]);
+  var pinTableColumn = useCallback(function (column) {
+    return pinnedColumns.includes(column) ? setPinnedColumns(pinnedColumns.filter(function (c) {
+      return c !== column;
+    })) : setPinnedColumns([].concat(_toConsumableArray(pinnedColumns), [column]));
+  }, [pinnedColumns]);
+
+  // TODO Potentially costly operation for non row based data containers. Revisit sorting below.
+  var dataTableStyle = useMemo(function () {
+    return {
+      minCellSize: minCellSize,
+      cellPadding: cellPadding,
+      optionsButton: theme.fieldTokenWidth + theme.fieldTokenRightMargin + optionButtonWidth + pinButton,
+      fontSize: theme.cellFontSize,
+      font: theme.fontFamily
+    };
+  }, [theme]);
+  var cellSizeCache = useMemo(function () {
+    return columns.reduce(function (acc, column) {
+      var _colMeta$column2 = colMeta[column],
+        colIdx = _colMeta$column2.colIdx,
+        displayName = _colMeta$column2.displayName,
+        type = _colMeta$column2.type;
+      return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, column, renderedSize(_objectSpread({
+        text: {
+          dataContainer: dataContainer,
+          column: displayName
+        },
+        colIdx: colIdx,
+        type: type,
+        numRowsToCalculate: rowsToCalculatePreview
+      }, dataTableStyle))));
+    }, {});
+  }, [columns, colMeta, dataContainer, rowsToCalculatePreview, dataTableStyle]);
+  return /*#__PURE__*/React.createElement(DataTable, {
+    colMeta: colMeta,
+    columns: columns,
+    cellSizeCache: cellSizeCache,
+    dataContainer: dataContainer,
+    pinnedColumns: pinnedColumns,
+    copyTableColumn: copyTableColumn,
+    pinTableColumn: pinTableColumn
+  });
+};
+export var PreviewDataPanel = withTheme(PreviewDataPanelWOTheme);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useMemo","useState","withTheme","DataTable","renderedSize","arrowSchemaToFields","parseFieldValue","createDataContainer","DataForm","DEFAULT_ROWS_TO_CALCULATE_PREVIEW","minCellSize","optionButtonWidth","pinButton","cellPadding","PreviewDataPanelWOTheme","_ref","result","_ref$rowsToCalculateP","rowsToCalculatePreview","_ref$defaultPinnedCol","defaultPinnedColumns","theme","_useState","_useState2","_slicedToArray","pinnedColumns","setPinnedColumns","fields","table","tableDuckDBTypes","dataContainer","cols","_toConsumableArray","Array","numCols","keys","map","i","getChildAt","inputDataFormat","COLS_ARRAY","columns","f","name","colMeta","reduce","acc","_ref2","colIdx","displayName","type","displayFormat","_objectSpread","_defineProperty","undefined","copyTableColumn","column","_navigator","_colMeta$column","text","mapIndex","row","valueAt","index","join","navigator","clipboard","writeText","pinTableColumn","includes","filter","c","concat","dataTableStyle","optionsButton","fieldTokenWidth","fieldTokenRightMargin","fontSize","cellFontSize","font","fontFamily","cellSizeCache","_colMeta$column2","numRowsToCalculate","createElement","PreviewDataPanel"],"sources":["../../../src/components/preview-data-panel.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport * as arrow from 'apache-arrow';\nimport React, {useCallback, useMemo, useState, CSSProperties} from 'react';\nimport {withTheme} from 'styled-components';\n\nimport {DataTable, renderedSize} from '@kepler.gl/components';\nimport {arrowSchemaToFields} from '@kepler.gl/processors';\nimport {parseFieldValue, createDataContainer, DataForm} from '@kepler.gl/utils';\n\ntype BaseComponentProps = {\n  className?: string;\n  style?: CSSProperties;\n};\n\nconst DEFAULT_ROWS_TO_CALCULATE_PREVIEW = 100;\n// min Cellsize should take into account option button and field token\nconst minCellSize = 80;\n// option buttons and field token\nconst optionButtonWidth = 20;\nconst pinButton = 20;\nconst cellPadding = 20;\n\nexport type ColMeta = {\n  [key: string]: {\n    colIdx: number;\n    name: string;\n    displayName: string;\n    type: string;\n  };\n};\n\nexport type DataTableStyle = {\n  minCellSize?: number;\n  cellPadding?: number;\n  fontSize?: number;\n  font?: string;\n  optionsButton?: number;\n};\n\nexport type QueryResult = {\n  table: arrow.Table;\n  tableDuckDBTypes: Record<string, string>;\n};\n\nexport type PreviewDataPanelProps = BaseComponentProps & {\n  result: QueryResult;\n  rowsToCalculatePreview?: number;\n  theme?: any;\n  setColumnDisplayFormat?: (formats: {[key: string]: string}) => void;\n  defaultPinnedColumns?: string[];\n  dataTableStyle: DataTableStyle;\n  onAddResultToMap: (result: QueryResult) => void;\n};\n\nconst PreviewDataPanelWOTheme: React.FC<PreviewDataPanelProps> = ({\n  result,\n  rowsToCalculatePreview = DEFAULT_ROWS_TO_CALCULATE_PREVIEW,\n  defaultPinnedColumns = [],\n  theme\n}) => {\n  const [pinnedColumns, setPinnedColumns] = useState<string[]>(defaultPinnedColumns);\n  const fields = useMemo(\n    () => arrowSchemaToFields(result.table, result.tableDuckDBTypes),\n    [result]\n  );\n  const dataContainer = useMemo(() => {\n    const cols = [...Array(result.table.numCols).keys()].map(i => result.table.getChildAt(i));\n\n    const dataContainer = createDataContainer(cols, {\n      fields,\n      inputDataFormat: DataForm.COLS_ARRAY\n    });\n    return dataContainer;\n  }, [result, fields]);\n\n  const columns = useMemo(() => fields.map(f => f.name), [fields]);\n  const colMeta = useMemo(\n    () =>\n      fields.reduce(\n        (acc, {name, displayName, type, displayFormat}, colIdx) => ({\n          ...acc,\n          [name]: {\n            // because '' || 'aaa' = 'aaa'\n            name: displayName !== undefined ? displayName : name,\n            displayName,\n            displayFormat,\n            type,\n            colIdx\n          }\n        }),\n        {}\n      ),\n    [fields]\n  );\n  const copyTableColumn = useCallback(\n    column => {\n      const {colIdx, type} = colMeta[column];\n      const text = dataContainer\n        .mapIndex(row => parseFieldValue(dataContainer.valueAt(row.index, colIdx), type))\n        .join('\\n');\n      navigator?.clipboard.writeText(text);\n    },\n    [colMeta, dataContainer]\n  );\n  const pinTableColumn = useCallback(\n    column =>\n      pinnedColumns.includes(column)\n        ? setPinnedColumns(pinnedColumns.filter(c => c !== column))\n        : setPinnedColumns([...pinnedColumns, column]),\n    [pinnedColumns]\n  );\n\n  // TODO Potentially costly operation for non row based data containers. Revisit sorting below.\n  const dataTableStyle = useMemo(\n    () => ({\n      minCellSize,\n      cellPadding,\n      optionsButton:\n        theme.fieldTokenWidth + theme.fieldTokenRightMargin + optionButtonWidth + pinButton,\n      fontSize: theme.cellFontSize,\n      font: theme.fontFamily\n    }),\n    [theme]\n  );\n  const cellSizeCache = useMemo(() => {\n    return columns.reduce((acc, column) => {\n      const {colIdx, displayName, type} = colMeta[column];\n      return {\n        ...acc,\n        [column]: renderedSize({\n          text: {\n            dataContainer,\n            column: displayName\n          },\n          colIdx,\n          type,\n          numRowsToCalculate: rowsToCalculatePreview,\n          ...dataTableStyle\n        })\n      };\n    }, {});\n  }, [columns, colMeta, dataContainer, rowsToCalculatePreview, dataTableStyle]);\n\n  return (\n    <DataTable\n      colMeta={colMeta}\n      columns={columns}\n      cellSizeCache={cellSizeCache}\n      dataContainer={dataContainer}\n      pinnedColumns={pinnedColumns}\n      copyTableColumn={copyTableColumn}\n      pinTableColumn={pinTableColumn}\n    />\n  );\n};\n\nexport const PreviewDataPanel = withTheme(\n  PreviewDataPanelWOTheme\n) as React.FC<PreviewDataPanelProps>;\n"],"mappings":";;;;;AAAA;AACA;;AAGA,OAAOA,KAAK,IAAGC,WAAW,EAAEC,OAAO,EAAEC,QAAQ,QAAsB,OAAO;AAC1E,SAAQC,SAAS,QAAO,mBAAmB;AAE3C,SAAQC,SAAS,EAAEC,YAAY,QAAO,uBAAuB;AAC7D,SAAQC,mBAAmB,QAAO,uBAAuB;AACzD,SAAQC,eAAe,EAAEC,mBAAmB,EAAEC,QAAQ,QAAO,kBAAkB;AAO/E,IAAMC,iCAAiC,GAAG,GAAG;AAC7C;AACA,IAAMC,WAAW,GAAG,EAAE;AACtB;AACA,IAAMC,iBAAiB,GAAG,EAAE;AAC5B,IAAMC,SAAS,GAAG,EAAE;AACpB,IAAMC,WAAW,GAAG,EAAE;AAkCtB,IAAMC,uBAAwD,GAAG,SAA3DA,uBAAwDA,CAAAC,IAAA,EAKxD;EAAA,IAJJC,MAAM,GAAAD,IAAA,CAANC,MAAM;IAAAC,qBAAA,GAAAF,IAAA,CACNG,sBAAsB;IAAtBA,sBAAsB,GAAAD,qBAAA,cAAGR,iCAAiC,GAAAQ,qBAAA;IAAAE,qBAAA,GAAAJ,IAAA,CAC1DK,oBAAoB;IAApBA,oBAAoB,GAAAD,qBAAA,cAAG,EAAE,GAAAA,qBAAA;IACzBE,KAAK,GAAAN,IAAA,CAALM,KAAK;EAEL,IAAAC,SAAA,GAA0CrB,QAAQ,CAAWmB,oBAAoB,CAAC;IAAAG,UAAA,GAAAC,cAAA,CAAAF,SAAA;IAA3EG,aAAa,GAAAF,UAAA;IAAEG,gBAAgB,GAAAH,UAAA;EACtC,IAAMI,MAAM,GAAG3B,OAAO,CACpB;IAAA,OAAMK,mBAAmB,CAACW,MAAM,CAACY,KAAK,EAAEZ,MAAM,CAACa,gBAAgB,CAAC;EAAA,GAChE,CAACb,MAAM,CACT,CAAC;EACD,IAAMc,aAAa,GAAG9B,OAAO,CAAC,YAAM;IAClC,IAAM+B,IAAI,GAAGC,kBAAA,CAAIC,KAAK,CAACjB,MAAM,CAACY,KAAK,CAACM,OAAO,CAAC,CAACC,IAAI,CAAC,CAAC,EAAEC,GAAG,CAAC,UAAAC,CAAC;MAAA,OAAIrB,MAAM,CAACY,KAAK,CAACU,UAAU,CAACD,CAAC,CAAC;IAAA,EAAC;IAEzF,IAAMP,aAAa,GAAGvB,mBAAmB,CAACwB,IAAI,EAAE;MAC9CJ,MAAM,EAANA,MAAM;MACNY,eAAe,EAAE/B,QAAQ,CAACgC;IAC5B,CAAC,CAAC;IACF,OAAOV,aAAa;EACtB,CAAC,EAAE,CAACd,MAAM,EAAEW,MAAM,CAAC,CAAC;EAEpB,IAAMc,OAAO,GAAGzC,OAAO,CAAC;IAAA,OAAM2B,MAAM,CAACS,GAAG,CAAC,UAAAM,CAAC;MAAA,OAAIA,CAAC,CAACC,IAAI;IAAA,EAAC;EAAA,GAAE,CAAChB,MAAM,CAAC,CAAC;EAChE,IAAMiB,OAAO,GAAG5C,OAAO,CACrB;IAAA,OACE2B,MAAM,CAACkB,MAAM,CACX,UAACC,GAAG,EAAAC,KAAA,EAA4CC,MAAM;MAAA,IAA/CL,IAAI,GAAAI,KAAA,CAAJJ,IAAI;QAAEM,WAAW,GAAAF,KAAA,CAAXE,WAAW;QAAEC,IAAI,GAAAH,KAAA,CAAJG,IAAI;QAAEC,aAAa,GAAAJ,KAAA,CAAbI,aAAa;MAAA,OAAAC,aAAA,CAAAA,aAAA,KACxCN,GAAG,OAAAO,eAAA,KACLV,IAAI,EAAG;QACN;QACAA,IAAI,EAAEM,WAAW,KAAKK,SAAS,GAAGL,WAAW,GAAGN,IAAI;QACpDM,WAAW,EAAXA,WAAW;QACXE,aAAa,EAAbA,aAAa;QACbD,IAAI,EAAJA,IAAI;QACJF,MAAM,EAANA;MACF,CAAC;IAAA,CACD,EACF,CAAC,CACH,CAAC;EAAA,GACH,CAACrB,MAAM,CACT,CAAC;EACD,IAAM4B,eAAe,GAAGxD,WAAW,CACjC,UAAAyD,MAAM,EAAI;IAAA,IAAAC,UAAA;IACR,IAAAC,eAAA,GAAuBd,OAAO,CAACY,MAAM,CAAC;MAA/BR,MAAM,GAAAU,eAAA,CAANV,MAAM;MAAEE,IAAI,GAAAQ,eAAA,CAAJR,IAAI;IACnB,IAAMS,IAAI,GAAG7B,aAAa,CACvB8B,QAAQ,CAAC,UAAAC,GAAG;MAAA,OAAIvD,eAAe,CAACwB,aAAa,CAACgC,OAAO,CAACD,GAAG,CAACE,KAAK,EAAEf,MAAM,CAAC,EAAEE,IAAI,CAAC;IAAA,EAAC,CAChFc,IAAI,CAAC,IAAI,CAAC;IACb,CAAAP,UAAA,GAAAQ,SAAS,cAAAR,UAAA,eAATA,UAAA,CAAWS,SAAS,CAACC,SAAS,CAACR,IAAI,CAAC;EACtC,CAAC,EACD,CAACf,OAAO,EAAEd,aAAa,CACzB,CAAC;EACD,IAAMsC,cAAc,GAAGrE,WAAW,CAChC,UAAAyD,MAAM;IAAA,OACJ/B,aAAa,CAAC4C,QAAQ,CAACb,MAAM,CAAC,GAC1B9B,gBAAgB,CAACD,aAAa,CAAC6C,MAAM,CAAC,UAAAC,CAAC;MAAA,OAAIA,CAAC,KAAKf,MAAM;IAAA,EAAC,CAAC,GACzD9B,gBAAgB,IAAA8C,MAAA,CAAAxC,kBAAA,CAAKP,aAAa,IAAE+B,MAAM,EAAC,CAAC;EAAA,GAClD,CAAC/B,aAAa,CAChB,CAAC;;EAED;EACA,IAAMgD,cAAc,GAAGzE,OAAO,CAC5B;IAAA,OAAO;MACLU,WAAW,EAAXA,WAAW;MACXG,WAAW,EAAXA,WAAW;MACX6D,aAAa,EACXrD,KAAK,CAACsD,eAAe,GAAGtD,KAAK,CAACuD,qBAAqB,GAAGjE,iBAAiB,GAAGC,SAAS;MACrFiE,QAAQ,EAAExD,KAAK,CAACyD,YAAY;MAC5BC,IAAI,EAAE1D,KAAK,CAAC2D;IACd,CAAC;EAAA,CAAC,EACF,CAAC3D,KAAK,CACR,CAAC;EACD,IAAM4D,aAAa,GAAGjF,OAAO,CAAC,YAAM;IAClC,OAAOyC,OAAO,CAACI,MAAM,CAAC,UAACC,GAAG,EAAEU,MAAM,EAAK;MACrC,IAAA0B,gBAAA,GAAoCtC,OAAO,CAACY,MAAM,CAAC;QAA5CR,MAAM,GAAAkC,gBAAA,CAANlC,MAAM;QAAEC,WAAW,GAAAiC,gBAAA,CAAXjC,WAAW;QAAEC,IAAI,GAAAgC,gBAAA,CAAJhC,IAAI;MAChC,OAAAE,aAAA,CAAAA,aAAA,KACKN,GAAG,OAAAO,eAAA,KACLG,MAAM,EAAGpD,YAAY,CAAAgD,aAAA;QACpBO,IAAI,EAAE;UACJ7B,aAAa,EAAbA,aAAa;UACb0B,MAAM,EAAEP;QACV,CAAC;QACDD,MAAM,EAANA,MAAM;QACNE,IAAI,EAAJA,IAAI;QACJiC,kBAAkB,EAAEjE;MAAsB,GACvCuD,cAAc,CAClB,CAAC;IAEN,CAAC,EAAE,CAAC,CAAC,CAAC;EACR,CAAC,EAAE,CAAChC,OAAO,EAAEG,OAAO,EAAEd,aAAa,EAAEZ,sBAAsB,EAAEuD,cAAc,CAAC,CAAC;EAE7E,oBACE3E,KAAA,CAAAsF,aAAA,CAACjF,SAAS;IACRyC,OAAO,EAAEA,OAAQ;IACjBH,OAAO,EAAEA,OAAQ;IACjBwC,aAAa,EAAEA,aAAc;IAC7BnD,aAAa,EAAEA,aAAc;IAC7BL,aAAa,EAAEA,aAAc;IAC7B8B,eAAe,EAAEA,eAAgB;IACjCa,cAAc,EAAEA;EAAe,CAChC,CAAC;AAEN,CAAC;AAED,OAAO,IAAMiB,gBAAgB,GAAGnF,SAAS,CACvCY,uBACF,CAAoC","ignoreList":[]}