ts-maps 0.2.7 → 0.3.0

package/dist/core-map/geometry/index.js

@@ -0,0 +1,1586 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/core-map/core/Util.ts
+var exports_Util = {};
+__export(exports_Util, {
+  wrapNum: () => wrapNum,
+  throttle: () => throttle,
+  template: () => template,
+  stamp: () => stamp,
+  splitWords: () => splitWords,
+  setOptions: () => setOptions,
+  setLastId: () => setLastId,
+  noop: () => noop,
+  lastId: () => lastId,
+  formatNum: () => formatNum,
+  falseFn: () => falseFn
+});
+function stamp(obj) {
+  if (!("_tsmap_id" in obj)) {
+    obj._tsmap_id = ++lastId;
+  }
+  return obj._tsmap_id;
+}
+function setLastId(id) {
+  lastId = id;
+}
+function throttle(fn, time, context) {
+  let lock = false;
+  let queuedArgs = false;
+  function later() {
+    lock = false;
+    if (queuedArgs) {
+      wrapperFn.apply(context, queuedArgs);
+      queuedArgs = false;
+    }
+  }
+  function wrapperFn(...args) {
+    if (lock) {
+      queuedArgs = args;
+    } else {
+      fn.apply(context, args);
+      setTimeout(later, time);
+      lock = true;
+    }
+  }
+  return wrapperFn;
+}
+function wrapNum(x, range, includeMax) {
+  const max = range[1];
+  const min = range[0];
+  const d = max - min;
+  return x === max && includeMax ? x : ((x - min) % d + d) % d + min;
+}
+function falseFn(..._args) {
+  return false;
+}
+function formatNum(num, precision) {
+  if (precision === false)
+    return num;
+  const pow = 10 ** (precision === undefined ? 6 : precision);
+  return Math.round(num * pow) / pow;
+}
+function splitWords(str) {
+  return str.trim().split(/\s+/);
+}
+function setOptions(obj, options) {
+  if (!Object.hasOwn(obj, "options")) {
+    obj.options = obj.options ? Object.create(obj.options) : {};
+  }
+  if (options) {
+    for (const i in options) {
+      if (Object.hasOwn(options, i)) {
+        obj.options[i] = options[i];
+      }
+    }
+  }
+  return obj.options;
+}
+function template(str, data) {
+  return str.replace(templateRe, (match, key) => {
+    const k = key.trim();
+    let value = data[k];
+    if (value === undefined)
+      throw new Error(`No value provided for variable ${match}`);
+    else if (typeof value === "function")
+      value = value(data);
+    return value;
+  });
+}
+function noop() {}
+var lastId = 0, templateRe;
+var init_Util = __esm(() => {
+  templateRe = /\{([^{}]+)\}/g;
+});
+
+// src/core-map/geometry/Point.ts
+class Point {
+  x;
+  y;
+  constructor(x, y, round) {
+    const valid = Point.validate(x, y);
+    if (!valid) {
+      throw new Error(`Invalid Point object: (${x}, ${y})`);
+    }
+    let _x;
+    let _y;
+    if (x instanceof Point) {
+      return x;
+    } else if (Array.isArray(x)) {
+      _x = x[0];
+      _y = x[1];
+    } else if (typeof x === "object" && x !== null && "x" in x && "y" in x) {
+      _x = x.x;
+      _y = x.y;
+    } else {
+      _x = x;
+      _y = y;
+    }
+    this.x = round ? Math.round(_x) : _x;
+    this.y = round ? Math.round(_y) : _y;
+  }
+  static validate(x, y) {
+    if (x instanceof Point || Array.isArray(x))
+      return true;
+    if (x && typeof x === "object" && "x" in x && "y" in x)
+      return true;
+    if ((x || x === 0) && (y || y === 0))
+      return true;
+    return false;
+  }
+  clone() {
+    const p = new Point(0, 0);
+    p.x = this.x;
+    p.y = this.y;
+    return p;
+  }
+  add(point) {
+    return this.clone()._add(new Point(point));
+  }
+  _add(point) {
+    this.x += point.x;
+    this.y += point.y;
+    return this;
+  }
+  subtract(point) {
+    return this.clone()._subtract(new Point(point));
+  }
+  _subtract(point) {
+    this.x -= point.x;
+    this.y -= point.y;
+    return this;
+  }
+  divideBy(num) {
+    return this.clone()._divideBy(num);
+  }
+  _divideBy(num) {
+    this.x /= num;
+    this.y /= num;
+    return this;
+  }
+  multiplyBy(num) {
+    return this.clone()._multiplyBy(num);
+  }
+  _multiplyBy(num) {
+    this.x *= num;
+    this.y *= num;
+    return this;
+  }
+  scaleBy(point) {
+    return new Point(this.x * point.x, this.y * point.y);
+  }
+  unscaleBy(point) {
+    return new Point(this.x / point.x, this.y / point.y);
+  }
+  round() {
+    return this.clone()._round();
+  }
+  _round() {
+    this.x = Math.round(this.x);
+    this.y = Math.round(this.y);
+    return this;
+  }
+  floor() {
+    return this.clone()._floor();
+  }
+  _floor() {
+    this.x = Math.floor(this.x);
+    this.y = Math.floor(this.y);
+    return this;
+  }
+  ceil() {
+    return this.clone()._ceil();
+  }
+  _ceil() {
+    this.x = Math.ceil(this.x);
+    this.y = Math.ceil(this.y);
+    return this;
+  }
+  trunc() {
+    return this.clone()._trunc();
+  }
+  _trunc() {
+    this.x = Math.trunc(this.x);
+    this.y = Math.trunc(this.y);
+    return this;
+  }
+  distanceTo(point) {
+    const p = new Point(point);
+    const x = p.x - this.x;
+    const y = p.y - this.y;
+    return Math.sqrt(x * x + y * y);
+  }
+  equals(point) {
+    const p = new Point(point);
+    return p.x === this.x && p.y === this.y;
+  }
+  contains(point) {
+    const p = new Point(point);
+    return Math.abs(p.x) <= Math.abs(this.x) && Math.abs(p.y) <= Math.abs(this.y);
+  }
+  toString() {
+    return `Point(${formatNum(this.x)}, ${formatNum(this.y)})`;
+  }
+}
+function toPoint(x, y, round) {
+  if (x instanceof Point)
+    return x;
+  if (Array.isArray(x))
+    return new Point(x[0], x[1]);
+  if (x === undefined || x === null)
+    return x;
+  if (typeof x === "object" && "x" in x && "y" in x)
+    return new Point(x.x, x.y);
+  return new Point(x, y, round);
+}
+var init_Point = __esm(() => {
+  init_Util();
+});
+
+// src/core-map/geometry/Bounds.ts
+class Bounds {
+  min;
+  max;
+  constructor(a, b) {
+    if (!a)
+      return;
+    if (a instanceof Bounds) {
+      return a;
+    }
+    const points = b ? [a, b] : a;
+    for (const point of points) {
+      this.extend(point);
+    }
+  }
+  extend(obj) {
+    let min2;
+    let max2;
+    if (!obj)
+      return this;
+    if (obj instanceof Point || Array.isArray(obj) && typeof obj[0] === "number" || obj && "x" in obj) {
+      min2 = max2 = toPoint(obj);
+    } else {
+      const b = new Bounds(obj);
+      min2 = b.min;
+      max2 = b.max;
+      if (!min2 || !max2)
+        return this;
+    }
+    if (!this.min && !this.max) {
+      this.min = min2.clone();
+      this.max = max2.clone();
+    } else {
+      this.min.x = Math.min(min2.x, this.min.x);
+      this.max.x = Math.max(max2.x, this.max.x);
+      this.min.y = Math.min(min2.y, this.min.y);
+      this.max.y = Math.max(max2.y, this.max.y);
+    }
+    return this;
+  }
+  getCenter(round) {
+    return new Point((this.min.x + this.max.x) / 2, (this.min.y + this.max.y) / 2, round);
+  }
+  getBottomLeft() {
+    return new Point(this.min.x, this.max.y);
+  }
+  getTopRight() {
+    return new Point(this.max.x, this.min.y);
+  }
+  getTopLeft() {
+    return this.min;
+  }
+  getBottomRight() {
+    return this.max;
+  }
+  getSize() {
+    return this.max.subtract(this.min);
+  }
+  contains(obj) {
+    let min, max;
+    let target = obj;
+    if (Array.isArray(target) && typeof target[0] === "number" || target instanceof Point) {
+      target = toPoint(target);
+    } else {
+      target = new Bounds(target);
+    }
+    if (target instanceof Bounds) {
+      min = target.min;
+      max = target.max;
+    } else {
+      min = max = target;
+    }
+    return min.x >= this.min.x && max.x <= this.max.x && min.y >= this.min.y && max.y <= this.max.y;
+  }
+  intersects(bounds) {
+    const b = new Bounds(bounds);
+    const min = this.min;
+    const max = this.max;
+    const min2 = b.min;
+    const max2 = b.max;
+    const xIntersects = max2.x >= min.x && min2.x <= max.x;
+    const yIntersects = max2.y >= min.y && min2.y <= max.y;
+    return xIntersects && yIntersects;
+  }
+  overlaps(bounds) {
+    const b = new Bounds(bounds);
+    const min = this.min;
+    const max = this.max;
+    const min2 = b.min;
+    const max2 = b.max;
+    const xOverlaps = max2.x > min.x && min2.x < max.x;
+    const yOverlaps = max2.y > min.y && min2.y < max.y;
+    return xOverlaps && yOverlaps;
+  }
+  isValid() {
+    return !!(this.min && this.max);
+  }
+  pad(bufferRatio) {
+    const min = this.min;
+    const max = this.max;
+    const heightBuffer = Math.abs(min.x - max.x) * bufferRatio;
+    const widthBuffer = Math.abs(min.y - max.y) * bufferRatio;
+    return new Bounds(new Point(min.x - heightBuffer, min.y - widthBuffer), new Point(max.x + heightBuffer, max.y + widthBuffer));
+  }
+  equals(bounds) {
+    if (!bounds)
+      return false;
+    const b = new Bounds(bounds);
+    return this.min.equals(b.getTopLeft()) && this.max.equals(b.getBottomRight());
+  }
+}
+function toBounds(a, b) {
+  if (!a || a instanceof Bounds)
+    return a;
+  return new Bounds(a, b);
+}
+var init_Bounds = __esm(() => {
+  init_Point();
+});
+
+// src/core-map/geometry/RTree.ts
+function bboxArea(b) {
+  return (b[2] - b[0]) * (b[3] - b[1]);
+}
+function bboxMargin(b) {
+  return b[2] - b[0] + (b[3] - b[1]);
+}
+function enlargedArea(a, b) {
+  const w = Math.max(a[2], b[2]) - Math.min(a[0], b[0]);
+  const h = Math.max(a[3], b[3]) - Math.min(a[1], b[1]);
+  return w * h;
+}
+function intersectionArea(a, b) {
+  const minX = Math.max(a[0], b[0]);
+  const minY = Math.max(a[1], b[1]);
+  const maxX = Math.min(a[2], b[2]);
+  const maxY = Math.min(a[3], b[3]);
+  if (maxX < minX || maxY < minY)
+    return 0;
+  return (maxX - minX) * (maxY - minY);
+}
+function bboxContains(a, b) {
+  return a[0] <= b[0] && a[1] <= b[1] && a[2] >= b[2] && a[3] >= b[3];
+}
+function bboxIntersects(a, b) {
+  return b[0] <= a[2] && b[1] <= a[3] && b[2] >= a[0] && b[3] >= a[1];
+}
+function bboxContainsPoint(b, x, y) {
+  return b[0] <= x && x <= b[2] && b[1] <= y && y <= b[3];
+}
+function emptyBBox() {
+  return [Infinity, Infinity, -Infinity, -Infinity];
+}
+function extend(target, other) {
+  if (other[0] < target[0])
+    target[0] = other[0];
+  if (other[1] < target[1])
+    target[1] = other[1];
+  if (other[2] > target[2])
+    target[2] = other[2];
+  if (other[3] > target[3])
+    target[3] = other[3];
+  return target;
+}
+function computeBBox(node, k, p) {
+  const bbox = node.bbox;
+  bbox[0] = Infinity;
+  bbox[1] = Infinity;
+  bbox[2] = -Infinity;
+  bbox[3] = -Infinity;
+  const children = node.children;
+  for (let i = k;i < p; i++)
+    extend(bbox, children[i].bbox);
+}
+function createNode(children) {
+  return { bbox: emptyBBox(), children, leaf: false };
+}
+
+class RTree {
+  _maxEntries;
+  _minEntries;
+  _root;
+  _size;
+  constructor(opts) {
+    const max = Math.max(4, opts?.maxEntries ?? 9);
+    const min = Math.max(2, opts?.minEntries ?? Math.ceil(max * 0.4));
+    this._maxEntries = max;
+    this._minEntries = Math.min(min, Math.floor(max / 2));
+    this._root = { bbox: emptyBBox(), children: [], leaf: true };
+    this._size = 0;
+  }
+  size() {
+    return this._size;
+  }
+  clear() {
+    this._root = { bbox: emptyBBox(), children: [], leaf: true };
+    this._size = 0;
+    return this;
+  }
+  insert(bbox, data) {
+    const record = { bbox: [bbox[0], bbox[1], bbox[2], bbox[3]], data };
+    this._insertRecord(record);
+    this._size++;
+    return this;
+  }
+  remove(bbox, data, equalsFn) {
+    const eq = equalsFn ?? ((a, b) => a === b);
+    const path = [];
+    const removed = this._removeFrom(this._root, bbox, data, eq, path);
+    if (removed) {
+      this._size--;
+      this._condense(path);
+    }
+    return this;
+  }
+  _removeFrom(node, bbox, data, eq, path) {
+    const children = node.children;
+    if (!children)
+      return false;
+    path.push(node);
+    if (node.leaf) {
+      for (let i = 0;i < children.length; i++) {
+        const c = children[i];
+        if (c.data !== undefined && eq(c.data, data)) {
+          children.splice(i, 1);
+          return true;
+        }
+      }
+      path.pop();
+      return false;
+    }
+    for (let i = 0;i < children.length; i++) {
+      const c = children[i];
+      if (!bboxContains(c.bbox, bbox))
+        continue;
+      if (this._removeFrom(c, bbox, data, eq, path))
+        return true;
+    }
+    path.pop();
+    return false;
+  }
+  search(bbox) {
+    const out = [];
+    const root = this._root;
+    if (!bboxIntersects(root.bbox, bbox))
+      return out;
+    const stack = [root];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      const children = node.children;
+      if (!children)
+        continue;
+      for (let i = 0;i < children.length; i++) {
+        const child = children[i];
+        if (!bboxIntersects(child.bbox, bbox))
+          continue;
+        if (node.leaf) {
+          out.push({ bbox: child.bbox, data: child.data });
+        } else if (bboxContains(bbox, child.bbox)) {
+          this._collectAll(child, out);
+        } else {
+          stack.push(child);
+        }
+      }
+    }
+    return out;
+  }
+  searchPoint(x, y) {
+    const out = [];
+    const root = this._root;
+    if (!bboxContainsPoint(root.bbox, x, y))
+      return out;
+    const stack = [root];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      const children = node.children;
+      if (!children)
+        continue;
+      for (let i = 0;i < children.length; i++) {
+        const child = children[i];
+        if (!bboxContainsPoint(child.bbox, x, y))
+          continue;
+        if (node.leaf)
+          out.push({ bbox: child.bbox, data: child.data });
+        else
+          stack.push(child);
+      }
+    }
+    return out;
+  }
+  all() {
+    const out = [];
+    this._collectAll(this._root, out);
+    return out;
+  }
+  load(items) {
+    if (items.length === 0)
+      return this;
+    if (items.length < this._minEntries) {
+      for (const it of items)
+        this.insert(it.bbox, it.data);
+      return this;
+    }
+    const records = items.map((it) => {
+      return { bbox: [it.bbox[0], it.bbox[1], it.bbox[2], it.bbox[3]], data: it.data };
+    });
+    const built = this._buildSTR(records, 0, records.length - 1, this._chooseHeight(records.length));
+    if (this._size === 0) {
+      this._root = built;
+      this._size = items.length;
+      return this;
+    }
+    const existingHeight = this._height(this._root);
+    const builtHeight = this._height(built);
+    if (existingHeight === builtHeight) {
+      this._mergeRoots(built);
+      this._size += items.length;
+    } else if (existingHeight < builtHeight) {
+      const old = this._root;
+      this._root = built;
+      this._size = items.length;
+      const oldEntries = [];
+      this._collectAll(old, oldEntries);
+      for (const it of oldEntries)
+        this.insert(it.bbox, it.data);
+    } else {
+      const targetDepth = existingHeight - builtHeight;
+      this._insertSubtree(built, targetDepth);
+      this._size += items.length;
+    }
+    return this;
+  }
+  _collectAll(node, out) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      const children = current.children;
+      if (!children)
+        continue;
+      if (current.leaf) {
+        for (let i = 0;i < children.length; i++) {
+          const c = children[i];
+          out.push({ bbox: c.bbox, data: c.data });
+        }
+      } else {
+        for (let i = 0;i < children.length; i++)
+          stack.push(children[i]);
+      }
+    }
+  }
+  _height(node) {
+    let h = 0;
+    let cur = node;
+    while (!cur.leaf) {
+      h++;
+      const next = cur.children?.[0];
+      if (!next)
+        break;
+      cur = next;
+    }
+    return h;
+  }
+  _mergeRoots(other) {
+    const root = this._root;
+    if (root.leaf !== other.leaf) {
+      const entries = [];
+      this._collectAll(other, entries);
+      for (const it of entries)
+        this.insert(it.bbox, it.data);
+      return;
+    }
+    const otherChildren = other.children;
+    for (const child of otherChildren)
+      root.children.push(child);
+    computeBBox(root, 0, root.children.length);
+    if (root.children.length > this._maxEntries) {
+      const split = this._splitChildren(root);
+      const newRoot = createNode([root, split]);
+      this._root = newRoot;
+      computeBBox(newRoot, 0, 2);
+    }
+  }
+  _chooseHeight(count) {
+    if (count <= this._maxEntries)
+      return 0;
+    return Math.ceil(Math.log(count) / Math.log(this._maxEntries));
+  }
+  _buildSTR(items, left, right, height) {
+    return this._buildSTRInner(items, left, right, height, true);
+  }
+  _buildSTRInner(items, left, right, height, packingRecords) {
+    const count = right - left + 1;
+    const M = this._maxEntries;
+    if (count <= M) {
+      const slice = items.slice(left, right + 1);
+      const node = {
+        bbox: emptyBBox(),
+        children: slice,
+        leaf: packingRecords
+      };
+      computeBBox(node, 0, slice.length);
+      return node;
+    }
+    const exp = Math.max(height - 1, 0);
+    const nodeSize = Math.ceil(count / M ** exp);
+    const stripCount = Math.ceil(Math.sqrt(Math.ceil(count / nodeSize)));
+    const stripSize = nodeSize * stripCount;
+    multiSelectSort(items, left, right, stripSize, compareCentroidX);
+    const parents = [];
+    for (let i = left;i <= right; i += stripSize) {
+      const stripRight = Math.min(i + stripSize - 1, right);
+      multiSelectSort(items, i, stripRight, nodeSize, compareCentroidY);
+      for (let j = i;j <= stripRight; j += nodeSize) {
+        const groupRight = Math.min(j + nodeSize - 1, stripRight);
+        const children = items.slice(j, groupRight + 1);
+        const node = {
+          bbox: emptyBBox(),
+          children,
+          leaf: packingRecords
+        };
+        computeBBox(node, 0, children.length);
+        parents.push(node);
+      }
+    }
+    if (parents.length === 1)
+      return parents[0];
+    return this._buildSTRInner(parents, 0, parents.length - 1, height - 1, false);
+  }
+  _insertRecord(record) {
+    const path = [];
+    let node = this._root;
+    while (!node.leaf) {
+      path.push(node);
+      const children = node.children;
+      let target = children[0];
+      let minEnlargement = enlargedArea(target.bbox, record.bbox) - bboxArea(target.bbox);
+      let minArea = bboxArea(target.bbox);
+      for (let i = 1;i < children.length; i++) {
+        const c = children[i];
+        const area = bboxArea(c.bbox);
+        const enlargement = enlargedArea(c.bbox, record.bbox) - area;
+        if (enlargement < minEnlargement) {
+          minEnlargement = enlargement;
+          minArea = area;
+          target = c;
+        } else if (enlargement === minEnlargement && area < minArea) {
+          minArea = area;
+          target = c;
+        }
+      }
+      node = target;
+    }
+    path.push(node);
+    node.children.push(record);
+    extend(node.bbox, record.bbox);
+    let level = path.length - 1;
+    while (level >= 0) {
+      if (path[level].children.length > this._maxEntries) {
+        this._split(path, level);
+      } else {
+        extend(path[level].bbox, record.bbox);
+      }
+      level--;
+    }
+  }
+  _insertSubtree(sub, targetDepth) {
+    const path = [];
+    let node = this._root;
+    let depth = 0;
+    while (depth < targetDepth && !node.leaf) {
+      path.push(node);
+      const children = node.children;
+      let target = children[0];
+      let minEnlargement = enlargedArea(target.bbox, sub.bbox) - bboxArea(target.bbox);
+      let minArea = bboxArea(target.bbox);
+      for (let i = 1;i < children.length; i++) {
+        const c = children[i];
+        const area = bboxArea(c.bbox);
+        const enlargement = enlargedArea(c.bbox, sub.bbox) - area;
+        if (enlargement < minEnlargement) {
+          minEnlargement = enlargement;
+          minArea = area;
+          target = c;
+        }
+      }
+      node = target;
+      depth++;
+    }
+    path.push(node);
+    node.children.push(sub);
+    extend(node.bbox, sub.bbox);
+    let level = path.length - 1;
+    while (level >= 0) {
+      if (path[level].children.length > this._maxEntries) {
+        this._split(path, level);
+      } else {
+        extend(path[level].bbox, sub.bbox);
+      }
+      level--;
+    }
+  }
+  _split(insertPath, level) {
+    const node = insertPath[level];
+    const newNode = this._splitChildren(node);
+    if (level === 0) {
+      this._root = createNode([node, newNode]);
+      computeBBox(this._root, 0, 2);
+    } else {
+      insertPath[level - 1].children.push(newNode);
+      computeBBox(insertPath[level - 1], 0, insertPath[level - 1].children.length);
+    }
+  }
+  _splitChildren(node) {
+    const children = node.children;
+    const M = this._maxEntries;
+    const m = this._minEntries;
+    this._chooseSplitAxis(children, m, M);
+    const index = this._chooseSplitIndex(children, m, M);
+    const rightChildren = children.splice(index, children.length - index);
+    const newNode = {
+      bbox: emptyBBox(),
+      children: rightChildren,
+      leaf: node.leaf
+    };
+    computeBBox(node, 0, children.length);
+    computeBBox(newNode, 0, rightChildren.length);
+    return newNode;
+  }
+  _chooseSplitAxis(children, m, M) {
+    children.sort(compareMinX);
+    const xMargin = this._allDistMargin(children, m, M);
+    children.sort(compareMinY);
+    const yMargin = this._allDistMargin(children, m, M);
+    if (xMargin < yMargin)
+      children.sort(compareMinX);
+  }
+  _allDistMargin(children, m, M) {
+    const leftBBox = emptyBBox();
+    const rightBBox = emptyBBox();
+    for (let i = 0;i < m; i++)
+      extend(leftBBox, children[i].bbox);
+    for (let i = children.length - m;i < children.length; i++)
+      extend(rightBBox, children[i].bbox);
+    let margin = bboxMargin(leftBBox) + bboxMargin(rightBBox);
+    const total = children.length;
+    for (let i = m;i < total - m; i++) {
+      extend(leftBBox, children[i].bbox);
+      margin += bboxMargin(leftBBox);
+    }
+    for (let i = total - m - 1;i >= m; i--) {
+      extend(rightBBox, children[i].bbox);
+      margin += bboxMargin(rightBBox);
+    }
+    return margin;
+  }
+  _chooseSplitIndex(children, m, M) {
+    let index = m;
+    let minOverlap = Infinity;
+    let minArea = Infinity;
+    const total = children.length;
+    for (let i = m;i <= total - m; i++) {
+      const leftBBox = emptyBBox();
+      for (let k = 0;k < i; k++)
+        extend(leftBBox, children[k].bbox);
+      const rightBBox = emptyBBox();
+      for (let k = i;k < total; k++)
+        extend(rightBBox, children[k].bbox);
+      const overlap = intersectionArea(leftBBox, rightBBox);
+      const area = bboxArea(leftBBox) + bboxArea(rightBBox);
+      if (overlap < minOverlap) {
+        minOverlap = overlap;
+        minArea = area;
+        index = i;
+      } else if (overlap === minOverlap && area < minArea) {
+        minArea = area;
+        index = i;
+      }
+    }
+    return index;
+  }
+  _condense(path) {
+    const reinsertPool = [];
+    for (let i = path.length - 1;i >= 0; i--) {
+      const node = path[i];
+      if (node.children && node.children.length === 0) {
+        if (i > 0) {
+          const parent = path[i - 1];
+          const idx = parent.children.indexOf(node);
+          if (idx >= 0)
+            parent.children.splice(idx, 1);
+        } else {
+          this.clear();
+          return;
+        }
+      } else if (node.children && node.children.length < this._minEntries && i > 0) {
+        this._collectLeafNodes(node, reinsertPool);
+        const parent = path[i - 1];
+        const idx = parent.children.indexOf(node);
+        if (idx >= 0)
+          parent.children.splice(idx, 1);
+      } else {
+        computeBBox(node, 0, node.children?.length ?? 0);
+      }
+    }
+    if (reinsertPool.length > 0) {
+      for (const leaf of reinsertPool) {
+        const children = leaf.children;
+        if (!children)
+          continue;
+        for (const c of children) {
+          this.insert(c.bbox, c.data);
+          this._size--;
+        }
+      }
+    }
+  }
+  _collectLeafNodes(node, out) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const cur = stack.pop();
+      if (cur.leaf) {
+        out.push(cur);
+      } else if (cur.children) {
+        for (const c of cur.children)
+          stack.push(c);
+      }
+    }
+  }
+}
+function compareMinX(a, b) {
+  return a.bbox[0] - b.bbox[0];
+}
+function compareMinY(a, b) {
+  return a.bbox[1] - b.bbox[1];
+}
+function compareCentroidX(a, b) {
+  return a.bbox[0] + a.bbox[2] - (b.bbox[0] + b.bbox[2]);
+}
+function compareCentroidY(a, b) {
+  return a.bbox[1] + a.bbox[3] - (b.bbox[1] + b.bbox[3]);
+}
+function multiSelectSort(arr, left, right, step, compare) {
+  const slice = arr.slice(left, right + 1);
+  slice.sort(compare);
+  for (let i = 0;i < slice.length; i++)
+    arr[left + i] = slice[i];
+}
+
+// src/core-map/geometry/Transformation.ts
+class Transformation {
+  _a;
+  _b;
+  _c;
+  _d;
+  constructor(a, b, c, d) {
+    if (Array.isArray(a)) {
+      this._a = a[0];
+      this._b = a[1];
+      this._c = a[2];
+      this._d = a[3];
+      return;
+    }
+    this._a = a;
+    this._b = b;
+    this._c = c;
+    this._d = d;
+  }
+  transform(point, scale) {
+    return this._transform(point.clone(), scale);
+  }
+  _transform(point, scale) {
+    scale ||= 1;
+    point.x = scale * (this._a * point.x + this._b);
+    point.y = scale * (this._c * point.y + this._d);
+    return point;
+  }
+  untransform(point, scale) {
+    scale ||= 1;
+    return new Point((point.x / scale - this._b) / this._a, (point.y / scale - this._d) / this._c);
+  }
+}
+function toTransformation(a, b, c, d) {
+  return new Transformation(a, b, c, d);
+}
+var init_Transformation = __esm(() => {
+  init_Point();
+});
+
+// src/core-map/geo/LatLngBounds.ts
+class LatLngBounds {
+  _southWest;
+  _northEast;
+  constructor(corner1, corner2) {
+    if (!corner1)
+      return;
+    if (corner1 instanceof LatLngBounds) {
+      return corner1;
+    }
+    const latlngs = corner2 ? [corner1, corner2] : corner1;
+    for (const latlng of latlngs)
+      this.extend(latlng);
+  }
+  extend(obj) {
+    const sw = this._southWest;
+    const ne = this._northEast;
+    let sw2, ne2;
+    if (obj instanceof LatLng) {
+      sw2 = obj;
+      ne2 = obj;
+    } else if (obj instanceof LatLngBounds) {
+      sw2 = obj._southWest;
+      ne2 = obj._northEast;
+      if (!sw2 || !ne2)
+        return this;
+    } else {
+      if (!obj)
+        return this;
+      if (LatLng.validate(obj))
+        return this.extend(new LatLng(obj));
+      return this.extend(new LatLngBounds(obj));
+    }
+    if (!sw && !ne) {
+      this._southWest = new LatLng(sw2.lat, sw2.lng);
+      this._northEast = new LatLng(ne2.lat, ne2.lng);
+    } else {
+      sw.lat = Math.min(sw2.lat, sw.lat);
+      sw.lng = Math.min(sw2.lng, sw.lng);
+      ne.lat = Math.max(ne2.lat, ne.lat);
+      ne.lng = Math.max(ne2.lng, ne.lng);
+    }
+    return this;
+  }
+  pad(bufferRatio) {
+    const sw = this._southWest;
+    const ne = this._northEast;
+    const heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio;
+    const widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio;
+    return new LatLngBounds(new LatLng(sw.lat - heightBuffer, sw.lng - widthBuffer), new LatLng(ne.lat + heightBuffer, ne.lng + widthBuffer));
+  }
+  getCenter() {
+    return new LatLng((this._southWest.lat + this._northEast.lat) / 2, (this._southWest.lng + this._northEast.lng) / 2);
+  }
+  getSouthWest() {
+    return this._southWest;
+  }
+  getNorthEast() {
+    return this._northEast;
+  }
+  getNorthWest() {
+    return new LatLng(this.getNorth(), this.getWest());
+  }
+  getSouthEast() {
+    return new LatLng(this.getSouth(), this.getEast());
+  }
+  getWest() {
+    return this._southWest.lng;
+  }
+  getSouth() {
+    return this._southWest.lat;
+  }
+  getEast() {
+    return this._northEast.lng;
+  }
+  getNorth() {
+    return this._northEast.lat;
+  }
+  contains(obj) {
+    let target = obj;
+    if (LatLng.validate(target))
+      target = new LatLng(target);
+    else
+      target = new LatLngBounds(target);
+    const sw = this._southWest;
+    const ne = this._northEast;
+    let sw2, ne2;
+    if (target instanceof LatLngBounds) {
+      sw2 = target.getSouthWest();
+      ne2 = target.getNorthEast();
+    } else {
+      sw2 = ne2 = target;
+    }
+    return sw2.lat >= sw.lat && ne2.lat <= ne.lat && sw2.lng >= sw.lng && ne2.lng <= ne.lng;
+  }
+  intersects(bounds) {
+    const b = new LatLngBounds(bounds);
+    const sw = this._southWest;
+    const ne = this._northEast;
+    const sw2 = b.getSouthWest();
+    const ne2 = b.getNorthEast();
+    const latIntersects = ne2.lat >= sw.lat && sw2.lat <= ne.lat;
+    const lngIntersects = ne2.lng >= sw.lng && sw2.lng <= ne.lng;
+    return latIntersects && lngIntersects;
+  }
+  overlaps(bounds) {
+    const b = new LatLngBounds(bounds);
+    const sw = this._southWest;
+    const ne = this._northEast;
+    const sw2 = b.getSouthWest();
+    const ne2 = b.getNorthEast();
+    const latOverlaps = ne2.lat > sw.lat && sw2.lat < ne.lat;
+    const lngOverlaps = ne2.lng > sw.lng && sw2.lng < ne.lng;
+    return latOverlaps && lngOverlaps;
+  }
+  toBBoxString() {
+    return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()].join(",");
+  }
+  equals(bounds, maxMargin) {
+    if (!bounds)
+      return false;
+    const b = new LatLngBounds(bounds);
+    return this._southWest.equals(b.getSouthWest(), maxMargin) && this._northEast.equals(b.getNorthEast(), maxMargin);
+  }
+  isValid() {
+    return !!(this._southWest && this._northEast);
+  }
+}
+function toLatLngBounds(a, b) {
+  if (a instanceof LatLngBounds)
+    return a;
+  return new LatLngBounds(a, b);
+}
+var init_LatLngBounds = __esm(() => {
+  init_LatLng();
+});
+
+// src/core-map/geo/crs/CRS.ts
+class CRS {
+  static projection = undefined;
+  static transformation = undefined;
+  static code;
+  static wrapLng;
+  static wrapLat;
+  static infinite = false;
+  static latLngToPoint(latlng, zoom) {
+    const projectedPoint = this.projection.project(latlng);
+    const scale = this.scale(zoom);
+    return this.transformation._transform(projectedPoint, scale);
+  }
+  static pointToLatLng(point, zoom) {
+    const scale = this.scale(zoom);
+    const untransformedPoint = this.transformation.untransform(point, scale);
+    return this.projection.unproject(untransformedPoint);
+  }
+  static project(latlng) {
+    return this.projection.project(latlng);
+  }
+  static unproject(point) {
+    return this.projection.unproject(point);
+  }
+  static scale(zoom) {
+    return 256 * 2 ** zoom;
+  }
+  static zoom(scale) {
+    return Math.log(scale / 256) / Math.LN2;
+  }
+  static getProjectedBounds(zoom) {
+    if (this.infinite)
+      return null;
+    const b = this.projection.bounds;
+    const s = this.scale(zoom);
+    const min = this.transformation.transform(b.min, s);
+    const max = this.transformation.transform(b.max, s);
+    return new Bounds(min, max);
+  }
+  static distance(_a, _b) {
+    return 0;
+  }
+  static wrapLatLng(latlng) {
+    const ll = new LatLng(latlng);
+    const lng = this.wrapLng ? wrapNum(ll.lng, this.wrapLng, true) : ll.lng;
+    const lat = this.wrapLat ? wrapNum(ll.lat, this.wrapLat, true) : ll.lat;
+    const alt = ll.alt;
+    return new LatLng(lat, lng, alt);
+  }
+  static wrapLatLngBounds(bounds) {
+    const b = new LatLngBounds(bounds);
+    const center = b.getCenter();
+    const newCenter = this.wrapLatLng(center);
+    const latShift = center.lat - newCenter.lat;
+    const lngShift = center.lng - newCenter.lng;
+    if (latShift === 0 && lngShift === 0)
+      return b;
+    const sw = b.getSouthWest();
+    const ne = b.getNorthEast();
+    const newSw = new LatLng(sw.lat - latShift, sw.lng - lngShift);
+    const newNe = new LatLng(ne.lat - latShift, ne.lng - lngShift);
+    return new LatLngBounds(newSw, newNe);
+  }
+}
+var init_CRS = __esm(() => {
+  init_Util();
+  init_Bounds();
+  init_LatLng();
+  init_LatLngBounds();
+});
+
+// src/core-map/geo/crs/EarthCRS.ts
+var EarthCRS;
+var init_EarthCRS = __esm(() => {
+  init_CRS();
+  EarthCRS = class EarthCRS extends CRS {
+    static wrapLng = [-180, 180];
+    static R = 6371000;
+    static distance(latlng1, latlng2) {
+      const rad = Math.PI / 180;
+      const lat1 = latlng1.lat * rad;
+      const lat2 = latlng2.lat * rad;
+      const sinDLat = Math.sin((latlng2.lat - latlng1.lat) * rad / 2);
+      const sinDLon = Math.sin((latlng2.lng - latlng1.lng) * rad / 2);
+      const a = sinDLat * sinDLat + Math.cos(lat1) * Math.cos(lat2) * sinDLon * sinDLon;
+      const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+      return this.R * c;
+    }
+  };
+});
+
+// src/core-map/geo/LatLng.ts
+class LatLng {
+  lat;
+  lng;
+  alt;
+  constructor(lat, lng, alt) {
+    const valid = LatLng.validate(lat, lng, alt);
+    if (!valid)
+      throw new Error(`Invalid LatLng object: (${lat}, ${lng})`);
+    let _lat, _lng, _alt;
+    if (lat instanceof LatLng) {
+      return lat;
+    } else if (Array.isArray(lat) && typeof lat[0] !== "object") {
+      if (lat.length === 3) {
+        _lat = lat[0];
+        _lng = lat[1];
+        _alt = lat[2];
+      } else {
+        _lat = lat[0];
+        _lng = lat[1];
+      }
+    } else if (typeof lat === "object" && lat !== null && "lat" in lat) {
+      const o = lat;
+      _lat = o.lat;
+      _lng = "lng" in o ? o.lng : o.lon;
+      _alt = o.alt;
+    } else {
+      _lat = lat;
+      _lng = lng;
+      _alt = alt;
+    }
+    this.lat = +_lat;
+    this.lng = +_lng;
+    if (_alt !== undefined)
+      this.alt = +_alt;
+  }
+  static validate(lat, lng, _alt) {
+    if (lat instanceof LatLng || typeof lat === "object" && lat !== null && "lat" in lat)
+      return true;
+    if (lat && Array.isArray(lat) && typeof lat[0] !== "object") {
+      if (lat.length === 3 || lat.length === 2)
+        return true;
+      return false;
+    }
+    if ((lat || lat === 0) && (lng || lng === 0))
+      return true;
+    return false;
+  }
+  equals(obj, maxMargin) {
+    if (!obj)
+      return false;
+    const other = new LatLng(obj);
+    const margin = Math.max(Math.abs(this.lat - other.lat), Math.abs(this.lng - other.lng));
+    return margin <= (maxMargin ?? 0.000000001);
+  }
+  toString(precision) {
+    return `LatLng(${formatNum(this.lat, precision)}, ${formatNum(this.lng, precision)})`;
+  }
+  distanceTo(other) {
+    return EarthCRS.distance(this, new LatLng(other));
+  }
+  wrap() {
+    return EarthCRS.wrapLatLng(this);
+  }
+  toBounds(sizeInMeters) {
+    const latAccuracy = 180 * sizeInMeters / 40075017;
+    const lngAccuracy = latAccuracy / Math.cos(Math.PI / 180 * this.lat);
+    return new LatLngBounds([this.lat - latAccuracy, this.lng - lngAccuracy], [this.lat + latAccuracy, this.lng + lngAccuracy]);
+  }
+  clone() {
+    const latlng = new LatLng(0, 0);
+    latlng.lat = this.lat;
+    latlng.lng = this.lng;
+    latlng.alt = this.alt;
+    return latlng;
+  }
+}
+function toLatLng(a, b, c) {
+  if (a instanceof LatLng)
+    return a;
+  if (a === null || a === undefined)
+    return a;
+  return new LatLng(a, b, c);
+}
+var init_LatLng = __esm(() => {
+  init_Util();
+  init_EarthCRS();
+  init_LatLngBounds();
+});
+
+// src/core-map/geometry/index.ts
+init_Bounds();
+init_Point();
+init_Transformation();
+
+// src/core-map/geometry/LineUtil.ts
+init_LatLng();
+init_LatLngBounds();
+init_Point();
+var exports_LineUtil = {};
+__export(exports_LineUtil, {
+  simplify: () => simplify,
+  polylineCenter: () => polylineCenter,
+  pointToSegmentDistance: () => pointToSegmentDistance,
+  isFlat: () => isFlat,
+  closestPointOnSegment: () => closestPointOnSegment,
+  clipSegment: () => clipSegment,
+  _sqClosestPointOnSegment: () => _sqClosestPointOnSegment,
+  _getEdgeIntersection: () => _getEdgeIntersection,
+  _getBitCode: () => _getBitCode
+});
+
+// src/core-map/geometry/PolyUtil.ts
+var exports_PolyUtil = {};
+__export(exports_PolyUtil, {
+  polygonCenter: () => polygonCenter,
+  clipPolygon: () => clipPolygon,
+  centroid: () => centroid
+});
+init_LatLng();
+init_LatLngBounds();
+init_Point();
+function clipPolygon(points, bounds, round) {
+  let clippedPoints;
+  const edges = [1, 4, 2, 8];
+  for (let i = 0, len = points.length;i < len; i++) {
+    points[i]._code = _getBitCode(points[i], bounds);
+  }
+  for (let k = 0;k < 4; k++) {
+    const edge = edges[k];
+    clippedPoints = [];
+    for (let i = 0, len = points.length, j = len - 1;i < len; j = i++) {
+      const a = points[i];
+      const b = points[j];
+      if (!(a._code & edge)) {
+        if (b._code & edge) {
+          const p = _getEdgeIntersection(b, a, edge, bounds, round);
+          p._code = _getBitCode(p, bounds);
+          clippedPoints.push(p);
+        }
+        clippedPoints.push(a);
+      } else if (!(b._code & edge)) {
+        const p = _getEdgeIntersection(b, a, edge, bounds, round);
+        p._code = _getBitCode(p, bounds);
+        clippedPoints.push(p);
+      }
+    }
+    points = clippedPoints;
+  }
+  return points;
+}
+function polygonCenter(latlngs, crs) {
+  if (!latlngs || latlngs.length === 0)
+    throw new Error("latlngs not passed");
+  if (!isFlat(latlngs)) {
+    console.warn("latlngs are not flat! Only the first ring will be used");
+    latlngs = latlngs[0];
+  }
+  let centroidLatLng = new LatLng(0, 0);
+  const bounds = new LatLngBounds(latlngs);
+  const areaBounds = bounds.getNorthWest().distanceTo(bounds.getSouthWest()) * bounds.getNorthEast().distanceTo(bounds.getNorthWest());
+  if (areaBounds < 1700) {
+    centroidLatLng = centroid(latlngs);
+  }
+  const len = latlngs.length;
+  const points = [];
+  for (let i = 0;i < len; i++) {
+    const latlng = new LatLng(latlngs[i]);
+    points.push(crs.project(new LatLng(latlng.lat - centroidLatLng.lat, latlng.lng - centroidLatLng.lng)));
+  }
+  let area = 0, x = 0, y = 0;
+  let center;
+  for (let i = 0, j = len - 1;i < len; j = i++) {
+    const p1 = points[i];
+    const p2 = points[j];
+    const f = p1.y * p2.x - p2.y * p1.x;
+    x += (p1.x + p2.x) * f;
+    y += (p1.y + p2.y) * f;
+    area += f * 3;
+  }
+  if (area === 0) {
+    center = points[0];
+  } else {
+    center = [x / area, y / area];
+  }
+  const latlngCenter = crs.unproject(new Point(center));
+  return new LatLng(latlngCenter.lat + centroidLatLng.lat, latlngCenter.lng + centroidLatLng.lng);
+}
+function centroid(coords) {
+  let latSum = 0;
+  let lngSum = 0;
+  let len = 0;
+  for (const coord of coords) {
+    const latlng = new LatLng(coord);
+    latSum += latlng.lat;
+    lngSum += latlng.lng;
+    len++;
+  }
+  return new LatLng(latSum / len, lngSum / len);
+}
+
+// src/core-map/geometry/LineUtil.ts
+function simplify(points, tolerance) {
+  if (!tolerance || !points.length)
+    return points.slice();
+  const sqTolerance = tolerance * tolerance;
+  points = _reducePoints(points, sqTolerance);
+  points = _simplifyDP(points, sqTolerance);
+  return points;
+}
+function pointToSegmentDistance(p, p1, p2) {
+  return Math.sqrt(_sqClosestPointOnSegment(p, p1, p2, true));
+}
+function closestPointOnSegment(p, p1, p2) {
+  return _sqClosestPointOnSegment(p, p1, p2);
+}
+function _simplifyDP(points, sqTolerance) {
+  const len = points.length;
+  const markers = new Uint8Array(len);
+  markers[0] = markers[len - 1] = 1;
+  _simplifyDPStep(points, markers, sqTolerance, 0, len - 1);
+  const newPoints = [];
+  for (let i = 0;i < len; i++) {
+    if (markers[i])
+      newPoints.push(points[i]);
+  }
+  return newPoints;
+}
+function _simplifyDPStep(points, markers, sqTolerance, first, last) {
+  let maxSqDist = 0;
+  let index = 0;
+  for (let i = first + 1;i <= last - 1; i++) {
+    const sqDist = _sqClosestPointOnSegment(points[i], points[first], points[last], true);
+    if (sqDist > maxSqDist) {
+      index = i;
+      maxSqDist = sqDist;
+    }
+  }
+  if (maxSqDist > sqTolerance) {
+    markers[index] = 1;
+    _simplifyDPStep(points, markers, sqTolerance, first, index);
+    _simplifyDPStep(points, markers, sqTolerance, index, last);
+  }
+}
+function _reducePoints(points, sqTolerance) {
+  const reducedPoints = [points[0]];
+  let prev = 0;
+  for (let i = 1;i < points.length; i++) {
+    if (_sqDist(points[i], points[prev]) > sqTolerance) {
+      reducedPoints.push(points[i]);
+      prev = i;
+    }
+  }
+  if (prev < points.length - 1)
+    reducedPoints.push(points[points.length - 1]);
+  return reducedPoints;
+}
+var _lastCode;
+function clipSegment(a, b, bounds, useLastCode, round) {
+  let codeA = useLastCode ? _lastCode : _getBitCode(a, bounds);
+  let codeB = _getBitCode(b, bounds);
+  _lastCode = codeB;
+  while (true) {
+    if (!(codeA | codeB))
+      return [a, b];
+    if (codeA & codeB)
+      return false;
+    const codeOut = codeA || codeB;
+    const p = _getEdgeIntersection(a, b, codeOut, bounds, round);
+    const newCode = _getBitCode(p, bounds);
+    if (codeOut === codeA) {
+      a = p;
+      codeA = newCode;
+    } else {
+      b = p;
+      codeB = newCode;
+    }
+  }
+}
+function _getEdgeIntersection(a, b, code, bounds, round) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const min = bounds.min;
+  const max = bounds.max;
+  let x = 0, y = 0;
+  if (code & 8) {
+    x = a.x + dx * (max.y - a.y) / dy;
+    y = max.y;
+  } else if (code & 4) {
+    x = a.x + dx * (min.y - a.y) / dy;
+    y = min.y;
+  } else if (code & 2) {
+    x = max.x;
+    y = a.y + dy * (max.x - a.x) / dx;
+  } else if (code & 1) {
+    x = min.x;
+    y = a.y + dy * (min.x - a.x) / dx;
+  }
+  return new Point(x, y, round);
+}
+function _getBitCode(p, bounds) {
+  let code = 0;
+  if (p.x < bounds.min.x)
+    code |= 1;
+  else if (p.x > bounds.max.x)
+    code |= 2;
+  if (p.y < bounds.min.y)
+    code |= 4;
+  else if (p.y > bounds.max.y)
+    code |= 8;
+  return code;
+}
+function _sqDist(p1, p2) {
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  return dx * dx + dy * dy;
+}
+function _sqClosestPointOnSegment(p, p1, p2, sqDist) {
+  let { x, y } = p1;
+  let dx = p2.x - x, dy = p2.y - y;
+  const dot = dx * dx + dy * dy;
+  let t;
+  if (dot > 0) {
+    t = ((p.x - x) * dx + (p.y - y) * dy) / dot;
+    if (t > 1) {
+      x = p2.x;
+      y = p2.y;
+    } else if (t > 0) {
+      x += dx * t;
+      y += dy * t;
+    }
+  }
+  dx = p.x - x;
+  dy = p.y - y;
+  return sqDist ? dx * dx + dy * dy : new Point(x, y);
+}
+function isFlat(latlngs) {
+  return !Array.isArray(latlngs[0]) || typeof latlngs[0][0] !== "object" && typeof latlngs[0][0] !== "undefined";
+}
+function polylineCenter(latlngs, crs) {
+  if (!latlngs || latlngs.length === 0)
+    throw new Error("latlngs not passed");
+  if (!isFlat(latlngs)) {
+    console.warn("latlngs are not flat! Only the first ring will be used");
+    latlngs = latlngs[0];
+  }
+  let centroidLatLng = new LatLng(0, 0);
+  const bounds = new LatLngBounds(latlngs);
+  const areaBounds = bounds.getNorthWest().distanceTo(bounds.getSouthWest()) * bounds.getNorthEast().distanceTo(bounds.getNorthWest());
+  if (areaBounds < 1700) {
+    centroidLatLng = centroid(latlngs);
+  }
+  const len = latlngs.length;
+  const points = [];
+  for (let i = 0;i < len; i++) {
+    const latlng = new LatLng(latlngs[i]);
+    points.push(crs.project(new LatLng(latlng.lat - centroidLatLng.lat, latlng.lng - centroidLatLng.lng)));
+  }
+  let halfDist = 0;
+  for (let i = 0;i < len - 1; i++) {
+    halfDist += points[i].distanceTo(points[i + 1]) / 2;
+  }
+  let center;
+  if (halfDist === 0) {
+    center = points[0];
+  } else {
+    let dist = 0;
+    center = points[0];
+    for (let i = 0;i < len - 1; i++) {
+      const p1 = points[i];
+      const p2 = points[i + 1];
+      const segDist = p1.distanceTo(p2);
+      dist += segDist;
+      if (dist > halfDist) {
+        const ratio = (dist - halfDist) / segDist;
+        center = [p2.x - ratio * (p2.x - p1.x), p2.y - ratio * (p2.y - p1.y)];
+        break;
+      }
+    }
+  }
+  const latlngCenter = crs.unproject(new Point(center));
+  return new LatLng(latlngCenter.lat + centroidLatLng.lat, latlngCenter.lng + centroidLatLng.lng);
+}
+export {
+  toTransformation,
+  toPoint,
+  toBounds,
+  Transformation,
+  RTree,
+  exports_PolyUtil as PolyUtil,
+  Point,
+  exports_LineUtil as LineUtil,
+  Bounds
+};