@mavonengine/core 0.0.2

package/dist/cjs/Particles/System/Emitter.cjs

@@ -0,0 +1,81 @@
+"use strict";
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Emitter_exports = {};
+__export(Emitter_exports, {
+  default: () => Emitter
+});
+module.exports = __toCommonJS(Emitter_exports);
+var import_three = require("three");
+var import_Game = __toESM(require("../../Game"), 1);
+var import_GameObject = __toESM(require("../../World/GameObject"), 1);
+class Emitter extends import_GameObject.default {
+  constructor(position, material, maxParticles, maxLifeTimeParticle) {
+    super();
+    /**
+     * If this is not a continous emitter it automatically destroys
+     * itself when all particles have decayed
+     */
+    this.continoues = true;
+    /**
+     * Mark for garbage collection
+     */
+    this.garbageCollect = false;
+    this.particles = [];
+    this.maxParticles = maxParticles;
+    this.maxLifeTimeParticle = maxLifeTimeParticle;
+    this.material = material;
+    this.geometry = new import_three.BufferGeometry();
+    this.positions = new Float32Array(this.maxParticles * 3);
+    this.scales = new Float32Array(this.maxParticles);
+    this.alphas = new Float32Array(this.maxParticles);
+    this.geometry.setAttribute("position", new import_three.BufferAttribute(this.positions, 3));
+    this.geometry.setAttribute("aScale", new import_three.BufferAttribute(this.scales, 1));
+    this.geometry.setAttribute("aAlpha", new import_three.BufferAttribute(this.alphas, 1));
+    this.mesh = new import_three.Points(this.geometry, this.material);
+    this.mesh.position.set(position.x, position.y, position.z);
+    import_Game.default.instance().scene.add(this.mesh);
+  }
+  /**
+   * Remove everything from the scene
+   */
+  destroy() {
+    super.destroy();
+    import_Game.default.instance().scene.remove(this.mesh);
+    this.geometry.dispose();
+    this.material.dispose();
+  }
+  update(_delta) {
+    this.geometry.attributes.aScale.needsUpdate = true;
+    this.geometry.attributes.position.needsUpdate = true;
+    if (!this.continoues && this.particles.filter((particle) => particle.age < particle.decay).length === 0) {
+      this.destroy();
+    }
+  }
+}
+Emitter.preview = null;

package/dist/cjs/Particles/System/Particle.cjs

@@ -0,0 +1,49 @@
+"use strict";
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Particle_exports = {};
+__export(Particle_exports, {
+  default: () => Particle
+});
+module.exports = __toCommonJS(Particle_exports);
+var import_GameObject = __toESM(require("../../World/GameObject"), 1);
+class Particle extends import_GameObject.default {
+  constructor(decay, position) {
+    super();
+    this.age = 0;
+    this.startAlpha = 1;
+    this.decay = decay;
+    this.position = position;
+  }
+  update(delta) {
+    this.age += delta;
+  }
+  get alpha() {
+    return Math.max(this.startAlpha * (1 - this.age / this.decay), 0);
+  }
+}

package/dist/cjs/Particles/System/ParticleEffect.cjs

@@ -0,0 +1,59 @@
+"use strict";
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ParticleEffect_exports = {};
+__export(ParticleEffect_exports, {
+  default: () => ParticleEffect
+});
+module.exports = __toCommonJS(ParticleEffect_exports);
+var import_WithEditorHelper = require("../../Editor/WithEditorHelper");
+var import_GameObject = __toESM(require("../../World/GameObject"), 1);
+class ParticleEffect extends (0, import_WithEditorHelper.WithEditorHelper)(import_GameObject.default) {
+  constructor() {
+    super(...arguments);
+    this.emitters = [];
+    this.persistent = false;
+  }
+  destroy() {
+    this.emitters.forEach((e) => e.destroy());
+    this.emitters = [];
+    super.destroy();
+  }
+  onMove(delta) {
+    this.emitters.forEach((e) => e.mesh.position.add(delta));
+  }
+  update(delta) {
+    this.emitters.forEach((emitter) => emitter.update(delta));
+    this.emitters = this.emitters.filter((emitter) => {
+      if (emitter.garbageCollect) {
+        emitter.destroy();
+      }
+      return !emitter.garbageCollect;
+    });
+  }
+}

