three-stdlib 2.22.7 → 2.22.9

package/dist/misc/GPUComputationRenderer.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+var GPUComputationRenderer = function(sizeX, sizeY, renderer) {
+  this.variables = [];
+  this.currentTextureIndex = 0;
+  var dataType = THREE.FloatType;
+  var scene = new THREE.Scene();
+  var camera = new THREE.Camera();
+  camera.position.z = 1;
+  var passThruUniforms = {
+    passThruTexture: { value: null }
+  };
+  var passThruShader = createShaderMaterial(getPassThroughFragmentShader(), passThruUniforms);
+  var mesh = new THREE.Mesh(new THREE.PlaneGeometry(2, 2), passThruShader);
+  scene.add(mesh);
+  this.setDataType = function(type) {
+    dataType = type;
+    return this;
+  };
+  this.addVariable = function(variableName, computeFragmentShader, initialValueTexture) {
+    var material = this.createShaderMaterial(computeFragmentShader);
+    var variable = {
+      name: variableName,
+      initialValueTexture,
+      material,
+      dependencies: null,
+      renderTargets: [],
+      wrapS: null,
+      wrapT: null,
+      minFilter: THREE.NearestFilter,
+      magFilter: THREE.NearestFilter
+    };
+    this.variables.push(variable);
+    return variable;
+  };
+  this.setVariableDependencies = function(variable, dependencies) {
+    variable.dependencies = dependencies;
+  };
+  this.init = function() {
+    if (renderer.capabilities.isWebGL2 === false && renderer.extensions.has("OES_texture_float") === false) {
+      return "No OES_texture_float support for float textures.";
+    }
+    if (renderer.capabilities.maxVertexTextures === 0) {
+      return "No support for vertex shader textures.";
+    }
+    for (let i = 0; i < this.variables.length; i++) {
+      var variable = this.variables[i];
+      variable.renderTargets[0] = this.createRenderTarget(
+        sizeX,
+        sizeY,
+        variable.wrapS,
+        variable.wrapT,
+        variable.minFilter,
+        variable.magFilter
+      );
+      variable.renderTargets[1] = this.createRenderTarget(
+        sizeX,
+        sizeY,
+        variable.wrapS,
+        variable.wrapT,
+        variable.minFilter,
+        variable.magFilter
+      );
+      this.renderTexture(variable.initialValueTexture, variable.renderTargets[0]);
+      this.renderTexture(variable.initialValueTexture, variable.renderTargets[1]);
+      var material = variable.material;
+      var uniforms = material.uniforms;
+      if (variable.dependencies !== null) {
+        for (let d = 0; d < variable.dependencies.length; d++) {
+          var depVar = variable.dependencies[d];
+          if (depVar.name !== variable.name) {
+            var found = false;
+            for (let j = 0; j < this.variables.length; j++) {
+              if (depVar.name === this.variables[j].name) {
+                found = true;
+                break;
+              }
+            }
+            if (!found) {
+              return "Variable dependency not found. Variable=" + variable.name + ", dependency=" + depVar.name;
+            }
+          }
+          uniforms[depVar.name] = { value: null };
+          material.fragmentShader = "\nuniform sampler2D " + depVar.name + ";\n" + material.fragmentShader;
+        }
+      }
+    }
+    this.currentTextureIndex = 0;
+    return null;
+  };
+  this.compute = function() {
+    var currentTextureIndex = this.currentTextureIndex;
+    var nextTextureIndex = this.currentTextureIndex === 0 ? 1 : 0;
+    for (let i = 0, il = this.variables.length; i < il; i++) {
+      var variable = this.variables[i];
+      if (variable.dependencies !== null) {
+        var uniforms = variable.material.uniforms;
+        for (let d = 0, dl = variable.dependencies.length; d < dl; d++) {
+          var depVar = variable.dependencies[d];
+          uniforms[depVar.name].value = depVar.renderTargets[currentTextureIndex].texture;
+        }
+      }
+      this.doRenderTarget(variable.material, variable.renderTargets[nextTextureIndex]);
+    }
+    this.currentTextureIndex = nextTextureIndex;
+  };
+  this.getCurrentRenderTarget = function(variable) {
+    return variable.renderTargets[this.currentTextureIndex];
+  };
+  this.getAlternateRenderTarget = function(variable) {
+    return variable.renderTargets[this.currentTextureIndex === 0 ? 1 : 0];
+  };
+  function addResolutionDefine(materialShader) {
+    materialShader.defines.resolution = "vec2( " + sizeX.toFixed(1) + ", " + sizeY.toFixed(1) + " )";
+  }
+  this.addResolutionDefine = addResolutionDefine;
+  function createShaderMaterial(computeFragmentShader, uniforms) {
+    uniforms = uniforms || {};
+    var material = new THREE.ShaderMaterial({
+      uniforms,
+      vertexShader: getPassThroughVertexShader(),
+      fragmentShader: computeFragmentShader
+    });
+    addResolutionDefine(material);
+    return material;
+  }
+  this.createShaderMaterial = createShaderMaterial;
+  this.createRenderTarget = function(sizeXTexture, sizeYTexture, wrapS, wrapT, minFilter, magFilter) {
+    sizeXTexture = sizeXTexture || sizeX;
+    sizeYTexture = sizeYTexture || sizeY;
+    wrapS = wrapS || THREE.ClampToEdgeWrapping;
+    wrapT = wrapT || THREE.ClampToEdgeWrapping;
+    minFilter = minFilter || THREE.NearestFilter;
+    magFilter = magFilter || THREE.NearestFilter;
+    var renderTarget = new THREE.WebGLRenderTarget(sizeXTexture, sizeYTexture, {
+      wrapS,
+      wrapT,
+      minFilter,
+      magFilter,
+      format: THREE.RGBAFormat,
+      type: dataType,
+      depthBuffer: false
+    });
+    return renderTarget;
+  };
+  this.createTexture = function() {
+    var data = new Float32Array(sizeX * sizeY * 4);
+    return new THREE.DataTexture(data, sizeX, sizeY, THREE.RGBAFormat, THREE.FloatType);
+  };
+  this.renderTexture = function(input, output) {
+    passThruUniforms.passThruTexture.value = input;
+    this.doRenderTarget(passThruShader, output);
+    passThruUniforms.passThruTexture.value = null;
+  };
+  this.doRenderTarget = function(material, output) {
+    var currentRenderTarget = renderer.getRenderTarget();
+    mesh.material = material;
+    renderer.setRenderTarget(output);
+    renderer.render(scene, camera);
+    mesh.material = passThruShader;
+    renderer.setRenderTarget(currentRenderTarget);
+  };
+  function getPassThroughVertexShader() {
+    return "void main()	{\n\n	gl_Position = vec4( position, 1.0 );\n\n}\n";
+  }
+  function getPassThroughFragmentShader() {
+    return "uniform sampler2D passThruTexture;\n\nvoid main() {\n\n	vec2 uv = gl_FragCoord.xy / resolution.xy;\n\n	gl_FragColor = texture2D( passThruTexture, uv );\n\n}\n";
+  }
+};
+exports.GPUComputationRenderer = GPUComputationRenderer;

