@antv/l7-map 2.9.32-alpha.2 → 2.9.33

package/lib/map.js

@@ -0,0 +1,308 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/map.ts
+var map_exports = {};
+__export(map_exports, {
+  Map: () => Map
+});
+module.exports = __toCommonJS(map_exports);
+var import_l7_utils = require("@antv/l7-utils");
+var import_lodash = require("lodash");
+var import_camera = __toESM(require("./camera"));
+var import_l7 = require("./css/l7.css");
+var import_lng_lat = __toESM(require("./geo/lng_lat"));
+var import_lng_lat_bounds = __toESM(require("./geo/lng_lat_bounds"));
+var import_point = __toESM(require("./geo/point"));
+var import_handler_manager = __toESM(require("./handler/handler_manager"));
+var import_hash = __toESM(require("./hash"));
+var import_util = require("./util");
+var import_performance = require("./utils/performance");
+var import_task_queue = __toESM(require("./utils/task_queue"));
+var defaultMinZoom = -2;
+var defaultMaxZoom = 22;
+var defaultMinPitch = 0;
+var defaultMaxPitch = 60;
+var DefaultOptions = {
+  hash: false,
+  zoom: -1,
+  center: [112, 32],
+  pitch: 0,
+  bearing: 0,
+  interactive: true,
+  minZoom: defaultMinZoom,
+  maxZoom: defaultMaxZoom,
+  minPitch: defaultMinPitch,
+  maxPitch: defaultMaxPitch,
+  scrollZoom: true,
+  boxZoom: true,
+  dragRotate: true,
+  dragPan: true,
+  keyboard: true,
+  doubleClickZoom: true,
+  touchZoomRotate: true,
+  touchPitch: true,
+  bearingSnap: 7,
+  clickTolerance: 3,
+  pitchWithRotate: true,
+  trackResize: true,
+  renderWorldCopies: true,
+  pitchEnabled: true,
+  rotateEnabled: true
+};
+var Map = class extends import_camera.default {
+  constructor(options) {
+    super((0, import_lodash.merge)({}, DefaultOptions, options));
+    this.renderTaskQueue = new import_task_queue.default();
+    this.trackResize = true;
+    this.onWindowOnline = () => {
+      this.update();
+    };
+    this.onWindowResize = (event) => {
+      if (this.trackResize) {
+        this.resize({ originalEvent: event }).update();
+      }
+    };
+    if (import_l7_utils.isMini) {
+      this.initMiniContainer();
+    } else {
+      this.initContainer();
+    }
+    this.resize();
+    this.handlers = new import_handler_manager.default(this, this.options);
+    if (typeof window !== "undefined") {
+      window.addEventListener("online", this.onWindowOnline, false);
+      window.addEventListener("resize", this.onWindowResize, false);
+      window.addEventListener("orientationchange", this.onWindowResize, false);
+    }
+    if (!import_l7_utils.isMini) {
+      const hashName = typeof options.hash === "string" && options.hash || void 0;
+      if (options.hash) {
+        this.hash = new import_hash.default(hashName).addTo(this);
+      }
+    }
+    if (!this.hash || !this.hash.onHashChange()) {
+      this.jumpTo({
+        center: options.center,
+        zoom: options.zoom,
+        bearing: options.bearing,
+        pitch: options.pitch
+      });
+      if (options.bounds) {
+        this.resize();
+        this.fitBounds(options.bounds, (0, import_lodash.merge)({}, options.fitBoundsOptions, { duration: 0 }));
+      }
+    }
+  }
+  resize(eventData) {
+    const [width, height] = this.containerDimensions();
+    this.transform.resize(width, height);
+    if (import_l7_utils.isMini) {
+      return this;
+    }
+    const fireMoving = !this.moving;
+    if (fireMoving) {
+      this.stop();
+      this.emit("movestart", new import_l7_utils.$window.Event("movestart", eventData));
+      this.emit("move", new import_l7_utils.$window.Event("move", eventData));
+    }
+    this.emit("resize", new import_l7_utils.$window.Event("resize", eventData));
+    if (fireMoving) {
+      this.emit("moveend", new import_l7_utils.$window.Event("moveend", eventData));
+    }
+    return this;
+  }
+  getContainer() {
+    return this.container;
+  }
+  getCanvas() {
+    return this.canvas;
+  }
+  getCanvasContainer() {
+    return this.canvasContainer;
+  }
+  project(lngLat) {
+    return this.transform.locationPoint(import_lng_lat.default.convert(lngLat));
+  }
+  unproject(point) {
+    return this.transform.pointLocation(import_point.default.convert(point));
+  }
+  getBounds() {
+    return this.transform.getBounds();
+  }
+  getMaxBounds() {
+    return this.transform.getMaxBounds();
+  }
+  setMaxBounds(bounds) {
+    this.transform.setMaxBounds(import_lng_lat_bounds.default.convert(bounds));
+  }
+  setStyle(style) {
+    return;
+  }
+  setMinZoom(minZoom) {
+    minZoom = minZoom === null || minZoom === void 0 ? defaultMinZoom : minZoom;
+    if (minZoom >= defaultMinZoom && minZoom <= this.transform.maxZoom) {
+      this.transform.minZoom = minZoom;
+      if (this.getZoom() < minZoom) {
+        this.setZoom(minZoom);
+      }
+      return this;
+    } else {
+      throw new Error(`minZoom must be between ${defaultMinZoom} and the current maxZoom, inclusive`);
+    }
+  }
+  getMinZoom() {
+    return this.transform.minZoom;
+  }
+  setMaxZoom(maxZoom) {
+    maxZoom = maxZoom === null || maxZoom === void 0 ? defaultMaxZoom : maxZoom;
+    if (maxZoom >= this.transform.minZoom) {
+      this.transform.maxZoom = maxZoom;
+      if (this.getZoom() > maxZoom) {
+        this.setZoom(maxZoom);
+      }
+      return this;
+    } else {
+      throw new Error("maxZoom must be greater than the current minZoom");
+    }
+  }
+  getMaxZoom() {
+    return this.transform.maxZoom;
+  }
+  setMinPitch(minPitch) {
+    minPitch = minPitch === null || minPitch === void 0 ? defaultMinPitch : minPitch;
+    if (minPitch < defaultMinPitch) {
+      throw new Error(`minPitch must be greater than or equal to ${defaultMinPitch}`);
+    }
+    if (minPitch >= defaultMinPitch && minPitch <= this.transform.maxPitch) {
+      this.transform.minPitch = minPitch;
+      if (this.getPitch() < minPitch) {
+        this.setPitch(minPitch);
+      }
+      return this;
+    } else {
+      throw new Error(`minPitch must be between ${defaultMinPitch} and the current maxPitch, inclusive`);
+    }
+  }
+  getMinPitch() {
+    return this.transform.minPitch;
+  }
+  setMaxPitch(maxPitch) {
+    maxPitch = maxPitch === null || maxPitch === void 0 ? defaultMaxPitch : maxPitch;
+    if (maxPitch > defaultMaxPitch) {
+      throw new Error(`maxPitch must be less than or equal to ${defaultMaxPitch}`);
+    }
+    if (maxPitch >= this.transform.minPitch) {
+      this.transform.maxPitch = maxPitch;
+      if (this.getPitch() > maxPitch) {
+        this.setPitch(maxPitch);
+      }
+      return this;
+    } else {
+      throw new Error("maxPitch must be greater than the current minPitch");
+    }
+  }
+  getMaxPitch() {
+    return this.transform.maxPitch;
+  }
+  getRenderWorldCopies() {
+    return this.transform.renderWorldCopies;
+  }
+  setRenderWorldCopies(renderWorldCopies) {
+    this.transform.renderWorldCopies = !!renderWorldCopies;
+  }
+  remove() {
+    this.container.removeChild(this.canvasContainer);
+    this.canvasContainer = null;
+    if (this.frame) {
+      this.frame.cancel();
+      this.frame = null;
+    }
+    this.renderTaskQueue.clear();
+  }
+  requestRenderFrame(cb) {
+    this.update();
+    return this.renderTaskQueue.add(cb);
+  }
+  cancelRenderFrame(id) {
+    return this.renderTaskQueue.remove(id);
+  }
+  triggerRepaint() {
+    if (!this.frame) {
+      this.frame = (0, import_util.renderframe)((paintStartTimeStamp) => {
+        import_performance.PerformanceUtils.frame(paintStartTimeStamp);
+        this.frame = null;
+        this.update(paintStartTimeStamp);
+      });
+    }
+  }
+  update(time) {
+    if (!this.frame) {
+      this.frame = (0, import_util.renderframe)((paintStartTimeStamp) => {
+        import_performance.PerformanceUtils.frame(paintStartTimeStamp);
+        this.frame = null;
+        this.renderTaskQueue.run(time);
+      });
+    }
+  }
+  initContainer() {
+    if (typeof this.options.container === "string") {
+      this.container = window.document.getElementById(this.options.container);
+      if (!this.container) {
+        throw new Error(`Container '${this.options.container}' not found.`);
+      }
+    } else if (this.options.container instanceof HTMLElement) {
+      this.container = this.options.container;
+    } else {
+      throw new Error("Invalid type: 'container' must be a String or HTMLElement.");
+    }
+    const container = this.container;
+    container.classList.add("l7-map");
+    const canvasContainer = this.canvasContainer = import_l7_utils.DOM.create("div", "l7-canvas-container", container);
+    if (this.options.interactive) {
+      canvasContainer.classList.add("l7-interactive");
+    }
+  }
+  initMiniContainer() {
+    this.container = this.options.canvas;
+    this.canvasContainer = this.container;
+  }
+  containerDimensions() {
+    let width = 0;
+    let height = 0;
+    if (this.container) {
+      if (import_l7_utils.isMini) {
+        width = this.container.width / import_l7_utils.$window.devicePixelRatio;
+        height = this.container.height / import_l7_utils.$window.devicePixelRatio;
+      } else {
+        width = this.container.clientWidth;
+        height = this.container.clientHeight;
+        width = width == 0 ? 400 : width;
+        height = height === 0 ? 300 : height;
+      }
+    }
+    return [width, height];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Map
+});

