three-stdlib 2.25.0 → 2.25.1

package/loaders/VRMLLoader.cjs

@@ -1,2105 +0,0 @@
-"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 === "" ? 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);
-    loader.load(
-      url,
-      function(text) {
-        try {
-          onLoad(scope.parse(text, path));
-        } catch (e) {
-          if (onError) {
-            onError(e);
-          } else {
-            console.error(e);
-          }
-          scope.manager.itemError(url);
-        }
-      },
-      onProgress,
-      onError
-    );
-  }
-  parse(data, path) {
-    const nodeMap = {};
-    function generateVRMLTree(data2) {
-      const tokenData = createTokens();
-      const lexer = new VRMLLexer(tokenData.tokens);
-      const parser = new VRMLParser(tokenData.tokenVocabulary);
-      const visitor = createVisitor(parser.getBaseCstVisitorConstructor());
-      const lexingResult = lexer.lex(data2);
-      parser.input = lexingResult.tokens;
-      const cstOutput = parser.vrml();
-      if (parser.errors.length > 0) {
-        console.error(parser.errors);
-        throw Error("THREE.VRMLLoader: Parsing errors detected.");
-      }
-      const ast = visitor.visit(cstOutput);
-      return ast;
-    }
-    function createTokens() {
-      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 = 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
-      });
-      const nodeTypes = [
-        "Anchor",
-        "Billboard",
-        "Collision",
-        "Group",
-        "Transform",
-        // grouping nodes
-        "Inline",
-        "LOD",
-        "Switch",
-        // special groups
-        "AudioClip",
-        "DirectionalLight",
-        "PointLight",
-        "Script",
-        "Shape",
-        "Sound",
-        "SpotLight",
-        "WorldInfo",
-        // common nodes
-        "CylinderSensor",
-        "PlaneSensor",
-        "ProximitySensor",
-        "SphereSensor",
-        "TimeSensor",
-        "TouchSensor",
-        "VisibilitySensor",
-        // sensors
-        "Box",
-        "Cone",
-        "Cylinder",
-        "ElevationGrid",
-        "Extrusion",
-        "IndexedFaceSet",
-        "IndexedLineSet",
-        "PointSet",
-        "Sphere",
-        // geometries
-        "Color",
-        "Coordinate",
-        "Normal",
-        "TextureCoordinate",
-        // geometric properties
-        "Appearance",
-        "FontStyle",
-        "ImageTexture",
-        "Material",
-        "MovieTexture",
-        "PixelTexture",
-        "TextureTransform",
-        // appearance
-        "ColorInterpolator",
-        "CoordinateInterpolator",
-        "NormalInterpolator",
-        "OrientationInterpolator",
-        "PositionInterpolator",
-        "ScalarInterpolator",
-        // interpolators
-        "Background",
-        "Fog",
-        "NavigationInfo",
-        "Viewpoint",
-        // bindable nodes
-        "Text"
-        // Text must be placed at the end of the regex so there are no matches for TextureTransform and TextureCoordinate
-      ];
-      const Version = chevrotain.createToken({
-        name: "Version",
-        pattern: /#VRML.*/,
-        longer_alt: Identifier
-      });
-      const NodeName = chevrotain.createToken({
-        name: "NodeName",
-        pattern: new RegExp(nodeTypes.join("|")),
-        longer_alt: Identifier
-      });
-      const DEF = chevrotain.createToken({
-        name: "DEF",
-        pattern: /DEF/,
-        longer_alt: Identifier
-      });
-      const USE = chevrotain.createToken({
-        name: "USE",
-        pattern: /USE/,
-        longer_alt: Identifier
-      });
-      const ROUTE = chevrotain.createToken({
-        name: "ROUTE",
-        pattern: /ROUTE/,
-        longer_alt: Identifier
-      });
-      const TO = chevrotain.createToken({
-        name: "TO",
-        pattern: /TO/,
-        longer_alt: Identifier
-      });
-      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 = 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: chevrotain.Lexer.SKIPPED
-      });
-      const WhiteSpace = chevrotain.createToken({
-        name: "WhiteSpace",
-        pattern: /[ ,\s]/,
-        group: chevrotain.Lexer.SKIPPED
-      });
-      const tokens = [
-        WhiteSpace,
-        // keywords appear before the Identifier
-        NodeName,
-        DEF,
-        USE,
-        ROUTE,
-        TO,
-        TrueLiteral,
-        FalseLiteral,
-        NullLiteral,
-        // the Identifier must appear after the keywords because all keywords are valid identifiers
-        Version,
-        Identifier,
-        RouteIdentifier,
-        StringLiteral,
-        HexLiteral,
-        NumberLiteral,
-        LSquare,
-        RSquare,
-        LCurly,
-        RCurly,
-        Comment
-      ];
-      const tokenVocabulary = {};
-      for (let i = 0, l = tokens.length; i < l; i++) {
-        const token = tokens[i];
-        tokenVocabulary[token.name] = token;
-      }
-      return { tokens, tokenVocabulary };
-    }
-    function createVisitor(BaseVRMLVisitor) {
-      function VRMLToASTVisitor() {
-        BaseVRMLVisitor.call(this);
-        this.validateVisitor();
-      }
-      VRMLToASTVisitor.prototype = Object.assign(Object.create(BaseVRMLVisitor.prototype), {
-        constructor: VRMLToASTVisitor,
-        vrml: function(ctx) {
-          const data2 = {
-            version: this.visit(ctx.version),
-            nodes: [],
-            routes: []
-          };
-          for (let i = 0, l = ctx.node.length; i < l; i++) {
-            const node = ctx.node[i];
-            data2.nodes.push(this.visit(node));
-          }
-          if (ctx.route) {
-            for (let i = 0, l = ctx.route.length; i < l; i++) {
-              const route = ctx.route[i];
-              data2.routes.push(this.visit(route));
-            }
-          }
-          return data2;
-        },
-        version: function(ctx) {
-          return ctx.Version[0].image;
-        },
-        node: function(ctx) {
-          const data2 = {
-            name: ctx.NodeName[0].image,
-            fields: []
-          };
-          if (ctx.field) {
-            for (let i = 0, l = ctx.field.length; i < l; i++) {
-              const field = ctx.field[i];
-              data2.fields.push(this.visit(field));
-            }
-          }
-          if (ctx.def) {
-            data2.DEF = this.visit(ctx.def[0]);
-          }
-          return data2;
-        },
-        field: function(ctx) {
-          const data2 = {
-            name: ctx.Identifier[0].image,
-            type: null,
-            values: null
-          };
-          let result;
-          if (ctx.singleFieldValue) {
-            result = this.visit(ctx.singleFieldValue[0]);
-          }
-          if (ctx.multiFieldValue) {
-            result = this.visit(ctx.multiFieldValue[0]);
-          }
-          data2.type = result.type;
-          data2.values = result.values;
-          return data2;
-        },
-        def: function(ctx) {
-          return (ctx.Identifier || ctx.NodeName)[0].image;
-        },
-        use: function(ctx) {
-          return { USE: (ctx.Identifier || ctx.NodeName)[0].image };
-        },
-        singleFieldValue: function(ctx) {
-          return processField(this, ctx);
-        },
-        multiFieldValue: function(ctx) {
-          return processField(this, ctx);
-        },
-        route: function(ctx) {
-          const data2 = {
-            FROM: ctx.RouteIdentifier[0].image,
-            TO: ctx.RouteIdentifier[1].image
-          };
-          return data2;
-        }
-      });
-      function processField(scope, ctx) {
-        const field = {
-          type: null,
-          values: []
-        };
-        if (ctx.node) {
-          field.type = "node";
-          for (let i = 0, l = ctx.node.length; i < l; i++) {
-            const node = ctx.node[i];
-            field.values.push(scope.visit(node));
-          }
-        }
-        if (ctx.use) {
-          field.type = "use";
-          for (let i = 0, l = ctx.use.length; i < l; i++) {
-            const use = ctx.use[i];
-            field.values.push(scope.visit(use));
-          }
-        }
-        if (ctx.StringLiteral) {
-          field.type = "string";
-          for (let i = 0, l = ctx.StringLiteral.length; i < l; i++) {
-            const stringLiteral = ctx.StringLiteral[i];
-            field.values.push(stringLiteral.image.replace(/'|"/g, ""));
-          }
-        }
-        if (ctx.NumberLiteral) {
-          field.type = "number";
-          for (let i = 0, l = ctx.NumberLiteral.length; i < l; i++) {
-            const numberLiteral = ctx.NumberLiteral[i];
-            field.values.push(parseFloat(numberLiteral.image));
-          }
-        }
-        if (ctx.HexLiteral) {
-          field.type = "hex";
-          for (let i = 0, l = ctx.HexLiteral.length; i < l; i++) {
-            const hexLiteral = ctx.HexLiteral[i];
-            field.values.push(hexLiteral.image);
-          }
-        }
-        if (ctx.TrueLiteral) {
-          field.type = "boolean";
-          for (let i = 0, l = ctx.TrueLiteral.length; i < l; i++) {
-            const trueLiteral = ctx.TrueLiteral[i];
-            if (trueLiteral.image === "TRUE")
-              field.values.push(true);
-          }
-        }
-        if (ctx.FalseLiteral) {
-          field.type = "boolean";
-          for (let i = 0, l = ctx.FalseLiteral.length; i < l; i++) {
-            const falseLiteral = ctx.FalseLiteral[i];
-            if (falseLiteral.image === "FALSE")
-              field.values.push(false);
-          }
-        }
-        if (ctx.NullLiteral) {
-          field.type = "null";
-          ctx.NullLiteral.forEach(function() {
-            field.values.push(null);
-          });
-        }
-        return field;
-      }
-      return new VRMLToASTVisitor();
-    }
-    function parseTree(tree2) {
-      const nodes = tree2.nodes;
-      const scene2 = new THREE.Scene();
-      for (let i = 0, l = nodes.length; i < l; i++) {
-        const node = nodes[i];
-        buildNodeMap(node);
-      }
-      for (let i = 0, l = nodes.length; i < l; i++) {
-        const node = nodes[i];
-        const object = getNode(node);
-        if (object instanceof THREE.Object3D)
-          scene2.add(object);
-        if (node.name === "WorldInfo")
-          scene2.userData.worldInfo = object;
-      }
-      return scene2;
-    }
-    function buildNodeMap(node) {
-      if (node.DEF) {
-        nodeMap[node.DEF] = node;
-      }
-      const fields = node.fields;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        if (field.type === "node") {
-          const fieldValues = field.values;
-          for (let j = 0, jl = fieldValues.length; j < jl; j++) {
-            buildNodeMap(fieldValues[j]);
-          }
-        }
-      }
-    }
-    function getNode(node) {
-      if (node.USE) {
-        return resolveUSE(node.USE);
-      }
-      if (node.build !== void 0)
-        return node.build;
-      node.build = buildNode(node);
-      return node.build;
-    }
-    function buildNode(node) {
-      const nodeName = node.name;
-      let build;
-      switch (nodeName) {
-        case "Group":
-        case "Transform":
-        case "Collision":
-          build = buildGroupingNode(node);
-          break;
-        case "Background":
-          build = buildBackgroundNode(node);
-          break;
-        case "Shape":
-          build = buildShapeNode(node);
-          break;
-        case "Appearance":
-          build = buildAppearanceNode(node);
-          break;
-        case "Material":
-          build = buildMaterialNode(node);
-          break;
-        case "ImageTexture":
-          build = buildImageTextureNode(node);
-          break;
-        case "PixelTexture":
-          build = buildPixelTextureNode(node);
-          break;
-        case "TextureTransform":
-          build = buildTextureTransformNode(node);
-          break;
-        case "IndexedFaceSet":
-          build = buildIndexedFaceSetNode(node);
-          break;
-        case "IndexedLineSet":
-          build = buildIndexedLineSetNode(node);
-          break;
-        case "PointSet":
-          build = buildPointSetNode(node);
-          break;
-        case "Box":
-          build = buildBoxNode(node);
-          break;
-        case "Cone":
-          build = buildConeNode(node);
-          break;
-        case "Cylinder":
-          build = buildCylinderNode(node);
-          break;
-        case "Sphere":
-          build = buildSphereNode(node);
-          break;
-        case "ElevationGrid":
-          build = buildElevationGridNode(node);
-          break;
-        case "Extrusion":
-          build = buildExtrusionNode(node);
-          break;
-        case "Color":
-        case "Coordinate":
-        case "Normal":
-        case "TextureCoordinate":
-          build = buildGeometricNode(node);
-          break;
-        case "WorldInfo":
-          build = buildWorldInfoNode(node);
-          break;
-        case "Anchor":
-        case "Billboard":
-        case "Inline":
-        case "LOD":
-        case "Switch":
-        case "AudioClip":
-        case "DirectionalLight":
-        case "PointLight":
-        case "Script":
-        case "Sound":
-        case "SpotLight":
-        case "CylinderSensor":
-        case "PlaneSensor":
-        case "ProximitySensor":
-        case "SphereSensor":
-        case "TimeSensor":
-        case "TouchSensor":
-        case "VisibilitySensor":
-        case "Text":
-        case "FontStyle":
-        case "MovieTexture":
-        case "ColorInterpolator":
-        case "CoordinateInterpolator":
-        case "NormalInterpolator":
-        case "OrientationInterpolator":
-        case "PositionInterpolator":
-        case "ScalarInterpolator":
-        case "Fog":
-        case "NavigationInfo":
-        case "Viewpoint":
-          break;
-        default:
-          console.warn("THREE.VRMLLoader: Unknown node:", nodeName);
-          break;
-      }
-      if (build !== void 0 && node.DEF !== void 0 && build.hasOwnProperty("name") === true) {
-        build.name = node.DEF;
-      }
-      return build;
-    }
-    function buildGroupingNode(node) {
-      const object = new THREE.Group();
-      const fields = node.fields;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "bboxCenter":
-            break;
-          case "bboxSize":
-            break;
-          case "center":
-            break;
-          case "children":
-            parseFieldChildren(fieldValues, object);
-            break;
-          case "collide":
-            break;
-          case "rotation":
-            const axis = new THREE.Vector3(fieldValues[0], fieldValues[1], fieldValues[2]);
-            const angle = fieldValues[3];
-            object.quaternion.setFromAxisAngle(axis, angle);
-            break;
-          case "scale":
-            object.scale.set(fieldValues[0], fieldValues[1], fieldValues[2]);
-            break;
-          case "scaleOrientation":
-            break;
-          case "translation":
-            object.position.set(fieldValues[0], fieldValues[1], fieldValues[2]);
-            break;
-          case "proxy":
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      return object;
-    }
-    function buildBackgroundNode(node) {
-      const group = new THREE.Group();
-      let groundAngle, groundColor;
-      let skyAngle, skyColor;
-      const fields = node.fields;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "groundAngle":
-            groundAngle = fieldValues;
-            break;
-          case "groundColor":
-            groundColor = fieldValues;
-            break;
-          case "backUrl":
-            break;
-          case "bottomUrl":
-            break;
-          case "frontUrl":
-            break;
-          case "leftUrl":
-            break;
-          case "rightUrl":
-            break;
-          case "topUrl":
-            break;
-          case "skyAngle":
-            skyAngle = fieldValues;
-            break;
-          case "skyColor":
-            skyColor = fieldValues;
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      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 });
-        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);
-        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({
-            fog: false,
-            side: THREE.BackSide,
-            vertexColors: true,
-            depthWrite: false,
-            depthTest: false
-          });
-          paintFaces(groundGeometry, radius, groundAngle, toColorArray(groundColor), false);
-          const ground = new THREE.Mesh(groundGeometry, groundMaterial);
-          group.add(ground);
-        }
-      }
-      group.renderOrder = -Infinity;
-      return group;
-    }
-    function buildShapeNode(node) {
-      const fields = node.fields;
-      let material = new THREE.MeshBasicMaterial({ color: 0 });
-      let geometry;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "appearance":
-            if (fieldValues[0] !== null) {
-              material = getNode(fieldValues[0]);
-            }
-            break;
-          case "geometry":
-            if (fieldValues[0] !== null) {
-              geometry = getNode(fieldValues[0]);
-            }
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      let object;
-      if (geometry && geometry.attributes.position) {
-        const type = geometry._type;
-        if (type === "points") {
-          const pointsMaterial = new THREE.PointsMaterial({ color: 16777215 });
-          if (geometry.attributes.color !== void 0) {
-            pointsMaterial.vertexColors = true;
-          } else {
-            if (material.isMeshPhongMaterial) {
-              pointsMaterial.color.copy(material.emissive);
-            }
-          }
-          object = new THREE.Points(geometry, pointsMaterial);
-        } else if (type === "line") {
-          const lineMaterial = new THREE.LineBasicMaterial({ color: 16777215 });
-          if (geometry.attributes.color !== void 0) {
-            lineMaterial.vertexColors = true;
-          } else {
-            if (material.isMeshPhongMaterial) {
-              lineMaterial.color.copy(material.emissive);
-            }
-          }
-          object = new THREE.LineSegments(geometry, lineMaterial);
-        } else {
-          if (geometry._solid !== void 0) {
-            material.side = geometry._solid ? THREE.FrontSide : THREE.DoubleSide;
-          }
-          if (geometry.attributes.color !== void 0) {
-            material.vertexColors = true;
-          }
-          object = new THREE.Mesh(geometry, material);
-        }
-      } else {
-        object = new THREE.Object3D();
-        object.visible = false;
-      }
-      return object;
-    }
-    function buildAppearanceNode(node) {
-      let material = new THREE.MeshPhongMaterial();
-      let transformData;
-      const fields = node.fields;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "material":
-            if (fieldValues[0] !== null) {
-              const materialData = getNode(fieldValues[0]);
-              if (materialData.diffuseColor)
-                material.color.copy(materialData.diffuseColor);
-              if (materialData.emissiveColor)
-                material.emissive.copy(materialData.emissiveColor);
-              if (materialData.shininess)
-                material.shininess = materialData.shininess;
-              if (materialData.specularColor)
-                material.specular.copy(materialData.specularColor);
-              if (materialData.transparency)
-                material.opacity = 1 - materialData.transparency;
-              if (materialData.transparency > 0)
-                material.transparent = true;
-            } else {
-              material = new THREE.MeshBasicMaterial({ color: 0 });
-            }
-            break;
-          case "texture":
-            const textureNode = fieldValues[0];
-            if (textureNode !== null) {
-              if (textureNode.name === "ImageTexture" || textureNode.name === "PixelTexture") {
-                material.map = getNode(textureNode);
-              } else {
-              }
-            }
-            break;
-          case "textureTransform":
-            if (fieldValues[0] !== null) {
-              transformData = getNode(fieldValues[0]);
-            }
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      if (material.map) {
-        if (material.map.__type) {
-          switch (material.map.__type) {
-            case TEXTURE_TYPE.INTENSITY_ALPHA:
-              material.opacity = 1;
-              break;
-            case TEXTURE_TYPE.RGB:
-              material.color.set(16777215);
-              break;
-            case TEXTURE_TYPE.RGBA:
-              material.color.set(16777215);
-              material.opacity = 1;
-              break;
-            default:
-          }
-          delete material.map.__type;
-        }
-        if (transformData) {
-          material.map.center.copy(transformData.center);
-          material.map.rotation = transformData.rotation;
-          material.map.repeat.copy(transformData.scale);
-          material.map.offset.copy(transformData.translation);
-        }
-      }
-      return material;
-    }
-    function buildMaterialNode(node) {
-      const materialData = {};
-      const fields = node.fields;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "ambientIntensity":
-            break;
-          case "diffuseColor":
-            materialData.diffuseColor = new THREE.Color(fieldValues[0], fieldValues[1], fieldValues[2]);
-            break;
-          case "emissiveColor":
-            materialData.emissiveColor = new THREE.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]);
-            break;
-          case "transparency":
-            materialData.transparency = fieldValues[0];
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      return materialData;
-    }
-    function parseHexColor(hex, textureType, color) {
-      let value;
-      switch (textureType) {
-        case TEXTURE_TYPE.INTENSITY:
-          value = parseInt(hex);
-          color.r = value;
-          color.g = value;
-          color.b = value;
-          color.a = 1;
-          break;
-        case TEXTURE_TYPE.INTENSITY_ALPHA:
-          value = parseInt("0x" + hex.substring(2, 4));
-          color.r = value;
-          color.g = value;
-          color.b = value;
-          color.a = parseInt("0x" + hex.substring(4, 6));
-          break;
-        case TEXTURE_TYPE.RGB:
-          color.r = parseInt("0x" + hex.substring(2, 4));
-          color.g = parseInt("0x" + hex.substring(4, 6));
-          color.b = parseInt("0x" + hex.substring(6, 8));
-          color.a = 1;
-          break;
-        case TEXTURE_TYPE.RGBA:
-          color.r = parseInt("0x" + hex.substring(2, 4));
-          color.g = parseInt("0x" + hex.substring(4, 6));
-          color.b = parseInt("0x" + hex.substring(6, 8));
-          color.a = parseInt("0x" + hex.substring(8, 10));
-          break;
-        default:
-      }
-    }
-    function getTextureType(num_components) {
-      let type;
-      switch (num_components) {
-        case 1:
-          type = TEXTURE_TYPE.INTENSITY;
-          break;
-        case 2:
-          type = TEXTURE_TYPE.INTENSITY_ALPHA;
-          break;
-        case 3:
-          type = TEXTURE_TYPE.RGB;
-          break;
-        case 4:
-          type = TEXTURE_TYPE.RGBA;
-          break;
-        default:
-      }
-      return type;
-    }
-    function buildPixelTextureNode(node) {
-      let texture;
-      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];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "image":
-            const width = fieldValues[0];
-            const height = fieldValues[1];
-            const num_components = fieldValues[2];
-            const textureType = getTextureType(num_components);
-            const data2 = new Uint8Array(4 * width * height);
-            const color = { r: 0, g: 0, b: 0, a: 0 };
-            for (let j = 3, k = 0, jl = fieldValues.length; j < jl; j++, k++) {
-              parseHexColor(fieldValues[j], textureType, color);
-              const stride = k * 4;
-              data2[stride + 0] = color.r;
-              data2[stride + 1] = color.g;
-              data2[stride + 2] = color.b;
-              data2[stride + 3] = color.a;
-            }
-            texture = new THREE.DataTexture(data2, width, height);
-            texture.needsUpdate = true;
-            texture.__type = textureType;
-            break;
-          case "repeatS":
-            if (fieldValues[0] === false)
-              wrapS = THREE.ClampToEdgeWrapping;
-            break;
-          case "repeatT":
-            if (fieldValues[0] === false)
-              wrapT = THREE.ClampToEdgeWrapping;
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      if (texture) {
-        texture.wrapS = wrapS;
-        texture.wrapT = wrapT;
-      }
-      return texture;
-    }
-    function buildImageTextureNode(node) {
-      let texture;
-      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];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "url":
-            const url = fieldValues[0];
-            if (url)
-              texture = textureLoader.load(url);
-            break;
-          case "repeatS":
-            if (fieldValues[0] === false)
-              wrapS = THREE.ClampToEdgeWrapping;
-            break;
-          case "repeatT":
-            if (fieldValues[0] === false)
-              wrapT = THREE.ClampToEdgeWrapping;
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      if (texture) {
-        texture.wrapS = wrapS;
-        texture.wrapT = wrapT;
-      }
-      return texture;
-    }
-    function buildTextureTransformNode(node) {
-      const transformData = {
-        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++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "center":
-            transformData.center.set(fieldValues[0], fieldValues[1]);
-            break;
-          case "rotation":
-            transformData.rotation = fieldValues[0];
-            break;
-          case "scale":
-            transformData.scale.set(fieldValues[0], fieldValues[1]);
-            break;
-          case "translation":
-            transformData.translation.set(fieldValues[0], fieldValues[1]);
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      return transformData;
-    }
-    function buildGeometricNode(node) {
-      return node.fields[0].values;
-    }
-    function buildWorldInfoNode(node) {
-      const worldInfo = {};
-      const fields = node.fields;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "title":
-            worldInfo.title = fieldValues[0];
-            break;
-          case "info":
-            worldInfo.info = fieldValues;
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      return worldInfo;
-    }
-    function buildIndexedFaceSetNode(node) {
-      let color, coord, normal, texCoord;
-      let ccw = true, solid = true, creaseAngle = 0;
-      let colorIndex, coordIndex, normalIndex, texCoordIndex;
-      let colorPerVertex = true, normalPerVertex = true;
-      const fields = node.fields;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "color":
-            const colorNode = fieldValues[0];
-            if (colorNode !== null) {
-              color = getNode(colorNode);
-            }
-            break;
-          case "coord":
-            const coordNode = fieldValues[0];
-            if (coordNode !== null) {
-              coord = getNode(coordNode);
-            }
-            break;
-          case "normal":
-            const normalNode = fieldValues[0];
-            if (normalNode !== null) {
-              normal = getNode(normalNode);
-            }
-            break;
-          case "texCoord":
-            const texCoordNode = fieldValues[0];
-            if (texCoordNode !== null) {
-              texCoord = getNode(texCoordNode);
-            }
-            break;
-          case "ccw":
-            ccw = fieldValues[0];
-            break;
-          case "colorIndex":
-            colorIndex = fieldValues;
-            break;
-          case "colorPerVertex":
-            colorPerVertex = fieldValues[0];
-            break;
-          case "convex":
-            break;
-          case "coordIndex":
-            coordIndex = fieldValues;
-            break;
-          case "creaseAngle":
-            creaseAngle = fieldValues[0];
-            break;
-          case "normalIndex":
-            normalIndex = fieldValues;
-            break;
-          case "normalPerVertex":
-            normalPerVertex = fieldValues[0];
-            break;
-          case "solid":
-            solid = fieldValues[0];
-            break;
-          case "texCoordIndex":
-            texCoordIndex = fieldValues;
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      if (coordIndex === void 0) {
-        console.warn("THREE.VRMLLoader: Missing coordIndex.");
-        return new THREE.BufferGeometry();
-      }
-      const triangulatedCoordIndex = triangulateFaceIndex(coordIndex, ccw);
-      let colorAttribute;
-      let normalAttribute;
-      let uvAttribute;
-      if (color) {
-        if (colorPerVertex === true) {
-          if (colorIndex && colorIndex.length > 0) {
-            const triangulatedColorIndex = triangulateFaceIndex(colorIndex, ccw);
-            colorAttribute = computeAttributeFromIndexedData(triangulatedCoordIndex, triangulatedColorIndex, color, 3);
-          } else {
-            colorAttribute = toNonIndexedAttribute(triangulatedCoordIndex, new THREE.Float32BufferAttribute(color, 3));
-          }
-        } else {
-          if (colorIndex && colorIndex.length > 0) {
-            const flattenFaceColors = flattenData(color, colorIndex);
-            const triangulatedFaceColors = triangulateFaceData(flattenFaceColors, coordIndex);
-            colorAttribute = computeAttributeFromFaceData(triangulatedCoordIndex, triangulatedFaceColors);
-          } else {
-            const triangulatedFaceColors = triangulateFaceData(color, coordIndex);
-            colorAttribute = computeAttributeFromFaceData(triangulatedCoordIndex, triangulatedFaceColors);
-          }
-        }
-      }
-      if (normal) {
-        if (normalPerVertex === true) {
-          if (normalIndex && normalIndex.length > 0) {
-            const triangulatedNormalIndex = triangulateFaceIndex(normalIndex, ccw);
-            normalAttribute = computeAttributeFromIndexedData(
-              triangulatedCoordIndex,
-              triangulatedNormalIndex,
-              normal,
-              3
-            );
-          } else {
-            normalAttribute = toNonIndexedAttribute(triangulatedCoordIndex, new THREE.Float32BufferAttribute(normal, 3));
-          }
-        } else {
-          if (normalIndex && normalIndex.length > 0) {
-            const flattenFaceNormals = flattenData(normal, normalIndex);
-            const triangulatedFaceNormals = triangulateFaceData(flattenFaceNormals, coordIndex);
-            normalAttribute = computeAttributeFromFaceData(triangulatedCoordIndex, triangulatedFaceNormals);
-          } else {
-            const triangulatedFaceNormals = triangulateFaceData(normal, coordIndex);
-            normalAttribute = computeAttributeFromFaceData(triangulatedCoordIndex, triangulatedFaceNormals);
-          }
-        }
-      } else {
-        normalAttribute = computeNormalAttribute(triangulatedCoordIndex, coord, creaseAngle);
-      }
-      if (texCoord) {
-        if (texCoordIndex && texCoordIndex.length > 0) {
-          const triangulatedTexCoordIndex = triangulateFaceIndex(texCoordIndex, ccw);
-          uvAttribute = computeAttributeFromIndexedData(triangulatedCoordIndex, triangulatedTexCoordIndex, texCoord, 2);
-        } else {
-          uvAttribute = toNonIndexedAttribute(triangulatedCoordIndex, new THREE.Float32BufferAttribute(texCoord, 2));
-        }
-      }
-      const geometry = new THREE.BufferGeometry();
-      const positionAttribute = toNonIndexedAttribute(triangulatedCoordIndex, new THREE.Float32BufferAttribute(coord, 3));
-      geometry.setAttribute("position", positionAttribute);
-      geometry.setAttribute("normal", normalAttribute);
-      if (colorAttribute)
-        geometry.setAttribute("color", colorAttribute);
-      if (uvAttribute)
-        geometry.setAttribute("uv", uvAttribute);
-      geometry._solid = solid;
-      geometry._type = "mesh";
-      return geometry;
-    }
-    function buildIndexedLineSetNode(node) {
-      let color, coord;
-      let colorIndex, coordIndex;
-      let colorPerVertex = true;
-      const fields = node.fields;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "color":
-            const colorNode = fieldValues[0];
-            if (colorNode !== null) {
-              color = getNode(colorNode);
-            }
-            break;
-          case "coord":
-            const coordNode = fieldValues[0];
-            if (coordNode !== null) {
-              coord = getNode(coordNode);
-            }
-            break;
-          case "colorIndex":
-            colorIndex = fieldValues;
-            break;
-          case "colorPerVertex":
-            colorPerVertex = fieldValues[0];
-            break;
-          case "coordIndex":
-            coordIndex = fieldValues;
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      let colorAttribute;
-      const expandedLineIndex = expandLineIndex(coordIndex);
-      if (color) {
-        if (colorPerVertex === true) {
-          if (colorIndex.length > 0) {
-            const expandedColorIndex = expandLineIndex(colorIndex);
-            colorAttribute = computeAttributeFromIndexedData(expandedLineIndex, expandedColorIndex, color, 3);
-          } else {
-            colorAttribute = toNonIndexedAttribute(expandedLineIndex, new THREE.Float32BufferAttribute(color, 3));
-          }
-        } else {
-          if (colorIndex.length > 0) {
-            const flattenLineColors = flattenData(color, colorIndex);
-            const expandedLineColors = expandLineData(flattenLineColors, coordIndex);
-            colorAttribute = computeAttributeFromLineData(expandedLineIndex, expandedLineColors);
-          } else {
-            const expandedLineColors = expandLineData(color, coordIndex);
-            colorAttribute = computeAttributeFromLineData(expandedLineIndex, expandedLineColors);
-          }
-        }
-      }
-      const geometry = new THREE.BufferGeometry();
-      const positionAttribute = toNonIndexedAttribute(expandedLineIndex, new THREE.Float32BufferAttribute(coord, 3));
-      geometry.setAttribute("position", positionAttribute);
-      if (colorAttribute)
-        geometry.setAttribute("color", colorAttribute);
-      geometry._type = "line";
-      return geometry;
-    }
-    function buildPointSetNode(node) {
-      let color, coord;
-      const fields = node.fields;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "color":
-            const colorNode = fieldValues[0];
-            if (colorNode !== null) {
-              color = getNode(colorNode);
-            }
-            break;
-          case "coord":
-            const coordNode = fieldValues[0];
-            if (coordNode !== null) {
-              coord = getNode(coordNode);
-            }
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      const geometry = new THREE.BufferGeometry();
-      geometry.setAttribute("position", new THREE.Float32BufferAttribute(coord, 3));
-      if (color)
-        geometry.setAttribute("color", new THREE.Float32BufferAttribute(color, 3));
-      geometry._type = "points";
-      return geometry;
-    }
-    function buildBoxNode(node) {
-      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];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "size":
-            size.x = fieldValues[0];
-            size.y = fieldValues[1];
-            size.z = fieldValues[2];
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      const geometry = new THREE.BoxGeometry(size.x, size.y, size.z);
-      return geometry;
-    }
-    function buildConeNode(node) {
-      let radius = 1, height = 2, openEnded = false;
-      const fields = node.fields;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "bottom":
-            openEnded = !fieldValues[0];
-            break;
-          case "bottomRadius":
-            radius = fieldValues[0];
-            break;
-          case "height":
-            height = fieldValues[0];
-            break;
-          case "side":
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      const geometry = new THREE.ConeGeometry(radius, height, 16, 1, openEnded);
-      return geometry;
-    }
-    function buildCylinderNode(node) {
-      let radius = 1, height = 2;
-      const fields = node.fields;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "bottom":
-            break;
-          case "radius":
-            radius = fieldValues[0];
-            break;
-          case "height":
-            height = fieldValues[0];
-            break;
-          case "side":
-            break;
-          case "top":
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      const geometry = new THREE.CylinderGeometry(radius, radius, height, 16, 1);
-      return geometry;
-    }
-    function buildSphereNode(node) {
-      let radius = 1;
-      const fields = node.fields;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "radius":
-            radius = fieldValues[0];
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      const geometry = new THREE.SphereGeometry(radius, 16, 16);
-      return geometry;
-    }
-    function buildElevationGridNode(node) {
-      let color;
-      let normal;
-      let texCoord;
-      let height;
-      let colorPerVertex = true;
-      let normalPerVertex = true;
-      let solid = true;
-      let ccw = true;
-      let creaseAngle = 0;
-      let xDimension = 2;
-      let zDimension = 2;
-      let xSpacing = 1;
-      let zSpacing = 1;
-      const fields = node.fields;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "color":
-            const colorNode = fieldValues[0];
-            if (colorNode !== null) {
-              color = getNode(colorNode);
-            }
-            break;
-          case "normal":
-            const normalNode = fieldValues[0];
-            if (normalNode !== null) {
-              normal = getNode(normalNode);
-            }
-            break;
-          case "texCoord":
-            const texCoordNode = fieldValues[0];
-            if (texCoordNode !== null) {
-              texCoord = getNode(texCoordNode);
-            }
-            break;
-          case "height":
-            height = fieldValues;
-            break;
-          case "ccw":
-            ccw = fieldValues[0];
-            break;
-          case "colorPerVertex":
-            colorPerVertex = fieldValues[0];
-            break;
-          case "creaseAngle":
-            creaseAngle = fieldValues[0];
-            break;
-          case "normalPerVertex":
-            normalPerVertex = fieldValues[0];
-            break;
-          case "solid":
-            solid = fieldValues[0];
-            break;
-          case "xDimension":
-            xDimension = fieldValues[0];
-            break;
-          case "xSpacing":
-            xSpacing = fieldValues[0];
-            break;
-          case "zDimension":
-            zDimension = fieldValues[0];
-            break;
-          case "zSpacing":
-            zSpacing = fieldValues[0];
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      const vertices = [];
-      const normals = [];
-      const colors = [];
-      const uvs = [];
-      for (let i = 0; i < zDimension; i++) {
-        for (let j = 0; j < xDimension; j++) {
-          const index = i * xDimension + j;
-          const x = xSpacing * i;
-          const y = height[index];
-          const z = zSpacing * j;
-          vertices.push(x, y, z);
-          if (color && colorPerVertex === true) {
-            const r = color[index * 3 + 0];
-            const g = color[index * 3 + 1];
-            const b = color[index * 3 + 2];
-            colors.push(r, g, b);
-          }
-          if (normal && normalPerVertex === true) {
-            const xn = normal[index * 3 + 0];
-            const yn = normal[index * 3 + 1];
-            const zn = normal[index * 3 + 2];
-            normals.push(xn, yn, zn);
-          }
-          if (texCoord) {
-            const s = texCoord[index * 2 + 0];
-            const t = texCoord[index * 2 + 1];
-            uvs.push(s, t);
-          } else {
-            uvs.push(i / (xDimension - 1), j / (zDimension - 1));
-          }
-        }
-      }
-      const indices = [];
-      for (let i = 0; i < xDimension - 1; i++) {
-        for (let j = 0; j < zDimension - 1; j++) {
-          const a = i + j * xDimension;
-          const b = i + (j + 1) * xDimension;
-          const c = i + 1 + (j + 1) * xDimension;
-          const d = i + 1 + j * xDimension;
-          if (ccw === true) {
-            indices.push(a, c, b);
-            indices.push(c, a, d);
-          } else {
-            indices.push(a, b, c);
-            indices.push(c, d, a);
-          }
-        }
-      }
-      const positionAttribute = toNonIndexedAttribute(indices, new THREE.Float32BufferAttribute(vertices, 3));
-      const uvAttribute = toNonIndexedAttribute(indices, new THREE.Float32BufferAttribute(uvs, 2));
-      let colorAttribute;
-      let normalAttribute;
-      if (color) {
-        if (colorPerVertex === false) {
-          for (let i = 0; i < xDimension - 1; i++) {
-            for (let j = 0; j < zDimension - 1; j++) {
-              const index = i + j * (xDimension - 1);
-              const r = color[index * 3 + 0];
-              const g = color[index * 3 + 1];
-              const b = color[index * 3 + 2];
-              colors.push(r, g, b);
-              colors.push(r, g, b);
-              colors.push(r, g, b);
-              colors.push(r, g, b);
-              colors.push(r, g, b);
-              colors.push(r, g, b);
-            }
-          }
-          colorAttribute = new THREE.Float32BufferAttribute(colors, 3);
-        } else {
-          colorAttribute = toNonIndexedAttribute(indices, new THREE.Float32BufferAttribute(colors, 3));
-        }
-      }
-      if (normal) {
-        if (normalPerVertex === false) {
-          for (let i = 0; i < xDimension - 1; i++) {
-            for (let j = 0; j < zDimension - 1; j++) {
-              const index = i + j * (xDimension - 1);
-              const xn = normal[index * 3 + 0];
-              const yn = normal[index * 3 + 1];
-              const zn = normal[index * 3 + 2];
-              normals.push(xn, yn, zn);
-              normals.push(xn, yn, zn);
-              normals.push(xn, yn, zn);
-              normals.push(xn, yn, zn);
-              normals.push(xn, yn, zn);
-              normals.push(xn, yn, zn);
-            }
-          }
-          normalAttribute = new THREE.Float32BufferAttribute(normals, 3);
-        } else {
-          normalAttribute = toNonIndexedAttribute(indices, new THREE.Float32BufferAttribute(normals, 3));
-        }
-      } else {
-        normalAttribute = computeNormalAttribute(indices, vertices, creaseAngle);
-      }
-      const geometry = new THREE.BufferGeometry();
-      geometry.setAttribute("position", positionAttribute);
-      geometry.setAttribute("normal", normalAttribute);
-      geometry.setAttribute("uv", uvAttribute);
-      if (colorAttribute)
-        geometry.setAttribute("color", colorAttribute);
-      geometry._solid = solid;
-      geometry._type = "mesh";
-      return geometry;
-    }
-    function buildExtrusionNode(node) {
-      let crossSection = [1, 1, 1, -1, -1, -1, -1, 1, 1, 1];
-      let spine = [0, 0, 0, 0, 1, 0];
-      let scale;
-      let orientation;
-      let beginCap = true;
-      let ccw = true;
-      let creaseAngle = 0;
-      let endCap = true;
-      let solid = true;
-      const fields = node.fields;
-      for (let i = 0, l = fields.length; i < l; i++) {
-        const field = fields[i];
-        const fieldName = field.name;
-        const fieldValues = field.values;
-        switch (fieldName) {
-          case "beginCap":
-            beginCap = fieldValues[0];
-            break;
-          case "ccw":
-            ccw = fieldValues[0];
-            break;
-          case "convex":
-            break;
-          case "creaseAngle":
-            creaseAngle = fieldValues[0];
-            break;
-          case "crossSection":
-            crossSection = fieldValues;
-            break;
-          case "endCap":
-            endCap = fieldValues[0];
-            break;
-          case "orientation":
-            orientation = fieldValues;
-            break;
-          case "scale":
-            scale = fieldValues;
-            break;
-          case "solid":
-            solid = fieldValues[0];
-            break;
-          case "spine":
-            spine = fieldValues;
-            break;
-          default:
-            console.warn("THREE.VRMLLoader: Unknown field:", fieldName);
-            break;
-        }
-      }
-      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();
-      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;
-        scaling.y = 1;
-        scaling.z = scale ? scale[j + 1] : 1;
-        axis.x = orientation ? orientation[o + 0] : 0;
-        axis.y = orientation ? orientation[o + 1] : 0;
-        axis.z = orientation ? orientation[o + 2] : 1;
-        const angle = orientation ? orientation[o + 3] : 0;
-        for (let k = 0, kl = crossSection.length; k < kl; k += 2) {
-          vertex.x = crossSection[k + 0];
-          vertex.y = 0;
-          vertex.z = crossSection[k + 1];
-          vertex.multiply(scaling);
-          quaternion.setFromAxisAngle(axis, angle);
-          vertex.applyQuaternion(quaternion);
-          vertex.add(spineVector);
-          vertices.push(vertex.x, vertex.y, vertex.z);
-        }
-      }
-      const indices = [];
-      const spineCount = spine.length / 3;
-      const crossSectionCount = crossSection.length / 2;
-      for (let i = 0; i < spineCount - 1; i++) {
-        for (let j = 0; j < crossSectionCount - 1; j++) {
-          const a = j + i * crossSectionCount;
-          let b = j + 1 + i * crossSectionCount;
-          const c = j + (i + 1) * crossSectionCount;
-          let d = j + 1 + (i + 1) * crossSectionCount;
-          if (j === crossSectionCount - 2 && crossSectionClosed === true) {
-            b = i * crossSectionCount;
-            d = (i + 1) * crossSectionCount;
-          }
-          if (ccw === true) {
-            indices.push(a, b, c);
-            indices.push(c, b, d);
-          } else {
-            indices.push(a, c, b);
-            indices.push(c, d, b);
-          }
-        }
-      }
-      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]));
-        }
-        const faces = THREE.ShapeUtils.triangulateShape(contour, []);
-        const capIndices = [];
-        for (let i = 0, l = faces.length; i < l; i++) {
-          const face = faces[i];
-          capIndices.push(face[0], face[1], face[2]);
-        }
-        if (beginCap === true) {
-          for (let i = 0, l = capIndices.length; i < l; i += 3) {
-            if (ccw === true) {
-              indices.push(capIndices[i + 0], capIndices[i + 1], capIndices[i + 2]);
-            } else {
-              indices.push(capIndices[i + 0], capIndices[i + 2], capIndices[i + 1]);
-            }
-          }
-        }
-        if (endCap === true) {
-          const indexOffset = crossSectionCount * (spineCount - 1);
-          for (let i = 0, l = capIndices.length; i < l; i += 3) {
-            if (ccw === true) {
-              indices.push(
-                indexOffset + capIndices[i + 0],
-                indexOffset + capIndices[i + 2],
-                indexOffset + capIndices[i + 1]
-              );
-            } else {
-              indices.push(
-                indexOffset + capIndices[i + 0],
-                indexOffset + capIndices[i + 1],
-                indexOffset + capIndices[i + 2]
-              );
-            }
-          }
-        }
-      }
-      const positionAttribute = toNonIndexedAttribute(indices, new THREE.Float32BufferAttribute(vertices, 3));
-      const normalAttribute = computeNormalAttribute(indices, vertices, creaseAngle);
-      const geometry = new THREE.BufferGeometry();
-      geometry.setAttribute("position", positionAttribute);
-      geometry.setAttribute("normal", normalAttribute);
-      geometry._solid = solid;
-      geometry._type = "mesh";
-      return geometry;
-    }
-    function resolveUSE(identifier) {
-      const node = nodeMap[identifier];
-      const build = getNode(node);
-      return build.isObject3D || build.isMaterial ? build.clone() : build;
-    }
-    function parseFieldChildren(children, owner) {
-      for (let i = 0, l = children.length; i < l; i++) {
-        const object = getNode(children[i]);
-        if (object instanceof THREE.Object3D)
-          owner.add(object);
-      }
-    }
-    function triangulateFaceIndex(index, ccw) {
-      const indices = [];
-      let start = 0;
-      for (let i = 0, l = index.length; i < l; i++) {
-        const i1 = index[start];
-        const i2 = index[i + (ccw ? 1 : 2)];
-        const i3 = index[i + (ccw ? 2 : 1)];
-        indices.push(i1, i2, i3);
-        if (index[i + 3] === -1 || i + 3 >= l) {
-          i += 3;
-          start = i + 1;
-        }
-      }
-      return indices;
-    }
-    function triangulateFaceData(data2, index) {
-      const triangulatedData = [];
-      let start = 0;
-      for (let i = 0, l = index.length; i < l; i++) {
-        const stride = start * 3;
-        const x = data2[stride];
-        const y = data2[stride + 1];
-        const z = data2[stride + 2];
-        triangulatedData.push(x, y, z);
-        if (index[i + 3] === -1 || i + 3 >= l) {
-          i += 3;
-          start++;
-        }
-      }
-      return triangulatedData;
-    }
-    function flattenData(data2, index) {
-      const flattenData2 = [];
-      for (let i = 0, l = index.length; i < l; i++) {
-        const i1 = index[i];
-        const stride = i1 * 3;
-        const x = data2[stride];
-        const y = data2[stride + 1];
-        const z = data2[stride + 2];
-        flattenData2.push(x, y, z);
-      }
-      return flattenData2;
-    }
-    function expandLineIndex(index) {
-      const indices = [];
-      for (let i = 0, l = index.length; i < l; i++) {
-        const i1 = index[i];
-        const i2 = index[i + 1];
-        indices.push(i1, i2);
-        if (index[i + 2] === -1 || i + 2 >= l) {
-          i += 2;
-        }
-      }
-      return indices;
-    }
-    function expandLineData(data2, index) {
-      const triangulatedData = [];
-      let start = 0;
-      for (let i = 0, l = index.length; i < l; i++) {
-        const stride = start * 3;
-        const x = data2[stride];
-        const y = data2[stride + 1];
-        const z = data2[stride + 2];
-        triangulatedData.push(x, y, z);
-        if (index[i + 2] === -1 || i + 2 >= l) {
-          i += 2;
-          start++;
-        }
-      }
-      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();
-    function computeAttributeFromIndexedData(coordIndex, index, data2, itemSize) {
-      const array = [];
-      for (let i = 0, l = coordIndex.length; i < l; i += 3) {
-        const a = index[i];
-        const b = index[i + 1];
-        const c = index[i + 2];
-        if (itemSize === 2) {
-          uvA.fromArray(data2, a * itemSize);
-          uvB.fromArray(data2, b * itemSize);
-          uvC.fromArray(data2, c * itemSize);
-          array.push(uvA.x, uvA.y);
-          array.push(uvB.x, uvB.y);
-          array.push(uvC.x, uvC.y);
-        } else {
-          vA.fromArray(data2, a * itemSize);
-          vB.fromArray(data2, b * itemSize);
-          vC.fromArray(data2, c * itemSize);
-          array.push(vA.x, vA.y, vA.z);
-          array.push(vB.x, vB.y, vB.z);
-          array.push(vC.x, vC.y, vC.z);
-        }
-      }
-      return new THREE.Float32BufferAttribute(array, itemSize);
-    }
-    function computeAttributeFromFaceData(index, faceData) {
-      const array = [];
-      for (let i = 0, j = 0, l = index.length; i < l; i += 3, j++) {
-        vA.fromArray(faceData, j * 3);
-        array.push(vA.x, vA.y, vA.z);
-        array.push(vA.x, vA.y, vA.z);
-        array.push(vA.x, vA.y, vA.z);
-      }
-      return new THREE.Float32BufferAttribute(array, 3);
-    }
-    function computeAttributeFromLineData(index, lineData) {
-      const array = [];
-      for (let i = 0, j = 0, l = index.length; i < l; i += 2, j++) {
-        vA.fromArray(lineData, j * 3);
-        array.push(vA.x, vA.y, vA.z);
-        array.push(vA.x, vA.y, vA.z);
-      }
-      return new THREE.Float32BufferAttribute(array, 3);
-    }
-    function toNonIndexedAttribute(indices, attribute) {
-      const array = attribute.array;
-      const itemSize = attribute.itemSize;
-      const array2 = new array.constructor(indices.length * itemSize);
-      let index = 0, index2 = 0;
-      for (let i = 0, l = indices.length; i < l; i++) {
-        index = indices[i] * itemSize;
-        for (let j = 0; j < itemSize; j++) {
-          array2[index2++] = array[index++];
-        }
-      }
-      return new THREE.Float32BufferAttribute(array2, itemSize);
-    }
-    const ab = new THREE.Vector3();
-    const cb = new THREE.Vector3();
-    function computeNormalAttribute(index, coord, creaseAngle) {
-      const faces = [];
-      const vertexNormals = {};
-      for (let i = 0, l = index.length; i < l; i += 3) {
-        const a = index[i];
-        const b = index[i + 1];
-        const c = index[i + 2];
-        const face = new Face(a, b, c);
-        vA.fromArray(coord, a * 3);
-        vB.fromArray(coord, b * 3);
-        vC.fromArray(coord, c * 3);
-        cb.subVectors(vC, vB);
-        ab.subVectors(vA, vB);
-        cb.cross(ab);
-        cb.normalize();
-        face.normal.copy(cb);
-        if (vertexNormals[a] === void 0)
-          vertexNormals[a] = [];
-        if (vertexNormals[b] === void 0)
-          vertexNormals[b] = [];
-        if (vertexNormals[c] === void 0)
-          vertexNormals[c] = [];
-        vertexNormals[a].push(face.normal);
-        vertexNormals[b].push(face.normal);
-        vertexNormals[c].push(face.normal);
-        faces.push(face);
-      }
-      const normals = [];
-      for (let i = 0, l = faces.length; i < l; i++) {
-        const face = faces[i];
-        const nA = weightedNormal(vertexNormals[face.a], face.normal, creaseAngle);
-        const nB = weightedNormal(vertexNormals[face.b], face.normal, creaseAngle);
-        const nC = weightedNormal(vertexNormals[face.c], face.normal, creaseAngle);
-        vA.fromArray(coord, face.a * 3);
-        vB.fromArray(coord, face.b * 3);
-        vC.fromArray(coord, face.c * 3);
-        normals.push(nA.x, nA.y, nA.z);
-        normals.push(nB.x, nB.y, nB.z);
-        normals.push(nC.x, nC.y, nC.z);
-      }
-      return new THREE.Float32BufferAttribute(normals, 3);
-    }
-    function weightedNormal(normals, vector, creaseAngle) {
-      const normal = new THREE.Vector3();
-      if (creaseAngle === 0) {
-        normal.copy(vector);
-      } else {
-        for (let i = 0, l = normals.length; i < l; i++) {
-          if (normals[i].angleTo(vector) < creaseAngle) {
-            normal.add(normals[i]);
-          }
-        }
-      }
-      return normal.normalize();
-    }
-    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]));
-      }
-      return array;
-    }
-    function paintFaces(geometry, radius, angles, colors, topDown) {
-      const thresholds = [];
-      const startAngle = topDown === true ? 0 : Math.PI;
-      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();
-        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();
-      for (let i = 0; i < indices.count; i++) {
-        const index = indices.getX(i);
-        position.fromBufferAttribute(positionAttribute, index);
-        let thresholdIndexA, thresholdIndexB;
-        let t = 1;
-        for (let j = 1; j < thresholds.length; j++) {
-          thresholdIndexA = j - 1;
-          thresholdIndexB = j;
-          const thresholdA = thresholds[thresholdIndexA];
-          const thresholdB = thresholds[thresholdIndexB];
-          if (topDown === true) {
-            if (position.y <= thresholdA.y && position.y > thresholdB.y) {
-              t = Math.abs(thresholdA.y - position.y) / Math.abs(thresholdA.y - thresholdB.y);
-              break;
-            }
-          } else {
-            if (position.y >= thresholdA.y && position.y < thresholdB.y) {
-              t = Math.abs(thresholdA.y - position.y) / Math.abs(thresholdA.y - thresholdB.y);
-              break;
-            }
-          }
-        }
-        const colorA = colors[thresholdIndexA];
-        const colorB = colors[thresholdIndexB];
-        color.copy(colorA).lerp(colorB, t);
-        colorAttribute.setXYZ(index, color.r, color.g, color.b);
-      }
-      geometry.setAttribute("color", colorAttribute);
-    }
-    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.");
-    }
-    const tree = generateVRMLTree(data);
-    const scene = parseTree(tree);
-    return scene;
-  }
-}
-class VRMLLexer {
-  constructor(tokens) {
-    this.lexer = new chevrotain.Lexer(tokens);
-  }
-  lex(inputText) {
-    const lexingResult = this.lexer.tokenize(inputText);
-    if (lexingResult.errors.length > 0) {
-      console.error(lexingResult.errors);
-      throw Error("THREE.VRMLLexer: Lexing errors detected.");
-    }
-    return lexingResult;
-  }
-}
-class VRMLParser extends chevrotain.CstParser {
-  constructor(tokenVocabulary) {
-    super(tokenVocabulary);
-    const $ = this;
-    const Version = tokenVocabulary["Version"];
-    const LCurly = tokenVocabulary["LCurly"];
-    const RCurly = tokenVocabulary["RCurly"];
-    const LSquare = tokenVocabulary["LSquare"];
-    const RSquare = tokenVocabulary["RSquare"];
-    const Identifier = tokenVocabulary["Identifier"];
-    const RouteIdentifier = tokenVocabulary["RouteIdentifier"];
-    const StringLiteral = tokenVocabulary["StringLiteral"];
-    const HexLiteral = tokenVocabulary["HexLiteral"];
-    const NumberLiteral = tokenVocabulary["NumberLiteral"];
-    const TrueLiteral = tokenVocabulary["TrueLiteral"];
-    const FalseLiteral = tokenVocabulary["FalseLiteral"];
-    const NullLiteral = tokenVocabulary["NullLiteral"];
-    const DEF = tokenVocabulary["DEF"];
-    const USE = tokenVocabulary["USE"];
-    const ROUTE = tokenVocabulary["ROUTE"];
-    const TO = tokenVocabulary["TO"];
-    const NodeName = tokenVocabulary["NodeName"];
-    $.RULE("vrml", function() {
-      $.SUBRULE($.version);
-      $.AT_LEAST_ONE(function() {
-        $.SUBRULE($.node);
-      });
-      $.MANY(function() {
-        $.SUBRULE($.route);
-      });
-    });
-    $.RULE("version", function() {
-      $.CONSUME(Version);
-    });
-    $.RULE("node", function() {
-      $.OPTION(function() {
-        $.SUBRULE($.def);
-      });
-      $.CONSUME(NodeName);
-      $.CONSUME(LCurly);
-      $.MANY(function() {
-        $.SUBRULE($.field);
-      });
-      $.CONSUME(RCurly);
-    });
-    $.RULE("field", function() {
-      $.CONSUME(Identifier);
-      $.OR2([
-        {
-          ALT: function() {
-            $.SUBRULE($.singleFieldValue);
-          }
-        },
-        {
-          ALT: function() {
-            $.SUBRULE($.multiFieldValue);
-          }
-        }
-      ]);
-    });
-    $.RULE("def", function() {
-      $.CONSUME(DEF);
-      $.OR([
-        {
-          ALT: function() {
-            $.CONSUME(Identifier);
-          }
-        },
-        {
-          ALT: function() {
-            $.CONSUME(NodeName);
-          }
-        }
-      ]);
-    });
-    $.RULE("use", function() {
-      $.CONSUME(USE);
-      $.OR([
-        {
-          ALT: function() {
-            $.CONSUME(Identifier);
-          }
-        },
-        {
-          ALT: function() {
-            $.CONSUME(NodeName);
-          }
-        }
-      ]);
-    });
-    $.RULE("singleFieldValue", function() {
-      $.AT_LEAST_ONE(function() {
-        $.OR([
-          {
-            ALT: function() {
-              $.SUBRULE($.node);
-            }
-          },
-          {
-            ALT: function() {
-              $.SUBRULE($.use);
-            }
-          },
-          {
-            ALT: function() {
-              $.CONSUME(StringLiteral);
-            }
-          },
-          {
-            ALT: function() {
-              $.CONSUME(HexLiteral);
-            }
-          },
-          {
-            ALT: function() {
-              $.CONSUME(NumberLiteral);
-            }
-          },
-          {
-            ALT: function() {
-              $.CONSUME(TrueLiteral);
-            }
-          },
-          {
-            ALT: function() {
-              $.CONSUME(FalseLiteral);
-            }
-          },
-          {
-            ALT: function() {
-              $.CONSUME(NullLiteral);
-            }
-          }
-        ]);
-      });
-    });
-    $.RULE("multiFieldValue", function() {
-      $.CONSUME(LSquare);
-      $.MANY(function() {
-        $.OR([
-          {
-            ALT: function() {
-              $.SUBRULE($.node);
-            }
-          },
-          {
-            ALT: function() {
-              $.SUBRULE($.use);
-            }
-          },
-          {
-            ALT: function() {
-              $.CONSUME(StringLiteral);
-            }
-          },
-          {
-            ALT: function() {
-              $.CONSUME(HexLiteral);
-            }
-          },
-          {
-            ALT: function() {
-              $.CONSUME(NumberLiteral);
-            }
-          },
-          {
-            ALT: function() {
-              $.CONSUME(NullLiteral);
-            }
-          }
-        ]);
-      });
-      $.CONSUME(RSquare);
-    });
-    $.RULE("route", function() {
-      $.CONSUME(ROUTE);
-      $.CONSUME(RouteIdentifier);
-      $.CONSUME(TO);
-      $.CONSUME2(RouteIdentifier);
-    });
-    this.performSelfAnalysis();
-  }
-}
-class Face {
-  constructor(a, b, c) {
-    this.a = a;
-    this.b = b;
-    this.c = c;
-    this.normal = new THREE.Vector3();
-  }
-}
-const TEXTURE_TYPE = {
-  INTENSITY: 1,
-  INTENSITY_ALPHA: 2,
-  RGB: 3,
-  RGBA: 4
-};
-exports.VRMLLoader = VRMLLoader;