@guardian/interactive-component-library 0.2.0-rc1 → 0.2.0-rc2

package/dist/node_modules/.pnpm/flatqueue@2.0.3/node_modules/flatqueue/index.js

@@ -0,0 +1,67 @@
+class FlatQueue {
+  constructor() {
+    this.ids = [];
+    this.values = [];
+    this.length = 0;
+  }
+  clear() {
+    this.length = 0;
+  }
+  push(id, value) {
+    let pos = this.length++;
+    while (pos > 0) {
+      const parent = pos - 1 >> 1;
+      const parentValue = this.values[parent];
+      if (value >= parentValue) break;
+      this.ids[pos] = this.ids[parent];
+      this.values[pos] = parentValue;
+      pos = parent;
+    }
+    this.ids[pos] = id;
+    this.values[pos] = value;
+  }
+  pop() {
+    if (this.length === 0) return void 0;
+    const top = this.ids[0];
+    this.length--;
+    if (this.length > 0) {
+      const id = this.ids[0] = this.ids[this.length];
+      const value = this.values[0] = this.values[this.length];
+      const halfLength = this.length >> 1;
+      let pos = 0;
+      while (pos < halfLength) {
+        let left = (pos << 1) + 1;
+        const right = left + 1;
+        let bestIndex = this.ids[left];
+        let bestValue = this.values[left];
+        const rightValue = this.values[right];
+        if (right < this.length && rightValue < bestValue) {
+          left = right;
+          bestIndex = this.ids[right];
+          bestValue = rightValue;
+        }
+        if (bestValue >= value) break;
+        this.ids[pos] = bestIndex;
+        this.values[pos] = bestValue;
+        pos = left;
+      }
+      this.ids[pos] = id;
+      this.values[pos] = value;
+    }
+    return top;
+  }
+  peek() {
+    if (this.length === 0) return void 0;
+    return this.ids[0];
+  }
+  peekValue() {
+    if (this.length === 0) return void 0;
+    return this.values[0];
+  }
+  shrink() {
+    this.ids.length = this.values.length = this.length;
+  }
+}
+export {
+  FlatQueue as default
+};

package/dist/node_modules/.pnpm/preact-merge-refs@1.0.2_preact@10.21.0/node_modules/preact-merge-refs/lib/preact-merge-refs.modern.js

@@ -0,0 +1,10 @@
+function n(n2) {
+  return (r) => {
+    n2.forEach((n3) => {
+      "function" == typeof n3 ? n3(r) : null != n3 && (n3.current = r);
+    });
+  };
+}
+export {
+  n as mergeRefs
+};

package/dist/node_modules/.pnpm/preact-transitioning@1.4.1_preact@10.21.0/node_modules/preact-transitioning/lib/preact-transitioning.modern.js

