three-stdlib 2.22.10 → 2.23.1

package/dist/loaders/{VRMLLoader.mjs → VRMLLoader.cjs}

@@ -1,13 +1,15 @@
-import { Loader, LoaderUtils, FileLoader, Scene, Object3D, Group, Vector3, SphereGeometry, MeshBasicMaterial, BackSide, Mesh, PointsMaterial, Points, LineBasicMaterial, LineSegments, FrontSide, DoubleSide, MeshPhongMaterial, Color, RepeatWrapping, ClampToEdgeWrapping, DataTexture, Vector2, BufferGeometry, Float32BufferAttribute, BoxGeometry, ConeGeometry, CylinderGeometry, Quaternion, ShapeUtils, BufferAttribute, TextureLoader } from "three";
-import { createToken, Lexer, CstParser } from "chevrotain";
-class VRMLLoader extends Loader {
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const chevrotain = require("chevrotain");
+class VRMLLoader extends THREE.Loader {
   constructor(manager) {
     super(manager);
   }
   load(url, onLoad, onProgress, onError) {
     const scope = this;
-    const path = scope.path === "" ? LoaderUtils.extractUrlBase(url) : scope.path;
-    const loader = new FileLoader(scope.manager);
+    const path = scope.path === "" ? THREE.LoaderUtils.extractUrlBase(url) : scope.path;
+    const loader = new THREE.FileLoader(scope.manager);
     loader.setPath(scope.path);
     loader.setRequestHeader(scope.requestHeader);
     loader.setWithCredentials(scope.withCredentials);
@@ -47,11 +49,11 @@ class VRMLLoader extends Loader {
       return ast;
     }
     function createTokens() {
-      const RouteIdentifier = createToken({
+      const RouteIdentifier = chevrotain.createToken({
         name: "RouteIdentifier",
         pattern: /[^\x30-\x39\0-\x20\x22\x27\x23\x2b\x2c\x2d\x2e\x5b\x5d\x5c\x7b\x7d][^\0-\x20\x22\x27\x23\x2b\x2c\x2d\x2e\x5b\x5d\x5c\x7b\x7d]*[\.][^\x30-\x39\0-\x20\x22\x27\x23\x2b\x2c\x2d\x2e\x5b\x5d\x5c\x7b\x7d][^\0-\x20\x22\x27\x23\x2b\x2c\x2d\x2e\x5b\x5d\x5c\x7b\x7d]*/
       });
-      const Identifier = createToken({
+      const Identifier = chevrotain.createToken({
         name: "Identifier",
         pattern: /[^\x30-\x39\0-\x20\x22\x27\x23\x2b\x2c\x2d\x2e\x5b\x5d\x5c\x7b\x7d][^\0-\x20\x22\x27\x23\x2b\x2c\x2d\x2e\x5b\x5d\x5c\x7b\x7d]*/,
         longer_alt: RouteIdentifier
@@ -122,58 +124,58 @@ class VRMLLoader extends Loader {
         "Text"
         // Text must be placed at the end of the regex so there are no matches for TextureTransform and TextureCoordinate
       ];
-      const Version = createToken({
+      const Version = chevrotain.createToken({
         name: "Version",
         pattern: /#VRML.*/,
         longer_alt: Identifier
       });
-      const NodeName = createToken({
+      const NodeName = chevrotain.createToken({
         name: "NodeName",
         pattern: new RegExp(nodeTypes.join("|")),
         longer_alt: Identifier
       });
-      const DEF = createToken({
+      const DEF = chevrotain.createToken({
         name: "DEF",
         pattern: /DEF/,
         longer_alt: Identifier
       });
-      const USE = createToken({
+      const USE = chevrotain.createToken({
         name: "USE",
         pattern: /USE/,
         longer_alt: Identifier
       });
-      const ROUTE = createToken({
+      const ROUTE = chevrotain.createToken({
         name: "ROUTE",
         pattern: /ROUTE/,
         longer_alt: Identifier
       });
-      const TO = createToken({
+      const TO = chevrotain.createToken({
         name: "TO",
         pattern: /TO/,
         longer_alt: Identifier
       });
-      const StringLiteral = createToken({
+      const StringLiteral = chevrotain.createToken({
         name: "StringLiteral",
         pattern: /"(?:[^\\"\n\r]|\\[bfnrtv"\\/]|\\u[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F])*"/
       });
-      const HexLiteral = createToken({ name: "HexLiteral", pattern: /0[xX][0-9a-fA-F]+/ });
-      const NumberLiteral = createToken({ name: "NumberLiteral", pattern: /[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?/ });
-      const TrueLiteral = createToken({ name: "TrueLiteral", pattern: /TRUE/ });
-      const FalseLiteral = createToken({ name: "FalseLiteral", pattern: /FALSE/ });
-      const NullLiteral = createToken({ name: "NullLiteral", pattern: /NULL/ });
-      const LSquare = createToken({ name: "LSquare", pattern: /\[/ });
-      const RSquare = createToken({ name: "RSquare", pattern: /]/ });
-      const LCurly = createToken({ name: "LCurly", pattern: /{/ });
-      const RCurly = createToken({ name: "RCurly", pattern: /}/ });
-      const Comment = createToken({
+      const HexLiteral = chevrotain.createToken({ name: "HexLiteral", pattern: /0[xX][0-9a-fA-F]+/ });
+      const NumberLiteral = chevrotain.createToken({ name: "NumberLiteral", pattern: /[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?/ });
+      const TrueLiteral = chevrotain.createToken({ name: "TrueLiteral", pattern: /TRUE/ });
+      const FalseLiteral = chevrotain.createToken({ name: "FalseLiteral", pattern: /FALSE/ });
+      const NullLiteral = chevrotain.createToken({ name: "NullLiteral", pattern: /NULL/ });
+      const LSquare = chevrotain.createToken({ name: "LSquare", pattern: /\[/ });
+      const RSquare = chevrotain.createToken({ name: "RSquare", pattern: /]/ });
+      const LCurly = chevrotain.createToken({ name: "LCurly", pattern: /{/ });
+      const RCurly = chevrotain.createToken({ name: "RCurly", pattern: /}/ });
+      const Comment = chevrotain.createToken({
         name: "Comment",
         pattern: /#.*/,
-        group: Lexer.SKIPPED
+        group: chevrotain.Lexer.SKIPPED
       });
-      const WhiteSpace = createToken({
+      const WhiteSpace = chevrotain.createToken({
         name: "WhiteSpace",
         pattern: /[ ,\s]/,
-        group: Lexer.SKIPPED
+        group: chevrotain.Lexer.SKIPPED
       });
       const tokens = [
         WhiteSpace,
@@ -355,7 +357,7 @@ class VRMLLoader extends Loader {
     }
     function parseTree(tree2) {
       const nodes = tree2.nodes;
-      const scene2 = new Scene();
+      const scene2 = new THREE.Scene();
       for (let i = 0, l = nodes.length; i < l; i++) {
         const node = nodes[i];
         buildNodeMap(node);
@@ -363,7 +365,7 @@ class VRMLLoader extends Loader {
       for (let i = 0, l = nodes.length; i < l; i++) {
         const node = nodes[i];
         const object = getNode(node);
-        if (object instanceof Object3D)
+        if (object instanceof THREE.Object3D)
           scene2.add(object);
         if (node.name === "WorldInfo")
           scene2.userData.worldInfo = object;
@@ -501,7 +503,7 @@ class VRMLLoader extends Loader {
       return build;
     }
     function buildGroupingNode(node) {
-      const object = new Group();
+      const object = new THREE.Group();
       const fields = node.fields;
       for (let i = 0, l = fields.length; i < l; i++) {
         const field = fields[i];
@@ -520,7 +522,7 @@ class VRMLLoader extends Loader {
           case "collide":
             break;
           case "rotation":
-            const axis = new Vector3(fieldValues[0], fieldValues[1], fieldValues[2]);
+            const axis = new THREE.Vector3(fieldValues[0], fieldValues[1], fieldValues[2]);
             const angle = fieldValues[3];
             object.quaternion.setFromAxisAngle(axis, angle);
             break;
@@ -542,7 +544,7 @@ class VRMLLoader extends Loader {
       return object;
     }
     function buildBackgroundNode(node) {
-      const group = new Group();
+      const group = new THREE.Group();
       let groundAngle, groundColor;
       let skyAngle, skyColor;
       const fields = node.fields;
@@ -582,29 +584,29 @@ class VRMLLoader extends Loader {
       }
       const radius = 1e4;
       if (skyColor) {
-        const skyGeometry = new SphereGeometry(radius, 32, 16);
-        const skyMaterial = new MeshBasicMaterial({ fog: false, side: BackSide, depthWrite: false, depthTest: false });
+        const skyGeometry = new THREE.SphereGeometry(radius, 32, 16);
+        const skyMaterial = new THREE.MeshBasicMaterial({ fog: false, side: THREE.BackSide, depthWrite: false, depthTest: false });
         if (skyColor.length > 3) {
           paintFaces(skyGeometry, radius, skyAngle, toColorArray(skyColor), true);
           skyMaterial.vertexColors = true;
         } else {
           skyMaterial.color.setRGB(skyColor[0], skyColor[1], skyColor[2]);
         }
-        const sky = new Mesh(skyGeometry, skyMaterial);
+        const sky = new THREE.Mesh(skyGeometry, skyMaterial);
         group.add(sky);
       }
       if (groundColor) {
         if (groundColor.length > 0) {
-          const groundGeometry = new SphereGeometry(radius, 32, 16, 0, 2 * Math.PI, 0.5 * Math.PI, 1.5 * Math.PI);
-          const groundMaterial = new MeshBasicMaterial({
+          const groundGeometry = new THREE.SphereGeometry(radius, 32, 16, 0, 2 * Math.PI, 0.5 * Math.PI, 1.5 * Math.PI);
+          const groundMaterial = new THREE.MeshBasicMaterial({
             fog: false,
-            side: BackSide,
+            side: THREE.BackSide,
             vertexColors: true,
             depthWrite: false,
             depthTest: false
           });
           paintFaces(groundGeometry, radius, groundAngle, toColorArray(groundColor), false);
-          const ground = new Mesh(groundGeometry, groundMaterial);
+          const ground = new THREE.Mesh(groundGeometry, groundMaterial);
           group.add(ground);
         }
       }
@@ -613,7 +615,7 @@ class VRMLLoader extends Loader {
     }
     function buildShapeNode(node) {
       const fields = node.fields;
-      let material = new MeshBasicMaterial({ color: 0 });
+      let material = new THREE.MeshBasicMaterial({ color: 0 });
       let geometry;
       for (let i = 0, l = fields.length; i < l; i++) {
         const field = fields[i];
@@ -639,7 +641,7 @@ class VRMLLoader extends Loader {
       if (geometry && geometry.attributes.position) {
         const type = geometry._type;
         if (type === "points") {
-          const pointsMaterial = new PointsMaterial({ color: 16777215 });
+          const pointsMaterial = new THREE.PointsMaterial({ color: 16777215 });
           if (geometry.attributes.color !== void 0) {
             pointsMaterial.vertexColors = true;
           } else {
@@ -647,9 +649,9 @@ class VRMLLoader extends Loader {
               pointsMaterial.color.copy(material.emissive);
             }
           }
-          object = new Points(geometry, pointsMaterial);
+          object = new THREE.Points(geometry, pointsMaterial);
         } else if (type === "line") {
-          const lineMaterial = new LineBasicMaterial({ color: 16777215 });
+          const lineMaterial = new THREE.LineBasicMaterial({ color: 16777215 });
           if (geometry.attributes.color !== void 0) {
             lineMaterial.vertexColors = true;
           } else {
@@ -657,24 +659,24 @@ class VRMLLoader extends Loader {
               lineMaterial.color.copy(material.emissive);
             }
           }
-          object = new LineSegments(geometry, lineMaterial);
+          object = new THREE.LineSegments(geometry, lineMaterial);
         } else {
           if (geometry._solid !== void 0) {
-            material.side = geometry._solid ? FrontSide : DoubleSide;
+            material.side = geometry._solid ? THREE.FrontSide : THREE.DoubleSide;
           }
           if (geometry.attributes.color !== void 0) {
             material.vertexColors = true;
           }
-          object = new Mesh(geometry, material);
+          object = new THREE.Mesh(geometry, material);
         }
       } else {
-        object = new Object3D();
+        object = new THREE.Object3D();
         object.visible = false;
       }
       return object;
     }
     function buildAppearanceNode(node) {
-      let material = new MeshPhongMaterial();
+      let material = new THREE.MeshPhongMaterial();
       let transformData;
       const fields = node.fields;
       for (let i = 0, l = fields.length; i < l; i++) {
@@ -698,7 +700,7 @@ class VRMLLoader extends Loader {
               if (materialData.transparency > 0)
                 material.transparent = true;
             } else {
-              material = new MeshBasicMaterial({ color: 0 });
+              material = new THREE.MeshBasicMaterial({ color: 0 });
             }
             break;
           case "texture":
@@ -757,16 +759,16 @@ class VRMLLoader extends Loader {
           case "ambientIntensity":
             break;
           case "diffuseColor":
-            materialData.diffuseColor = new Color(fieldValues[0], fieldValues[1], fieldValues[2]);
+            materialData.diffuseColor = new THREE.Color(fieldValues[0], fieldValues[1], fieldValues[2]);
             break;
           case "emissiveColor":
-            materialData.emissiveColor = new Color(fieldValues[0], fieldValues[1], fieldValues[2]);
+            materialData.emissiveColor = new THREE.Color(fieldValues[0], fieldValues[1], fieldValues[2]);
             break;
           case "shininess":
             materialData.shininess = fieldValues[0];
             break;
           case "specularColor":
-            materialData.emissiveColor = new Color(fieldValues[0], fieldValues[1], fieldValues[2]);
+            materialData.emissiveColor = new THREE.Color(fieldValues[0], fieldValues[1], fieldValues[2]);
             break;
           case "transparency":
             materialData.transparency = fieldValues[0];
@@ -831,8 +833,8 @@ class VRMLLoader extends Loader {
     }
     function buildPixelTextureNode(node) {
       let texture;
-      let wrapS = RepeatWrapping;
-      let wrapT = RepeatWrapping;
+      let wrapS = THREE.RepeatWrapping;
+      let wrapT = THREE.RepeatWrapping;
       const fields = node.fields;
       for (let i = 0, l = fields.length; i < l; i++) {
         const field = fields[i];
@@ -854,17 +856,17 @@ class VRMLLoader extends Loader {
               data2[stride + 2] = color.b;
               data2[stride + 3] = color.a;
             }
-            texture = new DataTexture(data2, width, height);
+            texture = new THREE.DataTexture(data2, width, height);
             texture.needsUpdate = true;
             texture.__type = textureType;
             break;
           case "repeatS":
             if (fieldValues[0] === false)
-              wrapS = ClampToEdgeWrapping;
+              wrapS = THREE.ClampToEdgeWrapping;
             break;
           case "repeatT":
             if (fieldValues[0] === false)
-              wrapT = ClampToEdgeWrapping;
+              wrapT = THREE.ClampToEdgeWrapping;
             break;
           default:
             console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
@@ -879,8 +881,8 @@ class VRMLLoader extends Loader {
     }
     function buildImageTextureNode(node) {
       let texture;
-      let wrapS = RepeatWrapping;
-      let wrapT = RepeatWrapping;
+      let wrapS = THREE.RepeatWrapping;
+      let wrapT = THREE.RepeatWrapping;
       const fields = node.fields;
       for (let i = 0, l = fields.length; i < l; i++) {
         const field = fields[i];
@@ -894,11 +896,11 @@ class VRMLLoader extends Loader {
             break;
           case "repeatS":
             if (fieldValues[0] === false)
-              wrapS = ClampToEdgeWrapping;
+              wrapS = THREE.ClampToEdgeWrapping;
             break;
           case "repeatT":
             if (fieldValues[0] === false)
-              wrapT = ClampToEdgeWrapping;
+              wrapT = THREE.ClampToEdgeWrapping;
             break;
           default:
             console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
@@ -913,10 +915,10 @@ class VRMLLoader extends Loader {
     }
     function buildTextureTransformNode(node) {
       const transformData = {
-        center: new Vector2(),
-        rotation: new Vector2(),
-        scale: new Vector2(),
-        translation: new Vector2()
+        center: new THREE.Vector2(),
+        rotation: new THREE.Vector2(),
+        scale: new THREE.Vector2(),
+        translation: new THREE.Vector2()
       };
       const fields = node.fields;
       for (let i = 0, l = fields.length; i < l; i++) {
@@ -1038,7 +1040,7 @@ class VRMLLoader extends Loader {
       }
       if (coordIndex === void 0) {
         console.warn("THREE.VRMLLoader: Missing coordIndex.");
-        return new BufferGeometry();
+        return new THREE.BufferGeometry();
       }
       const triangulatedCoordIndex = triangulateFaceIndex(coordIndex, ccw);
       let colorAttribute;
@@ -1050,7 +1052,7 @@ class VRMLLoader extends Loader {
             const triangulatedColorIndex = triangulateFaceIndex(colorIndex, ccw);
             colorAttribute = computeAttributeFromIndexedData(triangulatedCoordIndex, triangulatedColorIndex, color, 3);
           } else {
-            colorAttribute = toNonIndexedAttribute(triangulatedCoordIndex, new Float32BufferAttribute(color, 3));
+            colorAttribute = toNonIndexedAttribute(triangulatedCoordIndex, new THREE.Float32BufferAttribute(color, 3));
           }
         } else {
           if (colorIndex && colorIndex.length > 0) {
@@ -1074,7 +1076,7 @@ class VRMLLoader extends Loader {
               3
             );
           } else {
-            normalAttribute = toNonIndexedAttribute(triangulatedCoordIndex, new Float32BufferAttribute(normal, 3));
+            normalAttribute = toNonIndexedAttribute(triangulatedCoordIndex, new THREE.Float32BufferAttribute(normal, 3));
           }
         } else {
           if (normalIndex && normalIndex.length > 0) {
@@ -1094,11 +1096,11 @@ class VRMLLoader extends Loader {
           const triangulatedTexCoordIndex = triangulateFaceIndex(texCoordIndex, ccw);
           uvAttribute = computeAttributeFromIndexedData(triangulatedCoordIndex, triangulatedTexCoordIndex, texCoord, 2);
         } else {
-          uvAttribute = toNonIndexedAttribute(triangulatedCoordIndex, new Float32BufferAttribute(texCoord, 2));
+          uvAttribute = toNonIndexedAttribute(triangulatedCoordIndex, new THREE.Float32BufferAttribute(texCoord, 2));
         }
       }
-      const geometry = new BufferGeometry();
-      const positionAttribute = toNonIndexedAttribute(triangulatedCoordIndex, new Float32BufferAttribute(coord, 3));
+      const geometry = new THREE.BufferGeometry();
+      const positionAttribute = toNonIndexedAttribute(triangulatedCoordIndex, new THREE.Float32BufferAttribute(coord, 3));
       geometry.setAttribute("position", positionAttribute);
       geometry.setAttribute("normal", normalAttribute);
       if (colorAttribute)
@@ -1153,7 +1155,7 @@ class VRMLLoader extends Loader {
             const expandedColorIndex = expandLineIndex(colorIndex);
             colorAttribute = computeAttributeFromIndexedData(expandedLineIndex, expandedColorIndex, color, 3);
           } else {
-            colorAttribute = toNonIndexedAttribute(expandedLineIndex, new Float32BufferAttribute(color, 3));
+            colorAttribute = toNonIndexedAttribute(expandedLineIndex, new THREE.Float32BufferAttribute(color, 3));
           }
         } else {
           if (colorIndex.length > 0) {
@@ -1166,8 +1168,8 @@ class VRMLLoader extends Loader {
           }
         }
       }
-      const geometry = new BufferGeometry();
-      const positionAttribute = toNonIndexedAttribute(expandedLineIndex, new Float32BufferAttribute(coord, 3));
+      const geometry = new THREE.BufferGeometry();
+      const positionAttribute = toNonIndexedAttribute(expandedLineIndex, new THREE.Float32BufferAttribute(coord, 3));
       geometry.setAttribute("position", positionAttribute);
       if (colorAttribute)
         geometry.setAttribute("color", colorAttribute);
@@ -1199,15 +1201,15 @@ class VRMLLoader extends Loader {
             break;
         }
       }
-      const geometry = new BufferGeometry();
-      geometry.setAttribute("position", new Float32BufferAttribute(coord, 3));
+      const geometry = new THREE.BufferGeometry();
+      geometry.setAttribute("position", new THREE.Float32BufferAttribute(coord, 3));
       if (color)
-        geometry.setAttribute("color", new Float32BufferAttribute(color, 3));
+        geometry.setAttribute("color", new THREE.Float32BufferAttribute(color, 3));
       geometry._type = "points";
       return geometry;
     }
     function buildBoxNode(node) {
-      const size = new Vector3(2, 2, 2);
+      const size = new THREE.Vector3(2, 2, 2);
       const fields = node.fields;
       for (let i = 0, l = fields.length; i < l; i++) {
         const field = fields[i];
@@ -1224,7 +1226,7 @@ class VRMLLoader extends Loader {
             break;
         }
       }
-      const geometry = new BoxGeometry(size.x, size.y, size.z);
+      const geometry = new THREE.BoxGeometry(size.x, size.y, size.z);
       return geometry;
     }
     function buildConeNode(node) {
@@ -1251,7 +1253,7 @@ class VRMLLoader extends Loader {
             break;
         }
       }
-      const geometry = new ConeGeometry(radius, height, 16, 1, openEnded);
+      const geometry = new THREE.ConeGeometry(radius, height, 16, 1, openEnded);
       return geometry;
     }
     function buildCylinderNode(node) {
@@ -1279,7 +1281,7 @@ class VRMLLoader extends Loader {
             break;
         }
       }
-      const geometry = new CylinderGeometry(radius, radius, height, 16, 1);
+      const geometry = new THREE.CylinderGeometry(radius, radius, height, 16, 1);
       return geometry;
     }
     function buildSphereNode(node) {
@@ -1298,7 +1300,7 @@ class VRMLLoader extends Loader {
             break;
         }
       }
-      const geometry = new SphereGeometry(radius, 16, 16);
+      const geometry = new THREE.SphereGeometry(radius, 16, 16);
       return geometry;
     }
     function buildElevationGridNode(node) {
@@ -1422,8 +1424,8 @@ class VRMLLoader extends Loader {
           }
         }
       }
-      const positionAttribute = toNonIndexedAttribute(indices, new Float32BufferAttribute(vertices, 3));
-      const uvAttribute = toNonIndexedAttribute(indices, new Float32BufferAttribute(uvs, 2));
+      const positionAttribute = toNonIndexedAttribute(indices, new THREE.Float32BufferAttribute(vertices, 3));
+      const uvAttribute = toNonIndexedAttribute(indices, new THREE.Float32BufferAttribute(uvs, 2));
       let colorAttribute;
       let normalAttribute;
       if (color) {
@@ -1442,9 +1444,9 @@ class VRMLLoader extends Loader {
               colors.push(r, g, b);
             }
           }
-          colorAttribute = new Float32BufferAttribute(colors, 3);
+          colorAttribute = new THREE.Float32BufferAttribute(colors, 3);
         } else {
-          colorAttribute = toNonIndexedAttribute(indices, new Float32BufferAttribute(colors, 3));
+          colorAttribute = toNonIndexedAttribute(indices, new THREE.Float32BufferAttribute(colors, 3));
         }
       }
       if (normal) {
@@ -1463,14 +1465,14 @@ class VRMLLoader extends Loader {
               normals.push(xn, yn, zn);
             }
           }
-          normalAttribute = new Float32BufferAttribute(normals, 3);
+          normalAttribute = new THREE.Float32BufferAttribute(normals, 3);
         } else {
-          normalAttribute = toNonIndexedAttribute(indices, new Float32BufferAttribute(normals, 3));
+          normalAttribute = toNonIndexedAttribute(indices, new THREE.Float32BufferAttribute(normals, 3));
         }
       } else {
         normalAttribute = computeNormalAttribute(indices, vertices, creaseAngle);
       }
-      const geometry = new BufferGeometry();
+      const geometry = new THREE.BufferGeometry();
       geometry.setAttribute("position", positionAttribute);
       geometry.setAttribute("normal", normalAttribute);
       geometry.setAttribute("uv", uvAttribute);
@@ -1532,11 +1534,11 @@ class VRMLLoader extends Loader {
       }
       const crossSectionClosed = crossSection[0] === crossSection[crossSection.length - 2] && crossSection[1] === crossSection[crossSection.length - 1];
       const vertices = [];
-      const spineVector = new Vector3();
-      const scaling = new Vector3();
-      const axis = new Vector3();
-      const vertex = new Vector3();
-      const quaternion = new Quaternion();
+      const spineVector = new THREE.Vector3();
+      const scaling = new THREE.Vector3();
+      const axis = new THREE.Vector3();
+      const vertex = new THREE.Vector3();
+      const quaternion = new THREE.Quaternion();
       for (let i = 0, j = 0, o = 0, il = spine.length; i < il; i += 3, j += 2, o += 4) {
         spineVector.fromArray(spine, i);
         scaling.x = scale ? scale[j + 0] : 1;
@@ -1582,9 +1584,9 @@ class VRMLLoader extends Loader {
       if (beginCap === true || endCap === true) {
         const contour = [];
         for (let i = 0, l = crossSection.length; i < l; i += 2) {
-          contour.push(new Vector2(crossSection[i], crossSection[i + 1]));
+          contour.push(new THREE.Vector2(crossSection[i], crossSection[i + 1]));
         }
-        const faces = ShapeUtils.triangulateShape(contour, []);
+        const faces = THREE.ShapeUtils.triangulateShape(contour, []);
         const capIndices = [];
         for (let i = 0, l = faces.length; i < l; i++) {
           const face = faces[i];
@@ -1618,9 +1620,9 @@ class VRMLLoader extends Loader {
           }
         }
       }
-      const positionAttribute = toNonIndexedAttribute(indices, new Float32BufferAttribute(vertices, 3));
+      const positionAttribute = toNonIndexedAttribute(indices, new THREE.Float32BufferAttribute(vertices, 3));
       const normalAttribute = computeNormalAttribute(indices, vertices, creaseAngle);
-      const geometry = new BufferGeometry();
+      const geometry = new THREE.BufferGeometry();
       geometry.setAttribute("position", positionAttribute);
       geometry.setAttribute("normal", normalAttribute);
       geometry._solid = solid;
@@ -1635,7 +1637,7 @@ class VRMLLoader extends Loader {
     function parseFieldChildren(children, owner) {
       for (let i = 0, l = children.length; i < l; i++) {
         const object = getNode(children[i]);
-        if (object instanceof Object3D)
+        if (object instanceof THREE.Object3D)
           owner.add(object);
       }
     }
@@ -1710,12 +1712,12 @@ class VRMLLoader extends Loader {
       }
       return triangulatedData;
     }
-    const vA = new Vector3();
-    const vB = new Vector3();
-    const vC = new Vector3();
-    const uvA = new Vector2();
-    const uvB = new Vector2();
-    const uvC = new Vector2();
+    const vA = new THREE.Vector3();
+    const vB = new THREE.Vector3();
+    const vC = new THREE.Vector3();
+    const uvA = new THREE.Vector2();
+    const uvB = new THREE.Vector2();
+    const uvC = new THREE.Vector2();
     function computeAttributeFromIndexedData(coordIndex, index, data2, itemSize) {
       const array = [];
       for (let i = 0, l = coordIndex.length; i < l; i += 3) {
@@ -1738,7 +1740,7 @@ class VRMLLoader extends Loader {
           array.push(vC.x, vC.y, vC.z);
         }
       }
-      return new Float32BufferAttribute(array, itemSize);
+      return new THREE.Float32BufferAttribute(array, itemSize);
     }
     function computeAttributeFromFaceData(index, faceData) {
       const array = [];
@@ -1748,7 +1750,7 @@ class VRMLLoader extends Loader {
         array.push(vA.x, vA.y, vA.z);
         array.push(vA.x, vA.y, vA.z);
       }
-      return new Float32BufferAttribute(array, 3);
+      return new THREE.Float32BufferAttribute(array, 3);
     }
     function computeAttributeFromLineData(index, lineData) {
       const array = [];
@@ -1757,7 +1759,7 @@ class VRMLLoader extends Loader {
         array.push(vA.x, vA.y, vA.z);
         array.push(vA.x, vA.y, vA.z);
       }
-      return new Float32BufferAttribute(array, 3);
+      return new THREE.Float32BufferAttribute(array, 3);
     }
     function toNonIndexedAttribute(indices, attribute) {
       const array = attribute.array;
@@ -1770,10 +1772,10 @@ class VRMLLoader extends Loader {
           array2[index2++] = array[index++];
         }
       }
-      return new Float32BufferAttribute(array2, itemSize);
+      return new THREE.Float32BufferAttribute(array2, itemSize);
     }
-    const ab = new Vector3();
-    const cb = new Vector3();
+    const ab = new THREE.Vector3();
+    const cb = new THREE.Vector3();
     function computeNormalAttribute(index, coord, creaseAngle) {
       const faces = [];
       const vertexNormals = {};
@@ -1814,10 +1816,10 @@ class VRMLLoader extends Loader {
         normals.push(nB.x, nB.y, nB.z);
         normals.push(nC.x, nC.y, nC.z);
       }
-      return new Float32BufferAttribute(normals, 3);
+      return new THREE.Float32BufferAttribute(normals, 3);
     }
     function weightedNormal(normals, vector, creaseAngle) {
-      const normal = new Vector3();
+      const normal = new THREE.Vector3();
       if (creaseAngle === 0) {
         normal.copy(vector);
       } else {
@@ -1832,7 +1834,7 @@ class VRMLLoader extends Loader {
     function toColorArray(colors) {
       const array = [];
       for (let i = 0, l = colors.length; i < l; i += 3) {
-        array.push(new Color(colors[i], colors[i + 1], colors[i + 2]));
+        array.push(new THREE.Color(colors[i], colors[i + 1], colors[i + 2]));
       }
       return array;
     }
@@ -1842,15 +1844,15 @@ class VRMLLoader extends Loader {
       for (let i = 0, l = colors.length; i < l; i++) {
         let angle = i === 0 ? 0 : angles[i - 1];
         angle = topDown === true ? angle : startAngle - angle;
-        const point = new Vector3();
+        const point = new THREE.Vector3();
         point.setFromSphericalCoords(radius, angle, 0);
         thresholds.push(point);
       }
       const indices = geometry.index;
       const positionAttribute = geometry.attributes.position;
-      const colorAttribute = new BufferAttribute(new Float32Array(geometry.attributes.position.count * 3), 3);
-      const position = new Vector3();
-      const color = new Color();
+      const colorAttribute = new THREE.BufferAttribute(new Float32Array(geometry.attributes.position.count * 3), 3);
+      const position = new THREE.Vector3();
+      const color = new THREE.Color();
       for (let i = 0; i < indices.count; i++) {
         const index = indices.getX(i);
         position.fromBufferAttribute(positionAttribute, index);
@@ -1880,7 +1882,7 @@ class VRMLLoader extends Loader {
       }
       geometry.setAttribute("color", colorAttribute);
     }
-    const textureLoader = new TextureLoader(this.manager);
+    const textureLoader = new THREE.TextureLoader(this.manager);
     textureLoader.setPath(this.resourcePath || path).setCrossOrigin(this.crossOrigin);
     if (data.indexOf("#VRML V2.0") === -1) {
       throw Error("THREE.VRMLLexer: Version of VRML asset not supported.");
@@ -1892,7 +1894,7 @@ class VRMLLoader extends Loader {
 }
 class VRMLLexer {
   constructor(tokens) {
-    this.lexer = new Lexer(tokens);
+    this.lexer = new chevrotain.Lexer(tokens);
   }
   lex(inputText) {
     const lexingResult = this.lexer.tokenize(inputText);
@@ -1903,7 +1905,7 @@ class VRMLLexer {
     return lexingResult;
   }
 }
-class VRMLParser extends CstParser {
+class VRMLParser extends chevrotain.CstParser {
   constructor(tokenVocabulary) {
     super(tokenVocabulary);
     const $ = this;
@@ -2091,7 +2093,7 @@ class Face {
     this.a = a;
     this.b = b;
     this.c = c;
-    this.normal = new Vector3();
+    this.normal = new THREE.Vector3();
   }
 }
 const TEXTURE_TYPE = {
@@ -2100,6 +2102,4 @@ const TEXTURE_TYPE = {
   RGB: 3,
   RGBA: 4
 };
-export {
-  VRMLLoader
-};
+exports.VRMLLoader = VRMLLoader;