package/dist/misc/GPUComputationRenderer.mjs

@@ -0,0 +1,171 @@
+import { FloatType, Scene, Camera, Mesh, PlaneGeometry, NearestFilter, ShaderMaterial, ClampToEdgeWrapping, WebGLRenderTarget, RGBAFormat, DataTexture } from "three";
+var GPUComputationRenderer = function(sizeX, sizeY, renderer) {
+  this.variables = [];
+  this.currentTextureIndex = 0;
+  var dataType = FloatType;
+  var scene = new Scene();
+  var camera = new Camera();
+  camera.position.z = 1;
+  var passThruUniforms = {
+    passThruTexture: { value: null }
+  };
+  var passThruShader = createShaderMaterial(getPassThroughFragmentShader(), passThruUniforms);
+  var mesh = new Mesh(new PlaneGeometry(2, 2), passThruShader);
+  scene.add(mesh);
+  this.setDataType = function(type) {
+    dataType = type;
+    return this;
+  };
+  this.addVariable = function(variableName, computeFragmentShader, initialValueTexture) {
+    var material = this.createShaderMaterial(computeFragmentShader);
+    var variable = {
+      name: variableName,
+      initialValueTexture,
+      material,
+      dependencies: null,
+      renderTargets: [],
+      wrapS: null,
+      wrapT: null,
+      minFilter: NearestFilter,
+      magFilter: NearestFilter
+    };
+    this.variables.push(variable);
+    return variable;
+  };
+  this.setVariableDependencies = function(variable, dependencies) {
+    variable.dependencies = dependencies;
+  };
+  this.init = function() {
+    if (renderer.capabilities.isWebGL2 === false && renderer.extensions.has("OES_texture_float") === false) {
+      return "No OES_texture_float support for float textures.";
+    }
+    if (renderer.capabilities.maxVertexTextures === 0) {
+      return "No support for vertex shader textures.";
+    }
+    for (let i = 0; i < this.variables.length; i++) {
+      var variable = this.variables[i];
+      variable.renderTargets[0] = this.createRenderTarget(
+        sizeX,
+        sizeY,
+        variable.wrapS,
+        variable.wrapT,
+        variable.minFilter,
+        variable.magFilter
+      );
+      variable.renderTargets[1] = this.createRenderTarget(
+        sizeX,
+        sizeY,
+        variable.wrapS,
+        variable.wrapT,
+        variable.minFilter,
+        variable.magFilter
+      );
+      this.renderTexture(variable.initialValueTexture, variable.renderTargets[0]);
+      this.renderTexture(variable.initialValueTexture, variable.renderTargets[1]);
+      var material = variable.material;
+      var uniforms = material.uniforms;
+      if (variable.dependencies !== null) {
+        for (let d = 0; d < variable.dependencies.length; d++) {
+          var depVar = variable.dependencies[d];
+          if (depVar.name !== variable.name) {
+            var found = false;
+            for (let j = 0; j < this.variables.length; j++) {
+              if (depVar.name === this.variables[j].name) {
+                found = true;
+                break;
+              }
+            }
+            if (!found) {
+              return "Variable dependency not found. Variable=" + variable.name + ", dependency=" + depVar.name;
+            }
+          }
+          uniforms[depVar.name] = { value: null };
+          material.fragmentShader = "\nuniform sampler2D " + depVar.name + ";\n" + material.fragmentShader;
+        }
+      }
+    }
+    this.currentTextureIndex = 0;
+    return null;
+  };
+  this.compute = function() {
+    var currentTextureIndex = this.currentTextureIndex;
+    var nextTextureIndex = this.currentTextureIndex === 0 ? 1 : 0;
+    for (let i = 0, il = this.variables.length; i < il; i++) {
+      var variable = this.variables[i];
+      if (variable.dependencies !== null) {
+        var uniforms = variable.material.uniforms;
+        for (let d = 0, dl = variable.dependencies.length; d < dl; d++) {
+          var depVar = variable.dependencies[d];
+          uniforms[depVar.name].value = depVar.renderTargets[currentTextureIndex].texture;
+        }
+      }
+      this.doRenderTarget(variable.material, variable.renderTargets[nextTextureIndex]);
+    }
+    this.currentTextureIndex = nextTextureIndex;
+  };
+  this.getCurrentRenderTarget = function(variable) {
+    return variable.renderTargets[this.currentTextureIndex];
+  };
+  this.getAlternateRenderTarget = function(variable) {
+    return variable.renderTargets[this.currentTextureIndex === 0 ? 1 : 0];
+  };
+  function addResolutionDefine(materialShader) {
+    materialShader.defines.resolution = "vec2( " + sizeX.toFixed(1) + ", " + sizeY.toFixed(1) + " )";
+  }
+  this.addResolutionDefine = addResolutionDefine;
+  function createShaderMaterial(computeFragmentShader, uniforms) {
+    uniforms = uniforms || {};
+    var material = new ShaderMaterial({
+      uniforms,
+      vertexShader: getPassThroughVertexShader(),
+      fragmentShader: computeFragmentShader
+    });
+    addResolutionDefine(material);
+    return material;
+  }
+  this.createShaderMaterial = createShaderMaterial;
+  this.createRenderTarget = function(sizeXTexture, sizeYTexture, wrapS, wrapT, minFilter, magFilter) {
+    sizeXTexture = sizeXTexture || sizeX;
+    sizeYTexture = sizeYTexture || sizeY;
+    wrapS = wrapS || ClampToEdgeWrapping;
+    wrapT = wrapT || ClampToEdgeWrapping;
+    minFilter = minFilter || NearestFilter;
+    magFilter = magFilter || NearestFilter;
+    var renderTarget = new WebGLRenderTarget(sizeXTexture, sizeYTexture, {
+      wrapS,
+      wrapT,
+      minFilter,
+      magFilter,
+      format: RGBAFormat,
+      type: dataType,
+      depthBuffer: false
+    });
+    return renderTarget;
+  };
+  this.createTexture = function() {
+    var data = new Float32Array(sizeX * sizeY * 4);
+    return new DataTexture(data, sizeX, sizeY, RGBAFormat, FloatType);
+  };
+  this.renderTexture = function(input, output) {
+    passThruUniforms.passThruTexture.value = input;
+    this.doRenderTarget(passThruShader, output);
+    passThruUniforms.passThruTexture.value = null;
+  };
+  this.doRenderTarget = function(material, output) {
+    var currentRenderTarget = renderer.getRenderTarget();
+    mesh.material = material;
+    renderer.setRenderTarget(output);
+    renderer.render(scene, camera);
+    mesh.material = passThruShader;
+    renderer.setRenderTarget(currentRenderTarget);
+  };
+  function getPassThroughVertexShader() {
+    return "void main()	{\n\n	gl_Position = vec4( position, 1.0 );\n\n}\n";
+  }
+  function getPassThroughFragmentShader() {
+    return "uniform sampler2D passThruTexture;\n\nvoid main() {\n\n	vec2 uv = gl_FragCoord.xy / resolution.xy;\n\n	gl_FragColor = texture2D( passThruTexture, uv );\n\n}\n";
+  }
+};
+export {
+  GPUComputationRenderer
+};