@@ -0,0 +1,63 @@
+import { createElement, cloneElement } from "preact";
+import { mergeRefs as n } from "../../../../preact-merge-refs@1.0.2_preact@10.21.0/node_modules/preact-merge-refs/lib/preact-merge-refs.modern.js";
+import { useMemo, useRef, useState, useEffect, useLayoutEffect } from "preact/hooks";
+var T, c;
+!function(e) {
+  e.APPEAR = "appear", e.APPEAR_ACTIVE = "appearActive", e.APPEAR_DONE = "appearDone", e.ENTER = "enter", e.ENTER_ACTIVE = "enterActive", e.ENTER_DONE = "enterDone", e.EXIT = "exit", e.EXIT_ACTIVE = "exitActive", e.EXIT_DONE = "exitDone";
+}(T || (T = {})), function(e) {
+  e.ENTER = "onEnter", e.ENTERING = "onEntering", e.ENTERED = "onEntered", e.EXIT = "onExit", e.EXITING = "onExiting", e.EXITED = "onExited";
+}(c || (c = {}));
+const s = { [T.APPEAR]: [c.ENTER, T.APPEAR_ACTIVE], [T.APPEAR_ACTIVE]: [c.ENTERING, T.APPEAR_DONE, true], [T.APPEAR_DONE]: [c.ENTERED], [T.ENTER]: [c.ENTER, T.ENTER_ACTIVE], [T.ENTER_ACTIVE]: [c.ENTERING, T.ENTER_DONE, true], [T.ENTER_DONE]: [c.ENTERED], [T.EXIT]: [c.EXIT, T.EXIT_ACTIVE], [T.EXIT_ACTIVE]: [c.EXITING, T.EXIT_DONE, true], [T.EXIT_DONE]: [c.EXITED] };
+var u = (r) => {
+  const { children: c2, in: u2 = false, appear: A = false, enter: N2 = true, exit: l = true, duration: I = 500, alwaysMounted: p2 = false, addEndListener: R2 } = r, P2 = useRef(), _2 = useRef();
+  let d2 = false;
+  const [f, D] = useState(() => (d2 = true, u2 ? A ? T.APPEAR : T.APPEAR_DONE : T.EXIT_DONE));
+  useEffect(() => {
+    var e;
+    const { setTimeout: E, clearTimeout: t } = window, [n2, o, i] = s[f];
+    return null == (e = r[n2]) || e.call(r, P2.current), o && (i ? R2 ? R2(P2.current, () => D(o)) : _2.current = E(D, I, o) : D(o)), () => {
+      t(_2.current);
+    };
+  }, [f, I]), useLayoutEffect(() => {
+    d2 || D(u2 ? N2 ? T.ENTER : T.ENTER_DONE : l ? T.EXIT : T.EXIT_DONE);
+  }, [u2]);
+  const X = useMemo(() => {
+    const e = {};
+    return Object.values(T).forEach((r2) => {
+      e[r2] = f === r2;
+    }), e;
+  }, [f]);
+  if (!p2 && f === T.EXIT_DONE) return null;
+  const O = c2(X, f);
+  return cloneElement(O, { ref: n([P2, O.ref]) });
+};
+function N(e, r) {
+  if (null == e) return {};
+  var E, t, n2 = {}, o = Object.keys(e);
+  for (t = 0; t < o.length; t++) r.indexOf(E = o[t]) >= 0 || (n2[E] = e[E]);
+  return n2;
+}
+const p = ["children", "classNames"], R = { [T.APPEAR]: "-appear", [T.APPEAR_ACTIVE]: "-appear-active", [T.APPEAR_DONE]: "-appear-done", [T.ENTER]: "-enter", [T.ENTER_ACTIVE]: "-enter-active", [T.ENTER_DONE]: "-enter-done", [T.EXIT]: "-exit", [T.EXIT_ACTIVE]: "-exit-active", [T.EXIT_DONE]: "-exit-done" }, P = (...e) => e.filter((e2) => !!e2).join(" "), _ = (e, r) => "string" == typeof r ? `${r}${R[e]}` : r[e];
+var d = (E) => {
+  const { children: t, classNames: n2 } = E, o = N(E, p);
+  return createElement(u, o, (r, E2) => {
+    const { className: o2 } = t.props, i = useMemo(() => P(o2, ((e, r2) => {
+      const E3 = _(e, r2);
+      switch (e) {
+        case T.APPEAR_ACTIVE:
+          return P(_(T.APPEAR, r2), E3);
+        case T.ENTER_ACTIVE:
+          return P(_(T.ENTER, r2), E3);
+        case T.EXIT_ACTIVE:
+          return P(_(T.EXIT, r2), E3);
+        default:
+          return E3;
+      }
+    })(E2, n2)), [o2, n2, E2]);
+    return cloneElement(t, { className: i });
+  });
+};
+export {
+  d as CSSTransition,
+  u as Transition
+};

package/dist/node_modules/.pnpm/quickselect@2.0.0/node_modules/quickselect/index.js

@@ -0,0 +1,47 @@
+function quickselect(arr, k, left, right, compare) {
+  quickselectStep(arr, k, left || 0, right || arr.length - 1, compare || defaultCompare);
+}
+function quickselectStep(arr, k, left, right, compare) {
+  while (right > left) {
+    if (right - left > 600) {
+      var n = right - left + 1;
+      var m = k - left + 1;
+      var z = Math.log(n);
+      var s = 0.5 * Math.exp(2 * z / 3);
+      var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
+      var newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
+      var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
+      quickselectStep(arr, k, newLeft, newRight, compare);
+    }
+    var t = arr[k];
+    var i = left;
+    var j = right;
+    swap(arr, left, k);
+    if (compare(arr[right], t) > 0) swap(arr, left, right);
+    while (i < j) {
+      swap(arr, i, j);
+      i++;
+      j--;
+      while (compare(arr[i], t) < 0) i++;
+      while (compare(arr[j], t) > 0) j--;
+    }
+    if (compare(arr[left], t) === 0) swap(arr, left, j);
+    else {
+      j++;
+      swap(arr, j, right);
+    }
+    if (j <= k) left = j + 1;
+    if (k <= j) right = j - 1;
+  }
+}
+function swap(arr, i, j) {
+  var tmp = arr[i];
+  arr[i] = arr[j];
+  arr[j] = tmp;
+}
+function defaultCompare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+export {
+  quickselect as default
+};

