@antv/l7-layers 2.9.24 → 2.9.26-alpha.0

package/lib/utils/extrude_polyline.js

@@ -1,451 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/utils/extrude_polyline.ts
-var extrude_polyline_exports = {};
-__export(extrude_polyline_exports, {
-  computeMiter: () => computeMiter,
-  computeNormal: () => computeNormal,
-  default: () => ExtrudePolyline,
-  direction: () => direction
-});
-module.exports = __toCommonJS(extrude_polyline_exports);
-var import_l7_utils = require("@antv/l7-utils");
-var import_gl_matrix = require("gl-matrix");
-var tmp = import_gl_matrix.vec2.create();
-var capEnd = import_gl_matrix.vec2.create();
-var lineA = import_gl_matrix.vec2.create();
-var lineB = import_gl_matrix.vec2.create();
-var tangent = import_gl_matrix.vec2.create();
-function computeMiter(lineTangent, miter, start, end, halfThick) {
-  import_gl_matrix.vec2.add(lineTangent, start, end);
-  import_gl_matrix.vec2.normalize(lineTangent, lineTangent);
-  miter = import_gl_matrix.vec2.fromValues(-lineTangent[1], lineTangent[0]);
-  const tmpvec = import_gl_matrix.vec2.fromValues(-start[1], start[0]);
-  return [halfThick / import_gl_matrix.vec2.dot(miter, tmpvec), miter];
-}
-function computeNormal(out, dir) {
-  return import_gl_matrix.vec2.set(out, -dir[1], dir[0]);
-}
-function direction(out, a, b) {
-  import_gl_matrix.vec2.sub(out, a, b);
-  import_gl_matrix.vec2.normalize(out, out);
-  return out;
-}
-function isPointEqual(a, b) {
-  return a[0] === b[0] && a[1] === b[1];
-}
-var ExtrudePolyline = class {
-  constructor(opts = {}) {
-    this.lastFlip = -1;
-    this.miter = import_gl_matrix.vec2.fromValues(0, 0);
-    this.started = false;
-    this.dash = false;
-    this.totalDistance = 0;
-    this.currentIndex = 0;
-    this.join = opts.join || "miter";
-    this.cap = opts.cap || "butt";
-    this.miterLimit = opts.miterLimit || 10;
-    this.thickness = opts.thickness || 1;
-    this.dash = opts.dash || false;
-    this.complex = {
-      positions: [],
-      indices: [],
-      normals: [],
-      startIndex: 0,
-      indexes: []
-    };
-  }
-  simpleExtrude(points) {
-    const complex = this.complex;
-    if (points.length <= 1) {
-      return complex;
-    }
-    this.lastFlip = -1;
-    this.started = false;
-    this.normal = null;
-    this.totalDistance = 0;
-    const total = points.length;
-    let count = complex.startIndex;
-    for (let i = 1; i < total; i++) {
-      const last = points[i - 1];
-      const cur = points[i];
-      const next = i < points.length - 1 ? points[i + 1] : null;
-      const amt = this.simpleSegment(complex, count, last, cur, next);
-      count += amt;
-    }
-    if (this.dash) {
-      for (let i = 0; i < complex.positions.length / 6; i++) {
-        complex.positions[i * 6 + 5] = this.totalDistance;
-      }
-    }
-    complex.startIndex = complex.positions.length / 6;
-    return complex;
-  }
-  simpleExtrude_gaode2(points, originPoints) {
-    const complex = this.complex;
-    if (points.length <= 1) {
-      return complex;
-    }
-    this.lastFlip = -1;
-    this.started = false;
-    this.normal = null;
-    this.totalDistance = 0;
-    const total = points.length;
-    let count = complex.startIndex;
-    for (let i = 1; i < total; i++) {
-      const last = points[i - 1];
-      last.push(originPoints[i - 1][2] ?? 0);
-      const originLast = originPoints[i - 1];
-      const cur = points[i];
-      cur.push(originPoints[i][2] ?? 0);
-      const originCur = originPoints[i];
-      const next = i < points.length - 1 ? [...points[i + 1], originPoints[i + 1][2] ?? 0] : null;
-      const originNext = i < originPoints.length - 1 ? originPoints[i + 1] : null;
-      const amt = this.simpleSegment(complex, count, last, cur, next, originLast, originCur, originNext);
-      count += amt;
-    }
-    if (this.dash) {
-      for (let i = 0; i < complex.positions.length / 6; i++) {
-        complex.positions[i * 6 + 5] = this.totalDistance;
-      }
-    }
-    complex.startIndex = complex.positions.length / 6;
-    return complex;
-  }
-  extrude_gaode2(points, originPoints) {
-    const complex = this.complex;
-    if (points.length <= 1) {
-      return complex;
-    }
-    this.lastFlip = -1;
-    this.started = false;
-    this.normal = null;
-    this.totalDistance = 0;
-    const total = points.length;
-    let count = complex.startIndex;
-    for (let i = 1; i < total; i++) {
-      const last = points[i - 1];
-      last.push(originPoints[i - 1][2] ?? 0);
-      const originLast = originPoints[i - 1];
-      const cur = points[i];
-      cur.push(originPoints[i][2] ?? 0);
-      const originCur = originPoints[i];
-      const next = i < points.length - 1 ? [...points[i + 1], originPoints[i + 1][2] ?? 0] : null;
-      const originNext = i < originPoints.length - 1 ? originPoints[i + 1] : null;
-      const amt = this.segment_gaode2(complex, count, last, cur, next, originLast, originCur, originNext);
-      count += amt;
-    }
-    if (this.dash) {
-      for (let i = 0; i < complex.positions.length / 6; i++) {
-        complex.positions[i * 6 + 5] = this.totalDistance;
-      }
-    }
-    complex.startIndex = complex.positions.length / 6;
-    return complex;
-  }
-  extrude(points) {
-    const complex = this.complex;
-    if (points.length <= 1) {
-      return complex;
-    }
-    this.lastFlip = -1;
-    this.started = false;
-    this.normal = null;
-    this.totalDistance = 0;
-    const total = points.length;
-    let count = complex.startIndex;
-    for (let i = 1; i < total; i++) {
-      const last = points[i - 1];
-      const cur = points[i];
-      const next = i < points.length - 1 ? points[i + 1] : null;
-      const amt = this.segment(complex, count, last, cur, next);
-      count += amt;
-    }
-    if (this.dash) {
-      for (let i = 0; i < complex.positions.length / 6; i++) {
-        complex.positions[i * 6 + 5] = this.totalDistance;
-      }
-    }
-    complex.startIndex = complex.positions.length / 6;
-    return complex;
-  }
-  simpleSegment(complex, index, last, cur, next) {
-    let count = 0;
-    const indices = complex.indices;
-    const positions = complex.positions;
-    const normals = complex.normals;
-    const flatCur = (0, import_l7_utils.aProjectFlat)([cur[0], cur[1]]);
-    const flatLast = (0, import_l7_utils.aProjectFlat)([last[0], last[1]]);
-    direction(lineA, flatCur, flatLast);
-    let segmentDistance = 0;
-    if (this.dash) {
-      segmentDistance = this.lineSegmentDistance(flatCur, flatLast);
-      this.totalDistance += segmentDistance;
-    }
-    if (!this.normal) {
-      this.normal = import_gl_matrix.vec2.create();
-      computeNormal(this.normal, lineA);
-    }
-    if (!this.started) {
-      this.started = true;
-      this.extrusions(positions, normals, last, this.normal, this.thickness, this.totalDistance - segmentDistance);
-    }
-    indices.push(index + 0, index + 1, index + 2);
-    if (!next) {
-      computeNormal(this.normal, lineA);
-      this.extrusions(positions, normals, cur, this.normal, this.thickness, this.totalDistance);
-      indices.push(...this.lastFlip === 1 ? [index, index + 2, index + 3] : [index + 2, index + 1, index + 3]);
-      count += 2;
-    } else {
-      const flatNext = (0, import_l7_utils.aProjectFlat)([next[0], next[1]]);
-      if (isPointEqual(flatCur, flatNext)) {
-        import_gl_matrix.vec2.add(flatNext, flatCur, import_gl_matrix.vec2.normalize(flatNext, import_gl_matrix.vec2.subtract(flatNext, flatCur, flatLast)));
-      }
-      direction(lineB, flatNext, flatCur);
-      const [miterLen, miter] = computeMiter(tangent, import_gl_matrix.vec2.create(), lineA, lineB, this.thickness);
-      let flip = import_gl_matrix.vec2.dot(tangent, this.normal) < 0 ? -1 : 1;
-      this.extrusions(positions, normals, cur, miter, miterLen, this.totalDistance);
-      indices.push(...this.lastFlip === 1 ? [index, index + 2, index + 3] : [index + 2, index + 1, index + 3]);
-      flip = -1;
-      import_gl_matrix.vec2.copy(this.normal, miter);
-      count += 2;
-      this.lastFlip = flip;
-    }
-    return count;
-  }
-  segment_gaode2(complex, index, last, cur, next, originLast, originCur, originNext) {
-    let count = 0;
-    const indices = complex.indices;
-    const positions = complex.positions;
-    const normals = complex.normals;
-    const capSquare = this.cap === "square";
-    const joinBevel = this.join === "bevel";
-    const flatCur = (0, import_l7_utils.aProjectFlat)([originCur[0], originCur[1]]);
-    const flatLast = (0, import_l7_utils.aProjectFlat)([originLast[0], originLast[1]]);
-    direction(lineA, cur, last);
-    let segmentDistance = 0;
-    if (this.dash) {
-      segmentDistance = this.lineSegmentDistance(flatCur, flatLast);
-      this.totalDistance += segmentDistance;
-    }
-    if (!this.normal) {
-      this.normal = import_gl_matrix.vec2.create();
-      computeNormal(this.normal, lineA);
-    }
-    if (!this.started) {
-      this.started = true;
-      if (capSquare) {
-        const out1 = import_gl_matrix.vec2.create();
-        const out2 = import_gl_matrix.vec2.create();
-        import_gl_matrix.vec2.add(out1, this.normal, lineA);
-        import_gl_matrix.vec2.add(out2, this.normal, lineA);
-        normals.push(out2[0], out2[1], 0);
-        normals.push(out1[0], out1[1], 0);
-        positions.push(last[0], last[1], last[2] | 0, this.totalDistance - segmentDistance, -this.thickness, last[2] | 0);
-        this.complex.indexes.push(this.currentIndex);
-        positions.push(last[0], last[1], last[2] | 0, this.totalDistance - segmentDistance, this.thickness, last[2] | 0);
-        this.complex.indexes.push(this.currentIndex);
-        this.currentIndex++;
-      } else {
-        this.extrusions(positions, normals, last, this.normal, this.thickness, this.totalDistance - segmentDistance);
-      }
-    }
-    indices.push(index + 0, index + 1, index + 2);
-    if (!next) {
-      computeNormal(this.normal, lineA);
-      if (capSquare) {
-        const out1 = import_gl_matrix.vec2.create();
-        const out2 = import_gl_matrix.vec2.create();
-        import_gl_matrix.vec2.sub(out2, lineA, this.normal);
-        import_gl_matrix.vec2.add(out1, lineA, this.normal);
-        normals.push(out2[0], out2[1], 0);
-        normals.push(out1[0], out1[1], 0);
-        positions.push(cur[0], cur[1], cur[2] | 0, this.totalDistance, this.thickness, cur[2] | 0);
-        this.complex.indexes.push(this.currentIndex);
-        positions.push(cur[0], cur[1], cur[2] | 0, this.totalDistance, this.thickness, cur[2] | 0);
-        this.complex.indexes.push(this.currentIndex);
-        this.currentIndex++;
-      } else {
-        this.extrusions(positions, normals, cur, this.normal, this.thickness, this.totalDistance);
-      }
-      indices.push(...this.lastFlip === 1 ? [index, index + 2, index + 3] : [index + 2, index + 1, index + 3]);
-      count += 2;
-    } else {
-      if (isPointEqual(cur, next)) {
-        import_gl_matrix.vec2.add(next, cur, import_gl_matrix.vec2.normalize(next, import_gl_matrix.vec2.subtract(next, cur, last)));
-      }
-      direction(lineB, next, cur);
-      const [miterLen, miter] = computeMiter(tangent, import_gl_matrix.vec2.create(), lineA, lineB, this.thickness);
-      let flip = import_gl_matrix.vec2.dot(tangent, this.normal) < 0 ? -1 : 1;
-      let bevel = joinBevel;
-      if (!bevel && this.join === "miter") {
-        const limit = miterLen;
-        if (limit > this.miterLimit) {
-          bevel = true;
-        }
-      }
-      if (bevel) {
-        normals.push(this.normal[0], this.normal[1], 0);
-        normals.push(miter[0], miter[1], 0);
-        positions.push(cur[0], cur[1], cur[2] | 0, this.totalDistance, -this.thickness * flip, cur[2] | 0);
-        this.complex.indexes.push(this.currentIndex);
-        positions.push(cur[0], cur[1], cur[2] | 0, this.totalDistance, this.thickness * flip, cur[2] | 0);
-        this.complex.indexes.push(this.currentIndex);
-        this.currentIndex++;
-        indices.push(...this.lastFlip !== -flip ? [index, index + 2, index + 3] : [index + 2, index + 1, index + 3]);
-        indices.push(index + 2, index + 3, index + 4);
-        computeNormal(tmp, lineB);
-        import_gl_matrix.vec2.copy(this.normal, tmp);
-        normals.push(this.normal[0], this.normal[1], 0);
-        positions.push(cur[0], cur[1], cur[2] | 0, this.totalDistance, -this.thickness * flip, cur[2] | 0);
-        this.complex.indexes.push(this.currentIndex);
-        this.currentIndex++;
-        count += 3;
-      } else {
-        this.extrusions(positions, normals, cur, miter, miterLen, this.totalDistance);
-        indices.push(...this.lastFlip === 1 ? [index, index + 2, index + 3] : [index + 2, index + 1, index + 3]);
-        flip = -1;
-        import_gl_matrix.vec2.copy(this.normal, miter);
-        count += 2;
-      }
-      this.lastFlip = flip;
-    }
-    return count;
-  }
-  segment(complex, index, last, cur, next) {
-    let count = 0;
-    const indices = complex.indices;
-    const positions = complex.positions;
-    const normals = complex.normals;
-    const capSquare = this.cap === "square";
-    const joinBevel = this.join === "bevel";
-    const flatCur = (0, import_l7_utils.aProjectFlat)([cur[0], cur[1]]);
-    const flatLast = (0, import_l7_utils.aProjectFlat)([last[0], last[1]]);
-    direction(lineA, flatCur, flatLast);
-    let segmentDistance = 0;
-    if (this.dash) {
-      segmentDistance = this.lineSegmentDistance(flatCur, flatLast);
-      this.totalDistance += segmentDistance;
-    }
-    if (!this.normal) {
-      this.normal = import_gl_matrix.vec2.create();
-      computeNormal(this.normal, lineA);
-    }
-    if (!this.started) {
-      this.started = true;
-      if (capSquare) {
-        const out1 = import_gl_matrix.vec2.create();
-        const out2 = import_gl_matrix.vec2.create();
-        import_gl_matrix.vec2.add(out1, this.normal, lineA);
-        import_gl_matrix.vec2.add(out2, this.normal, lineA);
-        normals.push(out2[0], out2[1], 0);
-        normals.push(out1[0], out1[1], 0);
-        positions.push(last[0], last[1], last[2] | 0, this.totalDistance - segmentDistance, -this.thickness, last[2] | 0);
-        this.complex.indexes.push(this.currentIndex);
-        positions.push(last[0], last[1], last[2] | 0, this.totalDistance - segmentDistance, this.thickness, last[2] | 0);
-        this.complex.indexes.push(this.currentIndex);
-        this.currentIndex++;
-      } else {
-        this.extrusions(positions, normals, last, this.normal, this.thickness, this.totalDistance - segmentDistance);
-      }
-    }
-    indices.push(index + 0, index + 1, index + 2);
-    if (!next) {
-      computeNormal(this.normal, lineA);
-      if (capSquare) {
-        const out1 = import_gl_matrix.vec2.create();
-        const out2 = import_gl_matrix.vec2.create();
-        import_gl_matrix.vec2.sub(out2, lineA, this.normal);
-        import_gl_matrix.vec2.add(out1, lineA, this.normal);
-        normals.push(out2[0], out2[1], 0);
-        normals.push(out1[0], out1[1], 0);
-        positions.push(cur[0], cur[1], cur[2] | 0, this.totalDistance, this.thickness, cur[2] | 0);
-        this.complex.indexes.push(this.currentIndex);
-        positions.push(cur[0], cur[1], cur[2] | 0, this.totalDistance, this.thickness, cur[2] | 0);
-        this.complex.indexes.push(this.currentIndex);
-        this.currentIndex++;
-      } else {
-        this.extrusions(positions, normals, cur, this.normal, this.thickness, this.totalDistance);
-      }
-      indices.push(...this.lastFlip === 1 ? [index, index + 2, index + 3] : [index + 2, index + 1, index + 3]);
-      count += 2;
-    } else {
-      const flatNext = (0, import_l7_utils.aProjectFlat)([next[0], next[1]]);
-      if (isPointEqual(flatCur, flatNext)) {
-        import_gl_matrix.vec2.add(flatNext, flatCur, import_gl_matrix.vec2.normalize(flatNext, import_gl_matrix.vec2.subtract(flatNext, flatCur, flatLast)));
-      }
-      direction(lineB, flatNext, flatCur);
-      const [miterLen, miter] = computeMiter(tangent, import_gl_matrix.vec2.create(), lineA, lineB, this.thickness);
-      let flip = import_gl_matrix.vec2.dot(tangent, this.normal) < 0 ? -1 : 1;
-      let bevel = joinBevel;
-      if (!bevel && this.join === "miter") {
-        const limit = miterLen;
-        if (limit > this.miterLimit) {
-          bevel = true;
-        }
-      }
-      if (bevel) {
-        normals.push(this.normal[0], this.normal[1], 0);
-        normals.push(miter[0], miter[1], 0);
-        positions.push(cur[0], cur[1], cur[2] | 0, this.totalDistance, -this.thickness * flip, cur[2] | 0);
-        this.complex.indexes.push(this.currentIndex);
-        positions.push(cur[0], cur[1], cur[2] | 0, this.totalDistance, this.thickness * flip, cur[2] | 0);
-        this.complex.indexes.push(this.currentIndex);
-        this.currentIndex++;
-        indices.push(...this.lastFlip !== -flip ? [index, index + 2, index + 3] : [index + 2, index + 1, index + 3]);
-        indices.push(index + 2, index + 3, index + 4);
-        computeNormal(tmp, lineB);
-        import_gl_matrix.vec2.copy(this.normal, tmp);
-        normals.push(this.normal[0], this.normal[1], 0);
-        positions.push(cur[0], cur[1], cur[2] | 0, this.totalDistance, -this.thickness * flip, cur[2] | 0);
-        this.complex.indexes.push(this.currentIndex);
-        this.currentIndex++;
-        count += 3;
-      } else {
-        this.extrusions(positions, normals, cur, miter, miterLen, this.totalDistance);
-        indices.push(...this.lastFlip === 1 ? [index, index + 2, index + 3] : [index + 2, index + 1, index + 3]);
-        flip = -1;
-        import_gl_matrix.vec2.copy(this.normal, miter);
-        count += 2;
-      }
-      this.lastFlip = flip;
-    }
-    return count;
-  }
-  extrusions(positions, normals, point, normal, thickness, distanceRadio) {
-    normals.push(normal[0], normal[1], 0);
-    normals.push(normal[0], normal[1], 0);
-    positions.push(point[0], point[1], point[2] | 0, distanceRadio, -thickness, point[2] | 0);
-    this.complex.indexes.push(this.currentIndex);
-    positions.push(point[0], point[1], point[2] | 0, distanceRadio, thickness, point[2] | 0);
-    this.complex.indexes.push(this.currentIndex);
-    this.currentIndex++;
-  }
-  lineSegmentDistance(b1, a1) {
-    const dx = a1[0] - b1[0];
-    const dy = a1[1] - b1[1];
-    return Math.sqrt(dx * dx + dy * dy);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  computeMiter,
-  computeNormal,
-  direction
-});