package/dist/misc/Gyroscope.d.ts

@@ -0,0 +1,5 @@
+import { Object3D } from 'three'
+
+export class Gyroscope extends Object3D {
+  constructor()
+}

package/dist/misc/Gyroscope.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+var Gyroscope = function() {
+  THREE.Object3D.call(this);
+};
+Gyroscope.prototype = Object.create(THREE.Object3D.prototype);
+Gyroscope.prototype.constructor = Gyroscope;
+Gyroscope.prototype.updateMatrixWorld = function() {
+  var translationObject = new THREE.Vector3();
+  var quaternionObject = new THREE.Quaternion();
+  var scaleObject = new THREE.Vector3();
+  var translationWorld = new THREE.Vector3();
+  var quaternionWorld = new THREE.Quaternion();
+  var scaleWorld = new THREE.Vector3();
+  return function updateMatrixWorld(force) {
+    this.matrixAutoUpdate && this.updateMatrix();
+    if (this.matrixWorldNeedsUpdate || force) {
+      if (this.parent !== null) {
+        this.matrixWorld.multiplyMatrices(this.parent.matrixWorld, this.matrix);
+        this.matrixWorld.decompose(translationWorld, quaternionWorld, scaleWorld);
+        this.matrix.decompose(translationObject, quaternionObject, scaleObject);
+        this.matrixWorld.compose(translationWorld, quaternionObject, scaleWorld);
+      } else {
+        this.matrixWorld.copy(this.matrix);
+      }
+      this.matrixWorldNeedsUpdate = false;
+      force = true;
+    }
+    for (let i = 0, l = this.children.length; i < l; i++) {
+      this.children[i].updateMatrixWorld(force);
+    }
+  };
+}();
+exports.Gyroscope = Gyroscope;