package/lib/util.js

@@ -0,0 +1,97 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util.ts
+var util_exports = {};
+__export(util_exports, {
+  bezier: () => bezier,
+  cancel: () => cancel,
+  clamp: () => clamp,
+  ease: () => ease,
+  interpolate: () => interpolate,
+  now: () => now,
+  pick: () => pick,
+  prefersReducedMotion: () => prefersReducedMotion,
+  raf: () => raf,
+  renderframe: () => renderframe,
+  wrap: () => wrap
+});
+module.exports = __toCommonJS(util_exports);
+var import_l7_utils = require("@antv/l7-utils");
+var import_unitbezier = __toESM(require("@mapbox/unitbezier"));
+var reducedMotionQuery;
+function wrap(n, min, max) {
+  const d = max - min;
+  const w = ((n - min) % d + d) % d + min;
+  return w === min ? max : w;
+}
+function clamp(n, min, max) {
+  return Math.min(max, Math.max(min, n));
+}
+function interpolate(a, b, t) {
+  return a * (1 - t) + b * t;
+}
+function bezier(p1x, p1y, p2x, p2y) {
+  const bez = new import_unitbezier.default(p1x, p1y, p2x, p2y);
+  return (t) => {
+    return bez.solve(t);
+  };
+}
+var ease = bezier(0.25, 0.1, 0.25, 1);
+function prefersReducedMotion() {
+  if (import_l7_utils.isMini || !import_l7_utils.$window.matchMedia) {
+    return false;
+  }
+  if (reducedMotionQuery == null) {
+    reducedMotionQuery = import_l7_utils.$window.matchMedia("(prefers-reduced-motion: reduce)");
+  }
+  return reducedMotionQuery.matches;
+}
+function pick(src, properties) {
+  const result = {};
+  for (const name of properties) {
+    if (name in src) {
+      result[name] = src[name];
+    }
+  }
+  return result;
+}
+var now = import_l7_utils.isMini ? Date.now.bind(Date) : import_l7_utils.$window.performance && import_l7_utils.$window.performance.now ? import_l7_utils.$window.performance.now.bind(import_l7_utils.$window.performance) : Date.now.bind(Date);
+var raf = import_l7_utils.$window.requestAnimationFrame || import_l7_utils.$window.mozRequestAnimationFrame || import_l7_utils.$window.webkitRequestAnimationFrame || import_l7_utils.$window.msRequestAnimationFrame;
+var cancel = import_l7_utils.$window.cancelAnimationFrame || import_l7_utils.$window.mozCancelAnimationFrame || import_l7_utils.$window.webkitCancelAnimationFrame || import_l7_utils.$window.msCancelAnimationFrame;
+function renderframe(fn) {
+  const frame = raf(fn);
+  return { cancel: () => cancel(frame) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bezier,
+  cancel,
+  clamp,
+  ease,
+  interpolate,
+  now,
+  pick,
+  prefersReducedMotion,
+  raf,
+  renderframe,
+  wrap
+});

