@vuu-ui/vuu-filters 0.7.6 → 0.8.0-debug

package/cjs/index.js

@@ -1,34 +1,4882 @@
-"use strict";var Qo=Object.create;var oe=Object.defineProperty;var Ao=Object.getOwnPropertyDescriptor;var ko=Object.getOwnPropertyNames;var Mo=Object.getPrototypeOf,Lo=Object.prototype.hasOwnProperty;var Uo=(e,o)=>()=>(o||e((o={exports:{}}).exports,o),o.exports),Wo=(e,o)=>{for(var r in o)oe(e,r,{get:o[r],enumerable:!0})},De=(e,o,r,t)=>{if(o&&typeof o=="object"||typeof o=="function")for(let n of ko(o))!Lo.call(e,n)&&n!==r&&oe(e,n,{get:()=>o[n],enumerable:!(t=Ao(o,n))||t.enumerable});return e};var Ve=(e,o,r)=>(r=e!=null?Qo(Mo(e)):{},De(o||!e||!e.__esModule?oe(r,"default",{value:e,enumerable:!0}):r,e)),Ho=e=>De(oe({},"__esModule",{value:!0}),e);var Qe=(e,o,r)=>{if(!o.has(e))throw TypeError("Cannot "+r)};var R=(e,o,r)=>(Qe(e,o,"read from private field"),r?r.call(e):o.get(e)),Ae=(e,o,r)=>{if(o.has(e))throw TypeError("Cannot add the same private member more than once");o instanceof WeakSet?o.add(e):o.set(e,r)},Ie=(e,o,r,t)=>(Qe(e,o,"write to private field"),t?t.call(e,r):o.set(e,r),r);var Te=Uo((yt,le)=>{(function(){"use strict";var e={}.hasOwnProperty,o="[native code]";function r(){for(var t=[],n=0;n<arguments.length;n++){var i=arguments[n];if(i){var s=typeof i;if(s==="string"||s==="number")t.push(i);else if(Array.isArray(i)){if(i.length){var p=r.apply(null,i);p&&t.push(p)}}else if(s==="object"){if(i.toString!==Object.prototype.toString&&!i.toString.toString().includes("[native code]")){t.push(i.toString());continue}for(var f in i)e.call(i,f)&&i[f]&&t.push(f)}}}return t.join(" ")}typeof le<"u"&&le.exports?(r.default=r,le.exports=r):typeof define=="function"&&typeof define.amd=="object"&&define.amd?define("classnames",[],function(){return r}):window.classNames=r})()});var $r={};Wo($r,{AND:()=>h,ColumnFilter:()=>ar,ENDS_WITH:()=>Yo,EQUALS:()=>te,FilterInput:()=>Ir,FilterToolbar:()=>Nr,GREATER_THAN:()=>jo,IN:()=>$e,LESS_THAN:()=>Zo,OR:()=>Be,STARTS_WITH:()=>Oe,addFilter:()=>G,filterAsQuery:()=>H,filterClauses:()=>ze,filterEquals:()=>ne,filterIncludesColumn:()=>_e,filterPredicate:()=>ge,getFilterPredicate:()=>Vr,isAndFilter:()=>re,isFilterClause:()=>Go,isInFilter:()=>W,isMultiClauseFilter:()=>V,isMultiValueFilter:()=>D,isNamedFilter:()=>he,isOrFilter:()=>Ce,isSingleValueFilter:()=>k,overrideColName:()=>Xe,parseFilter:()=>Y,removeColumnFromFilter:()=>tr,removeFilter:()=>nr,splitFilterOnColumn:()=>ir,updateFilter:()=>je,useCodeMirrorEditor:()=>Ee,useFilterSuggestionProvider:()=>Rr});module.exports=Ho($r);var P=require("@heswell/salt-lab"),no=require("@salt-ds/core");var Se=require("react/jsx-runtime"),Ue=require("react");function ke(e){var o,r,t="";if(typeof e=="string"||typeof e=="number")t+=e;else if(typeof e=="object")if(Array.isArray(e))for(o=0;o<e.length;o++)e[o]&&(r=ke(e[o]))&&(t&&(t+=" "),t+=r);else for(o in e)e[o]&&(t&&(t+=" "),t+=o);return t}function Me(){for(var e,o,r=0,t="";r<arguments.length;)(e=arguments[r++])&&(o=ke(e))&&(t&&(t+=" "),t+=o);return t}function Le(e,o){o===void 0&&(o={});var r=o.insertAt;if(!(!e||typeof document>"u")){var t=document.head||document.getElementsByTagName("head")[0],n=document.createElement("style");n.type="text/css",r==="top"&&t.firstChild?t.insertBefore(n,t.firstChild):t.appendChild(n),n.styleSheet?n.styleSheet.cssText=e:n.appendChild(document.createTextNode(e))}}var Bo=`/* Style applied to the root element */
-.saltIcon {
-  --icon-color: var(--saltIcon-color, var(--salt-text-secondary-foreground));
-  --icon-size-multiplier: var(--saltIcon-size-multiplier, 1);
-  --icon-base-size: var(--salt-size-icon-base, 12px);
-  /**
-   * Icon size will be the multiplier (an integer from the size prop) * the base size (set by the theme per density)
-   * Icons should never be smaller than 12px for readability so we've added a max() to enforce this
-  */
-  --icon-size: max(calc(var(--icon-base-size) * var(--icon-size-multiplier)), 12px);
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+
+// ../../node_modules/classnames/index.js
+var require_classnames = __commonJS({
+  "../../node_modules/classnames/index.js"(exports, module2) {
+    (function() {
+      "use strict";
+      var hasOwn = {}.hasOwnProperty;
+      var nativeCodeString = "[native code]";
+      function classNames() {
+        var classes = [];
+        for (var i = 0; i < arguments.length; i++) {
+          var arg = arguments[i];
+          if (!arg)
+            continue;
+          var argType = typeof arg;
+          if (argType === "string" || argType === "number") {
+            classes.push(arg);
+          } else if (Array.isArray(arg)) {
+            if (arg.length) {
+              var inner = classNames.apply(null, arg);
+              if (inner) {
+                classes.push(inner);
+              }
+            }
+          } else if (argType === "object") {
+            if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes("[native code]")) {
+              classes.push(arg.toString());
+              continue;
+            }
+            for (var key in arg) {
+              if (hasOwn.call(arg, key) && arg[key]) {
+                classes.push(key);
+              }
+            }
+          }
+        }
+        return classes.join(" ");
+      }
+      if (typeof module2 !== "undefined" && module2.exports) {
+        classNames.default = classNames;
+        module2.exports = classNames;
+      } else if (typeof define === "function" && typeof define.amd === "object" && define.amd) {
+        define("classnames", [], function() {
+          return classNames;
+        });
+      } else {
+        window.classNames = classNames;
+      }
+    })();
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AND: () => AND,
+  ColumnFilter: () => ColumnFilter,
+  ENDS_WITH: () => ENDS_WITH,
+  EQUALS: () => EQUALS,
+  FilterInput: () => FilterInput,
+  FilterToolbar: () => FilterToolbar,
+  GREATER_THAN: () => GREATER_THAN,
+  IN: () => IN,
+  LESS_THAN: () => LESS_THAN,
+  OR: () => OR,
+  STARTS_WITH: () => STARTS_WITH,
+  addFilter: () => addFilter,
+  filterClauses: () => filterClauses,
+  filterEquals: () => filterEquals,
+  filterIncludesColumn: () => filterIncludesColumn,
+  overrideColName: () => overrideColName,
+  removeFilter: () => removeFilter,
+  splitFilterOnColumn: () => splitFilterOnColumn,
+  updateFilter: () => updateFilter,
+  useCodeMirrorEditor: () => useCodeMirrorEditor,
+  useFilterSuggestionProvider: () => useFilterSuggestionProvider
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/column-filter/ColumnFilter.tsx
+var import_salt_lab4 = require("@heswell/salt-lab");
+var import_core = require("@salt-ds/core");
+
+// ../../node_modules/@salt-ds/icons/dist-es/packages/icons/src/icon/Icon.js
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+
+// ../../node_modules/clsx/dist/clsx.m.js
+function r(e) {
+  var t, f, n = "";
+  if ("string" == typeof e || "number" == typeof e)
+    n += e;
+  else if ("object" == typeof e)
+    if (Array.isArray(e))
+      for (t = 0; t < e.length; t++)
+        e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+    else
+      for (t in e)
+        e[t] && (n && (n += " "), n += t);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = ""; f < arguments.length; )
+    (e = arguments[f++]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
 }
 
-.saltIcon {
-  fill: var(--saltIcon-color, var(--icon-color));
-  display: inline-block;
-  margin: var(--saltIcon-margin, 0);
-  position: relative;
-  width: var(--icon-size);
-  height: var(--icon-size);
-  min-width: var(--icon-size);
-  min-height: var(--icon-size);
+// ../../node_modules/@salt-ds/icons/dist-es/node_modules/style-inject/dist/style-inject.es.js
+function styleInject(css, ref) {
+  if (ref === void 0)
+    ref = {};
+  var insertAt = ref.insertAt;
+  if (!css || typeof document === "undefined") {
+    return;
+  }
+  var head = document.head || document.getElementsByTagName("head")[0];
+  var style = document.createElement("style");
+  style.type = "text/css";
+  if (insertAt === "top") {
+    if (head.firstChild) {
+      head.insertBefore(style, head.firstChild);
+    } else {
+      head.appendChild(style);
+    }
+  } else {
+    head.appendChild(style);
+  }
+  if (style.styleSheet) {
+    style.styleSheet.cssText = css;
+  } else {
+    style.appendChild(document.createTextNode(css));
+  }
 }
 
-.saltIcon:hover {
-  --icon-color: var(--saltIcon-color-hover, var(--salt-text-secondary-foreground));
+// ../../node_modules/@salt-ds/icons/dist-es/packages/icons/src/icon/Icon.css.js
+var css_248z = "/* Style applied to the root element */\n.saltIcon {\n  --icon-color: var(--saltIcon-color, var(--salt-text-secondary-foreground));\n  --icon-size-multiplier: var(--saltIcon-size-multiplier, 1);\n  --icon-base-size: var(--salt-size-icon-base, 12px);\n  /**\n   * Icon size will be the multiplier (an integer from the size prop) * the base size (set by the theme per density)\n   * Icons should never be smaller than 12px for readability so we've added a max() to enforce this\n  */\n  --icon-size: max(calc(var(--icon-base-size) * var(--icon-size-multiplier)), 12px);\n}\n\n.saltIcon {\n  fill: var(--saltIcon-color, var(--icon-color));\n  display: inline-block;\n  margin: var(--saltIcon-margin, 0);\n  position: relative;\n  width: var(--icon-size);\n  height: var(--icon-size);\n  min-width: var(--icon-size);\n  min-height: var(--icon-size);\n}\n\n.saltIcon:hover {\n  --icon-color: var(--saltIcon-color-hover, var(--salt-text-secondary-foreground));\n}\n\n.saltIcon:active {\n  --icon-color: var(--saltIcon-color-active, var(--salt-text-secondary-foreground));\n}\n";
+styleInject(css_248z);
+
+// ../../node_modules/@salt-ds/icons/dist-es/packages/icons/src/icon/Icon.js
+var makePrefixer = (prefix) => (...names) => [prefix, ...names].join("-");
+var withBaseName = makePrefixer("saltIcon");
+var DEFAULT_ICON_SIZE = 1;
+var Icon = (0, import_react.forwardRef)(function Icon2({ children, className, size = DEFAULT_ICON_SIZE, style: styleProp, ...rest }, ref) {
+  const style = {
+    ...styleProp,
+    "--saltIcon-size-multiplier": `${size}`
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("svg", {
+    className: clsx(withBaseName(), className),
+    style,
+    role: "img",
+    ...rest,
+    ref,
+    children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("g", {
+      "aria-hidden": true,
+      children
+    })
+  });
+});
+
+// ../../node_modules/@salt-ds/icons/dist-es/packages/icons/src/components/Delete.js
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var import_react2 = require("react");
+var DeleteIcon = (0, import_react2.forwardRef)(
+  function DeleteIcon2(props, ref) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Icon, {
+      "data-testid": "DeleteIcon",
+      "aria-label": "delete",
+      viewBox: "0 0 12 12",
+      ref,
+      ...props,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", {
+          d: "M5 4v6H4V4h1Zm2 0v6H6V4h1Z"
+        }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", {
+          fillRule: "evenodd",
+          d: "M4 0a1 1 0 0 0-1 1v1H0v1h1v7a2 2 0 0 0 2 2h5.25A1.75 1.75 0 0 0 10 10.25V3h1V2H8V1a1 1 0 0 0-1-1H4Zm5 3H2v7a1 1 0 0 0 1 1h5.25a.75.75 0 0 0 .75-.75V3ZM7 2H4v-.5a.5.5 0 0 1 .5-.5h2a.5.5 0 0 1 .5.5V2Z",
+          clipRule: "evenodd"
+        })
+      ]
+    });
+  }
+);
+
+// src/column-filter/RangeFilter.tsx
+var import_salt_lab = require("@heswell/salt-lab");
+
+// src/filter-utils.ts
+var import_vuu_utils = require("@vuu-ui/vuu-utils");
+var AND = "and";
+var EQUALS = "=";
+var GREATER_THAN = ">";
+var LESS_THAN = "<";
+var OR = "or";
+var STARTS_WITH = "starts";
+var ENDS_WITH = "ends";
+var IN = "in";
+var filterClauses = (filter, clauses = []) => {
+  if (filter) {
+    if ((0, import_vuu_utils.isMultiClauseFilter)(filter)) {
+      filter.filters.forEach((f) => clauses.push(...filterClauses(f)));
+    } else {
+      clauses.push(filter);
+    }
+  }
+  return clauses;
+};
+var DEFAULT_ADD_FILTER_OPTS = {
+  combineWith: "and"
+};
+var addFilter = (existingFilter, filter, { combineWith = AND } = DEFAULT_ADD_FILTER_OPTS) => {
+  var _a;
+  if (includesNoValues(filter)) {
+    if ((0, import_vuu_utils.isMultiClauseFilter)(filter)) {
+    } else {
+      existingFilter = removeFilterForColumn(existingFilter, {
+        name: filter.column
+      });
+    }
+  } else if (includesAllValues(filter)) {
+    if ((0, import_vuu_utils.isMultiClauseFilter)(filter)) {
+    }
+    return removeFilterForColumn(existingFilter, { name: (_a = filter.column) != null ? _a : "" });
+  }
+  if (!existingFilter) {
+    return filter;
+  }
+  if (!filter) {
+    return existingFilter;
+  }
+  if (existingFilter.op === AND && filter.op === AND) {
+    return {
+      op: AND,
+      filters: combine(existingFilter.filters, filter.filters)
+    };
+  }
+  if (existingFilter.op === AND) {
+    const filters = replaceOrInsert(existingFilter.filters, filter);
+    return filters.length > 1 ? { op: AND, filters } : filters[0];
+  }
+  if (filter.op === AND) {
+    return { op: AND, filters: filter.filters.concat(existingFilter) };
+  }
+  if (filterEquals(existingFilter, filter, true)) {
+    return filter;
+  }
+  if (canMerge(existingFilter, filter)) {
+    return merge(existingFilter, filter);
+  }
+  return { op: combineWith, filters: [existingFilter, filter] };
+};
+var includesNoValues = (filter) => {
+  if (!filter) {
+    return false;
+  }
+  if ((0, import_vuu_utils.isInFilter)(filter) && filter.values.length === 0) {
+    return true;
+  }
+  return (0, import_vuu_utils.isAndFilter)(filter) && filter.filters.some((f) => includesNoValues(f));
+};
+var includesAllValues = (filter) => {
+  if (!filter) {
+    return false;
+  }
+  if (filter.op === STARTS_WITH && filter.value === "") {
+    return true;
+  }
+  return filter.op === STARTS_WITH && filter.value === "";
+};
+var replaceOrInsert = (filters, filter) => {
+  return filters.concat(filter);
+};
+var merge = (f1, f2) => {
+  if (includesNoValues(f2)) {
+    return f2;
+  }
+  if ((0, import_vuu_utils.isInFilter)(f1) && (0, import_vuu_utils.isInFilter)(f2)) {
+    return {
+      ...f1,
+      values: [
+        ...f1.values,
+        ...f2.values.filter(
+          (v) => !f1.values.includes(v)
+        )
+      ]
+    };
+  } else if ((0, import_vuu_utils.isInFilter)(f1) && f2.op === EQUALS) {
+    return {
+      ...f1,
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      values: f1.values.concat([f2.value])
+    };
+  } else if (f1.op === EQUALS && f2.op === EQUALS) {
+    return {
+      column: f1.column,
+      op: IN,
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      values: [f1.value, f2.value]
+    };
+  }
+  return f2;
+};
+var combine = (existingFilters, replacementFilters) => {
+  const equivalentType = ({ op: t1 }, { op: t2 }) => {
+    return t1 === t2 || t1[0] === t2[0];
+  };
+  const replaces = (existingFilter, replacementFilter) => {
+    return existingFilter.column === replacementFilter.column && equivalentType(existingFilter, replacementFilter);
+  };
+  const stillApplicable = (existingFilter) => replacementFilters.some(
+    (replacementFilter) => replaces(existingFilter, replacementFilter)
+  ) === false;
+  return existingFilters.filter(stillApplicable).concat(replacementFilters);
+};
+var removeFilter = (sourceFilter, filterToRemove) => {
+  if (filterEquals(sourceFilter, filterToRemove, true)) {
+    return null;
+  }
+  if (sourceFilter.op !== AND) {
+    throw Error(
+      `removeFilter cannot remove ${JSON.stringify(
+        filterToRemove
+      )} from ${JSON.stringify(sourceFilter)}`
+    );
+  }
+  const filters = sourceFilter.filters.filter(
+    (f) => !filterEquals(f, filterToRemove)
+  );
+  return filters.length > 0 ? { type: AND, filters } : null;
+};
+var splitFilterOnColumn = (columnName, filter) => {
+  if (!filter) {
+    return [void 0, void 0];
+  }
+  if (filter.column === columnName) {
+    return [filter, void 0];
+  }
+  if (filter.op !== AND) {
+    return [void 0, filter];
+  }
+  const [[columnFilter = void 0], filters] = (0, import_vuu_utils.partition)(
+    filter.filters,
+    (f) => f.column === columnName
+  );
+  return filters.length === 1 ? [columnFilter, filters[0]] : [columnFilter, { op: AND, filters }];
+};
+var overrideColName = (filter, column) => {
+  if ((0, import_vuu_utils.isMultiClauseFilter)(filter)) {
+    return {
+      op: filter.op,
+      filters: filter.filters.map((f) => overrideColName(f, column))
+    };
+  }
+  return { ...filter, column };
+};
+var filterIncludesColumn = (filter, column) => {
+  if (!filter) {
+    return false;
+  }
+  const { op, column: filterColName } = filter;
+  switch (op) {
+    case AND:
+    case OR:
+      return filter.filters != null && filter.filters.some((f) => filterIncludesColumn(f, column));
+    default:
+      return filterColName === column.name;
+  }
+};
+var removeFilterForColumn = (sourceFilter, column) => {
+  const colName = column.name;
+  if (!sourceFilter) {
+    return void 0;
+  }
+  if (sourceFilter.column === colName) {
+    return void 0;
+  }
+  if ((0, import_vuu_utils.isAndFilter)(sourceFilter) || (0, import_vuu_utils.isOrFilter)(sourceFilter)) {
+    const { op } = sourceFilter;
+    const filters = sourceFilter.filters;
+    const otherColFilters = filters.filter((f) => f.column !== colName);
+    switch (otherColFilters.length) {
+      case 0:
+        return void 0;
+      case 1:
+        return otherColFilters[0];
+      default:
+        return { op, filters: otherColFilters };
+    }
+  }
+  return sourceFilter;
+};
+var canMerge = (f1, f2) => f1.column === f2.column && (f1.op === "=" || f1.op === "in") && (f2.op === "=" || f2.op === "in");
+var sameValues = (arr1, arr2) => {
+  if (arr1 === arr2) {
+    return true;
+  }
+  if (arr1.length === arr2.length) {
+    const a = arr1.slice().sort();
+    const b = arr2.slice().sort();
+    return a.join("|") === b.join("|");
+  }
+  return false;
+};
+var filterEquals = (f1, f2, strict = false) => {
+  if (!strict) {
+    return true;
+  }
+  if (f1 && f2 && canMerge(f1, f2)) {
+    return f1.op === f2.op && ((0, import_vuu_utils.isSingleValueFilter)(f1) && (0, import_vuu_utils.isSingleValueFilter)(f2) && f1.value === f2.value || (0, import_vuu_utils.isMultiValueFilter)(f1) && (0, import_vuu_utils.isMultiValueFilter)(f2) && sameValues(f1.values, f2.values));
+  }
+  return false;
+};
+var updateFilter = (filter, newFilter, mode) => {
+  if (filter && newFilter) {
+    if (mode === "replace") {
+      return newFilter;
+    }
+    if (filter.op === "and") {
+      return {
+        ...filter,
+        filters: filter.filters.concat(newFilter)
+      };
+    }
+    const { column: columnName } = newFilter;
+    if (columnName) {
+      const existingClause = newFilter.column ? (0, import_vuu_utils.extractFilterForColumn)(filter, columnName) : void 0;
+      if (existingClause && columnName) {
+        const result = removeFilterForColumn(filter, { name: columnName });
+        return updateFilter(result, newFilter, "add");
+      }
+    }
+    return {
+      op: "and",
+      filters: [filter, newFilter]
+    };
+  }
+  if (newFilter) {
+    return newFilter;
+  }
+  return filter;
+};
+
+// src/column-filter/utils.ts
+var isStartsWithValue = (value) => /\.\.\.$/.test(value);
+var getTypeaheadFilter = (column, filterValues, isStartsWithFilter) => {
+  if (filterValues.length === 0) {
+    return void 0;
+  }
+  if (isStartsWithFilter) {
+    const startsWith = filterValues[0].substring(0, filterValues[0].length - 3);
+    return {
+      column,
+      op: "starts",
+      value: `"${startsWith}"`
+    };
+  }
+  return {
+    column,
+    op: "in",
+    values: filterValues.map((value) => `"${value}"`)
+  };
+};
+var getRangeFilter = (column, startValue, endValue) => {
+  const startFilter = startValue === void 0 ? void 0 : { column, op: ">", value: startValue - 1 };
+  const endFilter = endValue === void 0 ? void 0 : { column, op: "<", value: endValue + 1 };
+  if (endFilter === void 0)
+    return startFilter;
+  return addFilter(startFilter, endFilter, { combineWith: "and" });
+};
+
+// src/column-filter/RangeFilter.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var RangeFilter = ({
+  defaultTypeaheadParams,
+  filterValues,
+  onChange
+}) => {
+  var _a, _b;
+  const columnName = defaultTypeaheadParams[1];
+  const startChangeHandler = (e) => {
+    const value = parseFloat(e.target.value);
+    const newRange = {
+      start: isNaN(value) ? void 0 : value,
+      end: filterValues == null ? void 0 : filterValues.end
+    };
+    const filter = getRangeFilter(columnName, newRange.start, newRange.end);
+    onChange(newRange, filter);
+  };
+  const endChangeHandler = (e) => {
+    const value = parseFloat(e.target.value);
+    const newRange = {
+      start: filterValues == null ? void 0 : filterValues.start,
+      end: isNaN(value) ? void 0 : value
+    };
+    const filter = getRangeFilter(columnName, newRange.start, newRange.end);
+    onChange(newRange, filter);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: { display: "flex", flexDirection: "row" }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_salt_lab.ToolbarField, { label: "From", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      import_salt_lab.Input,
+      {
+        onChange: startChangeHandler,
+        value: ((_a = filterValues == null ? void 0 : filterValues.start) == null ? void 0 : _a.toString()) || "",
+        type: "number"
+      }
+    ) }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_salt_lab.ToolbarField, { label: "To", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      import_salt_lab.Input,
+      {
+        onChange: endChangeHandler,
+        value: ((_b = filterValues == null ? void 0 : filterValues.end) == null ? void 0 : _b.toString()) || "",
+        type: "number"
+      }
+    ) })
+  ] });
+};
+
+// ../vuu-data-react/src/hooks/useDataSource.ts
+var import_vuu_utils2 = require("@vuu-ui/vuu-utils");
+var import_react3 = require("react");
+var { SELECTED } = import_vuu_utils2.metadataKeys;
+
+// ../vuu-data-react/src/hooks/useServerConnectionStatus.ts
+var import_react4 = require("react");
+var import_vuu_data = require("@vuu-ui/vuu-data");
+
+// ../vuu-data-react/src/hooks/useServerConnectionQuality.ts
+var import_react5 = require("react");
+var import_vuu_data2 = require("@vuu-ui/vuu-data");
+
+// ../vuu-data-react/src/hooks/useTypeaheadSuggestions.ts
+var import_react6 = require("react");
+var import_vuu_data3 = require("@vuu-ui/vuu-data");
+var TYPEAHEAD_MESSAGE_CONSTANTS = {
+  type: "RPC_CALL",
+  service: "TypeAheadRpcHandler"
+};
+var getTypeaheadParams = (table, column, text = "", selectedValues = []) => {
+  if (text !== "" && !selectedValues.includes(text.toLowerCase())) {
+    return [table, column, text];
+  }
+  return [table, column];
+};
+var useTypeaheadSuggestions = () => {
+  const getTypeaheadSuggestions = (0, import_react6.useCallback)(
+    async (params) => {
+      const rpcMessage = params.length === 2 ? {
+        method: "getUniqueFieldValues",
+        params,
+        ...TYPEAHEAD_MESSAGE_CONSTANTS
+      } : {
+        method: "getUniqueFieldValuesStartingWith",
+        params,
+        ...TYPEAHEAD_MESSAGE_CONSTANTS
+      };
+      const suggestions = await (0, import_vuu_data3.makeRpcCall)(rpcMessage);
+      return suggestions;
+    },
+    []
+  );
+  return getTypeaheadSuggestions;
+};
+
+// ../../node_modules/@lezer/common/dist/index.js
+var DefaultBufferLength = 1024;
+var nextPropID = 0;
+var Range = class {
+  constructor(from, to) {
+    this.from = from;
+    this.to = to;
+  }
+};
+var NodeProp = class {
+  /// Create a new node prop type.
+  constructor(config = {}) {
+    this.id = nextPropID++;
+    this.perNode = !!config.perNode;
+    this.deserialize = config.deserialize || (() => {
+      throw new Error("This node type doesn't define a deserialize function");
+    });
+  }
+  /// This is meant to be used with
+  /// [`NodeSet.extend`](#common.NodeSet.extend) or
+  /// [`LRParser.configure`](#lr.ParserConfig.props) to compute
+  /// prop values for each node type in the set. Takes a [match
+  /// object](#common.NodeType^match) or function that returns undefined
+  /// if the node type doesn't get this prop, and the prop's value if
+  /// it does.
+  add(match) {
+    if (this.perNode)
+      throw new RangeError("Can't add per-node props to node types");
+    if (typeof match != "function")
+      match = NodeType.match(match);
+    return (type) => {
+      let result = match(type);
+      return result === void 0 ? null : [this, result];
+    };
+  }
+};
+NodeProp.closedBy = new NodeProp({ deserialize: (str) => str.split(" ") });
+NodeProp.openedBy = new NodeProp({ deserialize: (str) => str.split(" ") });
+NodeProp.group = new NodeProp({ deserialize: (str) => str.split(" ") });
+NodeProp.contextHash = new NodeProp({ perNode: true });
+NodeProp.lookAhead = new NodeProp({ perNode: true });
+NodeProp.mounted = new NodeProp({ perNode: true });
+var noProps = /* @__PURE__ */ Object.create(null);
+var NodeType = class {
+  /// @internal
+  constructor(name, props, id, flags = 0) {
+    this.name = name;
+    this.props = props;
+    this.id = id;
+    this.flags = flags;
+  }
+  /// Define a node type.
+  static define(spec) {
+    let props = spec.props && spec.props.length ? /* @__PURE__ */ Object.create(null) : noProps;
+    let flags = (spec.top ? 1 : 0) | (spec.skipped ? 2 : 0) | (spec.error ? 4 : 0) | (spec.name == null ? 8 : 0);
+    let type = new NodeType(spec.name || "", props, spec.id, flags);
+    if (spec.props)
+      for (let src of spec.props) {
+        if (!Array.isArray(src))
+          src = src(type);
+        if (src) {
+          if (src[0].perNode)
+            throw new RangeError("Can't store a per-node prop on a node type");
+          props[src[0].id] = src[1];
+        }
+      }
+    return type;
+  }
+  /// Retrieves a node prop for this type. Will return `undefined` if
+  /// the prop isn't present on this node.
+  prop(prop) {
+    return this.props[prop.id];
+  }
+  /// True when this is the top node of a grammar.
+  get isTop() {
+    return (this.flags & 1) > 0;
+  }
+  /// True when this node is produced by a skip rule.
+  get isSkipped() {
+    return (this.flags & 2) > 0;
+  }
+  /// Indicates whether this is an error node.
+  get isError() {
+    return (this.flags & 4) > 0;
+  }
+  /// When true, this node type doesn't correspond to a user-declared
+  /// named node, for example because it is used to cache repetition.
+  get isAnonymous() {
+    return (this.flags & 8) > 0;
+  }
+  /// Returns true when this node's name or one of its
+  /// [groups](#common.NodeProp^group) matches the given string.
+  is(name) {
+    if (typeof name == "string") {
+      if (this.name == name)
+        return true;
+      let group = this.prop(NodeProp.group);
+      return group ? group.indexOf(name) > -1 : false;
+    }
+    return this.id == name;
+  }
+  /// Create a function from node types to arbitrary values by
+  /// specifying an object whose property names are node or
+  /// [group](#common.NodeProp^group) names. Often useful with
+  /// [`NodeProp.add`](#common.NodeProp.add). You can put multiple
+  /// names, separated by spaces, in a single property name to map
+  /// multiple node names to a single value.
+  static match(map) {
+    let direct = /* @__PURE__ */ Object.create(null);
+    for (let prop in map)
+      for (let name of prop.split(" "))
+        direct[name] = map[prop];
+    return (node) => {
+      for (let groups = node.prop(NodeProp.group), i = -1; i < (groups ? groups.length : 0); i++) {
+        let found = direct[i < 0 ? node.name : groups[i]];
+        if (found)
+          return found;
+      }
+    };
+  }
+};
+NodeType.none = new NodeType(
+  "",
+  /* @__PURE__ */ Object.create(null),
+  0,
+  8
+  /* NodeFlag.Anonymous */
+);
+var NodeSet = class {
+  /// Create a set with the given types. The `id` property of each
+  /// type should correspond to its position within the array.
+  constructor(types) {
+    this.types = types;
+    for (let i = 0; i < types.length; i++)
+      if (types[i].id != i)
+        throw new RangeError("Node type ids should correspond to array positions when creating a node set");
+  }
+  /// Create a copy of this set with some node properties added. The
+  /// arguments to this method can be created with
+  /// [`NodeProp.add`](#common.NodeProp.add).
+  extend(...props) {
+    let newTypes = [];
+    for (let type of this.types) {
+      let newProps = null;
+      for (let source of props) {
+        let add = source(type);
+        if (add) {
+          if (!newProps)
+            newProps = Object.assign({}, type.props);
+          newProps[add[0].id] = add[1];
+        }
+      }
+      newTypes.push(newProps ? new NodeType(type.name, newProps, type.id, type.flags) : type);
+    }
+    return new NodeSet(newTypes);
+  }
+};
+var CachedNode = /* @__PURE__ */ new WeakMap();
+var CachedInnerNode = /* @__PURE__ */ new WeakMap();
+var IterMode;
+(function(IterMode2) {
+  IterMode2[IterMode2["ExcludeBuffers"] = 1] = "ExcludeBuffers";
+  IterMode2[IterMode2["IncludeAnonymous"] = 2] = "IncludeAnonymous";
+  IterMode2[IterMode2["IgnoreMounts"] = 4] = "IgnoreMounts";
+  IterMode2[IterMode2["IgnoreOverlays"] = 8] = "IgnoreOverlays";
+})(IterMode || (IterMode = {}));
+var Tree = class {
+  /// Construct a new tree. See also [`Tree.build`](#common.Tree^build).
+  constructor(type, children, positions, length, props) {
+    this.type = type;
+    this.children = children;
+    this.positions = positions;
+    this.length = length;
+    this.props = null;
+    if (props && props.length) {
+      this.props = /* @__PURE__ */ Object.create(null);
+      for (let [prop, value] of props)
+        this.props[typeof prop == "number" ? prop : prop.id] = value;
+    }
+  }
+  /// @internal
+  toString() {
+    let mounted = this.prop(NodeProp.mounted);
+    if (mounted && !mounted.overlay)
+      return mounted.tree.toString();
+    let children = "";
+    for (let ch of this.children) {
+      let str = ch.toString();
+      if (str) {
+        if (children)
+          children += ",";
+        children += str;
+      }
+    }
+    return !this.type.name ? children : (/\W/.test(this.type.name) && !this.type.isError ? JSON.stringify(this.type.name) : this.type.name) + (children.length ? "(" + children + ")" : "");
+  }
+  /// Get a [tree cursor](#common.TreeCursor) positioned at the top of
+  /// the tree. Mode can be used to [control](#common.IterMode) which
+  /// nodes the cursor visits.
+  cursor(mode = 0) {
+    return new TreeCursor(this.topNode, mode);
+  }
+  /// Get a [tree cursor](#common.TreeCursor) pointing into this tree
+  /// at the given position and side (see
+  /// [`moveTo`](#common.TreeCursor.moveTo).
+  cursorAt(pos, side = 0, mode = 0) {
+    let scope = CachedNode.get(this) || this.topNode;
+    let cursor = new TreeCursor(scope);
+    cursor.moveTo(pos, side);
+    CachedNode.set(this, cursor._tree);
+    return cursor;
+  }
+  /// Get a [syntax node](#common.SyntaxNode) object for the top of the
+  /// tree.
+  get topNode() {
+    return new TreeNode(this, 0, 0, null);
+  }
+  /// Get the [syntax node](#common.SyntaxNode) at the given position.
+  /// If `side` is -1, this will move into nodes that end at the
+  /// position. If 1, it'll move into nodes that start at the
+  /// position. With 0, it'll only enter nodes that cover the position
+  /// from both sides.
+  ///
+  /// Note that this will not enter
+  /// [overlays](#common.MountedTree.overlay), and you often want
+  /// [`resolveInner`](#common.Tree.resolveInner) instead.
+  resolve(pos, side = 0) {
+    let node = resolveNode(CachedNode.get(this) || this.topNode, pos, side, false);
+    CachedNode.set(this, node);
+    return node;
+  }
+  /// Like [`resolve`](#common.Tree.resolve), but will enter
+  /// [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node
+  /// pointing into the innermost overlaid tree at the given position
+  /// (with parent links going through all parent structure, including
+  /// the host trees).
+  resolveInner(pos, side = 0) {
+    let node = resolveNode(CachedInnerNode.get(this) || this.topNode, pos, side, true);
+    CachedInnerNode.set(this, node);
+    return node;
+  }
+  /// Iterate over the tree and its children, calling `enter` for any
+  /// node that touches the `from`/`to` region (if given) before
+  /// running over such a node's children, and `leave` (if given) when
+  /// leaving the node. When `enter` returns `false`, that node will
+  /// not have its children iterated over (or `leave` called).
+  iterate(spec) {
+    let { enter, leave, from = 0, to = this.length } = spec;
+    let mode = spec.mode || 0, anon = (mode & IterMode.IncludeAnonymous) > 0;
+    for (let c = this.cursor(mode | IterMode.IncludeAnonymous); ; ) {
+      let entered = false;
+      if (c.from <= to && c.to >= from && (!anon && c.type.isAnonymous || enter(c) !== false)) {
+        if (c.firstChild())
+          continue;
+        entered = true;
+      }
+      for (; ; ) {
+        if (entered && leave && (anon || !c.type.isAnonymous))
+          leave(c);
+        if (c.nextSibling())
+          break;
+        if (!c.parent())
+          return;
+        entered = true;
+      }
+    }
+  }
+  /// Get the value of the given [node prop](#common.NodeProp) for this
+  /// node. Works with both per-node and per-type props.
+  prop(prop) {
+    return !prop.perNode ? this.type.prop(prop) : this.props ? this.props[prop.id] : void 0;
+  }
+  /// Returns the node's [per-node props](#common.NodeProp.perNode) in a
+  /// format that can be passed to the [`Tree`](#common.Tree)
+  /// constructor.
+  get propValues() {
+    let result = [];
+    if (this.props)
+      for (let id in this.props)
+        result.push([+id, this.props[id]]);
+    return result;
+  }
+  /// Balance the direct children of this tree, producing a copy of
+  /// which may have children grouped into subtrees with type
+  /// [`NodeType.none`](#common.NodeType^none).
+  balance(config = {}) {
+    return this.children.length <= 8 ? this : balanceRange(NodeType.none, this.children, this.positions, 0, this.children.length, 0, this.length, (children, positions, length) => new Tree(this.type, children, positions, length, this.propValues), config.makeTree || ((children, positions, length) => new Tree(NodeType.none, children, positions, length)));
+  }
+  /// Build a tree from a postfix-ordered buffer of node information,
+  /// or a cursor over such a buffer.
+  static build(data) {
+    return buildTree(data);
+  }
+};
+Tree.empty = new Tree(NodeType.none, [], [], 0);
+var FlatBufferCursor = class {
+  constructor(buffer, index) {
+    this.buffer = buffer;
+    this.index = index;
+  }
+  get id() {
+    return this.buffer[this.index - 4];
+  }
+  get start() {
+    return this.buffer[this.index - 3];
+  }
+  get end() {
+    return this.buffer[this.index - 2];
+  }
+  get size() {
+    return this.buffer[this.index - 1];
+  }
+  get pos() {
+    return this.index;
+  }
+  next() {
+    this.index -= 4;
+  }
+  fork() {
+    return new FlatBufferCursor(this.buffer, this.index);
+  }
+};
+var TreeBuffer = class {
+  /// Create a tree buffer.
+  constructor(buffer, length, set) {
+    this.buffer = buffer;
+    this.length = length;
+    this.set = set;
+  }
+  /// @internal
+  get type() {
+    return NodeType.none;
+  }
+  /// @internal
+  toString() {
+    let result = [];
+    for (let index = 0; index < this.buffer.length; ) {
+      result.push(this.childString(index));
+      index = this.buffer[index + 3];
+    }
+    return result.join(",");
+  }
+  /// @internal
+  childString(index) {
+    let id = this.buffer[index], endIndex = this.buffer[index + 3];
+    let type = this.set.types[id], result = type.name;
+    if (/\W/.test(result) && !type.isError)
+      result = JSON.stringify(result);
+    index += 4;
+    if (endIndex == index)
+      return result;
+    let children = [];
+    while (index < endIndex) {
+      children.push(this.childString(index));
+      index = this.buffer[index + 3];
+    }
+    return result + "(" + children.join(",") + ")";
+  }
+  /// @internal
+  findChild(startIndex, endIndex, dir, pos, side) {
+    let { buffer } = this, pick = -1;
+    for (let i = startIndex; i != endIndex; i = buffer[i + 3]) {
+      if (checkSide(side, pos, buffer[i + 1], buffer[i + 2])) {
+        pick = i;
+        if (dir > 0)
+          break;
+      }
+    }
+    return pick;
+  }
+  /// @internal
+  slice(startI, endI, from) {
+    let b = this.buffer;
+    let copy = new Uint16Array(endI - startI), len = 0;
+    for (let i = startI, j = 0; i < endI; ) {
+      copy[j++] = b[i++];
+      copy[j++] = b[i++] - from;
+      let to = copy[j++] = b[i++] - from;
+      copy[j++] = b[i++] - startI;
+      len = Math.max(len, to);
+    }
+    return new TreeBuffer(copy, len, this.set);
+  }
+};
+function checkSide(side, pos, from, to) {
+  switch (side) {
+    case -2:
+      return from < pos;
+    case -1:
+      return to >= pos && from < pos;
+    case 0:
+      return from < pos && to > pos;
+    case 1:
+      return from <= pos && to > pos;
+    case 2:
+      return to > pos;
+    case 4:
+      return true;
+  }
+}
+function enterUnfinishedNodesBefore(node, pos) {
+  let scan = node.childBefore(pos);
+  while (scan) {
+    let last = scan.lastChild;
+    if (!last || last.to != scan.to)
+      break;
+    if (last.type.isError && last.from == last.to) {
+      node = scan;
+      scan = last.prevSibling;
+    } else {
+      scan = last;
+    }
+  }
+  return node;
+}
+function resolveNode(node, pos, side, overlays) {
+  var _a;
+  while (node.from == node.to || (side < 1 ? node.from >= pos : node.from > pos) || (side > -1 ? node.to <= pos : node.to < pos)) {
+    let parent = !overlays && node instanceof TreeNode && node.index < 0 ? null : node.parent;
+    if (!parent)
+      return node;
+    node = parent;
+  }
+  let mode = overlays ? 0 : IterMode.IgnoreOverlays;
+  if (overlays)
+    for (let scan = node, parent = scan.parent; parent; scan = parent, parent = scan.parent) {
+      if (scan instanceof TreeNode && scan.index < 0 && ((_a = parent.enter(pos, side, mode)) === null || _a === void 0 ? void 0 : _a.from) != scan.from)
+        node = parent;
+    }
+  for (; ; ) {
+    let inner = node.enter(pos, side, mode);
+    if (!inner)
+      return node;
+    node = inner;
+  }
+}
+var TreeNode = class {
+  constructor(_tree, from, index, _parent) {
+    this._tree = _tree;
+    this.from = from;
+    this.index = index;
+    this._parent = _parent;
+  }
+  get type() {
+    return this._tree.type;
+  }
+  get name() {
+    return this._tree.type.name;
+  }
+  get to() {
+    return this.from + this._tree.length;
+  }
+  nextChild(i, dir, pos, side, mode = 0) {
+    for (let parent = this; ; ) {
+      for (let { children, positions } = parent._tree, e = dir > 0 ? children.length : -1; i != e; i += dir) {
+        let next = children[i], start = positions[i] + parent.from;
+        if (!checkSide(side, pos, start, start + next.length))
+          continue;
+        if (next instanceof TreeBuffer) {
+          if (mode & IterMode.ExcludeBuffers)
+            continue;
+          let index = next.findChild(0, next.buffer.length, dir, pos - start, side);
+          if (index > -1)
+            return new BufferNode(new BufferContext(parent, next, i, start), null, index);
+        } else if (mode & IterMode.IncludeAnonymous || (!next.type.isAnonymous || hasChild(next))) {
+          let mounted;
+          if (!(mode & IterMode.IgnoreMounts) && next.props && (mounted = next.prop(NodeProp.mounted)) && !mounted.overlay)
+            return new TreeNode(mounted.tree, start, i, parent);
+          let inner = new TreeNode(next, start, i, parent);
+          return mode & IterMode.IncludeAnonymous || !inner.type.isAnonymous ? inner : inner.nextChild(dir < 0 ? next.children.length - 1 : 0, dir, pos, side);
+        }
+      }
+      if (mode & IterMode.IncludeAnonymous || !parent.type.isAnonymous)
+        return null;
+      if (parent.index >= 0)
+        i = parent.index + dir;
+      else
+        i = dir < 0 ? -1 : parent._parent._tree.children.length;
+      parent = parent._parent;
+      if (!parent)
+        return null;
+    }
+  }
+  get firstChild() {
+    return this.nextChild(
+      0,
+      1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  get lastChild() {
+    return this.nextChild(
+      this._tree.children.length - 1,
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  childAfter(pos) {
+    return this.nextChild(
+      0,
+      1,
+      pos,
+      2
+      /* Side.After */
+    );
+  }
+  childBefore(pos) {
+    return this.nextChild(
+      this._tree.children.length - 1,
+      -1,
+      pos,
+      -2
+      /* Side.Before */
+    );
+  }
+  enter(pos, side, mode = 0) {
+    let mounted;
+    if (!(mode & IterMode.IgnoreOverlays) && (mounted = this._tree.prop(NodeProp.mounted)) && mounted.overlay) {
+      let rPos = pos - this.from;
+      for (let { from, to } of mounted.overlay) {
+        if ((side > 0 ? from <= rPos : from < rPos) && (side < 0 ? to >= rPos : to > rPos))
+          return new TreeNode(mounted.tree, mounted.overlay[0].from + this.from, -1, this);
+      }
+    }
+    return this.nextChild(0, 1, pos, side, mode);
+  }
+  nextSignificantParent() {
+    let val = this;
+    while (val.type.isAnonymous && val._parent)
+      val = val._parent;
+    return val;
+  }
+  get parent() {
+    return this._parent ? this._parent.nextSignificantParent() : null;
+  }
+  get nextSibling() {
+    return this._parent && this.index >= 0 ? this._parent.nextChild(
+      this.index + 1,
+      1,
+      0,
+      4
+      /* Side.DontCare */
+    ) : null;
+  }
+  get prevSibling() {
+    return this._parent && this.index >= 0 ? this._parent.nextChild(
+      this.index - 1,
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    ) : null;
+  }
+  cursor(mode = 0) {
+    return new TreeCursor(this, mode);
+  }
+  get tree() {
+    return this._tree;
+  }
+  toTree() {
+    return this._tree;
+  }
+  resolve(pos, side = 0) {
+    return resolveNode(this, pos, side, false);
+  }
+  resolveInner(pos, side = 0) {
+    return resolveNode(this, pos, side, true);
+  }
+  enterUnfinishedNodesBefore(pos) {
+    return enterUnfinishedNodesBefore(this, pos);
+  }
+  getChild(type, before = null, after = null) {
+    let r2 = getChildren(this, type, before, after);
+    return r2.length ? r2[0] : null;
+  }
+  getChildren(type, before = null, after = null) {
+    return getChildren(this, type, before, after);
+  }
+  /// @internal
+  toString() {
+    return this._tree.toString();
+  }
+  get node() {
+    return this;
+  }
+  matchContext(context) {
+    return matchNodeContext(this, context);
+  }
+};
+function getChildren(node, type, before, after) {
+  let cur = node.cursor(), result = [];
+  if (!cur.firstChild())
+    return result;
+  if (before != null) {
+    while (!cur.type.is(before))
+      if (!cur.nextSibling())
+        return result;
+  }
+  for (; ; ) {
+    if (after != null && cur.type.is(after))
+      return result;
+    if (cur.type.is(type))
+      result.push(cur.node);
+    if (!cur.nextSibling())
+      return after == null ? result : [];
+  }
+}
+function matchNodeContext(node, context, i = context.length - 1) {
+  for (let p = node.parent; i >= 0; p = p.parent) {
+    if (!p)
+      return false;
+    if (!p.type.isAnonymous) {
+      if (context[i] && context[i] != p.name)
+        return false;
+      i--;
+    }
+  }
+  return true;
+}
+var BufferContext = class {
+  constructor(parent, buffer, index, start) {
+    this.parent = parent;
+    this.buffer = buffer;
+    this.index = index;
+    this.start = start;
+  }
+};
+var BufferNode = class {
+  get name() {
+    return this.type.name;
+  }
+  get from() {
+    return this.context.start + this.context.buffer.buffer[this.index + 1];
+  }
+  get to() {
+    return this.context.start + this.context.buffer.buffer[this.index + 2];
+  }
+  constructor(context, _parent, index) {
+    this.context = context;
+    this._parent = _parent;
+    this.index = index;
+    this.type = context.buffer.set.types[context.buffer.buffer[index]];
+  }
+  child(dir, pos, side) {
+    let { buffer } = this.context;
+    let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], dir, pos - this.context.start, side);
+    return index < 0 ? null : new BufferNode(this.context, this, index);
+  }
+  get firstChild() {
+    return this.child(
+      1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  get lastChild() {
+    return this.child(
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  childAfter(pos) {
+    return this.child(
+      1,
+      pos,
+      2
+      /* Side.After */
+    );
+  }
+  childBefore(pos) {
+    return this.child(
+      -1,
+      pos,
+      -2
+      /* Side.Before */
+    );
+  }
+  enter(pos, side, mode = 0) {
+    if (mode & IterMode.ExcludeBuffers)
+      return null;
+    let { buffer } = this.context;
+    let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], side > 0 ? 1 : -1, pos - this.context.start, side);
+    return index < 0 ? null : new BufferNode(this.context, this, index);
+  }
+  get parent() {
+    return this._parent || this.context.parent.nextSignificantParent();
+  }
+  externalSibling(dir) {
+    return this._parent ? null : this.context.parent.nextChild(
+      this.context.index + dir,
+      dir,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  get nextSibling() {
+    let { buffer } = this.context;
+    let after = buffer.buffer[this.index + 3];
+    if (after < (this._parent ? buffer.buffer[this._parent.index + 3] : buffer.buffer.length))
+      return new BufferNode(this.context, this._parent, after);
+    return this.externalSibling(1);
+  }
+  get prevSibling() {
+    let { buffer } = this.context;
+    let parentStart = this._parent ? this._parent.index + 4 : 0;
+    if (this.index == parentStart)
+      return this.externalSibling(-1);
+    return new BufferNode(this.context, this._parent, buffer.findChild(
+      parentStart,
+      this.index,
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    ));
+  }
+  cursor(mode = 0) {
+    return new TreeCursor(this, mode);
+  }
+  get tree() {
+    return null;
+  }
+  toTree() {
+    let children = [], positions = [];
+    let { buffer } = this.context;
+    let startI = this.index + 4, endI = buffer.buffer[this.index + 3];
+    if (endI > startI) {
+      let from = buffer.buffer[this.index + 1];
+      children.push(buffer.slice(startI, endI, from));
+      positions.push(0);
+    }
+    return new Tree(this.type, children, positions, this.to - this.from);
+  }
+  resolve(pos, side = 0) {
+    return resolveNode(this, pos, side, false);
+  }
+  resolveInner(pos, side = 0) {
+    return resolveNode(this, pos, side, true);
+  }
+  enterUnfinishedNodesBefore(pos) {
+    return enterUnfinishedNodesBefore(this, pos);
+  }
+  /// @internal
+  toString() {
+    return this.context.buffer.childString(this.index);
+  }
+  getChild(type, before = null, after = null) {
+    let r2 = getChildren(this, type, before, after);
+    return r2.length ? r2[0] : null;
+  }
+  getChildren(type, before = null, after = null) {
+    return getChildren(this, type, before, after);
+  }
+  get node() {
+    return this;
+  }
+  matchContext(context) {
+    return matchNodeContext(this, context);
+  }
+};
+var TreeCursor = class {
+  /// Shorthand for `.type.name`.
+  get name() {
+    return this.type.name;
+  }
+  /// @internal
+  constructor(node, mode = 0) {
+    this.mode = mode;
+    this.buffer = null;
+    this.stack = [];
+    this.index = 0;
+    this.bufferNode = null;
+    if (node instanceof TreeNode) {
+      this.yieldNode(node);
+    } else {
+      this._tree = node.context.parent;
+      this.buffer = node.context;
+      for (let n = node._parent; n; n = n._parent)
+        this.stack.unshift(n.index);
+      this.bufferNode = node;
+      this.yieldBuf(node.index);
+    }
+  }
+  yieldNode(node) {
+    if (!node)
+      return false;
+    this._tree = node;
+    this.type = node.type;
+    this.from = node.from;
+    this.to = node.to;
+    return true;
+  }
+  yieldBuf(index, type) {
+    this.index = index;
+    let { start, buffer } = this.buffer;
+    this.type = type || buffer.set.types[buffer.buffer[index]];
+    this.from = start + buffer.buffer[index + 1];
+    this.to = start + buffer.buffer[index + 2];
+    return true;
+  }
+  yield(node) {
+    if (!node)
+      return false;
+    if (node instanceof TreeNode) {
+      this.buffer = null;
+      return this.yieldNode(node);
+    }
+    this.buffer = node.context;
+    return this.yieldBuf(node.index, node.type);
+  }
+  /// @internal
+  toString() {
+    return this.buffer ? this.buffer.buffer.childString(this.index) : this._tree.toString();
+  }
+  /// @internal
+  enterChild(dir, pos, side) {
+    if (!this.buffer)
+      return this.yield(this._tree.nextChild(dir < 0 ? this._tree._tree.children.length - 1 : 0, dir, pos, side, this.mode));
+    let { buffer } = this.buffer;
+    let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], dir, pos - this.buffer.start, side);
+    if (index < 0)
+      return false;
+    this.stack.push(this.index);
+    return this.yieldBuf(index);
+  }
+  /// Move the cursor to this node's first child. When this returns
+  /// false, the node has no child, and the cursor has not been moved.
+  firstChild() {
+    return this.enterChild(
+      1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  /// Move the cursor to this node's last child.
+  lastChild() {
+    return this.enterChild(
+      -1,
+      0,
+      4
+      /* Side.DontCare */
+    );
+  }
+  /// Move the cursor to the first child that ends after `pos`.
+  childAfter(pos) {
+    return this.enterChild(
+      1,
+      pos,
+      2
+      /* Side.After */
+    );
+  }
+  /// Move to the last child that starts before `pos`.
+  childBefore(pos) {
+    return this.enterChild(
+      -1,
+      pos,
+      -2
+      /* Side.Before */
+    );
+  }
+  /// Move the cursor to the child around `pos`. If side is -1 the
+  /// child may end at that position, when 1 it may start there. This
+  /// will also enter [overlaid](#common.MountedTree.overlay)
+  /// [mounted](#common.NodeProp^mounted) trees unless `overlays` is
+  /// set to false.
+  enter(pos, side, mode = this.mode) {
+    if (!this.buffer)
+      return this.yield(this._tree.enter(pos, side, mode));
+    return mode & IterMode.ExcludeBuffers ? false : this.enterChild(1, pos, side);
+  }
+  /// Move to the node's parent node, if this isn't the top node.
+  parent() {
+    if (!this.buffer)
+      return this.yieldNode(this.mode & IterMode.IncludeAnonymous ? this._tree._parent : this._tree.parent);
+    if (this.stack.length)
+      return this.yieldBuf(this.stack.pop());
+    let parent = this.mode & IterMode.IncludeAnonymous ? this.buffer.parent : this.buffer.parent.nextSignificantParent();
+    this.buffer = null;
+    return this.yieldNode(parent);
+  }
+  /// @internal
+  sibling(dir) {
+    if (!this.buffer)
+      return !this._tree._parent ? false : this.yield(this._tree.index < 0 ? null : this._tree._parent.nextChild(this._tree.index + dir, dir, 0, 4, this.mode));
+    let { buffer } = this.buffer, d = this.stack.length - 1;
+    if (dir < 0) {
+      let parentStart = d < 0 ? 0 : this.stack[d] + 4;
+      if (this.index != parentStart)
+        return this.yieldBuf(buffer.findChild(
+          parentStart,
+          this.index,
+          -1,
+          0,
+          4
+          /* Side.DontCare */
+        ));
+    } else {
+      let after = buffer.buffer[this.index + 3];
+      if (after < (d < 0 ? buffer.buffer.length : buffer.buffer[this.stack[d] + 3]))
+        return this.yieldBuf(after);
+    }
+    return d < 0 ? this.yield(this.buffer.parent.nextChild(this.buffer.index + dir, dir, 0, 4, this.mode)) : false;
+  }
+  /// Move to this node's next sibling, if any.
+  nextSibling() {
+    return this.sibling(1);
+  }
+  /// Move to this node's previous sibling, if any.
+  prevSibling() {
+    return this.sibling(-1);
+  }
+  atLastNode(dir) {
+    let index, parent, { buffer } = this;
+    if (buffer) {
+      if (dir > 0) {
+        if (this.index < buffer.buffer.buffer.length)
+          return false;
+      } else {
+        for (let i = 0; i < this.index; i++)
+          if (buffer.buffer.buffer[i + 3] < this.index)
+            return false;
+      }
+      ({ index, parent } = buffer);
+    } else {
+      ({ index, _parent: parent } = this._tree);
+    }
+    for (; parent; { index, _parent: parent } = parent) {
+      if (index > -1)
+        for (let i = index + dir, e = dir < 0 ? -1 : parent._tree.children.length; i != e; i += dir) {
+          let child = parent._tree.children[i];
+          if (this.mode & IterMode.IncludeAnonymous || child instanceof TreeBuffer || !child.type.isAnonymous || hasChild(child))
+            return false;
+        }
+    }
+    return true;
+  }
+  move(dir, enter) {
+    if (enter && this.enterChild(
+      dir,
+      0,
+      4
+      /* Side.DontCare */
+    ))
+      return true;
+    for (; ; ) {
+      if (this.sibling(dir))
+        return true;
+      if (this.atLastNode(dir) || !this.parent())
+        return false;
+    }
+  }
+  /// Move to the next node in a
+  /// [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR)
+  /// traversal, going from a node to its first child or, if the
+  /// current node is empty or `enter` is false, its next sibling or
+  /// the next sibling of the first parent node that has one.
+  next(enter = true) {
+    return this.move(1, enter);
+  }
+  /// Move to the next node in a last-to-first pre-order traveral. A
+  /// node is followed by its last child or, if it has none, its
+  /// previous sibling or the previous sibling of the first parent
+  /// node that has one.
+  prev(enter = true) {
+    return this.move(-1, enter);
+  }
+  /// Move the cursor to the innermost node that covers `pos`. If
+  /// `side` is -1, it will enter nodes that end at `pos`. If it is 1,
+  /// it will enter nodes that start at `pos`.
+  moveTo(pos, side = 0) {
+    while (this.from == this.to || (side < 1 ? this.from >= pos : this.from > pos) || (side > -1 ? this.to <= pos : this.to < pos))
+      if (!this.parent())
+        break;
+    while (this.enterChild(1, pos, side)) {
+    }
+    return this;
+  }
+  /// Get a [syntax node](#common.SyntaxNode) at the cursor's current
+  /// position.
+  get node() {
+    if (!this.buffer)
+      return this._tree;
+    let cache = this.bufferNode, result = null, depth = 0;
+    if (cache && cache.context == this.buffer) {
+      scan:
+        for (let index = this.index, d = this.stack.length; d >= 0; ) {
+          for (let c = cache; c; c = c._parent)
+            if (c.index == index) {
+              if (index == this.index)
+                return c;
+              result = c;
+              depth = d + 1;
+              break scan;
+            }
+          index = this.stack[--d];
+        }
+    }
+    for (let i = depth; i < this.stack.length; i++)
+      result = new BufferNode(this.buffer, result, this.stack[i]);
+    return this.bufferNode = new BufferNode(this.buffer, result, this.index);
+  }
+  /// Get the [tree](#common.Tree) that represents the current node, if
+  /// any. Will return null when the node is in a [tree
+  /// buffer](#common.TreeBuffer).
+  get tree() {
+    return this.buffer ? null : this._tree._tree;
+  }
+  /// Iterate over the current node and all its descendants, calling
+  /// `enter` when entering a node and `leave`, if given, when leaving
+  /// one. When `enter` returns `false`, any children of that node are
+  /// skipped, and `leave` isn't called for it.
+  iterate(enter, leave) {
+    for (let depth = 0; ; ) {
+      let mustLeave = false;
+      if (this.type.isAnonymous || enter(this) !== false) {
+        if (this.firstChild()) {
+          depth++;
+          continue;
+        }
+        if (!this.type.isAnonymous)
+          mustLeave = true;
+      }
+      for (; ; ) {
+        if (mustLeave && leave)
+          leave(this);
+        mustLeave = this.type.isAnonymous;
+        if (this.nextSibling())
+          break;
+        if (!depth)
+          return;
+        this.parent();
+        depth--;
+        mustLeave = true;
+      }
+    }
+  }
+  /// Test whether the current node matches a given context—a sequence
+  /// of direct parent node names. Empty strings in the context array
+  /// are treated as wildcards.
+  matchContext(context) {
+    if (!this.buffer)
+      return matchNodeContext(this.node, context);
+    let { buffer } = this.buffer, { types } = buffer.set;
+    for (let i = context.length - 1, d = this.stack.length - 1; i >= 0; d--) {
+      if (d < 0)
+        return matchNodeContext(this.node, context, i);
+      let type = types[buffer.buffer[this.stack[d]]];
+      if (!type.isAnonymous) {
+        if (context[i] && context[i] != type.name)
+          return false;
+        i--;
+      }
+    }
+    return true;
+  }
+};
+function hasChild(tree) {
+  return tree.children.some((ch) => ch instanceof TreeBuffer || !ch.type.isAnonymous || hasChild(ch));
+}
+function buildTree(data) {
+  var _a;
+  let { buffer, nodeSet, maxBufferLength = DefaultBufferLength, reused = [], minRepeatType = nodeSet.types.length } = data;
+  let cursor = Array.isArray(buffer) ? new FlatBufferCursor(buffer, buffer.length) : buffer;
+  let types = nodeSet.types;
+  let contextHash = 0, lookAhead = 0;
+  function takeNode(parentStart, minPos, children2, positions2, inRepeat) {
+    let { id, start, end, size } = cursor;
+    let lookAheadAtStart = lookAhead;
+    while (size < 0) {
+      cursor.next();
+      if (size == -1) {
+        let node2 = reused[id];
+        children2.push(node2);
+        positions2.push(start - parentStart);
+        return;
+      } else if (size == -3) {
+        contextHash = id;
+        return;
+      } else if (size == -4) {
+        lookAhead = id;
+        return;
+      } else {
+        throw new RangeError(`Unrecognized record size: ${size}`);
+      }
+    }
+    let type = types[id], node, buffer2;
+    let startPos = start - parentStart;
+    if (end - start <= maxBufferLength && (buffer2 = findBufferSize(cursor.pos - minPos, inRepeat))) {
+      let data2 = new Uint16Array(buffer2.size - buffer2.skip);
+      let endPos = cursor.pos - buffer2.size, index = data2.length;
+      while (cursor.pos > endPos)
+        index = copyToBuffer(buffer2.start, data2, index);
+      node = new TreeBuffer(data2, end - buffer2.start, nodeSet);
+      startPos = buffer2.start - parentStart;
+    } else {
+      let endPos = cursor.pos - size;
+      cursor.next();
+      let localChildren = [], localPositions = [];
+      let localInRepeat = id >= minRepeatType ? id : -1;
+      let lastGroup = 0, lastEnd = end;
+      while (cursor.pos > endPos) {
+        if (localInRepeat >= 0 && cursor.id == localInRepeat && cursor.size >= 0) {
+          if (cursor.end <= lastEnd - maxBufferLength) {
+            makeRepeatLeaf(localChildren, localPositions, start, lastGroup, cursor.end, lastEnd, localInRepeat, lookAheadAtStart);
+            lastGroup = localChildren.length;
+            lastEnd = cursor.end;
+          }
+          cursor.next();
+        } else {
+          takeNode(start, endPos, localChildren, localPositions, localInRepeat);
+        }
+      }
+      if (localInRepeat >= 0 && lastGroup > 0 && lastGroup < localChildren.length)
+        makeRepeatLeaf(localChildren, localPositions, start, lastGroup, start, lastEnd, localInRepeat, lookAheadAtStart);
+      localChildren.reverse();
+      localPositions.reverse();
+      if (localInRepeat > -1 && lastGroup > 0) {
+        let make = makeBalanced(type);
+        node = balanceRange(type, localChildren, localPositions, 0, localChildren.length, 0, end - start, make, make);
+      } else {
+        node = makeTree(type, localChildren, localPositions, end - start, lookAheadAtStart - end);
+      }
+    }
+    children2.push(node);
+    positions2.push(startPos);
+  }
+  function makeBalanced(type) {
+    return (children2, positions2, length2) => {
+      let lookAhead2 = 0, lastI = children2.length - 1, last, lookAheadProp;
+      if (lastI >= 0 && (last = children2[lastI]) instanceof Tree) {
+        if (!lastI && last.type == type && last.length == length2)
+          return last;
+        if (lookAheadProp = last.prop(NodeProp.lookAhead))
+          lookAhead2 = positions2[lastI] + last.length + lookAheadProp;
+      }
+      return makeTree(type, children2, positions2, length2, lookAhead2);
+    };
+  }
+  function makeRepeatLeaf(children2, positions2, base, i, from, to, type, lookAhead2) {
+    let localChildren = [], localPositions = [];
+    while (children2.length > i) {
+      localChildren.push(children2.pop());
+      localPositions.push(positions2.pop() + base - from);
+    }
+    children2.push(makeTree(nodeSet.types[type], localChildren, localPositions, to - from, lookAhead2 - to));
+    positions2.push(from - base);
+  }
+  function makeTree(type, children2, positions2, length2, lookAhead2 = 0, props) {
+    if (contextHash) {
+      let pair2 = [NodeProp.contextHash, contextHash];
+      props = props ? [pair2].concat(props) : [pair2];
+    }
+    if (lookAhead2 > 25) {
+      let pair2 = [NodeProp.lookAhead, lookAhead2];
+      props = props ? [pair2].concat(props) : [pair2];
+    }
+    return new Tree(type, children2, positions2, length2, props);
+  }
+  function findBufferSize(maxSize, inRepeat) {
+    let fork = cursor.fork();
+    let size = 0, start = 0, skip = 0, minStart = fork.end - maxBufferLength;
+    let result = { size: 0, start: 0, skip: 0 };
+    scan:
+      for (let minPos = fork.pos - maxSize; fork.pos > minPos; ) {
+        let nodeSize2 = fork.size;
+        if (fork.id == inRepeat && nodeSize2 >= 0) {
+          result.size = size;
+          result.start = start;
+          result.skip = skip;
+          skip += 4;
+          size += 4;
+          fork.next();
+          continue;
+        }
+        let startPos = fork.pos - nodeSize2;
+        if (nodeSize2 < 0 || startPos < minPos || fork.start < minStart)
+          break;
+        let localSkipped = fork.id >= minRepeatType ? 4 : 0;
+        let nodeStart = fork.start;
+        fork.next();
+        while (fork.pos > startPos) {
+          if (fork.size < 0) {
+            if (fork.size == -3)
+              localSkipped += 4;
+            else
+              break scan;
+          } else if (fork.id >= minRepeatType) {
+            localSkipped += 4;
+          }
+          fork.next();
+        }
+        start = nodeStart;
+        size += nodeSize2;
+        skip += localSkipped;
+      }
+    if (inRepeat < 0 || size == maxSize) {
+      result.size = size;
+      result.start = start;
+      result.skip = skip;
+    }
+    return result.size > 4 ? result : void 0;
+  }
+  function copyToBuffer(bufferStart, buffer2, index) {
+    let { id, start, end, size } = cursor;
+    cursor.next();
+    if (size >= 0 && id < minRepeatType) {
+      let startIndex = index;
+      if (size > 4) {
+        let endPos = cursor.pos - (size - 4);
+        while (cursor.pos > endPos)
+          index = copyToBuffer(bufferStart, buffer2, index);
+      }
+      buffer2[--index] = startIndex;
+      buffer2[--index] = end - bufferStart;
+      buffer2[--index] = start - bufferStart;
+      buffer2[--index] = id;
+    } else if (size == -3) {
+      contextHash = id;
+    } else if (size == -4) {
+      lookAhead = id;
+    }
+    return index;
+  }
+  let children = [], positions = [];
+  while (cursor.pos > 0)
+    takeNode(data.start || 0, data.bufferStart || 0, children, positions, -1);
+  let length = (_a = data.length) !== null && _a !== void 0 ? _a : children.length ? positions[0] + children[0].length : 0;
+  return new Tree(types[data.topID], children.reverse(), positions.reverse(), length);
 }
+var nodeSizeCache = /* @__PURE__ */ new WeakMap();
+function nodeSize(balanceType, node) {
+  if (!balanceType.isAnonymous || node instanceof TreeBuffer || node.type != balanceType)
+    return 1;
+  let size = nodeSizeCache.get(node);
+  if (size == null) {
+    size = 1;
+    for (let child of node.children) {
+      if (child.type != balanceType || !(child instanceof Tree)) {
+        size = 1;
+        break;
+      }
+      size += nodeSize(balanceType, child);
+    }
+    nodeSizeCache.set(node, size);
+  }
+  return size;
+}
+function balanceRange(balanceType, children, positions, from, to, start, length, mkTop, mkTree) {
+  let total = 0;
+  for (let i = from; i < to; i++)
+    total += nodeSize(balanceType, children[i]);
+  let maxChild = Math.ceil(
+    total * 1.5 / 8
+    /* Balance.BranchFactor */
+  );
+  let localChildren = [], localPositions = [];
+  function divide(children2, positions2, from2, to2, offset) {
+    for (let i = from2; i < to2; ) {
+      let groupFrom = i, groupStart = positions2[i], groupSize = nodeSize(balanceType, children2[i]);
+      i++;
+      for (; i < to2; i++) {
+        let nextSize = nodeSize(balanceType, children2[i]);
+        if (groupSize + nextSize >= maxChild)
+          break;
+        groupSize += nextSize;
+      }
+      if (i == groupFrom + 1) {
+        if (groupSize > maxChild) {
+          let only = children2[groupFrom];
+          divide(only.children, only.positions, 0, only.children.length, positions2[groupFrom] + offset);
+          continue;
+        }
+        localChildren.push(children2[groupFrom]);
+      } else {
+        let length2 = positions2[i - 1] + children2[i - 1].length - groupStart;
+        localChildren.push(balanceRange(balanceType, children2, positions2, groupFrom, i, groupStart, length2, null, mkTree));
+      }
+      localPositions.push(groupStart + offset - start);
+    }
+  }
+  divide(children, positions, from, to, 0);
+  return (mkTop || mkTree)(localChildren, localPositions, length);
+}
+var Parser = class {
+  /// Start a parse, returning a [partial parse](#common.PartialParse)
+  /// object. [`fragments`](#common.TreeFragment) can be passed in to
+  /// make the parse incremental.
+  ///
+  /// By default, the entire input is parsed. You can pass `ranges`,
+  /// which should be a sorted array of non-empty, non-overlapping
+  /// ranges, to parse only those ranges. The tree returned in that
+  /// case will start at `ranges[0].from`.
+  startParse(input, fragments, ranges) {
+    if (typeof input == "string")
+      input = new StringInput(input);
+    ranges = !ranges ? [new Range(0, input.length)] : ranges.length ? ranges.map((r2) => new Range(r2.from, r2.to)) : [new Range(0, 0)];
+    return this.createParse(input, fragments || [], ranges);
+  }
+  /// Run a full parse, returning the resulting tree.
+  parse(input, fragments, ranges) {
+    let parse = this.startParse(input, fragments, ranges);
+    for (; ; ) {
+      let done = parse.advance();
+      if (done)
+        return done;
+    }
+  }
+};
+var StringInput = class {
+  constructor(string) {
+    this.string = string;
+  }
+  get length() {
+    return this.string.length;
+  }
+  chunk(from) {
+    return this.string.slice(from);
+  }
+  get lineChunks() {
+    return false;
+  }
+  read(from, to) {
+    return this.string.slice(from, to);
+  }
+};
+var stoppedInner = new NodeProp({ perNode: true });
 
-.saltIcon:active {
-  --icon-color: var(--saltIcon-color-active, var(--salt-text-secondary-foreground));
+// ../../node_modules/@lezer/lr/dist/index.js
+var Stack = class {
+  /// @internal
+  constructor(p, stack, state, reducePos, pos, score, buffer, bufferBase, curContext, lookAhead = 0, parent) {
+    this.p = p;
+    this.stack = stack;
+    this.state = state;
+    this.reducePos = reducePos;
+    this.pos = pos;
+    this.score = score;
+    this.buffer = buffer;
+    this.bufferBase = bufferBase;
+    this.curContext = curContext;
+    this.lookAhead = lookAhead;
+    this.parent = parent;
+  }
+  /// @internal
+  toString() {
+    return `[${this.stack.filter((_, i) => i % 3 == 0).concat(this.state)}]@${this.pos}${this.score ? "!" + this.score : ""}`;
+  }
+  // Start an empty stack
+  /// @internal
+  static start(p, state, pos = 0) {
+    let cx3 = p.parser.context;
+    return new Stack(p, [], state, pos, pos, 0, [], 0, cx3 ? new StackContext(cx3, cx3.start) : null, 0, null);
+  }
+  /// The stack's current [context](#lr.ContextTracker) value, if
+  /// any. Its type will depend on the context tracker's type
+  /// parameter, or it will be `null` if there is no context
+  /// tracker.
+  get context() {
+    return this.curContext ? this.curContext.context : null;
+  }
+  // Push a state onto the stack, tracking its start position as well
+  // as the buffer base at that point.
+  /// @internal
+  pushState(state, start) {
+    this.stack.push(this.state, start, this.bufferBase + this.buffer.length);
+    this.state = state;
+  }
+  // Apply a reduce action
+  /// @internal
+  reduce(action) {
+    var _a;
+    let depth = action >> 19, type = action & 65535;
+    let { parser: parser2 } = this.p;
+    let dPrec = parser2.dynamicPrecedence(type);
+    if (dPrec)
+      this.score += dPrec;
+    if (depth == 0) {
+      this.pushState(parser2.getGoto(this.state, type, true), this.reducePos);
+      if (type < parser2.minRepeatTerm)
+        this.storeNode(type, this.reducePos, this.reducePos, 4, true);
+      this.reduceContext(type, this.reducePos);
+      return;
+    }
+    let base = this.stack.length - (depth - 1) * 3 - (action & 262144 ? 6 : 0);
+    let start = base ? this.stack[base - 2] : this.p.ranges[0].from, size = this.reducePos - start;
+    if (size >= 2e3 && !((_a = this.p.parser.nodeSet.types[type]) === null || _a === void 0 ? void 0 : _a.isAnonymous)) {
+      if (start == this.p.lastBigReductionStart) {
+        this.p.bigReductionCount++;
+        this.p.lastBigReductionSize = size;
+      } else if (this.p.lastBigReductionSize < size) {
+        this.p.bigReductionCount = 1;
+        this.p.lastBigReductionStart = start;
+        this.p.lastBigReductionSize = size;
+      }
+    }
+    let bufferBase = base ? this.stack[base - 1] : 0, count = this.bufferBase + this.buffer.length - bufferBase;
+    if (type < parser2.minRepeatTerm || action & 131072) {
+      let pos = parser2.stateFlag(
+        this.state,
+        1
+        /* StateFlag.Skipped */
+      ) ? this.pos : this.reducePos;
+      this.storeNode(type, start, pos, count + 4, true);
+    }
+    if (action & 262144) {
+      this.state = this.stack[base];
+    } else {
+      let baseStateID = this.stack[base - 3];
+      this.state = parser2.getGoto(baseStateID, type, true);
+    }
+    while (this.stack.length > base)
+      this.stack.pop();
+    this.reduceContext(type, start);
+  }
+  // Shift a value into the buffer
+  /// @internal
+  storeNode(term, start, end, size = 4, isReduce = false) {
+    if (term == 0 && (!this.stack.length || this.stack[this.stack.length - 1] < this.buffer.length + this.bufferBase)) {
+      let cur = this, top = this.buffer.length;
+      if (top == 0 && cur.parent) {
+        top = cur.bufferBase - cur.parent.bufferBase;
+        cur = cur.parent;
+      }
+      if (top > 0 && cur.buffer[top - 4] == 0 && cur.buffer[top - 1] > -1) {
+        if (start == end)
+          return;
+        if (cur.buffer[top - 2] >= start) {
+          cur.buffer[top - 2] = end;
+          return;
+        }
+      }
+    }
+    if (!isReduce || this.pos == end) {
+      this.buffer.push(term, start, end, size);
+    } else {
+      let index = this.buffer.length;
+      if (index > 0 && this.buffer[index - 4] != 0)
+        while (index > 0 && this.buffer[index - 2] > end) {
+          this.buffer[index] = this.buffer[index - 4];
+          this.buffer[index + 1] = this.buffer[index - 3];
+          this.buffer[index + 2] = this.buffer[index - 2];
+          this.buffer[index + 3] = this.buffer[index - 1];
+          index -= 4;
+          if (size > 4)
+            size -= 4;
+        }
+      this.buffer[index] = term;
+      this.buffer[index + 1] = start;
+      this.buffer[index + 2] = end;
+      this.buffer[index + 3] = size;
+    }
+  }
+  // Apply a shift action
+  /// @internal
+  shift(action, next, nextEnd) {
+    let start = this.pos;
+    if (action & 131072) {
+      this.pushState(action & 65535, this.pos);
+    } else if ((action & 262144) == 0) {
+      let nextState = action, { parser: parser2 } = this.p;
+      if (nextEnd > this.pos || next <= parser2.maxNode) {
+        this.pos = nextEnd;
+        if (!parser2.stateFlag(
+          nextState,
+          1
+          /* StateFlag.Skipped */
+        ))
+          this.reducePos = nextEnd;
+      }
+      this.pushState(nextState, start);
+      this.shiftContext(next, start);
+      if (next <= parser2.maxNode)
+        this.buffer.push(next, start, nextEnd, 4);
+    } else {
+      this.pos = nextEnd;
+      this.shiftContext(next, start);
+      if (next <= this.p.parser.maxNode)
+        this.buffer.push(next, start, nextEnd, 4);
+    }
+  }
+  // Apply an action
+  /// @internal
+  apply(action, next, nextEnd) {
+    if (action & 65536)
+      this.reduce(action);
+    else
+      this.shift(action, next, nextEnd);
+  }
+  // Add a prebuilt (reused) node into the buffer.
+  /// @internal
+  useNode(value, next) {
+    let index = this.p.reused.length - 1;
+    if (index < 0 || this.p.reused[index] != value) {
+      this.p.reused.push(value);
+      index++;
+    }
+    let start = this.pos;
+    this.reducePos = this.pos = start + value.length;
+    this.pushState(next, start);
+    this.buffer.push(
+      index,
+      start,
+      this.reducePos,
+      -1
+      /* size == -1 means this is a reused value */
+    );
+    if (this.curContext)
+      this.updateContext(this.curContext.tracker.reuse(this.curContext.context, value, this, this.p.stream.reset(this.pos - value.length)));
+  }
+  // Split the stack. Due to the buffer sharing and the fact
+  // that `this.stack` tends to stay quite shallow, this isn't very
+  // expensive.
+  /// @internal
+  split() {
+    let parent = this;
+    let off = parent.buffer.length;
+    while (off > 0 && parent.buffer[off - 2] > parent.reducePos)
+      off -= 4;
+    let buffer = parent.buffer.slice(off), base = parent.bufferBase + off;
+    while (parent && base == parent.bufferBase)
+      parent = parent.parent;
+    return new Stack(this.p, this.stack.slice(), this.state, this.reducePos, this.pos, this.score, buffer, base, this.curContext, this.lookAhead, parent);
+  }
+  // Try to recover from an error by 'deleting' (ignoring) one token.
+  /// @internal
+  recoverByDelete(next, nextEnd) {
+    let isNode = next <= this.p.parser.maxNode;
+    if (isNode)
+      this.storeNode(next, this.pos, nextEnd, 4);
+    this.storeNode(0, this.pos, nextEnd, isNode ? 8 : 4);
+    this.pos = this.reducePos = nextEnd;
+    this.score -= 190;
+  }
+  /// Check if the given term would be able to be shifted (optionally
+  /// after some reductions) on this stack. This can be useful for
+  /// external tokenizers that want to make sure they only provide a
+  /// given token when it applies.
+  canShift(term) {
+    for (let sim = new SimulatedStack(this); ; ) {
+      let action = this.p.parser.stateSlot(
+        sim.state,
+        4
+        /* ParseState.DefaultReduce */
+      ) || this.p.parser.hasAction(sim.state, term);
+      if (action == 0)
+        return false;
+      if ((action & 65536) == 0)
+        return true;
+      sim.reduce(action);
+    }
+  }
+  // Apply up to Recover.MaxNext recovery actions that conceptually
+  // inserts some missing token or rule.
+  /// @internal
+  recoverByInsert(next) {
+    if (this.stack.length >= 300)
+      return [];
+    let nextStates = this.p.parser.nextStates(this.state);
+    if (nextStates.length > 4 << 1 || this.stack.length >= 120) {
+      let best = [];
+      for (let i = 0, s; i < nextStates.length; i += 2) {
+        if ((s = nextStates[i + 1]) != this.state && this.p.parser.hasAction(s, next))
+          best.push(nextStates[i], s);
+      }
+      if (this.stack.length < 120)
+        for (let i = 0; best.length < 4 << 1 && i < nextStates.length; i += 2) {
+          let s = nextStates[i + 1];
+          if (!best.some((v, i2) => i2 & 1 && v == s))
+            best.push(nextStates[i], s);
+        }
+      nextStates = best;
+    }
+    let result = [];
+    for (let i = 0; i < nextStates.length && result.length < 4; i += 2) {
+      let s = nextStates[i + 1];
+      if (s == this.state)
+        continue;
+      let stack = this.split();
+      stack.pushState(s, this.pos);
+      stack.storeNode(0, stack.pos, stack.pos, 4, true);
+      stack.shiftContext(nextStates[i], this.pos);
+      stack.score -= 200;
+      result.push(stack);
+    }
+    return result;
+  }
+  // Force a reduce, if possible. Return false if that can't
+  // be done.
+  /// @internal
+  forceReduce() {
+    let reduce = this.p.parser.stateSlot(
+      this.state,
+      5
+      /* ParseState.ForcedReduce */
+    );
+    if ((reduce & 65536) == 0)
+      return false;
+    let { parser: parser2 } = this.p;
+    if (!parser2.validAction(this.state, reduce)) {
+      let depth = reduce >> 19, term = reduce & 65535;
+      let target = this.stack.length - depth * 3;
+      if (target < 0 || parser2.getGoto(this.stack[target], term, false) < 0)
+        return false;
+      this.storeNode(0, this.reducePos, this.reducePos, 4, true);
+      this.score -= 100;
+    }
+    this.reducePos = this.pos;
+    this.reduce(reduce);
+    return true;
+  }
+  /// @internal
+  forceAll() {
+    while (!this.p.parser.stateFlag(
+      this.state,
+      2
+      /* StateFlag.Accepting */
+    )) {
+      if (!this.forceReduce()) {
+        this.storeNode(0, this.pos, this.pos, 4, true);
+        break;
+      }
+    }
+    return this;
+  }
+  /// Check whether this state has no further actions (assumed to be a direct descendant of the
+  /// top state, since any other states must be able to continue
+  /// somehow). @internal
+  get deadEnd() {
+    if (this.stack.length != 3)
+      return false;
+    let { parser: parser2 } = this.p;
+    return parser2.data[parser2.stateSlot(
+      this.state,
+      1
+      /* ParseState.Actions */
+    )] == 65535 && !parser2.stateSlot(
+      this.state,
+      4
+      /* ParseState.DefaultReduce */
+    );
+  }
+  /// Restart the stack (put it back in its start state). Only safe
+  /// when this.stack.length == 3 (state is directly below the top
+  /// state). @internal
+  restart() {
+    this.state = this.stack[0];
+    this.stack.length = 0;
+  }
+  /// @internal
+  sameState(other) {
+    if (this.state != other.state || this.stack.length != other.stack.length)
+      return false;
+    for (let i = 0; i < this.stack.length; i += 3)
+      if (this.stack[i] != other.stack[i])
+        return false;
+    return true;
+  }
+  /// Get the parser used by this stack.
+  get parser() {
+    return this.p.parser;
+  }
+  /// Test whether a given dialect (by numeric ID, as exported from
+  /// the terms file) is enabled.
+  dialectEnabled(dialectID) {
+    return this.p.parser.dialect.flags[dialectID];
+  }
+  shiftContext(term, start) {
+    if (this.curContext)
+      this.updateContext(this.curContext.tracker.shift(this.curContext.context, term, this, this.p.stream.reset(start)));
+  }
+  reduceContext(term, start) {
+    if (this.curContext)
+      this.updateContext(this.curContext.tracker.reduce(this.curContext.context, term, this, this.p.stream.reset(start)));
+  }
+  /// @internal
+  emitContext() {
+    let last = this.buffer.length - 1;
+    if (last < 0 || this.buffer[last] != -3)
+      this.buffer.push(this.curContext.hash, this.reducePos, this.reducePos, -3);
+  }
+  /// @internal
+  emitLookAhead() {
+    let last = this.buffer.length - 1;
+    if (last < 0 || this.buffer[last] != -4)
+      this.buffer.push(this.lookAhead, this.reducePos, this.reducePos, -4);
+  }
+  updateContext(context) {
+    if (context != this.curContext.context) {
+      let newCx = new StackContext(this.curContext.tracker, context);
+      if (newCx.hash != this.curContext.hash)
+        this.emitContext();
+      this.curContext = newCx;
+    }
+  }
+  /// @internal
+  setLookAhead(lookAhead) {
+    if (lookAhead > this.lookAhead) {
+      this.emitLookAhead();
+      this.lookAhead = lookAhead;
+    }
+  }
+  /// @internal
+  close() {
+    if (this.curContext && this.curContext.tracker.strict)
+      this.emitContext();
+    if (this.lookAhead > 0)
+      this.emitLookAhead();
+  }
+};
+var StackContext = class {
+  constructor(tracker, context) {
+    this.tracker = tracker;
+    this.context = context;
+    this.hash = tracker.strict ? tracker.hash(context) : 0;
+  }
+};
+var Recover;
+(function(Recover2) {
+  Recover2[Recover2["Insert"] = 200] = "Insert";
+  Recover2[Recover2["Delete"] = 190] = "Delete";
+  Recover2[Recover2["Reduce"] = 100] = "Reduce";
+  Recover2[Recover2["MaxNext"] = 4] = "MaxNext";
+  Recover2[Recover2["MaxInsertStackDepth"] = 300] = "MaxInsertStackDepth";
+  Recover2[Recover2["DampenInsertStackDepth"] = 120] = "DampenInsertStackDepth";
+  Recover2[Recover2["MinBigReduction"] = 2e3] = "MinBigReduction";
+})(Recover || (Recover = {}));
+var SimulatedStack = class {
+  constructor(start) {
+    this.start = start;
+    this.state = start.state;
+    this.stack = start.stack;
+    this.base = this.stack.length;
+  }
+  reduce(action) {
+    let term = action & 65535, depth = action >> 19;
+    if (depth == 0) {
+      if (this.stack == this.start.stack)
+        this.stack = this.stack.slice();
+      this.stack.push(this.state, 0, 0);
+      this.base += 3;
+    } else {
+      this.base -= (depth - 1) * 3;
+    }
+    let goto = this.start.p.parser.getGoto(this.stack[this.base - 3], term, true);
+    this.state = goto;
+  }
+};
+var StackBufferCursor = class {
+  constructor(stack, pos, index) {
+    this.stack = stack;
+    this.pos = pos;
+    this.index = index;
+    this.buffer = stack.buffer;
+    if (this.index == 0)
+      this.maybeNext();
+  }
+  static create(stack, pos = stack.bufferBase + stack.buffer.length) {
+    return new StackBufferCursor(stack, pos, pos - stack.bufferBase);
+  }
+  maybeNext() {
+    let next = this.stack.parent;
+    if (next != null) {
+      this.index = this.stack.bufferBase - next.bufferBase;
+      this.stack = next;
+      this.buffer = next.buffer;
+    }
+  }
+  get id() {
+    return this.buffer[this.index - 4];
+  }
+  get start() {
+    return this.buffer[this.index - 3];
+  }
+  get end() {
+    return this.buffer[this.index - 2];
+  }
+  get size() {
+    return this.buffer[this.index - 1];
+  }
+  next() {
+    this.index -= 4;
+    this.pos -= 4;
+    if (this.index == 0)
+      this.maybeNext();
+  }
+  fork() {
+    return new StackBufferCursor(this.stack, this.pos, this.index);
+  }
+};
+function decodeArray(input, Type = Uint16Array) {
+  if (typeof input != "string")
+    return input;
+  let array = null;
+  for (let pos = 0, out = 0; pos < input.length; ) {
+    let value = 0;
+    for (; ; ) {
+      let next = input.charCodeAt(pos++), stop = false;
+      if (next == 126) {
+        value = 65535;
+        break;
+      }
+      if (next >= 92)
+        next--;
+      if (next >= 34)
+        next--;
+      let digit = next - 32;
+      if (digit >= 46) {
+        digit -= 46;
+        stop = true;
+      }
+      value += digit;
+      if (stop)
+        break;
+      value *= 46;
+    }
+    if (array)
+      array[out++] = value;
+    else
+      array = new Type(value);
+  }
+  return array;
+}
+var CachedToken = class {
+  constructor() {
+    this.start = -1;
+    this.value = -1;
+    this.end = -1;
+    this.extended = -1;
+    this.lookAhead = 0;
+    this.mask = 0;
+    this.context = 0;
+  }
+};
+var nullToken = new CachedToken();
+var InputStream = class {
+  /// @internal
+  constructor(input, ranges) {
+    this.input = input;
+    this.ranges = ranges;
+    this.chunk = "";
+    this.chunkOff = 0;
+    this.chunk2 = "";
+    this.chunk2Pos = 0;
+    this.next = -1;
+    this.token = nullToken;
+    this.rangeIndex = 0;
+    this.pos = this.chunkPos = ranges[0].from;
+    this.range = ranges[0];
+    this.end = ranges[ranges.length - 1].to;
+    this.readNext();
+  }
+  /// @internal
+  resolveOffset(offset, assoc) {
+    let range = this.range, index = this.rangeIndex;
+    let pos = this.pos + offset;
+    while (pos < range.from) {
+      if (!index)
+        return null;
+      let next = this.ranges[--index];
+      pos -= range.from - next.to;
+      range = next;
+    }
+    while (assoc < 0 ? pos > range.to : pos >= range.to) {
+      if (index == this.ranges.length - 1)
+        return null;
+      let next = this.ranges[++index];
+      pos += next.from - range.to;
+      range = next;
+    }
+    return pos;
+  }
+  /// @internal
+  clipPos(pos) {
+    if (pos >= this.range.from && pos < this.range.to)
+      return pos;
+    for (let range of this.ranges)
+      if (range.to > pos)
+        return Math.max(pos, range.from);
+    return this.end;
+  }
+  /// Look at a code unit near the stream position. `.peek(0)` equals
+  /// `.next`, `.peek(-1)` gives you the previous character, and so
+  /// on.
+  ///
+  /// Note that looking around during tokenizing creates dependencies
+  /// on potentially far-away content, which may reduce the
+  /// effectiveness incremental parsing—when looking forward—or even
+  /// cause invalid reparses when looking backward more than 25 code
+  /// units, since the library does not track lookbehind.
+  peek(offset) {
+    let idx = this.chunkOff + offset, pos, result;
+    if (idx >= 0 && idx < this.chunk.length) {
+      pos = this.pos + offset;
+      result = this.chunk.charCodeAt(idx);
+    } else {
+      let resolved = this.resolveOffset(offset, 1);
+      if (resolved == null)
+        return -1;
+      pos = resolved;
+      if (pos >= this.chunk2Pos && pos < this.chunk2Pos + this.chunk2.length) {
+        result = this.chunk2.charCodeAt(pos - this.chunk2Pos);
+      } else {
+        let i = this.rangeIndex, range = this.range;
+        while (range.to <= pos)
+          range = this.ranges[++i];
+        this.chunk2 = this.input.chunk(this.chunk2Pos = pos);
+        if (pos + this.chunk2.length > range.to)
+          this.chunk2 = this.chunk2.slice(0, range.to - pos);
+        result = this.chunk2.charCodeAt(0);
+      }
+    }
+    if (pos >= this.token.lookAhead)
+      this.token.lookAhead = pos + 1;
+    return result;
+  }
+  /// Accept a token. By default, the end of the token is set to the
+  /// current stream position, but you can pass an offset (relative to
+  /// the stream position) to change that.
+  acceptToken(token, endOffset = 0) {
+    let end = endOffset ? this.resolveOffset(endOffset, -1) : this.pos;
+    if (end == null || end < this.token.start)
+      throw new RangeError("Token end out of bounds");
+    this.token.value = token;
+    this.token.end = end;
+  }
+  getChunk() {
+    if (this.pos >= this.chunk2Pos && this.pos < this.chunk2Pos + this.chunk2.length) {
+      let { chunk, chunkPos } = this;
+      this.chunk = this.chunk2;
+      this.chunkPos = this.chunk2Pos;
+      this.chunk2 = chunk;
+      this.chunk2Pos = chunkPos;
+      this.chunkOff = this.pos - this.chunkPos;
+    } else {
+      this.chunk2 = this.chunk;
+      this.chunk2Pos = this.chunkPos;
+      let nextChunk = this.input.chunk(this.pos);
+      let end = this.pos + nextChunk.length;
+      this.chunk = end > this.range.to ? nextChunk.slice(0, this.range.to - this.pos) : nextChunk;
+      this.chunkPos = this.pos;
+      this.chunkOff = 0;
+    }
+  }
+  readNext() {
+    if (this.chunkOff >= this.chunk.length) {
+      this.getChunk();
+      if (this.chunkOff == this.chunk.length)
+        return this.next = -1;
+    }
+    return this.next = this.chunk.charCodeAt(this.chunkOff);
+  }
+  /// Move the stream forward N (defaults to 1) code units. Returns
+  /// the new value of [`next`](#lr.InputStream.next).
+  advance(n = 1) {
+    this.chunkOff += n;
+    while (this.pos + n >= this.range.to) {
+      if (this.rangeIndex == this.ranges.length - 1)
+        return this.setDone();
+      n -= this.range.to - this.pos;
+      this.range = this.ranges[++this.rangeIndex];
+      this.pos = this.range.from;
+    }
+    this.pos += n;
+    if (this.pos >= this.token.lookAhead)
+      this.token.lookAhead = this.pos + 1;
+    return this.readNext();
+  }
+  setDone() {
+    this.pos = this.chunkPos = this.end;
+    this.range = this.ranges[this.rangeIndex = this.ranges.length - 1];
+    this.chunk = "";
+    return this.next = -1;
+  }
+  /// @internal
+  reset(pos, token) {
+    if (token) {
+      this.token = token;
+      token.start = pos;
+      token.lookAhead = pos + 1;
+      token.value = token.extended = -1;
+    } else {
+      this.token = nullToken;
+    }
+    if (this.pos != pos) {
+      this.pos = pos;
+      if (pos == this.end) {
+        this.setDone();
+        return this;
+      }
+      while (pos < this.range.from)
+        this.range = this.ranges[--this.rangeIndex];
+      while (pos >= this.range.to)
+        this.range = this.ranges[++this.rangeIndex];
+      if (pos >= this.chunkPos && pos < this.chunkPos + this.chunk.length) {
+        this.chunkOff = pos - this.chunkPos;
+      } else {
+        this.chunk = "";
+        this.chunkOff = 0;
+      }
+      this.readNext();
+    }
+    return this;
+  }
+  /// @internal
+  read(from, to) {
+    if (from >= this.chunkPos && to <= this.chunkPos + this.chunk.length)
+      return this.chunk.slice(from - this.chunkPos, to - this.chunkPos);
+    if (from >= this.chunk2Pos && to <= this.chunk2Pos + this.chunk2.length)
+      return this.chunk2.slice(from - this.chunk2Pos, to - this.chunk2Pos);
+    if (from >= this.range.from && to <= this.range.to)
+      return this.input.read(from, to);
+    let result = "";
+    for (let r2 of this.ranges) {
+      if (r2.from >= to)
+        break;
+      if (r2.to > from)
+        result += this.input.read(Math.max(r2.from, from), Math.min(r2.to, to));
+    }
+    return result;
+  }
+};
+var TokenGroup = class {
+  constructor(data, id) {
+    this.data = data;
+    this.id = id;
+  }
+  token(input, stack) {
+    let { parser: parser2 } = stack.p;
+    readToken(this.data, input, stack, this.id, parser2.data, parser2.tokenPrecTable);
+  }
+};
+TokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false;
+var LocalTokenGroup = class {
+  constructor(data, precTable, elseToken) {
+    this.precTable = precTable;
+    this.elseToken = elseToken;
+    this.data = typeof data == "string" ? decodeArray(data) : data;
+  }
+  token(input, stack) {
+    let start = input.pos, skipped = 0;
+    for (; ; ) {
+      readToken(this.data, input, stack, 0, this.data, this.precTable);
+      if (input.token.value > -1)
+        break;
+      if (this.elseToken == null)
+        return;
+      if (input.next < 0)
+        break;
+      input.advance();
+      input.reset(input.pos, input.token);
+      skipped++;
+    }
+    if (skipped) {
+      input.reset(start, input.token);
+      input.acceptToken(this.elseToken, skipped);
+    }
+  }
+};
+LocalTokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false;
+function readToken(data, input, stack, group, precTable, precOffset) {
+  let state = 0, groupMask = 1 << group, { dialect } = stack.p.parser;
+  scan:
+    for (; ; ) {
+      if ((groupMask & data[state]) == 0)
+        break;
+      let accEnd = data[state + 1];
+      for (let i = state + 3; i < accEnd; i += 2)
+        if ((data[i + 1] & groupMask) > 0) {
+          let term = data[i];
+          if (dialect.allows(term) && (input.token.value == -1 || input.token.value == term || overrides(term, input.token.value, precTable, precOffset))) {
+            input.acceptToken(term);
+            break;
+          }
+        }
+      let next = input.next, low = 0, high = data[state + 2];
+      if (input.next < 0 && high > low && data[accEnd + high * 3 - 3] == 65535 && data[accEnd + high * 3 - 3] == 65535) {
+        state = data[accEnd + high * 3 - 1];
+        continue scan;
+      }
+      for (; low < high; ) {
+        let mid = low + high >> 1;
+        let index = accEnd + mid + (mid << 1);
+        let from = data[index], to = data[index + 1] || 65536;
+        if (next < from)
+          high = mid;
+        else if (next >= to)
+          low = mid + 1;
+        else {
+          state = data[index + 2];
+          input.advance();
+          continue scan;
+        }
+      }
+      break;
+    }
+}
+function findOffset(data, start, term) {
+  for (let i = start, next; (next = data[i]) != 65535; i++)
+    if (next == term)
+      return i - start;
+  return -1;
+}
+function overrides(token, prev, tableData, tableOffset) {
+  let iPrev = findOffset(tableData, tableOffset, prev);
+  return iPrev < 0 || findOffset(tableData, tableOffset, token) < iPrev;
+}
+var verbose = typeof process != "undefined" && process.env && /\bparse\b/.test(process.env.LOG);
+var stackIDs = null;
+var Safety;
+(function(Safety2) {
+  Safety2[Safety2["Margin"] = 25] = "Margin";
+})(Safety || (Safety = {}));
+function cutAt(tree, pos, side) {
+  let cursor = tree.cursor(IterMode.IncludeAnonymous);
+  cursor.moveTo(pos);
+  for (; ; ) {
+    if (!(side < 0 ? cursor.childBefore(pos) : cursor.childAfter(pos)))
+      for (; ; ) {
+        if ((side < 0 ? cursor.to < pos : cursor.from > pos) && !cursor.type.isError)
+          return side < 0 ? Math.max(0, Math.min(
+            cursor.to - 1,
+            pos - 25
+            /* Safety.Margin */
+          )) : Math.min(tree.length, Math.max(
+            cursor.from + 1,
+            pos + 25
+            /* Safety.Margin */
+          ));
+        if (side < 0 ? cursor.prevSibling() : cursor.nextSibling())
+          break;
+        if (!cursor.parent())
+          return side < 0 ? 0 : tree.length;
+      }
+  }
+}
+var FragmentCursor = class {
+  constructor(fragments, nodeSet) {
+    this.fragments = fragments;
+    this.nodeSet = nodeSet;
+    this.i = 0;
+    this.fragment = null;
+    this.safeFrom = -1;
+    this.safeTo = -1;
+    this.trees = [];
+    this.start = [];
+    this.index = [];
+    this.nextFragment();
+  }
+  nextFragment() {
+    let fr = this.fragment = this.i == this.fragments.length ? null : this.fragments[this.i++];
+    if (fr) {
+      this.safeFrom = fr.openStart ? cutAt(fr.tree, fr.from + fr.offset, 1) - fr.offset : fr.from;
+      this.safeTo = fr.openEnd ? cutAt(fr.tree, fr.to + fr.offset, -1) - fr.offset : fr.to;
+      while (this.trees.length) {
+        this.trees.pop();
+        this.start.pop();
+        this.index.pop();
+      }
+      this.trees.push(fr.tree);
+      this.start.push(-fr.offset);
+      this.index.push(0);
+      this.nextStart = this.safeFrom;
+    } else {
+      this.nextStart = 1e9;
+    }
+  }
+  // `pos` must be >= any previously given `pos` for this cursor
+  nodeAt(pos) {
+    if (pos < this.nextStart)
+      return null;
+    while (this.fragment && this.safeTo <= pos)
+      this.nextFragment();
+    if (!this.fragment)
+      return null;
+    for (; ; ) {
+      let last = this.trees.length - 1;
+      if (last < 0) {
+        this.nextFragment();
+        return null;
+      }
+      let top = this.trees[last], index = this.index[last];
+      if (index == top.children.length) {
+        this.trees.pop();
+        this.start.pop();
+        this.index.pop();
+        continue;
+      }
+      let next = top.children[index];
+      let start = this.start[last] + top.positions[index];
+      if (start > pos) {
+        this.nextStart = start;
+        return null;
+      }
+      if (next instanceof Tree) {
+        if (start == pos) {
+          if (start < this.safeFrom)
+            return null;
+          let end = start + next.length;
+          if (end <= this.safeTo) {
+            let lookAhead = next.prop(NodeProp.lookAhead);
+            if (!lookAhead || end + lookAhead < this.fragment.to)
+              return next;
+          }
+        }
+        this.index[last]++;
+        if (start + next.length >= Math.max(this.safeFrom, pos)) {
+          this.trees.push(next);
+          this.start.push(start);
+          this.index.push(0);
+        }
+      } else {
+        this.index[last]++;
+        this.nextStart = start + next.length;
+      }
+    }
+  }
+};
+var TokenCache = class {
+  constructor(parser2, stream) {
+    this.stream = stream;
+    this.tokens = [];
+    this.mainToken = null;
+    this.actions = [];
+    this.tokens = parser2.tokenizers.map((_) => new CachedToken());
+  }
+  getActions(stack) {
+    let actionIndex = 0;
+    let main = null;
+    let { parser: parser2 } = stack.p, { tokenizers } = parser2;
+    let mask = parser2.stateSlot(
+      stack.state,
+      3
+      /* ParseState.TokenizerMask */
+    );
+    let context = stack.curContext ? stack.curContext.hash : 0;
+    let lookAhead = 0;
+    for (let i = 0; i < tokenizers.length; i++) {
+      if ((1 << i & mask) == 0)
+        continue;
+      let tokenizer = tokenizers[i], token = this.tokens[i];
+      if (main && !tokenizer.fallback)
+        continue;
+      if (tokenizer.contextual || token.start != stack.pos || token.mask != mask || token.context != context) {
+        this.updateCachedToken(token, tokenizer, stack);
+        token.mask = mask;
+        token.context = context;
+      }
+      if (token.lookAhead > token.end + 25)
+        lookAhead = Math.max(token.lookAhead, lookAhead);
+      if (token.value != 0) {
+        let startIndex = actionIndex;
+        if (token.extended > -1)
+          actionIndex = this.addActions(stack, token.extended, token.end, actionIndex);
+        actionIndex = this.addActions(stack, token.value, token.end, actionIndex);
+        if (!tokenizer.extend) {
+          main = token;
+          if (actionIndex > startIndex)
+            break;
+        }
+      }
+    }
+    while (this.actions.length > actionIndex)
+      this.actions.pop();
+    if (lookAhead)
+      stack.setLookAhead(lookAhead);
+    if (!main && stack.pos == this.stream.end) {
+      main = new CachedToken();
+      main.value = stack.p.parser.eofTerm;
+      main.start = main.end = stack.pos;
+      actionIndex = this.addActions(stack, main.value, main.end, actionIndex);
+    }
+    this.mainToken = main;
+    return this.actions;
+  }
+  getMainToken(stack) {
+    if (this.mainToken)
+      return this.mainToken;
+    let main = new CachedToken(), { pos, p } = stack;
+    main.start = pos;
+    main.end = Math.min(pos + 1, p.stream.end);
+    main.value = pos == p.stream.end ? p.parser.eofTerm : 0;
+    return main;
+  }
+  updateCachedToken(token, tokenizer, stack) {
+    let start = this.stream.clipPos(stack.pos);
+    tokenizer.token(this.stream.reset(start, token), stack);
+    if (token.value > -1) {
+      let { parser: parser2 } = stack.p;
+      for (let i = 0; i < parser2.specialized.length; i++)
+        if (parser2.specialized[i] == token.value) {
+          let result = parser2.specializers[i](this.stream.read(token.start, token.end), stack);
+          if (result >= 0 && stack.p.parser.dialect.allows(result >> 1)) {
+            if ((result & 1) == 0)
+              token.value = result >> 1;
+            else
+              token.extended = result >> 1;
+            break;
+          }
+        }
+    } else {
+      token.value = 0;
+      token.end = this.stream.clipPos(start + 1);
+    }
+  }
+  putAction(action, token, end, index) {
+    for (let i = 0; i < index; i += 3)
+      if (this.actions[i] == action)
+        return index;
+    this.actions[index++] = action;
+    this.actions[index++] = token;
+    this.actions[index++] = end;
+    return index;
+  }
+  addActions(stack, token, end, index) {
+    let { state } = stack, { parser: parser2 } = stack.p, { data } = parser2;
+    for (let set = 0; set < 2; set++) {
+      for (let i = parser2.stateSlot(
+        state,
+        set ? 2 : 1
+        /* ParseState.Actions */
+      ); ; i += 3) {
+        if (data[i] == 65535) {
+          if (data[i + 1] == 1) {
+            i = pair(data, i + 2);
+          } else {
+            if (index == 0 && data[i + 1] == 2)
+              index = this.putAction(pair(data, i + 2), token, end, index);
+            break;
+          }
+        }
+        if (data[i] == token)
+          index = this.putAction(pair(data, i + 1), token, end, index);
+      }
+    }
+    return index;
+  }
+};
+var Rec;
+(function(Rec2) {
+  Rec2[Rec2["Distance"] = 5] = "Distance";
+  Rec2[Rec2["MaxRemainingPerStep"] = 3] = "MaxRemainingPerStep";
+  Rec2[Rec2["MinBufferLengthPrune"] = 500] = "MinBufferLengthPrune";
+  Rec2[Rec2["ForceReduceLimit"] = 10] = "ForceReduceLimit";
+  Rec2[Rec2["CutDepth"] = 15e3] = "CutDepth";
+  Rec2[Rec2["CutTo"] = 9e3] = "CutTo";
+  Rec2[Rec2["MaxLeftAssociativeReductionCount"] = 300] = "MaxLeftAssociativeReductionCount";
+  Rec2[Rec2["MaxStackCount"] = 12] = "MaxStackCount";
+})(Rec || (Rec = {}));
+var Parse = class {
+  constructor(parser2, input, fragments, ranges) {
+    this.parser = parser2;
+    this.input = input;
+    this.ranges = ranges;
+    this.recovering = 0;
+    this.nextStackID = 9812;
+    this.minStackPos = 0;
+    this.reused = [];
+    this.stoppedAt = null;
+    this.lastBigReductionStart = -1;
+    this.lastBigReductionSize = 0;
+    this.bigReductionCount = 0;
+    this.stream = new InputStream(input, ranges);
+    this.tokens = new TokenCache(parser2, this.stream);
+    this.topTerm = parser2.top[1];
+    let { from } = ranges[0];
+    this.stacks = [Stack.start(this, parser2.top[0], from)];
+    this.fragments = fragments.length && this.stream.end - from > parser2.bufferLength * 4 ? new FragmentCursor(fragments, parser2.nodeSet) : null;
+  }
+  get parsedPos() {
+    return this.minStackPos;
+  }
+  // Move the parser forward. This will process all parse stacks at
+  // `this.pos` and try to advance them to a further position. If no
+  // stack for such a position is found, it'll start error-recovery.
+  //
+  // When the parse is finished, this will return a syntax tree. When
+  // not, it returns `null`.
+  advance() {
+    let stacks = this.stacks, pos = this.minStackPos;
+    let newStacks = this.stacks = [];
+    let stopped, stoppedTokens;
+    if (this.bigReductionCount > 300 && stacks.length == 1) {
+      let [s] = stacks;
+      while (s.forceReduce() && s.stack.length && s.stack[s.stack.length - 2] >= this.lastBigReductionStart) {
+      }
+      this.bigReductionCount = this.lastBigReductionSize = 0;
+    }
+    for (let i = 0; i < stacks.length; i++) {
+      let stack = stacks[i];
+      for (; ; ) {
+        this.tokens.mainToken = null;
+        if (stack.pos > pos) {
+          newStacks.push(stack);
+        } else if (this.advanceStack(stack, newStacks, stacks)) {
+          continue;
+        } else {
+          if (!stopped) {
+            stopped = [];
+            stoppedTokens = [];
+          }
+          stopped.push(stack);
+          let tok = this.tokens.getMainToken(stack);
+          stoppedTokens.push(tok.value, tok.end);
+        }
+        break;
+      }
+    }
+    if (!newStacks.length) {
+      let finished = stopped && findFinished(stopped);
+      if (finished)
+        return this.stackToTree(finished);
+      if (this.parser.strict) {
+        if (verbose && stopped)
+          console.log("Stuck with token " + (this.tokens.mainToken ? this.parser.getName(this.tokens.mainToken.value) : "none"));
+        throw new SyntaxError("No parse at " + pos);
+      }
+      if (!this.recovering)
+        this.recovering = 5;
+    }
+    if (this.recovering && stopped) {
+      let finished = this.stoppedAt != null && stopped[0].pos > this.stoppedAt ? stopped[0] : this.runRecovery(stopped, stoppedTokens, newStacks);
+      if (finished)
+        return this.stackToTree(finished.forceAll());
+    }
+    if (this.recovering) {
+      let maxRemaining = this.recovering == 1 ? 1 : this.recovering * 3;
+      if (newStacks.length > maxRemaining) {
+        newStacks.sort((a, b) => b.score - a.score);
+        while (newStacks.length > maxRemaining)
+          newStacks.pop();
+      }
+      if (newStacks.some((s) => s.reducePos > pos))
+        this.recovering--;
+    } else if (newStacks.length > 1) {
+      outer:
+        for (let i = 0; i < newStacks.length - 1; i++) {
+          let stack = newStacks[i];
+          for (let j = i + 1; j < newStacks.length; j++) {
+            let other = newStacks[j];
+            if (stack.sameState(other) || stack.buffer.length > 500 && other.buffer.length > 500) {
+              if ((stack.score - other.score || stack.buffer.length - other.buffer.length) > 0) {
+                newStacks.splice(j--, 1);
+              } else {
+                newStacks.splice(i--, 1);
+                continue outer;
+              }
+            }
+          }
+        }
+      if (newStacks.length > 12)
+        newStacks.splice(
+          12,
+          newStacks.length - 12
+          /* Rec.MaxStackCount */
+        );
+    }
+    this.minStackPos = newStacks[0].pos;
+    for (let i = 1; i < newStacks.length; i++)
+      if (newStacks[i].pos < this.minStackPos)
+        this.minStackPos = newStacks[i].pos;
+    return null;
+  }
+  stopAt(pos) {
+    if (this.stoppedAt != null && this.stoppedAt < pos)
+      throw new RangeError("Can't move stoppedAt forward");
+    this.stoppedAt = pos;
+  }
+  // Returns an updated version of the given stack, or null if the
+  // stack can't advance normally. When `split` and `stacks` are
+  // given, stacks split off by ambiguous operations will be pushed to
+  // `split`, or added to `stacks` if they move `pos` forward.
+  advanceStack(stack, stacks, split) {
+    let start = stack.pos, { parser: parser2 } = this;
+    let base = verbose ? this.stackID(stack) + " -> " : "";
+    if (this.stoppedAt != null && start > this.stoppedAt)
+      return stack.forceReduce() ? stack : null;
+    if (this.fragments) {
+      let strictCx = stack.curContext && stack.curContext.tracker.strict, cxHash = strictCx ? stack.curContext.hash : 0;
+      for (let cached = this.fragments.nodeAt(start); cached; ) {
+        let match = this.parser.nodeSet.types[cached.type.id] == cached.type ? parser2.getGoto(stack.state, cached.type.id) : -1;
+        if (match > -1 && cached.length && (!strictCx || (cached.prop(NodeProp.contextHash) || 0) == cxHash)) {
+          stack.useNode(cached, match);
+          if (verbose)
+            console.log(base + this.stackID(stack) + ` (via reuse of ${parser2.getName(cached.type.id)})`);
+          return true;
+        }
+        if (!(cached instanceof Tree) || cached.children.length == 0 || cached.positions[0] > 0)
+          break;
+        let inner = cached.children[0];
+        if (inner instanceof Tree && cached.positions[0] == 0)
+          cached = inner;
+        else
+          break;
+      }
+    }
+    let defaultReduce = parser2.stateSlot(
+      stack.state,
+      4
+      /* ParseState.DefaultReduce */
+    );
+    if (defaultReduce > 0) {
+      stack.reduce(defaultReduce);
+      if (verbose)
+        console.log(base + this.stackID(stack) + ` (via always-reduce ${parser2.getName(
+          defaultReduce & 65535
+          /* Action.ValueMask */
+        )})`);
+      return true;
+    }
+    if (stack.stack.length >= 15e3) {
+      while (stack.stack.length > 9e3 && stack.forceReduce()) {
+      }
+    }
+    let actions = this.tokens.getActions(stack);
+    for (let i = 0; i < actions.length; ) {
+      let action = actions[i++], term = actions[i++], end = actions[i++];
+      let last = i == actions.length || !split;
+      let localStack = last ? stack : stack.split();
+      localStack.apply(action, term, end);
+      if (verbose)
+        console.log(base + this.stackID(localStack) + ` (via ${(action & 65536) == 0 ? "shift" : `reduce of ${parser2.getName(
+          action & 65535
+          /* Action.ValueMask */
+        )}`} for ${parser2.getName(term)} @ ${start}${localStack == stack ? "" : ", split"})`);
+      if (last)
+        return true;
+      else if (localStack.pos > start)
+        stacks.push(localStack);
+      else
+        split.push(localStack);
+    }
+    return false;
+  }
+  // Advance a given stack forward as far as it will go. Returns the
+  // (possibly updated) stack if it got stuck, or null if it moved
+  // forward and was given to `pushStackDedup`.
+  advanceFully(stack, newStacks) {
+    let pos = stack.pos;
+    for (; ; ) {
+      if (!this.advanceStack(stack, null, null))
+        return false;
+      if (stack.pos > pos) {
+        pushStackDedup(stack, newStacks);
+        return true;
+      }
+    }
+  }
+  runRecovery(stacks, tokens, newStacks) {
+    let finished = null, restarted = false;
+    for (let i = 0; i < stacks.length; i++) {
+      let stack = stacks[i], token = tokens[i << 1], tokenEnd = tokens[(i << 1) + 1];
+      let base = verbose ? this.stackID(stack) + " -> " : "";
+      if (stack.deadEnd) {
+        if (restarted)
+          continue;
+        restarted = true;
+        stack.restart();
+        if (verbose)
+          console.log(base + this.stackID(stack) + " (restarted)");
+        let done = this.advanceFully(stack, newStacks);
+        if (done)
+          continue;
+      }
+      let force = stack.split(), forceBase = base;
+      for (let j = 0; force.forceReduce() && j < 10; j++) {
+        if (verbose)
+          console.log(forceBase + this.stackID(force) + " (via force-reduce)");
+        let done = this.advanceFully(force, newStacks);
+        if (done)
+          break;
+        if (verbose)
+          forceBase = this.stackID(force) + " -> ";
+      }
+      for (let insert of stack.recoverByInsert(token)) {
+        if (verbose)
+          console.log(base + this.stackID(insert) + " (via recover-insert)");
+        this.advanceFully(insert, newStacks);
+      }
+      if (this.stream.end > stack.pos) {
+        if (tokenEnd == stack.pos) {
+          tokenEnd++;
+          token = 0;
+        }
+        stack.recoverByDelete(token, tokenEnd);
+        if (verbose)
+          console.log(base + this.stackID(stack) + ` (via recover-delete ${this.parser.getName(token)})`);
+        pushStackDedup(stack, newStacks);
+      } else if (!finished || finished.score < stack.score) {
+        finished = stack;
+      }
+    }
+    return finished;
+  }
+  // Convert the stack's buffer to a syntax tree.
+  stackToTree(stack) {
+    stack.close();
+    return Tree.build({
+      buffer: StackBufferCursor.create(stack),
+      nodeSet: this.parser.nodeSet,
+      topID: this.topTerm,
+      maxBufferLength: this.parser.bufferLength,
+      reused: this.reused,
+      start: this.ranges[0].from,
+      length: stack.pos - this.ranges[0].from,
+      minRepeatType: this.parser.minRepeatTerm
+    });
+  }
+  stackID(stack) {
+    let id = (stackIDs || (stackIDs = /* @__PURE__ */ new WeakMap())).get(stack);
+    if (!id)
+      stackIDs.set(stack, id = String.fromCodePoint(this.nextStackID++));
+    return id + stack;
+  }
+};
+function pushStackDedup(stack, newStacks) {
+  for (let i = 0; i < newStacks.length; i++) {
+    let other = newStacks[i];
+    if (other.pos == stack.pos && other.sameState(stack)) {
+      if (newStacks[i].score < stack.score)
+        newStacks[i] = stack;
+      return;
+    }
+  }
+  newStacks.push(stack);
 }
-`;Le(Bo);var $o=e=>(...o)=>[e,...o].join("-"),zo=$o("saltIcon"),Xo=1,We=(0,Ue.forwardRef)(function({children:o,className:r,size:t=Xo,style:n,...i},s){let p={...n,"--saltIcon-size-multiplier":`${t}`};return(0,Se.jsx)("svg",{className:Me(zo(),r),style:p,role:"img",...i,ref:s,children:(0,Se.jsx)("g",{"aria-hidden":!0,children:o})})});var _=require("react/jsx-runtime"),He=require("react");var Fe=(0,He.forwardRef)(function(o,r){return(0,_.jsxs)(We,{"data-testid":"DeleteIcon","aria-label":"delete",viewBox:"0 0 12 12",ref:r,...o,children:[(0,_.jsx)("path",{d:"M5 4v6H4V4h1Zm2 0v6H6V4h1Z"}),(0,_.jsx)("path",{fillRule:"evenodd",d:"M4 0a1 1 0 0 0-1 1v1H0v1h1v7a2 2 0 0 0 2 2h5.25A1.75 1.75 0 0 0 10 10.25V3h1V2H8V1a1 1 0 0 0-1-1H4Zm5 3H2v7a1 1 0 0 0 1 1h5.25a.75.75 0 0 0 .75-.75V3ZM7 2H4v-.5a.5.5 0 0 1 .5-.5h2a.5.5 0 0 1 .5.5V2Z",clipRule:"evenodd"})]})});var B=require("@heswell/salt-lab");var ie=require("@vuu-ui/vuu-utils");var _o=new Set(["=","!=",">",">=","<","<=","starts","ends"]),he=e=>e!==void 0&&e.name!==void 0,k=e=>e!==void 0&&_o.has(e.op),Go=e=>e!==void 0&&(k(e)||D(e)),D=e=>e!==void 0&&e.op==="in",W=e=>e.op==="in",re=e=>e.op==="and",Ce=e=>e.op==="or";function V(e){return e!==void 0&&(e.op==="and"||e.op==="or")}var h="and",te="=",jo=">",Zo="<",Be="or",Oe="starts",Yo="ends",$e="in",ze=(e,o=[])=>(e&&(V(e)?e.filters.forEach(r=>o.push(...ze(r))):o.push(e)),o),qo={combineWith:"and"},G=(e,o,{combineWith:r=h}=qo)=>{var t;if(be(o))V(o)||(e=ve(e,{name:o.column}));else if(Jo(o))return V(o),ve(e,{name:(t=o.column)!=null?t:""});if(!e)return o;if(!o)return e;if(e.op===h&&o.op===h)return{op:h,filters:rr(e.filters,o.filters)};if(e.op===h){let n=er(e.filters,o);return n.length>1?{op:h,filters:n}:n[0]}return o.op===h?{op:h,filters:o.filters.concat(e)}:ne(e,o,!0)?o:Ge(e,o)?or(e,o):{op:r,filters:[e,o]}},be=e=>e?W(e)&&e.values.length===0?!0:re(e)&&e.filters.some(o=>be(o)):!1,Ko=e=>typeof e=="string"?`"${e}"`:e,H=e=>V(e)?e.filters.map(o=>H(o)).join(` ${e.op} `):D(e)?`${e.column} ${e.op} [${e.values.join(",")}]`:`${e.column} ${e.op} ${Ko(e.value)}`,Jo=e=>e?e.op===Oe&&e.value===""?!0:e.op===Oe&&e.value==="":!1,er=(e,o)=>e.concat(o),or=(e,o)=>be(o)?o:W(e)&&W(o)?{...e,values:[...e.values,...o.values.filter(r=>!e.values.includes(r))]}:W(e)&&o.op===te?{...e,values:e.values.concat([o.value])}:e.op===te&&o.op===te?{column:e.column,op:$e,values:[e.value,o.value]}:o,rr=(e,o)=>{let r=({op:i},{op:s})=>i===s||i[0]===s[0],t=(i,s)=>i.column===s.column&&r(i,s),n=i=>o.some(s=>t(i,s))===!1;return e.filter(n).concat(o)},tr=(e,o)=>{if(V(o)){let[r,t]=o.filters;if(r.column===e.name)return[t,H(t)];if(t.column===e.name)return[r,H(r)]}return[void 0,""]},nr=(e,o)=>{if(ne(e,o,!0))return null;if(e.op!==h)throw Error(`removeFilter cannot remove ${JSON.stringify(o)} from ${JSON.stringify(e)}`);let r=e.filters.filter(t=>!ne(t,o));return r.length>0?{type:h,filters:r}:null},ir=(e,o)=>{if(!e)return[null,null];if(e.column===o)return[e,null];if(e.op!==h)return[null,e];let[[r=null],t]=(0,ie.partition)(e.filters,n=>n.column===o);return t.length===1?[r,t[0]]:[r,{op:h,filters:t}]},Xe=(e,o)=>V(e)?{op:e.op,filters:e.filters.map(r=>Xe(r,o))}:{...e,column:o},_e=(e,o)=>{if(!e)return!1;let{op:r,column:t}=e;switch(r){case h:case Be:return e.filters!=null&&e.filters.some(n=>_e(n,o));default:return t===o.name}},ve=(e,o)=>{let r=o.name;if(e&&e.column!==r){if(re(e)||Ce(e)){let{op:t}=e,i=e.filters.filter(s=>s.column!==r);switch(i.length){case 0:return;case 1:return i[0];default:return{op:t,filters:i}}}return e}},Ge=(e,o)=>e.column===o.column&&(e.op==="="||e.op==="in")&&(o.op==="="||o.op==="in"),sr=(e,o)=>{if(e===o)return!0;if(e.length===o.length){let r=e.slice().sort(),t=o.slice().sort();return r.join("|")===t.join("|")}return!1},ne=(e,o,r=!1)=>r?e&&o&&Ge(e,o)?e.op===o.op&&(k(e)&&k(o)&&e.value===o.value||D(e)&&D(o)&&sr(e.values,o.values)):!1:!0,je=(e,o,r)=>{if(e&&o){if(r==="replace")return o;if(e.op==="and")return{...e,filters:e.filters.concat(o)};let{column:t}=o;if(t&&(o.column?(0,ie.extractFilterForColumn)(e,t):void 0)&&t){let i=ve(e,{name:t});return je(i,o,"add")}return{op:"and",filters:[e,o]}}return o||e};var j=e=>/\.\.\.$/.test(e),Ze=(e,o,r)=>{if(o.length!==0){if(r){let t=o[0].substring(0,o[0].length-3);return{column:e,op:"starts",value:`"${t}"`}}return{column:e,op:"in",values:o.map(t=>`"${t}"`)}}},ye=(e,o,r)=>{let t=o===void 0?void 0:{column:e,op:">",value:o-1},n=r===void 0?void 0:{column:e,op:"<",value:r+1};return n===void 0?t:G(t,n,{combineWith:"and"})};var M=require("react/jsx-runtime"),Ye=({defaultTypeaheadParams:e,filterValues:o,onChange:r})=>{var s,p;let t=e[1],n=f=>{let l=parseFloat(f.target.value),u={start:isNaN(l)?void 0:l,end:o==null?void 0:o.end},m=ye(t,u.start,u.end);r(u,m)},i=f=>{let l=parseFloat(f.target.value),u={start:o==null?void 0:o.start,end:isNaN(l)?void 0:l},m=ye(t,u.start,u.end);r(u,m)};return(0,M.jsxs)("div",{style:{display:"flex",flexDirection:"row"},children:[(0,M.jsx)(B.ToolbarField,{label:"From",children:(0,M.jsx)(B.Input,{onChange:n,value:((s=o==null?void 0:o.start)==null?void 0:s.toString())||"",type:"number"})}),(0,M.jsx)(B.ToolbarField,{label:"To",children:(0,M.jsx)(B.Input,{onChange:i,value:((p=o==null?void 0:o.end)==null?void 0:p.toString())||"",type:"number"})})]})};var Q=require("react"),qe=require("@vuu-ui/vuu-data"),Ke=require("@heswell/salt-lab");var eo=require("react/jsx-runtime"),Je=({defaultTypeaheadParams:e,filterValues:o=[],onChange:r})=>{let[t,n]=e,[i,s]=(0,Q.useState)(""),[p,f]=(0,Q.useState)([]),l=(0,qe.useTypeaheadSuggestions)();(0,Q.useEffect)(()=>{let a=i?[t,n,i]:e,c=!0;return l(a).then(x=>{c&&(j(o[0])&&x.unshift(o[0]),i&&x.unshift(`${i}...`),x.concat(o),f(x))}),()=>{c=!1}},[o,i,n,t,l,e]);let u=(0,Q.useCallback)(a=>{let c=a.target.value;s(c)},[]),m=(0,Q.useCallback)((a,c)=>{if(s(""),c===null)return;c.some(j)&&(c=c.filter(j).slice(-1));let x=Ze(n,c,j(c[0]));r(c,x)},[n,r]);return(0,eo.jsx)(Ke.ComboBoxDeprecated,{multiSelect:!0,onInputChange:u,onChange:m,source:p,style:{minWidth:200},inputValue:i,selectedItem:o},n)};var oo=require("react"),se=require("@heswell/salt-lab"),Z=require("react/jsx-runtime"),ro=e=>(0,Z.jsx)(lr,{...e}),lr=(0,oo.memo)(function({item:o,itemTextHighlightPattern:r,...t}){return(0,Z.jsx)(se.ListItem,{...t,children:(0,Z.jsx)("span",{style:{marginLeft:10},children:(0,Z.jsx)(se.Highlighter,{matchPattern:r,text:o==null?void 0:o.name})})})});var w=require("react");var Pe=(e,o,r)=>e.filter(t=>t[r]!==o[r]).concat(o),to=e=>{var C,y;let[o,r]=(0,w.useState)(""),[t,n]=(0,w.useState)([]),[i,s]=(0,w.useState)([]),[p,f]=(0,w.useState)([]),l=()=>{r(""),s([]),f([]),n([]),e("")},u=(0,w.useCallback)(g=>{let F=Pe(t,{column:o,filter:g},"column");n(F);let N=F.map(U=>U.filter).reduce((U,X)=>X===void 0?U:G(U,X,{combineWith:h}),void 0),xe=N===void 0?"":H(N);e(xe,N)},[o,e,t]),m=(0,w.useCallback)((g,F)=>{f(Pe(p,{column:o,value:g},"column")),u(F)},[o,p,u]),a=(0,w.useCallback)((g,F)=>{s(Pe(i,{column:o,value:g},"column")),u(F)},[o,i,u]),c=(0,w.useCallback)(g=>r((g==null?void 0:g.name)||""),[]),x=(C=i.filter(g=>g.column===o)[0])==null?void 0:C.value,d=(y=p.filter(g=>g.column===o)[0])==null?void 0:y.value;return{clear:l,selectedColumnName:o,rangeValue:x,typeaheadValue:d,onSelectedColumnChange:c,onRangeChange:a,onTypeaheadChange:m}};var v=require("react/jsx-runtime"),ar=({className:e,table:o,columns:r,onFilterSubmit:t,...n})=>{let{clear:i,onTypeaheadChange:s,onRangeChange:p,onSelectedColumnChange:f,selectedColumnName:l,rangeValue:u,typeaheadValue:m}=to(t);return(0,v.jsxs)(P.Toolbar,{...n,style:{alignItems:"center",height:"36px"},children:[(0,v.jsx)(P.ToolbarField,{label:"Select a column to filter",labelPlacement:"top",style:{width:180},children:(0,v.jsx)(P.Dropdown,{source:r,ListItem:ro,itemToString:c=>c.name,onSelectionChange:(c,x)=>f(x)})}),l&&(()=>{var d;let c=[o,l];switch((d=r.find(C=>C.name===l))==null?void 0:d.serverDataType){case"string":case"char":return(0,v.jsx)(P.ToolbarField,{label:"Start typing to select a filter",labelPlacement:"top",children:(0,v.jsx)(Je,{defaultTypeaheadParams:c,filterValues:m,onChange:s})});case"int":case"long":case"double":return(0,v.jsx)(P.ToolbarField,{label:"Select a range",labelPlacement:"top",children:(0,v.jsx)(Ye,{defaultTypeaheadParams:c,filterValues:u,onChange:p})});default:return(0,v.jsx)(P.ToolbarField,{children:(0,v.jsx)(no.Text,{children:"Data type unsupported"})})}})(),(0,v.jsx)(P.ToolbarButton,{onClick:i,children:(0,v.jsx)(Fe,{})})]})};var Ne=require("@salt-ds/core");var I=require("@vuu-ui/vuu-codemirror"),xo=Ve(Te(),1),A=require("react");var T=require("@vuu-ui/vuu-codemirror");var io=require("@vuu-ui/vuu-codemirror"),ae=io.LRParser.deserialize({version:14,states:"%QOVQPOOOOQO'#C_'#C_O_QQO'#C^OOQO'#DO'#DOOvQQO'#C|OOQO'#DR'#DROVQPO'#CuOOQO'#C}'#C}QOQPOOOOQO'#C`'#C`O!UQQO,58xO!dQPO,59VOVQPO,59]OVQPO,59_O!iQPO,59hO!nQQO,59aOOQO'#DQ'#DQOOQO1G.d1G.dO!UQQO1G.qO!yQQO1G.wOOQO1G.y1G.yOOQO'#Cw'#CwOOQO1G/S1G/SOOQO1G.{1G.{O#[QPO'#CnO#dQPO7+$]O!UQQO'#CxO#iQPO,59YOOQO<<Gw<<GwOOQO,59d,59dOOQO-E6v-E6v",stateData:"#q~OoOS~OsPOvUO~OTXOUXOVXOWXOXXOYXO`ZO~Of[Oh]Oj^OmpX~OZ`O[`O]`O^`O~OabO~OseO~Of[Oh]OwgO~Oh]Ofeijeimeiwei~OcjOdbX~OdlO~OcjOdba~O",goto:"#YvPPw}!TPPPPPPPPPPwPP!WPP!ZP!ZP!aP!g!jPPP!p!s!aP#P!aXROU[]XQOU[]RYQRibXTOU[]XVOU[]Rf^QkhRnkRWOQSOQ_UQc[Rd]QaYQhbRmj",nodeNames:"\u26A0 Filter ColumnValueExpression Column Operator Eq NotEq Gt Lt Starts Ends Number String True False ColumnSetExpression In LBrack Values Comma RBrack AndExpression And OrExpression Or ParenthesizedExpression As FilterName",maxTerm:39,skippedNodes:[0],repeatNodeCount:1,tokenData:"6p~RnXY#PYZ#P]^#Ppq#Pqr#brs#mxy$eyz$j|}$o!O!P$t!Q![%S!^!_%_!_!`%d!`!a%i!c!}%n!}#O&V#P#Q&[#R#S%n#T#U&a#U#X%n#X#Y(w#Y#Z+]#Z#]%n#]#^.]#^#c%n#c#d/e#d#g%n#g#h0m#h#i4[#i#o%n~#USo~XY#PYZ#P]^#Ppq#P~#eP!_!`#h~#mOU~~#pWOX#mZ]#m^r#mrs$Ys#O#m#P;'S#m;'S;=`$_<%lO#m~$_O[~~$bP;=`<%l#m~$jOv~~$oOw~~$tOc~~$wP!Q![$z~%PPZ~!Q![$z~%XQZ~!O!P$t!Q![%S~%dOW~~%iOT~~%nOV~P%sUsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%n~&[Oa~~&aOd~R&fYsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#b%n#b#c'U#c#g%n#g#h(^#h#o%nR'ZWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#W%n#W#X's#X#o%nR'zUfQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR(eUjQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR(|WsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#b%n#b#c)f#c#o%nR)kWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#W%n#W#X*T#X#o%nR*YWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#g%n#g#h*r#h#o%nR*yUYQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR+bVsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#U+w#U#o%nR+|WsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#`%n#`#a,f#a#o%nR,kWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#g%n#g#h-T#h#o%nR-YWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#X%n#X#Y-r#Y#o%nR-yU^QsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR.bWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#b%n#b#c.z#c#o%nR/RU`QsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR/jWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#f%n#f#g0S#g#o%nR0ZUhQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR0rWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#h%n#h#i1[#i#o%nR1aVsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#U1v#U#o%nR1{WsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#f%n#f#g2e#g#o%nR2jWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#h%n#h#i3S#i#o%nR3XWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#g%n#g#h3q#h#o%nR3xUXQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR4aWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#f%n#f#g4y#g#o%nR5OWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#i%n#i#j5h#j#o%nR5mWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#X%n#X#Y6V#Y#o%nR6^U]QsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%n",tokenizers:[0,1],topRules:{Filter:[0,1]},tokenPrec:0});var cr=T.LRLanguage.define({name:"VuuFilterQuery",parser:ae.configure({props:[(0,T.styleTags)({Identifier:T.tags.variableName,String:T.tags.string,Or:T.tags.emphasis,Operator:T.tags.operator})]})}),so=()=>new T.LanguageSupport(cr);var E=require("@vuu-ui/vuu-utils");var O,Re=class{constructor(){Ae(this,O,void 0)}setFilterCombinatorOp(o,r=R(this,O)){(0,E.isMultiClauseFilter)(r)&&r.op===o||Ie(this,O,{op:o,filters:[R(this,O)]})}add(o){if(R(this,O)===void 0)Ie(this,O,o);else if((0,E.isMultiClauseFilter)(R(this,O)))R(this,O).filters.push(o);else throw Error("Invalid filter passed to FilterExpression")}setColumn(o,r=R(this,O)){if((0,E.isMultiClauseFilter)(r)){let t=r.filters.at(-1);t&&this.setColumn(o,t)}else r&&(r.column=o)}setOp(o,r=R(this,O)){if((0,E.isMultiClauseFilter)(r)){let t=r.filters.at(-1);t&&this.setOp(o,t)}else r&&(r.op=o)}setValue(o,r=R(this,O)){var t;if((0,E.isMultiClauseFilter)(r)){let n=r.filters.at(-1);n&&this.setValue(o,n)}else(0,E.isMultiValueFilter)(r)?((t=r.values)!=null||(r.values=[]),r.values.push(o)):(0,E.isSingleValueFilter)(r)&&(r.value=o)}toJSON(o=R(this,O)){return this.name?{...o,name:this.name}:o}};O=new WeakMap;var ce=(e,o)=>{let r=new Re,t=e.cursor();do{let{name:n,from:i,to:s}=t;switch(n){case"ColumnValueExpression":r.add({});break;case"ColumnSetExpression":r.add({op:"in"});break;case"Or":case"And":r.setFilterCombinatorOp(o.substring(i,s));break;case"Column":r.setColumn(o.substring(i,s));break;case"Operator":r.setOp(o.substring(i,s));break;case"String":r.setValue(o.substring(i+1,s-1));break;case"Number":r.setValue(parseFloat(o.substring(i,s)));break;case"True":r.setValue(!0);break;case"False":r.setValue(!1);break;case"FilterName":r.name=o.substring(i,s);break;default:}}while(t.next());return r.toJSON()};var pr=ae.configure({strict:!0}),Y=e=>{let o=pr.parse(e);return ce(o,e)};var L=require("@vuu-ui/vuu-codemirror"),ur=L.HighlightStyle.define([{tag:L.tags.variableName,color:"var(--vuuFilterEditor-variableColor)"},{tag:L.tags.comment,color:"green",fontStyle:"italic"}]),lo=(0,L.syntaxHighlighting)(ur);var ao=require("@vuu-ui/vuu-codemirror"),co=ao.EditorView.theme({"&":{color:"var(--vuuFilterEditor-color)",backgroundColor:"var(--vuuFilterEditor-background)",fontSize:"var(--vuuFilterEditor-fontSize)"},".cm-content":{caretColor:"var(--vuuFilterEditor-cursorColor)",padding:0},".cm-line":{lineHeight:"var(--vuuFilterEditor-lineHeight)"},"&.cm-focused .cm-cursor":{borderLeftColor:"var(--vuuFilterEditor-cursorColor)"},"&.cm-focused .cm-selectionBackground, ::selection":{backgroundColor:"var(--vuuFilterEditor-selectionBackground)"},".cm-selectionBackground, ::selection":{backgroundColor:"var(--vuuFilterEditor-selectionBackground)"},".cm-scroller":{fontFamily:"var(--vuuFilterEditor-fontFamily)"},".cm-tooltip":{background:"var(--vuuFilterEditor-tooltipBackground)",border:"var(--vuuFilterEditor-tooltipBorder)",boxShadow:"var(--vuuFilterEditor-tooltipElevation)","&.cm-tooltip-autocomplete > ul":{fontFamily:"var(--vuuFilterEditor-fontFamily)",fontSize:"var(--vuuFilterEditor-fontSize)",maxHeight:"240px"},"&.cm-tooltip-autocomplete > ul > li":{alignItems:"center",display:"flex",height:"var(--vuuFilterEditor-suggestion-height)",padding:"0 3px",lineHeight:"var(--vuuFilterEditor-suggestion-height)"},"&.cm-tooltip-autocomplete li[aria-selected]":{background:"var(--vuuFilterEditor-suggestion-selectedBackground)",color:"var(--vuuFilterEditor-suggestion-selectedColor)"}},".cm-completionIcon":{height:"18px",flex:"0 0 16px"},".cm-completionLabel":{flex:"1 1 auto"},".cm-completionIcon-filter":{position:"relative","&:after":{background:"var(--salt-text-secondary-foreground)",content:"''","-webkit-mask":"var(--svg-filter) center center/13px 13px","-webkit-mask-repeat":"no-repeat",position:"absolute",height:"18px",left:"0px",top:"0px",width:"16px"}}},{dark:!1});var S=require("@vuu-ui/vuu-codemirror"),we=require("react"),po=(e,o)=>{let r=e.prevSibling||e.parent;for(;r&&!["Column","Operator","In"].includes(r.name);)r=r.prevSibling||r.parent;if((r==null?void 0:r.name)==="In"||(r==null?void 0:r.name)==="Operator")return(0,S.getValue)(r,o)},mr=(e,o,r)=>{let t=(0,S.getValue)(e,o);if(!(r===void 0||t===r)&&["contains","ends","starts"].some(n=>n.startsWith(t.toLowerCase())))return t},uo=(e,o)=>{let r=e.prevSibling||e.parent||e.lastChild;for(;r&&r.name==="\u26A0";)r=r.prevSibling;if(r&&["As","Or","And"].includes(r.name))return(0,S.getValue)(r,o)},mo=(e,o)=>{if(e.name==="FilterName")return(0,S.getValue)(e,o);{let r=e.prevSibling||e.parent||e.lastChild;for(;r&&r.name!=="FilterName";)r=r.prevSibling;if(r&&r.name==="FilterName")return(0,S.getValue)(e,o)}},fo=(e,o)=>{let r=e.prevSibling;if((r==null?void 0:r.name)==="Column")return(0,S.getValue)(r,o);if((r==null?void 0:r.name)==="Operator")return fo(r,o)},dr=(e,o)=>{let r=e.lastChild,t=[];for(;r&&r.name!=="In";){let n=(0,S.getValue)(r,o);if(n)t.push(n);else break;r=r.prevSibling}return t};var go=(e,o,r)=>{let t=(0,we.useCallback)(async(n,i,s={})=>{let{startsWith:p=""}=s,f=await e.getSuggestions(i,s);return{from:n.pos-p.length,options:f}},[e]);return(0,we.useCallback)(async n=>{var u,m;let{state:i,pos:s}=n,p=(u=n.matchBefore(/\w*/))!=null?u:{from:0,to:0,text:void 0},l=(0,S.syntaxTree)(i).resolveInner(s,-1);switch(console.log({nodeBeforeName:l.name}),l.name){case"Filter":if(n.pos===0)return t(n,"column");if(uo(l,i)==="as")return t(n,"name");{let c=mo(l,i);return t(n,"save",{onSubmit:o.current,existingFilter:r,filterName:c})}case"String":{let a=po(l,i),c=fo(l,i),{from:x,to:d}=l;if(d-x===2&&n.pos===x+1){if(c&&a)return t(n,"columnValue",{columnName:c,operator:a,quoted:!0,startsWith:p.text})}else console.log(`we have a string, column is ${c} ${x} ${d}`)}break;case"As":return t(n,"name");case"FilterName":return t(n,"save",{onSubmit:o.current,existingFilter:r,filterName:mo(l,i)});case"Column":{let a=(0,S.getValue)(l,i);return await e.isPartialMatch("column",void 0,a)?t(n,"column",{startsWith:a}):t(n,"operator",{columnName:a})}case"\u26A0":{let a=(0,S.getNodeByName)(l,i),c=po(l,i),x=c?void 0:mr(l,i,a);return x?t(n,"operator",{columnName:a,startsWith:x}):t(n,"columnValue",{columnName:a,operator:c,startsWith:p.text})}case"Identifier":if(uo(l,i)==="as")return{from:n.pos,options:[{label:"press ENTER to apply filter and save",apply:()=>o.current(),boost:5}]};break;case"ColumnSetExpression":case"Values":{let a=(0,S.getNodeByName)(l,i),c=dr(l,i);return t(n,"columnValue",{columnName:a,selection:c})}case"Comma":case"LBrack":{let a=(0,S.getNodeByName)(l,i);return t(n,"columnValue",{columnName:a})}case"ColumnValueExpression":{let a=(m=l.lastChild)==null?void 0:m.prevSibling;if((a==null?void 0:a.name)==="Column")return t(n,"operator",{columnName:(0,S.getNodeByName)(l,i)});if((a==null?void 0:a.name)==="Operator")return t(n,"columnValue",{columnName:(0,S.getNodeByName)(a,i),operator:(0,S.getValue)(a,i)})}break;case"In":return{from:n.pos,options:[{label:"[",apply:" [",type:"text"}]};case"Eq":return t(n,"columnValue",{columnName:(0,S.getNodeByName)(l,i)});case"AndExpression":case"OrExpression":return t(n,"column");default:}},[r,t,o,e])};var q=e=>{if(e.current==null)throw Error("EditorView not defined");return e.current},fr=e=>(0,xo.default)("vuuSuggestion",{vuuIllustration:e.isIllustration}),gr=e=>{let o=e.lastIndexOf(" as ");return o!==-1?e.slice(0,o):e},xr=()=>console.log("noooop"),Ee=({existingFilter:e,onSubmitFilter:o,suggestionProvider:r})=>{let t=(0,A.useRef)(null),n=(0,A.useRef)(xr),i=(0,A.useRef)(),s=go(r,n,e),[p,f]=(0,A.useMemo)(()=>{let l=()=>{let d=q(i),C=d.state.doc.toString(),y=(0,I.ensureSyntaxTree)(d.state,d.state.doc.length,5e3);if(y){let g=ce(y,C);return[g,gr(C),g.name]}else return[void 0,"",void 0]},u=()=>{q(i).setState(x())},m=d=>{let[C,y,g]=l();o==null||o(C,y,d,g),u()},a=d=>I.keymap.of([{key:d,run(){return m(),!0}}]),c=d=>I.keymap.of([{key:d,run(){return(0,I.startCompletion)(q(i)),!0}}]),x=()=>I.EditorState.create({doc:"",extensions:[I.minimalSetup,(0,I.autocompletion)({override:[s],optionClass:fr}),so(),I.keymap.of(I.defaultKeymap),a("Ctrl-Enter"),c("ArrowDown"),I.EditorView.updateListener.of(d=>{let C=q(i);d.docChanged&&(0,I.startCompletion)(C)}),I.EditorState.transactionFilter.of(d=>d.newDoc.lines>1?[]:d),co,lo]});return n.current=d=>{m(d),setTimeout(()=>{q(i).focus()},100)},[x,u]},[s,o]);return(0,A.useEffect)(()=>{if(!t.current)throw Error("editor not in dom");return i.current=new I.EditorView({state:p(),parent:t.current}),()=>{var l;(l=i.current)==null||l.destroy()}},[s,p]),{editorRef:t,clearInput:f}};var $=require("react/jsx-runtime"),pe="vuuFilterInput",Ir=({existingFilter:e,iconName:o="filter",namedFilters:r,onSubmitFilter:t,suggestionProvider:n,...i})=>{let{editorRef:s,clearInput:p}=Ee({existingFilter:e,onSubmitFilter:t,suggestionProvider:n});return(0,$.jsxs)("div",{...i,className:pe,children:[(0,$.jsx)(Ne.Button,{className:`${pe}-FilterButton`,"data-icon":o,tabIndex:-1}),(0,$.jsx)("div",{className:`${pe}-Editor`,ref:s}),(0,$.jsx)(Ne.Button,{className:`${pe}-ClearButton`,"data-icon":"close-circle",onClick:p})]})};var b=require("@vuu-ui/vuu-codemirror"),me=require("@vuu-ui/vuu-data"),J=require("react");var K=require("@vuu-ui/vuu-utils"),Io=(e,o)=>{let r=(0,K.createEl)("div","vuuFunctionDoc"),t=(0,K.createEl)("div","function-heading"),n=(0,K.createEl)("span","function-name",e);t.appendChild(n);let i=(0,K.createEl)("p",void 0,o);return r.appendChild(t),r.appendChild(i),r};var Sr=[],Fr={},hr=e=>[{label:"Press ENTER to create TAB",apply:()=>e("tab"),boost:6}],So=(e,o,r=!0)=>{let t=o?[{label:"REPLACE existing filter",apply:()=>e("replace"),boost:8},{label:"AND existing filter",apply:()=>e("and"),boost:7},{label:"OR existing filter",apply:()=>e("or"),boost:7}]:[{label:"Press ENTER to submit",apply:()=>e(),boost:6}];return r?t.concat(b.booleanJoinSuggestions).concat(b.asNameSuggestion):t},Cr=(e,o)=>So(e,o,!0),Or=e=>So(e,void 0),vr=({existingFilter:e,filterName:o,onSubmit:r,saveOptions:t})=>{let n=o&&t.allowSaveAsTab,i=e?Cr(r,e):Or(r);return n?i.concat(hr(r)):i},br=e=>e.map(o=>({boost:5,label:o.name})),yr=e=>e?Array.from(e.entries()).map(([o,r])=>({info:()=>Io(o,r),label:o,type:"filter"})):Sr,Pr={label:"Done",apply:"] ",type:"keyword",boost:10},ue=(e,o="")=>e.filter(r=>o===""||r.label.startsWith(o)).map(r=>({...r,apply:r.label+" "})),Tr={allowReplace:!0},Rr=({columns:e,namedFilters:o,saveOptions:r=Tr,table:t,typeaheadHook:n=me.useTypeaheadSuggestions})=>{let i=(0,J.useRef)(),s=n(),p=(0,J.useCallback)(async(l,u=Fr)=>{let{columnName:m,existingFilter:a,filterName:c,operator:x,quoted:d,onSubmit:C,startsWith:y,selection:g}=u;switch(l){case"operator":{let F=e.find(N=>N.name===m);if(F)switch(F.serverDataType){case"string":case"char":return ue(b.stringOperators,y);case"int":case"long":case"double":return ue(b.numericOperators)}else console.warn(`'${m}' does not match any column name`)}break;case"column":{let F=await br(e),N=await yr(o);return(i.current=ue(F)).concat(ue(N))}case"columnValue":if(m){let F=e.find(Vo=>Vo.name===m);if(!F)throw Error(`useFilterSUggestionProvider no column ${m}`);let N=Array.isArray(g)?g.length===0?"[":",":"",xe=(0,me.getTypeaheadParams)(t,m,y),U=await s(xe),X=x==="starts";return i.current=(0,b.toSuggestions)(U,{moveCursorToEnd:d,quoted:(F==null?void 0:F.serverDataType)==="string"&&!d,suffix:d?"":" ",prefix:X?y:N,isIllustration:X}),Array.isArray(g)&&(g==null?void 0:g.length)>1?[Pr,...i.current]:i.current}break;case"save":{if(typeof C!="function")throw Error("useFilterSuggestionProvider, onSubmit must be supplied for 'save' suggestions");return await vr({existingFilter:a,filterName:c,onSubmit:C,saveOptions:r})}case"name":return await(0,b.getNamePrompt)("filter");default:}return[]},[e,s,o,r,t]),f=(0,J.useCallback)(async(l,u,m)=>{let a=await p(l,{columnName:u});if(m&&a)for(let c of a){if(c.label===m)return!1;if(c.label.startsWith(m))return!0}return!1},[p]);return{getSuggestions:p,isPartialMatch:f}};var wo=require("@heswell/salt-lab"),Eo=Ve(Te(),1);var ee=require("@heswell/salt-lab");var Fo=require("@heswell/salt-lab"),de=require("react"),Oo=require("react/jsx-runtime"),wr=e=>typeof e=="string",ho=e=>wr(e)?e.startsWith('"')&&e.endsWith('"')?e.slice(1,-1):e:e.map(ho),Co=({column:e,selected:o,suggestionProvider:r,...t})=>{let n=o!=null?ho(o):void 0,i=Array.isArray(n)?n:n!=null?[n]:[],[s,p]=(0,de.useState)(i);console.log({initialValues:i});let f=(0,de.useCallback)(async l=>{if(l){let u=await r.getSuggestions("columnValue",{columnName:e});console.log({values:u}),p(u.map(m=>m.label))}},[e,r]);return(0,Oo.jsx)(Fo.Dropdown,{...t,onOpenChange:f,selected:n,source:s})};var vo=require("@heswell/salt-lab"),fe=require("react"),Po=require("react/jsx-runtime"),Er=e=>typeof e=="string",bo=e=>{if(e!==void 0)return Er(e)?e.startsWith('"')&&e.endsWith('"')?e.slice(1,-1):e:e.map(bo)},yo=({column:e,selected:o,suggestionProvider:r,...t})=>{let n=bo(o),i=Array.isArray(n)?n:n!=null?[n]:[],[s,p]=(0,fe.useState)(i),f=(0,fe.useCallback)(async l=>{if(l){let u=await r.getSuggestions("columnValue",{columnName:e});console.log({values:u}),p(u.map(m=>m.label))}},[e,r]);return(0,Po.jsx)(vo.Dropdown,{...t,onOpenChange:f,selected:n,selectionStrategy:"multiple",source:s})};var z=require("react/jsx-runtime"),To=(e,o)=>{if(he(e))return(0,z.jsx)(ee.ToggleButton,{className:"vuuToggleButton",toggled:!0,variant:"secondary",children:e.name});if(k(e)){let{column:r,value:t}=e;return(0,z.jsx)(ee.ToolbarField,{className:"vuuFilterDropdown",label:r,labelPlacement:"top",children:(0,z.jsx)(Co,{column:r,selected:t.toString(),selectionStrategy:"default",source:[t.toString()],suggestionProvider:o,style:{width:100}})},r)}if(D(e)){let r=e.values.map(t=>t.toString());return(0,z.jsx)(ee.ToolbarField,{className:"vuuFilterDropdown",label:e.column,labelPlacement:"top",children:(0,z.jsx)(yo,{column:e.column,selected:r,source:r,suggestionProvider:o,style:{width:100}})},e.column)}return e.filters.map(r=>To(r,o))},Ro=({filter:e,suggestionProvider:o})=>e?To(e,o):[];var No=require("react/jsx-runtime"),Nr=({className:e,filter:o,suggestionProvider:r,...t})=>{console.log(`FilterToolbar ${JSON.stringify(o,null,2)}`);let n=Ro({filter:o,suggestionProvider:r});return(0,No.jsx)(wo.Toolbar,{className:(0,Eo.default)("vuuFilterToolbar",e),...t,children:n})};var Do=new Map,Dr=()=>!1,Vr=(e,o)=>{let r=Do.get(o);if(r)return r;try{let t=Y(o);return r=ge(e,t),Do.set(o,r),r}catch{return console.warn(`filter-evaluation-utils, failed to parse filter "${o}"`),Dr}};function ge(e,o){switch(o.op){case"in":return Qr(e,o);case"=":return Ar(e,o);case">":return kr(e,o);case">=":return Mr(e,o);case"<":return Lr(e,o);case"<=":return Ur(e,o);case"starts":return Wr(e,o);case"and":return Hr(e,o);case"or":return Br(e,o);default:return console.log(`unrecognized filter type ${o.op}`),()=>!0}}var Qr=(e,o)=>r=>o.values.indexOf(r[e[o.column]])!==-1,Ar=(e,o)=>r=>r[e[o.column]]===o.value,kr=(e,o)=>r=>r[e[o.column]]>o.value,Mr=(e,o)=>r=>r[e[o.column]]>=o.value,Lr=(e,o)=>r=>r[e[o.column]]<o.value,Ur=(e,o)=>r=>r[e[o.column]]<=o.value,Wr=(e,o)=>{let r=o.value;if(typeof r!="string")throw Error("string filter applied to value of wrong type");return t=>{let n=t[e[o.column]];if(typeof n!="string")throw Error("string filter applied to value of wrong type");return n.toLowerCase().startsWith(r.toLowerCase())}},Hr=(e,o)=>{let r=o.filters.map(t=>ge(e,t));return t=>r.every(n=>n(t))};function Br(e,o){let r=o.filters.map(t=>ge(e,t));return t=>r.some(n=>n(t))}
+var Dialect = class {
+  constructor(source, flags, disabled) {
+    this.source = source;
+    this.flags = flags;
+    this.disabled = disabled;
+  }
+  allows(term) {
+    return !this.disabled || this.disabled[term] == 0;
+  }
+};
+var LRParser = class extends Parser {
+  /// @internal
+  constructor(spec) {
+    super();
+    this.wrappers = [];
+    if (spec.version != 14)
+      throw new RangeError(`Parser version (${spec.version}) doesn't match runtime version (${14})`);
+    let nodeNames = spec.nodeNames.split(" ");
+    this.minRepeatTerm = nodeNames.length;
+    for (let i = 0; i < spec.repeatNodeCount; i++)
+      nodeNames.push("");
+    let topTerms = Object.keys(spec.topRules).map((r2) => spec.topRules[r2][1]);
+    let nodeProps = [];
+    for (let i = 0; i < nodeNames.length; i++)
+      nodeProps.push([]);
+    function setProp(nodeID, prop, value) {
+      nodeProps[nodeID].push([prop, prop.deserialize(String(value))]);
+    }
+    if (spec.nodeProps)
+      for (let propSpec of spec.nodeProps) {
+        let prop = propSpec[0];
+        if (typeof prop == "string")
+          prop = NodeProp[prop];
+        for (let i = 1; i < propSpec.length; ) {
+          let next = propSpec[i++];
+          if (next >= 0) {
+            setProp(next, prop, propSpec[i++]);
+          } else {
+            let value = propSpec[i + -next];
+            for (let j = -next; j > 0; j--)
+              setProp(propSpec[i++], prop, value);
+            i++;
+          }
+        }
+      }
+    this.nodeSet = new NodeSet(nodeNames.map((name, i) => NodeType.define({
+      name: i >= this.minRepeatTerm ? void 0 : name,
+      id: i,
+      props: nodeProps[i],
+      top: topTerms.indexOf(i) > -1,
+      error: i == 0,
+      skipped: spec.skippedNodes && spec.skippedNodes.indexOf(i) > -1
+    })));
+    if (spec.propSources)
+      this.nodeSet = this.nodeSet.extend(...spec.propSources);
+    this.strict = false;
+    this.bufferLength = DefaultBufferLength;
+    let tokenArray = decodeArray(spec.tokenData);
+    this.context = spec.context;
+    this.specializerSpecs = spec.specialized || [];
+    this.specialized = new Uint16Array(this.specializerSpecs.length);
+    for (let i = 0; i < this.specializerSpecs.length; i++)
+      this.specialized[i] = this.specializerSpecs[i].term;
+    this.specializers = this.specializerSpecs.map(getSpecializer);
+    this.states = decodeArray(spec.states, Uint32Array);
+    this.data = decodeArray(spec.stateData);
+    this.goto = decodeArray(spec.goto);
+    this.maxTerm = spec.maxTerm;
+    this.tokenizers = spec.tokenizers.map((value) => typeof value == "number" ? new TokenGroup(tokenArray, value) : value);
+    this.topRules = spec.topRules;
+    this.dialects = spec.dialects || {};
+    this.dynamicPrecedences = spec.dynamicPrecedences || null;
+    this.tokenPrecTable = spec.tokenPrec;
+    this.termNames = spec.termNames || null;
+    this.maxNode = this.nodeSet.types.length - 1;
+    this.dialect = this.parseDialect();
+    this.top = this.topRules[Object.keys(this.topRules)[0]];
+  }
+  createParse(input, fragments, ranges) {
+    let parse = new Parse(this, input, fragments, ranges);
+    for (let w of this.wrappers)
+      parse = w(parse, input, fragments, ranges);
+    return parse;
+  }
+  /// Get a goto table entry @internal
+  getGoto(state, term, loose = false) {
+    let table = this.goto;
+    if (term >= table[0])
+      return -1;
+    for (let pos = table[term + 1]; ; ) {
+      let groupTag = table[pos++], last = groupTag & 1;
+      let target = table[pos++];
+      if (last && loose)
+        return target;
+      for (let end = pos + (groupTag >> 1); pos < end; pos++)
+        if (table[pos] == state)
+          return target;
+      if (last)
+        return -1;
+    }
+  }
+  /// Check if this state has an action for a given terminal @internal
+  hasAction(state, terminal) {
+    let data = this.data;
+    for (let set = 0; set < 2; set++) {
+      for (let i = this.stateSlot(
+        state,
+        set ? 2 : 1
+        /* ParseState.Actions */
+      ), next; ; i += 3) {
+        if ((next = data[i]) == 65535) {
+          if (data[i + 1] == 1)
+            next = data[i = pair(data, i + 2)];
+          else if (data[i + 1] == 2)
+            return pair(data, i + 2);
+          else
+            break;
+        }
+        if (next == terminal || next == 0)
+          return pair(data, i + 1);
+      }
+    }
+    return 0;
+  }
+  /// @internal
+  stateSlot(state, slot) {
+    return this.states[state * 6 + slot];
+  }
+  /// @internal
+  stateFlag(state, flag) {
+    return (this.stateSlot(
+      state,
+      0
+      /* ParseState.Flags */
+    ) & flag) > 0;
+  }
+  /// @internal
+  validAction(state, action) {
+    if (action == this.stateSlot(
+      state,
+      4
+      /* ParseState.DefaultReduce */
+    ))
+      return true;
+    for (let i = this.stateSlot(
+      state,
+      1
+      /* ParseState.Actions */
+    ); ; i += 3) {
+      if (this.data[i] == 65535) {
+        if (this.data[i + 1] == 1)
+          i = pair(this.data, i + 2);
+        else
+          return false;
+      }
+      if (action == pair(this.data, i + 1))
+        return true;
+    }
+  }
+  /// Get the states that can follow this one through shift actions or
+  /// goto jumps. @internal
+  nextStates(state) {
+    let result = [];
+    for (let i = this.stateSlot(
+      state,
+      1
+      /* ParseState.Actions */
+    ); ; i += 3) {
+      if (this.data[i] == 65535) {
+        if (this.data[i + 1] == 1)
+          i = pair(this.data, i + 2);
+        else
+          break;
+      }
+      if ((this.data[i + 2] & 65536 >> 16) == 0) {
+        let value = this.data[i + 1];
+        if (!result.some((v, i2) => i2 & 1 && v == value))
+          result.push(this.data[i], value);
+      }
+    }
+    return result;
+  }
+  /// Configure the parser. Returns a new parser instance that has the
+  /// given settings modified. Settings not provided in `config` are
+  /// kept from the original parser.
+  configure(config) {
+    let copy = Object.assign(Object.create(LRParser.prototype), this);
+    if (config.props)
+      copy.nodeSet = this.nodeSet.extend(...config.props);
+    if (config.top) {
+      let info = this.topRules[config.top];
+      if (!info)
+        throw new RangeError(`Invalid top rule name ${config.top}`);
+      copy.top = info;
+    }
+    if (config.tokenizers)
+      copy.tokenizers = this.tokenizers.map((t) => {
+        let found = config.tokenizers.find((r2) => r2.from == t);
+        return found ? found.to : t;
+      });
+    if (config.specializers) {
+      copy.specializers = this.specializers.slice();
+      copy.specializerSpecs = this.specializerSpecs.map((s, i) => {
+        let found = config.specializers.find((r2) => r2.from == s.external);
+        if (!found)
+          return s;
+        let spec = Object.assign(Object.assign({}, s), { external: found.to });
+        copy.specializers[i] = getSpecializer(spec);
+        return spec;
+      });
+    }
+    if (config.contextTracker)
+      copy.context = config.contextTracker;
+    if (config.dialect)
+      copy.dialect = this.parseDialect(config.dialect);
+    if (config.strict != null)
+      copy.strict = config.strict;
+    if (config.wrap)
+      copy.wrappers = copy.wrappers.concat(config.wrap);
+    if (config.bufferLength != null)
+      copy.bufferLength = config.bufferLength;
+    return copy;
+  }
+  /// Tells you whether any [parse wrappers](#lr.ParserConfig.wrap)
+  /// are registered for this parser.
+  hasWrappers() {
+    return this.wrappers.length > 0;
+  }
+  /// Returns the name associated with a given term. This will only
+  /// work for all terms when the parser was generated with the
+  /// `--names` option. By default, only the names of tagged terms are
+  /// stored.
+  getName(term) {
+    return this.termNames ? this.termNames[term] : String(term <= this.maxNode && this.nodeSet.types[term].name || term);
+  }
+  /// The eof term id is always allocated directly after the node
+  /// types. @internal
+  get eofTerm() {
+    return this.maxNode + 1;
+  }
+  /// The type of top node produced by the parser.
+  get topNode() {
+    return this.nodeSet.types[this.top[1]];
+  }
+  /// @internal
+  dynamicPrecedence(term) {
+    let prec = this.dynamicPrecedences;
+    return prec == null ? 0 : prec[term] || 0;
+  }
+  /// @internal
+  parseDialect(dialect) {
+    let values = Object.keys(this.dialects), flags = values.map(() => false);
+    if (dialect)
+      for (let part of dialect.split(" ")) {
+        let id = values.indexOf(part);
+        if (id >= 0)
+          flags[id] = true;
+      }
+    let disabled = null;
+    for (let i = 0; i < values.length; i++)
+      if (!flags[i]) {
+        for (let j = this.dialects[values[i]], id; (id = this.data[j++]) != 65535; )
+          (disabled || (disabled = new Uint8Array(this.maxTerm + 1)))[id] = 1;
+      }
+    return new Dialect(dialect, flags, disabled);
+  }
+  /// Used by the output of the parser generator. Not available to
+  /// user code. @hide
+  static deserialize(spec) {
+    return new LRParser(spec);
+  }
+};
+function pair(data, off) {
+  return data[off] | data[off + 1] << 16;
+}
+function findFinished(stacks) {
+  let best = null;
+  for (let stack of stacks) {
+    let stopped = stack.p.stoppedAt;
+    if ((stack.pos == stack.p.stream.end || stopped != null && stack.pos > stopped) && stack.p.parser.stateFlag(
+      stack.state,
+      2
+      /* StateFlag.Accepting */
+    ) && (!best || best.score < stack.score))
+      best = stack;
+  }
+  return best;
+}
+function getSpecializer(spec) {
+  if (spec.external) {
+    let mask = spec.extend ? 1 : 0;
+    return (value, stack) => spec.external(value, stack) << 1 | mask;
+  }
+  return spec.get;
+}
+
+// ../vuu-filter-parser/src/generated/filter-parser.js
+var parser = LRParser.deserialize({
+  version: 14,
+  states: "%QOVQPOOOOQO'#C_'#C_O_QQO'#C^OOQO'#DO'#DOOvQQO'#C|OOQO'#DR'#DROVQPO'#CuOOQO'#C}'#C}QOQPOOOOQO'#C`'#C`O!UQQO,58xO!dQPO,59VOVQPO,59]OVQPO,59_O!iQPO,59hO!nQQO,59aOOQO'#DQ'#DQOOQO1G.d1G.dO!UQQO1G.qO!yQQO1G.wOOQO1G.y1G.yOOQO'#Cw'#CwOOQO1G/S1G/SOOQO1G.{1G.{O#[QPO'#CnO#dQPO7+$]O!UQQO'#CxO#iQPO,59YOOQO<<Gw<<GwOOQO,59d,59dOOQO-E6v-E6v",
+  stateData: "#q~OoOS~OsPOvUO~OTXOUXOVXOWXOXXOYXO`ZO~Of[Oh]Oj^OmpX~OZ`O[`O]`O^`O~OabO~OseO~Of[Oh]OwgO~Oh]Ofeijeimeiwei~OcjOdbX~OdlO~OcjOdba~O",
+  goto: "#YvPPw}!TPPPPPPPPPPwPP!WPP!ZP!ZP!aP!g!jPPP!p!s!aP#P!aXROU[]XQOU[]RYQRibXTOU[]XVOU[]Rf^QkhRnkRWOQSOQ_UQc[Rd]QaYQhbRmj",
+  nodeNames: "\u26A0 Filter ColumnValueExpression Column Operator Eq NotEq Gt Lt Starts Ends Number String True False ColumnSetExpression In LBrack Values Comma RBrack AndExpression And OrExpression Or ParenthesizedExpression As FilterName",
+  maxTerm: 39,
+  skippedNodes: [0],
+  repeatNodeCount: 1,
+  tokenData: "6p~RnXY#PYZ#P]^#Ppq#Pqr#brs#mxy$eyz$j|}$o!O!P$t!Q![%S!^!_%_!_!`%d!`!a%i!c!}%n!}#O&V#P#Q&[#R#S%n#T#U&a#U#X%n#X#Y(w#Y#Z+]#Z#]%n#]#^.]#^#c%n#c#d/e#d#g%n#g#h0m#h#i4[#i#o%n~#USo~XY#PYZ#P]^#Ppq#P~#eP!_!`#h~#mOU~~#pWOX#mZ]#m^r#mrs$Ys#O#m#P;'S#m;'S;=`$_<%lO#m~$_O[~~$bP;=`<%l#m~$jOv~~$oOw~~$tOc~~$wP!Q![$z~%PPZ~!Q![$z~%XQZ~!O!P$t!Q![%S~%dOW~~%iOT~~%nOV~P%sUsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%n~&[Oa~~&aOd~R&fYsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#b%n#b#c'U#c#g%n#g#h(^#h#o%nR'ZWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#W%n#W#X's#X#o%nR'zUfQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR(eUjQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR(|WsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#b%n#b#c)f#c#o%nR)kWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#W%n#W#X*T#X#o%nR*YWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#g%n#g#h*r#h#o%nR*yUYQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR+bVsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#U+w#U#o%nR+|WsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#`%n#`#a,f#a#o%nR,kWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#g%n#g#h-T#h#o%nR-YWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#X%n#X#Y-r#Y#o%nR-yU^QsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR.bWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#b%n#b#c.z#c#o%nR/RU`QsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR/jWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#f%n#f#g0S#g#o%nR0ZUhQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR0rWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#h%n#h#i1[#i#o%nR1aVsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#U1v#U#o%nR1{WsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#f%n#f#g2e#g#o%nR2jWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#h%n#h#i3S#i#o%nR3XWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#g%n#g#h3q#h#o%nR3xUXQsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%nR4aWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#f%n#f#g4y#g#o%nR5OWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#i%n#i#j5h#j#o%nR5mWsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#X%n#X#Y6V#Y#o%nR6^U]QsP}!O%n!O!P%n!Q![%n!c!}%n#R#S%n#T#o%n",
+  tokenizers: [0, 1],
+  topRules: { "Filter": [0, 1] },
+  tokenPrec: 0
+});
+
+// ../vuu-filter-parser/src/FilterTreeWalker.ts
+var import_vuu_utils3 = require("@vuu-ui/vuu-utils");
+var _filter;
+var FilterExpression = class {
+  constructor() {
+    __privateAdd(this, _filter, void 0);
+  }
+  setFilterCombinatorOp(op, filter = __privateGet(this, _filter)) {
+    if ((0, import_vuu_utils3.isMultiClauseFilter)(filter) && filter.op === op) {
+      return;
+    } else {
+      __privateSet(this, _filter, {
+        op,
+        filters: [__privateGet(this, _filter)]
+      });
+    }
+  }
+  add(filter) {
+    if (__privateGet(this, _filter) === void 0) {
+      __privateSet(this, _filter, filter);
+    } else if ((0, import_vuu_utils3.isMultiClauseFilter)(__privateGet(this, _filter))) {
+      __privateGet(this, _filter).filters.push(filter);
+    } else {
+      throw Error(`Invalid filter passed to FilterExpression`);
+    }
+  }
+  setColumn(column, filter = __privateGet(this, _filter)) {
+    if ((0, import_vuu_utils3.isMultiClauseFilter)(filter)) {
+      const target = filter.filters.at(-1);
+      if (target) {
+        this.setColumn(column, target);
+      }
+    } else if (filter) {
+      filter.column = column;
+    }
+  }
+  setOp(value, filter = __privateGet(this, _filter)) {
+    if ((0, import_vuu_utils3.isMultiClauseFilter)(filter)) {
+      const target = filter.filters.at(-1);
+      if (target) {
+        this.setOp(value, target);
+      }
+    } else if (filter) {
+      filter.op = value;
+    }
+  }
+  setValue(value, filter = __privateGet(this, _filter)) {
+    var _a;
+    if ((0, import_vuu_utils3.isMultiClauseFilter)(filter)) {
+      const target = filter.filters.at(-1);
+      if (target) {
+        this.setValue(value, target);
+      }
+    } else if ((0, import_vuu_utils3.isMultiValueFilter)(filter)) {
+      (_a = filter.values) != null ? _a : filter.values = [];
+      filter.values.push(value);
+    } else if ((0, import_vuu_utils3.isSingleValueFilter)(filter)) {
+      filter.value = value;
+    }
+  }
+  toJSON(filter = __privateGet(this, _filter)) {
+    if (this.name) {
+      return {
+        ...filter,
+        name: this.name
+      };
+    } else {
+      return filter;
+    }
+  }
+};
+_filter = new WeakMap();
+var walkTree = (tree, source) => {
+  const filterExpression = new FilterExpression();
+  const cursor = tree.cursor();
+  do {
+    const { name, from, to } = cursor;
+    switch (name) {
+      case "ColumnValueExpression":
+        filterExpression.add({});
+        break;
+      case "ColumnSetExpression":
+        filterExpression.add({ op: "in" });
+        break;
+      case "Or":
+      case "And":
+        filterExpression.setFilterCombinatorOp(source.substring(from, to));
+        break;
+      case "Column":
+        filterExpression.setColumn(source.substring(from, to));
+        break;
+      case "Operator":
+        filterExpression.setOp(source.substring(from, to));
+        break;
+      case "String":
+        filterExpression.setValue(source.substring(from + 1, to - 1));
+        break;
+      case "Number":
+        filterExpression.setValue(parseFloat(source.substring(from, to)));
+        break;
+      case "True":
+        filterExpression.setValue(true);
+        break;
+      case "False":
+        filterExpression.setValue(false);
+        break;
+      case "FilterName":
+        filterExpression.name = source.substring(from, to);
+        break;
+      default:
+    }
+  } while (cursor.next());
+  return filterExpression.toJSON();
+};
+
+// ../vuu-filter-parser/src/FilterParser.ts
+var strictParser = parser.configure({ strict: true });
+
+// ../vuu-data-react/src/hooks/useVuuMenuActions.ts
+var import_vuu_utils4 = require("@vuu-ui/vuu-utils");
+var import_react7 = require("react");
+var { KEY } = import_vuu_utils4.metadataKeys;
+
+// ../vuu-data-react/src/hooks/useVuuTables.ts
+var import_react8 = require("react");
+var import_vuu_data4 = require("@vuu-ui/vuu-data");
+
+// src/column-filter/TypeaheadFilter.tsx
+var import_salt_lab2 = require("@heswell/salt-lab");
+var import_react9 = require("react");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var TypeaheadFilter = ({
+  defaultTypeaheadParams,
+  filterValues = [],
+  onChange: onFilterChange
+}) => {
+  const [tableName, columnName] = defaultTypeaheadParams;
+  const [searchValue, setSearchValue] = (0, import_react9.useState)("");
+  const [typeaheadValues, setTypeaheadValues] = (0, import_react9.useState)([]);
+  const getSuggestions = useTypeaheadSuggestions();
+  (0, import_react9.useEffect)(() => {
+    const params = searchValue ? [tableName, columnName, searchValue] : defaultTypeaheadParams;
+    let isSubscribed = true;
+    getSuggestions(params).then((options) => {
+      if (!isSubscribed) {
+        return;
+      }
+      if (isStartsWithValue(filterValues[0])) {
+        options.unshift(filterValues[0]);
+      }
+      if (searchValue) {
+        options.unshift(`${searchValue}...`);
+      }
+      options.concat(filterValues);
+      setTypeaheadValues(options);
+    });
+    return () => {
+      isSubscribed = false;
+    };
+  }, [
+    filterValues,
+    searchValue,
+    columnName,
+    tableName,
+    getSuggestions,
+    defaultTypeaheadParams
+  ]);
+  const onInputChange = (0, import_react9.useCallback)(
+    (evt) => {
+      const value = evt.target.value;
+      setSearchValue(value);
+    },
+    []
+  );
+  const onSelectionChange = (0, import_react9.useCallback)(
+    (_evt, selected) => {
+      setSearchValue("");
+      if (selected === null)
+        return;
+      if (selected.some(isStartsWithValue)) {
+        selected = selected.filter(isStartsWithValue).slice(-1);
+      }
+      const filter = getTypeaheadFilter(
+        columnName,
+        selected,
+        isStartsWithValue(selected[0])
+      );
+      onFilterChange(selected, filter);
+    },
+    [columnName, onFilterChange]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    import_salt_lab2.ComboBoxDeprecated,
+    {
+      multiSelect: true,
+      onInputChange,
+      onChange: onSelectionChange,
+      source: typeaheadValues,
+      style: { minWidth: 200 },
+      inputValue: searchValue,
+      selectedItem: filterValues
+    },
+    columnName
+  );
+};
+
+// src/column-filter/ColumnListItem.tsx
+var import_react10 = require("react");
+var import_salt_lab3 = require("@heswell/salt-lab");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var ColumnListItem = (props) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(MemoColumnItem, { ...props });
+};
+var MemoColumnItem = (0, import_react10.memo)(function MemoizedItem({
+  item,
+  itemTextHighlightPattern,
+  ...restProps
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_salt_lab3.ListItem, { ...restProps, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { style: { marginLeft: 10 }, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+    import_salt_lab3.Highlighter,
+    {
+      matchPattern: itemTextHighlightPattern,
+      text: item == null ? void 0 : item.name
+    }
+  ) }) });
+});
+
+// src/column-filter/useColumnFilterStore.ts
+var import_vuu_utils5 = require("@vuu-ui/vuu-utils");
+var import_react11 = require("react");
+var addOrReplace = (array, newValue, key) => array.filter((oldValue) => oldValue[key] !== newValue[key]).concat(newValue);
+var useColumnFilterStore = (onFilterSubmit) => {
+  var _a, _b;
+  const [selectedColumnName, setSelectedColumnName] = (0, import_react11.useState)("");
+  const [savedFilters, setSavedFilters] = (0, import_react11.useState)([]);
+  const [rangeValues, setRangeValues] = (0, import_react11.useState)([]);
+  const [typeaheadValues, setTypeaheadValues] = (0, import_react11.useState)([]);
+  const clear = () => {
+    setSelectedColumnName("");
+    setRangeValues([]);
+    setTypeaheadValues([]);
+    setSavedFilters([]);
+    onFilterSubmit({ filter: "" });
+  };
+  const updateFilters = (0, import_react11.useCallback)(
+    (newFilter) => {
+      const newSavedFilters = addOrReplace(
+        savedFilters,
+        { column: selectedColumnName, filter: newFilter },
+        "column"
+      );
+      setSavedFilters(newSavedFilters);
+      const combinedFilter = newSavedFilters.map((x) => x.filter).reduce((prev, filter) => {
+        if (filter === void 0)
+          return prev;
+        return addFilter(prev, filter, { combineWith: AND });
+      }, void 0);
+      const query = combinedFilter === void 0 ? "" : (0, import_vuu_utils5.filterAsQuery)(combinedFilter);
+      onFilterSubmit({ filter: query, filterStruct: combinedFilter });
+    },
+    [selectedColumnName, onFilterSubmit, savedFilters]
+  );
+  const onTypeaheadChange = (0, import_react11.useCallback)(
+    (newValues, newFilter) => {
+      setTypeaheadValues(
+        addOrReplace(
+          typeaheadValues,
+          { column: selectedColumnName, value: newValues },
+          "column"
+        )
+      );
+      updateFilters(newFilter);
+    },
+    [selectedColumnName, typeaheadValues, updateFilters]
+  );
+  const onRangeChange = (0, import_react11.useCallback)(
+    (newValues, newFilter) => {
+      setRangeValues(
+        addOrReplace(
+          rangeValues,
+          { column: selectedColumnName, value: newValues },
+          "column"
+        )
+      );
+      updateFilters(newFilter);
+    },
+    [selectedColumnName, rangeValues, updateFilters]
+  );
+  const onSelectedColumnChange = (0, import_react11.useCallback)(
+    (column) => setSelectedColumnName((column == null ? void 0 : column.name) || ""),
+    []
+  );
+  const rangeValue = (_a = rangeValues.filter(
+    (v) => v.column === selectedColumnName
+  )[0]) == null ? void 0 : _a.value;
+  const typeaheadValue = (_b = typeaheadValues.filter(
+    (v) => v.column === selectedColumnName
+  )[0]) == null ? void 0 : _b.value;
+  return {
+    clear,
+    selectedColumnName,
+    rangeValue,
+    typeaheadValue,
+    onSelectedColumnChange,
+    onRangeChange,
+    onTypeaheadChange
+  };
+};
+
+// src/column-filter/ColumnFilter.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var ColumnFilter = ({
+  className,
+  table,
+  columns,
+  onFilterSubmit,
+  ...htmlAttributes
+}) => {
+  const {
+    clear,
+    onTypeaheadChange,
+    onRangeChange,
+    onSelectedColumnChange,
+    selectedColumnName,
+    rangeValue,
+    typeaheadValue
+  } = useColumnFilterStore(onFilterSubmit);
+  const getFilterComponent = () => {
+    var _a;
+    const defaultTypeaheadParams = [table, selectedColumnName];
+    const selectedColumnType = (_a = columns.find(
+      (column) => column.name === selectedColumnName
+    )) == null ? void 0 : _a.serverDataType;
+    switch (selectedColumnType) {
+      case "string":
+      case "char":
+        return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+          import_salt_lab4.ToolbarField,
+          {
+            label: "Start typing to select a filter",
+            labelPlacement: "top",
+            children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+              TypeaheadFilter,
+              {
+                defaultTypeaheadParams,
+                filterValues: typeaheadValue,
+                onChange: onTypeaheadChange
+              }
+            )
+          }
+        );
+      case "int":
+      case "long":
+      case "double":
+        return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_salt_lab4.ToolbarField, { label: "Select a range", labelPlacement: "top", children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+          RangeFilter,
+          {
+            defaultTypeaheadParams,
+            filterValues: rangeValue,
+            onChange: onRangeChange
+          }
+        ) });
+      default:
+        return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_salt_lab4.ToolbarField, { children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_core.Text, { children: "Data type unsupported" }) });
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(
+    import_salt_lab4.Toolbar,
+    {
+      ...htmlAttributes,
+      style: { alignItems: "center", height: "36px" },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+          import_salt_lab4.ToolbarField,
+          {
+            label: "Select a column to filter",
+            labelPlacement: "top",
+            style: { width: 180 },
+            children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+              import_salt_lab4.Dropdown,
+              {
+                source: columns,
+                ListItem: ColumnListItem,
+                itemToString: (column) => column.name,
+                onSelectionChange: (_evt, column) => onSelectedColumnChange(column)
+              }
+            )
+          }
+        ),
+        selectedColumnName && getFilterComponent(),
+        /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_salt_lab4.ToolbarButton, { onClick: clear, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(DeleteIcon, {}) })
+      ]
+    }
+  );
+};
+
+// src/filter-input/FilterInput.tsx
+var import_core2 = require("@salt-ds/core");
+
+// src/filter-input/useCodeMirrorEditor.ts
+var import_vuu_codemirror5 = require("@vuu-ui/vuu-codemirror");
+var import_classnames = __toESM(require_classnames(), 1);
+var import_react13 = require("react");
+
+// src/filter-input/FilterLanguage.ts
+var import_vuu_codemirror = require("@vuu-ui/vuu-codemirror");
+var filterLanguage = import_vuu_codemirror.LRLanguage.define({
+  name: "VuuFilterQuery",
+  parser: parser.configure({
+    props: [
+      (0, import_vuu_codemirror.styleTags)({
+        Identifier: import_vuu_codemirror.tags.variableName,
+        String: import_vuu_codemirror.tags.string,
+        Or: import_vuu_codemirror.tags.emphasis,
+        Operator: import_vuu_codemirror.tags.operator
+      })
+    ]
+  })
+});
+var filterLanguageSupport = () => {
+  return new import_vuu_codemirror.LanguageSupport(filterLanguage);
+};
+
+// src/filter-input/highlighting.ts
+var import_vuu_codemirror2 = require("@vuu-ui/vuu-codemirror");
+var myHighlightStyle = import_vuu_codemirror2.HighlightStyle.define([
+  { tag: import_vuu_codemirror2.tags.variableName, color: "var(--vuuFilterEditor-variableColor)" },
+  { tag: import_vuu_codemirror2.tags.comment, color: "green", fontStyle: "italic" }
+]);
+var vuuHighlighting = (0, import_vuu_codemirror2.syntaxHighlighting)(myHighlightStyle);
+
+// src/filter-input/theme.ts
+var import_vuu_codemirror3 = require("@vuu-ui/vuu-codemirror");
+var vuuTheme = import_vuu_codemirror3.EditorView.theme(
+  {
+    "&": {
+      color: "var(--vuuFilterEditor-color)",
+      backgroundColor: "var(--vuuFilterEditor-background)",
+      fontSize: "var(--vuuFilterEditor-fontSize)"
+    },
+    ".cm-content": {
+      caretColor: "var(--vuuFilterEditor-cursorColor)",
+      padding: 0
+    },
+    ".cm-line": {
+      lineHeight: "var(--vuuFilterEditor-lineHeight)"
+    },
+    "&.cm-focused .cm-cursor": {
+      borderLeftColor: "var(--vuuFilterEditor-cursorColor)"
+    },
+    "&.cm-focused .cm-selectionBackground, ::selection": {
+      backgroundColor: "var(--vuuFilterEditor-selectionBackground)"
+    },
+    ".cm-selectionBackground, ::selection": {
+      backgroundColor: "var(--vuuFilterEditor-selectionBackground)"
+    },
+    ".cm-scroller": {
+      fontFamily: "var(--vuuFilterEditor-fontFamily)"
+    },
+    ".cm-tooltip": {
+      background: "var(--vuuFilterEditor-tooltipBackground)",
+      border: "var(--vuuFilterEditor-tooltipBorder)",
+      boxShadow: "var(--vuuFilterEditor-tooltipElevation)",
+      "&.cm-tooltip-autocomplete > ul": {
+        fontFamily: "var(--vuuFilterEditor-fontFamily)",
+        fontSize: "var(--vuuFilterEditor-fontSize)",
+        maxHeight: "240px"
+      },
+      "&.cm-tooltip-autocomplete > ul > li": {
+        alignItems: "center",
+        display: "flex",
+        height: "var(--vuuFilterEditor-suggestion-height)",
+        padding: "0 3px",
+        lineHeight: "var(--vuuFilterEditor-suggestion-height)"
+      },
+      "&.cm-tooltip-autocomplete li[aria-selected]": {
+        background: "var(--vuuFilterEditor-suggestion-selectedBackground)",
+        color: "var(--vuuFilterEditor-suggestion-selectedColor)"
+      }
+    },
+    ".cm-completionIcon": {
+      height: "18px",
+      flex: "0 0 16px"
+    },
+    ".cm-completionLabel": {
+      flex: "1 1 auto"
+    },
+    ".cm-completionIcon-filter": {
+      position: "relative",
+      "&:after": {
+        background: "var(--salt-text-secondary-foreground)",
+        content: "''",
+        "-webkit-mask": "var(--svg-filter) center center/13px 13px",
+        "-webkit-mask-repeat": "no-repeat",
+        position: "absolute",
+        height: "18px",
+        left: "0px",
+        top: "0px",
+        width: "16px"
+      }
+    }
+  },
+  { dark: false }
+);
+
+// src/filter-input/useFilterAutoComplete.ts
+var import_vuu_codemirror4 = require("@vuu-ui/vuu-codemirror");
+var import_react12 = require("react");
+var getOperator = (node, state) => {
+  let maybeColumnNode = node.prevSibling || node.parent;
+  while (maybeColumnNode && !["Column", "Operator", "In"].includes(maybeColumnNode.name)) {
+    maybeColumnNode = maybeColumnNode.prevSibling || maybeColumnNode.parent;
+  }
+  if ((maybeColumnNode == null ? void 0 : maybeColumnNode.name) === "In" || (maybeColumnNode == null ? void 0 : maybeColumnNode.name) === "Operator") {
+    return (0, import_vuu_codemirror4.getValue)(maybeColumnNode, state);
+  } else {
+    return void 0;
+  }
+};
+var getPartialOperator = (maybeOperatorNode, state, columnName) => {
+  const value = (0, import_vuu_codemirror4.getValue)(maybeOperatorNode, state);
+  if (columnName === void 0 || value === columnName) {
+    return;
+  }
+  if (["contains", "ends", "starts"].some(
+    (val) => val.startsWith(value.toLowerCase())
+  )) {
+    return value;
+  } else {
+    return void 0;
+  }
+};
+var getClauseOperator = (node, state) => {
+  let maybeTargetNode = node.prevSibling || node.parent || node.lastChild;
+  while (maybeTargetNode && maybeTargetNode.name === "\u26A0")
+    maybeTargetNode = maybeTargetNode.prevSibling;
+  if (maybeTargetNode && ["As", "Or", "And"].includes(maybeTargetNode.name)) {
+    return (0, import_vuu_codemirror4.getValue)(maybeTargetNode, state);
+  } else {
+    return void 0;
+  }
+};
+var getFilterName = (node, state) => {
+  if (node.name === "FilterName") {
+    return (0, import_vuu_codemirror4.getValue)(node, state);
+  } else {
+    let maybeTargetNode = node.prevSibling || node.parent || node.lastChild;
+    while (maybeTargetNode && maybeTargetNode.name !== "FilterName")
+      maybeTargetNode = maybeTargetNode.prevSibling;
+    if (maybeTargetNode && maybeTargetNode.name === "FilterName") {
+      return (0, import_vuu_codemirror4.getValue)(node, state);
+    }
+  }
+};
+var getColumnName = (node, state) => {
+  const prevNode = node.prevSibling;
+  if ((prevNode == null ? void 0 : prevNode.name) === "Column") {
+    return (0, import_vuu_codemirror4.getValue)(prevNode, state);
+  } else if ((prevNode == null ? void 0 : prevNode.name) === "Operator") {
+    return getColumnName(prevNode, state);
+  }
+};
+var getSetValues = (node, state) => {
+  let maybeTargetNode = node.lastChild;
+  const values = [];
+  while (maybeTargetNode && maybeTargetNode.name !== "In") {
+    const value = (0, import_vuu_codemirror4.getValue)(maybeTargetNode, state);
+    if (value) {
+      values.push(value);
+    } else {
+      break;
+    }
+    maybeTargetNode = maybeTargetNode.prevSibling;
+  }
+  return values;
+};
+var useAutoComplete = (suggestionProvider, onSubmit, existingFilter) => {
+  const makeSuggestions = (0, import_react12.useCallback)(
+    async (context, suggestionType, optionalArgs = {}) => {
+      const { startsWith = "" } = optionalArgs;
+      const options = await suggestionProvider.getSuggestions(
+        suggestionType,
+        optionalArgs
+      );
+      return { from: context.pos - startsWith.length, options };
+    },
+    [suggestionProvider]
+  );
+  return (0, import_react12.useCallback)(
+    async (context) => {
+      var _a, _b;
+      const { state, pos } = context;
+      const word = (_a = context.matchBefore(/\w*/)) != null ? _a : {
+        from: 0,
+        to: 0,
+        text: void 0
+      };
+      const tree = (0, import_vuu_codemirror4.syntaxTree)(state);
+      const nodeBefore = tree.resolveInner(pos, -1);
+      console.log({ nodeBeforeName: nodeBefore.name });
+      switch (nodeBefore.name) {
+        case "Filter":
+          if (context.pos === 0) {
+            return makeSuggestions(context, "column");
+          } else {
+            const clauseOperator = getClauseOperator(nodeBefore, state);
+            if (clauseOperator === "as") {
+              return makeSuggestions(context, "name");
+            } else {
+              const filterName = getFilterName(nodeBefore, state);
+              return makeSuggestions(context, "save", {
+                onSubmit: onSubmit.current,
+                existingFilter,
+                filterName
+              });
+            }
+          }
+        case "String":
+          {
+            const operator = getOperator(nodeBefore, state);
+            const columnName = getColumnName(nodeBefore, state);
+            const { from, to } = nodeBefore;
+            if (to - from === 2 && context.pos === from + 1) {
+              if (columnName && operator) {
+                return makeSuggestions(context, "columnValue", {
+                  columnName,
+                  operator,
+                  quoted: true,
+                  startsWith: word.text
+                });
+              }
+            } else {
+              console.log(
+                `we have a string, column is ${columnName} ${from} ${to}`
+              );
+            }
+          }
+          break;
+        case "As":
+          return makeSuggestions(context, "name");
+        case "FilterName":
+          return makeSuggestions(context, "save", {
+            onSubmit: onSubmit.current,
+            existingFilter,
+            filterName: getFilterName(nodeBefore, state)
+          });
+        case "Column": {
+          const columnName = (0, import_vuu_codemirror4.getValue)(nodeBefore, state);
+          const isPartialMatch = await suggestionProvider.isPartialMatch(
+            "column",
+            void 0,
+            columnName
+          );
+          if (isPartialMatch) {
+            return makeSuggestions(context, "column", {
+              startsWith: columnName
+            });
+          } else {
+            return makeSuggestions(context, "operator", { columnName });
+          }
+        }
+        case "\u26A0": {
+          const columnName = (0, import_vuu_codemirror4.getNodeByName)(nodeBefore, state);
+          const operator = getOperator(nodeBefore, state);
+          const partialOperator = operator ? void 0 : getPartialOperator(nodeBefore, state, columnName);
+          if (partialOperator) {
+            return makeSuggestions(context, "operator", {
+              columnName,
+              startsWith: partialOperator
+            });
+          } else {
+            return makeSuggestions(context, "columnValue", {
+              columnName,
+              operator,
+              startsWith: word.text
+            });
+          }
+        }
+        case "Identifier":
+          {
+            const clauseOperator = getClauseOperator(nodeBefore, state);
+            if (clauseOperator === "as") {
+              return {
+                from: context.pos,
+                options: [
+                  {
+                    label: "press ENTER to apply filter and save",
+                    apply: () => onSubmit.current(),
+                    boost: 5
+                  }
+                ]
+              };
+            }
+          }
+          break;
+        case "ColumnSetExpression":
+        case "Values": {
+          const columnName = (0, import_vuu_codemirror4.getNodeByName)(nodeBefore, state);
+          const selection = getSetValues(nodeBefore, state);
+          return makeSuggestions(context, "columnValue", {
+            columnName,
+            selection
+          });
+        }
+        case "Comma":
+        case "LBrack": {
+          const columnName = (0, import_vuu_codemirror4.getNodeByName)(nodeBefore, state);
+          return makeSuggestions(context, "columnValue", { columnName });
+        }
+        case "ColumnValueExpression":
+          {
+            const lastToken = (_b = nodeBefore.lastChild) == null ? void 0 : _b.prevSibling;
+            if ((lastToken == null ? void 0 : lastToken.name) === "Column") {
+              return makeSuggestions(context, "operator", {
+                columnName: (0, import_vuu_codemirror4.getNodeByName)(nodeBefore, state)
+              });
+            } else if ((lastToken == null ? void 0 : lastToken.name) === "Operator") {
+              return makeSuggestions(context, "columnValue", {
+                columnName: (0, import_vuu_codemirror4.getNodeByName)(lastToken, state),
+                operator: (0, import_vuu_codemirror4.getValue)(lastToken, state)
+              });
+            }
+          }
+          break;
+        case "In": {
+          return {
+            from: context.pos,
+            options: [{ label: "[", apply: " [", type: "text" }]
+          };
+        }
+        case "Eq": {
+          return makeSuggestions(context, "columnValue", {
+            columnName: (0, import_vuu_codemirror4.getNodeByName)(nodeBefore, state)
+          });
+        }
+        case "AndExpression":
+        case "OrExpression": {
+          return makeSuggestions(context, "column");
+        }
+        default:
+      }
+    },
+    [existingFilter, makeSuggestions, onSubmit, suggestionProvider]
+  );
+};
+
+// src/filter-input/useCodeMirrorEditor.ts
+var getView = (ref) => {
+  if (ref.current == void 0) {
+    throw Error("EditorView not defined");
+  }
+  return ref.current;
+};
+var getOptionClass = (completion) => {
+  return (0, import_classnames.default)("vuuSuggestion", {
+    vuuIllustration: completion.isIllustration
+  });
+};
+var stripName = (filterQuery) => {
+  const pos = filterQuery.lastIndexOf(" as ");
+  if (pos !== -1) {
+    return filterQuery.slice(0, pos);
+  } else {
+    return filterQuery;
+  }
+};
+var noop = () => console.log("noooop");
+var useCodeMirrorEditor = ({
+  existingFilter,
+  onSubmitFilter,
+  suggestionProvider
+}) => {
+  const editorRef = (0, import_react13.useRef)(null);
+  const onSubmit = (0, import_react13.useRef)(noop);
+  const viewRef = (0, import_react13.useRef)();
+  const completionFn = useAutoComplete(
+    suggestionProvider,
+    onSubmit,
+    existingFilter
+  );
+  const [createState, clearInput] = (0, import_react13.useMemo)(() => {
+    const parseFilter2 = () => {
+      const view = getView(viewRef);
+      const source = view.state.doc.toString();
+      const tree = (0, import_vuu_codemirror5.ensureSyntaxTree)(view.state, view.state.doc.length, 5e3);
+      if (tree) {
+        const filter = walkTree(tree, source);
+        return [filter, stripName(source), filter.name];
+      } else {
+        return [void 0, "", void 0];
+      }
+    };
+    const clearInput2 = () => {
+      getView(viewRef).setState(createState2());
+    };
+    const submitFilterAndClearInput = (mode) => {
+      const [filter, filterQuery, filterName] = parseFilter2();
+      onSubmitFilter == null ? void 0 : onSubmitFilter(filter, filterQuery, mode, filterName);
+      clearInput2();
+    };
+    const submitFilter = (key) => {
+      return import_vuu_codemirror5.keymap.of([
+        {
+          key,
+          run() {
+            submitFilterAndClearInput();
+            return true;
+          }
+        }
+      ]);
+    };
+    const showSuggestions = (key) => {
+      return import_vuu_codemirror5.keymap.of([
+        {
+          key,
+          run() {
+            (0, import_vuu_codemirror5.startCompletion)(getView(viewRef));
+            return true;
+          }
+        }
+      ]);
+    };
+    const createState2 = () => import_vuu_codemirror5.EditorState.create({
+      doc: "",
+      extensions: [
+        import_vuu_codemirror5.minimalSetup,
+        (0, import_vuu_codemirror5.autocompletion)({
+          override: [completionFn],
+          optionClass: getOptionClass
+        }),
+        filterLanguageSupport(),
+        import_vuu_codemirror5.keymap.of(import_vuu_codemirror5.defaultKeymap),
+        submitFilter("Ctrl-Enter"),
+        showSuggestions("ArrowDown"),
+        import_vuu_codemirror5.EditorView.updateListener.of((v) => {
+          const view = getView(viewRef);
+          if (v.docChanged) {
+            (0, import_vuu_codemirror5.startCompletion)(view);
+          }
+        }),
+        import_vuu_codemirror5.EditorState.transactionFilter.of(
+          (tr) => tr.newDoc.lines > 1 ? [] : tr
+        ),
+        vuuTheme,
+        vuuHighlighting
+      ]
+    });
+    onSubmit.current = (mode) => {
+      submitFilterAndClearInput(mode);
+      setTimeout(() => {
+        getView(viewRef).focus();
+      }, 100);
+    };
+    return [createState2, clearInput2];
+  }, [completionFn, onSubmitFilter]);
+  (0, import_react13.useEffect)(() => {
+    if (!editorRef.current) {
+      throw Error("editor not in dom");
+    }
+    viewRef.current = new import_vuu_codemirror5.EditorView({
+      state: createState(),
+      parent: editorRef.current
+    });
+    return () => {
+      var _a;
+      (_a = viewRef.current) == null ? void 0 : _a.destroy();
+    };
+  }, [completionFn, createState]);
+  return { editorRef, clearInput };
+};
+
+// src/filter-input/FilterInput.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var classBase = "vuuFilterInput";
+var FilterInput = ({
+  existingFilter,
+  iconName = "filter",
+  namedFilters,
+  onSubmitFilter,
+  suggestionProvider,
+  ...props
+}) => {
+  const { editorRef, clearInput } = useCodeMirrorEditor({
+    existingFilter,
+    onSubmitFilter,
+    suggestionProvider
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { ...props, className: classBase, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+      import_core2.Button,
+      {
+        className: `${classBase}-FilterButton`,
+        "data-icon": iconName,
+        tabIndex: -1
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { className: `${classBase}-Editor`, ref: editorRef }),
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+      import_core2.Button,
+      {
+        className: `${classBase}-ClearButton`,
+        "data-icon": "close-circle",
+        onClick: clearInput
+      }
+    )
+  ] });
+};
+
+// src/filter-input/useFilterSuggestionProvider.ts
+var import_vuu_codemirror6 = require("@vuu-ui/vuu-codemirror");
+var import_react14 = require("react");
+
+// src/filter-input/filterInfo.ts
+var import_vuu_utils6 = require("@vuu-ui/vuu-utils");
+var filterInfo = (filterName, filterQuery) => {
+  const rootElement = (0, import_vuu_utils6.createEl)("div", "vuuFunctionDoc");
+  const headingElement = (0, import_vuu_utils6.createEl)("div", "function-heading");
+  const nameElement = (0, import_vuu_utils6.createEl)("span", "function-name", filterName);
+  headingElement.appendChild(nameElement);
+  const child2 = (0, import_vuu_utils6.createEl)("p", void 0, filterQuery);
+  rootElement.appendChild(headingElement);
+  rootElement.appendChild(child2);
+  return rootElement;
+};
+
+// src/filter-input/useFilterSuggestionProvider.ts
+var NO_NAMED_FILTERS = [];
+var NONE = {};
+var saveAsTab = (onSubmit) => [
+  {
+    label: "Press ENTER to create TAB",
+    apply: () => onSubmit("tab"),
+    boost: 6
+  }
+];
+var makeSaveOrExtendSuggestions = (onSubmit, existingFilter, withJoinSuggestions = true) => {
+  const result = existingFilter ? [
+    {
+      label: "REPLACE existing filter",
+      apply: () => onSubmit("replace"),
+      boost: 8
+    },
+    {
+      label: "AND existing filter",
+      apply: () => onSubmit("and"),
+      boost: 7
+    },
+    {
+      label: "OR existing filter",
+      apply: () => onSubmit("or"),
+      boost: 7
+    }
+  ] : [
+    {
+      label: "Press ENTER to submit",
+      apply: () => onSubmit(),
+      boost: 6
+    }
+  ];
+  return withJoinSuggestions ? result.concat(import_vuu_codemirror6.booleanJoinSuggestions).concat(import_vuu_codemirror6.asNameSuggestion) : result;
+};
+var promptToSaveOrExtend = (onSubmit, existingFilter) => makeSaveOrExtendSuggestions(onSubmit, existingFilter, true);
+var promptToSave = (onSubmit) => makeSaveOrExtendSuggestions(onSubmit, void 0);
+var getSaveSuggestions = ({
+  existingFilter,
+  filterName,
+  onSubmit,
+  saveOptions
+}) => {
+  const includeTabSuggestion = filterName && saveOptions.allowSaveAsTab;
+  const result = existingFilter ? promptToSaveOrExtend(onSubmit, existingFilter) : promptToSave(onSubmit);
+  if (includeTabSuggestion) {
+    return result.concat(saveAsTab(onSubmit));
+  } else {
+    return result;
+  }
+};
+var suggestColumns = (columns) => columns.map((column) => ({
+  boost: 5,
+  label: column.name
+}));
+var suggestNamedFilters = (namedFilters) => namedFilters ? Array.from(namedFilters.entries()).map(([filterName, filterQuery]) => ({
+  info: () => filterInfo(filterName, filterQuery),
+  label: filterName,
+  type: "filter"
+})) : NO_NAMED_FILTERS;
+var doneCommand = {
+  label: "Done",
+  apply: "] ",
+  type: "keyword",
+  boost: 10
+};
+var withApplySpace = (suggestions, startsWith = "") => suggestions.filter((sugg) => startsWith === "" || sugg.label.startsWith(startsWith)).map((suggestion) => ({
+  ...suggestion,
+  apply: suggestion.label + " "
+}));
+var defaultSaveOptions = {
+  allowReplace: true
+};
+var useFilterSuggestionProvider = ({
+  columns,
+  namedFilters,
+  saveOptions = defaultSaveOptions,
+  table,
+  typeaheadHook: useTypeahead = useTypeaheadSuggestions
+}) => {
+  const latestSuggestionsRef = (0, import_react14.useRef)();
+  const getTypeaheadSuggestions = useTypeahead();
+  const getSuggestions = (0, import_react14.useCallback)(
+    async (suggestionType, options = NONE) => {
+      const {
+        columnName,
+        existingFilter,
+        filterName,
+        operator,
+        quoted: autoQuoted,
+        onSubmit,
+        startsWith,
+        selection
+      } = options;
+      switch (suggestionType) {
+        case "operator":
+          {
+            const column = columns.find((col) => col.name === columnName);
+            if (column) {
+              switch (column.serverDataType) {
+                case "string":
+                case "char":
+                  return withApplySpace(import_vuu_codemirror6.stringOperators, startsWith);
+                case "int":
+                case "long":
+                case "double":
+                  return withApplySpace(import_vuu_codemirror6.numericOperators);
+              }
+            } else {
+              console.warn(`'${columnName}' does not match any column name`);
+            }
+          }
+          break;
+        case "column": {
+          const columnSuggestions = await suggestColumns(columns);
+          const filterSuggestions = await suggestNamedFilters(namedFilters);
+          return (latestSuggestionsRef.current = withApplySpace(columnSuggestions)).concat(
+            withApplySpace(filterSuggestions)
+          );
+        }
+        case "columnValue":
+          {
+            if (columnName) {
+              const column = columns.find((col) => col.name === columnName);
+              if (!column) {
+                throw Error(
+                  `useFilterSUggestionProvider no column ${columnName}`
+                );
+              }
+              const prefix = Array.isArray(selection) ? selection.length === 0 ? "[" : "," : "";
+              const params = getTypeaheadParams(
+                table,
+                columnName,
+                startsWith
+              );
+              const suggestions = await getTypeaheadSuggestions(params);
+              const isIllustration = operator === "starts";
+              latestSuggestionsRef.current = (0, import_vuu_codemirror6.toSuggestions)(suggestions, {
+                moveCursorToEnd: autoQuoted,
+                quoted: (column == null ? void 0 : column.serverDataType) === "string" && !autoQuoted,
+                suffix: autoQuoted ? "" : " ",
+                prefix: isIllustration ? startsWith : prefix,
+                isIllustration
+              });
+              if (Array.isArray(selection) && (selection == null ? void 0 : selection.length) > 1) {
+                return [doneCommand, ...latestSuggestionsRef.current];
+              }
+              return latestSuggestionsRef.current;
+            }
+          }
+          break;
+        case "save": {
+          if (typeof onSubmit !== "function") {
+            throw Error(
+              "useFilterSuggestionProvider, onSubmit must be supplied for 'save' suggestions"
+            );
+          }
+          return await getSaveSuggestions({
+            existingFilter,
+            filterName,
+            onSubmit,
+            saveOptions
+          });
+        }
+        case "name":
+          return await (0, import_vuu_codemirror6.getNamePrompt)("filter");
+        default:
+      }
+      return [];
+    },
+    [columns, getTypeaheadSuggestions, namedFilters, saveOptions, table]
+  );
+  const isPartialMatch = (0, import_react14.useCallback)(
+    async (valueType, columnName, pattern) => {
+      const suggestions = (
+        // latestSuggestions && latestSuggestions.length > 0
+        //   ? latestSuggestions
+        await getSuggestions(valueType, { columnName })
+      );
+      if (pattern && suggestions) {
+        for (const option of suggestions) {
+          if (option.label === pattern) {
+            return false;
+          } else if (option.label.startsWith(pattern)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    },
+    [getSuggestions]
+  );
+  return {
+    getSuggestions,
+    isPartialMatch
+  };
+};
+
+// src/filter-toolbar/FilterToolbar.tsx
+var import_salt_lab8 = require("@heswell/salt-lab");
+var import_classnames2 = __toESM(require_classnames(), 1);
+
+// src/filter-toolbar/useFilterToolbar.tsx
+var import_vuu_utils7 = require("@vuu-ui/vuu-utils");
+var import_salt_lab7 = require("@heswell/salt-lab");
+
+// src/filter-toolbar/FilterDropdown.tsx
+var import_salt_lab5 = require("@heswell/salt-lab");
+var import_react15 = require("react");
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var isString = (s) => typeof s === "string";
+var stripQuotes = (selected) => {
+  if (isString(selected)) {
+    if (selected.startsWith('"') && selected.endsWith('"')) {
+      return selected.slice(1, -1);
+    } else {
+      return selected;
+    }
+  } else {
+    return selected.map(stripQuotes);
+  }
+};
+var FilterDropdown = ({
+  column,
+  selected: selectedProp,
+  suggestionProvider,
+  ...props
+}) => {
+  const selected = selectedProp != null ? stripQuotes(selectedProp) : void 0;
+  const initialValues = Array.isArray(selected) ? selected : selected != null ? [selected] : [];
+  const [values, setValues] = (0, import_react15.useState)(initialValues);
+  console.log({ initialValues });
+  const handleOpenChange = (0, import_react15.useCallback)(
+    async (isOpen) => {
+      if (isOpen) {
+        const values2 = await suggestionProvider.getSuggestions("columnValue", {
+          columnName: column
+        });
+        console.log({ values: values2 });
+        setValues(values2.map((suggestion) => suggestion.label));
+      }
+    },
+    [column, suggestionProvider]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    import_salt_lab5.Dropdown,
+    {
+      ...props,
+      onOpenChange: handleOpenChange,
+      selected,
+      source: values
+    }
+  );
+};
+
+// src/filter-toolbar/FilterDropdownMultiSelect.tsx
+var import_salt_lab6 = require("@heswell/salt-lab");
+var import_react16 = require("react");
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var isString2 = (s) => typeof s === "string";
+var stripQuotes2 = (selected) => {
+  if (selected === void 0) {
+    return void 0;
+  } else if (isString2(selected)) {
+    if (selected.startsWith('"') && selected.endsWith('"')) {
+      return selected.slice(1, -1);
+    } else {
+      return selected;
+    }
+  } else {
+    return selected.map(stripQuotes2);
+  }
+};
+var FilterDropdownMultiSelect = ({
+  column,
+  selected: selectedProp,
+  suggestionProvider,
+  ...props
+}) => {
+  const selected = stripQuotes2(selectedProp);
+  const initialValues = Array.isArray(selected) ? selected : selected != null ? [selected] : [];
+  const [values, setValues] = (0, import_react16.useState)(initialValues);
+  const handleOpenChange = (0, import_react16.useCallback)(
+    async (isOpen) => {
+      if (isOpen) {
+        const values2 = await suggestionProvider.getSuggestions("columnValue", {
+          columnName: column
+        });
+        console.log({ values: values2 });
+        setValues(values2.map((suggestion) => suggestion.label));
+      }
+    },
+    [column, suggestionProvider]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+    import_salt_lab6.Dropdown,
+    {
+      ...props,
+      onOpenChange: handleOpenChange,
+      selected,
+      selectionStrategy: "multiple",
+      source: values
+    }
+  );
+};
+
+// src/filter-toolbar/useFilterToolbar.tsx
+var import_jsx_runtime10 = require("react/jsx-runtime");
+var filterToControl = (filter, suggestionProvider) => {
+  if ((0, import_vuu_utils7.isNamedFilter)(filter)) {
+    return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+      import_salt_lab7.ToggleButton,
+      {
+        className: "vuuToggleButton",
+        toggled: true,
+        variant: "secondary",
+        children: filter.name
+      }
+    );
+  }
+  if ((0, import_vuu_utils7.isSingleValueFilter)(filter)) {
+    const { column, value } = filter;
+    return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+      import_salt_lab7.ToolbarField,
+      {
+        className: "vuuFilterDropdown",
+        label: column,
+        labelPlacement: "top",
+        children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+          FilterDropdown,
+          {
+            column,
+            selected: value.toString(),
+            selectionStrategy: "default",
+            source: [value.toString()],
+            suggestionProvider,
+            style: { width: 100 }
+          }
+        )
+      },
+      column
+    );
+  }
+  if ((0, import_vuu_utils7.isMultiValueFilter)(filter)) {
+    const values = filter.values.map((v) => v.toString());
+    return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+      import_salt_lab7.ToolbarField,
+      {
+        className: "vuuFilterDropdown",
+        label: filter.column,
+        labelPlacement: "top",
+        children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+          FilterDropdownMultiSelect,
+          {
+            column: filter.column,
+            selected: values,
+            source: values,
+            suggestionProvider,
+            style: { width: 100 }
+          }
+        )
+      },
+      filter.column
+    );
+  }
+  return filter.filters.map(
+    (filter2) => filterToControl(filter2, suggestionProvider)
+  );
+};
+var useFilterToolbar = ({
+  filter,
+  suggestionProvider
+}) => {
+  if (filter) {
+    return filterToControl(filter, suggestionProvider);
+  }
+  return [];
+};
+
+// src/filter-toolbar/FilterToolbar.tsx
+var import_jsx_runtime11 = require("react/jsx-runtime");
+var FilterToolbar = ({
+  className,
+  filter,
+  suggestionProvider,
+  ...props
+}) => {
+  console.log(`FilterToolbar ${JSON.stringify(filter, null, 2)}`);
+  const toolbarItems = useFilterToolbar({ filter, suggestionProvider });
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_salt_lab8.Toolbar, { className: (0, import_classnames2.default)("vuuFilterToolbar", className), ...props, children: toolbarItems });
+};
 /*! Bundled license information:
 
 classnames/index.js: