three-stdlib 2.22.9 → 2.22.10

package/dist/math/Capsule.mjs

@@ -1,100 +1,98 @@
 import { Vector3 } from "three";
-var Capsule = function() {
-  var _v1 = new Vector3();
-  var _v2 = new Vector3();
-  var _v3 = new Vector3();
-  var EPS = 1e-10;
-  function Capsule2(start, end, radius) {
-    this.start = start == void 0 ? new Vector3(0, 0, 0) : start;
-    this.end = end == void 0 ? new Vector3(0, 1, 0) : end;
-    this.radius = radius == void 0 ? 1 : radius;
+const _v1 = /* @__PURE__ */ new Vector3();
+const _v2 = /* @__PURE__ */ new Vector3();
+const _v3 = /* @__PURE__ */ new Vector3();
+const EPS = 1e-10;
+class Capsule {
+  constructor(start = new Vector3(0, 0, 0), end = new Vector3(0, 1, 0), radius = 1) {
+    this.start = start;
+    this.end = end;
+    this.radius = radius;
   }
-  Object.assign(Capsule2.prototype, {
-    clone: function() {
-      return new Capsule2(this.start.clone(), this.end.clone(), this.radius);
-    },
-    set: function(start, end, radius) {
-      this.start.copy(start);
-      this.end.copy(end);
-      this.radius = radius;
-    },
-    copy: function(capsule) {
-      this.start.copy(capsule.start);
-      this.end.copy(capsule.end);
-      this.radius = capsule.radius;
-    },
-    getCenter: function(target) {
-      return target.copy(this.end).add(this.start).multiplyScalar(0.5);
-    },
-    translate: function(v) {
-      this.start.add(v);
-      this.end.add(v);
-    },
-    checkAABBAxis: function(p1x, p1y, p2x, p2y, minx, maxx, miny, maxy, radius) {
-      return (minx - p1x < radius || minx - p2x < radius) && (p1x - maxx < radius || p2x - maxx < radius) && (miny - p1y < radius || miny - p2y < radius) && (p1y - maxy < radius || p2y - maxy < radius);
-    },
-    intersectsBox: function(box) {
-      return this.checkAABBAxis(
-        this.start.x,
-        this.start.y,
-        this.end.x,
-        this.end.y,
-        box.min.x,
-        box.max.x,
-        box.min.y,
-        box.max.y,
-        this.radius
-      ) && this.checkAABBAxis(
-        this.start.x,
-        this.start.z,
-        this.end.x,
-        this.end.z,
-        box.min.x,
-        box.max.x,
-        box.min.z,
-        box.max.z,
-        this.radius
-      ) && this.checkAABBAxis(
-        this.start.y,
-        this.start.z,
-        this.end.y,
-        this.end.z,
-        box.min.y,
-        box.max.y,
-        box.min.z,
-        box.max.z,
-        this.radius
-      );
-    },
-    lineLineMinimumPoints: function(line1, line2) {
-      var r = _v1.copy(line1.end).sub(line1.start);
-      var s = _v2.copy(line2.end).sub(line2.start);
-      var w = _v3.copy(line2.start).sub(line1.start);
-      var a = r.dot(s), b = r.dot(r), c = s.dot(s), d = s.dot(w), e = r.dot(w);
-      var t1, t2, divisor = b * c - a * a;
-      if (Math.abs(divisor) < EPS) {
-        var d1 = -d / c;
-        var d2 = (a - d) / c;
-        if (Math.abs(d1 - 0.5) < Math.abs(d2 - 0.5)) {
-          t1 = 0;
-          t2 = d1;
-        } else {
-          t1 = 1;
-          t2 = d2;
-        }
+  clone() {
+    return new Capsule(this.start.clone(), this.end.clone(), this.radius);
+  }
+  set(start, end, radius) {
+    this.start.copy(start);
+    this.end.copy(end);
+    this.radius = radius;
+  }
+  copy(capsule) {
+    this.start.copy(capsule.start);
+    this.end.copy(capsule.end);
+    this.radius = capsule.radius;
+  }
+  getCenter(target) {
+    return target.copy(this.end).add(this.start).multiplyScalar(0.5);
+  }
+  translate(v) {
+    this.start.add(v);
+    this.end.add(v);
+  }
+  checkAABBAxis(p1x, p1y, p2x, p2y, minx, maxx, miny, maxy, radius) {
+    return (minx - p1x < radius || minx - p2x < radius) && (p1x - maxx < radius || p2x - maxx < radius) && (miny - p1y < radius || miny - p2y < radius) && (p1y - maxy < radius || p2y - maxy < radius);
+  }
+  intersectsBox(box) {
+    return this.checkAABBAxis(
+      this.start.x,
+      this.start.y,
+      this.end.x,
+      this.end.y,
+      box.min.x,
+      box.max.x,
+      box.min.y,
+      box.max.y,
+      this.radius
+    ) && this.checkAABBAxis(
+      this.start.x,
+      this.start.z,
+      this.end.x,
+      this.end.z,
+      box.min.x,
+      box.max.x,
+      box.min.z,
+      box.max.z,
+      this.radius
+    ) && this.checkAABBAxis(
+      this.start.y,
+      this.start.z,
+      this.end.y,
+      this.end.z,
+      box.min.y,
+      box.max.y,
+      box.min.z,
+      box.max.z,
+      this.radius
+    );
+  }
+  lineLineMinimumPoints(line1, line2) {
+    const r = _v1.copy(line1.end).sub(line1.start);
+    const s = _v2.copy(line2.end).sub(line2.start);
+    const w = _v3.copy(line2.start).sub(line1.start);
+    const a = r.dot(s), b = r.dot(r), c = s.dot(s), d = s.dot(w), e = r.dot(w);
+    let t1, t2;
+    const divisor = b * c - a * a;
+    if (Math.abs(divisor) < EPS) {
+      const d1 = -d / c;
+      const d2 = (a - d) / c;
+      if (Math.abs(d1 - 0.5) < Math.abs(d2 - 0.5)) {
+        t1 = 0;
+        t2 = d1;
       } else {
-        t1 = (d * a + e * c) / divisor;
-        t2 = (t1 * a - d) / c;
+        t1 = 1;
+        t2 = d2;
       }
-      t2 = Math.max(0, Math.min(1, t2));
-      t1 = Math.max(0, Math.min(1, t1));
-      var point1 = r.multiplyScalar(t1).add(line1.start);
-      var point2 = s.multiplyScalar(t2).add(line2.start);
-      return [point1, point2];
+    } else {
+      t1 = (d * a + e * c) / divisor;
+      t2 = (t1 * a - d) / c;
     }
-  });
-  return Capsule2;
-}();
+    t2 = Math.max(0, Math.min(1, t2));
+    t1 = Math.max(0, Math.min(1, t1));
+    const point1 = r.multiplyScalar(t1).add(line1.start);
+    const point2 = s.multiplyScalar(t2).add(line2.start);
+    return [point1, point2];
+  }
+}
 export {
   Capsule
 };

package/dist/math/ColorConverter.js

@@ -1,52 +1,42 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
-var ColorConverter = {
-  setHSV: function(color, h, s, v) {
+const _hsl = {};
+class ColorConverter {
+  static setHSV(color, h, s, v) {
     h = THREE.MathUtils.euclideanModulo(h, 1);
     s = THREE.MathUtils.clamp(s, 0, 1);
     v = THREE.MathUtils.clamp(v, 0, 1);
     return color.setHSL(h, s * v / ((h = (2 - s) * v) < 1 ? h : 2 - h), h * 0.5);
-  },
-  getHSV: function() {
-    var hsl = {};
-    return function getHSV(color, target) {
-      if (target === void 0) {
-        console.warn("THREE.ColorConverter: .getHSV() target is now required");
-        target = { h: 0, s: 0, l: 0 };
-      }
-      color.getHSL(hsl);
-      hsl.s *= hsl.l < 0.5 ? hsl.l : 1 - hsl.l;
-      target.h = hsl.h;
-      target.s = 2 * hsl.s / (hsl.l + hsl.s);
-      target.v = hsl.l + hsl.s;
-      return target;
-    };
-  }(),
+  }
+  static getHSV(color, target) {
+    color.getHSL(_hsl);
+    _hsl.s *= _hsl.l < 0.5 ? _hsl.l : 1 - _hsl.l;
+    target.h = _hsl.h;
+    target.s = 2 * _hsl.s / (_hsl.l + _hsl.s);
+    target.v = _hsl.l + _hsl.s;
+    return target;
+  }
   // where c, m, y, k is between 0 and 1
-  setCMYK: function(color, c, m, y, k) {
-    var r = (1 - c) * (1 - k);
-    var g = (1 - m) * (1 - k);
-    var b = (1 - y) * (1 - k);
+  static setCMYK(color, c, m, y, k) {
+    const r = (1 - c) * (1 - k);
+    const g = (1 - m) * (1 - k);
+    const b = (1 - y) * (1 - k);
     return color.setRGB(r, g, b);
-  },
-  getCMYK: function(color, target) {
-    if (target === void 0) {
-      console.warn("THREE.ColorConverter: .getCMYK() target is now required");
-      target = { c: 0, m: 0, y: 0, k: 0 };
-    }
-    var r = color.r;
-    var g = color.g;
-    var b = color.b;
-    var k = 1 - Math.max(r, g, b);
-    var c = (1 - r - k) / (1 - k);
-    var m = (1 - g - k) / (1 - k);
-    var y = (1 - b - k) / (1 - k);
+  }
+  static getCMYK(color, target) {
+    const r = color.r;
+    const g = color.g;
+    const b = color.b;
+    const k = 1 - Math.max(r, g, b);
+    const c = (1 - r - k) / (1 - k);
+    const m = (1 - g - k) / (1 - k);
+    const y = (1 - b - k) / (1 - k);
     target.c = c;
     target.m = m;
     target.y = y;
     target.k = k;
     return target;
   }
-};
+}
 exports.ColorConverter = ColorConverter;

package/dist/math/ColorConverter.mjs

@@ -1,52 +1,42 @@
 import { MathUtils } from "three";
-var ColorConverter = {
-  setHSV: function(color, h, s, v) {
+const _hsl = {};
+class ColorConverter {
+  static setHSV(color, h, s, v) {
     h = MathUtils.euclideanModulo(h, 1);
     s = MathUtils.clamp(s, 0, 1);
     v = MathUtils.clamp(v, 0, 1);
     return color.setHSL(h, s * v / ((h = (2 - s) * v) < 1 ? h : 2 - h), h * 0.5);
-  },
-  getHSV: function() {
-    var hsl = {};
-    return function getHSV(color, target) {
-      if (target === void 0) {
-        console.warn("THREE.ColorConverter: .getHSV() target is now required");
-        target = { h: 0, s: 0, l: 0 };
-      }
-      color.getHSL(hsl);
-      hsl.s *= hsl.l < 0.5 ? hsl.l : 1 - hsl.l;
-      target.h = hsl.h;
-      target.s = 2 * hsl.s / (hsl.l + hsl.s);
-      target.v = hsl.l + hsl.s;
-      return target;
-    };
-  }(),
+  }
+  static getHSV(color, target) {
+    color.getHSL(_hsl);
+    _hsl.s *= _hsl.l < 0.5 ? _hsl.l : 1 - _hsl.l;
+    target.h = _hsl.h;
+    target.s = 2 * _hsl.s / (_hsl.l + _hsl.s);
+    target.v = _hsl.l + _hsl.s;
+    return target;
+  }
   // where c, m, y, k is between 0 and 1
-  setCMYK: function(color, c, m, y, k) {
-    var r = (1 - c) * (1 - k);
-    var g = (1 - m) * (1 - k);
-    var b = (1 - y) * (1 - k);
+  static setCMYK(color, c, m, y, k) {
+    const r = (1 - c) * (1 - k);
+    const g = (1 - m) * (1 - k);
+    const b = (1 - y) * (1 - k);
     return color.setRGB(r, g, b);
-  },
-  getCMYK: function(color, target) {
-    if (target === void 0) {
-      console.warn("THREE.ColorConverter: .getCMYK() target is now required");
-      target = { c: 0, m: 0, y: 0, k: 0 };
-    }
-    var r = color.r;
-    var g = color.g;
-    var b = color.b;
-    var k = 1 - Math.max(r, g, b);
-    var c = (1 - r - k) / (1 - k);
-    var m = (1 - g - k) / (1 - k);
-    var y = (1 - b - k) / (1 - k);
+  }
+  static getCMYK(color, target) {
+    const r = color.r;
+    const g = color.g;
+    const b = color.b;
+    const k = 1 - Math.max(r, g, b);
+    const c = (1 - r - k) / (1 - k);
+    const m = (1 - g - k) / (1 - k);
+    const y = (1 - b - k) / (1 - k);
     target.c = c;
     target.m = m;
     target.y = y;
     target.k = k;
     return target;
   }
-};
+}
 export {
   ColorConverter
 };

package/dist/math/ConvexHull.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
 const Visible = 0;
 const Deleted = 1;
-const _v1 = new THREE.Vector3();
-const _line3 = new THREE.Line3();
-const _plane = new THREE.Plane();
-const _closestPoint = new THREE.Vector3();
-const _triangle = new THREE.Triangle();
+const _v1 = /* @__PURE__ */ new THREE.Vector3();
+const _line3 = /* @__PURE__ */ new THREE.Line3();
+const _plane = /* @__PURE__ */ new THREE.Plane();
+const _closestPoint = /* @__PURE__ */ new THREE.Vector3();
+const _triangle = /* @__PURE__ */ new THREE.Triangle();
 class ConvexHull {
   constructor() {
     this.tolerance = -1;
@@ -33,17 +33,12 @@ class ConvexHull {
     object.traverse(function(node) {
       const geometry = node.geometry;
       if (geometry !== void 0) {
-        if (geometry.isGeometry) {
-          console.error("THREE.ConvexHull no longer supports Geometry. Use THREE.BufferGeometry instead.");
-          return;
-        } else if (geometry.isBufferGeometry) {
-          const attribute = geometry.attributes.position;
-          if (attribute !== void 0) {
-            for (let i = 0, l = attribute.count; i < l; i++) {
-              const point = new THREE.Vector3();
-              point.fromBufferAttribute(attribute, i).applyMatrix4(node.matrixWorld);
-              points.push(point);
-            }
+        const attribute = geometry.attributes.position;
+        if (attribute !== void 0) {
+          for (let i = 0, l = attribute.count; i < l; i++) {
+            const point = new THREE.Vector3();
+            point.fromBufferAttribute(attribute, i).applyMatrix4(node.matrixWorld);
+            points.push(point);
           }
         }
       }
@@ -119,7 +114,7 @@ class ConvexHull {
     this.assigned.remove(vertex);
     return this;
   }
-  // Removes all the visible vertices that a given face is able to see which are stored in the 'assigned' vertext list
+  // Removes all the visible vertices that a given face is able to see which are stored in the 'assigned' vertex list
   removeAllVerticesFromFace(face) {
     if (face.outside !== null) {
       const start = face.outside;
@@ -595,3 +590,7 @@ class VertexList {
   }
 }
 exports.ConvexHull = ConvexHull;
+exports.Face = Face;
+exports.HalfEdge = HalfEdge;
+exports.VertexList = VertexList;
+exports.VertexNode = VertexNode;

package/dist/math/ConvexHull.mjs

@@ -1,11 +1,11 @@
 import { Vector3, Line3, Plane, Triangle } from "three";
 const Visible = 0;
 const Deleted = 1;
-const _v1 = new Vector3();
-const _line3 = new Line3();
-const _plane = new Plane();
-const _closestPoint = new Vector3();
-const _triangle = new Triangle();
+const _v1 = /* @__PURE__ */ new Vector3();
+const _line3 = /* @__PURE__ */ new Line3();
+const _plane = /* @__PURE__ */ new Plane();
+const _closestPoint = /* @__PURE__ */ new Vector3();
+const _triangle = /* @__PURE__ */ new Triangle();
 class ConvexHull {
   constructor() {
     this.tolerance = -1;
@@ -31,17 +31,12 @@ class ConvexHull {
     object.traverse(function(node) {
       const geometry = node.geometry;
       if (geometry !== void 0) {
-        if (geometry.isGeometry) {
-          console.error("THREE.ConvexHull no longer supports Geometry. Use THREE.BufferGeometry instead.");
-          return;
-        } else if (geometry.isBufferGeometry) {
-          const attribute = geometry.attributes.position;
-          if (attribute !== void 0) {
-            for (let i = 0, l = attribute.count; i < l; i++) {
-              const point = new Vector3();
-              point.fromBufferAttribute(attribute, i).applyMatrix4(node.matrixWorld);
-              points.push(point);
-            }
+        const attribute = geometry.attributes.position;
+        if (attribute !== void 0) {
+          for (let i = 0, l = attribute.count; i < l; i++) {
+            const point = new Vector3();
+            point.fromBufferAttribute(attribute, i).applyMatrix4(node.matrixWorld);
+            points.push(point);
           }
         }
       }
@@ -117,7 +112,7 @@ class ConvexHull {
     this.assigned.remove(vertex);
     return this;
   }
-  // Removes all the visible vertices that a given face is able to see which are stored in the 'assigned' vertext list
+  // Removes all the visible vertices that a given face is able to see which are stored in the 'assigned' vertex list
   removeAllVerticesFromFace(face) {
     if (face.outside !== null) {
       const start = face.outside;
@@ -593,5 +588,9 @@ class VertexList {
   }
 }
 export {
-  ConvexHull
+  ConvexHull,
+  Face,
+  HalfEdge,
+  VertexList,
+  VertexNode
 };

package/dist/math/ImprovedNoise.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-var ImprovedNoise = function() {
-  var p = [
+function init() {
+  const _p2 = [
     151,
     160,
     137,
@@ -260,43 +260,45 @@ var ImprovedNoise = function() {
     180
   ];
   for (let i = 0; i < 256; i++) {
-    p[256 + i] = p[i];
+    _p2[256 + i] = _p2[i];
   }
-  function fade(t) {
-    return t * t * t * (t * (t * 6 - 15) + 10);
+  return _p2;
+}
+const _p = /* @__PURE__ */ init();
+function fade(t) {
+  return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function lerp(t, a, b) {
+  return a + t * (b - a);
+}
+function grad(hash, x, y, z) {
+  const h = hash & 15;
+  const u = h < 8 ? x : y, v = h < 4 ? y : h == 12 || h == 14 ? x : z;
+  return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
+}
+class ImprovedNoise {
+  noise(x, y, z) {
+    const floorX = Math.floor(x), floorY = Math.floor(y), floorZ = Math.floor(z);
+    const X = floorX & 255, Y = floorY & 255, Z = floorZ & 255;
+    x -= floorX;
+    y -= floorY;
+    z -= floorZ;
+    const xMinus1 = x - 1, yMinus1 = y - 1, zMinus1 = z - 1;
+    const u = fade(x), v = fade(y), w = fade(z);
+    const A = _p[X] + Y, AA = _p[A] + Z, AB = _p[A + 1] + Z, B = _p[X + 1] + Y, BA = _p[B] + Z, BB = _p[B + 1] + Z;
+    return lerp(
+      w,
+      lerp(
+        v,
+        lerp(u, grad(_p[AA], x, y, z), grad(_p[BA], xMinus1, y, z)),
+        lerp(u, grad(_p[AB], x, yMinus1, z), grad(_p[BB], xMinus1, yMinus1, z))
+      ),
+      lerp(
+        v,
+        lerp(u, grad(_p[AA + 1], x, y, zMinus1), grad(_p[BA + 1], xMinus1, y, zMinus1)),
+        lerp(u, grad(_p[AB + 1], x, yMinus1, zMinus1), grad(_p[BB + 1], xMinus1, yMinus1, zMinus1))
+      )
+    );
   }
-  function lerp(t, a, b) {
-    return a + t * (b - a);
-  }
-  function grad(hash, x, y, z) {
-    var h = hash & 15;
-    var u = h < 8 ? x : y, v = h < 4 ? y : h == 12 || h == 14 ? x : z;
-    return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
-  }
-  return {
-    noise: function(x, y, z) {
-      var floorX = Math.floor(x), floorY = Math.floor(y), floorZ = Math.floor(z);
-      var X = floorX & 255, Y = floorY & 255, Z = floorZ & 255;
-      x -= floorX;
-      y -= floorY;
-      z -= floorZ;
-      var xMinus1 = x - 1, yMinus1 = y - 1, zMinus1 = z - 1;
-      var u = fade(x), v = fade(y), w = fade(z);
-      var A = p[X] + Y, AA = p[A] + Z, AB = p[A + 1] + Z, B = p[X + 1] + Y, BA = p[B] + Z, BB = p[B + 1] + Z;
-      return lerp(
-        w,
-        lerp(
-          v,
-          lerp(u, grad(p[AA], x, y, z), grad(p[BA], xMinus1, y, z)),
-          lerp(u, grad(p[AB], x, yMinus1, z), grad(p[BB], xMinus1, yMinus1, z))
-        ),
-        lerp(
-          v,
-          lerp(u, grad(p[AA + 1], x, y, zMinus1), grad(p[BA + 1], xMinus1, y, zMinus1)),
-          lerp(u, grad(p[AB + 1], x, yMinus1, zMinus1), grad(p[BB + 1], xMinus1, yMinus1, zMinus1))
-        )
-      );
-    }
-  };
-};
+}
 exports.ImprovedNoise = ImprovedNoise;

package/dist/math/ImprovedNoise.mjs

@@ -1,5 +1,5 @@
-var ImprovedNoise = function() {
-  var p = [
+function init() {
+  const _p2 = [
     151,
     160,
     137,
@@ -258,45 +258,47 @@ var ImprovedNoise = function() {
     180
   ];
   for (let i = 0; i < 256; i++) {
-    p[256 + i] = p[i];
+    _p2[256 + i] = _p2[i];
   }
-  function fade(t) {
-    return t * t * t * (t * (t * 6 - 15) + 10);
+  return _p2;
+}
+const _p = /* @__PURE__ */ init();
+function fade(t) {
+  return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function lerp(t, a, b) {
+  return a + t * (b - a);
+}
+function grad(hash, x, y, z) {
+  const h = hash & 15;
+  const u = h < 8 ? x : y, v = h < 4 ? y : h == 12 || h == 14 ? x : z;
+  return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
+}
+class ImprovedNoise {
+  noise(x, y, z) {
+    const floorX = Math.floor(x), floorY = Math.floor(y), floorZ = Math.floor(z);
+    const X = floorX & 255, Y = floorY & 255, Z = floorZ & 255;
+    x -= floorX;
+    y -= floorY;
+    z -= floorZ;
+    const xMinus1 = x - 1, yMinus1 = y - 1, zMinus1 = z - 1;
+    const u = fade(x), v = fade(y), w = fade(z);
+    const A = _p[X] + Y, AA = _p[A] + Z, AB = _p[A + 1] + Z, B = _p[X + 1] + Y, BA = _p[B] + Z, BB = _p[B + 1] + Z;
+    return lerp(
+      w,
+      lerp(
+        v,
+        lerp(u, grad(_p[AA], x, y, z), grad(_p[BA], xMinus1, y, z)),
+        lerp(u, grad(_p[AB], x, yMinus1, z), grad(_p[BB], xMinus1, yMinus1, z))
+      ),
+      lerp(
+        v,
+        lerp(u, grad(_p[AA + 1], x, y, zMinus1), grad(_p[BA + 1], xMinus1, y, zMinus1)),
+        lerp(u, grad(_p[AB + 1], x, yMinus1, zMinus1), grad(_p[BB + 1], xMinus1, yMinus1, zMinus1))
+      )
+    );
   }
-  function lerp(t, a, b) {
-    return a + t * (b - a);
-  }
-  function grad(hash, x, y, z) {
-    var h = hash & 15;
-    var u = h < 8 ? x : y, v = h < 4 ? y : h == 12 || h == 14 ? x : z;
-    return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
-  }
-  return {
-    noise: function(x, y, z) {
-      var floorX = Math.floor(x), floorY = Math.floor(y), floorZ = Math.floor(z);
-      var X = floorX & 255, Y = floorY & 255, Z = floorZ & 255;
-      x -= floorX;
-      y -= floorY;
-      z -= floorZ;
-      var xMinus1 = x - 1, yMinus1 = y - 1, zMinus1 = z - 1;
-      var u = fade(x), v = fade(y), w = fade(z);
-      var A = p[X] + Y, AA = p[A] + Z, AB = p[A + 1] + Z, B = p[X + 1] + Y, BA = p[B] + Z, BB = p[B + 1] + Z;
-      return lerp(
-        w,
-        lerp(
-          v,
-          lerp(u, grad(p[AA], x, y, z), grad(p[BA], xMinus1, y, z)),
-          lerp(u, grad(p[AB], x, yMinus1, z), grad(p[BB], xMinus1, yMinus1, z))
-        ),
-        lerp(
-          v,
-          lerp(u, grad(p[AA + 1], x, y, zMinus1), grad(p[BA + 1], xMinus1, y, zMinus1)),
-          lerp(u, grad(p[AB + 1], x, yMinus1, zMinus1), grad(p[BB + 1], xMinus1, yMinus1, zMinus1))
-        )
-      );
-    }
-  };
-};
+}
 export {
   ImprovedNoise
 };