package/dist/node_modules/.pnpm/rbush-knn@4.0.0/node_modules/rbush-knn/index.js

@@ -0,0 +1,42 @@
+import TinyQueue from "../../../tinyqueue@2.0.3/node_modules/tinyqueue/index.js";
+function knn(tree, x, y, n, predicate, maxDistance) {
+  let node = tree.data;
+  const result = [];
+  const toBBox = tree.toBBox;
+  const queue = new TinyQueue(void 0, compareDist);
+  while (node) {
+    for (let i = 0; i < node.children.length; i++) {
+      const child = node.children[i];
+      const dist = boxDist(x, y, node.leaf ? toBBox(child) : child);
+      {
+        queue.push({
+          node: child,
+          isItem: node.leaf,
+          dist
+        });
+      }
+    }
+    while (queue.length && queue.peek().isItem) {
+      const candidate = queue.pop().node;
+      if (!predicate || predicate(candidate))
+        result.push(candidate);
+      if (result.length === n) return result;
+    }
+    node = queue.pop();
+    if (node) node = node.node;
+  }
+  return result;
+}
+function compareDist(a, b) {
+  return a.dist - b.dist;
+}
+function boxDist(x, y, box) {
+  const dx = axisDist(x, box.minX, box.maxX), dy = axisDist(y, box.minY, box.maxY);
+  return dx * dx + dy * dy;
+}
+function axisDist(k, min, max) {
+  return k < min ? min - k : k <= max ? 0 : k - max;
+}
+export {
+  knn as default
+};

package/dist/node_modules/.pnpm/rbush@4.0.0/node_modules/rbush/index.js