package/dist/misc/Gyroscope.mjs

@@ -0,0 +1,35 @@
+import { Object3D, Vector3, Quaternion } from "three";
+var Gyroscope = function() {
+  Object3D.call(this);
+};
+Gyroscope.prototype = Object.create(Object3D.prototype);
+Gyroscope.prototype.constructor = Gyroscope;
+Gyroscope.prototype.updateMatrixWorld = function() {
+  var translationObject = new Vector3();
+  var quaternionObject = new Quaternion();
+  var scaleObject = new Vector3();
+  var translationWorld = new Vector3();
+  var quaternionWorld = new Quaternion();
+  var scaleWorld = new Vector3();
+  return function updateMatrixWorld(force) {
+    this.matrixAutoUpdate && this.updateMatrix();
+    if (this.matrixWorldNeedsUpdate || force) {
+      if (this.parent !== null) {
+        this.matrixWorld.multiplyMatrices(this.parent.matrixWorld, this.matrix);
+        this.matrixWorld.decompose(translationWorld, quaternionWorld, scaleWorld);
+        this.matrix.decompose(translationObject, quaternionObject, scaleObject);
+        this.matrixWorld.compose(translationWorld, quaternionObject, scaleWorld);
+      } else {
+        this.matrixWorld.copy(this.matrix);
+      }
+      this.matrixWorldNeedsUpdate = false;
+      force = true;
+    }
+    for (let i = 0, l = this.children.length; i < l; i++) {
+      this.children[i].updateMatrixWorld(force);
+    }
+  };
+}();
+export {
+  Gyroscope
+};

