@seed-ship/mcp-ui-solid 3.0.5 → 4.0.0

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

@@ -0,0 +1,379 @@
+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
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/.pnpm/rbush@3.0.1/node_modules/rbush/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/.pnpm/rbush@3.0.1/node_modules/rbush/index.js"],"sourcesContent":["import quickselect from 'quickselect';\n\nexport default class RBush {\n    constructor(maxEntries = 9) {\n        // max entries in a node is 9 by default; min node fill is 40% for best performance\n        this._maxEntries = Math.max(4, maxEntries);\n        this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));\n        this.clear();\n    }\n\n    all() {\n        return this._all(this.data, []);\n    }\n\n    search(bbox) {\n        let node = this.data;\n        const result = [];\n\n        if (!intersects(bbox, node)) return result;\n\n        const toBBox = this.toBBox;\n        const nodesToSearch = [];\n\n        while (node) {\n            for (let i = 0; i < node.children.length; i++) {\n                const child = node.children[i];\n                const childBBox = node.leaf ? toBBox(child) : child;\n\n                if (intersects(bbox, childBBox)) {\n                    if (node.leaf) result.push(child);\n                    else if (contains(bbox, childBBox)) this._all(child, result);\n                    else nodesToSearch.push(child);\n                }\n            }\n            node = nodesToSearch.pop();\n        }\n\n        return result;\n    }\n\n    collides(bbox) {\n        let node = this.data;\n\n        if (!intersects(bbox, node)) return false;\n\n        const nodesToSearch = [];\n        while (node) {\n            for (let i = 0; i < node.children.length; i++) {\n                const child = node.children[i];\n                const childBBox = node.leaf ? this.toBBox(child) : child;\n\n                if (intersects(bbox, childBBox)) {\n                    if (node.leaf || contains(bbox, childBBox)) return true;\n                    nodesToSearch.push(child);\n                }\n            }\n            node = nodesToSearch.pop();\n        }\n\n        return false;\n    }\n\n    load(data) {\n        if (!(data && data.length)) return this;\n\n        if (data.length < this._minEntries) {\n            for (let i = 0; i < data.length; i++) {\n                this.insert(data[i]);\n            }\n            return this;\n        }\n\n        // recursively build the tree with the given data from scratch using OMT algorithm\n        let node = this._build(data.slice(), 0, data.length - 1, 0);\n\n        if (!this.data.children.length) {\n            // save as is if tree is empty\n            this.data = node;\n\n        } else if (this.data.height === node.height) {\n            // split root if trees have the same height\n            this._splitRoot(this.data, node);\n\n        } else {\n            if (this.data.height < node.height) {\n                // swap trees if inserted one is bigger\n                const tmpNode = this.data;\n                this.data = node;\n                node = tmpNode;\n            }\n\n            // insert the small tree into the large tree at appropriate level\n            this._insert(node, this.data.height - node.height - 1, true);\n        }\n\n        return this;\n    }\n\n    insert(item) {\n        if (item) this._insert(item, this.data.height - 1);\n        return this;\n    }\n\n    clear() {\n        this.data = createNode([]);\n        return this;\n    }\n\n    remove(item, equalsFn) {\n        if (!item) return this;\n\n        let node = this.data;\n        const bbox = this.toBBox(item);\n        const path = [];\n        const indexes = [];\n        let i, parent, goingUp;\n\n        // depth-first iterative tree traversal\n        while (node || path.length) {\n\n            if (!node) { // go up\n                node = path.pop();\n                parent = path[path.length - 1];\n                i = indexes.pop();\n                goingUp = true;\n            }\n\n            if (node.leaf) { // check current node\n                const index = findItem(item, node.children, equalsFn);\n\n                if (index !== -1) {\n                    // item found, remove the item and condense tree upwards\n                    node.children.splice(index, 1);\n                    path.push(node);\n                    this._condense(path);\n                    return this;\n                }\n            }\n\n            if (!goingUp && !node.leaf && contains(node, bbox)) { // go down\n                path.push(node);\n                indexes.push(i);\n                i = 0;\n                parent = node;\n                node = node.children[0];\n\n            } else if (parent) { // go right\n                i++;\n                node = parent.children[i];\n                goingUp = false;\n\n            } else node = null; // nothing found\n        }\n\n        return this;\n    }\n\n    toBBox(item) { return item; }\n\n    compareMinX(a, b) { return a.minX - b.minX; }\n    compareMinY(a, b) { return a.minY - b.minY; }\n\n    toJSON() { return this.data; }\n\n    fromJSON(data) {\n        this.data = data;\n        return this;\n    }\n\n    _all(node, result) {\n        const nodesToSearch = [];\n        while (node) {\n            if (node.leaf) result.push(...node.children);\n            else nodesToSearch.push(...node.children);\n\n            node = nodesToSearch.pop();\n        }\n        return result;\n    }\n\n    _build(items, left, right, height) {\n\n        const N = right - left + 1;\n        let M = this._maxEntries;\n        let node;\n\n        if (N <= M) {\n            // reached leaf level; return leaf\n            node = createNode(items.slice(left, right + 1));\n            calcBBox(node, this.toBBox);\n            return node;\n        }\n\n        if (!height) {\n            // target height of the bulk-loaded tree\n            height = Math.ceil(Math.log(N) / Math.log(M));\n\n            // target number of root entries to maximize storage utilization\n            M = Math.ceil(N / Math.pow(M, height - 1));\n        }\n\n        node = createNode([]);\n        node.leaf = false;\n        node.height = height;\n\n        // split the items into M mostly square tiles\n\n        const N2 = Math.ceil(N / M);\n        const N1 = N2 * Math.ceil(Math.sqrt(M));\n\n        multiSelect(items, left, right, N1, this.compareMinX);\n\n        for (let i = left; i <= right; i += N1) {\n\n            const right2 = Math.min(i + N1 - 1, right);\n\n            multiSelect(items, i, right2, N2, this.compareMinY);\n\n            for (let j = i; j <= right2; j += N2) {\n\n                const right3 = Math.min(j + N2 - 1, right2);\n\n                // pack each entry recursively\n                node.children.push(this._build(items, j, right3, height - 1));\n            }\n        }\n\n        calcBBox(node, this.toBBox);\n\n        return node;\n    }\n\n    _chooseSubtree(bbox, node, level, path) {\n        while (true) {\n            path.push(node);\n\n            if (node.leaf || path.length - 1 === level) break;\n\n            let minArea = Infinity;\n            let minEnlargement = Infinity;\n            let targetNode;\n\n            for (let i = 0; i < node.children.length; i++) {\n                const child = node.children[i];\n                const area = bboxArea(child);\n                const enlargement = enlargedArea(bbox, child) - area;\n\n                // choose entry with the least area enlargement\n                if (enlargement < minEnlargement) {\n                    minEnlargement = enlargement;\n                    minArea = area < minArea ? area : minArea;\n                    targetNode = child;\n\n                } else if (enlargement === minEnlargement) {\n                    // otherwise choose one with the smallest area\n                    if (area < minArea) {\n                        minArea = area;\n                        targetNode = child;\n                    }\n                }\n            }\n\n            node = targetNode || node.children[0];\n        }\n\n        return node;\n    }\n\n    _insert(item, level, isNode) {\n        const bbox = isNode ? item : this.toBBox(item);\n        const insertPath = [];\n\n        // find the best node for accommodating the item, saving all nodes along the path too\n        const node = this._chooseSubtree(bbox, this.data, level, insertPath);\n\n        // put the item into the node\n        node.children.push(item);\n        extend(node, bbox);\n\n        // split on node overflow; propagate upwards if necessary\n        while (level >= 0) {\n            if (insertPath[level].children.length > this._maxEntries) {\n                this._split(insertPath, level);\n                level--;\n            } else break;\n        }\n\n        // adjust bboxes along the insertion path\n        this._adjustParentBBoxes(bbox, insertPath, level);\n    }\n\n    // split overflowed node into two\n    _split(insertPath, level) {\n        const node = insertPath[level];\n        const M = node.children.length;\n        const m = this._minEntries;\n\n        this._chooseSplitAxis(node, m, M);\n\n        const splitIndex = this._chooseSplitIndex(node, m, M);\n\n        const newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));\n        newNode.height = node.height;\n        newNode.leaf = node.leaf;\n\n        calcBBox(node, this.toBBox);\n        calcBBox(newNode, this.toBBox);\n\n        if (level) insertPath[level - 1].children.push(newNode);\n        else this._splitRoot(node, newNode);\n    }\n\n    _splitRoot(node, newNode) {\n        // split root node\n        this.data = createNode([node, newNode]);\n        this.data.height = node.height + 1;\n        this.data.leaf = false;\n        calcBBox(this.data, this.toBBox);\n    }\n\n    _chooseSplitIndex(node, m, M) {\n        let index;\n        let minOverlap = Infinity;\n        let minArea = Infinity;\n\n        for (let i = m; i <= M - m; i++) {\n            const bbox1 = distBBox(node, 0, i, this.toBBox);\n            const bbox2 = distBBox(node, i, M, this.toBBox);\n\n            const overlap = intersectionArea(bbox1, bbox2);\n            const area = bboxArea(bbox1) + bboxArea(bbox2);\n\n            // choose distribution with minimum overlap\n            if (overlap < minOverlap) {\n                minOverlap = overlap;\n                index = i;\n\n                minArea = area < minArea ? area : minArea;\n\n            } else if (overlap === minOverlap) {\n                // otherwise choose distribution with minimum area\n                if (area < minArea) {\n                    minArea = area;\n                    index = i;\n                }\n            }\n        }\n\n        return index || M - m;\n    }\n\n    // sorts node children by the best axis for split\n    _chooseSplitAxis(node, m, M) {\n        const compareMinX = node.leaf ? this.compareMinX : compareNodeMinX;\n        const compareMinY = node.leaf ? this.compareMinY : compareNodeMinY;\n        const xMargin = this._allDistMargin(node, m, M, compareMinX);\n        const yMargin = this._allDistMargin(node, m, M, compareMinY);\n\n        // if total distributions margin value is minimal for x, sort by minX,\n        // otherwise it's already sorted by minY\n        if (xMargin < yMargin) node.children.sort(compareMinX);\n    }\n\n    // total margin of all possible split distributions where each node is at least m full\n    _allDistMargin(node, m, M, compare) {\n        node.children.sort(compare);\n\n        const toBBox = this.toBBox;\n        const leftBBox = distBBox(node, 0, m, toBBox);\n        const rightBBox = distBBox(node, M - m, M, toBBox);\n        let margin = bboxMargin(leftBBox) + bboxMargin(rightBBox);\n\n        for (let i = m; i < M - m; i++) {\n            const child = node.children[i];\n            extend(leftBBox, node.leaf ? toBBox(child) : child);\n            margin += bboxMargin(leftBBox);\n        }\n\n        for (let i = M - m - 1; i >= m; i--) {\n            const child = node.children[i];\n            extend(rightBBox, node.leaf ? toBBox(child) : child);\n            margin += bboxMargin(rightBBox);\n        }\n\n        return margin;\n    }\n\n    _adjustParentBBoxes(bbox, path, level) {\n        // adjust bboxes along the given tree path\n        for (let i = level; i >= 0; i--) {\n            extend(path[i], bbox);\n        }\n    }\n\n    _condense(path) {\n        // go through the path, removing empty nodes and updating bboxes\n        for (let i = path.length - 1, siblings; i >= 0; i--) {\n            if (path[i].children.length === 0) {\n                if (i > 0) {\n                    siblings = path[i - 1].children;\n                    siblings.splice(siblings.indexOf(path[i]), 1);\n\n                } else this.clear();\n\n            } else calcBBox(path[i], this.toBBox);\n        }\n    }\n}\n\nfunction findItem(item, items, equalsFn) {\n    if (!equalsFn) return items.indexOf(item);\n\n    for (let i = 0; i < items.length; i++) {\n        if (equalsFn(item, items[i])) return i;\n    }\n    return -1;\n}\n\n// calculate node's bbox from bboxes of its children\nfunction calcBBox(node, toBBox) {\n    distBBox(node, 0, node.children.length, toBBox, node);\n}\n\n// min bounding rectangle of node children from k to p-1\nfunction distBBox(node, k, p, toBBox, destNode) {\n    if (!destNode) destNode = createNode(null);\n    destNode.minX = Infinity;\n    destNode.minY = Infinity;\n    destNode.maxX = -Infinity;\n    destNode.maxY = -Infinity;\n\n    for (let i = k; i < p; i++) {\n        const child = node.children[i];\n        extend(destNode, node.leaf ? toBBox(child) : child);\n    }\n\n    return destNode;\n}\n\nfunction extend(a, b) {\n    a.minX = Math.min(a.minX, b.minX);\n    a.minY = Math.min(a.minY, b.minY);\n    a.maxX = Math.max(a.maxX, b.maxX);\n    a.maxY = Math.max(a.maxY, b.maxY);\n    return a;\n}\n\nfunction compareNodeMinX(a, b) { return a.minX - b.minX; }\nfunction compareNodeMinY(a, b) { return a.minY - b.minY; }\n\nfunction bboxArea(a)   { return (a.maxX - a.minX) * (a.maxY - a.minY); }\nfunction bboxMargin(a) { return (a.maxX - a.minX) + (a.maxY - a.minY); }\n\nfunction enlargedArea(a, b) {\n    return (Math.max(b.maxX, a.maxX) - Math.min(b.minX, a.minX)) *\n           (Math.max(b.maxY, a.maxY) - Math.min(b.minY, a.minY));\n}\n\nfunction intersectionArea(a, b) {\n    const minX = Math.max(a.minX, b.minX);\n    const minY = Math.max(a.minY, b.minY);\n    const maxX = Math.min(a.maxX, b.maxX);\n    const maxY = Math.min(a.maxY, b.maxY);\n\n    return Math.max(0, maxX - minX) *\n           Math.max(0, maxY - minY);\n}\n\nfunction contains(a, b) {\n    return a.minX <= b.minX &&\n           a.minY <= b.minY &&\n           b.maxX <= a.maxX &&\n           b.maxY <= a.maxY;\n}\n\nfunction intersects(a, b) {\n    return b.minX <= a.maxX &&\n           b.minY <= a.maxY &&\n           b.maxX >= a.minX &&\n           b.maxY >= a.minY;\n}\n\nfunction createNode(children) {\n    return {\n        children,\n        height: 1,\n        leaf: true,\n        minX: Infinity,\n        minY: Infinity,\n        maxX: -Infinity,\n        maxY: -Infinity\n    };\n}\n\n// sort an array so that items come in groups of n unsorted items, with groups sorted between each other;\n// combines selection algorithm with binary divide & conquer approach\n\nfunction multiSelect(arr, left, right, n, compare) {\n    const stack = [left, right];\n\n    while (stack.length) {\n        right = stack.pop();\n        left = stack.pop();\n\n        if (right - left <= n) continue;\n\n        const mid = left + Math.ceil((right - left) / n / 2) * n;\n        quickselect(arr, mid, left, right, compare);\n\n        stack.push(left, mid, mid, right);\n    }\n}\n"],"names":[],"mappings":";AAEe,MAAM,MAAM;AAAA,EACvB,YAAY,aAAa,GAAG;AAExB,SAAK,cAAc,KAAK,IAAI,GAAG,UAAU;AACzC,SAAK,cAAc,KAAK,IAAI,GAAG,KAAK,KAAK,KAAK,cAAc,GAAG,CAAC;AAChE,SAAK,MAAK;AAAA,EACd;AAAA,EAEA,MAAM;AACF,WAAO,KAAK,KAAK,KAAK,MAAM,CAAA,CAAE;AAAA,EAClC;AAAA,EAEA,OAAO,MAAM;AACT,QAAI,OAAO,KAAK;AAChB,UAAM,SAAS,CAAA;AAEf,QAAI,CAAC,WAAW,MAAM,IAAI,EAAG,QAAO;AAEpC,UAAM,SAAS,KAAK;AACpB,UAAM,gBAAgB,CAAA;AAEtB,WAAO,MAAM;AACT,eAAS,IAAI,GAAG,IAAI,KAAK,SAAS,QAAQ,KAAK;AAC3C,cAAM,QAAQ,KAAK,SAAS,CAAC;AAC7B,cAAM,YAAY,KAAK,OAAO,OAAO,KAAK,IAAI;AAE9C,YAAI,WAAW,MAAM,SAAS,GAAG;AAC7B,cAAI,KAAK,KAAM,QAAO,KAAK,KAAK;AAAA,mBACvB,SAAS,MAAM,SAAS,EAAG,MAAK,KAAK,OAAO,MAAM;AAAA,cACtD,eAAc,KAAK,KAAK;AAAA,QACjC;AAAA,MACJ;AACA,aAAO,cAAc,IAAG;AAAA,IAC5B;AAEA,WAAO;AAAA,EACX;AAAA,EAEA,SAAS,MAAM;AACX,QAAI,OAAO,KAAK;AAEhB,QAAI,CAAC,WAAW,MAAM,IAAI,EAAG,QAAO;AAEpC,UAAM,gBAAgB,CAAA;AACtB,WAAO,MAAM;AACT,eAAS,IAAI,GAAG,IAAI,KAAK,SAAS,QAAQ,KAAK;AAC3C,cAAM,QAAQ,KAAK,SAAS,CAAC;AAC7B,cAAM,YAAY,KAAK,OAAO,KAAK,OAAO,KAAK,IAAI;AAEnD,YAAI,WAAW,MAAM,SAAS,GAAG;AAC7B,cAAI,KAAK,QAAQ,SAAS,MAAM,SAAS,EAAG,QAAO;AACnD,wBAAc,KAAK,KAAK;AAAA,QAC5B;AAAA,MACJ;AACA,aAAO,cAAc,IAAG;AAAA,IAC5B;AAEA,WAAO;AAAA,EACX;AAAA,EAEA,KAAK,MAAM;AACP,QAAI,EAAE,QAAQ,KAAK,QAAS,QAAO;AAEnC,QAAI,KAAK,SAAS,KAAK,aAAa;AAChC,eAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AAClC,aAAK,OAAO,KAAK,CAAC,CAAC;AAAA,MACvB;AACA,aAAO;AAAA,IACX;AAGA,QAAI,OAAO,KAAK,OAAO,KAAK,SAAS,GAAG,KAAK,SAAS,GAAG,CAAC;AAE1D,QAAI,CAAC,KAAK,KAAK,SAAS,QAAQ;AAE5B,WAAK,OAAO;AAAA,IAEhB,WAAW,KAAK,KAAK,WAAW,KAAK,QAAQ;AAEzC,WAAK,WAAW,KAAK,MAAM,IAAI;AAAA,IAEnC,OAAO;AACH,UAAI,KAAK,KAAK,SAAS,KAAK,QAAQ;AAEhC,cAAM,UAAU,KAAK;AACrB,aAAK,OAAO;AACZ,eAAO;AAAA,MACX;AAGA,WAAK,QAAQ,MAAM,KAAK,KAAK,SAAS,KAAK,SAAS,GAAG,IAAI;AAAA,IAC/D;AAEA,WAAO;AAAA,EACX;AAAA,EAEA,OAAO,MAAM;AACT,QAAI,KAAM,MAAK,QAAQ,MAAM,KAAK,KAAK,SAAS,CAAC;AACjD,WAAO;AAAA,EACX;AAAA,EAEA,QAAQ;AACJ,SAAK,OAAO,WAAW,EAAE;AACzB,WAAO;AAAA,EACX;AAAA,EAEA,OAAO,MAAM,UAAU;AACnB,QAAI,CAAC,KAAM,QAAO;AAElB,QAAI,OAAO,KAAK;AAChB,UAAM,OAAO,KAAK,OAAO,IAAI;AAC7B,UAAM,OAAO,CAAA;AACb,UAAM,UAAU,CAAA;AAChB,QAAI,GAAG,QAAQ;AAGf,WAAO,QAAQ,KAAK,QAAQ;AAExB,UAAI,CAAC,MAAM;AACP,eAAO,KAAK,IAAG;AACf,iBAAS,KAAK,KAAK,SAAS,CAAC;AAC7B,YAAI,QAAQ,IAAG;AACf,kBAAU;AAAA,MACd;AAEA,UAAI,KAAK,MAAM;AACX,cAAM,QAAQ,SAAS,MAAM,KAAK,UAAU,QAAQ;AAEpD,YAAI,UAAU,IAAI;AAEd,eAAK,SAAS,OAAO,OAAO,CAAC;AAC7B,eAAK,KAAK,IAAI;AACd,eAAK,UAAU,IAAI;AACnB,iBAAO;AAAA,QACX;AAAA,MACJ;AAEA,UAAI,CAAC,WAAW,CAAC,KAAK,QAAQ,SAAS,MAAM,IAAI,GAAG;AAChD,aAAK,KAAK,IAAI;AACd,gBAAQ,KAAK,CAAC;AACd,YAAI;AACJ,iBAAS;AACT,eAAO,KAAK,SAAS,CAAC;AAAA,MAE1B,WAAW,QAAQ;AACf;AACA,eAAO,OAAO,SAAS,CAAC;AACxB,kBAAU;AAAA,MAEd,MAAO,QAAO;AAAA,IAClB;AAEA,WAAO;AAAA,EACX;AAAA,EAEA,OAAO,MAAM;AAAE,WAAO;AAAA,EAAM;AAAA,EAE5B,YAAY,GAAG,GAAG;AAAE,WAAO,EAAE,OAAO,EAAE;AAAA,EAAM;AAAA,EAC5C,YAAY,GAAG,GAAG;AAAE,WAAO,EAAE,OAAO,EAAE;AAAA,EAAM;AAAA,EAE5C,SAAS;AAAE,WAAO,KAAK;AAAA,EAAM;AAAA,EAE7B,SAAS,MAAM;AACX,SAAK,OAAO;AACZ,WAAO;AAAA,EACX;AAAA,EAEA,KAAK,MAAM,QAAQ;AACf,UAAM,gBAAgB,CAAA;AACtB,WAAO,MAAM;AACT,UAAI,KAAK,KAAM,QAAO,KAAK,GAAG,KAAK,QAAQ;AAAA,UACtC,eAAc,KAAK,GAAG,KAAK,QAAQ;AAExC,aAAO,cAAc,IAAG;AAAA,IAC5B;AACA,WAAO;AAAA,EACX;AAAA,EAEA,OAAO,OAAO,MAAM,OAAO,QAAQ;AAE/B,UAAM,IAAI,QAAQ,OAAO;AACzB,QAAI,IAAI,KAAK;AACb,QAAI;AAEJ,QAAI,KAAK,GAAG;AAER,aAAO,WAAW,MAAM,MAAM,MAAM,QAAQ,CAAC,CAAC;AAC9C,eAAS,MAAM,KAAK,MAAM;AAC1B,aAAO;AAAA,IACX;AAEA,QAAI,CAAC,QAAQ;AAET,eAAS,KAAK,KAAK,KAAK,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;AAG5C,UAAI,KAAK,KAAK,IAAI,KAAK,IAAI,GAAG,SAAS,CAAC,CAAC;AAAA,IAC7C;AAEA,WAAO,WAAW,EAAE;AACpB,SAAK,OAAO;AACZ,SAAK,SAAS;AAId,UAAM,KAAK,KAAK,KAAK,IAAI,CAAC;AAC1B,UAAM,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,CAAC,CAAC;AAEtC,gBAAY,OAAO,MAAM,OAAO,IAAI,KAAK,WAAW;AAEpD,aAAS,IAAI,MAAM,KAAK,OAAO,KAAK,IAAI;AAEpC,YAAM,SAAS,KAAK,IAAI,IAAI,KAAK,GAAG,KAAK;AAEzC,kBAAY,OAAO,GAAG,QAAQ,IAAI,KAAK,WAAW;AAElD,eAAS,IAAI,GAAG,KAAK,QAAQ,KAAK,IAAI;AAElC,cAAM,SAAS,KAAK,IAAI,IAAI,KAAK,GAAG,MAAM;AAG1C,aAAK,SAAS,KAAK,KAAK,OAAO,OAAO,GAAG,QAAQ,SAAS,CAAC,CAAC;AAAA,MAChE;AAAA,IACJ;AAEA,aAAS,MAAM,KAAK,MAAM;AAE1B,WAAO;AAAA,EACX;AAAA,EAEA,eAAe,MAAM,MAAM,OAAO,MAAM;AACpC,WAAO,MAAM;AACT,WAAK,KAAK,IAAI;AAEd,UAAI,KAAK,QAAQ,KAAK,SAAS,MAAM,MAAO;AAE5C,UAAI,UAAU;AACd,UAAI,iBAAiB;AACrB,UAAI;AAEJ,eAAS,IAAI,GAAG,IAAI,KAAK,SAAS,QAAQ,KAAK;AAC3C,cAAM,QAAQ,KAAK,SAAS,CAAC;AAC7B,cAAM,OAAO,SAAS,KAAK;AAC3B,cAAM,cAAc,aAAa,MAAM,KAAK,IAAI;AAGhD,YAAI,cAAc,gBAAgB;AAC9B,2BAAiB;AACjB,oBAAU,OAAO,UAAU,OAAO;AAClC,uBAAa;AAAA,QAEjB,WAAW,gBAAgB,gBAAgB;AAEvC,cAAI,OAAO,SAAS;AAChB,sBAAU;AACV,yBAAa;AAAA,UACjB;AAAA,QACJ;AAAA,MACJ;AAEA,aAAO,cAAc,KAAK,SAAS,CAAC;AAAA,IACxC;AAEA,WAAO;AAAA,EACX;AAAA,EAEA,QAAQ,MAAM,OAAO,QAAQ;AACzB,UAAM,OAAO,SAAS,OAAO,KAAK,OAAO,IAAI;AAC7C,UAAM,aAAa,CAAA;AAGnB,UAAM,OAAO,KAAK,eAAe,MAAM,KAAK,MAAM,OAAO,UAAU;AAGnE,SAAK,SAAS,KAAK,IAAI;AACvB,WAAO,MAAM,IAAI;AAGjB,WAAO,SAAS,GAAG;AACf,UAAI,WAAW,KAAK,EAAE,SAAS,SAAS,KAAK,aAAa;AACtD,aAAK,OAAO,YAAY,KAAK;AAC7B;AAAA,MACJ,MAAO;AAAA,IACX;AAGA,SAAK,oBAAoB,MAAM,YAAY,KAAK;AAAA,EACpD;AAAA;AAAA,EAGA,OAAO,YAAY,OAAO;AACtB,UAAM,OAAO,WAAW,KAAK;AAC7B,UAAM,IAAI,KAAK,SAAS;AACxB,UAAM,IAAI,KAAK;AAEf,SAAK,iBAAiB,MAAM,GAAG,CAAC;AAEhC,UAAM,aAAa,KAAK,kBAAkB,MAAM,GAAG,CAAC;AAEpD,UAAM,UAAU,WAAW,KAAK,SAAS,OAAO,YAAY,KAAK,SAAS,SAAS,UAAU,CAAC;AAC9F,YAAQ,SAAS,KAAK;AACtB,YAAQ,OAAO,KAAK;AAEpB,aAAS,MAAM,KAAK,MAAM;AAC1B,aAAS,SAAS,KAAK,MAAM;AAE7B,QAAI,MAAO,YAAW,QAAQ,CAAC,EAAE,SAAS,KAAK,OAAO;AAAA,QACjD,MAAK,WAAW,MAAM,OAAO;AAAA,EACtC;AAAA,EAEA,WAAW,MAAM,SAAS;AAEtB,SAAK,OAAO,WAAW,CAAC,MAAM,OAAO,CAAC;AACtC,SAAK,KAAK,SAAS,KAAK,SAAS;AACjC,SAAK,KAAK,OAAO;AACjB,aAAS,KAAK,MAAM,KAAK,MAAM;AAAA,EACnC;AAAA,EAEA,kBAAkB,MAAM,GAAG,GAAG;AAC1B,QAAI;AACJ,QAAI,aAAa;AACjB,QAAI,UAAU;AAEd,aAAS,IAAI,GAAG,KAAK,IAAI,GAAG,KAAK;AAC7B,YAAM,QAAQ,SAAS,MAAM,GAAG,GAAG,KAAK,MAAM;AAC9C,YAAM,QAAQ,SAAS,MAAM,GAAG,GAAG,KAAK,MAAM;AAE9C,YAAM,UAAU,iBAAiB,OAAO,KAAK;AAC7C,YAAM,OAAO,SAAS,KAAK,IAAI,SAAS,KAAK;AAG7C,UAAI,UAAU,YAAY;AACtB,qBAAa;AACb,gBAAQ;AAER,kBAAU,OAAO,UAAU,OAAO;AAAA,MAEtC,WAAW,YAAY,YAAY;AAE/B,YAAI,OAAO,SAAS;AAChB,oBAAU;AACV,kBAAQ;AAAA,QACZ;AAAA,MACJ;AAAA,IACJ;AAEA,WAAO,SAAS,IAAI;AAAA,EACxB;AAAA;AAAA,EAGA,iBAAiB,MAAM,GAAG,GAAG;AACzB,UAAM,cAAc,KAAK,OAAO,KAAK,cAAc;AACnD,UAAM,cAAc,KAAK,OAAO,KAAK,cAAc;AACnD,UAAM,UAAU,KAAK,eAAe,MAAM,GAAG,GAAG,WAAW;AAC3D,UAAM,UAAU,KAAK,eAAe,MAAM,GAAG,GAAG,WAAW;AAI3D,QAAI,UAAU,QAAS,MAAK,SAAS,KAAK,WAAW;AAAA,EACzD;AAAA;AAAA,EAGA,eAAe,MAAM,GAAG,GAAG,SAAS;AAChC,SAAK,SAAS,KAAK,OAAO;AAE1B,UAAM,SAAS,KAAK;AACpB,UAAM,WAAW,SAAS,MAAM,GAAG,GAAG,MAAM;AAC5C,UAAM,YAAY,SAAS,MAAM,IAAI,GAAG,GAAG,MAAM;AACjD,QAAI,SAAS,WAAW,QAAQ,IAAI,WAAW,SAAS;AAExD,aAAS,IAAI,GAAG,IAAI,IAAI,GAAG,KAAK;AAC5B,YAAM,QAAQ,KAAK,SAAS,CAAC;AAC7B,aAAO,UAAU,KAAK,OAAO,OAAO,KAAK,IAAI,KAAK;AAClD,gBAAU,WAAW,QAAQ;AAAA,IACjC;AAEA,aAAS,IAAI,IAAI,IAAI,GAAG,KAAK,GAAG,KAAK;AACjC,YAAM,QAAQ,KAAK,SAAS,CAAC;AAC7B,aAAO,WAAW,KAAK,OAAO,OAAO,KAAK,IAAI,KAAK;AACnD,gBAAU,WAAW,SAAS;AAAA,IAClC;AAEA,WAAO;AAAA,EACX;AAAA,EAEA,oBAAoB,MAAM,MAAM,OAAO;AAEnC,aAAS,IAAI,OAAO,KAAK,GAAG,KAAK;AAC7B,aAAO,KAAK,CAAC,GAAG,IAAI;AAAA,IACxB;AAAA,EACJ;AAAA,EAEA,UAAU,MAAM;AAEZ,aAAS,IAAI,KAAK,SAAS,GAAG,UAAU,KAAK,GAAG,KAAK;AACjD,UAAI,KAAK,CAAC,EAAE,SAAS,WAAW,GAAG;AAC/B,YAAI,IAAI,GAAG;AACP,qBAAW,KAAK,IAAI,CAAC,EAAE;AACvB,mBAAS,OAAO,SAAS,QAAQ,KAAK,CAAC,CAAC,GAAG,CAAC;AAAA,QAEhD,MAAO,MAAK,MAAK;AAAA,MAErB,MAAO,UAAS,KAAK,CAAC,GAAG,KAAK,MAAM;AAAA,IACxC;AAAA,EACJ;AACJ;AAEA,SAAS,SAAS,MAAM,OAAO,UAAU;AACrC,MAAI,CAAC,SAAU,QAAO,MAAM,QAAQ,IAAI;AAExC,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,QAAI,SAAS,MAAM,MAAM,CAAC,CAAC,EAAG,QAAO;AAAA,EACzC;AACA,SAAO;AACX;AAGA,SAAS,SAAS,MAAM,QAAQ;AAC5B,WAAS,MAAM,GAAG,KAAK,SAAS,QAAQ,QAAQ,IAAI;AACxD;AAGA,SAAS,SAAS,MAAM,GAAG,GAAG,QAAQ,UAAU;AAC5C,MAAI,CAAC,SAAU,YAAW,WAAW,IAAI;AACzC,WAAS,OAAO;AAChB,WAAS,OAAO;AAChB,WAAS,OAAO;AAChB,WAAS,OAAO;AAEhB,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,UAAM,QAAQ,KAAK,SAAS,CAAC;AAC7B,WAAO,UAAU,KAAK,OAAO,OAAO,KAAK,IAAI,KAAK;AAAA,EACtD;AAEA,SAAO;AACX;AAEA,SAAS,OAAO,GAAG,GAAG;AAClB,IAAE,OAAO,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI;AAChC,IAAE,OAAO,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI;AAChC,IAAE,OAAO,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI;AAChC,IAAE,OAAO,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI;AAChC,SAAO;AACX;AAEA,SAAS,gBAAgB,GAAG,GAAG;AAAE,SAAO,EAAE,OAAO,EAAE;AAAM;AACzD,SAAS,gBAAgB,GAAG,GAAG;AAAE,SAAO,EAAE,OAAO,EAAE;AAAM;AAEzD,SAAS,SAAS,GAAK;AAAE,UAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE;AAAO;AACvE,SAAS,WAAW,GAAG;AAAE,SAAQ,EAAE,OAAO,EAAE,QAAS,EAAE,OAAO,EAAE;AAAO;AAEvE,SAAS,aAAa,GAAG,GAAG;AACxB,UAAQ,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI,IAAI,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI,MAClD,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI,IAAI,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI;AAC9D;AAEA,SAAS,iBAAiB,GAAG,GAAG;AAC5B,QAAM,OAAO,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI;AACpC,QAAM,OAAO,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI;AACpC,QAAM,OAAO,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI;AACpC,QAAM,OAAO,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI;AAEpC,SAAO,KAAK,IAAI,GAAG,OAAO,IAAI,IACvB,KAAK,IAAI,GAAG,OAAO,IAAI;AAClC;AAEA,SAAS,SAAS,GAAG,GAAG;AACpB,SAAO,EAAE,QAAQ,EAAE,QACZ,EAAE,QAAQ,EAAE,QACZ,EAAE,QAAQ,EAAE,QACZ,EAAE,QAAQ,EAAE;AACvB;AAEA,SAAS,WAAW,GAAG,GAAG;AACtB,SAAO,EAAE,QAAQ,EAAE,QACZ,EAAE,QAAQ,EAAE,QACZ,EAAE,QAAQ,EAAE,QACZ,EAAE,QAAQ,EAAE;AACvB;AAEA,SAAS,WAAW,UAAU;AAC1B,SAAO;AAAA,IACH;AAAA,IACA,QAAQ;AAAA,IACR,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA,EACd;AACA;AAKA,SAAS,YAAY,KAAK,MAAM,OAAO,GAAG,SAAS;AAC/C,QAAM,QAAQ,CAAC,MAAM,KAAK;AAE1B,SAAO,MAAM,QAAQ;AACjB,YAAQ,MAAM,IAAG;AACjB,WAAO,MAAM,IAAG;AAEhB,QAAI,QAAQ,QAAQ,EAAG;AAEvB,UAAM,MAAM,OAAO,KAAK,MAAM,QAAQ,QAAQ,IAAI,CAAC,IAAI;AACvD,gBAAY,KAAK,KAAK,MAAM,OAAO,OAAO;AAE1C,UAAM,KAAK,MAAM,KAAK,KAAK,KAAK;AAAA,EACpC;AACJ;","x_google_ignoreList":[0]}

package/dist/services/data-validator.cjs

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DEFAULT_IGNORE_COLUMNS = /* @__PURE__ */ new Set(["id", "code_geo", "code_parent"]);
+const DEFAULT_IGNORE_PATTERNS = [
+  /^20[012]\d$/,
+  // years 2000-2029
+  /^\d{5}$/,
+  // postal codes / INSEE codes
+  /^\d{1,2}$/
+  // indices, ranks (1-99)
+];
+function extractSourceNumbers(rows, ignoreColumns) {
+  const numbers = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const [col, val] of Object.entries(row)) {
+      if (ignoreColumns.has(col)) continue;
+      if (typeof val === "number" && isFinite(val)) {
+        numbers.add(val);
+      } else if (typeof val === "string") {
+        const parsed = Number(val.replace(/\s/g, "").replace(",", "."));
+        if (!isNaN(parsed) && isFinite(parsed)) {
+          numbers.add(parsed);
+        }
+      }
+    }
+  }
+  return numbers;
+}
+function extractLLMNumbers(text, ignorePatterns) {
+  const numberRegex = /\d[\d\s,.]*\d|\d+/g;
+  const results = [];
+  let match;
+  while ((match = numberRegex.exec(text)) !== null) {
+    const raw = match[0];
+    const cleaned = raw.replace(/[\s.]/g, "").replace(",", ".");
+    const value = Number(cleaned);
+    if (isNaN(value) || !isFinite(value)) continue;
+    if (ignorePatterns.some((p) => p.test(raw.trim()))) continue;
+    results.push({
+      value,
+      position: match.index,
+      context: text.slice(
+        Math.max(0, match.index - 10),
+        match.index + raw.length + 10
+      )
+    });
+  }
+  return results;
+}
+function validateAgainstSource(text, sourceRows, options = {}) {
+  const tolerance = options.tolerance ?? 0.01;
+  const ignoreColumns = new Set(options.ignoreColumns || [...DEFAULT_IGNORE_COLUMNS]);
+  const ignorePatterns = options.ignorePatterns || DEFAULT_IGNORE_PATTERNS;
+  const sourceNumbers = extractSourceNumbers(sourceRows, ignoreColumns);
+  const llmNumbers = extractLLMNumbers(text, ignorePatterns);
+  const hallucinated = [];
+  for (const num of llmNumbers) {
+    if (sourceNumbers.has(num.value)) continue;
+    let closest;
+    let minDistance = Infinity;
+    for (const src of sourceNumbers) {
+      const dist = Math.abs(num.value - src) / Math.max(Math.abs(src), 1);
+      if (dist < minDistance) {
+        minDistance = dist;
+        closest = src;
+      }
+    }
+    if (minDistance <= tolerance) continue;
+    hallucinated.push({
+      ...num,
+      closest,
+      distance: minDistance
+    });
+  }
+  const confidence = llmNumbers.length > 0 ? 1 - hallucinated.length / llmNumbers.length : 1;
+  return {
+    valid: hallucinated.length === 0,
+    llmNumbers,
+    sourceNumbers,
+    hallucinated,
+    confidence
+  };
+}
+exports.validateAgainstSource = validateAgainstSource;
+//# sourceMappingURL=data-validator.cjs.map