@@ -0,0 +1,378 @@
+import quickselect from "../../../quickselect@2.0.0/node_modules/quickselect/index.js";
+class RBush {
+  constructor(maxEntries = 9) {
+    this._maxEntries = Math.max(4, maxEntries);
+    this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));
+    this.clear();
+  }
+  all() {
+    return this._all(this.data, []);
+  }
+  search(bbox) {
+    let node = this.data;
+    const result = [];
+    if (!intersects(bbox, node)) return result;
+    const toBBox = this.toBBox;
+    const nodesToSearch = [];
+    while (node) {
+      for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+        const childBBox = node.leaf ? toBBox(child) : child;
+        if (intersects(bbox, childBBox)) {
+          if (node.leaf) result.push(child);
+          else if (contains(bbox, childBBox)) this._all(child, result);
+          else nodesToSearch.push(child);
+        }
+      }
+      node = nodesToSearch.pop();
+    }
+    return result;
+  }
+  collides(bbox) {
+    let node = this.data;
+    if (!intersects(bbox, node)) return false;
+    const nodesToSearch = [];
+    while (node) {
+      for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+        const childBBox = node.leaf ? this.toBBox(child) : child;
+        if (intersects(bbox, childBBox)) {
+          if (node.leaf || contains(bbox, childBBox)) return true;
+          nodesToSearch.push(child);
+        }
+      }
+      node = nodesToSearch.pop();
+    }
+    return false;
+  }
+  load(data) {
+    if (!(data && data.length)) return this;
+    if (data.length < this._minEntries) {
+      for (let i = 0; i < data.length; i++) {
+        this.insert(data[i]);
+      }
+      return this;
+    }
+    let node = this._build(data.slice(), 0, data.length - 1, 0);
+    if (!this.data.children.length) {
+      this.data = node;
+    } else if (this.data.height === node.height) {
+      this._splitRoot(this.data, node);
+    } else {
+      if (this.data.height < node.height) {
+        const tmpNode = this.data;
+        this.data = node;
+        node = tmpNode;
+      }
+      this._insert(node, this.data.height - node.height - 1, true);
+    }
+    return this;
+  }
+  insert(item) {
+    if (item) this._insert(item, this.data.height - 1);
+    return this;
+  }
+  clear() {
+    this.data = createNode([]);
+    return this;
+  }
+  remove(item, equalsFn) {
+    if (!item) return this;
+    let node = this.data;
+    const bbox = this.toBBox(item);
+    const path = [];
+    const indexes = [];
+    let i, parent, goingUp;
+    while (node || path.length) {
+      if (!node) {
+        node = path.pop();
+        parent = path[path.length - 1];
+        i = indexes.pop();
+        goingUp = true;
+      }
+      if (node.leaf) {
+        const index = findItem(item, node.children, equalsFn);
+        if (index !== -1) {
+          node.children.splice(index, 1);
+          path.push(node);
+          this._condense(path);
+          return this;
+        }
+      }
+      if (!goingUp && !node.leaf && contains(node, bbox)) {
+        path.push(node);
+        indexes.push(i);
+        i = 0;
+        parent = node;
+        node = node.children[0];
+      } else if (parent) {
+        i++;
+        node = parent.children[i];
+        goingUp = false;
+      } else node = null;
+    }
+    return this;
+  }
+  toBBox(item) {
+    return item;
+  }
+  compareMinX(a, b) {
+    return a.minX - b.minX;
+  }
+  compareMinY(a, b) {
+    return a.minY - b.minY;
+  }
+  toJSON() {
+    return this.data;
+  }
+  fromJSON(data) {
+    this.data = data;
+    return this;
+  }
+  _all(node, result) {
+    const nodesToSearch = [];
+    while (node) {
+      if (node.leaf) result.push(...node.children);
+      else nodesToSearch.push(...node.children);
+      node = nodesToSearch.pop();
+    }
+    return result;
+  }
+  _build(items, left, right, height) {
+    const N = right - left + 1;
+    let M = this._maxEntries;
+    let node;
+    if (N <= M) {
+      node = createNode(items.slice(left, right + 1));
+      calcBBox(node, this.toBBox);
+      return node;
+    }
+    if (!height) {
+      height = Math.ceil(Math.log(N) / Math.log(M));
+      M = Math.ceil(N / Math.pow(M, height - 1));
+    }
+    node = createNode([]);
+    node.leaf = false;
+    node.height = height;
+    const N2 = Math.ceil(N / M);
+    const N1 = N2 * Math.ceil(Math.sqrt(M));
+    multiSelect(items, left, right, N1, this.compareMinX);
+    for (let i = left; i <= right; i += N1) {
+      const right2 = Math.min(i + N1 - 1, right);
+      multiSelect(items, i, right2, N2, this.compareMinY);
+      for (let j = i; j <= right2; j += N2) {
+        const right3 = Math.min(j + N2 - 1, right2);
+        node.children.push(this._build(items, j, right3, height - 1));
+      }
+    }
+    calcBBox(node, this.toBBox);
+    return node;
+  }
+  _chooseSubtree(bbox, node, level, path) {
+    while (true) {
+      path.push(node);
+      if (node.leaf || path.length - 1 === level) break;
+      let minArea = Infinity;
+      let minEnlargement = Infinity;
+      let targetNode;
+      for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+        const area = bboxArea(child);
+        const enlargement = enlargedArea(bbox, child) - area;
+        if (enlargement < minEnlargement) {
+          minEnlargement = enlargement;
+          minArea = area < minArea ? area : minArea;
+          targetNode = child;
+        } else if (enlargement === minEnlargement) {
+          if (area < minArea) {
+            minArea = area;
+            targetNode = child;
+          }
+        }
+      }
+      node = targetNode || node.children[0];
+    }
+    return node;
+  }
+  _insert(item, level, isNode) {
+    const bbox = isNode ? item : this.toBBox(item);
+    const insertPath = [];
+    const node = this._chooseSubtree(bbox, this.data, level, insertPath);
+    node.children.push(item);
+    extend(node, bbox);
+    while (level >= 0) {
+      if (insertPath[level].children.length > this._maxEntries) {
+        this._split(insertPath, level);
+        level--;
+      } else break;
+    }
+    this._adjustParentBBoxes(bbox, insertPath, level);
+  }
+  // split overflowed node into two
+  _split(insertPath, level) {
+    const node = insertPath[level];
+    const M = node.children.length;
+    const m = this._minEntries;
+    this._chooseSplitAxis(node, m, M);
+    const splitIndex = this._chooseSplitIndex(node, m, M);
+    const newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
+    newNode.height = node.height;
+    newNode.leaf = node.leaf;
+    calcBBox(node, this.toBBox);
+    calcBBox(newNode, this.toBBox);
+    if (level) insertPath[level - 1].children.push(newNode);
+    else this._splitRoot(node, newNode);
+  }
+  _splitRoot(node, newNode) {
+    this.data = createNode([node, newNode]);
+    this.data.height = node.height + 1;
+    this.data.leaf = false;
+    calcBBox(this.data, this.toBBox);
+  }
+  _chooseSplitIndex(node, m, M) {
+    let index;
+    let minOverlap = Infinity;
+    let minArea = Infinity;
+    for (let i = m; i <= M - m; i++) {
+      const bbox1 = distBBox(node, 0, i, this.toBBox);
+      const bbox2 = distBBox(node, i, M, this.toBBox);
+      const overlap = intersectionArea(bbox1, bbox2);
+      const area = bboxArea(bbox1) + bboxArea(bbox2);
+      if (overlap < minOverlap) {
+        minOverlap = overlap;
+        index = i;
+        minArea = area < minArea ? area : minArea;
+      } else if (overlap === minOverlap) {
+        if (area < minArea) {
+          minArea = area;
+          index = i;
+        }
+      }
+    }
+    return index || M - m;
+  }
+  // sorts node children by the best axis for split
+  _chooseSplitAxis(node, m, M) {
+    const compareMinX = node.leaf ? this.compareMinX : compareNodeMinX;
+    const compareMinY = node.leaf ? this.compareMinY : compareNodeMinY;
+    const xMargin = this._allDistMargin(node, m, M, compareMinX);
+    const yMargin = this._allDistMargin(node, m, M, compareMinY);
+    if (xMargin < yMargin) node.children.sort(compareMinX);
+  }
+  // total margin of all possible split distributions where each node is at least m full
+  _allDistMargin(node, m, M, compare) {
+    node.children.sort(compare);
+    const toBBox = this.toBBox;
+    const leftBBox = distBBox(node, 0, m, toBBox);
+    const rightBBox = distBBox(node, M - m, M, toBBox);
+    let margin = bboxMargin(leftBBox) + bboxMargin(rightBBox);
+    for (let i = m; i < M - m; i++) {
+      const child = node.children[i];
+      extend(leftBBox, node.leaf ? toBBox(child) : child);
+      margin += bboxMargin(leftBBox);
+    }
+    for (let i = M - m - 1; i >= m; i--) {
+      const child = node.children[i];
+      extend(rightBBox, node.leaf ? toBBox(child) : child);
+      margin += bboxMargin(rightBBox);
+    }
+    return margin;
+  }
+  _adjustParentBBoxes(bbox, path, level) {
+    for (let i = level; i >= 0; i--) {
+      extend(path[i], bbox);
+    }
+  }
+  _condense(path) {
+    for (let i = path.length - 1, siblings; i >= 0; i--) {
+      if (path[i].children.length === 0) {
+        if (i > 0) {
+          siblings = path[i - 1].children;
+          siblings.splice(siblings.indexOf(path[i]), 1);
+        } else this.clear();
+      } else calcBBox(path[i], this.toBBox);
+    }
+  }
+}
+function findItem(item, items, equalsFn) {
+  if (!equalsFn) return items.indexOf(item);
+  for (let i = 0; i < items.length; i++) {
+    if (equalsFn(item, items[i])) return i;
+  }
+  return -1;
+}
+function calcBBox(node, toBBox) {
+  distBBox(node, 0, node.children.length, toBBox, node);
+}
+function distBBox(node, k, p, toBBox, destNode) {
+  if (!destNode) destNode = createNode(null);
+  destNode.minX = Infinity;
+  destNode.minY = Infinity;
+  destNode.maxX = -Infinity;
+  destNode.maxY = -Infinity;
+  for (let i = k; i < p; i++) {
+    const child = node.children[i];
+    extend(destNode, node.leaf ? toBBox(child) : child);
+  }
+  return destNode;
+}
+function extend(a, b) {
+  a.minX = Math.min(a.minX, b.minX);
+  a.minY = Math.min(a.minY, b.minY);
+  a.maxX = Math.max(a.maxX, b.maxX);
+  a.maxY = Math.max(a.maxY, b.maxY);
+  return a;
+}
+function compareNodeMinX(a, b) {
+  return a.minX - b.minX;
+}
+function compareNodeMinY(a, b) {
+  return a.minY - b.minY;
+}
+function bboxArea(a) {
+  return (a.maxX - a.minX) * (a.maxY - a.minY);
+}
+function bboxMargin(a) {
+  return a.maxX - a.minX + (a.maxY - a.minY);
+}
+function enlargedArea(a, b) {
+  return (Math.max(b.maxX, a.maxX) - Math.min(b.minX, a.minX)) * (Math.max(b.maxY, a.maxY) - Math.min(b.minY, a.minY));
+}
+function intersectionArea(a, b) {
+  const minX = Math.max(a.minX, b.minX);
+  const minY = Math.max(a.minY, b.minY);
+  const maxX = Math.min(a.maxX, b.maxX);
+  const maxY = Math.min(a.maxY, b.maxY);
+  return Math.max(0, maxX - minX) * Math.max(0, maxY - minY);
+}
+function contains(a, b) {
+  return a.minX <= b.minX && a.minY <= b.minY && b.maxX <= a.maxX && b.maxY <= a.maxY;
+}
+function intersects(a, b) {
+  return b.minX <= a.maxX && b.minY <= a.maxY && b.maxX >= a.minX && b.maxY >= a.minY;
+}
+function createNode(children) {
+  return {
+    children,
+    height: 1,
+    leaf: true,
+    minX: Infinity,
+    minY: Infinity,
+    maxX: -Infinity,
+    maxY: -Infinity
+  };
+}
+function multiSelect(arr, left, right, n, compare) {
+  const stack = [left, right];
+  while (stack.length) {
+    right = stack.pop();
+    left = stack.pop();
+    if (right - left <= n) continue;
+    const mid = left + Math.ceil((right - left) / n / 2) * n;
+    quickselect(arr, mid, left, right, compare);
+    stack.push(left, mid, mid, right);
+  }
+}
+export {
+  RBush as default
+};