package/dist/cjs/Particles/System/ParticlePreviewRegistry.cjs

@@ -0,0 +1,63 @@
+"use strict";
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ParticlePreviewRegistry_exports = {};
+__export(ParticlePreviewRegistry_exports, {
+  getPreviewMap: () => getPreviewMap,
+  registerParticle: () => registerParticle,
+  spawnParticle: () => spawnParticle
+});
+module.exports = __toCommonJS(ParticlePreviewRegistry_exports);
+var import_Logger = __toESM(require("../../Utils/Logger"), 1);
+const registry = {};
+const logger = new import_Logger.default(process.env.NODE_ENV === "production" ? "error" : "debug");
+function registerParticle(name, entry) {
+  registry[name] = entry;
+  logger.info(`Particle registered: ${name}`);
+}
+function getPreviewMap() {
+  return Object.fromEntries(Object.entries(registry).map(([k, v]) => [k, v.preview]));
+}
+function spawnParticle(name, position) {
+  const effect = registry[name]?.spawn(position) ?? null;
+  if (effect) {
+    effect.persistent = true;
+    effect.registerEditorHelper(position, name, effect);
+    effect.emitters.forEach((e) => {
+      e.mesh.name = name;
+      e.mesh.userData.editorHelper = effect.editorHelper;
+    });
+  }
+  return effect;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPreviewMap,
+  registerParticle,
+  spawnParticle
+});

package/dist/cjs/Particles/System/ParticleSystem.cjs

@@ -0,0 +1,61 @@
+"use strict";
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ParticleSystem_exports = {};
+__export(ParticleSystem_exports, {
+  default: () => ParticleSystem
+});
+module.exports = __toCommonJS(ParticleSystem_exports);
+var import_Game = __toESM(require("../../Game"), 1);
+var import_GameObject = __toESM(require("../../World/GameObject"), 1);
+class ParticleSystem extends import_GameObject.default {
+  constructor() {
+    super();
+    this.effects = [];
+    this.stats = {
+      particles: 0
+    };
+    const particlePane = import_Game.default.instance().debug.ui?.addFolder({
+      title: "Particles"
+    });
+    if (particlePane) {
+      particlePane.addBinding(this.stats, "particles", { label: "Particles", readonly: true });
+    }
+  }
+  addEffect(effect) {
+    this.effects.push(effect);
+  }
+  update(delta) {
+    this.stats.particles = 0;
+    this.effects.forEach((effect) => {
+      effect.update(delta);
+      if (import_Game.default.instance().debug.active)
+        effect.emitters.forEach((emitter) => this.stats.particles += emitter.particles.length);
+    });
+  }
+}

package/dist/cjs/Prefab/Grass/Grass.cjs