package/lib/utils/grid-index.js

@@ -1,136 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/utils/grid-index.ts
-var grid_index_exports = {};
-__export(grid_index_exports, {
-  default: () => grid_index_default
-});
-module.exports = __toCommonJS(grid_index_exports);
-var GridIndex = class {
-  constructor(width, height, cellSize) {
-    this.boxCells = [];
-    const boxCells = this.boxCells;
-    this.xCellCount = Math.ceil(width / cellSize);
-    this.yCellCount = Math.ceil(height / cellSize);
-    for (let i = 0; i < this.xCellCount * this.yCellCount; i++) {
-      boxCells.push([]);
-    }
-    this.boxKeys = [];
-    this.bboxes = [];
-    this.width = width;
-    this.height = height;
-    this.xScale = this.xCellCount / width;
-    this.yScale = this.yCellCount / height;
-    this.boxUid = 0;
-  }
-  insert(key, x1, y1, x2, y2) {
-    this.forEachCell(x1, y1, x2, y2, this.insertBoxCell, this.boxUid++);
-    this.boxKeys.push(key);
-    this.bboxes.push(x1);
-    this.bboxes.push(y1);
-    this.bboxes.push(x2);
-    this.bboxes.push(y2);
-  }
-  query(x1, y1, x2, y2, predicate) {
-    return this.queryHitTest(x1, y1, x2, y2, false, predicate);
-  }
-  hitTest(x1, y1, x2, y2, predicate) {
-    return this.queryHitTest(x1, y1, x2, y2, true, predicate);
-  }
-  insertBoxCell(x1, y1, x2, y2, cellIndex, uid) {
-    this.boxCells[cellIndex].push(uid);
-  }
-  queryHitTest(x1, y1, x2, y2, hitTest, predicate) {
-    if (x2 < 0 || x1 > this.width || y2 < 0 || y1 > this.height) {
-      return hitTest ? false : [];
-    }
-    const result = [];
-    if (x1 <= 0 && y1 <= 0 && this.width <= x2 && this.height <= y2) {
-      if (hitTest) {
-        return true;
-      }
-      for (let boxUid = 0; boxUid < this.boxKeys.length; boxUid++) {
-        result.push({
-          key: this.boxKeys[boxUid],
-          x1: this.bboxes[boxUid * 4],
-          y1: this.bboxes[boxUid * 4 + 1],
-          x2: this.bboxes[boxUid * 4 + 2],
-          y2: this.bboxes[boxUid * 4 + 3]
-        });
-      }
-      return predicate ? result.filter(predicate) : result;
-    }
-    const queryArgs = {
-      hitTest,
-      seenUids: { box: {}, circle: {} }
-    };
-    this.forEachCell(x1, y1, x2, y2, this.queryCell, result, queryArgs, predicate);
-    return hitTest ? result.length > 0 : result;
-  }
-  queryCell(x1, y1, x2, y2, cellIndex, result, queryArgs, predicate) {
-    const seenUids = queryArgs.seenUids;
-    const boxCell = this.boxCells[cellIndex];
-    if (boxCell !== null) {
-      const bboxes = this.bboxes;
-      for (const boxUid of boxCell) {
-        if (!seenUids.box[boxUid]) {
-          seenUids.box[boxUid] = true;
-          const offset = boxUid * 4;
-          if (x1 <= bboxes[offset + 2] && y1 <= bboxes[offset + 3] && x2 >= bboxes[offset + 0] && y2 >= bboxes[offset + 1] && (!predicate || predicate(this.boxKeys[boxUid]))) {
-            if (queryArgs.hitTest) {
-              result.push(true);
-              return true;
-            }
-            result.push({
-              key: this.boxKeys[boxUid],
-              x1: bboxes[offset],
-              y1: bboxes[offset + 1],
-              x2: bboxes[offset + 2],
-              y2: bboxes[offset + 3]
-            });
-          }
-        }
-      }
-    }
-    return false;
-  }
-  forEachCell(x1, y1, x2, y2, fn, arg1, arg2, predicate) {
-    const cx1 = this.convertToXCellCoord(x1);
-    const cy1 = this.convertToYCellCoord(y1);
-    const cx2 = this.convertToXCellCoord(x2);
-    const cy2 = this.convertToYCellCoord(y2);
-    for (let x = cx1; x <= cx2; x++) {
-      for (let y = cy1; y <= cy2; y++) {
-        const cellIndex = this.xCellCount * y + x;
-        if (fn.call(this, x1, y1, x2, y2, cellIndex, arg1, arg2, predicate)) {
-          return;
-        }
-      }
-    }
-  }
-  convertToXCellCoord(x) {
-    return Math.max(0, Math.min(this.xCellCount - 1, Math.floor(x * this.xScale)));
-  }
-  convertToYCellCoord(y) {
-    return Math.max(0, Math.min(this.yCellCount - 1, Math.floor(y * this.yScale)));
-  }
-};
-var grid_index_default = GridIndex;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});