package/lib/utils/Aabb.js

@@ -0,0 +1,90 @@
+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/Aabb.ts
+var Aabb_exports = {};
+__export(Aabb_exports, {
+  default: () => Aabb
+});
+module.exports = __toCommonJS(Aabb_exports);
+var import_gl_matrix = require("gl-matrix");
+var Aabb = class {
+  constructor(min, max) {
+    this.min = min;
+    this.max = max;
+    this.center = import_gl_matrix.vec3.scale(new Float32Array(3), import_gl_matrix.vec3.add(new Float32Array(3), this.min, this.max), 0.5);
+  }
+  quadrant(index) {
+    const split = [index % 2 === 0, index < 2];
+    const qMin = import_gl_matrix.vec3.clone(this.min);
+    const qMax = import_gl_matrix.vec3.clone(this.max);
+    for (let axis = 0; axis < split.length; axis++) {
+      qMin[axis] = split[axis] ? this.min[axis] : this.center[axis];
+      qMax[axis] = split[axis] ? this.center[axis] : this.max[axis];
+    }
+    qMax[2] = this.max[2];
+    return new Aabb(qMin, qMax);
+  }
+  distanceX(point) {
+    const pointOnAabb = Math.max(Math.min(this.max[0], point[0]), this.min[0]);
+    return pointOnAabb - point[0];
+  }
+  distanceY(point) {
+    const pointOnAabb = Math.max(Math.min(this.max[1], point[1]), this.min[1]);
+    return pointOnAabb - point[1];
+  }
+  intersects(frustum) {
+    const aabbPoints = [
+      [this.min[0], this.min[1], 0, 1],
+      [this.max[0], this.min[1], 0, 1],
+      [this.max[0], this.max[1], 0, 1],
+      [this.min[0], this.max[1], 0, 1]
+    ];
+    let fullyInside = true;
+    for (const plane of frustum.planes) {
+      let pointsInside = 0;
+      for (const i of aabbPoints) {
+        pointsInside += import_gl_matrix.vec4.dot(plane, i) >= 0;
+      }
+      if (pointsInside === 0) {
+        return 0;
+      }
+      if (pointsInside !== aabbPoints.length) {
+        fullyInside = false;
+      }
+    }
+    if (fullyInside) {
+      return 2;
+    }
+    for (let axis = 0; axis < 3; axis++) {
+      let projMin = Number.MAX_VALUE;
+      let projMax = -Number.MAX_VALUE;
+      for (const p of frustum.points) {
+        const projectedPoint = p[axis] - this.min[axis];
+        projMin = Math.min(projMin, projectedPoint);
+        projMax = Math.max(projMax, projectedPoint);
+      }
+      if (projMax < 0 || projMin > this.max[axis] - this.min[axis]) {
+        return 0;
+      }
+    }
+    return 1;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/utils/dom.js

@@ -0,0 +1,159 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/dom.ts
+var dom_exports = {};
+__export(dom_exports, {
+  default: () => dom_default
+});
+module.exports = __toCommonJS(dom_exports);
+var import_l7_utils = require("@antv/l7-utils");
+var import_point = __toESM(require("../geo/point"));
+var DOM = {};
+var dom_default = DOM;
+DOM.create = (tagName, className, container) => {
+  const el = import_l7_utils.$window.document.createElement(tagName);
+  if (className !== void 0) {
+    el.className = className;
+  }
+  if (container) {
+    container.appendChild(el);
+  }
+  return el;
+};
+DOM.createNS = (namespaceURI, tagName) => {
+  const el = import_l7_utils.$window.document.createElementNS(namespaceURI, tagName);
+  return el;
+};
+var docStyle = import_l7_utils.$window.document && import_l7_utils.$window.document.documentElement.style;
+function testProp(props) {
+  if (!docStyle) {
+    return props[0];
+  }
+  for (const i of props) {
+    if (i in docStyle) {
+      return i;
+    }
+  }
+  return props[0];
+}
+var selectProp = testProp([
+  "userSelect",
+  "MozUserSelect",
+  "WebkitUserSelect",
+  "msUserSelect"
+]);
+var userSelect;
+DOM.disableDrag = () => {
+  if (docStyle && selectProp) {
+    userSelect = docStyle[selectProp];
+    docStyle[selectProp] = "none";
+  }
+};
+DOM.enableDrag = () => {
+  if (docStyle && selectProp) {
+    docStyle[selectProp] = userSelect;
+  }
+};
+var transformProp = testProp(["transform", "WebkitTransform"]);
+DOM.setTransform = (el, value) => {
+  el.style[transformProp] = value;
+};
+var passiveSupported = false;
+try {
+  const options = Object.defineProperty({}, "passive", {
+    get() {
+      passiveSupported = true;
+    }
+  });
+  import_l7_utils.$window.addEventListener("test", options, options);
+  import_l7_utils.$window.removeEventListener("test", options, options);
+} catch (err) {
+  passiveSupported = false;
+}
+DOM.addEventListener = (target, type, callback, options = {}) => {
+  if ("passive" in options && passiveSupported) {
+    target.addEventListener(type, callback, options);
+  } else {
+    target.addEventListener(type, callback, options.capture);
+  }
+};
+DOM.removeEventListener = (target, type, callback, options = {}) => {
+  if ("passive" in options && passiveSupported) {
+    target.removeEventListener(type, callback, options);
+  } else {
+    target.removeEventListener(type, callback, options.capture);
+  }
+};
+var suppressClick = (e) => {
+  e.preventDefault();
+  e.stopPropagation();
+  import_l7_utils.$window.removeEventListener("click", suppressClick, true);
+};
+DOM.suppressClick = () => {
+  if (import_l7_utils.isMini) {
+    return;
+  }
+  import_l7_utils.$window.addEventListener("click", suppressClick, true);
+  setTimeout(() => {
+    import_l7_utils.$window.removeEventListener("click", suppressClick, true);
+  }, 0);
+};
+DOM.mousePos = (el, e) => {
+  if (!import_l7_utils.isMini) {
+    const rect = el.getBoundingClientRect();
+    return new import_point.default(e.clientX - rect.left - el.clientLeft, e.clientY - rect.top - el.clientTop);
+  } else {
+    return new import_point.default(e.clientX - el.left - 0, e.clientY - el.top - 0);
+  }
+};
+DOM.touchPos = (el, touches) => {
+  if (!import_l7_utils.isMini) {
+    const rect = el.getBoundingClientRect();
+    const points = [];
+    for (const touche of touches) {
+      points.push(new import_point.default(touche.clientX - rect.left - el.clientLeft, touche.clientY - rect.top - el.clientTop));
+    }
+    return points;
+  } else {
+    const points = [];
+    for (const touche of touches) {
+      points.push(new import_point.default(touche.clientX - el.left, touche.clientY - el.top));
+    }
+    return points;
+  }
+};
+DOM.mouseButton = (e) => {
+  if (!import_l7_utils.isMini) {
+    return e.button;
+  }
+  if (typeof import_l7_utils.$window.InstallTrigger !== "undefined" && e.button === 2 && e.ctrlKey && import_l7_utils.$window.navigator.platform.toUpperCase().indexOf("MAC") >= 0) {
+    return 0;
+  }
+  return e.button;
+};
+DOM.remove = (node) => {
+  if (node.parentNode) {
+    node.parentNode.removeChild(node);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});