package/dist/node_modules/.pnpm/tinyqueue@2.0.3/node_modules/tinyqueue/index.js

@@ -0,0 +1,65 @@
+class TinyQueue {
+  constructor(data = [], compare = defaultCompare) {
+    this.data = data;
+    this.length = this.data.length;
+    this.compare = compare;
+    if (this.length > 0) {
+      for (let i = (this.length >> 1) - 1; i >= 0; i--) this._down(i);
+    }
+  }
+  push(item) {
+    this.data.push(item);
+    this.length++;
+    this._up(this.length - 1);
+  }
+  pop() {
+    if (this.length === 0) return void 0;
+    const top = this.data[0];
+    const bottom = this.data.pop();
+    this.length--;
+    if (this.length > 0) {
+      this.data[0] = bottom;
+      this._down(0);
+    }
+    return top;
+  }
+  peek() {
+    return this.data[0];
+  }
+  _up(pos) {
+    const { data, compare } = this;
+    const item = data[pos];
+    while (pos > 0) {
+      const parent = pos - 1 >> 1;
+      const current = data[parent];
+      if (compare(item, current) >= 0) break;
+      data[pos] = current;
+      pos = parent;
+    }
+    data[pos] = item;
+  }
+  _down(pos) {
+    const { data, compare } = this;
+    const halfLength = this.length >> 1;
+    const item = data[pos];
+    while (pos < halfLength) {
+      let left = (pos << 1) + 1;
+      let best = data[left];
+      const right = left + 1;
+      if (right < this.length && compare(data[right], best) < 0) {
+        left = right;
+        best = data[right];
+      }
+      if (compare(best, item) >= 0) break;
+      data[pos] = best;
+      pos = left;
+    }
+    data[pos] = item;
+  }
+}
+function defaultCompare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+export {
+  TinyQueue as default
+};

package/dist/shared/colors/index.d.ts

@@ -0,0 +1,2 @@
+export function isDarkColor(color: any): boolean;
+export function isLightColor(color: any): boolean;

package/dist/shared/helpers/createStore.d.ts

@@ -0,0 +1 @@
+export default function createStore(initialStore: any): ((selectorFn?: (store: any) => any) => any)[];

package/dist/shared/helpers/geometry.d.ts

@@ -0,0 +1,3 @@
+export function rectsIntersect(rect1: any, rect2: any): boolean;
+export function pointInsideRect(point: any, rect: any): boolean;
+export function rectInsideRect(rect1: any, rect2: any): boolean;