package/dist/services/data-validator.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-validator.cjs","sources":["../../src/services/data-validator.ts"],"sourcesContent":["/**\n * Data Validator — anti-hallucination for LLM-generated text\n * v3.1.0: Pure regex-based number verification against source data\n *\n * Compares numbers in LLM text to numbers in source data rows.\n * Detects ~90% of numerical hallucinations with zero LLM cost, <1ms latency.\n */\n\nimport type { DataValidation, DataValidationOptions, LLMNumber, HallucinatedNumber } from '../types/chat-bus'\n\nconst DEFAULT_IGNORE_COLUMNS = new Set(['id', 'code_geo', 'code_parent'])\nconst DEFAULT_IGNORE_PATTERNS: RegExp[] = [\n  /^20[012]\\d$/,       // years 2000-2029\n  /^\\d{5}$/,           // postal codes / INSEE codes\n  /^\\d{1,2}$/,         // indices, ranks (1-99)\n]\n\n/**\n * Extract all numeric values from source data rows.\n * Handles both number types and string-encoded numbers (e.g. \"22 306\", \"3,337\").\n */\nfunction extractSourceNumbers(\n  rows: Record<string, unknown>[],\n  ignoreColumns: Set<string>\n): Set<number> {\n  const numbers = new Set<number>()\n  for (const row of rows) {\n    for (const [col, val] of Object.entries(row)) {\n      if (ignoreColumns.has(col)) continue\n      if (typeof val === 'number' && isFinite(val)) {\n        numbers.add(val)\n      } else if (typeof val === 'string') {\n        const parsed = Number(val.replace(/\\s/g, '').replace(',', '.'))\n        if (!isNaN(parsed) && isFinite(parsed)) {\n          numbers.add(parsed)\n        }\n      }\n    }\n  }\n  return numbers\n}\n\n/**\n * Extract all numbers from LLM text.\n * Handles French/European formats: \"22 306\", \"3 337\", \"3,337\", \"22306\".\n */\nfunction extractLLMNumbers(\n  text: string,\n  ignorePatterns: RegExp[]\n): LLMNumber[] {\n  const numberRegex = /\\d[\\d\\s,.]*\\d|\\d+/g\n  const results: LLMNumber[] = []\n  let match: RegExpExecArray | null\n\n  while ((match = numberRegex.exec(text)) !== null) {\n    const raw = match[0]\n    // Normalize: remove spaces/dots (thousand separators), comma → decimal point\n    const cleaned = raw.replace(/[\\s.]/g, '').replace(',', '.')\n    const value = Number(cleaned)\n\n    if (isNaN(value) || !isFinite(value)) continue\n    if (ignorePatterns.some(p => p.test(raw.trim()))) continue\n\n    results.push({\n      value,\n      position: match.index,\n      context: text.slice(\n        Math.max(0, match.index - 10),\n        match.index + raw.length + 10\n      ),\n    })\n  }\n\n  return results\n}\n\n/**\n * Validate LLM-generated text against source data rows.\n *\n * Pure function — no IO, no LLM calls, no side effects.\n * Returns which numbers in the text are verified vs hallucinated.\n *\n * @example\n * ```typescript\n * const rows = [{ type: 'Appartement', ventes: 22306, prix_m2: 3337 }]\n * const result = validateAgainstSource(\n *   \"On observe 22 306 ventes à 3 337 EUR/m². En 2023, 18 245 ventes.\",\n *   rows\n * )\n * // result.valid === false\n * // result.hallucinated === [{ value: 18245, ... }]\n * // result.confidence === 0.67\n * ```\n */\nexport function validateAgainstSource(\n  text: string,\n  sourceRows: Record<string, unknown>[],\n  options: DataValidationOptions = {}\n): DataValidation {\n  const tolerance = options.tolerance ?? 0.01\n  const ignoreColumns = new Set(options.ignoreColumns || [...DEFAULT_IGNORE_COLUMNS])\n  const ignorePatterns = options.ignorePatterns || DEFAULT_IGNORE_PATTERNS\n\n  // 1. Extract source numbers\n  const sourceNumbers = extractSourceNumbers(sourceRows, ignoreColumns)\n\n  // 2. Extract LLM numbers\n  const llmNumbers = extractLLMNumbers(text, ignorePatterns)\n\n  // 3. Check each LLM number against source\n  const hallucinated: HallucinatedNumber[] = []\n\n  for (const num of llmNumbers) {\n    // Exact match\n    if (sourceNumbers.has(num.value)) continue\n\n    // Tolerance match (rounding)\n    let closest: number | undefined\n    let minDistance = Infinity\n\n    for (const src of sourceNumbers) {\n      const dist = Math.abs(num.value - src) / Math.max(Math.abs(src), 1)\n      if (dist < minDistance) {\n        minDistance = dist\n        closest = src\n      }\n    }\n\n    if (minDistance <= tolerance) continue // acceptable rounding\n\n    hallucinated.push({\n      ...num,\n      closest,\n      distance: minDistance,\n    })\n  }\n\n  const confidence = llmNumbers.length > 0\n    ? 1 - (hallucinated.length / llmNumbers.length)\n    : 1\n\n  return {\n    valid: hallucinated.length === 0,\n    llmNumbers,\n    sourceNumbers,\n    hallucinated,\n    confidence,\n  }\n}\n"],"names":[],"mappings":";;AAUA,MAAM,yBAAyB,oBAAI,IAAI,CAAC,MAAM,YAAY,aAAa,CAAC;AACxE,MAAM,0BAAoC;AAAA,EACxC;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AACF;AAMA,SAAS,qBACP,MACA,eACa;AACb,QAAM,8BAAc,IAAA;AACpB,aAAW,OAAO,MAAM;AACtB,eAAW,CAAC,KAAK,GAAG,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC5C,UAAI,cAAc,IAAI,GAAG,EAAG;AAC5B,UAAI,OAAO,QAAQ,YAAY,SAAS,GAAG,GAAG;AAC5C,gBAAQ,IAAI,GAAG;AAAA,MACjB,WAAW,OAAO,QAAQ,UAAU;AAClC,cAAM,SAAS,OAAO,IAAI,QAAQ,OAAO,EAAE,EAAE,QAAQ,KAAK,GAAG,CAAC;AAC9D,YAAI,CAAC,MAAM,MAAM,KAAK,SAAS,MAAM,GAAG;AACtC,kBAAQ,IAAI,MAAM;AAAA,QACpB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAMA,SAAS,kBACP,MACA,gBACa;AACb,QAAM,cAAc;AACpB,QAAM,UAAuB,CAAA;AAC7B,MAAI;AAEJ,UAAQ,QAAQ,YAAY,KAAK,IAAI,OAAO,MAAM;AAChD,UAAM,MAAM,MAAM,CAAC;AAEnB,UAAM,UAAU,IAAI,QAAQ,UAAU,EAAE,EAAE,QAAQ,KAAK,GAAG;AAC1D,UAAM,QAAQ,OAAO,OAAO;AAE5B,QAAI,MAAM,KAAK,KAAK,CAAC,SAAS,KAAK,EAAG;AACtC,QAAI,eAAe,KAAK,CAAA,MAAK,EAAE,KAAK,IAAI,KAAA,CAAM,CAAC,EAAG;AAElD,YAAQ,KAAK;AAAA,MACX;AAAA,MACA,UAAU,MAAM;AAAA,MAChB,SAAS,KAAK;AAAA,QACZ,KAAK,IAAI,GAAG,MAAM,QAAQ,EAAE;AAAA,QAC5B,MAAM,QAAQ,IAAI,SAAS;AAAA,MAAA;AAAA,IAC7B,CACD;AAAA,EACH;AAEA,SAAO;AACT;AAoBO,SAAS,sBACd,MACA,YACA,UAAiC,CAAA,GACjB;AAChB,QAAM,YAAY,QAAQ,aAAa;AACvC,QAAM,gBAAgB,IAAI,IAAI,QAAQ,iBAAiB,CAAC,GAAG,sBAAsB,CAAC;AAClF,QAAM,iBAAiB,QAAQ,kBAAkB;AAGjD,QAAM,gBAAgB,qBAAqB,YAAY,aAAa;AAGpE,QAAM,aAAa,kBAAkB,MAAM,cAAc;AAGzD,QAAM,eAAqC,CAAA;AAE3C,aAAW,OAAO,YAAY;AAE5B,QAAI,cAAc,IAAI,IAAI,KAAK,EAAG;AAGlC,QAAI;AACJ,QAAI,cAAc;AAElB,eAAW,OAAO,eAAe;AAC/B,YAAM,OAAO,KAAK,IAAI,IAAI,QAAQ,GAAG,IAAI,KAAK,IAAI,KAAK,IAAI,GAAG,GAAG,CAAC;AAClE,UAAI,OAAO,aAAa;AACtB,sBAAc;AACd,kBAAU;AAAA,MACZ;AAAA,IACF;AAEA,QAAI,eAAe,UAAW;AAE9B,iBAAa,KAAK;AAAA,MAChB,GAAG;AAAA,MACH;AAAA,MACA,UAAU;AAAA,IAAA,CACX;AAAA,EACH;AAEA,QAAM,aAAa,WAAW,SAAS,IACnC,IAAK,aAAa,SAAS,WAAW,SACtC;AAEJ,SAAO;AAAA,IACL,OAAO,aAAa,WAAW;AAAA,IAC/B;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;;"}

package/dist/services/data-validator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Data Validator — anti-hallucination for LLM-generated text
+ * v3.1.0: Pure regex-based number verification against source data
+ *
+ * Compares numbers in LLM text to numbers in source data rows.
+ * Detects ~90% of numerical hallucinations with zero LLM cost, <1ms latency.
+ */
+import type { DataValidation, DataValidationOptions } from '../types/chat-bus';
+/**
+ * Validate LLM-generated text against source data rows.
+ *
+ * Pure function — no IO, no LLM calls, no side effects.
+ * Returns which numbers in the text are verified vs hallucinated.
+ *
+ * @example
+ * ```typescript
+ * const rows = [{ type: 'Appartement', ventes: 22306, prix_m2: 3337 }]
+ * const result = validateAgainstSource(
+ *   "On observe 22 306 ventes à 3 337 EUR/m². En 2023, 18 245 ventes.",
+ *   rows
+ * )
+ * // result.valid === false
+ * // result.hallucinated === [{ value: 18245, ... }]
+ * // result.confidence === 0.67
+ * ```
+ */
+export declare function validateAgainstSource(text: string, sourceRows: Record<string, unknown>[], options?: DataValidationOptions): DataValidation;
+//# sourceMappingURL=data-validator.d.ts.map

package/dist/services/data-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-validator.d.ts","sourceRoot":"","sources":["../../src/services/data-validator.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAiC,MAAM,mBAAmB,CAAA;AAoE7G;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACrC,OAAO,GAAE,qBAA0B,GAClC,cAAc,CAkDhB"}

package/dist/services/data-validator.js

@@ -0,0 +1,85 @@
+const DEFAULT_IGNORE_COLUMNS = /* @__PURE__ */ new Set(["id", "code_geo", "code_parent"]);
+const DEFAULT_IGNORE_PATTERNS = [
+  /^20[012]\d$/,
+  // years 2000-2029
+  /^\d{5}$/,
+  // postal codes / INSEE codes
+  /^\d{1,2}$/
+  // indices, ranks (1-99)
+];
+function extractSourceNumbers(rows, ignoreColumns) {
+  const numbers = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const [col, val] of Object.entries(row)) {
+      if (ignoreColumns.has(col)) continue;
+      if (typeof val === "number" && isFinite(val)) {
+        numbers.add(val);
+      } else if (typeof val === "string") {
+        const parsed = Number(val.replace(/\s/g, "").replace(",", "."));
+        if (!isNaN(parsed) && isFinite(parsed)) {
+          numbers.add(parsed);
+        }
+      }
+    }
+  }
+  return numbers;
+}
+function extractLLMNumbers(text, ignorePatterns) {
+  const numberRegex = /\d[\d\s,.]*\d|\d+/g;
+  const results = [];
+  let match;
+  while ((match = numberRegex.exec(text)) !== null) {
+    const raw = match[0];
+    const cleaned = raw.replace(/[\s.]/g, "").replace(",", ".");
+    const value = Number(cleaned);
+    if (isNaN(value) || !isFinite(value)) continue;
+    if (ignorePatterns.some((p) => p.test(raw.trim()))) continue;
+    results.push({
+      value,
+      position: match.index,
+      context: text.slice(
+        Math.max(0, match.index - 10),
+        match.index + raw.length + 10
+      )
+    });
+  }
+  return results;
+}
+function validateAgainstSource(text, sourceRows, options = {}) {
+  const tolerance = options.tolerance ?? 0.01;
+  const ignoreColumns = new Set(options.ignoreColumns || [...DEFAULT_IGNORE_COLUMNS]);
+  const ignorePatterns = options.ignorePatterns || DEFAULT_IGNORE_PATTERNS;
+  const sourceNumbers = extractSourceNumbers(sourceRows, ignoreColumns);
+  const llmNumbers = extractLLMNumbers(text, ignorePatterns);
+  const hallucinated = [];
+  for (const num of llmNumbers) {
+    if (sourceNumbers.has(num.value)) continue;
+    let closest;
+    let minDistance = Infinity;
+    for (const src of sourceNumbers) {
+      const dist = Math.abs(num.value - src) / Math.max(Math.abs(src), 1);
+      if (dist < minDistance) {
+        minDistance = dist;
+        closest = src;
+      }
+    }
+    if (minDistance <= tolerance) continue;
+    hallucinated.push({
+      ...num,
+      closest,
+      distance: minDistance
+    });
+  }
+  const confidence = llmNumbers.length > 0 ? 1 - hallucinated.length / llmNumbers.length : 1;
+  return {
+    valid: hallucinated.length === 0,
+    llmNumbers,
+    sourceNumbers,
+    hallucinated,
+    confidence
+  };
+}
+export {
+  validateAgainstSource
+};
+//# sourceMappingURL=data-validator.js.map

