three-stdlib 2.22.10 → 2.23.1

package/dist/loaders/VRMLLoader.js

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