@teselagen/ove 0.8.9 → 0.8.10

package/index.es.js

@@ -10749,7 +10749,7 @@ const _AbstractPointerSensor = class _AbstractPointerSensor {
 };
 __name(_AbstractPointerSensor, "AbstractPointerSensor");
 let AbstractPointerSensor = _AbstractPointerSensor;
-const events = {
+const events$1 = {
   move: {
     name: "pointermove"
   },
@@ -10763,7 +10763,7 @@ const _PointerSensor = class _PointerSensor extends AbstractPointerSensor {
       event
     } = props;
     const listenerTarget = getOwnerDocument(event.target);
-    super(props, events, listenerTarget);
+    super(props, events$1, listenerTarget);
   }
 };
 __name(_PointerSensor, "PointerSensor");
@@ -10786,7 +10786,7 @@ PointerSensor.activators = [{
     return true;
   }, "handler")
 }];
-const events$1 = {
+const events$1$1 = {
   move: {
     name: "mousemove"
   },
@@ -10800,7 +10800,7 @@ var MouseButton;
 })(MouseButton || (MouseButton = {}));
 const _MouseSensor = class _MouseSensor extends AbstractPointerSensor {
   constructor(props) {
-    super(props, events$1, getOwnerDocument(props.event.target));
+    super(props, events$1$1, getOwnerDocument(props.event.target));
   }
 };
 __name(_MouseSensor, "MouseSensor");
@@ -18200,7 +18200,7 @@ const __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Ob
   __proto__: null,
   default: __viteBrowserExternal
 }, Symbol.toStringTag, { value: "Module" }));