package/dist/misc/MD2Character.d.ts

@@ -0,0 +1,33 @@
+import { Object3D, Mesh, Texture, AnimationMixer } from 'three'
+
+export interface MD2PartsConfig {
+  baseUrl: string
+  body: string
+  skins: string[]
+  weapons: Array<[string, string]>
+}
+
+export class MD2Character {
+  constructor()
+  scale: number
+  animationFPS: number
+  root: Object3D
+  meshBody: Mesh | null
+  meshWeapon: Mesh | null
+  skinsBody: Texture[]
+  skinsWeapon: Texture[]
+  weapons: Mesh[]
+  activeAnimation: string | null
+  mixer: AnimationMixer | null
+  loadCounter: number
+
+  onLoadComplete(): void
+  loadParts(config: MD2PartsConfig): void
+  setPlaybackRate(rate: number): void
+  setWireframe(wireframeEnabled: boolean): void
+  setSkin(index: number): void
+  setWeapon(index: number): void
+  setAnimation(clipName: string): void
+  syncWeaponAnimation(): void
+  update(delta: number): void
+}

package/dist/misc/MD2Character.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const MD2Loader = require("../loaders/MD2Loader.js");
+var MD2Character = function() {
+  var scope = this;
+  this.scale = 1;
+  this.animationFPS = 6;
+  this.root = new THREE.Object3D();
+  this.meshBody = null;
+  this.meshWeapon = null;
+  this.skinsBody = [];
+  this.skinsWeapon = [];
+  this.weapons = [];
+  this.activeAnimation = null;
+  this.mixer = null;
+  this.onLoadComplete = function() {
+  };
+  this.loadCounter = 0;
+  this.loadParts = function(config) {
+    this.loadCounter = config.weapons.length * 2 + config.skins.length + 1;
+    var weaponsTextures = [];
+    for (let i = 0; i < config.weapons.length; i++)
+      weaponsTextures[i] = config.weapons[i][1];
+    this.skinsBody = loadTextures(config.baseUrl + "skins/", config.skins);
+    this.skinsWeapon = loadTextures(config.baseUrl + "skins/", weaponsTextures);
+    var loader = new MD2Loader.MD2Loader();
+    loader.load(config.baseUrl + config.body, function(geo) {
+      var boundingBox = new THREE.Box3();
+      boundingBox.setFromBufferAttribute(geo.attributes.position);
+      scope.root.position.y = -scope.scale * boundingBox.min.y;
+      var mesh = createPart(geo, scope.skinsBody[0]);
+      mesh.scale.set(scope.scale, scope.scale, scope.scale);
+      scope.root.add(mesh);
+      scope.meshBody = mesh;
+      scope.meshBody.clipOffset = 0;
+      scope.activeAnimationClipName = mesh.geometry.animations[0].name;
+      scope.mixer = new THREE.AnimationMixer(mesh);
+      checkLoadingComplete();
+    });
+    var generateCallback = function(index, name) {
+      return function(geo) {
+        var mesh = createPart(geo, scope.skinsWeapon[index]);
+        mesh.scale.set(scope.scale, scope.scale, scope.scale);
+        mesh.visible = false;
+        mesh.name = name;
+        scope.root.add(mesh);
+        scope.weapons[index] = mesh;
+        scope.meshWeapon = mesh;
+        checkLoadingComplete();
+      };
+    };
+    for (let i = 0; i < config.weapons.length; i++) {
+      loader.load(config.baseUrl + config.weapons[i][0], generateCallback(i, config.weapons[i][0]));
+    }
+  };
+  this.setPlaybackRate = function(rate) {
+    if (rate !== 0) {
+      this.mixer.timeScale = 1 / rate;
+    } else {
+      this.mixer.timeScale = 0;
+    }
+  };
+  this.setWireframe = function(wireframeEnabled) {
+    if (wireframeEnabled) {
+      if (this.meshBody)
+        this.meshBody.material = this.meshBody.materialWireframe;
+      if (this.meshWeapon)
+        this.meshWeapon.material = this.meshWeapon.materialWireframe;
+    } else {
+      if (this.meshBody)
+        this.meshBody.material = this.meshBody.materialTexture;
+      if (this.meshWeapon)
+        this.meshWeapon.material = this.meshWeapon.materialTexture;
+    }
+  };
+  this.setSkin = function(index) {
+    if (this.meshBody && this.meshBody.material.wireframe === false) {
+      this.meshBody.material.map = this.skinsBody[index];
+    }
+  };
+  this.setWeapon = function(index) {
+    for (let i = 0; i < this.weapons.length; i++)
+      this.weapons[i].visible = false;
+    var activeWeapon = this.weapons[index];
+    if (activeWeapon) {
+      activeWeapon.visible = true;
+      this.meshWeapon = activeWeapon;
+      scope.syncWeaponAnimation();
+    }
+  };
+  this.setAnimation = function(clipName) {
+    if (this.meshBody) {
+      if (this.meshBody.activeAction) {
+        this.meshBody.activeAction.stop();
+        this.meshBody.activeAction = null;
+      }
+      var action = this.mixer.clipAction(clipName, this.meshBody);
+      if (action) {
+        this.meshBody.activeAction = action.play();
+      }
+    }
+    scope.activeClipName = clipName;
+    scope.syncWeaponAnimation();
+  };
+  this.syncWeaponAnimation = function() {
+    var clipName = scope.activeClipName;
+    if (scope.meshWeapon) {
+      if (this.meshWeapon.activeAction) {
+        this.meshWeapon.activeAction.stop();
+        this.meshWeapon.activeAction = null;
+      }
+      var action = this.mixer.clipAction(clipName, this.meshWeapon);
+      if (action) {
+        this.meshWeapon.activeAction = action.syncWith(this.meshBody.activeAction).play();
+      }
+    }
+  };
+  this.update = function(delta) {
+    if (this.mixer)
+      this.mixer.update(delta);
+  };
+  function loadTextures(baseUrl, textureUrls) {
+    var textureLoader = new THREE.TextureLoader();
+    var textures = [];
+    for (let i = 0; i < textureUrls.length; i++) {
+      textures[i] = textureLoader.load(baseUrl + textureUrls[i], checkLoadingComplete);
+      textures[i].mapping = THREE.UVMapping;
+      textures[i].name = textureUrls[i];
+      if ("colorSpace" in textures[i])
+        textures[i].colorSpace = "srgb";
+      else
+        textures[i].encoding = 3001;
+    }
+    return textures;
+  }
+  function createPart(geometry, skinMap) {
+    var materialWireframe = new THREE.MeshLambertMaterial({
+      color: 16755200,
+      wireframe: true,
+      morphTargets: true,
+      morphNormals: true
+    });
+    var materialTexture = new THREE.MeshLambertMaterial({
+      color: 16777215,
+      wireframe: false,
+      map: skinMap,
+      morphTargets: true,
+      morphNormals: true
+    });
+    var mesh = new THREE.Mesh(geometry, materialTexture);
+    mesh.rotation.y = -Math.PI / 2;
+    mesh.castShadow = true;
+    mesh.receiveShadow = true;
+    mesh.materialTexture = materialTexture;
+    mesh.materialWireframe = materialWireframe;
+    return mesh;
+  }
+  function checkLoadingComplete() {
+    scope.loadCounter -= 1;
+    if (scope.loadCounter === 0)
+      scope.onLoadComplete();
+  }
+};
+exports.MD2Character = MD2Character;