@@ -0,0 +1,214 @@
+"use strict";
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Grass_exports = {};
+__export(Grass_exports, {
+  default: () => Grass
+});
+module.exports = __toCommonJS(Grass_exports);
+var import_WithEditorHelper = require("../../Editor/WithEditorHelper");
+var import_Game = __toESM(require("../../Game"), 1);
+var import_Math = require("../../Utils/Math");
+var import_Entity3D = __toESM(require("../../World/Entity3D"), 1);
+var import_three = require("three");
+var import_SkeletonUtils = require("three/examples/jsm/utils/SkeletonUtils.js");
+var import_Fragment = __toESM(require("./Fragment.glsl"), 1);
+var import_Vertex = __toESM(require("./Vertex.glsl"), 1);
+const MAX_PUSH_POINTS = 150;
+class Grass extends (0, import_WithEditorHelper.WithEditorHelper)(import_Entity3D.default) {
+  constructor(highModel, lowModel, grassBlades = 2e5, patchSize = 12.5, position = new import_three.Vector3(), coordCallback) {
+    super();
+    this.instancePositions = new Float32Array(grassBlades * 3);
+    this.patchSize = patchSize;
+    this.position = position;
+    this.coordCallback = coordCallback;
+    this.registerEditorHelper(position, "Grass", this);
+    const onLoad = () => {
+      const highSource = (0, import_SkeletonUtils.clone)(highModel.scene.clone()).children.find((child) => child instanceof import_three.Mesh);
+      const lowSource = (0, import_SkeletonUtils.clone)(lowModel.scene.clone()).children.find((child) => child instanceof import_three.Mesh);
+      if (!highSource || !lowSource) {
+        console.error("No mesh found in model");
+        return;
+      }
+      this.highGeometry = highSource.geometry.clone();
+      this.highGeometry.rotateZ(Math.PI / 180 * 90);
+      this.lowGeometry = lowSource.geometry.clone();
+      this.lowGeometry.rotateZ(Math.PI / 180 * 90);
+      this.build(grassBlades);
+      import_Game.default.instance().scene.add(this.mesh, this.lowResMesh);
+    };
+    if (import_Game.default.instance().resources.loaded) {
+      onLoad();
+    } else {
+      import_Game.default.instance().resources.on("loaded", onLoad);
+    }
+  }
+  build(grassBlades) {
+    const { patchSize, position, coordCallback } = this;
+    const positions = new Float32Array(grassBlades * 3);
+    const instanceRotation = new Float32Array(grassBlades);
+    const instanceScales = new Float32Array(grassBlades);
+    let bladeIndex = 0;
+    while (bladeIndex < grassBlades) {
+      const x = (0, import_Math.randRange)(-patchSize, patchSize);
+      const z = (0, import_Math.randRange)(-patchSize, patchSize);
+      const distSq = x * x + z * z;
+      const maxDistSq = patchSize * patchSize;
+      const densityFalloff = Math.exp(-distSq / (maxDistSq * 0.1));
+      if (Math.random() < densityFalloff) {
+        positions[bladeIndex * 3] = x;
+        positions[bladeIndex * 3 + 1] = coordCallback ? coordCallback(x, z) : 0;
+        positions[bladeIndex * 3 + 2] = z;
+        instanceRotation[bladeIndex] = Math.random() * Math.PI * 2;
+        instanceScales[bladeIndex] = (0, import_Math.randRange)(2.3, 3.5);
+        bladeIndex++;
+      }
+    }
+    const instanceLeans = new Float32Array(grassBlades);
+    for (let i = 0; i < grassBlades; i++) {
+      instanceLeans[i] = (0, import_Math.randRange)(-0.4, 0.4);
+    }
+    const buildGeometry = (baseGeometry) => {
+      const geometry = new import_three.InstancedBufferGeometry();
+      geometry.index = baseGeometry.index;
+      geometry.attributes = { ...baseGeometry.attributes };
+      geometry.setAttribute("offset", new import_three.InstancedBufferAttribute(positions, 3));
+      geometry.setAttribute("rotationAngle", new import_three.InstancedBufferAttribute(instanceRotation, 1));
+      geometry.setAttribute("instanceScale", new import_three.InstancedBufferAttribute(instanceScales, 1));
+      geometry.setAttribute("randomLean", new import_three.InstancedBufferAttribute(instanceLeans, 1));
+      geometry.instanceCount = grassBlades;
+      geometry.boundingBox = new import_three.Box3(
+        new import_three.Vector3(-patchSize, -patchSize, -patchSize),
+        new import_three.Vector3(patchSize, patchSize, patchSize)
+      );
+      geometry.boundingSphere = geometry.boundingBox.getBoundingSphere(new import_three.Sphere());
+      const material = new import_three.ShaderMaterial({
+        vertexShader: import_Vertex.default,
+        fragmentShader: import_Fragment.default,
+        side: import_three.DoubleSide,
+        uniforms: {
+          uTime: { value: 0 },
+          pushPositions: {
+            value: Array.from({ length: MAX_PUSH_POINTS }, () => new import_three.Vector3())
+          },
+          pushRadii: {
+            value: Array.from({ length: MAX_PUSH_POINTS }).fill(0)
+          }
+        }
+      });
+      const mesh = new import_three.Mesh(geometry, material);
+      mesh.position.copy(position);
+      mesh.userData.grassInstance = this;
+      mesh.raycast = (raycaster, intersects) => {
+        if (!import_Game.default.instance().editor)
+          return;
+        if (!geometry.boundingBox)
+          return;
+        const box = new import_three.Box3().copy(geometry.boundingBox).applyMatrix4(mesh.matrixWorld);
+        const target = new import_three.Vector3();
+        if (raycaster.ray.intersectBox(box, target)) {
+          intersects.push({
+            distance: raycaster.ray.origin.distanceTo(target),
+            point: target.clone(),
+            object: mesh
+          });
+        }
+      };
+      return { mesh, material };
+    };
+    if (this.mesh) {
+      this.mesh.geometry.dispose();
+      this.lowResMesh.geometry.dispose();
+      const highGeo = buildGeometry(this.highGeometry).mesh.geometry;
+      const lowGeo = buildGeometry(this.lowGeometry).mesh.geometry;
+      this.mesh.geometry = highGeo;
+      this.lowResMesh.geometry = lowGeo;
+      this.instancePositions = positions;
+    } else {
+      const high = buildGeometry(this.highGeometry);
+      this.mesh = high.mesh;
+      this.material = high.material;
+      this.instancePositions = positions;
+      const low = buildGeometry(this.lowGeometry);
+      this.lowResMesh = low.mesh;
+      this.lowResMaterial = low.material;
+      this.lowResMesh.visible = false;
+      this.tagWithHelper(this.mesh);
+      this.tagWithHelper(this.lowResMesh);
+    }
+  }
+  reallocate(grassBlades) {
+    if (!this.highGeometry || !this.lowGeometry)
+      return;
+    this.build(grassBlades);
+  }
+  addBindings(folder) {
+    const proxy = { bladeCount: this.mesh?.geometry.getAttribute("offset")?.count ?? 0 };
+    folder.addBinding(proxy, "bladeCount", { min: 1e3, max: 5e4, step: 1e3, label: "Blade Count" }).on("change", ({ value }) => this.reallocate(value));
+  }
+  destroy() {
+    this.material?.dispose();
+    this.lowResMaterial?.dispose();
+    this.mesh?.geometry.dispose();
+    this.lowResMesh?.geometry.dispose();
+    import_Game.default.instance().scene.remove(this.mesh, this.lowResMesh);
+    super.destroy();
+  }
+  setPushPoints(points) {
+    const materials = [this.material, this.lowResMaterial].filter(
+      (m) => !!m
+    );
+    if (!materials.length)
+      return;
+    for (let i = 0; i < MAX_PUSH_POINTS; i++) {
+      if (points[i]) {
+        materials.forEach((mat) => {
+          mat.uniforms.pushPositions.value[i].copy(points[i].position);
+          mat.uniforms.pushRadii.value[i] = points[i].radius;
+        });
+      }
+    }
+  }
+  update(delta) {
+    [this.material, this.lowResMaterial].forEach((mat) => {
+      if (mat)
+        mat.uniforms.uTime.value += delta;
+    });
+    const cameraPos = import_Game.default.instance().camera.instance.position;
+    const distance = cameraPos.distanceTo(this.mesh.position);
+    if (this.lowResMesh) {
+      if (distance > 20) {
+        this.lowResMesh.visible = true;
+        this.mesh.visible = false;
+      } else {
+        this.lowResMesh.visible = false;
+        this.mesh.visible = true;
+      }
+    }
+  }
+}

package/dist/cjs/Prefab/Grass/GrassAffectingEntity.cjs

@@ -0,0 +1,30 @@
+"use strict";
+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);
+var GrassAffectingEntity_exports = {};
+__export(GrassAffectingEntity_exports, {
+  isGrassAffectingEntity: () => isGrassAffectingEntity
+});
+module.exports = __toCommonJS(GrassAffectingEntity_exports);
+function isGrassAffectingEntity(obj) {
+  return typeof obj.getPushPoints === "function";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isGrassAffectingEntity
+});