-const require$$0 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
+const require$$3$1 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
 var objectInspect;
 var hasRequiredObjectInspect;
 function requireObjectInspect() {
@@ -18258,7 +18258,7 @@ function requireObjectInspect() {
     return $replace.call(str, sepRegex, "$&_");
   }
   __name(addNumericSeparator, "addNumericSeparator");
-  var utilInspect = require$$0;
+  var utilInspect = require$$3$1;
   var inspectCustom = utilInspect.custom;
   var inspectSymbol = isSymbol2(inspectCustom) ? inspectCustom : null;
   objectInspect = /* @__PURE__ */ __name(function inspect_(obj, options, depth, seen) {
@@ -19723,6 +19723,9 @@ function tableQueryParamsToHasuraClauses({
       } else {
         if (path2) {
           const allPaths = [path2, ...additionalSearchPaths];
+          if (allPaths.length > 1) {
+            return { _or: allPaths.map((p2) => addColumnFilters(p2)) };
+          }
           return allPaths.map((p2) => addColumnFilters(p2));
         } else {
           return addColumnFilters(filterOn);
@@ -90016,6 +90019,392 @@ function convertBasePosTraceToPerBpTrace(chromData) {
   }, chromData);
 }
 __name(convertBasePosTraceToPerBpTrace, "convertBasePosTraceToPerBpTrace");
+var events = { exports: {} };
+var hasRequiredEvents;
+function requireEvents() {
+  if (hasRequiredEvents) return events.exports;
+  hasRequiredEvents = 1;
+  var R2 = typeof Reflect === "object" ? Reflect : null;
+  var ReflectApply = R2 && typeof R2.apply === "function" ? R2.apply : /* @__PURE__ */ __name(function ReflectApply2(target, receiver, args) {
+    return Function.prototype.apply.call(target, receiver, args);
+  }, "ReflectApply");
+  var ReflectOwnKeys;
+  if (R2 && typeof R2.ownKeys === "function") {
+    ReflectOwnKeys = R2.ownKeys;
+  } else if (Object.getOwnPropertySymbols) {
+    ReflectOwnKeys = /* @__PURE__ */ __name(function ReflectOwnKeys2(target) {
+      return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
+    }, "ReflectOwnKeys");
+  } else {
+    ReflectOwnKeys = /* @__PURE__ */ __name(function ReflectOwnKeys2(target) {
+      return Object.getOwnPropertyNames(target);
+    }, "ReflectOwnKeys");
+  }
+  function ProcessEmitWarning(warning) {
+    if (console && console.warn) console.warn(warning);
+  }
+  __name(ProcessEmitWarning, "ProcessEmitWarning");
+  var NumberIsNaN = Number.isNaN || /* @__PURE__ */ __name(function NumberIsNaN2(value) {
+    return value !== value;
+  }, "NumberIsNaN");
+  function EventEmitter() {
+    EventEmitter.init.call(this);
+  }
+  __name(EventEmitter, "EventEmitter");
+  events.exports = EventEmitter;
+  events.exports.once = once2;
+  EventEmitter.EventEmitter = EventEmitter;
+  EventEmitter.prototype._events = void 0;
+  EventEmitter.prototype._eventsCount = 0;
+  EventEmitter.prototype._maxListeners = void 0;
+  var defaultMaxListeners = 10;
+  function checkListener(listener) {
+    if (typeof listener !== "function") {
+      throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+    }
+  }
+  __name(checkListener, "checkListener");
+  Object.defineProperty(EventEmitter, "defaultMaxListeners", {
+    enumerable: true,
+    get: /* @__PURE__ */ __name(function() {
+      return defaultMaxListeners;
+    }, "get"),
+    set: /* @__PURE__ */ __name(function(arg) {
+      if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
+        throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
+      }
+      defaultMaxListeners = arg;
+    }, "set")
+  });
+  EventEmitter.init = function() {
+    if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
+      this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+    }
+    this._maxListeners = this._maxListeners || void 0;
+  };
+  EventEmitter.prototype.setMaxListeners = /* @__PURE__ */ __name(function setMaxListeners(n2) {
+    if (typeof n2 !== "number" || n2 < 0 || NumberIsNaN(n2)) {
+      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n2 + ".");
+    }
+    this._maxListeners = n2;
+    return this;
+  }, "setMaxListeners");
+  function _getMaxListeners(that) {
+    if (that._maxListeners === void 0)
+      return EventEmitter.defaultMaxListeners;
+    return that._maxListeners;
+  }
+  __name(_getMaxListeners, "_getMaxListeners");
+  EventEmitter.prototype.getMaxListeners = /* @__PURE__ */ __name(function getMaxListeners() {
+    return _getMaxListeners(this);
+  }, "getMaxListeners");
+  EventEmitter.prototype.emit = /* @__PURE__ */ __name(function emit(type2) {
+    var args = [];
+    for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+    var doError = type2 === "error";
+    var events2 = this._events;
+    if (events2 !== void 0)
+      doError = doError && events2.error === void 0;
+    else if (!doError)
+      return false;
+    if (doError) {
+      var er;
+      if (args.length > 0)
+        er = args[0];
+      if (er instanceof Error) {
+        throw er;
+      }
+      var err2 = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
+      err2.context = er;
+      throw err2;
+    }
+    var handler = events2[type2];
+    if (handler === void 0)
+      return false;
+    if (typeof handler === "function") {
+      ReflectApply(handler, this, args);
+    } else {
+      var len = handler.length;
+      var listeners = arrayClone(handler, len);
+      for (var i = 0; i < len; ++i)
+        ReflectApply(listeners[i], this, args);
+    }
+    return true;
+  }, "emit");
+  function _addListener(target, type2, listener, prepend) {
+    var m2;
+    var events2;
+    var existing;
+    checkListener(listener);
+    events2 = target._events;
+    if (events2 === void 0) {
+      events2 = target._events = /* @__PURE__ */ Object.create(null);
+      target._eventsCount = 0;
+    } else {
+      if (events2.newListener !== void 0) {
+        target.emit(
+          "newListener",
+          type2,
+          listener.listener ? listener.listener : listener
+        );
+        events2 = target._events;
+      }
+      existing = events2[type2];
+    }
+    if (existing === void 0) {
+      existing = events2[type2] = listener;
+      ++target._eventsCount;
+    } else {
+      if (typeof existing === "function") {
+        existing = events2[type2] = prepend ? [listener, existing] : [existing, listener];
+      } else if (prepend) {
+        existing.unshift(listener);
+      } else {
+        existing.push(listener);
+      }
+      m2 = _getMaxListeners(target);
+      if (m2 > 0 && existing.length > m2 && !existing.warned) {
+        existing.warned = true;
+        var w2 = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type2) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+        w2.name = "MaxListenersExceededWarning";
+        w2.emitter = target;
+        w2.type = type2;
+        w2.count = existing.length;
+        ProcessEmitWarning(w2);
+      }
+    }
+    return target;
+  }
+  __name(_addListener, "_addListener");
+  EventEmitter.prototype.addListener = /* @__PURE__ */ __name(function addListener(type2, listener) {
+    return _addListener(this, type2, listener, false);
+  }, "addListener");
+  EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+  EventEmitter.prototype.prependListener = /* @__PURE__ */ __name(function prependListener(type2, listener) {
+    return _addListener(this, type2, listener, true);
+  }, "prependListener");
+  function onceWrapper() {
+    if (!this.fired) {
+      this.target.removeListener(this.type, this.wrapFn);
+      this.fired = true;
+      if (arguments.length === 0)
+        return this.listener.call(this.target);
+      return this.listener.apply(this.target, arguments);
+    }
+  }
+  __name(onceWrapper, "onceWrapper");
+  function _onceWrap(target, type2, listener) {
+    var state2 = { fired: false, wrapFn: void 0, target, type: type2, listener };
+    var wrapped = onceWrapper.bind(state2);
+    wrapped.listener = listener;
+    state2.wrapFn = wrapped;
+    return wrapped;
+  }
+  __name(_onceWrap, "_onceWrap");
+  EventEmitter.prototype.once = /* @__PURE__ */ __name(function once3(type2, listener) {
+    checkListener(listener);
+    this.on(type2, _onceWrap(this, type2, listener));
+    return this;
+  }, "once");
+  EventEmitter.prototype.prependOnceListener = /* @__PURE__ */ __name(function prependOnceListener(type2, listener) {
+    checkListener(listener);
+    this.prependListener(type2, _onceWrap(this, type2, listener));
+    return this;
+  }, "prependOnceListener");
+  EventEmitter.prototype.removeListener = /* @__PURE__ */ __name(function removeListener(type2, listener) {
+    var list2, events2, position2, i, originalListener;
+    checkListener(listener);
+    events2 = this._events;
+    if (events2 === void 0)
+      return this;
+    list2 = events2[type2];
+    if (list2 === void 0)
+      return this;
+    if (list2 === listener || list2.listener === listener) {
+      if (--this._eventsCount === 0)
+        this._events = /* @__PURE__ */ Object.create(null);
+      else {
+        delete events2[type2];
+        if (events2.removeListener)
+          this.emit("removeListener", type2, list2.listener || listener);
+      }
+    } else if (typeof list2 !== "function") {
+      position2 = -1;
+      for (i = list2.length - 1; i >= 0; i--) {
+        if (list2[i] === listener || list2[i].listener === listener) {
+          originalListener = list2[i].listener;
+          position2 = i;
+          break;
+        }
+      }
+      if (position2 < 0)
+        return this;
+      if (position2 === 0)
+        list2.shift();
+      else {
+        spliceOne2(list2, position2);
+      }
+      if (list2.length === 1)
+        events2[type2] = list2[0];
+      if (events2.removeListener !== void 0)
+        this.emit("removeListener", type2, originalListener || listener);
+    }
+    return this;
+  }, "removeListener");
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+  EventEmitter.prototype.removeAllListeners = /* @__PURE__ */ __name(function removeAllListeners(type2) {
+    var listeners, events2, i;
+    events2 = this._events;
+    if (events2 === void 0)
+      return this;
+    if (events2.removeListener === void 0) {
+      if (arguments.length === 0) {
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+      } else if (events2[type2] !== void 0) {
+        if (--this._eventsCount === 0)
+          this._events = /* @__PURE__ */ Object.create(null);
+        else
+          delete events2[type2];
+      }
+      return this;
+    }
+    if (arguments.length === 0) {
+      var keys3 = Object.keys(events2);
+      var key;
+      for (i = 0; i < keys3.length; ++i) {
+        key = keys3[i];
+        if (key === "removeListener") continue;
+        this.removeAllListeners(key);
+      }
+      this.removeAllListeners("removeListener");
+      this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+      return this;
+    }
+    listeners = events2[type2];
+    if (typeof listeners === "function") {
+      this.removeListener(type2, listeners);
+    } else if (listeners !== void 0) {
+      for (i = listeners.length - 1; i >= 0; i--) {
+        this.removeListener(type2, listeners[i]);
+      }
+    }
+    return this;
+  }, "removeAllListeners");
+  function _listeners(target, type2, unwrap2) {
+    var events2 = target._events;
+    if (events2 === void 0)
+      return [];
+    var evlistener = events2[type2];
+    if (evlistener === void 0)
+      return [];
+    if (typeof evlistener === "function")
+      return unwrap2 ? [evlistener.listener || evlistener] : [evlistener];
+    return unwrap2 ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+  }
+  __name(_listeners, "_listeners");
+  EventEmitter.prototype.listeners = /* @__PURE__ */ __name(function listeners(type2) {
+    return _listeners(this, type2, true);
+  }, "listeners");
+  EventEmitter.prototype.rawListeners = /* @__PURE__ */ __name(function rawListeners(type2) {
+    return _listeners(this, type2, false);
+  }, "rawListeners");
+  EventEmitter.listenerCount = function(emitter, type2) {
+    if (typeof emitter.listenerCount === "function") {
+      return emitter.listenerCount(type2);
+    } else {
+      return listenerCount.call(emitter, type2);
+    }
+  };
+  EventEmitter.prototype.listenerCount = listenerCount;
+  function listenerCount(type2) {
+    var events2 = this._events;
+    if (events2 !== void 0) {
+      var evlistener = events2[type2];
+      if (typeof evlistener === "function") {
+        return 1;
+      } else if (evlistener !== void 0) {
+        return evlistener.length;
+      }
+    }
+    return 0;
+  }
+  __name(listenerCount, "listenerCount");
+  EventEmitter.prototype.eventNames = /* @__PURE__ */ __name(function eventNames() {
+    return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+  }, "eventNames");
+  function arrayClone(arr, n2) {
+    var copy = new Array(n2);
+    for (var i = 0; i < n2; ++i)
+      copy[i] = arr[i];
+    return copy;
+  }
+  __name(arrayClone, "arrayClone");
+  function spliceOne2(list2, index2) {
+    for (; index2 + 1 < list2.length; index2++)
+      list2[index2] = list2[index2 + 1];
+    list2.pop();
+  }
+  __name(spliceOne2, "spliceOne");
+  function unwrapListeners(arr) {
+    var ret = new Array(arr.length);
+    for (var i = 0; i < ret.length; ++i) {
+      ret[i] = arr[i].listener || arr[i];
+    }
+    return ret;
+  }
+  __name(unwrapListeners, "unwrapListeners");
+  function once2(emitter, name2) {
+    return new Promise(function(resolve, reject) {
+      function errorListener(err2) {
+        emitter.removeListener(name2, resolver2);
+        reject(err2);
+      }
+      __name(errorListener, "errorListener");
+      function resolver2() {
+        if (typeof emitter.removeListener === "function") {
+          emitter.removeListener("error", errorListener);
+        }
+        resolve([].slice.call(arguments));
+      }
+      __name(resolver2, "resolver");
+      eventTargetAgnosticAddListener(emitter, name2, resolver2, { once: true });
+      if (name2 !== "error") {
+        addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+      }
+    });
+  }
+  __name(once2, "once");
+  function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+    if (typeof emitter.on === "function") {
+      eventTargetAgnosticAddListener(emitter, "error", handler, flags);
+    }
+  }
+  __name(addErrorHandlerIfEventEmitter, "addErrorHandlerIfEventEmitter");
+  function eventTargetAgnosticAddListener(emitter, name2, listener, flags) {
+    if (typeof emitter.on === "function") {
+      if (flags.once) {
+        emitter.once(name2, listener);
+      } else {
+        emitter.on(name2, listener);
+      }
+    } else if (typeof emitter.addEventListener === "function") {
+      emitter.addEventListener(name2, /* @__PURE__ */ __name(function wrapListener(arg) {
+        if (flags.once) {
+          emitter.removeEventListener(name2, wrapListener);
+        }
+        listener(arg);
+      }, "wrapListener"));
+    } else {
+      throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+    }
+  }
+  __name(eventTargetAgnosticAddListener, "eventTargetAgnosticAddListener");
+  return events.exports;
+}
+__name(requireEvents, "requireEvents");
 var inherits_browser = { exports: {} };
 var hasRequiredInherits_browser;
 function requireInherits_browser() {
@@ -90055,7 +90444,7 @@ var hasRequiredStreamBrowser;
 function requireStreamBrowser() {
   if (hasRequiredStreamBrowser) return streamBrowser;
   hasRequiredStreamBrowser = 1;
-  streamBrowser = require$$0.EventEmitter;
+  streamBrowser = requireEvents().EventEmitter;
   return streamBrowser;
 }
 __name(requireStreamBrowser, "requireStreamBrowser");
@@ -90136,7 +90525,7 @@ function requireBuffer_list() {
   }
   __name(_toPrimitive2, "_toPrimitive");
   var _require = requireBuffer(), Buffer2 = _require.Buffer;
-  var _require2 = require$$0, inspect = _require2.inspect;
+  var _require2 = require$$3$1, inspect = _require2.inspect;
   var custom = inspect && inspect.custom || "inspect";
   function copyBuffer(src2, target, offset4) {
     Buffer2.prototype.copy.call(src2, target, offset4);
@@ -91477,7 +91866,7 @@ function require_stream_readable() {
   _stream_readable = Readable;
   var Duplex;
   Readable.ReadableState = ReadableState;
-  require$$0.EventEmitter;
+  requireEvents().EventEmitter;
   var EElistenerCount = /* @__PURE__ */ __name(function EElistenerCount2(emitter, type2) {
     return emitter.listeners(type2).length;
   }, "EElistenerCount");
@@ -91493,7 +91882,7 @@ function require_stream_readable() {
     return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
   }
   __name(_isUint8Array, "_isUint8Array");
-  var debugUtil = require$$0;
+  var debugUtil = require$$3$1;
   var debug;
   if (debugUtil && debugUtil.debuglog) {
     debug = debugUtil.debuglog("stream");
@@ -92450,7 +92839,7 @@ function requireStreamBrowserify() {
   if (hasRequiredStreamBrowserify) return streamBrowserify;
   hasRequiredStreamBrowserify = 1;
   streamBrowserify = Stream;
-  var EE = require$$0.EventEmitter;
+  var EE = requireEvents().EventEmitter;
   var inherits = requireInherits_browser();
   inherits(Stream, EE);
   Stream.Readable = require_stream_readable();
@@ -116223,7 +116612,7 @@ function showFileDialog({ multiple = false, onSelect }) {
   input.click();
 }
 __name(showFileDialog, "showFileDialog");
-const version = "0.8.8";
+const version = "0.8.9";
 const packageJson = {
   version
 };
@@ -143429,6 +143818,7 @@ const genericAnnotationProperties = /* @__PURE__ */ __name(({
           isProtein: isProtein2,
           compact: true,
           isInfinite: true,
+          withDisplayOptions: true,
           schema: this.schema,
           entities: annotationsToUse
         }