three-stdlib 2.22.8 → 2.22.10

package/dist/loaders/STLLoader.d.ts

@@ -1,4 +1,5 @@
-import { BufferGeometry, Loader, LoadingManager } from 'three'
+import { BufferGeometry, LoadingManager } from 'three'
+import { Loader } from '../types/Loader'
 
 export class STLLoader extends Loader {
   constructor(manager?: LoadingManager)

package/dist/loaders/SVGLoader.d.ts

@@ -1,4 +1,5 @@
-import { Loader, LoadingManager, ShapePath, BufferGeometry, Vector3, Shape } from 'three'
+import { LoadingManager, ShapePath, BufferGeometry, Vector3, Shape } from 'three'
+import { Loader } from '../types/Loader'
 
 export interface SVGResultPaths extends ShapePath {
   userData?:

package/dist/loaders/TDSLoader.d.ts

@@ -1,4 +1,5 @@
-import { Color, Group, Loader, LoadingManager, Material, Mesh, Texture } from 'three'
+import { Color, Group, LoadingManager, Material, Mesh, Texture } from 'three'
+import { Loader } from '../types/Loader'
 
 export class TDSLoader extends Loader {
   constructor(manager?: LoadingManager)

package/dist/loaders/TTFLoader.d.ts

@@ -1,4 +1,5 @@
-import { Loader, LoadingManager } from 'three'
+import { LoadingManager } from 'three'
+import { Loader } from '../types/Loader'
 
 export class TTFLoader extends Loader {
   constructor(manager?: LoadingManager)

package/dist/loaders/TiltLoader.d.ts

@@ -1,4 +1,5 @@
-import { Loader, LoadingManager, Group } from 'three'
+import { LoadingManager, Group } from 'three'
+import { Loader } from '../types/Loader'
 
 export class TiltLoader extends Loader {
   constructor(manager?: LoadingManager)

package/dist/loaders/TiltLoader.js

@@ -284,7 +284,9 @@ const common = {
 const shaders = () => ({
   Light: {
     uniforms: {
-      mainTex: { value: new THREE.TextureLoader().setPath("./textures/tiltbrush/").loader.load("Light.webp") },
+      mainTex: {
+        value: /* @__PURE__ */ new THREE.TextureLoader().setPath("./textures/tiltbrush/").loader.load("Light.webp")
+      },
       alphaTest: { value: 0.067 },
       emission_gain: { value: 0.45 },
       alpha: { value: 1 }

package/dist/loaders/TiltLoader.mjs

@@ -282,7 +282,9 @@ const common = {
 const shaders = () => ({
   Light: {
     uniforms: {
-      mainTex: { value: new TextureLoader().setPath("./textures/tiltbrush/").loader.load("Light.webp") },
+      mainTex: {
+        value: /* @__PURE__ */ new TextureLoader().setPath("./textures/tiltbrush/").loader.load("Light.webp")
+      },
       alphaTest: { value: 0.067 },
       emission_gain: { value: 0.45 },
       alpha: { value: 1 }

package/dist/loaders/VOXLoader.d.ts

@@ -1,4 +1,5 @@
-import { Data3DTexture, Mesh, Loader, LoadingManager } from 'three'
+import { Texture, Mesh, LoadingManager } from 'three'
+import { Loader } from '../types/Loader'
 
 export interface Chunk {
   palette: number[]
@@ -23,6 +24,7 @@ export class VOXMesh extends Mesh {
   constructor(chunk: Chunk)
 }
 
-export class VOXData3DTexture extends Data3DTexture {
+// Data3DTexture
+export class VOXData3DTexture extends Texture {
   constructor(chunk: Chunk)
 }

package/dist/loaders/VRMLLoader.d.ts

@@ -1,4 +1,5 @@
-import { Scene, Loader, LoadingManager } from 'three'
+import { Scene, LoadingManager } from 'three'
+import { Loader } from '../types/Loader'
 
 export class VRMLLoader extends Loader {
   constructor(manager?: LoadingManager)

package/dist/loaders/VRMLoader.d.ts

@@ -0,0 +1,20 @@
+import { LoadingManager } from 'three'
+import { Loader } from '../types/Loader'
+
+import { GLTFLoader, GLTF } from './GLTFLoader'
+import { DRACOLoader } from './DRACOLoader'
+
+export class VRMLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  gltfLoader: GLTFLoader
+
+  load(
+    url: string,
+    onLoad: (scene: GLTF) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<GLTF>
+  parse(gltf: GLTF, onLoad: (scene: GLTF) => void): void
+  setDRACOLoader(dracoLoader: DRACOLoader): this
+}

package/dist/loaders/VTKLoader.d.ts

@@ -1,4 +1,5 @@
-import { BufferGeometry, Loader, LoadingManager } from 'three'
+import { BufferGeometry, LoadingManager } from 'three'
+import { Loader } from '../types/Loader'
 
 export class VTKLoader extends Loader {
   constructor(manager?: LoadingManager)

package/dist/loaders/XLoader.d.ts

@@ -0,0 +1,20 @@
+import { Mesh, LoadingManager } from 'three'
+import { Loader } from '../types/Loader'
+
+export interface XResult {
+  animations: object[]
+  models: Mesh[]
+}
+
+export class XLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (object: XResult) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<XResult>
+  parse(data: ArrayBuffer | string, onLoad: (object: object) => void): object
+}

package/dist/loaders/XLoader.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
-var XLoader = function() {
+var XLoader = /* @__PURE__ */ function() {
   var classCallCheck = function(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
       throw new TypeError("Cannot call a class as a function");

package/dist/loaders/XLoader.mjs

@@ -1,5 +1,5 @@
 import { Vector3, Quaternion, Loader, TextureLoader, FileLoader, LoaderUtils, Matrix4, Bone, BufferGeometry, Float32BufferAttribute, Uint16BufferAttribute, MeshPhongMaterial, FrontSide, Vector2, SkinnedMesh, Mesh, Skeleton, AnimationClip, AnimationMixer } from "three";
-var XLoader = function() {
+var XLoader = /* @__PURE__ */ function() {
   var classCallCheck = function(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
       throw new TypeError("Cannot call a class as a function");

package/dist/loaders/XYZLoader.d.ts

@@ -1,4 +1,5 @@
-import { BufferGeometry, Loader, LoadingManager } from 'three'
+import { BufferGeometry, LoadingManager } from 'three'
+import { Loader } from '../types/Loader'
 
 export class XYZLoader extends Loader {
   constructor(manager?: LoadingManager)

package/dist/loaders/lwo/IFFParser.js

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const THREE = require("three");
 const LWO2Parser = require("./LWO2Parser.js");
 const LWO3Parser = require("./LWO3Parser.js");
-function IFFParser() {
-  this.debugger = new Debugger();
-}
-IFFParser.prototype = {
-  constructor: IFFParser,
-  parse: function(buffer) {
+class IFFParser {
+  constructor() {
+    this.debugger = new Debugger();
+  }
+  parse(buffer) {
     this.reader = new DataViewReader(buffer);
     this.tree = {
       materials: {},
@@ -33,7 +31,7 @@ IFFParser.prototype = {
     this.debugger.offset = this.reader.offset;
     this.debugger.closeForms();
     return this.tree;
-  },
+  }
   parseTopForm() {
     this.debugger.offset = this.reader.offset;
     var topForm = this.reader.getIDTag();
@@ -54,7 +52,7 @@ IFFParser.prototype = {
     this.debugger.nodeID = type;
     this.debugger.log();
     return;
-  },
+  }
   ///
   // FORM PARSING METHODS
   ///
@@ -185,7 +183,7 @@ IFFParser.prototype = {
     this.debugger.node = 0;
     this.debugger.nodeID = type;
     this.debugger.log();
-  },
+  }
   setupForm(type, length) {
     if (!this.currentForm)
       this.currentForm = this.currentNode;
@@ -198,15 +196,15 @@ IFFParser.prototype = {
       console.warn("LWOLoader: form already exists on parent: ", type, this.currentForm);
       this.currentForm = this.currentForm[type];
     }
-  },
+  }
   skipForm(length) {
     this.reader.skip(length - 4);
-  },
+  }
   parseUnknownForm(type, length) {
     console.warn("LWOLoader: unknown FORM encountered: " + type, length);
     printBuffer(this.reader.dv.buffer, this.reader.offset, length - 4);
     this.reader.skip(length - 4);
-  },
+  }
   parseSurfaceForm(length) {
     this.reader.skip(8);
     var name = this.reader.getString();
@@ -224,7 +222,7 @@ IFFParser.prototype = {
     this.parentForm = this.tree.materials;
     this.currentForm = surface;
     this.currentFormEnd = this.reader.offset + length;
-  },
+  }
   parseSurfaceLwo2(length) {
     var name = this.reader.getString();
     var surface = {
@@ -240,7 +238,7 @@ IFFParser.prototype = {
     this.parentForm = this.tree.materials;
     this.currentForm = surface;
     this.currentFormEnd = this.reader.offset + length;
-  },
+  }
   parseSubNode(length) {
     this.reader.skip(8);
     var name = this.reader.getString();
@@ -250,20 +248,20 @@ IFFParser.prototype = {
     this.currentForm = node;
     this.currentNode = node;
     this.currentFormEnd = this.reader.offset + length;
-  },
+  }
   // collect attributes from all nodes at the top level of a surface
   parseConnections(length) {
     this.currentFormEnd = this.reader.offset + length;
     this.parentForm = this.currentForm;
     this.currentForm = this.currentSurface.connections;
-  },
+  }
   // surface node attribute data, e.g. specular, roughness etc
   parseEntryForm(length) {
     this.reader.skip(8);
     var name = this.reader.getString();
     this.currentForm = this.currentNode.attributes;
     this.setupForm(name, length);
-  },
+  }
   // parse values from material - doesn't match up to other LWO3 data types
   // sub form of entry form
   parseValueForm() {
@@ -280,13 +278,13 @@ IFFParser.prototype = {
       this.reader.skip(24);
       this.currentForm.value = this.reader.getFloat64Array(3);
     }
-  },
+  }
   // holds various data about texture node image state
   // Data other thanmipMapLevel unknown
   parseImageStateForm() {
     this.reader.skip(8);
     this.currentForm.mipMapLevel = this.reader.getFloat32();
-  },
+  }
   // LWO2 style image data node OR LWO3 textures defined at top level in editor (not as SURF node)
   parseImageMap(length) {
     this.currentFormEnd = this.reader.offset + length;
@@ -297,7 +295,7 @@ IFFParser.prototype = {
     this.currentForm.maps.push(map);
     this.currentForm = map;
     this.reader.skip(10);
-  },
+  }
   parseTextureNodeAttribute(type) {
     this.reader.skip(28);
     this.reader.skip(20);
@@ -325,11 +323,11 @@ IFFParser.prototype = {
         break;
     }
     this.reader.skip(2);
-  },
+  }
   // ENVL forms are currently ignored
   parseEnvelope(length) {
     this.reader.skip(length - 4);
-  },
+  }
   ///
   // CHUNK PARSING METHODS
   ///
@@ -351,7 +349,7 @@ IFFParser.prototype = {
     };
     this.tree.textures.push(texture);
     this.currentForm = texture;
-  },
+  }
   parseClipLwo2(length) {
     var texture = {
       index: this.reader.getUint32(),
@@ -370,17 +368,17 @@ IFFParser.prototype = {
     }
     this.tree.textures.push(texture);
     this.currentForm = texture;
-  },
+  }
   parseImage() {
     this.reader.skip(8);
     this.currentForm.fileName = this.reader.getString();
-  },
+  }
   parseXVAL(type, length) {
     var endOffset = this.reader.offset + length - 4;
     this.reader.skip(8);
     this.currentForm[type] = this.reader.getFloat32();
     this.reader.setOffset(endOffset);
-  },
+  }
   parseXVAL3(type, length) {
     var endOffset = this.reader.offset + length - 4;
     this.reader.skip(8);
@@ -390,7 +388,7 @@ IFFParser.prototype = {
       z: this.reader.getFloat32()
     };
     this.reader.setOffset(endOffset);
-  },
+  }
   // Tags associated with an object
   // OTAG { type[ID4], tag-string[S0] }
   parseObjectTag() {
@@ -399,7 +397,7 @@ IFFParser.prototype = {
     this.tree.objectTags[this.reader.getIDTag()] = {
       tagString: this.reader.getString()
     };
-  },
+  }
   // Signals the start of a new layer. All the data chunks which follow will be included in this layer until another layer chunk is encountered.
   // LAYR: number[U2], flags[U2], pivot[VEC12], name[S0], parent[U2]
   parseLayer(length) {
@@ -415,16 +413,16 @@ IFFParser.prototype = {
     this.currentLayer = layer;
     var parsedLength = 16 + stringOffset(this.currentLayer.name);
     this.currentLayer.parent = parsedLength < length ? this.reader.getUint16() : -1;
-  },
+  }
   // VEC12 * ( F4 + F4 + F4 ) array of x,y,z vectors
   // Converting from left to right handed coordinate system:
   // x -> -x and switch material FrontSide -> BackSide
   parsePoints(length) {
     this.currentPoints = [];
-    for (let i = 0; i < length / 4; i += 3) {
+    for (var i = 0; i < length / 4; i += 3) {
       this.currentPoints.push(this.reader.getFloat32(), this.reader.getFloat32(), -this.reader.getFloat32());
     }
-  },
+  }
   // parse VMAP or VMAD
   // Associates a set of floating-point vectors with a set of points.
   // VMAP: { type[ID4], dimension[U2], name[S0], ( vert[VX], value[F4] # dimension ) * }
@@ -467,7 +465,7 @@ IFFParser.prototype = {
         console.warn("LWOLoader: unknown vertex map type: " + type);
         this.reader.skip(remainingLength);
     }
-  },
+  }
   parseUVMapping(name, finalOffset, discontinuous) {
     var uvIndices = [];
     var polyIndices = [];
@@ -494,7 +492,7 @@ IFFParser.prototype = {
         uvs
       };
     }
-  },
+  }
   parseMorphTargets(name, finalOffset, type) {
     var indices = [];
     var points = [];
@@ -510,7 +508,7 @@ IFFParser.prototype = {
       points,
       type
     };
-  },
+  }
   // A list of polygons for the current layer.
   // POLS { type[ID4], ( numvert+flags[U2], vert[VX] # numvert ) * }
   parsePolygonList(length) {
@@ -522,7 +520,7 @@ IFFParser.prototype = {
       var numverts = this.reader.getUint16();
       numverts = numverts & 1023;
       polygonDimensions.push(numverts);
-      for (let j = 0; j < numverts; j++)
+      for (var j = 0; j < numverts; j++)
         indices.push(this.reader.getVariableLengthIndex());
     }
     var geometryData = {
@@ -536,23 +534,23 @@ IFFParser.prototype = {
     else if (polygonDimensions[0] === 2)
       geometryData.type = "lines";
     this.currentLayer.geometry = geometryData;
-  },
+  }
   // Lists the tag strings that can be associated with polygons by the PTAG chunk.
   // TAGS { tag-string[S0] * }
   parseTagStrings(length) {
     this.tree.tags = this.reader.getStringArray(length);
-  },
+  }
   // Associates tags of a given type with polygons in the most recent POLS chunk.
   // PTAG { type[ID4], ( poly[VX], tag[U2] ) * }
   parsePolygonTagMapping(length) {
     var finalOffset = this.reader.offset + length;
     var type = this.reader.getIDTag();
-    if (type === "SURF") {
+    if (type === "SURF")
       this.parseMaterialIndices(finalOffset);
-    } else {
+    else {
       this.reader.skip(length - 4);
     }
-  },
+  }
   parseMaterialIndices(finalOffset) {
     this.currentLayer.geometry.materialIndices = [];
     while (this.reader.offset < finalOffset) {
@@ -560,87 +558,88 @@ IFFParser.prototype = {
       var materialIndex = this.reader.getUint16();
       this.currentLayer.geometry.materialIndices.push(polygonIndex, materialIndex);
     }
-  },
+  }
   parseUnknownCHUNK(blockID, length) {
     console.warn("LWOLoader: unknown chunk type: " + blockID + " length: " + length);
     var data = this.reader.getString(length);
     this.currentForm[blockID] = data;
   }
-};
-function DataViewReader(buffer) {
-  this.dv = new DataView(buffer);
-  this.offset = 0;
 }
-DataViewReader.prototype = {
-  constructor: DataViewReader,
-  size: function() {
+class DataViewReader {
+  constructor(buffer) {
+    this.dv = new DataView(buffer);
+    this.offset = 0;
+    this._textDecoder = new TextDecoder();
+    this._bytes = new Uint8Array(buffer);
+  }
+  size() {
     return this.dv.buffer.byteLength;
-  },
+  }
   setOffset(offset) {
     if (offset > 0 && offset < this.dv.buffer.byteLength) {
       this.offset = offset;
     } else {
       console.error("LWOLoader: invalid buffer offset");
     }
-  },
-  endOfFile: function() {
+  }
+  endOfFile() {
     if (this.offset >= this.size())
       return true;
     return false;
-  },
-  skip: function(length) {
+  }
+  skip(length) {
     this.offset += length;
-  },
-  getUint8: function() {
+  }
+  getUint8() {
     var value = this.dv.getUint8(this.offset);
     this.offset += 1;
     return value;
-  },
-  getUint16: function() {
+  }
+  getUint16() {
     var value = this.dv.getUint16(this.offset);
     this.offset += 2;
     return value;
-  },
-  getInt32: function() {
+  }
+  getInt32() {
     var value = this.dv.getInt32(this.offset, false);
     this.offset += 4;
     return value;
-  },
-  getUint32: function() {
+  }
+  getUint32() {
     var value = this.dv.getUint32(this.offset, false);
     this.offset += 4;
     return value;
-  },
-  getUint64: function() {
+  }
+  getUint64() {
     var low, high;
     high = this.getUint32();
     low = this.getUint32();
     return high * 4294967296 + low;
-  },
-  getFloat32: function() {
+  }
+  getFloat32() {
     var value = this.dv.getFloat32(this.offset, false);
     this.offset += 4;
     return value;
-  },
-  getFloat32Array: function(size) {
+  }
+  getFloat32Array(size) {
     var a = [];
-    for (let i = 0; i < size; i++) {
+    for (var i = 0; i < size; i++) {
       a.push(this.getFloat32());
     }
     return a;
-  },
-  getFloat64: function() {
+  }
+  getFloat64() {
     var value = this.dv.getFloat64(this.offset, this.littleEndian);
     this.offset += 8;
     return value;
-  },
-  getFloat64Array: function(size) {
+  }
+  getFloat64Array(size) {
     var a = [];
-    for (let i = 0; i < size; i++) {
+    for (var i = 0; i < size; i++) {
       a.push(this.getFloat64());
     }
     return a;
-  },
+  }
   // get variable-length index data type
   // VX ::= index[U2] | (index + 0xFF000000)[U4]
   // If the index value is less than 65,280 (0xFF00),then VX === U2
@@ -653,50 +652,45 @@ DataViewReader.prototype = {
       return this.getUint8() * 65536 + this.getUint8() * 256 + this.getUint8();
     }
     return firstByte * 256 + this.getUint8();
-  },
+  }
   // An ID tag is a sequence of 4 bytes containing 7-bit ASCII values
   getIDTag() {
     return this.getString(4);
-  },
-  getString: function(size) {
+  }
+  getString(size) {
     if (size === 0)
       return;
-    var a = [];
+    const start = this.offset;
+    let result;
+    let length;
     if (size) {
-      for (let i = 0; i < size; i++) {
-        a[i] = this.getUint8();
-      }
+      length = size;
+      result = this._textDecoder.decode(new Uint8Array(this.dv.buffer, start, size));
     } else {
-      var currentChar;
-      var len = 0;
-      while (currentChar !== 0) {
-        currentChar = this.getUint8();
-        if (currentChar !== 0)
-          a.push(currentChar);
-        len++;
-      }
-      if (!isEven(len + 1))
-        this.getUint8();
+      length = this._bytes.indexOf(0, start) - start;
+      result = this._textDecoder.decode(new Uint8Array(this.dv.buffer, start, length));
+      length++;
+      length += length % 2;
     }
-    return THREE.LoaderUtils.decodeText(new Uint8Array(a));
-  },
-  getStringArray: function(size) {
+    this.skip(length);
+    return result;
+  }
+  getStringArray(size) {
     var a = this.getString(size);
     a = a.split("\0");
     return a.filter(Boolean);
   }
-};
-function Debugger() {
-  this.active = false;
-  this.depth = 0;
-  this.formList = [];
 }
-Debugger.prototype = {
-  constructor: Debugger,
-  enable: function() {
+class Debugger {
+  constructor() {
+    this.active = false;
+    this.depth = 0;
+    this.formList = [];
+  }
+  enable() {
     this.active = true;
-  },
-  log: function() {
+  }
+  log() {
     if (!this.active)
       return;
     var nodeType;
@@ -724,11 +718,11 @@ Debugger.prototype = {
       this.formList.push(this.dataOffset + this.length);
     }
     this.skipped = false;
-  },
-  closeForms: function() {
+  }
+  closeForms() {
     if (!this.active)
       return;
-    for (let i = this.formList.length - 1; i >= 0; i--) {
+    for (var i = this.formList.length - 1; i >= 0; i--) {
       if (this.offset >= this.formList[i]) {
         this.depth -= 1;
         console.log("| ".repeat(this.depth) + "}");
@@ -736,7 +730,7 @@ Debugger.prototype = {
       }
     }
   }
-};
+}
 function isEven(num) {
   return num % 2;
 }
@@ -744,6 +738,6 @@ function stringOffset(string) {
   return string.length + 1 + (isEven(string.length + 1) ? 1 : 0);
 }
 function printBuffer(buffer, from, to) {
-  console.log(THREE.LoaderUtils.decodeText(new Uint8Array(buffer, from, to)));
+  console.log(new TextDecoder().decode(new Uint8Array(buffer, from, to)));
 }
 exports.IFFParser = IFFParser;