package/dist/services/data-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-validator.js","sources":["../../src/services/data-validator.ts"],"sourcesContent":["/**\n * Data Validator — anti-hallucination for LLM-generated text\n * v3.1.0: Pure regex-based number verification against source data\n *\n * Compares numbers in LLM text to numbers in source data rows.\n * Detects ~90% of numerical hallucinations with zero LLM cost, <1ms latency.\n */\n\nimport type { DataValidation, DataValidationOptions, LLMNumber, HallucinatedNumber } from '../types/chat-bus'\n\nconst DEFAULT_IGNORE_COLUMNS = new Set(['id', 'code_geo', 'code_parent'])\nconst DEFAULT_IGNORE_PATTERNS: RegExp[] = [\n  /^20[012]\\d$/,       // years 2000-2029\n  /^\\d{5}$/,           // postal codes / INSEE codes\n  /^\\d{1,2}$/,         // indices, ranks (1-99)\n]\n\n/**\n * Extract all numeric values from source data rows.\n * Handles both number types and string-encoded numbers (e.g. \"22 306\", \"3,337\").\n */\nfunction extractSourceNumbers(\n  rows: Record<string, unknown>[],\n  ignoreColumns: Set<string>\n): Set<number> {\n  const numbers = new Set<number>()\n  for (const row of rows) {\n    for (const [col, val] of Object.entries(row)) {\n      if (ignoreColumns.has(col)) continue\n      if (typeof val === 'number' && isFinite(val)) {\n        numbers.add(val)\n      } else if (typeof val === 'string') {\n        const parsed = Number(val.replace(/\\s/g, '').replace(',', '.'))\n        if (!isNaN(parsed) && isFinite(parsed)) {\n          numbers.add(parsed)\n        }\n      }\n    }\n  }\n  return numbers\n}\n\n/**\n * Extract all numbers from LLM text.\n * Handles French/European formats: \"22 306\", \"3 337\", \"3,337\", \"22306\".\n */\nfunction extractLLMNumbers(\n  text: string,\n  ignorePatterns: RegExp[]\n): LLMNumber[] {\n  const numberRegex = /\\d[\\d\\s,.]*\\d|\\d+/g\n  const results: LLMNumber[] = []\n  let match: RegExpExecArray | null\n\n  while ((match = numberRegex.exec(text)) !== null) {\n    const raw = match[0]\n    // Normalize: remove spaces/dots (thousand separators), comma → decimal point\n    const cleaned = raw.replace(/[\\s.]/g, '').replace(',', '.')\n    const value = Number(cleaned)\n\n    if (isNaN(value) || !isFinite(value)) continue\n    if (ignorePatterns.some(p => p.test(raw.trim()))) continue\n\n    results.push({\n      value,\n      position: match.index,\n      context: text.slice(\n        Math.max(0, match.index - 10),\n        match.index + raw.length + 10\n      ),\n    })\n  }\n\n  return results\n}\n\n/**\n * Validate LLM-generated text against source data rows.\n *\n * Pure function — no IO, no LLM calls, no side effects.\n * Returns which numbers in the text are verified vs hallucinated.\n *\n * @example\n * ```typescript\n * const rows = [{ type: 'Appartement', ventes: 22306, prix_m2: 3337 }]\n * const result = validateAgainstSource(\n *   \"On observe 22 306 ventes à 3 337 EUR/m². En 2023, 18 245 ventes.\",\n *   rows\n * )\n * // result.valid === false\n * // result.hallucinated === [{ value: 18245, ... }]\n * // result.confidence === 0.67\n * ```\n */\nexport function validateAgainstSource(\n  text: string,\n  sourceRows: Record<string, unknown>[],\n  options: DataValidationOptions = {}\n): DataValidation {\n  const tolerance = options.tolerance ?? 0.01\n  const ignoreColumns = new Set(options.ignoreColumns || [...DEFAULT_IGNORE_COLUMNS])\n  const ignorePatterns = options.ignorePatterns || DEFAULT_IGNORE_PATTERNS\n\n  // 1. Extract source numbers\n  const sourceNumbers = extractSourceNumbers(sourceRows, ignoreColumns)\n\n  // 2. Extract LLM numbers\n  const llmNumbers = extractLLMNumbers(text, ignorePatterns)\n\n  // 3. Check each LLM number against source\n  const hallucinated: HallucinatedNumber[] = []\n\n  for (const num of llmNumbers) {\n    // Exact match\n    if (sourceNumbers.has(num.value)) continue\n\n    // Tolerance match (rounding)\n    let closest: number | undefined\n    let minDistance = Infinity\n\n    for (const src of sourceNumbers) {\n      const dist = Math.abs(num.value - src) / Math.max(Math.abs(src), 1)\n      if (dist < minDistance) {\n        minDistance = dist\n        closest = src\n      }\n    }\n\n    if (minDistance <= tolerance) continue // acceptable rounding\n\n    hallucinated.push({\n      ...num,\n      closest,\n      distance: minDistance,\n    })\n  }\n\n  const confidence = llmNumbers.length > 0\n    ? 1 - (hallucinated.length / llmNumbers.length)\n    : 1\n\n  return {\n    valid: hallucinated.length === 0,\n    llmNumbers,\n    sourceNumbers,\n    hallucinated,\n    confidence,\n  }\n}\n"],"names":[],"mappings":"AAUA,MAAM,yBAAyB,oBAAI,IAAI,CAAC,MAAM,YAAY,aAAa,CAAC;AACxE,MAAM,0BAAoC;AAAA,EACxC;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AACF;AAMA,SAAS,qBACP,MACA,eACa;AACb,QAAM,8BAAc,IAAA;AACpB,aAAW,OAAO,MAAM;AACtB,eAAW,CAAC,KAAK,GAAG,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC5C,UAAI,cAAc,IAAI,GAAG,EAAG;AAC5B,UAAI,OAAO,QAAQ,YAAY,SAAS,GAAG,GAAG;AAC5C,gBAAQ,IAAI,GAAG;AAAA,MACjB,WAAW,OAAO,QAAQ,UAAU;AAClC,cAAM,SAAS,OAAO,IAAI,QAAQ,OAAO,EAAE,EAAE,QAAQ,KAAK,GAAG,CAAC;AAC9D,YAAI,CAAC,MAAM,MAAM,KAAK,SAAS,MAAM,GAAG;AACtC,kBAAQ,IAAI,MAAM;AAAA,QACpB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAMA,SAAS,kBACP,MACA,gBACa;AACb,QAAM,cAAc;AACpB,QAAM,UAAuB,CAAA;AAC7B,MAAI;AAEJ,UAAQ,QAAQ,YAAY,KAAK,IAAI,OAAO,MAAM;AAChD,UAAM,MAAM,MAAM,CAAC;AAEnB,UAAM,UAAU,IAAI,QAAQ,UAAU,EAAE,EAAE,QAAQ,KAAK,GAAG;AAC1D,UAAM,QAAQ,OAAO,OAAO;AAE5B,QAAI,MAAM,KAAK,KAAK,CAAC,SAAS,KAAK,EAAG;AACtC,QAAI,eAAe,KAAK,CAAA,MAAK,EAAE,KAAK,IAAI,KAAA,CAAM,CAAC,EAAG;AAElD,YAAQ,KAAK;AAAA,MACX;AAAA,MACA,UAAU,MAAM;AAAA,MAChB,SAAS,KAAK;AAAA,QACZ,KAAK,IAAI,GAAG,MAAM,QAAQ,EAAE;AAAA,QAC5B,MAAM,QAAQ,IAAI,SAAS;AAAA,MAAA;AAAA,IAC7B,CACD;AAAA,EACH;AAEA,SAAO;AACT;AAoBO,SAAS,sBACd,MACA,YACA,UAAiC,CAAA,GACjB;AAChB,QAAM,YAAY,QAAQ,aAAa;AACvC,QAAM,gBAAgB,IAAI,IAAI,QAAQ,iBAAiB,CAAC,GAAG,sBAAsB,CAAC;AAClF,QAAM,iBAAiB,QAAQ,kBAAkB;AAGjD,QAAM,gBAAgB,qBAAqB,YAAY,aAAa;AAGpE,QAAM,aAAa,kBAAkB,MAAM,cAAc;AAGzD,QAAM,eAAqC,CAAA;AAE3C,aAAW,OAAO,YAAY;AAE5B,QAAI,cAAc,IAAI,IAAI,KAAK,EAAG;AAGlC,QAAI;AACJ,QAAI,cAAc;AAElB,eAAW,OAAO,eAAe;AAC/B,YAAM,OAAO,KAAK,IAAI,IAAI,QAAQ,GAAG,IAAI,KAAK,IAAI,KAAK,IAAI,GAAG,GAAG,CAAC;AAClE,UAAI,OAAO,aAAa;AACtB,sBAAc;AACd,kBAAU;AAAA,MACZ;AAAA,IACF;AAEA,QAAI,eAAe,UAAW;AAE9B,iBAAa,KAAK;AAAA,MAChB,GAAG;AAAA,MACH;AAAA,MACA,UAAU;AAAA,IAAA,CACX;AAAA,EACH;AAEA,QAAM,aAAa,WAAW,SAAS,IACnC,IAAK,aAAa,SAAS,WAAW,SACtC;AAEJ,SAAO;AAAA,IACL,OAAO,aAAa,WAAW;AAAA,IAC/B;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;"}

package/dist/services/index.d.ts

@@ -6,4 +6,5 @@
 export { validateComponent, validateLayout, validateIframeDomain, getIframeSandbox, DEFAULT_RESOURCE_LIMITS, DEFAULT_IFRAME_DOMAINS, TRUSTED_IFRAME_DOMAINS, } from './validation';
 export { ComponentRegistry } from './component-registry';
 export { createEventEmitter, createCommandHandler, createChatBus, mergeScratchpadSections } from './chat-bus';
+export { validateAgainstSource } from './data-validator';
 //# sourceMappingURL=index.d.ts.map