map-2d-base 1.0.0

package/README.md

@@ -0,0 +1,3 @@
+# 乾坤库的底层基础
+
+

package/dist/assets/map-2d-base.css

@@ -0,0 +1 @@
+:host,:root{--ol-background-color:#fff;--ol-accent-background-color:#f5f5f5;--ol-subtle-background-color:hsla(0,0%,50%,.25);--ol-partial-background-color:hsla(0,0%,100%,.75);--ol-foreground-color:#333;--ol-subtle-foreground-color:#666;--ol-brand-color:#0af}.ol-box{background-color:var(--ol-partial-background-color);border:.00781rem solid var(--ol-background-color);border-radius:.01042rem;box-sizing:border-box}.ol-mouse-position{position:absolute;right:.04167rem;top:.04167rem}.ol-scale-line{background:var(--ol-partial-background-color);border-radius:.02083rem;bottom:.04167rem;left:.04167rem;padding:.01042rem;position:absolute}.ol-scale-line-inner{border:.00521rem solid var(--ol-subtle-foreground-color);border-top:none;color:var(--ol-foreground-color);font-size:.05208rem;margin:.00521rem;text-align:center;transition:all .25s;will-change:contents,width}.ol-scale-bar{bottom:.04167rem;left:.04167rem;position:absolute}.ol-scale-bar-inner{display:flex}.ol-scale-step-marker{background-color:var(--ol-foreground-color);float:right;height:.07813rem;width:.00521rem;z-index:10}.ol-scale-step-text{bottom:-.02604rem;font-size:.05208rem;z-index:11}.ol-scale-step-text,.ol-scale-text{color:var(--ol-foreground-color);position:absolute;text-shadow:-.00781rem 0 var(--ol-partial-background-color),0 .00781rem var(--ol-partial-background-color),.00781rem 0 var(--ol-partial-background-color),0 -.00781rem var(--ol-partial-background-color)}.ol-scale-text{bottom:.13021rem;font-size:.0625rem;text-align:center}.ol-scale-singlebar{border:.00521rem solid var(--ol-foreground-color);box-sizing:border-box;height:.05208rem;position:relative;z-index:9}.ol-scale-singlebar-even{background-color:var(--ol-subtle-foreground-color)}.ol-scale-singlebar-odd{background-color:var(--ol-background-color)}.ol-unsupported{display:none}.ol-unselectable,.ol-viewport{-webkit-touch-callout:none;-webkit-user-select:none;-moz-user-select:none;user-select:none;-webkit-tap-highlight-color:transparent}.ol-viewport canvas{all:unset;overflow:hidden}.ol-viewport{touch-action:pan-x pan-y}.ol-selectable{-webkit-touch-callout:default;-webkit-user-select:text;-moz-user-select:text;user-select:text}.ol-grabbing{cursor:grabbing}.ol-grab{cursor:move;cursor:grab}.ol-control{background-color:var(--ol-subtle-background-color);border-radius:.02083rem;position:absolute}.ol-zoom{left:.5em;top:.5em}.ol-rotate{right:.5em;top:.5em;transition:opacity .25s linear,visibility 0s linear}.ol-rotate.ol-hidden{opacity:0;transition:opacity .25s linear,visibility 0s linear .25s;visibility:hidden}.ol-zoom-extent{left:.5em;top:4.643em}.ol-full-screen{right:.5em;top:.5em}.ol-control button{background-color:var(--ol-background-color);border:none;border-radius:.01042rem;color:var(--ol-subtle-foreground-color);display:block;font-size:inherit;font-weight:700;height:1.375em;line-height:.4em;margin:.00521rem;padding:0;text-align:center;text-decoration:none;width:1.375em}.ol-control button::-moz-focus-inner{border:none;padding:0}.ol-zoom-extent button{line-height:1.4em}.ol-compass{display:block;font-weight:400;will-change:transform}.ol-touch .ol-control button{font-size:1.5em}.ol-touch .ol-zoom-extent{top:5.5em}.ol-control button:focus,.ol-control button:hover{color:var(--ol-foreground-color);outline:.00521rem solid var(--ol-subtle-foreground-color);text-decoration:none}.ol-zoom .ol-zoom-in{border-radius:.01042rem .01042rem 0 0}.ol-zoom .ol-zoom-out{border-radius:0 0 .01042rem .01042rem}.ol-attribution{align-items:center;bottom:.5em;display:flex;flex-flow:row-reverse;max-width:calc(100% - 1.3em);right:.5em;text-align:right}.ol-attribution a{color:var(--ol-subtle-foreground-color);text-decoration:none}.ol-attribution ul{color:var(--ol-foreground-color);font-size:.0625rem;margin:0;padding:.00521rem .5em;text-shadow:0 0 .01042rem var(--ol-background-color)}.ol-attribution li{display:inline;list-style:none}.ol-attribution li:not(:last-child):after{content:" "}.ol-attribution img{max-height:2em;max-width:inherit;vertical-align:middle}.ol-attribution button{flex-shrink:0}.ol-attribution.ol-collapsed ul{display:none}.ol-attribution:not(.ol-collapsed){background:var(--ol-partial-background-color)}.ol-attribution.ol-uncollapsible{border-radius:.02083rem 0 0;bottom:0;right:0}.ol-attribution.ol-uncollapsible img{margin-top:-.2em;max-height:1.6em}.ol-attribution.ol-uncollapsible button{display:none}.ol-zoomslider{height:1.04167rem;left:.5em;top:4.5em}.ol-zoomslider button{height:.05208rem;position:relative}.ol-touch .ol-zoomslider{top:5.5em}.ol-overviewmap{bottom:.5em;left:.5em}.ol-overviewmap.ol-uncollapsible{border-radius:0 .02083rem 0 0;bottom:0;left:0}.ol-overviewmap .ol-overviewmap-map,.ol-overviewmap button{display:block}.ol-overviewmap .ol-overviewmap-map{border:.00521rem solid var(--ol-subtle-foreground-color);height:.78125rem;width:.78125rem}.ol-overviewmap:not(.ol-collapsed) button{bottom:0;left:0;position:absolute}.ol-overviewmap.ol-collapsed .ol-overviewmap-map,.ol-overviewmap.ol-uncollapsible button{display:none}.ol-overviewmap:not(.ol-collapsed){background:var(--ol-subtle-background-color)}.ol-overviewmap-box{border:.00781rem dotted var(--ol-subtle-foreground-color)}.ol-overviewmap .ol-overviewmap-box:hover{cursor:move}.ol-overviewmap .ol-viewport:hover{cursor:pointer}

package/dist/chunks/asserts-B5CSgOpZ.js

@@ -0,0 +1,713 @@
+const ObjectEventType = {
+  /**
+   * Triggered when a property is changed.
+   * @event module:ol/Object.ObjectEvent#propertychange
+   * @api
+   */
+  PROPERTYCHANGE: "propertychange"
+};
+const EventType = {
+  /**
+   * Generic change event. Triggered when the revision counter is increased.
+   * @event module:ol/events/Event~BaseEvent#change
+   * @api
+   */
+  CHANGE: "change",
+  /**
+   * Generic error event. Triggered when an error occurs.
+   * @event module:ol/events/Event~BaseEvent#error
+   * @api
+   */
+  ERROR: "error",
+  CONTEXTMENU: "contextmenu",
+  CLICK: "click",
+  DBLCLICK: "dblclick",
+  KEYDOWN: "keydown",
+  KEYPRESS: "keypress",
+  LOAD: "load",
+  TOUCHMOVE: "touchmove",
+  WHEEL: "wheel"
+};
+class Disposable {
+  constructor() {
+    this.disposed = false;
+  }
+  /**
+   * Clean up.
+   */
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = true;
+      this.disposeInternal();
+    }
+  }
+  /**
+   * Extension point for disposable objects.
+   * @protected
+   */
+  disposeInternal() {
+  }
+}
+function binarySearch(haystack, needle, comparator) {
+  let mid, cmp;
+  comparator = comparator || ascending;
+  let low = 0;
+  let high = haystack.length;
+  let found = false;
+  while (low < high) {
+    mid = low + (high - low >> 1);
+    cmp = +comparator(haystack[mid], needle);
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid;
+      found = !cmp;
+    }
+  }
+  return found ? low : ~low;
+}
+function ascending(a, b) {
+  return a > b ? 1 : a < b ? -1 : 0;
+}
+function descending(a, b) {
+  return a < b ? 1 : a > b ? -1 : 0;
+}
+function linearFindNearest(arr, target, direction) {
+  if (arr[0] <= target) {
+    return 0;
+  }
+  const n = arr.length;
+  if (target <= arr[n - 1]) {
+    return n - 1;
+  }
+  if (typeof direction === "function") {
+    for (let i = 1; i < n; ++i) {
+      const candidate = arr[i];
+      if (candidate === target) {
+        return i;
+      }
+      if (candidate < target) {
+        if (direction(target, arr[i - 1], candidate) > 0) {
+          return i - 1;
+        }
+        return i;
+      }
+    }
+    return n - 1;
+  }
+  if (direction > 0) {
+    for (let i = 1; i < n; ++i) {
+      if (arr[i] < target) {
+        return i - 1;
+      }
+    }
+    return n - 1;
+  }
+  if (direction < 0) {
+    for (let i = 1; i < n; ++i) {
+      if (arr[i] <= target) {
+        return i;
+      }
+    }
+    return n - 1;
+  }
+  for (let i = 1; i < n; ++i) {
+    if (arr[i] == target) {
+      return i;
+    }
+    if (arr[i] < target) {
+      if (arr[i - 1] - target < target - arr[i]) {
+        return i - 1;
+      }
+      return i;
+    }
+  }
+  return n - 1;
+}
+function reverseSubArray(arr, begin, end) {
+  while (begin < end) {
+    const tmp = arr[begin];
+    arr[begin] = arr[end];
+    arr[end] = tmp;
+    ++begin;
+    --end;
+  }
+}
+function extend(arr, data) {
+  const extension = Array.isArray(data) ? data : [data];
+  const length = extension.length;
+  for (let i = 0; i < length; i++) {
+    arr[arr.length] = extension[i];
+  }
+}
+function equals(arr1, arr2) {
+  const len1 = arr1.length;
+  if (len1 !== arr2.length) {
+    return false;
+  }
+  for (let i = 0; i < len1; i++) {
+    if (arr1[i] !== arr2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function isSorted(arr, func, strict) {
+  const compare = func || ascending;
+  return arr.every(function(currentVal, index) {
+    if (index === 0) {
+      return true;
+    }
+    const res = compare(arr[index - 1], currentVal);
+    return !(res > 0 || res === 0);
+  });
+}
+function TRUE() {
+  return true;
+}
+function FALSE() {
+  return false;
+}
+function VOID() {
+}
+function memoizeOne(fn) {
+  let lastResult;
+  let lastArgs;
+  let lastThis;
+  return function() {
+    const nextArgs = Array.prototype.slice.call(arguments);
+    if (!lastArgs || this !== lastThis || !equals(nextArgs, lastArgs)) {
+      lastThis = this;
+      lastArgs = nextArgs;
+      lastResult = fn.apply(this, arguments);
+    }
+    return lastResult;
+  };
+}
+function toPromise(getter) {
+  function promiseGetter() {
+    let value;
+    try {
+      value = getter();
+    } catch (err) {
+      return Promise.reject(err);
+    }
+    if (value instanceof Promise) {
+      return value;
+    }
+    return Promise.resolve(value);
+  }
+  return promiseGetter();
+}
+function clear(object) {
+  for (const property in object) {
+    delete object[property];
+  }
+}
+function isEmpty(object) {
+  let property;
+  for (property in object) {
+    return false;
+  }
+  return !property;
+}
+class BaseEvent {
+  /**
+   * @param {string} type Type.
+   */
+  constructor(type) {
+    this.propagationStopped;
+    this.defaultPrevented;
+    this.type = type;
+    this.target = null;
+  }
+  /**
+   * Prevent default. This means that no emulated `click`, `singleclick` or `doubleclick` events
+   * will be fired.
+   * @api
+   */
+  preventDefault() {
+    this.defaultPrevented = true;
+  }
+  /**
+   * Stop event propagation.
+   * @api
+   */
+  stopPropagation() {
+    this.propagationStopped = true;
+  }
+}
+class Target extends Disposable {
+  /**
+   * @param {*} [target] Default event target for dispatched events.
+   */
+  constructor(target) {
+    super();
+    this.eventTarget_ = target;
+    this.pendingRemovals_ = null;
+    this.dispatching_ = null;
+    this.listeners_ = null;
+  }
+  /**
+   * @param {string} type Type.
+   * @param {import("../events.js").Listener} listener Listener.
+   */
+  addEventListener(type, listener) {
+    if (!type || !listener) {
+      return;
+    }
+    const listeners = this.listeners_ || (this.listeners_ = {});
+    const listenersForType = listeners[type] || (listeners[type] = []);
+    if (!listenersForType.includes(listener)) {
+      listenersForType.push(listener);
+    }
+  }
+  /**
+   * Dispatches an event and calls all listeners listening for events
+   * of this type. The event parameter can either be a string or an
+   * Object with a `type` property.
+   *
+   * @param {import("./Event.js").default|string} event Event object.
+   * @return {boolean|undefined} `false` if anyone called preventDefault on the
+   *     event object or if any of the listeners returned false.
+   * @api
+   */
+  dispatchEvent(event) {
+    const isString = typeof event === "string";
+    const type = isString ? event : event.type;
+    const listeners = this.listeners_ && this.listeners_[type];
+    if (!listeners) {
+      return;
+    }
+    const evt = isString ? new BaseEvent(event) : (
+      /** @type {Event} */
+      event
+    );
+    if (!evt.target) {
+      evt.target = this.eventTarget_ || this;
+    }
+    const dispatching = this.dispatching_ || (this.dispatching_ = {});
+    const pendingRemovals = this.pendingRemovals_ || (this.pendingRemovals_ = {});
+    if (!(type in dispatching)) {
+      dispatching[type] = 0;
+      pendingRemovals[type] = 0;
+    }
+    ++dispatching[type];
+    let propagate;
+    for (let i = 0, ii = listeners.length; i < ii; ++i) {
+      if ("handleEvent" in listeners[i]) {
+        propagate = /** @type {import("../events.js").ListenerObject} */
+        listeners[i].handleEvent(evt);
+      } else {
+        propagate = /** @type {import("../events.js").ListenerFunction} */
+        listeners[i].call(this, evt);
+      }
+      if (propagate === false || evt.propagationStopped) {
+        propagate = false;
+        break;
+      }
+    }
+    if (--dispatching[type] === 0) {
+      let pr = pendingRemovals[type];
+      delete pendingRemovals[type];
+      while (pr--) {
+        this.removeEventListener(type, VOID);
+      }
+      delete dispatching[type];
+    }
+    return propagate;
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    this.listeners_ && clear(this.listeners_);
+  }
+  /**
+   * Get the listeners for a specified event type. Listeners are returned in the
+   * order that they will be called in.
+   *
+   * @param {string} type Type.
+   * @return {Array<import("../events.js").Listener>|undefined} Listeners.
+   */
+  getListeners(type) {
+    return this.listeners_ && this.listeners_[type] || void 0;
+  }
+  /**
+   * @param {string} [type] Type. If not provided,
+   *     `true` will be returned if this event target has any listeners.
+   * @return {boolean} Has listeners.
+   */
+  hasListener(type) {
+    if (!this.listeners_) {
+      return false;
+    }
+    return type ? type in this.listeners_ : Object.keys(this.listeners_).length > 0;
+  }
+  /**
+   * @param {string} type Type.
+   * @param {import("../events.js").Listener} listener Listener.
+   */
+  removeEventListener(type, listener) {
+    if (!this.listeners_) {
+      return;
+    }
+    const listeners = this.listeners_[type];
+    if (!listeners) {
+      return;
+    }
+    const index = listeners.indexOf(listener);
+    if (index !== -1) {
+      if (this.pendingRemovals_ && type in this.pendingRemovals_) {
+        listeners[index] = VOID;
+        ++this.pendingRemovals_[type];
+      } else {
+        listeners.splice(index, 1);
+        if (listeners.length === 0) {
+          delete this.listeners_[type];
+        }
+      }
+    }
+  }
+}
+function listen(target, type, listener, thisArg, once) {
+  if (once) {
+    const originalListener = listener;
+    listener = function(event) {
+      target.removeEventListener(type, listener);
+      return originalListener.call(thisArg != null ? thisArg : this, event);
+    };
+  } else if (thisArg && thisArg !== target) {
+    listener = listener.bind(thisArg);
+  }
+  const eventsKey = {
+    target,
+    type,
+    listener
+  };
+  target.addEventListener(type, listener);
+  return eventsKey;
+}
+function listenOnce(target, type, listener, thisArg) {
+  return listen(target, type, listener, thisArg, true);
+}
+function unlistenByKey(key) {
+  if (key && key.target) {
+    key.target.removeEventListener(key.type, key.listener);
+    clear(key);
+  }
+}
+class Observable extends Target {
+  constructor() {
+    super();
+    this.on = /** @type {ObservableOnSignature<import("./events").EventsKey>} */
+    this.onInternal;
+    this.once = /** @type {ObservableOnSignature<import("./events").EventsKey>} */
+    this.onceInternal;
+    this.un = /** @type {ObservableOnSignature<void>} */
+    this.unInternal;
+    this.revision_ = 0;
+  }
+  /**
+   * Increases the revision counter and dispatches a 'change' event.
+   * @api
+   */
+  changed() {
+    ++this.revision_;
+    this.dispatchEvent(EventType.CHANGE);
+  }
+  /**
+   * Get the version number for this object.  Each time the object is modified,
+   * its version number will be incremented.
+   * @return {number} Revision.
+   * @api
+   */
+  getRevision() {
+    return this.revision_;
+  }
+  /**
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @return {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} Event key.
+   * @protected
+   */
+  onInternal(type, listener) {
+    if (Array.isArray(type)) {
+      const len = type.length;
+      const keys = new Array(len);
+      for (let i = 0; i < len; ++i) {
+        keys[i] = listen(this, type[i], listener);
+      }
+      return keys;
+    }
+    return listen(
+      this,
+      /** @type {string} */
+      type,
+      listener
+    );
+  }
+  /**
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @return {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} Event key.
+   * @protected
+   */
+  onceInternal(type, listener) {
+    let key;
+    if (Array.isArray(type)) {
+      const len = type.length;
+      key = new Array(len);
+      for (let i = 0; i < len; ++i) {
+        key[i] = listenOnce(this, type[i], listener);
+      }
+    } else {
+      key = listenOnce(
+        this,
+        /** @type {string} */
+        type,
+        listener
+      );
+    }
+    listener.ol_key = key;
+    return key;
+  }
+  /**
+   * Unlisten for a certain type of event.
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @protected
+   */
+  unInternal(type, listener) {
+    const key = (
+      /** @type {Object} */
+      listener.ol_key
+    );
+    if (key) {
+      unByKey(key);
+    } else if (Array.isArray(type)) {
+      for (let i = 0, ii = type.length; i < ii; ++i) {
+        this.removeEventListener(type[i], listener);
+      }
+    } else {
+      this.removeEventListener(type, listener);
+    }
+  }
+}
+Observable.prototype.on;
+Observable.prototype.once;
+Observable.prototype.un;
+function unByKey(key) {
+  if (Array.isArray(key)) {
+    for (let i = 0, ii = key.length; i < ii; ++i) {
+      unlistenByKey(key[i]);
+    }
+  } else {
+    unlistenByKey(
+      /** @type {import("./events.js").EventsKey} */
+      key
+    );
+  }
+}
+function abstract() {
+  throw new Error("Unimplemented abstract method.");
+}
+let uidCounter_ = 0;
+function getUid(obj) {
+  return obj.ol_uid || (obj.ol_uid = String(++uidCounter_));
+}
+class ObjectEvent extends BaseEvent {
+  /**
+   * @param {string} type The event type.
+   * @param {string} key The property name.
+   * @param {*} oldValue The old value for `key`.
+   */
+  constructor(type, key, oldValue) {
+    super(type);
+    this.key = key;
+    this.oldValue = oldValue;
+  }
+}
+class BaseObject extends Observable {
+  /**
+   * @param {Object<string, *>} [values] An object with key-value pairs.
+   */
+  constructor(values) {
+    super();
+    this.on;
+    this.once;
+    this.un;
+    getUid(this);
+    this.values_ = null;
+    if (values !== void 0) {
+      this.setProperties(values);
+    }
+  }
+  /**
+   * Gets a value.
+   * @param {string} key Key name.
+   * @return {*} Value.
+   * @api
+   */
+  get(key) {
+    let value;
+    if (this.values_ && this.values_.hasOwnProperty(key)) {
+      value = this.values_[key];
+    }
+    return value;
+  }
+  /**
+   * Get a list of object property names.
+   * @return {Array<string>} List of property names.
+   * @api
+   */
+  getKeys() {
+    return this.values_ && Object.keys(this.values_) || [];
+  }
+  /**
+   * Get an object of all property names and values.
+   * @return {Object<string, *>} Object.
+   * @api
+   */
+  getProperties() {
+    return this.values_ && Object.assign({}, this.values_) || {};
+  }
+  /**
+   * Get an object of all property names and values.
+   * @return {Object<string, *>?} Object.
+   */
+  getPropertiesInternal() {
+    return this.values_;
+  }
+  /**
+   * @return {boolean} The object has properties.
+   */
+  hasProperties() {
+    return !!this.values_;
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {*} oldValue Old value.
+   */
+  notify(key, oldValue) {
+    let eventType;
+    eventType = `change:${key}`;
+    if (this.hasListener(eventType)) {
+      this.dispatchEvent(new ObjectEvent(eventType, key, oldValue));
+    }
+    eventType = ObjectEventType.PROPERTYCHANGE;
+    if (this.hasListener(eventType)) {
+      this.dispatchEvent(new ObjectEvent(eventType, key, oldValue));
+    }
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {import("./events.js").Listener} listener Listener.
+   */
+  addChangeListener(key, listener) {
+    this.addEventListener(`change:${key}`, listener);
+  }
+  /**
+   * @param {string} key Key name.
+   * @param {import("./events.js").Listener} listener Listener.
+   */
+  removeChangeListener(key, listener) {
+    this.removeEventListener(`change:${key}`, listener);
+  }
+  /**
+   * Sets a value.
+   * @param {string} key Key name.
+   * @param {*} value Value.
+   * @param {boolean} [silent] Update without triggering an event.
+   * @api
+   */
+  set(key, value, silent) {
+    const values = this.values_ || (this.values_ = {});
+    if (silent) {
+      values[key] = value;
+    } else {
+      const oldValue = values[key];
+      values[key] = value;
+      if (oldValue !== value) {
+        this.notify(key, oldValue);
+      }
+    }
+  }
+  /**
+   * Sets a collection of key-value pairs.  Note that this changes any existing
+   * properties and adds new ones (it does not remove any existing properties).
+   * @param {Object<string, *>} values Values.
+   * @param {boolean} [silent] Update without triggering an event.
+   * @api
+   */
+  setProperties(values, silent) {
+    for (const key in values) {
+      this.set(key, values[key], silent);
+    }
+  }
+  /**
+   * Apply any properties from another object without triggering events.
+   * @param {BaseObject} source The source object.
+   * @protected
+   */
+  applyProperties(source) {
+    if (!source.values_) {
+      return;
+    }
+    Object.assign(this.values_ || (this.values_ = {}), source.values_);
+  }
+  /**
+   * Unsets a property.
+   * @param {string} key Key name.
+   * @param {boolean} [silent] Unset without triggering an event.
+   * @api
+   */
+  unset(key, silent) {
+    if (this.values_ && key in this.values_) {
+      const oldValue = this.values_[key];
+      delete this.values_[key];
+      if (isEmpty(this.values_)) {
+        this.values_ = null;
+      }
+      if (!silent) {
+        this.notify(key, oldValue);
+      }
+    }
+  }
+}
+function assert(assertion, errorMessage) {
+  if (!assertion) {
+    throw new Error(errorMessage);
+  }
+}
+export {
+  BaseObject as B,
+  Disposable as D,
+  EventType as E,
+  FALSE as F,
+  ObjectEventType as O,
+  Target as T,
+  VOID as V,
+  BaseEvent as a,
+  assert as b,
+  clear as c,
+  ascending as d,
+  extend as e,
+  linearFindNearest as f,
+  equals as g,
+  TRUE as h,
+  abstract as i,
+  getUid as j,
+  isEmpty as k,
+  listen as l,
+  descending as m,
+  Observable as n,
+  binarySearch as o,
+  memoizeOne as p,
+  isSorted as q,
+  reverseSubArray as r,
+  listenOnce as s,
+  toPromise as t,
+  unlistenByKey as u
+};