diff --git a/webgl/gltf-demo/.gitignore b/webgl/gltf-demo/.gitignore
new file mode 100644
index 0000000..dd9b9d9
--- /dev/null
+++ b/webgl/gltf-demo/.gitignore
@@ -0,0 +1,3 @@
+build/
+!build/basis_transcoder.js
+!build/basis_transcoder.wasm
diff --git a/webgl/gltf-demo/AGI_HQ/AgiHQ.gltf b/webgl/gltf-demo/AGI_HQ/AgiHQ.gltf
new file mode 100644
index 0000000..4b364cb
--- /dev/null
+++ b/webgl/gltf-demo/AGI_HQ/AgiHQ.gltf
@@ -0,0 +1,281 @@
+{
+  "accessors": [
+    {
+      "name": "Node-Mesh_0_positions",
+      "componentType": 5126,
+      "count": 426519,
+      "min": [
+        -263.67950439453125,
+        -280.67950439453125,
+        -52.20021438598633
+      ],
+      "max": [
+        299.67950439453125,
+        247.67950439453125,
+        -13.959484100341797
+      ],
+      "type": "VEC3",
+      "bufferView": 0,
+      "byteOffset": 0
+    },
+    {
+      "name": "Node-Mesh_0_texcoords",
+      "componentType": 5126,
+      "count": 426519,
+      "min": [
+        0.001038654474541545,
+        0.0010396799771115184
+      ],
+      "max": [
+        0.9990835189819336,
+        0.9990107417106628
+      ],
+      "type": "VEC2",
+      "bufferView": 1,
+      "byteOffset": 0
+    },
+    {
+      "name": "Node-Mesh_0_indices",
+      "componentType": 5125,
+      "count": 2055249,
+      "min": [
+        0
+      ],
+      "max": [
+        426518
+      ],
+      "type": "SCALAR",
+      "bufferView": 2,
+      "byteOffset": 0
+    },
+    {
+      "name": "Node-Mesh_1_positions",
+      "componentType": 5126,
+      "count": 513603,
+      "min": [
+        -263.67950439453125,
+        -280.67950439453125,
+        -52.742218017578125
+      ],
+      "max": [
+        299.67950439453125,
+        247.67950439453125,
+        -12.004308700561523
+      ],
+      "type": "VEC3",
+      "bufferView": 0,
+      "byteOffset": 5118228
+    },
+    {
+      "name": "Node-Mesh_1_texcoords",
+      "componentType": 5126,
+      "count": 513603,
+      "min": [
+        0.0010405026841908693,
+        0.0010377200087532401
+      ],
+      "max": [
+        0.999070942401886,
+        0.9744246006011963
+      ],
+      "type": "VEC2",
+      "bufferView": 1,
+      "byteOffset": 3412152
+    },
+    {
+      "name": "Node-Mesh_1_indices",
+      "componentType": 5125,
+      "count": 2128626,
+      "min": [
+        0
+      ],
+      "max": [
+        513602
+      ],
+      "type": "SCALAR",
+      "bufferView": 2,
+      "byteOffset": 8220996
+    }
+  ],
+  "asset": {
+    "generator": "obj2gltf",
+    "version": "2.0"
+  },
+  "buffers": [
+    {
+      "name": "Model",
+      "byteLength": 35537940,
+      "uri": "Model.bin"
+    }
+  ],
+  "bufferViews": [
+    {
+      "name": "bufferView_0",
+      "buffer": 0,
+      "byteLength": 11281464,
+      "byteOffset": 0,
+      "byteStride": 12,
+      "target": 34962
+    },
+    {
+      "name": "bufferView_1",
+      "buffer": 0,
+      "byteLength": 7520976,
+      "byteOffset": 11281464,
+      "byteStride": 8,
+      "target": 34962
+    },
+    {
+      "name": "bufferView_2",
+      "buffer": 0,
+      "byteLength": 16735500,
+      "byteOffset": 18802440,
+      "target": 34963
+    }
+  ],
+  "materials": [
+    {
+      "name": "Model_0",
+      "pbrMetallicRoughness": {
+        "baseColorTexture": {
+          "index": 0
+        },
+        "baseColorFactor": [
+          1,
+          1,
+          1,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "name": "Model_1",
+      "pbrMetallicRoughness": {
+        "baseColorTexture": {
+          "index": 1
+        },
+        "baseColorFactor": [
+          1,
+          1,
+          1,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    }
+  ],
+  "meshes": [
+    {
+      "name": "Node-Mesh",
+      "primitives": [
+        {
+          "attributes": {
+            "POSITION": 0,
+            "TEXCOORD_0": 1
+          },
+          "indices": 2,
+          "material": 0,
+          "mode": 4
+        },
+        {
+          "attributes": {
+            "POSITION": 3,
+            "TEXCOORD_0": 4
+          },
+          "indices": 5,
+          "material": 1,
+          "mode": 4
+        }
+      ]
+    }
+  ],
+  "nodes": [
+    {
+      "rotation": [
+        0.7071067811865476,
+        0,
+        0,
+        -0.7071067811865476
+      ],
+      "name": "Node",
+      "mesh": 0
+    },
+    {
+      "children": [
+        0
+      ],
+      "name": "Root"
+    }
+  ],
+  "samplers": [
+    {
+      "magFilter": 9729,
+      "minFilter": 9729,
+      "wrapS": 10497,
+      "wrapT": 10497
+    }
+  ],
+  "scene": 0,
+  "scenes": [
+    {
+      "nodes": [
+        1
+      ]
+    }
+  ],
+  "images": [
+    {
+      "name": "Model_0",
+      "mimeType": "image/basis",
+      "uri": "Model_0_4096.basis"
+    },
+    {
+      "name": "Model_1",
+      "mimeType": "image/basis",
+      "uri": "Model_1_4096.basis"
+    }
+  ],
+  "textures": [
+    {
+      "name": "Model_0",
+      "sampler": 0,
+      "extensions": {
+        "GOOGLE_texture_basis": {
+          "source": 0
+        }
+      }
+    },
+    {
+      "name": "Model_1",
+      "sampler": 0,
+      "extensions": {
+        "GOOGLE_texture_basis": {
+          "source": 1
+        }
+      }
+    }
+  ],
+  "extensionsUsed": [
+    "GOOGLE_texture_basis"
+  ],
+  "extensionsRequired": [
+    "GOOGLE_texture_basis"
+  ]
+}
diff --git a/webgl/gltf-demo/AGI_HQ/Model.bin b/webgl/gltf-demo/AGI_HQ/Model.bin
new file mode 100644
index 0000000..abae6cf
--- /dev/null
+++ b/webgl/gltf-demo/AGI_HQ/Model.bin
Binary files differ
diff --git a/webgl/gltf-demo/AGI_HQ/Model_0_4096.basis b/webgl/gltf-demo/AGI_HQ/Model_0_4096.basis
new file mode 100644
index 0000000..f0f00c4
--- /dev/null
+++ b/webgl/gltf-demo/AGI_HQ/Model_0_4096.basis
Binary files differ
diff --git a/webgl/gltf-demo/AGI_HQ/Model_1_4096.basis b/webgl/gltf-demo/AGI_HQ/Model_1_4096.basis
new file mode 100644
index 0000000..24e5c32
--- /dev/null
+++ b/webgl/gltf-demo/AGI_HQ/Model_1_4096.basis
Binary files differ
diff --git a/webgl/gltf-demo/BasisTextureLoader.js b/webgl/gltf-demo/BasisTextureLoader.js
new file mode 100644
index 0000000..4f79545
--- /dev/null
+++ b/webgl/gltf-demo/BasisTextureLoader.js
@@ -0,0 +1,169 @@
+/**
+ * @author Don McCurdy / https://www.donmccurdy.com
+ * @author Austin Eng / https://github.com/austinEng
+ * @author Shrek Shao / https://github.com/shrekshao
+ */
+
+/**
+ * An example three.js loader for Basis compressed textures.
+ */
+THREE.BasisTextureLoader = class BasisTextureLoader {
+
+  constructor () {
+
+    this.etcSupported = false;
+    this.dxtSupported = false;
+    this.pvrtcSupported = false;
+
+    this.format = null;
+
+  }
+
+  detectSupport ( renderer ) {
+
+    const context = renderer.context;
+
+    this.etcSupported = context.getExtension('WEBGL_compressed_texture_etc1');
+    this.dxtSupported = context.getExtension('WEBGL_compressed_texture_s3tc');
+    this.pvrtcSupported = context.getExtension('WEBGL_compressed_texture_pvrtc')
+      || context.getExtension('WEBKIT_WEBGL_compressed_texture_pvrtc');
+
+    if ( ! this.etcSupported && ! this.dxtSupported && ! this.pvrtcSupported ) {
+
+      throw new Error( 'THREE.BasisTextureLoader: No suitable compressed texture format found.' );
+
+    }
+
+    this.format = this.etcSupported
+      ? BASIS_FORMAT.cTFETC1
+      : ( this.dxtSupported
+        ? BASIS_FORMAT.cTFBC1
+        : BASIS_FORMAT.cTFPVRTC1_4_OPAQUE_ONLY );
+
+     return this;
+
+  }
+
+  load ( url, onLoad, onProgress, onError ) {
+
+    fetch( url )
+      .then( ( res ) => res.arrayBuffer() )
+      .then( (arrayBuffer) => this._createTexture( arrayBuffer ) )
+      .then( onLoad )
+      .catch( onError );
+
+  }
+
+  _createTexture ( arrayBuffer ) {
+
+    const BASIS_FORMAT = THREE.BasisTextureLoader.BASIS_FORMAT;
+    const DXT_FORMAT_MAP = THREE.BasisTextureLoader.DXT_FORMAT_MAP;
+
+    const basisFile = new BasisFile( new Uint8Array( arrayBuffer ) );
+
+    const width = basisFile.getImageWidth( 0, 0 );
+    const height = basisFile.getImageHeight( 0, 0 );
+    const images = basisFile.getNumImages();
+    const levels = basisFile.getNumLevels( 0 );
+
+    function cleanup () {
+
+      basisFile.close();
+      basisFile.delete();
+
+    }
+
+    if ( ! width || ! height || ! images || ! levels ) {
+
+      cleanup();
+      throw new Error( 'THREE.BasisTextureLoader:  Invalid .basis file' );
+
+    }
+
+    if ( ! basisFile.startTranscoding() ) {
+
+      cleanup();
+      throw new Error( 'THREE.BasisTextureLoader: .startTranscoding failed' );
+
+    }
+
+    const dst = new Uint8Array( basisFile.getImageTranscodedSizeInBytes( 0, 0, this.format ) );
+
+    const startTime = performance.now();
+
+    const status = basisFile.transcodeImage(
+      dst,
+      0,
+      0,
+      this.format,
+      this.etcSupported ? 0 : ( this.dxtSupported ? 1 : 0 ),
+      0
+    );
+
+    console.log( `THREE.BasisTextureLoader: Transcode time: ${performance.now() - startTime}ms`, dst );
+
+    cleanup();
+
+    if ( ! status ) {
+
+      throw new Error( 'THREE.BasisTextureLoader: .transcodeImage failed.' );
+
+    }
+
+    const mipmaps = [ { data: dst, width, height } ];
+
+    let texture;
+
+    if ( this.etcSupported ) {
+
+      texture = new THREE.CompressedTexture( mipmaps, width, height, THREE.RGB_ETC1_Format );
+
+    } else if ( this.dxtSupported ) {
+
+      texture = new THREE.CompressedTexture( mipmaps, width, height, DXT_FORMAT_MAP[ this.format ], THREE.UnsignedByteType );
+
+    } else if ( this.pvrtcSupported ) {
+
+      texture = new THREE.CompressedTexture( mipmaps, width, height, THREE.RGB_PVRTC_4BPPV1_Format );
+
+    } else {
+
+      throw new Error( 'THREE.BasisTextureLoader: No supported format available.' );
+
+    }
+
+    texture.minFilter = THREE.LinearMipMapLinearFilter;
+    texture.magFilter = THREE.LinearFilter;
+    texture.encoding = THREE.sRGBEncoding;
+    texture.generateMipmaps = false;
+    texture.flipY = false;
+    texture.needsUpdate = true;
+
+    return texture;
+
+  }
+}
+
+const BASIS_FORMAT = {
+  cTFETC1: 0,
+  cTFBC1: 1,
+  cTFBC4: 2,
+  cTFPVRTC1_4_OPAQUE_ONLY: 3,
+  cTFBC7_M6_OPAQUE_ONLY: 4,
+  cTFETC2: 5,
+  cTFBC3: 6,
+  cTFBC5: 7,
+};
+
+// DXT formats, from:
+// http://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_s3tc/
+const DXT_FORMAT_MAP = {};
+const COMPRESSED_RGB_S3TC_DXT1_EXT  = 0x83F0;
+const COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1;
+const COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2;
+const COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3;
+DXT_FORMAT_MAP[ BASIS_FORMAT.cTFBC1 ] = COMPRESSED_RGB_S3TC_DXT1_EXT;
+DXT_FORMAT_MAP[ BASIS_FORMAT.cTFBC3 ] = COMPRESSED_RGBA_S3TC_DXT5_EXT;
+
+THREE.BasisTextureLoader.BASIS_FORMAT = BASIS_FORMAT;
+THREE.BasisTextureLoader.DXT_FORMAT_MAP = DXT_FORMAT_MAP;
diff --git a/webgl/gltf-demo/GLTFLoader.js b/webgl/gltf-demo/GLTFLoader.js
new file mode 100644
index 0000000..31bc8af
--- /dev/null
+++ b/webgl/gltf-demo/GLTFLoader.js
@@ -0,0 +1,3214 @@
+/**
+ * Copyright 2019 the three.js authors
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * @author Rich Tibbett / https://github.com/richtr
+ * @author mrdoob / http://mrdoob.com/
+ * @author Tony Parisi / http://www.tonyparisi.com/
+ * @author Takahiro / https://github.com/takahirox
+ * @author Don McCurdy / https://www.donmccurdy.com
+ */
+
+/**
+ * A modified version of THREE.GLTFLoader, with support for the (hypothetical)
+ * GOOGLE_texture_basis extension. This extension is defined for the sake of
+ * example only – the glTF format will officially reference Basis files within
+ * a KTX2 wrapper.
+ */
+THREE.GLTFLoader = ( function () {
+
+  function GLTFLoader( manager ) {
+
+    this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+    this.dracoLoader = null;
+
+  }
+
+  GLTFLoader.prototype = {
+
+    constructor: GLTFLoader,
+
+    crossOrigin: 'anonymous',
+
+    load: function ( url, onLoad, onProgress, onError ) {
+
+      var scope = this;
+
+      var resourcePath;
+
+      if ( this.resourcePath !== undefined ) {
+
+        resourcePath = this.resourcePath;
+
+      } else if ( this.path !== undefined ) {
+
+        resourcePath = this.path;
+
+      } else {
+
+        resourcePath = THREE.LoaderUtils.extractUrlBase( url );
+
+      }
+
+      // Tells the LoadingManager to track an extra item, which resolves after
+      // the model is fully loaded. This means the count of items loaded will
+      // be incorrect, but ensures manager.onLoad() does not fire early.
+      scope.manager.itemStart( url );
+
+      var _onError = function ( e ) {
+
+        if ( onError ) {
+
+          onError( e );
+
+        } else {
+
+          console.error( e );
+
+        }
+
+        scope.manager.itemError( url );
+        scope.manager.itemEnd( url );
+
+      };
+
+      var loader = new THREE.FileLoader( scope.manager );
+
+      loader.setPath( this.path );
+      loader.setResponseType( 'arraybuffer' );
+
+      loader.load( url, function ( data ) {
+
+        try {
+
+          scope.parse( data, resourcePath, function ( gltf ) {
+
+            onLoad( gltf );
+
+            scope.manager.itemEnd( url );
+
+          }, _onError );
+
+        } catch ( e ) {
+
+          _onError( e );
+
+        }
+
+      }, onProgress, _onError );
+
+    },
+
+    setCrossOrigin: function ( value ) {
+
+      this.crossOrigin = value;
+      return this;
+
+    },
+
+    setPath: function ( value ) {
+
+      this.path = value;
+      return this;
+
+    },
+
+    setResourcePath: function ( value ) {
+
+      this.resourcePath = value;
+      return this;
+
+    },
+
+    setDRACOLoader: function ( dracoLoader ) {
+
+      this.dracoLoader = dracoLoader;
+      return this;
+
+    },
+
+    parse: function ( data, path, onLoad, onError ) {
+
+      var content;
+      var extensions = {};
+
+      if ( typeof data === 'string' ) {
+
+        content = data;
+
+      } else {
+
+        var magic = THREE.LoaderUtils.decodeText( new Uint8Array( data, 0, 4 ) );
+
+        if ( magic === BINARY_EXTENSION_HEADER_MAGIC ) {
+
+          try {
+
+            extensions[ EXTENSIONS.KHR_BINARY_GLTF ] = new GLTFBinaryExtension( data );
+
+          } catch ( error ) {
+
+            if ( onError ) onError( error );
+            return;
+
+          }
+
+          content = extensions[ EXTENSIONS.KHR_BINARY_GLTF ].content;
+
+        } else {
+
+          content = THREE.LoaderUtils.decodeText( new Uint8Array( data ) );
+
+        }
+
+      }
+
+      var json = JSON.parse( content );
+
+      if ( json.asset === undefined || json.asset.version[ 0 ] < 2 ) {
+
+        if ( onError ) onError( new Error( 'THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported. Use LegacyGLTFLoader instead.' ) );
+        return;
+
+      }
+
+      if ( json.extensionsUsed ) {
+
+        for ( var i = 0; i < json.extensionsUsed.length; ++ i ) {
+
+          var extensionName = json.extensionsUsed[ i ];
+          var extensionsRequired = json.extensionsRequired || [];
+
+          switch ( extensionName ) {
+
+            case EXTENSIONS.KHR_LIGHTS_PUNCTUAL:
+              extensions[ extensionName ] = new GLTFLightsExtension( json );
+              break;
+
+            case EXTENSIONS.KHR_MATERIALS_UNLIT:
+              extensions[ extensionName ] = new GLTFMaterialsUnlitExtension( json );
+              break;
+
+            case EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS:
+              extensions[ extensionName ] = new GLTFMaterialsPbrSpecularGlossinessExtension( json );
+              break;
+
+            case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:
+              extensions[ extensionName ] = new GLTFDracoMeshCompressionExtension( json, this.dracoLoader );
+              break;
+
+            case EXTENSIONS.MSFT_TEXTURE_DDS:
+              extensions[ EXTENSIONS.MSFT_TEXTURE_DDS ] = new GLTFTextureDDSExtension();
+              break;
+
+            case EXTENSIONS.GOOGLE_TEXTURE_BASIS:
+              extensions[ EXTENSIONS.GOOGLE_TEXTURE_BASIS ] = new GLTFTextureBasisExtension();
+              break;
+
+            case EXTENSIONS.KHR_TEXTURE_TRANSFORM:
+              extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] = new GLTFTextureTransformExtension( json );
+              break;
+
+            default:
+
+              if ( extensionsRequired.indexOf( extensionName ) >= 0 ) {
+
+                console.warn( 'THREE.GLTFLoader: Unknown extension "' + extensionName + '".' );
+
+              }
+
+          }
+
+        }
+
+      }
+
+      var parser = new GLTFParser( json, extensions, {
+
+        path: path || this.resourcePath || '',
+        crossOrigin: this.crossOrigin,
+        manager: this.manager
+
+      } );
+
+      parser.parse( onLoad, onError );
+
+    }
+
+  };
+
+  /* GLTFREGISTRY */
+
+  function GLTFRegistry() {
+
+    var objects = {};
+
+    return  {
+
+      get: function ( key ) {
+
+        return objects[ key ];
+
+      },
+
+      add: function ( key, object ) {
+
+        objects[ key ] = object;
+
+      },
+
+      remove: function ( key ) {
+
+        delete objects[ key ];
+
+      },
+
+      removeAll: function () {
+
+        objects = {};
+
+      }
+
+    };
+
+  }
+
+  /*********************************/
+  /********** EXTENSIONS ***********/
+  /*********************************/
+
+  var EXTENSIONS = {
+    KHR_BINARY_GLTF: 'KHR_binary_glTF',
+    KHR_DRACO_MESH_COMPRESSION: 'KHR_draco_mesh_compression',
+    KHR_LIGHTS_PUNCTUAL: 'KHR_lights_punctual',
+    KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS: 'KHR_materials_pbrSpecularGlossiness',
+    KHR_MATERIALS_UNLIT: 'KHR_materials_unlit',
+    KHR_TEXTURE_TRANSFORM: 'KHR_texture_transform',
+    MSFT_TEXTURE_DDS: 'MSFT_texture_dds',
+    GOOGLE_TEXTURE_BASIS: 'GOOGLE_texture_basis'
+  };
+
+  /**
+   * DDS Texture Extension
+   *
+   * Specification:
+   * https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_texture_dds
+   *
+   */
+  function GLTFTextureDDSExtension() {
+
+    if ( ! THREE.DDSLoader ) {
+
+      throw new Error( 'THREE.GLTFLoader: Attempting to load .dds texture without importing THREE.DDSLoader' );
+
+    }
+
+    this.name = EXTENSIONS.MSFT_TEXTURE_DDS;
+    this.ddsLoader = new THREE.DDSLoader();
+
+  }
+
+  /**
+   * Basis Texture Extension
+   *
+   */
+  function GLTFTextureBasisExtension() {
+
+    this.name = EXTENSIONS.GOOGLE_TEXTURE_BASIS;
+
+  }
+
+  /**
+   * Lights Extension
+   *
+   * Specification: PENDING
+   */
+  function GLTFLightsExtension( json ) {
+
+    this.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL;
+
+    var extension = ( json.extensions && json.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ] ) || {};
+    this.lightDefs = extension.lights || [];
+
+  }
+
+  GLTFLightsExtension.prototype.loadLight = function ( lightIndex ) {
+
+    var lightDef = this.lightDefs[ lightIndex ];
+    var lightNode;
+
+    var color = new THREE.Color( 0xffffff );
+    if ( lightDef.color !== undefined ) color.fromArray( lightDef.color );
+
+    var range = lightDef.range !== undefined ? lightDef.range : 0;
+
+    switch ( lightDef.type ) {
+
+      case 'directional':
+        lightNode = new THREE.DirectionalLight( color );
+        lightNode.target.position.set( 0, 0, - 1 );
+        lightNode.add( lightNode.target );
+        break;
+
+      case 'point':
+        lightNode = new THREE.PointLight( color );
+        lightNode.distance = range;
+        break;
+
+      case 'spot':
+        lightNode = new THREE.SpotLight( color );
+        lightNode.distance = range;
+        // Handle spotlight properties.
+        lightDef.spot = lightDef.spot || {};
+        lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== undefined ? lightDef.spot.innerConeAngle : 0;
+        lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== undefined ? lightDef.spot.outerConeAngle : Math.PI / 4.0;
+        lightNode.angle = lightDef.spot.outerConeAngle;
+        lightNode.penumbra = 1.0 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle;
+        lightNode.target.position.set( 0, 0, - 1 );
+        lightNode.add( lightNode.target );
+        break;
+
+      default:
+        throw new Error( 'THREE.GLTFLoader: Unexpected light type, "' + lightDef.type + '".' );
+
+    }
+
+    // Some lights (e.g. spot) default to a position other than the origin. Reset the position
+    // here, because node-level parsing will only override position if explicitly specified.
+    lightNode.position.set( 0, 0, 0 );
+
+    lightNode.decay = 2;
+
+    if ( lightDef.intensity !== undefined ) lightNode.intensity = lightDef.intensity;
+
+    lightNode.name = lightDef.name || ( 'light_' + lightIndex );
+
+    return Promise.resolve( lightNode );
+
+  };
+
+  /**
+   * Unlit Materials Extension (pending)
+   *
+   * PR: https://github.com/KhronosGroup/glTF/pull/1163
+   */
+  function GLTFMaterialsUnlitExtension() {
+
+    this.name = EXTENSIONS.KHR_MATERIALS_UNLIT;
+
+  }
+
+  GLTFMaterialsUnlitExtension.prototype.getMaterialType = function () {
+
+    return THREE.MeshBasicMaterial;
+
+  };
+
+  GLTFMaterialsUnlitExtension.prototype.extendParams = function ( materialParams, materialDef, parser ) {
+
+    var pending = [];
+
+    materialParams.color = new THREE.Color( 1.0, 1.0, 1.0 );
+    materialParams.opacity = 1.0;
+
+    var metallicRoughness = materialDef.pbrMetallicRoughness;
+
+    if ( metallicRoughness ) {
+
+      if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {
+
+        var array = metallicRoughness.baseColorFactor;
+
+        materialParams.color.fromArray( array );
+        materialParams.opacity = array[ 3 ];
+
+      }
+
+      if ( metallicRoughness.baseColorTexture !== undefined ) {
+
+        pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture ) );
+
+      }
+
+    }
+
+    return Promise.all( pending );
+
+  };
+
+  /* BINARY EXTENSION */
+
+  var BINARY_EXTENSION_BUFFER_NAME = 'binary_glTF';
+  var BINARY_EXTENSION_HEADER_MAGIC = 'glTF';
+  var BINARY_EXTENSION_HEADER_LENGTH = 12;
+  var BINARY_EXTENSION_CHUNK_TYPES = { JSON: 0x4E4F534A, BIN: 0x004E4942 };
+
+  function GLTFBinaryExtension( data ) {
+
+    this.name = EXTENSIONS.KHR_BINARY_GLTF;
+    this.content = null;
+    this.body = null;
+
+    var headerView = new DataView( data, 0, BINARY_EXTENSION_HEADER_LENGTH );
+
+    this.header = {
+      magic: THREE.LoaderUtils.decodeText( new Uint8Array( data.slice( 0, 4 ) ) ),
+      version: headerView.getUint32( 4, true ),
+      length: headerView.getUint32( 8, true )
+    };
+
+    if ( this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC ) {
+
+      throw new Error( 'THREE.GLTFLoader: Unsupported glTF-Binary header.' );
+
+    } else if ( this.header.version < 2.0 ) {
+
+      throw new Error( 'THREE.GLTFLoader: Legacy binary file detected. Use LegacyGLTFLoader instead.' );
+
+    }
+
+    var chunkView = new DataView( data, BINARY_EXTENSION_HEADER_LENGTH );
+    var chunkIndex = 0;
+
+    while ( chunkIndex < chunkView.byteLength ) {
+
+      var chunkLength = chunkView.getUint32( chunkIndex, true );
+      chunkIndex += 4;
+
+      var chunkType = chunkView.getUint32( chunkIndex, true );
+      chunkIndex += 4;
+
+      if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON ) {
+
+        var contentArray = new Uint8Array( data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength );
+        this.content = THREE.LoaderUtils.decodeText( contentArray );
+
+      } else if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN ) {
+
+        var byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;
+        this.body = data.slice( byteOffset, byteOffset + chunkLength );
+
+      }
+
+      // Clients must ignore chunks with unknown types.
+
+      chunkIndex += chunkLength;
+
+    }
+
+    if ( this.content === null ) {
+
+      throw new Error( 'THREE.GLTFLoader: JSON content not found.' );
+
+    }
+
+  }
+
+  /**
+   * DRACO Mesh Compression Extension
+   *
+   * Specification: https://github.com/KhronosGroup/glTF/pull/874
+   */
+  function GLTFDracoMeshCompressionExtension( json, dracoLoader ) {
+
+    if ( ! dracoLoader ) {
+
+      throw new Error( 'THREE.GLTFLoader: No DRACOLoader instance provided.' );
+
+    }
+
+    this.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION;
+    this.json = json;
+    this.dracoLoader = dracoLoader;
+
+  }
+
+  GLTFDracoMeshCompressionExtension.prototype.decodePrimitive = function ( primitive, parser ) {
+
+    var json = this.json;
+    var dracoLoader = this.dracoLoader;
+    var bufferViewIndex = primitive.extensions[ this.name ].bufferView;
+    var gltfAttributeMap = primitive.extensions[ this.name ].attributes;
+    var threeAttributeMap = {};
+    var attributeNormalizedMap = {};
+    var attributeTypeMap = {};
+
+    for ( var attributeName in gltfAttributeMap ) {
+
+      var threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();
+
+      threeAttributeMap[ threeAttributeName ] = gltfAttributeMap[ attributeName ];
+
+    }
+
+    for ( attributeName in primitive.attributes ) {
+
+      var threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();
+
+      if ( gltfAttributeMap[ attributeName ] !== undefined ) {
+
+        var accessorDef = json.accessors[ primitive.attributes[ attributeName ] ];
+        var componentType = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
+
+        attributeTypeMap[ threeAttributeName ] = componentType;
+        attributeNormalizedMap[ threeAttributeName ] = accessorDef.normalized === true;
+
+      }
+
+    }
+
+    return parser.getDependency( 'bufferView', bufferViewIndex ).then( function ( bufferView ) {
+
+      return new Promise( function ( resolve ) {
+
+        dracoLoader.decodeDracoFile( bufferView, function ( geometry ) {
+
+          for ( var attributeName in geometry.attributes ) {
+
+            var attribute = geometry.attributes[ attributeName ];
+            var normalized = attributeNormalizedMap[ attributeName ];
+
+            if ( normalized !== undefined ) attribute.normalized = normalized;
+
+          }
+
+          resolve( geometry );
+
+        }, threeAttributeMap, attributeTypeMap );
+
+      } );
+
+    } );
+
+  };
+
+  /**
+   * Texture Transform Extension
+   *
+   * Specification:
+   */
+  function GLTFTextureTransformExtension() {
+
+    this.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM;
+
+  }
+
+  GLTFTextureTransformExtension.prototype.extendTexture = function ( texture, transform ) {
+
+    texture = texture.clone();
+
+    if ( transform.offset !== undefined ) {
+
+      texture.offset.fromArray( transform.offset );
+
+    }
+
+    if ( transform.rotation !== undefined ) {
+
+      texture.rotation = transform.rotation;
+
+    }
+
+    if ( transform.scale !== undefined ) {
+
+      texture.repeat.fromArray( transform.scale );
+
+    }
+
+    if ( transform.texCoord !== undefined ) {
+
+      console.warn( 'THREE.GLTFLoader: Custom UV sets in "' + this.name + '" extension not yet supported.' );
+
+    }
+
+    texture.needsUpdate = true;
+
+    return texture;
+
+  };
+
+  /**
+   * Specular-Glossiness Extension
+   *
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness
+   */
+  function GLTFMaterialsPbrSpecularGlossinessExtension() {
+
+    return {
+
+      name: EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS,
+
+      specularGlossinessParams: [
+        'color',
+        'map',
+        'lightMap',
+        'lightMapIntensity',
+        'aoMap',
+        'aoMapIntensity',
+        'emissive',
+        'emissiveIntensity',
+        'emissiveMap',
+        'bumpMap',
+        'bumpScale',
+        'normalMap',
+        'displacementMap',
+        'displacementScale',
+        'displacementBias',
+        'specularMap',
+        'specular',
+        'glossinessMap',
+        'glossiness',
+        'alphaMap',
+        'envMap',
+        'envMapIntensity',
+        'refractionRatio',
+      ],
+
+      getMaterialType: function () {
+
+        return THREE.ShaderMaterial;
+
+      },
+
+      extendParams: function ( materialParams, materialDef, parser ) {
+
+        var pbrSpecularGlossiness = materialDef.extensions[ this.name ];
+
+        var shader = THREE.ShaderLib[ 'standard' ];
+
+        var uniforms = THREE.UniformsUtils.clone( shader.uniforms );
+
+        var specularMapParsFragmentChunk = [
+          '#ifdef USE_SPECULARMAP',
+          '  uniform sampler2D specularMap;',
+          '#endif'
+        ].join( '\n' );
+
+        var glossinessMapParsFragmentChunk = [
+          '#ifdef USE_GLOSSINESSMAP',
+          '  uniform sampler2D glossinessMap;',
+          '#endif'
+        ].join( '\n' );
+
+        var specularMapFragmentChunk = [
+          'vec3 specularFactor = specular;',
+          '#ifdef USE_SPECULARMAP',
+          '  vec4 texelSpecular = texture2D( specularMap, vUv );',
+          '  texelSpecular = sRGBToLinear( texelSpecular );',
+          '  // reads channel RGB, compatible with a glTF Specular-Glossiness (RGBA) texture',
+          '  specularFactor *= texelSpecular.rgb;',
+          '#endif'
+        ].join( '\n' );
+
+        var glossinessMapFragmentChunk = [
+          'float glossinessFactor = glossiness;',
+          '#ifdef USE_GLOSSINESSMAP',
+          '  vec4 texelGlossiness = texture2D( glossinessMap, vUv );',
+          '  // reads channel A, compatible with a glTF Specular-Glossiness (RGBA) texture',
+          '  glossinessFactor *= texelGlossiness.a;',
+          '#endif'
+        ].join( '\n' );
+
+        var lightPhysicalFragmentChunk = [
+          'PhysicalMaterial material;',
+          'material.diffuseColor = diffuseColor.rgb;',
+          'material.specularRoughness = clamp( 1.0 - glossinessFactor, 0.04, 1.0 );',
+          'material.specularColor = specularFactor.rgb;',
+        ].join( '\n' );
+
+        var fragmentShader = shader.fragmentShader
+          .replace( 'uniform float roughness;', 'uniform vec3 specular;' )
+          .replace( 'uniform float metalness;', 'uniform float glossiness;' )
+          .replace( '#include <roughnessmap_pars_fragment>', specularMapParsFragmentChunk )
+          .replace( '#include <metalnessmap_pars_fragment>', glossinessMapParsFragmentChunk )
+          .replace( '#include <roughnessmap_fragment>', specularMapFragmentChunk )
+          .replace( '#include <metalnessmap_fragment>', glossinessMapFragmentChunk )
+          .replace( '#include <lights_physical_fragment>', lightPhysicalFragmentChunk );
+
+        delete uniforms.roughness;
+        delete uniforms.metalness;
+        delete uniforms.roughnessMap;
+        delete uniforms.metalnessMap;
+
+        uniforms.specular = { value: new THREE.Color().setHex( 0x111111 ) };
+        uniforms.glossiness = { value: 0.5 };
+        uniforms.specularMap = { value: null };
+        uniforms.glossinessMap = { value: null };
+
+        materialParams.vertexShader = shader.vertexShader;
+        materialParams.fragmentShader = fragmentShader;
+        materialParams.uniforms = uniforms;
+        materialParams.defines = { 'STANDARD': '' };
+
+        materialParams.color = new THREE.Color( 1.0, 1.0, 1.0 );
+        materialParams.opacity = 1.0;
+
+        var pending = [];
+
+        if ( Array.isArray( pbrSpecularGlossiness.diffuseFactor ) ) {
+
+          var array = pbrSpecularGlossiness.diffuseFactor;
+
+          materialParams.color.fromArray( array );
+          materialParams.opacity = array[ 3 ];
+
+        }
+
+        if ( pbrSpecularGlossiness.diffuseTexture !== undefined ) {
+
+          pending.push( parser.assignTexture( materialParams, 'map', pbrSpecularGlossiness.diffuseTexture ) );
+
+        }
+
+        materialParams.emissive = new THREE.Color( 0.0, 0.0, 0.0 );
+        materialParams.glossiness = pbrSpecularGlossiness.glossinessFactor !== undefined ? pbrSpecularGlossiness.glossinessFactor : 1.0;
+        materialParams.specular = new THREE.Color( 1.0, 1.0, 1.0 );
+
+        if ( Array.isArray( pbrSpecularGlossiness.specularFactor ) ) {
+
+          materialParams.specular.fromArray( pbrSpecularGlossiness.specularFactor );
+
+        }
+
+        if ( pbrSpecularGlossiness.specularGlossinessTexture !== undefined ) {
+
+          var specGlossMapDef = pbrSpecularGlossiness.specularGlossinessTexture;
+          pending.push( parser.assignTexture( materialParams, 'glossinessMap', specGlossMapDef ) );
+          pending.push( parser.assignTexture( materialParams, 'specularMap', specGlossMapDef ) );
+
+        }
+
+        return Promise.all( pending );
+
+      },
+
+      createMaterial: function ( params ) {
+
+        // setup material properties based on MeshStandardMaterial for Specular-Glossiness
+
+        var material = new THREE.ShaderMaterial( {
+          defines: params.defines,
+          vertexShader: params.vertexShader,
+          fragmentShader: params.fragmentShader,
+          uniforms: params.uniforms,
+          fog: true,
+          lights: true,
+          opacity: params.opacity,
+          transparent: params.transparent
+        } );
+
+        material.isGLTFSpecularGlossinessMaterial = true;
+
+        material.color = params.color;
+
+        material.map = params.map === undefined ? null : params.map;
+
+        material.lightMap = null;
+        material.lightMapIntensity = 1.0;
+
+        material.aoMap = params.aoMap === undefined ? null : params.aoMap;
+        material.aoMapIntensity = 1.0;
+
+        material.emissive = params.emissive;
+        material.emissiveIntensity = 1.0;
+        material.emissiveMap = params.emissiveMap === undefined ? null : params.emissiveMap;
+
+        material.bumpMap = params.bumpMap === undefined ? null : params.bumpMap;
+        material.bumpScale = 1;
+
+        material.normalMap = params.normalMap === undefined ? null : params.normalMap;
+
+        if ( params.normalScale ) material.normalScale = params.normalScale;
+
+        material.displacementMap = null;
+        material.displacementScale = 1;
+        material.displacementBias = 0;
+
+        material.specularMap = params.specularMap === undefined ? null : params.specularMap;
+        material.specular = params.specular;
+
+        material.glossinessMap = params.glossinessMap === undefined ? null : params.glossinessMap;
+        material.glossiness = params.glossiness;
+
+        material.alphaMap = null;
+
+        material.envMap = params.envMap === undefined ? null : params.envMap;
+        material.envMapIntensity = 1.0;
+
+        material.refractionRatio = 0.98;
+
+        material.extensions.derivatives = true;
+
+        return material;
+
+      },
+
+      /**
+       * Clones a GLTFSpecularGlossinessMaterial instance. The ShaderMaterial.copy() method can
+       * copy only properties it knows about or inherits, and misses many properties that would
+       * normally be defined by MeshStandardMaterial.
+       *
+       * This method allows GLTFSpecularGlossinessMaterials to be cloned in the process of
+       * loading a glTF model, but cloning later (e.g. by the user) would require these changes
+       * AND also updating `.onBeforeRender` on the parent mesh.
+       *
+       * @param  {THREE.ShaderMaterial} source
+       * @return {THREE.ShaderMaterial}
+       */
+      cloneMaterial: function ( source ) {
+
+        var target = source.clone();
+
+        target.isGLTFSpecularGlossinessMaterial = true;
+
+        var params = this.specularGlossinessParams;
+
+        for ( var i = 0, il = params.length; i < il; i ++ ) {
+
+          target[ params[ i ] ] = source[ params[ i ] ];
+
+        }
+
+        return target;
+
+      },
+
+      // Here's based on refreshUniformsCommon() and refreshUniformsStandard() in WebGLRenderer.
+      refreshUniforms: function ( renderer, scene, camera, geometry, material, group ) {
+
+        if ( material.isGLTFSpecularGlossinessMaterial !== true ) {
+
+          return;
+
+        }
+
+        var uniforms = material.uniforms;
+        var defines = material.defines;
+
+        uniforms.opacity.value = material.opacity;
+
+        uniforms.diffuse.value.copy( material.color );
+        uniforms.emissive.value.copy( material.emissive ).multiplyScalar( material.emissiveIntensity );
+
+        uniforms.map.value = material.map;
+        uniforms.specularMap.value = material.specularMap;
+        uniforms.alphaMap.value = material.alphaMap;
+
+        uniforms.lightMap.value = material.lightMap;
+        uniforms.lightMapIntensity.value = material.lightMapIntensity;
+
+        uniforms.aoMap.value = material.aoMap;
+        uniforms.aoMapIntensity.value = material.aoMapIntensity;
+
+        // uv repeat and offset setting priorities
+        // 1. color map
+        // 2. specular map
+        // 3. normal map
+        // 4. bump map
+        // 5. alpha map
+        // 6. emissive map
+
+        var uvScaleMap;
+
+        if ( material.map ) {
+
+          uvScaleMap = material.map;
+
+        } else if ( material.specularMap ) {
+
+          uvScaleMap = material.specularMap;
+
+        } else if ( material.displacementMap ) {
+
+          uvScaleMap = material.displacementMap;
+
+        } else if ( material.normalMap ) {
+
+          uvScaleMap = material.normalMap;
+
+        } else if ( material.bumpMap ) {
+
+          uvScaleMap = material.bumpMap;
+
+        } else if ( material.glossinessMap ) {
+
+          uvScaleMap = material.glossinessMap;
+
+        } else if ( material.alphaMap ) {
+
+          uvScaleMap = material.alphaMap;
+
+        } else if ( material.emissiveMap ) {
+
+          uvScaleMap = material.emissiveMap;
+
+        }
+
+        if ( uvScaleMap !== undefined ) {
+
+          // backwards compatibility
+          if ( uvScaleMap.isWebGLRenderTarget ) {
+
+            uvScaleMap = uvScaleMap.texture;
+
+          }
+
+          if ( uvScaleMap.matrixAutoUpdate === true ) {
+
+            uvScaleMap.updateMatrix();
+
+          }
+
+          uniforms.uvTransform.value.copy( uvScaleMap.matrix );
+
+        }
+
+        if ( material.envMap ) {
+
+          uniforms.envMap.value = material.envMap;
+          uniforms.envMapIntensity.value = material.envMapIntensity;
+
+          // don't flip CubeTexture envMaps, flip everything else:
+          //  WebGLRenderTargetCube will be flipped for backwards compatibility
+          //  WebGLRenderTargetCube.texture will be flipped because it's a Texture and NOT a CubeTexture
+          // this check must be handled differently, or removed entirely, if WebGLRenderTargetCube uses a CubeTexture in the future
+          uniforms.flipEnvMap.value = material.envMap.isCubeTexture ? - 1 : 1;
+
+          uniforms.reflectivity.value = material.reflectivity;
+          uniforms.refractionRatio.value = material.refractionRatio;
+
+          uniforms.maxMipLevel.value = renderer.properties.get( material.envMap ).__maxMipLevel;
+
+        }
+
+        uniforms.specular.value.copy( material.specular );
+        uniforms.glossiness.value = material.glossiness;
+
+        uniforms.glossinessMap.value = material.glossinessMap;
+
+        uniforms.emissiveMap.value = material.emissiveMap;
+        uniforms.bumpMap.value = material.bumpMap;
+        uniforms.normalMap.value = material.normalMap;
+
+        uniforms.displacementMap.value = material.displacementMap;
+        uniforms.displacementScale.value = material.displacementScale;
+        uniforms.displacementBias.value = material.displacementBias;
+
+        if ( uniforms.glossinessMap.value !== null && defines.USE_GLOSSINESSMAP === undefined ) {
+
+          defines.USE_GLOSSINESSMAP = '';
+          // set USE_ROUGHNESSMAP to enable vUv
+          defines.USE_ROUGHNESSMAP = '';
+
+        }
+
+        if ( uniforms.glossinessMap.value === null && defines.USE_GLOSSINESSMAP !== undefined ) {
+
+          delete defines.USE_GLOSSINESSMAP;
+          delete defines.USE_ROUGHNESSMAP;
+
+        }
+
+      }
+
+    };
+
+  }
+
+  /*********************************/
+  /********** INTERPOLATION ********/
+  /*********************************/
+
+  // Spline Interpolation
+  // Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#appendix-c-spline-interpolation
+  function GLTFCubicSplineInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
+
+    THREE.Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );
+
+  }
+
+  GLTFCubicSplineInterpolant.prototype = Object.create( THREE.Interpolant.prototype );
+  GLTFCubicSplineInterpolant.prototype.constructor = GLTFCubicSplineInterpolant;
+
+  GLTFCubicSplineInterpolant.prototype.copySampleValue_ = function ( index ) {
+
+    // Copies a sample value to the result buffer. See description of glTF
+    // CUBICSPLINE values layout in interpolate_() function below.
+
+    var result = this.resultBuffer,
+      values = this.sampleValues,
+      valueSize = this.valueSize,
+      offset = index * valueSize * 3 + valueSize;
+
+    for ( var i = 0; i !== valueSize; i ++ ) {
+
+      result[ i ] = values[ offset + i ];
+
+    }
+
+    return result;
+
+  };
+
+  GLTFCubicSplineInterpolant.prototype.beforeStart_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_;
+
+  GLTFCubicSplineInterpolant.prototype.afterEnd_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_;
+
+  GLTFCubicSplineInterpolant.prototype.interpolate_ = function ( i1, t0, t, t1 ) {
+
+    var result = this.resultBuffer;
+    var values = this.sampleValues;
+    var stride = this.valueSize;
+
+    var stride2 = stride * 2;
+    var stride3 = stride * 3;
+
+    var td = t1 - t0;
+
+    var p = ( t - t0 ) / td;
+    var pp = p * p;
+    var ppp = pp * p;
+
+    var offset1 = i1 * stride3;
+    var offset0 = offset1 - stride3;
+
+    var s2 = - 2 * ppp + 3 * pp;
+    var s3 = ppp - pp;
+    var s0 = 1 - s2;
+    var s1 = s3 - pp + p;
+
+    // Layout of keyframe output values for CUBICSPLINE animations:
+    //   [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]
+    for ( var i = 0; i !== stride; i ++ ) {
+
+      var p0 = values[ offset0 + i + stride ]; // splineVertex_k
+      var m0 = values[ offset0 + i + stride2 ] * td; // outTangent_k * (t_k+1 - t_k)
+      var p1 = values[ offset1 + i + stride ]; // splineVertex_k+1
+      var m1 = values[ offset1 + i ] * td; // inTangent_k+1 * (t_k+1 - t_k)
+
+      result[ i ] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
+
+    }
+
+    return result;
+
+  };
+
+  /*********************************/
+  /********** INTERNALS ************/
+  /*********************************/
+
+  /* CONSTANTS */
+
+  var WEBGL_CONSTANTS = {
+    FLOAT: 5126,
+    //FLOAT_MAT2: 35674,
+    FLOAT_MAT3: 35675,
+    FLOAT_MAT4: 35676,
+    FLOAT_VEC2: 35664,
+    FLOAT_VEC3: 35665,
+    FLOAT_VEC4: 35666,
+    LINEAR: 9729,
+    REPEAT: 10497,
+    SAMPLER_2D: 35678,
+    POINTS: 0,
+    LINES: 1,
+    LINE_LOOP: 2,
+    LINE_STRIP: 3,
+    TRIANGLES: 4,
+    TRIANGLE_STRIP: 5,
+    TRIANGLE_FAN: 6,
+    UNSIGNED_BYTE: 5121,
+    UNSIGNED_SHORT: 5123
+  };
+
+  var WEBGL_TYPE = {
+    5126: Number,
+    //35674: THREE.Matrix2,
+    35675: THREE.Matrix3,
+    35676: THREE.Matrix4,
+    35664: THREE.Vector2,
+    35665: THREE.Vector3,
+    35666: THREE.Vector4,
+    35678: THREE.Texture
+  };
+
+  var WEBGL_COMPONENT_TYPES = {
+    5120: Int8Array,
+    5121: Uint8Array,
+    5122: Int16Array,
+    5123: Uint16Array,
+    5125: Uint32Array,
+    5126: Float32Array
+  };
+
+  var WEBGL_FILTERS = {
+    9728: THREE.NearestFilter,
+    9729: THREE.LinearFilter,
+    9984: THREE.NearestMipMapNearestFilter,
+    9985: THREE.LinearMipMapNearestFilter,
+    9986: THREE.NearestMipMapLinearFilter,
+    9987: THREE.LinearMipMapLinearFilter
+  };
+
+  var WEBGL_WRAPPINGS = {
+    33071: THREE.ClampToEdgeWrapping,
+    33648: THREE.MirroredRepeatWrapping,
+    10497: THREE.RepeatWrapping
+  };
+
+  var WEBGL_SIDES = {
+    1028: THREE.BackSide, // Culling front
+    1029: THREE.FrontSide // Culling back
+    //1032: THREE.NoSide   // Culling front and back, what to do?
+  };
+
+  var WEBGL_DEPTH_FUNCS = {
+    512: THREE.NeverDepth,
+    513: THREE.LessDepth,
+    514: THREE.EqualDepth,
+    515: THREE.LessEqualDepth,
+    516: THREE.GreaterEqualDepth,
+    517: THREE.NotEqualDepth,
+    518: THREE.GreaterEqualDepth,
+    519: THREE.AlwaysDepth
+  };
+
+  var WEBGL_BLEND_EQUATIONS = {
+    32774: THREE.AddEquation,
+    32778: THREE.SubtractEquation,
+    32779: THREE.ReverseSubtractEquation
+  };
+
+  var WEBGL_BLEND_FUNCS = {
+    0: THREE.ZeroFactor,
+    1: THREE.OneFactor,
+    768: THREE.SrcColorFactor,
+    769: THREE.OneMinusSrcColorFactor,
+    770: THREE.SrcAlphaFactor,
+    771: THREE.OneMinusSrcAlphaFactor,
+    772: THREE.DstAlphaFactor,
+    773: THREE.OneMinusDstAlphaFactor,
+    774: THREE.DstColorFactor,
+    775: THREE.OneMinusDstColorFactor,
+    776: THREE.SrcAlphaSaturateFactor
+    // The followings are not supported by Three.js yet
+    //32769: CONSTANT_COLOR,
+    //32770: ONE_MINUS_CONSTANT_COLOR,
+    //32771: CONSTANT_ALPHA,
+    //32772: ONE_MINUS_CONSTANT_COLOR
+  };
+
+  var WEBGL_TYPE_SIZES = {
+    'SCALAR': 1,
+    'VEC2': 2,
+    'VEC3': 3,
+    'VEC4': 4,
+    'MAT2': 4,
+    'MAT3': 9,
+    'MAT4': 16
+  };
+
+  var ATTRIBUTES = {
+    POSITION: 'position',
+    NORMAL: 'normal',
+    TANGENT: 'tangent',
+    TEXCOORD_0: 'uv',
+    TEXCOORD_1: 'uv2',
+    COLOR_0: 'color',
+    WEIGHTS_0: 'skinWeight',
+    JOINTS_0: 'skinIndex',
+  };
+
+  var PATH_PROPERTIES = {
+    scale: 'scale',
+    translation: 'position',
+    rotation: 'quaternion',
+    weights: 'morphTargetInfluences'
+  };
+
+  var INTERPOLATION = {
+    CUBICSPLINE: undefined, // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each
+                            // keyframe track will be initialized with a default interpolation type, then modified.
+    LINEAR: THREE.InterpolateLinear,
+    STEP: THREE.InterpolateDiscrete
+  };
+
+  var STATES_ENABLES = {
+    2884: 'CULL_FACE',
+    2929: 'DEPTH_TEST',
+    3042: 'BLEND',
+    3089: 'SCISSOR_TEST',
+    32823: 'POLYGON_OFFSET_FILL',
+    32926: 'SAMPLE_ALPHA_TO_COVERAGE'
+  };
+
+  var ALPHA_MODES = {
+    OPAQUE: 'OPAQUE',
+    MASK: 'MASK',
+    BLEND: 'BLEND'
+  };
+
+  var MIME_TYPE_FORMATS = {
+    'image/png': THREE.RGBAFormat,
+    'image/jpeg': THREE.RGBFormat
+  };
+
+  /* UTILITY FUNCTIONS */
+
+  function resolveURL( url, path ) {
+
+    // Invalid URL
+    if ( typeof url !== 'string' || url === '' ) return '';
+
+    // Absolute URL http://,https://,//
+    if ( /^(https?:)?\/\//i.test( url ) ) return url;
+
+    // Data URI
+    if ( /^data:.*,.*$/i.test( url ) ) return url;
+
+    // Blob URL
+    if ( /^blob:.*$/i.test( url ) ) return url;
+
+    // Relative URL
+    return path + url;
+
+  }
+
+  var defaultMaterial;
+
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#default-material
+   */
+  function createDefaultMaterial() {
+
+    defaultMaterial = defaultMaterial || new THREE.MeshStandardMaterial( {
+      color: 0xFFFFFF,
+      emissive: 0x000000,
+      metalness: 1,
+      roughness: 1,
+      transparent: false,
+      depthTest: true,
+      side: THREE.FrontSide
+    } );
+
+    return defaultMaterial;
+
+  }
+
+  function addUnknownExtensionsToUserData( knownExtensions, object, objectDef ) {
+
+    // Add unknown glTF extensions to an object's userData.
+
+    for ( var name in objectDef.extensions ) {
+
+      if ( knownExtensions[ name ] === undefined ) {
+
+        object.userData.gltfExtensions = object.userData.gltfExtensions || {};
+        object.userData.gltfExtensions[ name ] = objectDef.extensions[ name ];
+
+      }
+
+    }
+
+  }
+
+  /**
+   * @param {THREE.Object3D|THREE.Material|THREE.BufferGeometry} object
+   * @param {GLTF.definition} gltfDef
+   */
+  function assignExtrasToUserData( object, gltfDef ) {
+
+    if ( gltfDef.extras !== undefined ) {
+
+      if ( typeof gltfDef.extras === 'object' ) {
+
+        object.userData = gltfDef.extras;
+
+      } else {
+
+        console.warn( 'THREE.GLTFLoader: Ignoring primitive type .extras, ' + gltfDef.extras );
+
+      }
+
+    }
+
+  }
+
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#morph-targets
+   *
+   * @param {THREE.BufferGeometry} geometry
+   * @param {Array<GLTF.Target>} targets
+   * @param {GLTFParser} parser
+   * @return {Promise<THREE.BufferGeometry>}
+   */
+  function addMorphTargets( geometry, targets, parser ) {
+
+    var hasMorphPosition = false;
+    var hasMorphNormal = false;
+
+    for ( var i = 0, il = targets.length; i < il; i ++ ) {
+
+      var target = targets[ i ];
+
+      if ( target.POSITION !== undefined ) hasMorphPosition = true;
+      if ( target.NORMAL !== undefined ) hasMorphNormal = true;
+
+      if ( hasMorphPosition && hasMorphNormal ) break;
+
+    }
+
+    if ( ! hasMorphPosition && ! hasMorphNormal ) return Promise.resolve( geometry );
+
+    var pendingPositionAccessors = [];
+    var pendingNormalAccessors = [];
+
+    for ( var i = 0, il = targets.length; i < il; i ++ ) {
+
+      var target = targets[ i ];
+
+      if ( hasMorphPosition ) {
+
+        var pendingAccessor = target.POSITION !== undefined
+          ? parser.getDependency( 'accessor', target.POSITION )
+          : geometry.attributes.position;
+
+        pendingPositionAccessors.push( pendingAccessor );
+
+      }
+
+      if ( hasMorphNormal ) {
+
+        var pendingAccessor = target.NORMAL !== undefined
+          ? parser.getDependency( 'accessor', target.NORMAL )
+          : geometry.attributes.normal;
+
+        pendingNormalAccessors.push( pendingAccessor );
+
+      }
+
+    }
+
+    return Promise.all( [
+      Promise.all( pendingPositionAccessors ),
+      Promise.all( pendingNormalAccessors )
+    ] ).then( function ( accessors ) {
+
+      var morphPositions = accessors[ 0 ];
+      var morphNormals = accessors[ 1 ];
+
+      // Clone morph target accessors before modifying them.
+
+      for ( var i = 0, il = morphPositions.length; i < il; i ++ ) {
+
+        if ( geometry.attributes.position === morphPositions[ i ] ) continue;
+
+        morphPositions[ i ] = cloneBufferAttribute( morphPositions[ i ] );
+
+      }
+
+      for ( var i = 0, il = morphNormals.length; i < il; i ++ ) {
+
+        if ( geometry.attributes.normal === morphNormals[ i ] ) continue;
+
+        morphNormals[ i ] = cloneBufferAttribute( morphNormals[ i ] );
+
+      }
+
+      for ( var i = 0, il = targets.length; i < il; i ++ ) {
+
+        var target = targets[ i ];
+        var attributeName = 'morphTarget' + i;
+
+        if ( hasMorphPosition ) {
+
+          // Three.js morph position is absolute value. The formula is
+          //   basePosition
+          //     + weight0 * ( morphPosition0 - basePosition )
+          //     + weight1 * ( morphPosition1 - basePosition )
+          //     ...
+          // while the glTF one is relative
+          //   basePosition
+          //     + weight0 * glTFmorphPosition0
+          //     + weight1 * glTFmorphPosition1
+          //     ...
+          // then we need to convert from relative to absolute here.
+
+          if ( target.POSITION !== undefined ) {
+
+            var positionAttribute = morphPositions[ i ];
+            positionAttribute.name = attributeName;
+
+            var position = geometry.attributes.position;
+
+            for ( var j = 0, jl = positionAttribute.count; j < jl; j ++ ) {
+
+              positionAttribute.setXYZ(
+                j,
+                positionAttribute.getX( j ) + position.getX( j ),
+                positionAttribute.getY( j ) + position.getY( j ),
+                positionAttribute.getZ( j ) + position.getZ( j )
+              );
+
+            }
+
+          }
+
+        }
+
+        if ( hasMorphNormal ) {
+
+          // see target.POSITION's comment
+
+          if ( target.NORMAL !== undefined ) {
+
+            var normalAttribute = morphNormals[ i ];
+            normalAttribute.name = attributeName;
+
+            var normal = geometry.attributes.normal;
+
+            for ( var j = 0, jl = normalAttribute.count; j < jl; j ++ ) {
+
+              normalAttribute.setXYZ(
+                j,
+                normalAttribute.getX( j ) + normal.getX( j ),
+                normalAttribute.getY( j ) + normal.getY( j ),
+                normalAttribute.getZ( j ) + normal.getZ( j )
+              );
+
+            }
+
+          }
+
+        }
+
+      }
+
+      if ( hasMorphPosition ) geometry.morphAttributes.position = morphPositions;
+      if ( hasMorphNormal ) geometry.morphAttributes.normal = morphNormals;
+
+      return geometry;
+
+    } );
+
+  }
+
+  /**
+   * @param {THREE.Mesh} mesh
+   * @param {GLTF.Mesh} meshDef
+   */
+  function updateMorphTargets( mesh, meshDef ) {
+
+    mesh.updateMorphTargets();
+
+    if ( meshDef.weights !== undefined ) {
+
+      for ( var i = 0, il = meshDef.weights.length; i < il; i ++ ) {
+
+        mesh.morphTargetInfluences[ i ] = meshDef.weights[ i ];
+
+      }
+
+    }
+
+    // .extras has user-defined data, so check that .extras.targetNames is an array.
+    if ( meshDef.extras && Array.isArray( meshDef.extras.targetNames ) ) {
+
+      var targetNames = meshDef.extras.targetNames;
+
+      if ( mesh.morphTargetInfluences.length === targetNames.length ) {
+
+        mesh.morphTargetDictionary = {};
+
+        for ( var i = 0, il = targetNames.length; i < il; i ++ ) {
+
+          mesh.morphTargetDictionary[ targetNames[ i ] ] = i;
+
+        }
+
+      } else {
+
+        console.warn( 'THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.' );
+
+      }
+
+    }
+
+  }
+  function isObjectEqual( a, b ) {
+
+    if ( Object.keys( a ).length !== Object.keys( b ).length ) return false;
+
+    for ( var key in a ) {
+
+      if ( a[ key ] !== b[ key ] ) return false;
+
+    }
+
+    return true;
+
+  }
+
+  function createPrimitiveKey( primitiveDef ) {
+
+    var dracoExtension = primitiveDef.extensions && primitiveDef.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ];
+    var geometryKey;
+
+    if ( dracoExtension ) {
+
+      geometryKey = 'draco:' + dracoExtension.bufferView
+        + ':' + dracoExtension.indices
+        + ':' + createAttributesKey( dracoExtension.attributes );
+
+    } else {
+
+      geometryKey = primitiveDef.indices + ':' + createAttributesKey( primitiveDef.attributes ) + ':' + primitiveDef.mode;
+
+    }
+
+    return geometryKey;
+
+  }
+
+  function createAttributesKey( attributes ) {
+
+    var attributesKey = '';
+
+    var keys = Object.keys( attributes ).sort();
+
+    for ( var i = 0, il = keys.length; i < il; i ++ ) {
+
+      attributesKey += keys[ i ] + ':' + attributes[ keys[ i ] ] + ';';
+
+    }
+
+    return attributesKey;
+
+  }
+
+  function cloneBufferAttribute( attribute ) {
+
+    if ( attribute.isInterleavedBufferAttribute ) {
+
+      var count = attribute.count;
+      var itemSize = attribute.itemSize;
+      var array = attribute.array.slice( 0, count * itemSize );
+
+      for ( var i = 0, j = 0; i < count; ++ i ) {
+
+        array[ j ++ ] = attribute.getX( i );
+        if ( itemSize >= 2 ) array[ j ++ ] = attribute.getY( i );
+        if ( itemSize >= 3 ) array[ j ++ ] = attribute.getZ( i );
+        if ( itemSize >= 4 ) array[ j ++ ] = attribute.getW( i );
+
+      }
+
+      return new THREE.BufferAttribute( array, itemSize, attribute.normalized );
+
+    }
+
+    return attribute.clone();
+
+  }
+
+  /* GLTF PARSER */
+
+  function GLTFParser( json, extensions, options ) {
+
+    this.json = json || {};
+    this.extensions = extensions || {};
+    this.options = options || {};
+
+    // loader object cache
+    this.cache = new GLTFRegistry();
+
+    // BufferGeometry caching
+    this.primitiveCache = {};
+
+    this.textureLoader = new THREE.TextureLoader( this.options.manager );
+    this.textureLoader.setCrossOrigin( this.options.crossOrigin );
+
+    this.fileLoader = new THREE.FileLoader( this.options.manager );
+    this.fileLoader.setResponseType( 'arraybuffer' );
+
+  }
+
+  GLTFParser.prototype.parse = function ( onLoad, onError ) {
+
+    var parser = this;
+    var json = this.json;
+    var extensions = this.extensions;
+
+    // Clear the loader cache
+    this.cache.removeAll();
+
+    // Mark the special nodes/meshes in json for efficient parse
+    this.markDefs();
+
+    Promise.all( [
+
+      this.getDependencies( 'scene' ),
+      this.getDependencies( 'animation' ),
+      this.getDependencies( 'camera' ),
+
+    ] ).then( function ( dependencies ) {
+
+      var result = {
+        scene: dependencies[ 0 ][ json.scene || 0 ],
+        scenes: dependencies[ 0 ],
+        animations: dependencies[ 1 ],
+        cameras: dependencies[ 2 ],
+        asset: json.asset,
+        parser: parser,
+        userData: {}
+      };
+
+      addUnknownExtensionsToUserData( extensions, result, json );
+
+      onLoad( result );
+
+    } ).catch( onError );
+
+  };
+
+  /**
+   * Marks the special nodes/meshes in json for efficient parse.
+   */
+  GLTFParser.prototype.markDefs = function () {
+
+    var nodeDefs = this.json.nodes || [];
+    var skinDefs = this.json.skins || [];
+    var meshDefs = this.json.meshes || [];
+
+    var meshReferences = {};
+    var meshUses = {};
+
+    // Nothing in the node definition indicates whether it is a Bone or an
+    // Object3D. Use the skins' joint references to mark bones.
+    for ( var skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex ++ ) {
+
+      var joints = skinDefs[ skinIndex ].joints;
+
+      for ( var i = 0, il = joints.length; i < il; i ++ ) {
+
+        nodeDefs[ joints[ i ] ].isBone = true;
+
+      }
+
+    }
+
+    // Meshes can (and should) be reused by multiple nodes in a glTF asset. To
+    // avoid having more than one THREE.Mesh with the same name, count
+    // references and rename instances below.
+    //
+    // Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
+    for ( var nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {
+
+      var nodeDef = nodeDefs[ nodeIndex ];
+
+      if ( nodeDef.mesh !== undefined ) {
+
+        if ( meshReferences[ nodeDef.mesh ] === undefined ) {
+
+          meshReferences[ nodeDef.mesh ] = meshUses[ nodeDef.mesh ] = 0;
+
+        }
+
+        meshReferences[ nodeDef.mesh ] ++;
+
+        // Nothing in the mesh definition indicates whether it is
+        // a SkinnedMesh or Mesh. Use the node's mesh reference
+        // to mark SkinnedMesh if node has skin.
+        if ( nodeDef.skin !== undefined ) {
+
+          meshDefs[ nodeDef.mesh ].isSkinnedMesh = true;
+
+        }
+
+      }
+
+    }
+
+    this.json.meshReferences = meshReferences;
+    this.json.meshUses = meshUses;
+
+  };
+
+  /**
+   * Requests the specified dependency asynchronously, with caching.
+   * @param {string} type
+   * @param {number} index
+   * @return {Promise<THREE.Object3D|THREE.Material|THREE.Texture|THREE.AnimationClip|ArrayBuffer|Object>}
+   */
+  GLTFParser.prototype.getDependency = function ( type, index ) {
+
+    var cacheKey = type + ':' + index;
+    var dependency = this.cache.get( cacheKey );
+
+    if ( ! dependency ) {
+
+      switch ( type ) {
+
+        case 'scene':
+          dependency = this.loadScene( index );
+          break;
+
+        case 'node':
+          dependency = this.loadNode( index );
+          break;
+
+        case 'mesh':
+          dependency = this.loadMesh( index );
+          break;
+
+        case 'accessor':
+          dependency = this.loadAccessor( index );
+          break;
+
+        case 'bufferView':
+          dependency = this.loadBufferView( index );
+          break;
+
+        case 'buffer':
+          dependency = this.loadBuffer( index );
+          break;
+
+        case 'material':
+          dependency = this.loadMaterial( index );
+          break;
+
+        case 'texture':
+          dependency = this.loadTexture( index );
+          break;
+
+        case 'skin':
+          dependency = this.loadSkin( index );
+          break;
+
+        case 'animation':
+          dependency = this.loadAnimation( index );
+          break;
+
+        case 'camera':
+          dependency = this.loadCamera( index );
+          break;
+
+        case 'light':
+          dependency = this.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ].loadLight( index );
+          break;
+
+        default:
+          throw new Error( 'Unknown type: ' + type );
+
+      }
+
+      this.cache.add( cacheKey, dependency );
+
+    }
+
+    return dependency;
+
+  };
+
+  /**
+   * Requests all dependencies of the specified type asynchronously, with caching.
+   * @param {string} type
+   * @return {Promise<Array<Object>>}
+   */
+  GLTFParser.prototype.getDependencies = function ( type ) {
+
+    var dependencies = this.cache.get( type );
+
+    if ( ! dependencies ) {
+
+      var parser = this;
+      var defs = this.json[ type + ( type === 'mesh' ? 'es' : 's' ) ] || [];
+
+      dependencies = Promise.all( defs.map( function ( def, index ) {
+
+        return parser.getDependency( type, index );
+
+      } ) );
+
+      this.cache.add( type, dependencies );
+
+    }
+
+    return dependencies;
+
+  };
+
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+   * @param {number} bufferIndex
+   * @return {Promise<ArrayBuffer>}
+   */
+  GLTFParser.prototype.loadBuffer = function ( bufferIndex ) {
+
+    var bufferDef = this.json.buffers[ bufferIndex ];
+    var loader = this.fileLoader;
+
+    if ( bufferDef.type && bufferDef.type !== 'arraybuffer' ) {
+
+      throw new Error( 'THREE.GLTFLoader: ' + bufferDef.type + ' buffer type is not supported.' );
+
+    }
+
+    // If present, GLB container is required to be the first buffer.
+    if ( bufferDef.uri === undefined && bufferIndex === 0 ) {
+
+      return Promise.resolve( this.extensions[ EXTENSIONS.KHR_BINARY_GLTF ].body );
+
+    }
+
+    var options = this.options;
+
+    return new Promise( function ( resolve, reject ) {
+
+      loader.load( resolveURL( bufferDef.uri, options.path ), resolve, undefined, function () {
+
+        reject( new Error( 'THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".' ) );
+
+      } );
+
+    } );
+
+  };
+
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+   * @param {number} bufferViewIndex
+   * @return {Promise<ArrayBuffer>}
+   */
+  GLTFParser.prototype.loadBufferView = function ( bufferViewIndex ) {
+
+    var bufferViewDef = this.json.bufferViews[ bufferViewIndex ];
+
+    return this.getDependency( 'buffer', bufferViewDef.buffer ).then( function ( buffer ) {
+
+      var byteLength = bufferViewDef.byteLength || 0;
+      var byteOffset = bufferViewDef.byteOffset || 0;
+      return buffer.slice( byteOffset, byteOffset + byteLength );
+
+    } );
+
+  };
+
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
+   * @param {number} accessorIndex
+   * @return {Promise<THREE.BufferAttribute|THREE.InterleavedBufferAttribute>}
+   */
+  GLTFParser.prototype.loadAccessor = function ( accessorIndex ) {
+
+    var parser = this;
+    var json = this.json;
+
+    var accessorDef = this.json.accessors[ accessorIndex ];
+
+    if ( accessorDef.bufferView === undefined && accessorDef.sparse === undefined ) {
+
+      // Ignore empty accessors, which may be used to declare runtime
+      // information about attributes coming from another source (e.g. Draco
+      // compression extension).
+      return Promise.resolve( null );
+
+    }
+
+    var pendingBufferViews = [];
+
+    if ( accessorDef.bufferView !== undefined ) {
+
+      pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.bufferView ) );
+
+    } else {
+
+      pendingBufferViews.push( null );
+
+    }
+
+    if ( accessorDef.sparse !== undefined ) {
+
+      pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.indices.bufferView ) );
+      pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.values.bufferView ) );
+
+    }
+
+    return Promise.all( pendingBufferViews ).then( function ( bufferViews ) {
+
+      var bufferView = bufferViews[ 0 ];
+
+      var itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];
+      var TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
+
+      // For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12.
+      var elementBytes = TypedArray.BYTES_PER_ELEMENT;
+      var itemBytes = elementBytes * itemSize;
+      var byteOffset = accessorDef.byteOffset || 0;
+      var byteStride = accessorDef.bufferView !== undefined ? json.bufferViews[ accessorDef.bufferView ].byteStride : undefined;
+      var normalized = accessorDef.normalized === true;
+      var array, bufferAttribute;
+
+      // The buffer is not interleaved if the stride is the item size in bytes.
+      if ( byteStride && byteStride !== itemBytes ) {
+
+        var ibCacheKey = 'InterleavedBuffer:' + accessorDef.bufferView + ':' + accessorDef.componentType;
+        var ib = parser.cache.get( ibCacheKey );
+
+        if ( ! ib ) {
+
+          // Use the full buffer if it's interleaved.
+          array = new TypedArray( bufferView );
+
+          // Integer parameters to IB/IBA are in array elements, not bytes.
+          ib = new THREE.InterleavedBuffer( array, byteStride / elementBytes );
+
+          parser.cache.add( ibCacheKey, ib );
+
+        }
+
+        bufferAttribute = new THREE.InterleavedBufferAttribute( ib, itemSize, byteOffset / elementBytes, normalized );
+
+      } else {
+
+        if ( bufferView === null ) {
+
+          array = new TypedArray( accessorDef.count * itemSize );
+
+        } else {
+
+          array = new TypedArray( bufferView, byteOffset, accessorDef.count * itemSize );
+
+        }
+
+        bufferAttribute = new THREE.BufferAttribute( array, itemSize, normalized );
+
+      }
+
+      // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#sparse-accessors
+      if ( accessorDef.sparse !== undefined ) {
+
+        var itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR;
+        var TypedArrayIndices = WEBGL_COMPONENT_TYPES[ accessorDef.sparse.indices.componentType ];
+
+        var byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0;
+        var byteOffsetValues = accessorDef.sparse.values.byteOffset || 0;
+
+        var sparseIndices = new TypedArrayIndices( bufferViews[ 1 ], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices );
+        var sparseValues = new TypedArray( bufferViews[ 2 ], byteOffsetValues, accessorDef.sparse.count * itemSize );
+
+        if ( bufferView !== null ) {
+
+          // Avoid modifying the original ArrayBuffer, if the bufferView wasn't initialized with zeroes.
+          bufferAttribute.setArray( bufferAttribute.array.slice() );
+
+        }
+
+        for ( var i = 0, il = sparseIndices.length; i < il; i ++ ) {
+
+          var index = sparseIndices[ i ];
+
+          bufferAttribute.setX( index, sparseValues[ i * itemSize ] );
+          if ( itemSize >= 2 ) bufferAttribute.setY( index, sparseValues[ i * itemSize + 1 ] );
+          if ( itemSize >= 3 ) bufferAttribute.setZ( index, sparseValues[ i * itemSize + 2 ] );
+          if ( itemSize >= 4 ) bufferAttribute.setW( index, sparseValues[ i * itemSize + 3 ] );
+          if ( itemSize >= 5 ) throw new Error( 'THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.' );
+
+        }
+
+      }
+
+      return bufferAttribute;
+
+    } );
+
+  };
+
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
+   * @param {number} textureIndex
+   * @return {Promise<THREE.Texture>}
+   */
+  GLTFParser.prototype.loadTexture = function ( textureIndex ) {
+
+    var parser = this;
+    var json = this.json;
+    var options = this.options;
+    var textureLoader = this.textureLoader;
+
+    var URL = window.URL || window.webkitURL;
+
+    var textureDef = json.textures[ textureIndex ];
+
+    var textureExtensions = textureDef.extensions || {};
+
+    var source;
+
+    if ( textureExtensions[ EXTENSIONS.MSFT_TEXTURE_DDS ] ) {
+
+      source = json.images[ textureExtensions[ EXTENSIONS.MSFT_TEXTURE_DDS ].source ];
+
+    } else if ( textureExtensions[ EXTENSIONS.GOOGLE_TEXTURE_BASIS ] ) {
+
+      source = json.images[ textureExtensions[ EXTENSIONS.GOOGLE_TEXTURE_BASIS ].source ];
+
+    } else {
+
+      source = json.images[ textureDef.source ];
+
+    }
+
+    var sourceURI = source.uri;
+    var isObjectURL = false;
+
+    if ( source.bufferView !== undefined ) {
+
+      // Load binary image data from bufferView, if provided.
+
+      sourceURI = parser.getDependency( 'bufferView', source.bufferView ).then( function ( bufferView ) {
+
+        isObjectURL = true;
+        var blob = new Blob( [ bufferView ], { type: source.mimeType } );
+        sourceURI = URL.createObjectURL( blob );
+        return sourceURI;
+
+      } );
+
+    }
+
+    return Promise.resolve( sourceURI ).then( function ( sourceURI ) {
+
+      // Load Texture resource.
+
+      var loader = THREE.Loader.Handlers.get( sourceURI );
+
+      if ( ! loader ) {
+
+        loader = textureExtensions[ EXTENSIONS.MSFT_TEXTURE_DDS ]
+          ? parser.extensions[ EXTENSIONS.MSFT_TEXTURE_DDS ].ddsLoader
+          : textureLoader;
+
+      }
+
+      return new Promise( function ( resolve, reject ) {
+
+        loader.load( resolveURL( sourceURI, options.path ), resolve, undefined, reject );
+
+      } );
+
+    } ).then( function ( texture ) {
+
+      // Clean up resources and configure Texture.
+
+      if ( isObjectURL === true ) {
+
+        URL.revokeObjectURL( sourceURI );
+
+      }
+
+      texture.flipY = false;
+
+      if ( textureDef.name !== undefined ) texture.name = textureDef.name;
+
+      // Ignore unknown mime types, like DDS files.
+      if ( source.mimeType in MIME_TYPE_FORMATS ) {
+
+        texture.format = MIME_TYPE_FORMATS[ source.mimeType ];
+
+      }
+
+      var samplers = json.samplers || {};
+      var sampler = samplers[ textureDef.sampler ] || {};
+
+      texture.magFilter = WEBGL_FILTERS[ sampler.magFilter ] || THREE.LinearFilter;
+      texture.minFilter = WEBGL_FILTERS[ sampler.minFilter ] || THREE.LinearMipMapLinearFilter;
+      texture.wrapS = WEBGL_WRAPPINGS[ sampler.wrapS ] || THREE.RepeatWrapping;
+      texture.wrapT = WEBGL_WRAPPINGS[ sampler.wrapT ] || THREE.RepeatWrapping;
+
+      return texture;
+
+    } );
+
+  };
+
+  /**
+   * Asynchronously assigns a texture to the given material parameters.
+   * @param {Object} materialParams
+   * @param {string} mapName
+   * @param {Object} mapDef
+   * @return {Promise}
+   */
+  GLTFParser.prototype.assignTexture = function ( materialParams, mapName, mapDef ) {
+
+    var parser = this;
+
+    return this.getDependency( 'texture', mapDef.index ).then( function ( texture ) {
+
+      if ( ! texture.isCompressedTexture ) {
+
+        switch ( mapName ) {
+
+          case 'aoMap':
+          case 'emissiveMap':
+          case 'metalnessMap':
+          case 'normalMap':
+          case 'roughnessMap':
+            texture.format = THREE.RGBFormat;
+            break;
+
+        }
+
+      }
+
+      if ( parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] ) {
+
+        var transform = mapDef.extensions !== undefined ? mapDef.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] : undefined;
+
+        if ( transform ) {
+
+          texture = parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ].extendTexture( texture, transform );
+
+        }
+
+      }
+
+      materialParams[ mapName ] = texture;
+
+    } );
+
+  };
+
+  /**
+   * Assigns final material to a Mesh, Line, or Points instance. The instance
+   * already has a material (generated from the glTF material options alone)
+   * but reuse of the same glTF material may require multiple threejs materials
+   * to accomodate different primitive types, defines, etc. New materials will
+   * be created if necessary, and reused from a cache.
+   * @param  {THREE.Object3D} mesh Mesh, Line, or Points instance.
+   */
+  GLTFParser.prototype.assignFinalMaterial = function ( mesh ) {
+
+    var geometry = mesh.geometry;
+    var material = mesh.material;
+    var extensions = this.extensions;
+
+    var useVertexTangents = geometry.attributes.tangent !== undefined;
+    var useVertexColors = geometry.attributes.color !== undefined;
+    var useFlatShading = geometry.attributes.normal === undefined;
+    var useSkinning = mesh.isSkinnedMesh === true;
+    var useMorphTargets = Object.keys( geometry.morphAttributes ).length > 0;
+    var useMorphNormals = useMorphTargets && geometry.morphAttributes.normal !== undefined;
+
+    if ( mesh.isPoints ) {
+
+      var cacheKey = 'PointsMaterial:' + material.uuid;
+
+      var pointsMaterial = this.cache.get( cacheKey );
+
+      if ( ! pointsMaterial ) {
+
+        pointsMaterial = new THREE.PointsMaterial();
+        THREE.Material.prototype.copy.call( pointsMaterial, material );
+        pointsMaterial.color.copy( material.color );
+        pointsMaterial.map = material.map;
+        pointsMaterial.lights = false; // PointsMaterial doesn't support lights yet
+
+        this.cache.add( cacheKey, pointsMaterial );
+
+      }
+
+      material = pointsMaterial;
+
+    } else if ( mesh.isLine ) {
+
+      var cacheKey = 'LineBasicMaterial:' + material.uuid;
+
+      var lineMaterial = this.cache.get( cacheKey );
+
+      if ( ! lineMaterial ) {
+
+        lineMaterial = new THREE.LineBasicMaterial();
+        THREE.Material.prototype.copy.call( lineMaterial, material );
+        lineMaterial.color.copy( material.color );
+        lineMaterial.lights = false; // LineBasicMaterial doesn't support lights yet
+
+        this.cache.add( cacheKey, lineMaterial );
+
+      }
+
+      material = lineMaterial;
+
+    }
+
+    // Clone the material if it will be modified
+    if ( useVertexTangents || useVertexColors || useFlatShading || useSkinning || useMorphTargets ) {
+
+      var cacheKey = 'ClonedMaterial:' + material.uuid + ':';
+
+      if ( material.isGLTFSpecularGlossinessMaterial ) cacheKey += 'specular-glossiness:';
+      if ( useSkinning ) cacheKey += 'skinning:';
+      if ( useVertexTangents ) cacheKey += 'vertex-tangents:';
+      if ( useVertexColors ) cacheKey += 'vertex-colors:';
+      if ( useFlatShading ) cacheKey += 'flat-shading:';
+      if ( useMorphTargets ) cacheKey += 'morph-targets:';
+      if ( useMorphNormals ) cacheKey += 'morph-normals:';
+
+      var cachedMaterial = this.cache.get( cacheKey );
+
+      if ( ! cachedMaterial ) {
+
+        cachedMaterial = material.isGLTFSpecularGlossinessMaterial
+          ? extensions[ EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS ].cloneMaterial( material )
+          : material.clone();
+
+        if ( useSkinning ) cachedMaterial.skinning = true;
+        if ( useVertexTangents ) cachedMaterial.vertexTangents = true;
+        if ( useVertexColors ) cachedMaterial.vertexColors = THREE.VertexColors;
+        if ( useFlatShading ) cachedMaterial.flatShading = true;
+        if ( useMorphTargets ) cachedMaterial.morphTargets = true;
+        if ( useMorphNormals ) cachedMaterial.morphNormals = true;
+
+        this.cache.add( cacheKey, cachedMaterial );
+
+      }
+
+      material = cachedMaterial;
+
+    }
+
+    // workarounds for mesh and geometry
+
+    if ( material.aoMap && geometry.attributes.uv2 === undefined && geometry.attributes.uv !== undefined ) {
+
+      console.log( 'THREE.GLTFLoader: Duplicating UVs to support aoMap.' );
+      geometry.addAttribute( 'uv2', new THREE.BufferAttribute( geometry.attributes.uv.array, 2 ) );
+
+    }
+
+    if ( material.isGLTFSpecularGlossinessMaterial ) {
+
+      // for GLTFSpecularGlossinessMaterial(ShaderMaterial) uniforms runtime update
+      mesh.onBeforeRender = extensions[ EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS ].refreshUniforms;
+
+    }
+
+    mesh.material = material;
+
+  };
+
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
+   * @param {number} materialIndex
+   * @return {Promise<THREE.Material>}
+   */
+  GLTFParser.prototype.loadMaterial = function ( materialIndex ) {
+
+    var parser = this;
+    var json = this.json;
+    var extensions = this.extensions;
+    var materialDef = json.materials[ materialIndex ];
+
+    var materialType;
+    var materialParams = {};
+    var materialExtensions = materialDef.extensions || {};
+
+    var pending = [];
+
+    if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS ] ) {
+
+      var sgExtension = extensions[ EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS ];
+      materialType = sgExtension.getMaterialType();
+      pending.push( sgExtension.extendParams( materialParams, materialDef, parser ) );
+
+    } else if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ] ) {
+
+      var kmuExtension = extensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ];
+      materialType = kmuExtension.getMaterialType();
+      pending.push( kmuExtension.extendParams( materialParams, materialDef, parser ) );
+
+    } else {
+
+      // Specification:
+      // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#metallic-roughness-material
+
+      materialType = THREE.MeshStandardMaterial;
+
+      var metallicRoughness = materialDef.pbrMetallicRoughness || {};
+
+      materialParams.color = new THREE.Color( 1.0, 1.0, 1.0 );
+      materialParams.opacity = 1.0;
+
+      if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {
+
+        var array = metallicRoughness.baseColorFactor;
+
+        materialParams.color.fromArray( array );
+        materialParams.opacity = array[ 3 ];
+
+      }
+
+      if ( metallicRoughness.baseColorTexture !== undefined ) {
+
+        pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture ) );
+
+      }
+
+      materialParams.metalness = metallicRoughness.metallicFactor !== undefined ? metallicRoughness.metallicFactor : 1.0;
+      materialParams.roughness = metallicRoughness.roughnessFactor !== undefined ? metallicRoughness.roughnessFactor : 1.0;
+
+      if ( metallicRoughness.metallicRoughnessTexture !== undefined ) {
+
+        pending.push( parser.assignTexture( materialParams, 'metalnessMap', metallicRoughness.metallicRoughnessTexture ) );
+        pending.push( parser.assignTexture( materialParams, 'roughnessMap', metallicRoughness.metallicRoughnessTexture ) );
+
+      }
+
+    }
+
+    if ( materialDef.doubleSided === true ) {
+
+      materialParams.side = THREE.DoubleSide;
+
+    }
+
+    var alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE;
+
+    if ( alphaMode === ALPHA_MODES.BLEND ) {
+
+      materialParams.transparent = true;
+
+    } else {
+
+      materialParams.transparent = false;
+
+      if ( alphaMode === ALPHA_MODES.MASK ) {
+
+        materialParams.alphaTest = materialDef.alphaCutoff !== undefined ? materialDef.alphaCutoff : 0.5;
+
+      }
+
+    }
+
+    if ( materialDef.normalTexture !== undefined && materialType !== THREE.MeshBasicMaterial ) {
+
+      pending.push( parser.assignTexture( materialParams, 'normalMap', materialDef.normalTexture ) );
+
+      materialParams.normalScale = new THREE.Vector2( 1, 1 );
+
+      if ( materialDef.normalTexture.scale !== undefined ) {
+
+        materialParams.normalScale.set( materialDef.normalTexture.scale, materialDef.normalTexture.scale );
+
+      }
+
+    }
+
+    if ( materialDef.occlusionTexture !== undefined && materialType !== THREE.MeshBasicMaterial ) {
+
+      pending.push( parser.assignTexture( materialParams, 'aoMap', materialDef.occlusionTexture ) );
+
+      if ( materialDef.occlusionTexture.strength !== undefined ) {
+
+        materialParams.aoMapIntensity = materialDef.occlusionTexture.strength;
+
+      }
+
+    }
+
+    if ( materialDef.emissiveFactor !== undefined && materialType !== THREE.MeshBasicMaterial ) {
+
+      materialParams.emissive = new THREE.Color().fromArray( materialDef.emissiveFactor );
+
+    }
+
+    if ( materialDef.emissiveTexture !== undefined && materialType !== THREE.MeshBasicMaterial ) {
+
+      pending.push( parser.assignTexture( materialParams, 'emissiveMap', materialDef.emissiveTexture ) );
+
+    }
+
+    return Promise.all( pending ).then( function () {
+
+      var material;
+
+      if ( materialType === THREE.ShaderMaterial ) {
+
+        material = extensions[ EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS ].createMaterial( materialParams );
+
+      } else {
+
+        material = new materialType( materialParams );
+
+      }
+
+      if ( materialDef.name !== undefined ) material.name = materialDef.name;
+
+      // baseColorTexture, emissiveTexture, and specularGlossinessTexture use sRGB encoding.
+      if ( material.map ) material.map.encoding = THREE.sRGBEncoding;
+      if ( material.emissiveMap ) material.emissiveMap.encoding = THREE.sRGBEncoding;
+      if ( material.specularMap ) material.specularMap.encoding = THREE.sRGBEncoding;
+
+      assignExtrasToUserData( material, materialDef );
+
+      if ( materialDef.extensions ) addUnknownExtensionsToUserData( extensions, material, materialDef );
+
+      return material;
+
+    } );
+
+  };
+
+  /**
+   * @param {THREE.BufferGeometry} geometry
+   * @param {GLTF.Primitive} primitiveDef
+   * @param {GLTFParser} parser
+   * @return {Promise<THREE.BufferGeometry>}
+   */
+  function addPrimitiveAttributes( geometry, primitiveDef, parser ) {
+
+    var attributes = primitiveDef.attributes;
+
+    var pending = [];
+
+    function assignAttributeAccessor( accessorIndex, attributeName ) {
+
+      return parser.getDependency( 'accessor', accessorIndex )
+        .then( function ( accessor ) {
+
+          geometry.addAttribute( attributeName, accessor );
+
+        } );
+
+    }
+
+    for ( var gltfAttributeName in attributes ) {
+
+      var threeAttributeName = ATTRIBUTES[ gltfAttributeName ] || gltfAttributeName.toLowerCase();
+
+      // Skip attributes already provided by e.g. Draco extension.
+      if ( threeAttributeName in geometry.attributes ) continue;
+
+      pending.push( assignAttributeAccessor( attributes[ gltfAttributeName ], threeAttributeName ) );
+
+    }
+
+    if ( primitiveDef.indices !== undefined && ! geometry.index ) {
+
+      var accessor = parser.getDependency( 'accessor', primitiveDef.indices ).then( function ( accessor ) {
+
+        geometry.setIndex( accessor );
+
+      } );
+
+      pending.push( accessor );
+
+    }
+
+    assignExtrasToUserData( geometry, primitiveDef );
+
+    return Promise.all( pending ).then( function () {
+
+      return primitiveDef.targets !== undefined
+        ? addMorphTargets( geometry, primitiveDef.targets, parser )
+        : geometry;
+
+    } );
+
+  }
+
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
+   *
+   * Creates BufferGeometries from primitives.
+   *
+   * @param {Array<GLTF.Primitive>} primitives
+   * @return {Promise<Array<THREE.BufferGeometry>>}
+   */
+  GLTFParser.prototype.loadGeometries = function ( primitives ) {
+
+    var parser = this;
+    var extensions = this.extensions;
+    var cache = this.primitiveCache;
+
+    function createDracoPrimitive( primitive ) {
+
+      return extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ]
+        .decodePrimitive( primitive, parser )
+        .then( function ( geometry ) {
+
+          return addPrimitiveAttributes( geometry, primitive, parser );
+
+        } );
+
+    }
+
+    var pending = [];
+
+    for ( var i = 0, il = primitives.length; i < il; i ++ ) {
+
+      var primitive = primitives[ i ];
+      var cacheKey = createPrimitiveKey( primitive );
+
+      // See if we've already created this geometry
+      var cached = cache[ cacheKey ];
+
+      if ( cached ) {
+
+        // Use the cached geometry if it exists
+        pending.push( cached.promise );
+
+      } else {
+
+        var geometryPromise;
+
+        if ( primitive.extensions && primitive.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ] ) {
+
+          // Use DRACO geometry if available
+          geometryPromise = createDracoPrimitive( primitive );
+
+        } else {
+
+          // Otherwise create a new geometry
+          geometryPromise = addPrimitiveAttributes( new THREE.BufferGeometry(), primitive, parser );
+
+        }
+
+        // Cache this geometry
+        cache[ cacheKey ] = { primitive: primitive, promise: geometryPromise };
+
+        pending.push( geometryPromise );
+
+      }
+
+    }
+
+    return Promise.all( pending );
+
+  };
+
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
+   * @param {number} meshIndex
+   * @return {Promise<THREE.Group|THREE.Mesh|THREE.SkinnedMesh>}
+   */
+  GLTFParser.prototype.loadMesh = function ( meshIndex ) {
+
+    var parser = this;
+    var json = this.json;
+    var extensions = this.extensions;
+
+    var meshDef = json.meshes[ meshIndex ];
+    var primitives = meshDef.primitives;
+
+    var pending = [];
+
+    for ( var i = 0, il = primitives.length; i < il; i ++ ) {
+
+      var material = primitives[ i ].material === undefined
+        ? createDefaultMaterial()
+        : this.getDependency( 'material', primitives[ i ].material );
+
+      pending.push( material );
+
+    }
+
+    return Promise.all( pending ).then( function ( originalMaterials ) {
+
+      return parser.loadGeometries( primitives ).then( function ( geometries ) {
+
+        var meshes = [];
+
+        for ( var i = 0, il = geometries.length; i < il; i ++ ) {
+
+          var geometry = geometries[ i ];
+          var primitive = primitives[ i ];
+
+          // 1. create Mesh
+
+          var mesh;
+
+          var material = originalMaterials[ i ];
+
+          if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLES ||
+            primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ||
+            primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ||
+            primitive.mode === undefined ) {
+
+            // .isSkinnedMesh isn't in glTF spec. See .markDefs()
+            mesh = meshDef.isSkinnedMesh === true
+              ? new THREE.SkinnedMesh( geometry, material )
+              : new THREE.Mesh( geometry, material );
+
+            if ( mesh.isSkinnedMesh === true ) mesh.normalizeSkinWeights(); // #15319
+
+            if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ) {
+
+              mesh.drawMode = THREE.TriangleStripDrawMode;
+
+            } else if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ) {
+
+              mesh.drawMode = THREE.TriangleFanDrawMode;
+
+            }
+
+          } else if ( primitive.mode === WEBGL_CONSTANTS.LINES ) {
+
+            mesh = new THREE.LineSegments( geometry, material );
+
+          } else if ( primitive.mode === WEBGL_CONSTANTS.LINE_STRIP ) {
+
+            mesh = new THREE.Line( geometry, material );
+
+          } else if ( primitive.mode === WEBGL_CONSTANTS.LINE_LOOP ) {
+
+            mesh = new THREE.LineLoop( geometry, material );
+
+          } else if ( primitive.mode === WEBGL_CONSTANTS.POINTS ) {
+
+            mesh = new THREE.Points( geometry, material );
+
+          } else {
+
+            throw new Error( 'THREE.GLTFLoader: Primitive mode unsupported: ' + primitive.mode );
+
+          }
+
+          if ( Object.keys( mesh.geometry.morphAttributes ).length > 0 ) {
+
+            updateMorphTargets( mesh, meshDef );
+
+          }
+
+          mesh.name = meshDef.name || ( 'mesh_' + meshIndex );
+
+          if ( geometries.length > 1 ) mesh.name += '_' + i;
+
+          assignExtrasToUserData( mesh, meshDef );
+
+          parser.assignFinalMaterial( mesh );
+
+          meshes.push( mesh );
+
+        }
+
+        if ( meshes.length === 1 ) {
+
+          return meshes[ 0 ];
+
+        }
+
+        var group = new THREE.Group();
+
+        for ( var i = 0, il = meshes.length; i < il; i ++ ) {
+
+          group.add( meshes[ i ] );
+
+        }
+
+        return group;
+
+      } );
+
+    } );
+
+  };
+
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
+   * @param {number} cameraIndex
+   * @return {Promise<THREE.Camera>}
+   */
+  GLTFParser.prototype.loadCamera = function ( cameraIndex ) {
+
+    var camera;
+    var cameraDef = this.json.cameras[ cameraIndex ];
+    var params = cameraDef[ cameraDef.type ];
+
+    if ( ! params ) {
+
+      console.warn( 'THREE.GLTFLoader: Missing camera parameters.' );
+      return;
+
+    }
+
+    if ( cameraDef.type === 'perspective' ) {
+
+      camera = new THREE.PerspectiveCamera( THREE.Math.radToDeg( params.yfov ), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6 );
+
+    } else if ( cameraDef.type === 'orthographic' ) {
+
+      camera = new THREE.OrthographicCamera( params.xmag / - 2, params.xmag / 2, params.ymag / 2, params.ymag / - 2, params.znear, params.zfar );
+
+    }
+
+    if ( cameraDef.name !== undefined ) camera.name = cameraDef.name;
+
+    assignExtrasToUserData( camera, cameraDef );
+
+    return Promise.resolve( camera );
+
+  };
+
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
+   * @param {number} skinIndex
+   * @return {Promise<Object>}
+   */
+  GLTFParser.prototype.loadSkin = function ( skinIndex ) {
+
+    var skinDef = this.json.skins[ skinIndex ];
+
+    var skinEntry = { joints: skinDef.joints };
+
+    if ( skinDef.inverseBindMatrices === undefined ) {
+
+      return Promise.resolve( skinEntry );
+
+    }
+
+    return this.getDependency( 'accessor', skinDef.inverseBindMatrices ).then( function ( accessor ) {
+
+      skinEntry.inverseBindMatrices = accessor;
+
+      return skinEntry;
+
+    } );
+
+  };
+
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
+   * @param {number} animationIndex
+   * @return {Promise<THREE.AnimationClip>}
+   */
+  GLTFParser.prototype.loadAnimation = function ( animationIndex ) {
+
+    var json = this.json;
+
+    var animationDef = json.animations[ animationIndex ];
+
+    var pendingNodes = [];
+    var pendingInputAccessors = [];
+    var pendingOutputAccessors = [];
+    var pendingSamplers = [];
+    var pendingTargets = [];
+
+    for ( var i = 0, il = animationDef.channels.length; i < il; i ++ ) {
+
+      var channel = animationDef.channels[ i ];
+      var sampler = animationDef.samplers[ channel.sampler ];
+      var target = channel.target;
+      var name = target.node !== undefined ? target.node : target.id; // NOTE: target.id is deprecated.
+      var input = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.input ] : sampler.input;
+      var output = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.output ] : sampler.output;
+
+      pendingNodes.push( this.getDependency( 'node', name ) );
+      pendingInputAccessors.push( this.getDependency( 'accessor', input ) );
+      pendingOutputAccessors.push( this.getDependency( 'accessor', output ) );
+      pendingSamplers.push( sampler );
+      pendingTargets.push( target );
+
+    }
+
+    return Promise.all( [
+
+      Promise.all( pendingNodes ),
+      Promise.all( pendingInputAccessors ),
+      Promise.all( pendingOutputAccessors ),
+      Promise.all( pendingSamplers ),
+      Promise.all( pendingTargets )
+
+    ] ).then( function ( dependencies ) {
+
+      var nodes = dependencies[ 0 ];
+      var inputAccessors = dependencies[ 1 ];
+      var outputAccessors = dependencies[ 2 ];
+      var samplers = dependencies[ 3 ];
+      var targets = dependencies[ 4 ];
+
+      var tracks = [];
+
+      for ( var i = 0, il = nodes.length; i < il; i ++ ) {
+
+        var node = nodes[ i ];
+        var inputAccessor = inputAccessors[ i ];
+        var outputAccessor = outputAccessors[ i ];
+        var sampler = samplers[ i ];
+        var target = targets[ i ];
+
+        if ( node === undefined ) continue;
+
+        node.updateMatrix();
+        node.matrixAutoUpdate = true;
+
+        var TypedKeyframeTrack;
+
+        switch ( PATH_PROPERTIES[ target.path ] ) {
+
+          case PATH_PROPERTIES.weights:
+
+            TypedKeyframeTrack = THREE.NumberKeyframeTrack;
+            break;
+
+          case PATH_PROPERTIES.rotation:
+
+            TypedKeyframeTrack = THREE.QuaternionKeyframeTrack;
+            break;
+
+          case PATH_PROPERTIES.position:
+          case PATH_PROPERTIES.scale:
+          default:
+
+            TypedKeyframeTrack = THREE.VectorKeyframeTrack;
+            break;
+
+        }
+
+        var targetName = node.name ? node.name : node.uuid;
+
+        var interpolation = sampler.interpolation !== undefined ? INTERPOLATION[ sampler.interpolation ] : THREE.InterpolateLinear;
+
+        var targetNames = [];
+
+        if ( PATH_PROPERTIES[ target.path ] === PATH_PROPERTIES.weights ) {
+
+          // Node may be a THREE.Group (glTF mesh with several primitives) or a THREE.Mesh.
+          node.traverse( function ( object ) {
+
+            if ( object.isMesh === true && object.morphTargetInfluences ) {
+
+              targetNames.push( object.name ? object.name : object.uuid );
+
+            }
+
+          } );
+
+        } else {
+
+          targetNames.push( targetName );
+
+        }
+
+        for ( var j = 0, jl = targetNames.length; j < jl; j ++ ) {
+
+          var track = new TypedKeyframeTrack(
+            targetNames[ j ] + '.' + PATH_PROPERTIES[ target.path ],
+            inputAccessor.array,
+            outputAccessor.array,
+            interpolation
+          );
+
+          // Override interpolation with custom factory method.
+          if ( sampler.interpolation === 'CUBICSPLINE' ) {
+
+            track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline( result ) {
+
+              // A CUBICSPLINE keyframe in glTF has three output values for each input value,
+              // representing inTangent, splineVertex, and outTangent. As a result, track.getValueSize()
+              // must be divided by three to get the interpolant's sampleSize argument.
+
+              return new GLTFCubicSplineInterpolant( this.times, this.values, this.getValueSize() / 3, result );
+
+            };
+
+            // Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants.
+            track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;
+
+          }
+
+          tracks.push( track );
+
+        }
+
+      }
+
+      var name = animationDef.name !== undefined ? animationDef.name : 'animation_' + animationIndex;
+
+      return new THREE.AnimationClip( name, undefined, tracks );
+
+    } );
+
+  };
+
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
+   * @param {number} nodeIndex
+   * @return {Promise<THREE.Object3D>}
+   */
+  GLTFParser.prototype.loadNode = function ( nodeIndex ) {
+
+    var json = this.json;
+    var extensions = this.extensions;
+    var parser = this;
+
+    var meshReferences = json.meshReferences;
+    var meshUses = json.meshUses;
+
+    var nodeDef = json.nodes[ nodeIndex ];
+
+    return ( function () {
+
+      // .isBone isn't in glTF spec. See .markDefs
+      if ( nodeDef.isBone === true ) {
+
+        return Promise.resolve( new THREE.Bone() );
+
+      } else if ( nodeDef.mesh !== undefined ) {
+
+        return parser.getDependency( 'mesh', nodeDef.mesh ).then( function ( mesh ) {
+
+          var node;
+
+          if ( meshReferences[ nodeDef.mesh ] > 1 ) {
+
+            var instanceNum = meshUses[ nodeDef.mesh ] ++;
+
+            node = mesh.clone();
+            node.name += '_instance_' + instanceNum;
+
+            // onBeforeRender copy for Specular-Glossiness
+            node.onBeforeRender = mesh.onBeforeRender;
+
+            for ( var i = 0, il = node.children.length; i < il; i ++ ) {
+
+              node.children[ i ].name += '_instance_' + instanceNum;
+              node.children[ i ].onBeforeRender = mesh.children[ i ].onBeforeRender;
+
+            }
+
+          } else {
+
+            node = mesh;
+
+          }
+
+          // if weights are provided on the node, override weights on the mesh.
+          if ( nodeDef.weights !== undefined ) {
+
+            node.traverse( function ( o ) {
+
+              if ( ! o.isMesh ) return;
+
+              for ( var i = 0, il = nodeDef.weights.length; i < il; i ++ ) {
+
+                o.morphTargetInfluences[ i ] = nodeDef.weights[ i ];
+
+              }
+
+            } );
+
+          }
+
+          return node;
+
+        } );
+
+      } else if ( nodeDef.camera !== undefined ) {
+
+        return parser.getDependency( 'camera', nodeDef.camera );
+
+      } else if ( nodeDef.extensions
+        && nodeDef.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ]
+        && nodeDef.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ].light !== undefined ) {
+
+        return parser.getDependency( 'light', nodeDef.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ].light );
+
+      } else {
+
+        return Promise.resolve( new THREE.Object3D() );
+
+      }
+
+    }() ).then( function ( node ) {
+
+      if ( nodeDef.name !== undefined ) {
+
+        node.name = THREE.PropertyBinding.sanitizeNodeName( nodeDef.name );
+
+      }
+
+      assignExtrasToUserData( node, nodeDef );
+
+      if ( nodeDef.extensions ) addUnknownExtensionsToUserData( extensions, node, nodeDef );
+
+      if ( nodeDef.matrix !== undefined ) {
+
+        var matrix = new THREE.Matrix4();
+        matrix.fromArray( nodeDef.matrix );
+        node.applyMatrix( matrix );
+
+      } else {
+
+        if ( nodeDef.translation !== undefined ) {
+
+          node.position.fromArray( nodeDef.translation );
+
+        }
+
+        if ( nodeDef.rotation !== undefined ) {
+
+          node.quaternion.fromArray( nodeDef.rotation );
+
+        }
+
+        if ( nodeDef.scale !== undefined ) {
+
+          node.scale.fromArray( nodeDef.scale );
+
+        }
+
+      }
+
+      return node;
+
+    } );
+
+  };
+
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
+   * @param {number} sceneIndex
+   * @return {Promise<THREE.Scene>}
+   */
+  GLTFParser.prototype.loadScene = function () {
+
+    // scene node hierachy builder
+
+    function buildNodeHierachy( nodeId, parentObject, json, parser ) {
+
+      var nodeDef = json.nodes[ nodeId ];
+
+      return parser.getDependency( 'node', nodeId ).then( function ( node ) {
+
+        if ( nodeDef.skin === undefined ) return node;
+
+        // build skeleton here as well
+
+        var skinEntry;
+
+        return parser.getDependency( 'skin', nodeDef.skin ).then( function ( skin ) {
+
+          skinEntry = skin;
+
+          var pendingJoints = [];
+
+          for ( var i = 0, il = skinEntry.joints.length; i < il; i ++ ) {
+
+            pendingJoints.push( parser.getDependency( 'node', skinEntry.joints[ i ] ) );
+
+          }
+
+          return Promise.all( pendingJoints );
+
+        } ).then( function ( jointNodes ) {
+
+          var meshes = node.isGroup === true ? node.children : [ node ];
+
+          for ( var i = 0, il = meshes.length; i < il; i ++ ) {
+
+            var mesh = meshes[ i ];
+
+            var bones = [];
+            var boneInverses = [];
+
+            for ( var j = 0, jl = jointNodes.length; j < jl; j ++ ) {
+
+              var jointNode = jointNodes[ j ];
+
+              if ( jointNode ) {
+
+                bones.push( jointNode );
+
+                var mat = new THREE.Matrix4();
+
+                if ( skinEntry.inverseBindMatrices !== undefined ) {
+
+                  mat.fromArray( skinEntry.inverseBindMatrices.array, j * 16 );
+
+                }
+
+                boneInverses.push( mat );
+
+              } else {
+
+                console.warn( 'THREE.GLTFLoader: Joint "%s" could not be found.', skinEntry.joints[ j ] );
+
+              }
+
+            }
+
+            mesh.bind( new THREE.Skeleton( bones, boneInverses ), mesh.matrixWorld );
+
+          }
+
+          return node;
+
+        } );
+
+      } ).then( function ( node ) {
+
+        // build node hierachy
+
+        parentObject.add( node );
+
+        var pending = [];
+
+        if ( nodeDef.children ) {
+
+          var children = nodeDef.children;
+
+          for ( var i = 0, il = children.length; i < il; i ++ ) {
+
+            var child = children[ i ];
+            pending.push( buildNodeHierachy( child, node, json, parser ) );
+
+          }
+
+        }
+
+        return Promise.all( pending );
+
+      } );
+
+    }
+
+    return function loadScene( sceneIndex ) {
+
+      var json = this.json;
+      var extensions = this.extensions;
+      var sceneDef = this.json.scenes[ sceneIndex ];
+      var parser = this;
+
+      var scene = new THREE.Scene();
+      if ( sceneDef.name !== undefined ) scene.name = sceneDef.name;
+
+      assignExtrasToUserData( scene, sceneDef );
+
+      if ( sceneDef.extensions ) addUnknownExtensionsToUserData( extensions, scene, sceneDef );
+
+      var nodeIds = sceneDef.nodes || [];
+
+      var pending = [];
+
+      for ( var i = 0, il = nodeIds.length; i < il; i ++ ) {
+
+        pending.push( buildNodeHierachy( nodeIds[ i ], scene, json, parser ) );
+
+      }
+
+      return Promise.all( pending ).then( function () {
+
+        return scene;
+
+      } );
+
+    };
+
+  }();
+
+  return GLTFLoader;
+
+} )();
\ No newline at end of file
diff --git a/webgl/gltf-demo/README.md b/webgl/gltf-demo/README.md
new file mode 100644
index 0000000..0cbc973
--- /dev/null
+++ b/webgl/gltf-demo/README.md
@@ -0,0 +1,44 @@
+# glTF Demo
+
+A WebGL demo rendering a glTF 3D model with `.basis` texture files, transcoded into one of the following compressed texture formats:
+
+* DTX (BC1)
+  * Tested in Chrome (Linux and macOS) and Firefox (macOS).
+* ETC1
+  * Tested in Chrome on Android, Pixel 3 XL.
+* PVRTC (COMPRESSED_RGB_PVRTC_4BPPV1_IMG)
+  * Tested in Chrome and Safari on iOS iPhone 6 Plus.
+
+Requires WebAssembly and WebGL support.
+
+The glTF model in this demo uses a hypothetical `GOOGLE_texture_basis` extension. That extension is defined for the sake of example only – the glTF format will officially embed Basis files within a KTX2 wrapper, through a new
+extension that is currently in development.
+
+## Testing locally
+
+See [how to run things locally](https://threejs.org/docs/#manual/en/introduction/How-to-run-things-locally), or (with [Node.js](https://nodejs.org/en/) installed), run:
+
+```
+npx serve
+```
+
+The console will display a `localhost` URL for local testing, and (on supported WiFi networks and devices) may also display an IP address accessible by other devices on the same network. Note that mobile devices must support WebAssembly to run this demo. Learn more about [remote debugging your android devices](https://developers.google.com/web/tools/chrome-devtools/remote-debugging/).
+
+## Building transcoder locally
+
+Prebuilt versions of `basis_transcoder.js` and `basis_transcoder.wasm` are included in the `wasm/build/` folder, and are sufficient for local demos. To build the transcoder yourself, first install emscripten ([tutorial](https://webassembly.org/getting-started/developers-guide/)) and cmake ([download](https://cmake.org/download/)). Then run:
+
+```shell
+cd webgl/gltf-demo/wasm/build/
+emcmake cmake ../
+make
+```
+
+## Credits
+
+* Contributors:
+  * [Don McCurdy](https://www.donmccurdy.com)
+  * [Austin Eng](https://github.com/austinEng)
+  * [Shrek Shao](https://github.com/shrekshao)
+* Made with [three.js](https://threejs.org/).
+* Thanks to [AGI](http://agi.com/) for providing the glTF model.
diff --git a/webgl/gltf-demo/index.html b/webgl/gltf-demo/index.html
new file mode 100644
index 0000000..f38ec0f
--- /dev/null
+++ b/webgl/gltf-demo/index.html
@@ -0,0 +1,117 @@
+<!DOCTYPE html>
+
+<head>
+  <script src="https://cdn.jsdelivr.net/npm/three@v0.104.0"></script>
+  <script src="GLTFLoader.js"></script>
+  <script src="BasisTextureLoader.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/three@v0.104.0/examples/js/controls/OrbitControls.js"></script>
+  <style>
+    html, body { width:100%; height:100%; margin:0; padding:0; }
+    canvas { display:block; }
+    #panel { position: absolute; top: 10px; left: 10px; color: white; background-color:rgba(0.3, 0.3, 0.3, 0.3); padding: 0.5em; max-width: 400px;}
+  </style>
+</head>
+
+<body>
+  <script src="./wasm/build/basis_transcoder.js"></script>
+  <script>
+    Module.onRuntimeInitialized = () => {
+
+      const { BasisFile, initializeBasis } = Module;
+
+      window.BasisFile = BasisFile;
+
+      initializeBasis();
+
+      // Initialize three.js scene and renderer.
+
+      const renderer = new THREE.WebGLRenderer( { antialias: true } );
+      renderer.setSize( window.innerWidth, window.innerHeight );
+      renderer.gammaOutput = true;
+      renderer.gammaFactor = 2.2;
+
+      const scene = new THREE.Scene();
+      scene.background = new THREE.Color( 0xf0f0f0 );
+
+      const light = new THREE.AmbientLight();
+      scene.add( light );
+
+      const light2 = new THREE.PointLight();
+      scene.add( light2 );
+
+      const camera = new THREE.PerspectiveCamera( 60, window.innerWidth / window.innerHeight, 0.1, 100 );
+      camera.position.set( 8, 6, 5 );
+      camera.lookAt( new THREE.Vector3( 0, -2, 0 ) );
+
+      const controls = new THREE.OrbitControls( camera, renderer.domElement );
+      controls.autoRotate = true;
+
+      // Create BasisTextureLoader and detect supported target formats.
+
+      const basisLoader = new THREE.BasisTextureLoader();
+      basisLoader.detectSupport( renderer );
+
+      const formatName = basisLoader.etcSupported
+        ? 'ETC1'
+        : ( basisLoader.dxtSupported ? 'BC1' : 'PVRTC' );
+      log(`Transcode to: <strong>${formatName}</strong>`);
+
+      // Register BasisTextureLoader for .basis extension.
+
+      THREE.Loader.Handlers.add( /\.basis$/, basisLoader );
+
+      // Create GLTFLoader, load model, and render.
+
+      const loader = new THREE.GLTFLoader();
+
+      loader.load( 'AGI_HQ/AgiHQ.gltf', ( gltf ) => {
+
+        const model = gltf.scene;
+        model.scale.set( 0.01, 0.01, 0.01 );
+
+        scene.add( model );
+
+        document.body.appendChild( renderer.domElement );
+
+        animate();
+
+      }, undefined, ( e ) => console.error( e ) );
+
+      // Main render loop.
+
+      function animate() {
+
+        requestAnimationFrame( animate );
+        controls.update();
+        renderer.render( scene, camera );
+
+      }
+
+      // Support viewport resizing.
+
+      window.addEventListener( 'resize', () => {
+
+        camera.aspect = window.innerWidth / window.innerHeight;
+        camera.updateProjectionMatrix();
+        renderer.setSize( window.innerWidth, window.innerHeight );
+
+      }, false );
+
+    }
+
+    function log(s) {
+
+      const div = document.createElement('div');
+      div.innerHTML = s;
+      document.getElementById('log').appendChild(div);
+
+    }
+  </script>
+  <div id="panel">
+    <strong>Basis Texture Transcoder glTF Demo</strong>
+    <div id="log"></div>
+
+  </div>
+</body>
+
+</html>
\ No newline at end of file
diff --git a/webgl/gltf-demo/wasm/CMakeLists.txt b/webgl/gltf-demo/wasm/CMakeLists.txt
new file mode 100644
index 0000000..e6171d9
--- /dev/null
+++ b/webgl/gltf-demo/wasm/CMakeLists.txt
@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 3.0)
+
+project(basisu_transcoder_js)
+
+if (EMSCRIPTEN)
+  set(CMAKE_CXX_STANDARD 11)
+
+  add_executable(basis_transcoder.js
+    ../../../transcoder/basisu_transcoder.cpp
+    basis_wrappers.cpp
+  )
+
+  target_include_directories(basis_transcoder.js PRIVATE ../../../transcoder)
+
+  set_target_properties(basis_transcoder.js PROPERTIES
+      OUTPUT_NAME "basis_transcoder"
+      SUFFIX ".js"
+      LINK_FLAGS "--bind -s ALLOW_MEMORY_GROWTH=1 -O3 -s ASSERTIONS=0")
+endif()
diff --git a/webgl/gltf-demo/wasm/basis_wrappers.cpp b/webgl/gltf-demo/wasm/basis_wrappers.cpp
new file mode 100644
index 0000000..64a850d
--- /dev/null
+++ b/webgl/gltf-demo/wasm/basis_wrappers.cpp
@@ -0,0 +1,205 @@
+// basis_wrappers.cpp - Simple C-style wrappers to the C++ transcoder for WebGL use.
+#include "basisu_transcoder.h"
+#include <emscripten/bind.h>
+
+#include <iostream>
+
+using namespace emscripten;
+using namespace basist;
+
+static basist::etc1_global_selector_codebook *g_pGlobal_codebook;
+
+void basis_init()
+{
+  basisu_transcoder_init();
+
+  if (!g_pGlobal_codebook)
+    g_pGlobal_codebook = new basist::etc1_global_selector_codebook(g_global_selector_cb_size, g_global_selector_cb);
+}
+
+#define MAGIC 0xDEADBEE1
+
+struct basis_file
+{
+  int m_magic = 0;
+	basisu_transcoder m_transcoder;
+  std::vector<uint8_t> m_file;
+
+  basis_file(const emscripten::val& jsBuffer)
+    : m_file([&]() {
+        size_t byteLength = jsBuffer["byteLength"].as<size_t>();
+        return std::vector<uint8_t>(byteLength);
+      }()),
+      m_transcoder(g_pGlobal_codebook)
+  {
+    unsigned int length = jsBuffer["length"].as<unsigned int>();
+    emscripten::val memory = emscripten::val::module_property("HEAP8")["buffer"];
+    emscripten::val memoryView = jsBuffer["constructor"].new_(memory, reinterpret_cast<uintptr_t>(m_file.data()), length);
+    memoryView.call<void>("set", jsBuffer);
+
+    if (!m_transcoder.validate_header(m_file.data(), m_file.size())) {
+      m_file.clear();
+      std::cerr << "Invalid Basis header" << std::endl;
+    }
+
+    // Initialized after validation
+    m_magic = MAGIC;
+  }
+
+  void close() {
+    assert(m_magic == MAGIC);
+    m_file.clear();
+  }
+
+  uint32_t getHasAlpha() {
+    assert(m_magic == MAGIC);
+    if (m_magic != MAGIC)
+      return 0;
+
+    basisu_image_level_info li;
+    if (!m_transcoder.get_image_level_info(m_file.data(), m_file.size(), li, 0, 0))
+      return 0;
+
+    return li.m_alpha_flag;
+  }
+
+  uint32_t getNumImages() {
+    assert(m_magic == MAGIC);
+    if (m_magic != MAGIC)
+      return 0;
+
+    return m_transcoder.get_total_images(m_file.data(), m_file.size());
+  }
+
+  uint32_t getNumLevels(uint32_t image_index) {
+    assert(m_magic == MAGIC);
+    if (m_magic != MAGIC)
+      return 0;
+
+    basisu_image_info ii;
+    if (!m_transcoder.get_image_info(m_file.data(), m_file.size(), ii, image_index))
+      return 0;
+
+    return ii.m_total_levels;
+  }
+
+  uint32_t getImageWidth(uint32_t image_index, uint32_t level_index) {
+    assert(m_magic == MAGIC);
+    if (m_magic != MAGIC)
+      return 0;
+
+    uint32_t orig_width, orig_height, total_blocks;
+    if (!m_transcoder.get_image_level_desc(m_file.data(), m_file.size(), image_index, level_index, orig_width, orig_height, total_blocks))
+      return 0;
+
+    return orig_width;
+  }
+
+  uint32_t getImageHeight(uint32_t image_index, uint32_t level_index) {
+    assert(m_magic == MAGIC);
+    if (m_magic != MAGIC)
+      return 0;
+
+    uint32_t orig_width, orig_height, total_blocks;
+    if (!m_transcoder.get_image_level_desc(m_file.data(), m_file.size(), image_index, level_index, orig_width, orig_height, total_blocks))
+      return 0;
+
+    return orig_height;
+  }
+
+  uint32_t getImageTranscodedSizeInBytes(uint32_t image_index, uint32_t level_index, uint32_t format) {
+    assert(m_magic == MAGIC);
+    if (m_magic != MAGIC)
+      return 0;
+
+    if (format >= cTFTotalTextureFormats)
+      return 0;
+
+    uint32_t bytes_per_block = basis_get_bytes_per_block(static_cast<transcoder_texture_format>(format));
+
+    uint32_t orig_width, orig_height, total_blocks;
+    if (!m_transcoder.get_image_level_desc(m_file.data(), m_file.size(), image_index, level_index, orig_width, orig_height, total_blocks))
+      return 0;
+
+    return total_blocks * bytes_per_block;
+  }
+
+  uint32_t startTranscoding() {
+    assert(m_magic == MAGIC);
+    if (m_magic != MAGIC)
+      return 0;
+
+    return m_transcoder.start_transcoding(m_file.data(), m_file.size());
+  }
+
+  uint32_t transcodeImage(const emscripten::val& dst, uint32_t image_index, uint32_t level_index, uint32_t format, uint32_t pvrtc_wrap_addressing, uint32_t get_alpha_for_opaque_formats) {
+    assert(m_magic == MAGIC);
+    if (m_magic != MAGIC)
+      return 0;
+
+    if (format >= cTFTotalTextureFormats)
+      return 0;
+
+    uint32_t bytes_per_block = basis_get_bytes_per_block(static_cast<transcoder_texture_format>(format));
+
+    uint32_t orig_width, orig_height, total_blocks;
+    if (!m_transcoder.get_image_level_desc(m_file.data(), m_file.size(), image_index, level_index, orig_width, orig_height, total_blocks))
+      return 0;
+
+    uint32_t required_size = total_blocks * bytes_per_block;
+
+    std::vector<uint8_t> dst_data(required_size);
+
+    uint32_t status = m_transcoder.transcode_image_level(
+      m_file.data(), m_file.size(), image_index, level_index,
+      dst_data.data(), dst_data.size() / bytes_per_block,
+      static_cast<basist::transcoder_texture_format>(format),
+      (
+        (pvrtc_wrap_addressing ? basisu_transcoder::cDecodeFlagsPVRTCWrapAddressing : 0) |
+        (get_alpha_for_opaque_formats ? basisu_transcoder::cDecodeFlagsTranscodeAlphaDataToOpaqueFormats : 0)
+      ));
+
+    emscripten::val memory = emscripten::val::module_property("HEAP8")["buffer"];
+    emscripten::val memoryView = emscripten::val::global("Uint8Array").new_(memory, reinterpret_cast<uintptr_t>(dst_data.data()), dst_data.size());
+
+    dst.call<void>("set", memoryView);
+    return status;
+  }
+};
+
+EMSCRIPTEN_BINDINGS(basis_transcoder) {
+
+  function("initializeBasis", &basis_init);
+
+  class_<basis_file>("BasisFile")
+    .constructor<const emscripten::val&>()
+    .function("close", optional_override([](basis_file& self) {
+      return self.close();
+    }))
+    .function("getHasAlpha", optional_override([](basis_file& self) {
+      return self.getHasAlpha();
+    }))
+    .function("getNumImages", optional_override([](basis_file& self) {
+      return self.getNumImages();
+    }))
+    .function("getNumLevels", optional_override([](basis_file& self, uint32_t imageIndex) {
+      return self.getNumLevels(imageIndex);
+    }))
+    .function("getImageWidth", optional_override([](basis_file& self, uint32_t imageIndex, uint32_t levelIndex) {
+      return self.getImageWidth(imageIndex, levelIndex);
+    }))
+    .function("getImageHeight", optional_override([](basis_file& self, uint32_t imageIndex, uint32_t levelIndex) {
+      return self.getImageHeight(imageIndex, levelIndex);
+    }))
+    .function("getImageTranscodedSizeInBytes", optional_override([](basis_file& self, uint32_t imageIndex, uint32_t levelIndex, uint32_t format) {
+      return self.getImageTranscodedSizeInBytes(imageIndex, levelIndex, format);
+    }))
+    .function("startTranscoding", optional_override([](basis_file& self) {
+      return self.startTranscoding();
+    }))
+    .function("transcodeImage", optional_override([](basis_file& self, const emscripten::val& dst, uint32_t imageIndex, uint32_t levelIndex, uint32_t format, uint32_t pvrtcWrapAddressing, uint32_t getAlphaForOpaqueFormats) {
+      return self.transcodeImage(dst, imageIndex, levelIndex, format, pvrtcWrapAddressing, getAlphaForOpaqueFormats);
+    }))
+  ;
+
+}
diff --git a/webgl/gltf-demo/wasm/build/basis_transcoder.js b/webgl/gltf-demo/wasm/build/basis_transcoder.js
new file mode 100644
index 0000000..604804f
--- /dev/null
+++ b/webgl/gltf-demo/wasm/build/basis_transcoder.js
@@ -0,0 +1 @@
+var Module=typeof Module!=="undefined"?Module:{};var moduleOverrides={};var key;for(key in Module){if(Module.hasOwnProperty(key)){moduleOverrides[key]=Module[key]}}Module["arguments"]=[];Module["thisProgram"]="./this.program";Module["quit"]=function(status,toThrow){throw toThrow};Module["preRun"]=[];Module["postRun"]=[];var ENVIRONMENT_IS_WEB=false;var ENVIRONMENT_IS_WORKER=false;var ENVIRONMENT_IS_NODE=false;var ENVIRONMENT_IS_SHELL=false;ENVIRONMENT_IS_WEB=typeof window==="object";ENVIRONMENT_IS_WORKER=typeof importScripts==="function";ENVIRONMENT_IS_NODE=typeof process==="object"&&typeof require==="function"&&!ENVIRONMENT_IS_WEB&&!ENVIRONMENT_IS_WORKER;ENVIRONMENT_IS_SHELL=!ENVIRONMENT_IS_WEB&&!ENVIRONMENT_IS_NODE&&!ENVIRONMENT_IS_WORKER;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}else{return scriptDirectory+path}}if(ENVIRONMENT_IS_NODE){scriptDirectory=__dirname+"/";var nodeFS;var nodePath;Module["read"]=function shell_read(filename,binary){var ret;if(!nodeFS)nodeFS=require("fs");if(!nodePath)nodePath=require("path");filename=nodePath["normalize"](filename);ret=nodeFS["readFileSync"](filename);return binary?ret:ret.toString()};Module["readBinary"]=function readBinary(filename){var ret=Module["read"](filename,true);if(!ret.buffer){ret=new Uint8Array(ret)}assert(ret.buffer);return ret};if(process["argv"].length>1){Module["thisProgram"]=process["argv"][1].replace(/\\/g,"/")}Module["arguments"]=process["argv"].slice(2);if(typeof module!=="undefined"){module["exports"]=Module}process["on"]("uncaughtException",function(ex){if(!(ex instanceof ExitStatus)){throw ex}});process["on"]("unhandledRejection",abort);Module["quit"]=function(status){process["exit"](status)};Module["inspect"]=function(){return"[Emscripten Module object]"}}else if(ENVIRONMENT_IS_SHELL){if(typeof read!="undefined"){Module["read"]=function shell_read(f){return read(f)}}Module["readBinary"]=function readBinary(f){var data;if(typeof readbuffer==="function"){return new Uint8Array(readbuffer(f))}data=read(f,"binary");assert(typeof data==="object");return data};if(typeof scriptArgs!="undefined"){Module["arguments"]=scriptArgs}else if(typeof arguments!="undefined"){Module["arguments"]=arguments}if(typeof quit==="function"){Module["quit"]=function(status){quit(status)}}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(document.currentScript){scriptDirectory=document.currentScript.src}if(scriptDirectory.indexOf("blob:")!==0){scriptDirectory=scriptDirectory.substr(0,scriptDirectory.lastIndexOf("/")+1)}else{scriptDirectory=""}Module["read"]=function shell_read(url){var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText};if(ENVIRONMENT_IS_WORKER){Module["readBinary"]=function readBinary(url){var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}Module["readAsync"]=function readAsync(url,onload,onerror){var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=function xhr_onload(){if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}onerror()};xhr.onerror=onerror;xhr.send(null)};Module["setWindowTitle"]=function(title){document.title=title}}else{}var out=Module["print"]||(typeof console!=="undefined"?console.log.bind(console):typeof print!=="undefined"?print:null);var err=Module["printErr"]||(typeof printErr!=="undefined"?printErr:typeof console!=="undefined"&&console.warn.bind(console)||out);for(key in moduleOverrides){if(moduleOverrides.hasOwnProperty(key)){Module[key]=moduleOverrides[key]}}moduleOverrides=undefined;function dynamicAlloc(size){var ret=HEAP32[DYNAMICTOP_PTR>>2];var end=ret+size+15&-16;if(end<=_emscripten_get_heap_size()){HEAP32[DYNAMICTOP_PTR>>2]=end}else{var success=_emscripten_resize_heap(end);if(!success)return 0}return ret}function getNativeTypeSize(type){switch(type){case"i1":case"i8":return 1;case"i16":return 2;case"i32":return 4;case"i64":return 8;case"float":return 4;case"double":return 8;default:{if(type[type.length-1]==="*"){return 4}else if(type[0]==="i"){var bits=parseInt(type.substr(1));assert(bits%8===0,"getNativeTypeSize invalid bits "+bits+", type "+type);return bits/8}else{return 0}}}}var asm2wasmImports={"f64-rem":function(x,y){return x%y},"debugger":function(){debugger}};var functionPointers=new Array(0);var tempRet0=0;var setTempRet0=function(value){tempRet0=value};if(typeof WebAssembly!=="object"){err("no native wasm support detected")}var wasmMemory;var wasmTable;var ABORT=false;var EXITSTATUS=0;function assert(condition,text){if(!condition){abort("Assertion failed: "+text)}}function setValue(ptr,value,type,noSafe){type=type||"i8";if(type.charAt(type.length-1)==="*")type="i32";switch(type){case"i1":HEAP8[ptr>>0]=value;break;case"i8":HEAP8[ptr>>0]=value;break;case"i16":HEAP16[ptr>>1]=value;break;case"i32":HEAP32[ptr>>2]=value;break;case"i64":tempI64=[value>>>0,(tempDouble=value,+Math_abs(tempDouble)>=1?tempDouble>0?(Math_min(+Math_floor(tempDouble/4294967296),4294967295)|0)>>>0:~~+Math_ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[ptr>>2]=tempI64[0],HEAP32[ptr+4>>2]=tempI64[1];break;case"float":HEAPF32[ptr>>2]=value;break;case"double":HEAPF64[ptr>>3]=value;break;default:abort("invalid type for setValue: "+type)}}var ALLOC_NONE=3;function allocate(slab,types,allocator,ptr){var zeroinit,size;if(typeof slab==="number"){zeroinit=true;size=slab}else{zeroinit=false;size=slab.length}var singleType=typeof types==="string"?types:null;var ret;if(allocator==ALLOC_NONE){ret=ptr}else{ret=[_malloc,stackAlloc,dynamicAlloc][allocator](Math.max(size,singleType?1:types.length))}if(zeroinit){var stop;ptr=ret;assert((ret&3)==0);stop=ret+(size&~3);for(;ptr<stop;ptr+=4){HEAP32[ptr>>2]=0}stop=ret+size;while(ptr<stop){HEAP8[ptr++>>0]=0}return ret}if(singleType==="i8"){if(slab.subarray||slab.slice){HEAPU8.set(slab,ret)}else{HEAPU8.set(new Uint8Array(slab),ret)}return ret}var i=0,type,typeSize,previousType;while(i<size){var curr=slab[i];type=singleType||types[i];if(type===0){i++;continue}if(type=="i64")type="i32";setValue(ret+i,curr,type);if(previousType!==type){typeSize=getNativeTypeSize(type);previousType=type}i+=typeSize}return ret}var UTF8Decoder=typeof TextDecoder!=="undefined"?new TextDecoder("utf8"):undefined;function UTF8ArrayToString(u8Array,idx,maxBytesToRead){var endIdx=idx+maxBytesToRead;var endPtr=idx;while(u8Array[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&u8Array.subarray&&UTF8Decoder){return UTF8Decoder.decode(u8Array.subarray(idx,endPtr))}else{var str="";while(idx<endPtr){var u0=u8Array[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=u8Array[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=u8Array[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|u8Array[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}}return str}function UTF8ToString(ptr,maxBytesToRead){return ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):""}function stringToUTF8Array(str,outU8Array,outIdx,maxBytesToWrite){if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.charCodeAt(i);if(u>=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023}if(u<=127){if(outIdx>=endIdx)break;outU8Array[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;outU8Array[outIdx++]=192|u>>6;outU8Array[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;outU8Array[outIdx++]=224|u>>12;outU8Array[outIdx++]=128|u>>6&63;outU8Array[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;outU8Array[outIdx++]=240|u>>18;outU8Array[outIdx++]=128|u>>12&63;outU8Array[outIdx++]=128|u>>6&63;outU8Array[outIdx++]=128|u&63}}outU8Array[outIdx]=0;return outIdx-startIdx}function stringToUTF8(str,outPtr,maxBytesToWrite){return stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite)}function lengthBytesUTF8(str){var len=0;for(var i=0;i<str.length;++i){var u=str.charCodeAt(i);if(u>=55296&&u<=57343)u=65536+((u&1023)<<10)|str.charCodeAt(++i)&1023;if(u<=127)++len;else if(u<=2047)len+=2;else if(u<=65535)len+=3;else len+=4}return len}var UTF16Decoder=typeof TextDecoder!=="undefined"?new TextDecoder("utf-16le"):undefined;function allocateUTF8(str){var size=lengthBytesUTF8(str)+1;var ret=_malloc(size);if(ret)stringToUTF8Array(str,HEAP8,ret,size);return ret}function writeArrayToMemory(array,buffer){HEAP8.set(array,buffer)}function demangle(func){return func}function demangleAll(text){var regex=/__Z[\w\d_]+/g;return text.replace(regex,function(x){var y=demangle(x);return x===y?x:y+" ["+x+"]"})}function jsStackTrace(){var err=new Error;if(!err.stack){try{throw new Error(0)}catch(e){err=e}if(!err.stack){return"(no stack trace available)"}}return err.stack.toString()}function stackTrace(){var js=jsStackTrace();if(Module["extraStackTrace"])js+="\n"+Module["extraStackTrace"]();return demangleAll(js)}var WASM_PAGE_SIZE=65536;function alignUp(x,multiple){if(x%multiple>0){x+=multiple-x%multiple}return x}var buffer,HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateGlobalBufferViews(){Module["HEAP8"]=HEAP8=new Int8Array(buffer);Module["HEAP16"]=HEAP16=new Int16Array(buffer);Module["HEAP32"]=HEAP32=new Int32Array(buffer);Module["HEAPU8"]=HEAPU8=new Uint8Array(buffer);Module["HEAPU16"]=HEAPU16=new Uint16Array(buffer);Module["HEAPU32"]=HEAPU32=new Uint32Array(buffer);Module["HEAPF32"]=HEAPF32=new Float32Array(buffer);Module["HEAPF64"]=HEAPF64=new Float64Array(buffer)}var DYNAMIC_BASE=5913552,DYNAMICTOP_PTR=670640;var TOTAL_STACK=5242880;var INITIAL_TOTAL_MEMORY=Module["TOTAL_MEMORY"]||16777216;if(INITIAL_TOTAL_MEMORY<TOTAL_STACK)err("TOTAL_MEMORY should be larger than TOTAL_STACK, was "+INITIAL_TOTAL_MEMORY+"! (TOTAL_STACK="+TOTAL_STACK+")");if(Module["buffer"]){buffer=Module["buffer"]}else{if(typeof WebAssembly==="object"&&typeof WebAssembly.Memory==="function"){wasmMemory=new WebAssembly.Memory({"initial":INITIAL_TOTAL_MEMORY/WASM_PAGE_SIZE});buffer=wasmMemory.buffer}else{buffer=new ArrayBuffer(INITIAL_TOTAL_MEMORY)}}updateGlobalBufferViews();HEAP32[DYNAMICTOP_PTR>>2]=DYNAMIC_BASE;function callRuntimeCallbacks(callbacks){while(callbacks.length>0){var callback=callbacks.shift();if(typeof callback=="function"){callback();continue}var func=callback.func;if(typeof func==="number"){if(callback.arg===undefined){Module["dynCall_v"](func)}else{Module["dynCall_vi"](func,callback.arg)}}else{func(callback.arg===undefined?null:callback.arg)}}}var __ATPRERUN__=[];var __ATINIT__=[];var __ATMAIN__=[];var __ATPOSTRUN__=[];var runtimeInitialized=false;function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(__ATPRERUN__)}function ensureInitRuntime(){if(runtimeInitialized)return;runtimeInitialized=true;if(!Module["noFSInit"]&&!FS.init.initialized)FS.init();TTY.init();callRuntimeCallbacks(__ATINIT__)}function preMain(){FS.ignorePermissions=false;callRuntimeCallbacks(__ATMAIN__)}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(__ATPOSTRUN__)}function addOnPreRun(cb){__ATPRERUN__.unshift(cb)}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb)}var Math_abs=Math.abs;var Math_ceil=Math.ceil;var Math_floor=Math.floor;var Math_min=Math.min;var runDependencies=0;var runDependencyWatcher=null;var dependenciesFulfilled=null;function getUniqueRunDependency(id){return id}function addRunDependency(id){runDependencies++;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies)}}function removeRunDependency(id){runDependencies--;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies)}if(runDependencies==0){if(runDependencyWatcher!==null){clearInterval(runDependencyWatcher);runDependencyWatcher=null}if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}Module["preloadedImages"]={};Module["preloadedAudios"]={};var dataURIPrefix="data:application/octet-stream;base64,";function isDataURI(filename){return String.prototype.startsWith?filename.startsWith(dataURIPrefix):filename.indexOf(dataURIPrefix)===0}var wasmBinaryFile="basis_transcoder.wasm";if(!isDataURI(wasmBinaryFile)){wasmBinaryFile=locateFile(wasmBinaryFile)}function getBinary(){try{if(Module["wasmBinary"]){return new Uint8Array(Module["wasmBinary"])}if(Module["readBinary"]){return Module["readBinary"](wasmBinaryFile)}else{throw"both async and sync fetching of the wasm failed"}}catch(err){abort(err)}}function getBinaryPromise(){if(!Module["wasmBinary"]&&(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER)&&typeof fetch==="function"){return fetch(wasmBinaryFile,{credentials:"same-origin"}).then(function(response){if(!response["ok"]){throw"failed to load wasm binary file at '"+wasmBinaryFile+"'"}return response["arrayBuffer"]()}).catch(function(){return getBinary()})}return new Promise(function(resolve,reject){resolve(getBinary())})}function createWasm(env){var info={"env":env,"global":{"NaN":NaN,Infinity:Infinity},"global.Math":Math,"asm2wasm":asm2wasmImports};function receiveInstance(instance,module){var exports=instance.exports;Module["asm"]=exports;removeRunDependency("wasm-instantiate")}addRunDependency("wasm-instantiate");if(Module["instantiateWasm"]){try{return Module["instantiateWasm"](info,receiveInstance)}catch(e){err("Module.instantiateWasm callback failed with error: "+e);return false}}function receiveInstantiatedSource(output){receiveInstance(output["instance"])}function instantiateArrayBuffer(receiver){getBinaryPromise().then(function(binary){return WebAssembly.instantiate(binary,info)}).then(receiver,function(reason){err("failed to asynchronously prepare wasm: "+reason);abort(reason)})}if(!Module["wasmBinary"]&&typeof WebAssembly.instantiateStreaming==="function"&&!isDataURI(wasmBinaryFile)&&typeof fetch==="function"){WebAssembly.instantiateStreaming(fetch(wasmBinaryFile,{credentials:"same-origin"}),info).then(receiveInstantiatedSource,function(reason){err("wasm streaming compile failed: "+reason);err("falling back to ArrayBuffer instantiation");instantiateArrayBuffer(receiveInstantiatedSource)})}else{instantiateArrayBuffer(receiveInstantiatedSource)}return{}}Module["asm"]=function(global,env,providedBuffer){env["memory"]=wasmMemory;env["table"]=wasmTable=new WebAssembly.Table({"initial":573,"maximum":573,"element":"anyfunc"});env["__memory_base"]=1024;env["__table_base"]=0;var exports=createWasm(env);return exports};__ATINIT__.push({func:function(){globalCtors()}});function ___assert_fail(condition,filename,line,func){abort("Assertion failed: "+UTF8ToString(condition)+", at: "+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"])}function ___cxa_allocate_exception(size){return _malloc(size)}function ___cxa_free_exception(ptr){try{return _free(ptr)}catch(e){}}var EXCEPTIONS={last:0,caught:[],infos:{},deAdjust:function(adjusted){if(!adjusted||EXCEPTIONS.infos[adjusted])return adjusted;for(var key in EXCEPTIONS.infos){var ptr=+key;var adj=EXCEPTIONS.infos[ptr].adjusted;var len=adj.length;for(var i=0;i<len;i++){if(adj[i]===adjusted){return ptr}}}return adjusted},addRef:function(ptr){if(!ptr)return;var info=EXCEPTIONS.infos[ptr];info.refcount++},decRef:function(ptr){if(!ptr)return;var info=EXCEPTIONS.infos[ptr];assert(info.refcount>0);info.refcount--;if(info.refcount===0&&!info.rethrown){if(info.destructor){Module["dynCall_vi"](info.destructor,ptr)}delete EXCEPTIONS.infos[ptr];___cxa_free_exception(ptr)}},clearRef:function(ptr){if(!ptr)return;var info=EXCEPTIONS.infos[ptr];info.refcount=0}};function ___cxa_throw(ptr,type,destructor){EXCEPTIONS.infos[ptr]={ptr:ptr,adjusted:[ptr],type:type,destructor:destructor,refcount:0,caught:false,rethrown:false};EXCEPTIONS.last=ptr;if(!("uncaught_exception"in __ZSt18uncaught_exceptionv)){__ZSt18uncaught_exceptionv.uncaught_exception=1}else{__ZSt18uncaught_exceptionv.uncaught_exception++}throw ptr}function ___cxa_uncaught_exception(){return!!__ZSt18uncaught_exceptionv.uncaught_exception}function ___lock(){}function ___setErrNo(value){if(Module["___errno_location"])HEAP32[Module["___errno_location"]()>>2]=value;return value}function ___map_file(pathname,size){___setErrNo(1);return-1}var PATH={splitPath:function(filename){var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:function(parts,allowAboveRoot){var up=0;for(var i=parts.length-1;i>=0;i--){var last=parts[i];if(last==="."){parts.splice(i,1)}else if(last===".."){parts.splice(i,1);up++}else if(up){parts.splice(i,1);up--}}if(allowAboveRoot){for(;up;up--){parts.unshift("..")}}return parts},normalize:function(path){var isAbsolute=path.charAt(0)==="/",trailingSlash=path.substr(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(function(p){return!!p}),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path},dirname:function(path){var result=PATH.splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return"."}if(dir){dir=dir.substr(0,dir.length-1)}return root+dir},basename:function(path){if(path==="/")return"/";var lastSlash=path.lastIndexOf("/");if(lastSlash===-1)return path;return path.substr(lastSlash+1)},extname:function(path){return PATH.splitPath(path)[3]},join:function(){var paths=Array.prototype.slice.call(arguments,0);return PATH.normalize(paths.join("/"))},join2:function(l,r){return PATH.normalize(l+"/"+r)},resolve:function(){var resolvedPath="",resolvedAbsolute=false;for(var i=arguments.length-1;i>=-1&&!resolvedAbsolute;i--){var path=i>=0?arguments[i]:FS.cwd();if(typeof path!=="string"){throw new TypeError("Arguments to path.resolve must be strings")}else if(!path){return""}resolvedPath=path+"/"+resolvedPath;resolvedAbsolute=path.charAt(0)==="/"}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(function(p){return!!p}),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."},relative:function(from,to){from=PATH.resolve(from).substr(1);to=PATH.resolve(to).substr(1);function trim(arr){var start=0;for(;start<arr.length;start++){if(arr[start]!=="")break}var end=arr.length-1;for(;end>=0;end--){if(arr[end]!=="")break}if(start>end)return[];return arr.slice(start,end-start+1)}var fromParts=trim(from.split("/"));var toParts=trim(to.split("/"));var length=Math.min(fromParts.length,toParts.length);var samePartsLength=length;for(var i=0;i<length;i++){if(fromParts[i]!==toParts[i]){samePartsLength=i;break}}var outputParts=[];for(var i=samePartsLength;i<fromParts.length;i++){outputParts.push("..")}outputParts=outputParts.concat(toParts.slice(samePartsLength));return outputParts.join("/")}};var TTY={ttys:[],init:function(){},shutdown:function(){},register:function(dev,ops){TTY.ttys[dev]={input:[],output:[],ops:ops};FS.registerDevice(dev,TTY.stream_ops)},stream_ops:{open:function(stream){var tty=TTY.ttys[stream.node.rdev];if(!tty){throw new FS.ErrnoError(19)}stream.tty=tty;stream.seekable=false},close:function(stream){stream.tty.ops.flush(stream.tty)},flush:function(stream){stream.tty.ops.flush(stream.tty)},read:function(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.get_char){throw new FS.ErrnoError(6)}var bytesRead=0;for(var i=0;i<length;i++){var result;try{result=stream.tty.ops.get_char(stream.tty)}catch(e){throw new FS.ErrnoError(5)}if(result===undefined&&bytesRead===0){throw new FS.ErrnoError(11)}if(result===null||result===undefined)break;bytesRead++;buffer[offset+i]=result}if(bytesRead){stream.node.timestamp=Date.now()}return bytesRead},write:function(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.put_char){throw new FS.ErrnoError(6)}try{for(var i=0;i<length;i++){stream.tty.ops.put_char(stream.tty,buffer[offset+i])}}catch(e){throw new FS.ErrnoError(5)}if(length){stream.node.timestamp=Date.now()}return i}},default_tty_ops:{get_char:function(tty){if(!tty.input.length){var result=null;if(ENVIRONMENT_IS_NODE){var BUFSIZE=256;var buf=new Buffer(BUFSIZE);var bytesRead=0;var isPosixPlatform=process.platform!="win32";var fd=process.stdin.fd;if(isPosixPlatform){var usingDevice=false;try{fd=fs.openSync("/dev/stdin","r");usingDevice=true}catch(e){}}try{bytesRead=fs.readSync(fd,buf,0,BUFSIZE,null)}catch(e){if(e.toString().indexOf("EOF")!=-1)bytesRead=0;else throw e}if(usingDevice){fs.closeSync(fd)}if(bytesRead>0){result=buf.slice(0,bytesRead).toString("utf-8")}else{result=null}}else if(typeof window!="undefined"&&typeof window.prompt=="function"){result=window.prompt("Input: ");if(result!==null){result+="\n"}}else if(typeof readline=="function"){result=readline();if(result!==null){result+="\n"}}if(!result){return null}tty.input=intArrayFromString(result,true)}return tty.input.shift()},put_char:function(tty,val){if(val===null||val===10){out(UTF8ArrayToString(tty.output,0));tty.output=[]}else{if(val!=0)tty.output.push(val)}},flush:function(tty){if(tty.output&&tty.output.length>0){out(UTF8ArrayToString(tty.output,0));tty.output=[]}}},default_tty1_ops:{put_char:function(tty,val){if(val===null||val===10){err(UTF8ArrayToString(tty.output,0));tty.output=[]}else{if(val!=0)tty.output.push(val)}},flush:function(tty){if(tty.output&&tty.output.length>0){err(UTF8ArrayToString(tty.output,0));tty.output=[]}}}};var MEMFS={ops_table:null,mount:function(mount){return MEMFS.createNode(null,"/",16384|511,0)},createNode:function(parent,name,mode,dev){if(FS.isBlkdev(mode)||FS.isFIFO(mode)){throw new FS.ErrnoError(1)}if(!MEMFS.ops_table){MEMFS.ops_table={dir:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,lookup:MEMFS.node_ops.lookup,mknod:MEMFS.node_ops.mknod,rename:MEMFS.node_ops.rename,unlink:MEMFS.node_ops.unlink,rmdir:MEMFS.node_ops.rmdir,readdir:MEMFS.node_ops.readdir,symlink:MEMFS.node_ops.symlink},stream:{llseek:MEMFS.stream_ops.llseek}},file:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:{llseek:MEMFS.stream_ops.llseek,read:MEMFS.stream_ops.read,write:MEMFS.stream_ops.write,allocate:MEMFS.stream_ops.allocate,mmap:MEMFS.stream_ops.mmap,msync:MEMFS.stream_ops.msync}},link:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,readlink:MEMFS.node_ops.readlink},stream:{}},chrdev:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:FS.chrdev_stream_ops}}}var node=FS.createNode(parent,name,mode,dev);if(FS.isDir(node.mode)){node.node_ops=MEMFS.ops_table.dir.node;node.stream_ops=MEMFS.ops_table.dir.stream;node.contents={}}else if(FS.isFile(node.mode)){node.node_ops=MEMFS.ops_table.file.node;node.stream_ops=MEMFS.ops_table.file.stream;node.usedBytes=0;node.contents=null}else if(FS.isLink(node.mode)){node.node_ops=MEMFS.ops_table.link.node;node.stream_ops=MEMFS.ops_table.link.stream}else if(FS.isChrdev(node.mode)){node.node_ops=MEMFS.ops_table.chrdev.node;node.stream_ops=MEMFS.ops_table.chrdev.stream}node.timestamp=Date.now();if(parent){parent.contents[name]=node}return node},getFileDataAsRegularArray:function(node){if(node.contents&&node.contents.subarray){var arr=[];for(var i=0;i<node.usedBytes;++i)arr.push(node.contents[i]);return arr}return node.contents},getFileDataAsTypedArray:function(node){if(!node.contents)return new Uint8Array;if(node.contents.subarray)return node.contents.subarray(0,node.usedBytes);return new Uint8Array(node.contents)},expandFileStorage:function(node,newCapacity){var prevCapacity=node.contents?node.contents.length:0;if(prevCapacity>=newCapacity)return;var CAPACITY_DOUBLING_MAX=1024*1024;newCapacity=Math.max(newCapacity,prevCapacity*(prevCapacity<CAPACITY_DOUBLING_MAX?2:1.125)|0);if(prevCapacity!=0)newCapacity=Math.max(newCapacity,256);var oldContents=node.contents;node.contents=new Uint8Array(newCapacity);if(node.usedBytes>0)node.contents.set(oldContents.subarray(0,node.usedBytes),0);return},resizeFileStorage:function(node,newSize){if(node.usedBytes==newSize)return;if(newSize==0){node.contents=null;node.usedBytes=0;return}if(!node.contents||node.contents.subarray){var oldContents=node.contents;node.contents=new Uint8Array(new ArrayBuffer(newSize));if(oldContents){node.contents.set(oldContents.subarray(0,Math.min(newSize,node.usedBytes)))}node.usedBytes=newSize;return}if(!node.contents)node.contents=[];if(node.contents.length>newSize)node.contents.length=newSize;else while(node.contents.length<newSize)node.contents.push(0);node.usedBytes=newSize},node_ops:{getattr:function(node){var attr={};attr.dev=FS.isChrdev(node.mode)?node.id:1;attr.ino=node.id;attr.mode=node.mode;attr.nlink=1;attr.uid=0;attr.gid=0;attr.rdev=node.rdev;if(FS.isDir(node.mode)){attr.size=4096}else if(FS.isFile(node.mode)){attr.size=node.usedBytes}else if(FS.isLink(node.mode)){attr.size=node.link.length}else{attr.size=0}attr.atime=new Date(node.timestamp);attr.mtime=new Date(node.timestamp);attr.ctime=new Date(node.timestamp);attr.blksize=4096;attr.blocks=Math.ceil(attr.size/attr.blksize);return attr},setattr:function(node,attr){if(attr.mode!==undefined){node.mode=attr.mode}if(attr.timestamp!==undefined){node.timestamp=attr.timestamp}if(attr.size!==undefined){MEMFS.resizeFileStorage(node,attr.size)}},lookup:function(parent,name){throw FS.genericErrors[2]},mknod:function(parent,name,mode,dev){return MEMFS.createNode(parent,name,mode,dev)},rename:function(old_node,new_dir,new_name){if(FS.isDir(old_node.mode)){var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(new_node){for(var i in new_node.contents){throw new FS.ErrnoError(39)}}}delete old_node.parent.contents[old_node.name];old_node.name=new_name;new_dir.contents[new_name]=old_node;old_node.parent=new_dir},unlink:function(parent,name){delete parent.contents[name]},rmdir:function(parent,name){var node=FS.lookupNode(parent,name);for(var i in node.contents){throw new FS.ErrnoError(39)}delete parent.contents[name]},readdir:function(node){var entries=[".",".."];for(var key in node.contents){if(!node.contents.hasOwnProperty(key)){continue}entries.push(key)}return entries},symlink:function(parent,newname,oldpath){var node=MEMFS.createNode(parent,newname,511|40960,0);node.link=oldpath;return node},readlink:function(node){if(!FS.isLink(node.mode)){throw new FS.ErrnoError(22)}return node.link}},stream_ops:{read:function(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=stream.node.usedBytes)return 0;var size=Math.min(stream.node.usedBytes-position,length);if(size>8&&contents.subarray){buffer.set(contents.subarray(position,position+size),offset)}else{for(var i=0;i<size;i++)buffer[offset+i]=contents[position+i]}return size},write:function(stream,buffer,offset,length,position,canOwn){canOwn=false;if(!length)return 0;var node=stream.node;node.timestamp=Date.now();if(buffer.subarray&&(!node.contents||node.contents.subarray)){if(canOwn){node.contents=buffer.subarray(offset,offset+length);node.usedBytes=length;return length}else if(node.usedBytes===0&&position===0){node.contents=new Uint8Array(buffer.subarray(offset,offset+length));node.usedBytes=length;return length}else if(position+length<=node.usedBytes){node.contents.set(buffer.subarray(offset,offset+length),position);return length}}MEMFS.expandFileStorage(node,position+length);if(node.contents.subarray&&buffer.subarray)node.contents.set(buffer.subarray(offset,offset+length),position);else{for(var i=0;i<length;i++){node.contents[position+i]=buffer[offset+i]}}node.usedBytes=Math.max(node.usedBytes,position+length);return length},llseek:function(stream,offset,whence){var position=offset;if(whence===1){position+=stream.position}else if(whence===2){if(FS.isFile(stream.node.mode)){position+=stream.node.usedBytes}}if(position<0){throw new FS.ErrnoError(22)}return position},allocate:function(stream,offset,length){MEMFS.expandFileStorage(stream.node,offset+length);stream.node.usedBytes=Math.max(stream.node.usedBytes,offset+length)},mmap:function(stream,buffer,offset,length,position,prot,flags){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(19)}var ptr;var allocated;var contents=stream.node.contents;if(!(flags&2)&&(contents.buffer===buffer||contents.buffer===buffer.buffer)){allocated=false;ptr=contents.byteOffset}else{if(position>0||position+length<stream.node.usedBytes){if(contents.subarray){contents=contents.subarray(position,position+length)}else{contents=Array.prototype.slice.call(contents,position,position+length)}}allocated=true;ptr=_malloc(length);if(!ptr){throw new FS.ErrnoError(12)}buffer.set(contents,ptr)}return{ptr:ptr,allocated:allocated}},msync:function(stream,buffer,offset,length,mmapFlags){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(19)}if(mmapFlags&2){return 0}var bytesWritten=MEMFS.stream_ops.write(stream,buffer,0,length,offset,false);return 0}}};var IDBFS={dbs:{},indexedDB:function(){if(typeof indexedDB!=="undefined")return indexedDB;var ret=null;if(typeof window==="object")ret=window.indexedDB||window.mozIndexedDB||window.webkitIndexedDB||window.msIndexedDB;assert(ret,"IDBFS used, but indexedDB not supported");return ret},DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",mount:function(mount){return MEMFS.mount.apply(null,arguments)},syncfs:function(mount,populate,callback){IDBFS.getLocalSet(mount,function(err,local){if(err)return callback(err);IDBFS.getRemoteSet(mount,function(err,remote){if(err)return callback(err);var src=populate?remote:local;var dst=populate?local:remote;IDBFS.reconcile(src,dst,callback)})})},getDB:function(name,callback){var db=IDBFS.dbs[name];if(db){return callback(null,db)}var req;try{req=IDBFS.indexedDB().open(name,IDBFS.DB_VERSION)}catch(e){return callback(e)}if(!req){return callback("Unable to connect to IndexedDB")}req.onupgradeneeded=function(e){var db=e.target.result;var transaction=e.target.transaction;var fileStore;if(db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)){fileStore=transaction.objectStore(IDBFS.DB_STORE_NAME)}else{fileStore=db.createObjectStore(IDBFS.DB_STORE_NAME)}if(!fileStore.indexNames.contains("timestamp")){fileStore.createIndex("timestamp","timestamp",{unique:false})}};req.onsuccess=function(){db=req.result;IDBFS.dbs[name]=db;callback(null,db)};req.onerror=function(e){callback(this.error);e.preventDefault()}},getLocalSet:function(mount,callback){var entries={};function isRealDir(p){return p!=="."&&p!==".."}function toAbsolute(root){return function(p){return PATH.join2(root,p)}}var check=FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));while(check.length){var path=check.pop();var stat;try{stat=FS.stat(path)}catch(e){return callback(e)}if(FS.isDir(stat.mode)){check.push.apply(check,FS.readdir(path).filter(isRealDir).map(toAbsolute(path)))}entries[path]={timestamp:stat.mtime}}return callback(null,{type:"local",entries:entries})},getRemoteSet:function(mount,callback){var entries={};IDBFS.getDB(mount.mountpoint,function(err,db){if(err)return callback(err);try{var transaction=db.transaction([IDBFS.DB_STORE_NAME],"readonly");transaction.onerror=function(e){callback(this.error);e.preventDefault()};var store=transaction.objectStore(IDBFS.DB_STORE_NAME);var index=store.index("timestamp");index.openKeyCursor().onsuccess=function(event){var cursor=event.target.result;if(!cursor){return callback(null,{type:"remote",db:db,entries:entries})}entries[cursor.primaryKey]={timestamp:cursor.key};cursor.continue()}}catch(e){return callback(e)}})},loadLocalEntry:function(path,callback){var stat,node;try{var lookup=FS.lookupPath(path);node=lookup.node;stat=FS.stat(path)}catch(e){return callback(e)}if(FS.isDir(stat.mode)){return callback(null,{timestamp:stat.mtime,mode:stat.mode})}else if(FS.isFile(stat.mode)){node.contents=MEMFS.getFileDataAsTypedArray(node);return callback(null,{timestamp:stat.mtime,mode:stat.mode,contents:node.contents})}else{return callback(new Error("node type not supported"))}},storeLocalEntry:function(path,entry,callback){try{if(FS.isDir(entry.mode)){FS.mkdir(path,entry.mode)}else if(FS.isFile(entry.mode)){FS.writeFile(path,entry.contents,{canOwn:true})}else{return callback(new Error("node type not supported"))}FS.chmod(path,entry.mode);FS.utime(path,entry.timestamp,entry.timestamp)}catch(e){return callback(e)}callback(null)},removeLocalEntry:function(path,callback){try{var lookup=FS.lookupPath(path);var stat=FS.stat(path);if(FS.isDir(stat.mode)){FS.rmdir(path)}else if(FS.isFile(stat.mode)){FS.unlink(path)}}catch(e){return callback(e)}callback(null)},loadRemoteEntry:function(store,path,callback){var req=store.get(path);req.onsuccess=function(event){callback(null,event.target.result)};req.onerror=function(e){callback(this.error);e.preventDefault()}},storeRemoteEntry:function(store,path,entry,callback){var req=store.put(entry,path);req.onsuccess=function(){callback(null)};req.onerror=function(e){callback(this.error);e.preventDefault()}},removeRemoteEntry:function(store,path,callback){var req=store.delete(path);req.onsuccess=function(){callback(null)};req.onerror=function(e){callback(this.error);e.preventDefault()}},reconcile:function(src,dst,callback){var total=0;var create=[];Object.keys(src.entries).forEach(function(key){var e=src.entries[key];var e2=dst.entries[key];if(!e2||e.timestamp>e2.timestamp){create.push(key);total++}});var remove=[];Object.keys(dst.entries).forEach(function(key){var e=dst.entries[key];var e2=src.entries[key];if(!e2){remove.push(key);total++}});if(!total){return callback(null)}var errored=false;var completed=0;var db=src.type==="remote"?src.db:dst.db;var transaction=db.transaction([IDBFS.DB_STORE_NAME],"readwrite");var store=transaction.objectStore(IDBFS.DB_STORE_NAME);function done(err){if(err){if(!done.errored){done.errored=true;return callback(err)}return}if(++completed>=total){return callback(null)}}transaction.onerror=function(e){done(this.error);e.preventDefault()};create.sort().forEach(function(path){if(dst.type==="local"){IDBFS.loadRemoteEntry(store,path,function(err,entry){if(err)return done(err);IDBFS.storeLocalEntry(path,entry,done)})}else{IDBFS.loadLocalEntry(path,function(err,entry){if(err)return done(err);IDBFS.storeRemoteEntry(store,path,entry,done)})}});remove.sort().reverse().forEach(function(path){if(dst.type==="local"){IDBFS.removeLocalEntry(path,done)}else{IDBFS.removeRemoteEntry(store,path,done)}})}};var NODEFS={isWindows:false,staticInit:function(){NODEFS.isWindows=!!process.platform.match(/^win/);var flags=process["binding"]("constants");if(flags["fs"]){flags=flags["fs"]}NODEFS.flagsForNodeMap={1024:flags["O_APPEND"],64:flags["O_CREAT"],128:flags["O_EXCL"],0:flags["O_RDONLY"],2:flags["O_RDWR"],4096:flags["O_SYNC"],512:flags["O_TRUNC"],1:flags["O_WRONLY"]}},bufferFrom:function(arrayBuffer){return Buffer.alloc?Buffer.from(arrayBuffer):new Buffer(arrayBuffer)},mount:function(mount){assert(ENVIRONMENT_IS_NODE);return NODEFS.createNode(null,"/",NODEFS.getMode(mount.opts.root),0)},createNode:function(parent,name,mode,dev){if(!FS.isDir(mode)&&!FS.isFile(mode)&&!FS.isLink(mode)){throw new FS.ErrnoError(22)}var node=FS.createNode(parent,name,mode);node.node_ops=NODEFS.node_ops;node.stream_ops=NODEFS.stream_ops;return node},getMode:function(path){var stat;try{stat=fs.lstatSync(path);if(NODEFS.isWindows){stat.mode=stat.mode|(stat.mode&292)>>2}}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(-e.errno)}return stat.mode},realPath:function(node){var parts=[];while(node.parent!==node){parts.push(node.name);node=node.parent}parts.push(node.mount.opts.root);parts.reverse();return PATH.join.apply(null,parts)},flagsForNode:function(flags){flags&=~2097152;flags&=~2048;flags&=~32768;flags&=~524288;var newFlags=0;for(var k in NODEFS.flagsForNodeMap){if(flags&k){newFlags|=NODEFS.flagsForNodeMap[k];flags^=k}}if(!flags){return newFlags}else{throw new FS.ErrnoError(22)}},node_ops:{getattr:function(node){var path=NODEFS.realPath(node);var stat;try{stat=fs.lstatSync(path)}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(-e.errno)}if(NODEFS.isWindows&&!stat.blksize){stat.blksize=4096}if(NODEFS.isWindows&&!stat.blocks){stat.blocks=(stat.size+stat.blksize-1)/stat.blksize|0}return{dev:stat.dev,ino:stat.ino,mode:stat.mode,nlink:stat.nlink,uid:stat.uid,gid:stat.gid,rdev:stat.rdev,size:stat.size,atime:stat.atime,mtime:stat.mtime,ctime:stat.ctime,blksize:stat.blksize,blocks:stat.blocks}},setattr:function(node,attr){var path=NODEFS.realPath(node);try{if(attr.mode!==undefined){fs.chmodSync(path,attr.mode);node.mode=attr.mode}if(attr.timestamp!==undefined){var date=new Date(attr.timestamp);fs.utimesSync(path,date,date)}if(attr.size!==undefined){fs.truncateSync(path,attr.size)}}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(-e.errno)}},lookup:function(parent,name){var path=PATH.join2(NODEFS.realPath(parent),name);var mode=NODEFS.getMode(path);return NODEFS.createNode(parent,name,mode)},mknod:function(parent,name,mode,dev){var node=NODEFS.createNode(parent,name,mode,dev);var path=NODEFS.realPath(node);try{if(FS.isDir(node.mode)){fs.mkdirSync(path,node.mode)}else{fs.writeFileSync(path,"",{mode:node.mode})}}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(-e.errno)}return node},rename:function(oldNode,newDir,newName){var oldPath=NODEFS.realPath(oldNode);var newPath=PATH.join2(NODEFS.realPath(newDir),newName);try{fs.renameSync(oldPath,newPath)}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(-e.errno)}},unlink:function(parent,name){var path=PATH.join2(NODEFS.realPath(parent),name);try{fs.unlinkSync(path)}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(-e.errno)}},rmdir:function(parent,name){var path=PATH.join2(NODEFS.realPath(parent),name);try{fs.rmdirSync(path)}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(-e.errno)}},readdir:function(node){var path=NODEFS.realPath(node);try{return fs.readdirSync(path)}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(-e.errno)}},symlink:function(parent,newName,oldPath){var newPath=PATH.join2(NODEFS.realPath(parent),newName);try{fs.symlinkSync(oldPath,newPath)}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(-e.errno)}},readlink:function(node){var path=NODEFS.realPath(node);try{path=fs.readlinkSync(path);path=NODEJS_PATH.relative(NODEJS_PATH.resolve(node.mount.opts.root),path);return path}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(-e.errno)}}},stream_ops:{open:function(stream){var path=NODEFS.realPath(stream.node);try{if(FS.isFile(stream.node.mode)){stream.nfd=fs.openSync(path,NODEFS.flagsForNode(stream.flags))}}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(-e.errno)}},close:function(stream){try{if(FS.isFile(stream.node.mode)&&stream.nfd){fs.closeSync(stream.nfd)}}catch(e){if(!e.code)throw e;throw new FS.ErrnoError(-e.errno)}},read:function(stream,buffer,offset,length,position){if(length===0)return 0;try{return fs.readSync(stream.nfd,NODEFS.bufferFrom(buffer.buffer),offset,length,position)}catch(e){throw new FS.ErrnoError(-e.errno)}},write:function(stream,buffer,offset,length,position){try{return fs.writeSync(stream.nfd,NODEFS.bufferFrom(buffer.buffer),offset,length,position)}catch(e){throw new FS.ErrnoError(-e.errno)}},llseek:function(stream,offset,whence){var position=offset;if(whence===1){position+=stream.position}else if(whence===2){if(FS.isFile(stream.node.mode)){try{var stat=fs.fstatSync(stream.nfd);position+=stat.size}catch(e){throw new FS.ErrnoError(-e.errno)}}}if(position<0){throw new FS.ErrnoError(22)}return position}}};var WORKERFS={DIR_MODE:16895,FILE_MODE:33279,reader:null,mount:function(mount){assert(ENVIRONMENT_IS_WORKER);if(!WORKERFS.reader)WORKERFS.reader=new FileReaderSync;var root=WORKERFS.createNode(null,"/",WORKERFS.DIR_MODE,0);var createdParents={};function ensureParent(path){var parts=path.split("/");var parent=root;for(var i=0;i<parts.length-1;i++){var curr=parts.slice(0,i+1).join("/");if(!createdParents[curr]){createdParents[curr]=WORKERFS.createNode(parent,parts[i],WORKERFS.DIR_MODE,0)}parent=createdParents[curr]}return parent}function base(path){var parts=path.split("/");return parts[parts.length-1]}Array.prototype.forEach.call(mount.opts["files"]||[],function(file){WORKERFS.createNode(ensureParent(file.name),base(file.name),WORKERFS.FILE_MODE,0,file,file.lastModifiedDate)});(mount.opts["blobs"]||[]).forEach(function(obj){WORKERFS.createNode(ensureParent(obj["name"]),base(obj["name"]),WORKERFS.FILE_MODE,0,obj["data"])});(mount.opts["packages"]||[]).forEach(function(pack){pack["metadata"].files.forEach(function(file){var name=file.filename.substr(1);WORKERFS.createNode(ensureParent(name),base(name),WORKERFS.FILE_MODE,0,pack["blob"].slice(file.start,file.end))})});return root},createNode:function(parent,name,mode,dev,contents,mtime){var node=FS.createNode(parent,name,mode);node.mode=mode;node.node_ops=WORKERFS.node_ops;node.stream_ops=WORKERFS.stream_ops;node.timestamp=(mtime||new Date).getTime();assert(WORKERFS.FILE_MODE!==WORKERFS.DIR_MODE);if(mode===WORKERFS.FILE_MODE){node.size=contents.size;node.contents=contents}else{node.size=4096;node.contents={}}if(parent){parent.contents[name]=node}return node},node_ops:{getattr:function(node){return{dev:1,ino:undefined,mode:node.mode,nlink:1,uid:0,gid:0,rdev:undefined,size:node.size,atime:new Date(node.timestamp),mtime:new Date(node.timestamp),ctime:new Date(node.timestamp),blksize:4096,blocks:Math.ceil(node.size/4096)}},setattr:function(node,attr){if(attr.mode!==undefined){node.mode=attr.mode}if(attr.timestamp!==undefined){node.timestamp=attr.timestamp}},lookup:function(parent,name){throw new FS.ErrnoError(2)},mknod:function(parent,name,mode,dev){throw new FS.ErrnoError(1)},rename:function(oldNode,newDir,newName){throw new FS.ErrnoError(1)},unlink:function(parent,name){throw new FS.ErrnoError(1)},rmdir:function(parent,name){throw new FS.ErrnoError(1)},readdir:function(node){var entries=[".",".."];for(var key in node.contents){if(!node.contents.hasOwnProperty(key)){continue}entries.push(key)}return entries},symlink:function(parent,newName,oldPath){throw new FS.ErrnoError(1)},readlink:function(node){throw new FS.ErrnoError(1)}},stream_ops:{read:function(stream,buffer,offset,length,position){if(position>=stream.node.size)return 0;var chunk=stream.node.contents.slice(position,position+length);var ab=WORKERFS.reader.readAsArrayBuffer(chunk);buffer.set(new Uint8Array(ab),offset);return chunk.size},write:function(stream,buffer,offset,length,position){throw new FS.ErrnoError(5)},llseek:function(stream,offset,whence){var position=offset;if(whence===1){position+=stream.position}else if(whence===2){if(FS.isFile(stream.node.mode)){position+=stream.node.size}}if(position<0){throw new FS.ErrnoError(22)}return position}}};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,trackingDelegate:{},tracking:{openFlags:{READ:1,WRITE:2}},ErrnoError:null,genericErrors:{},filesystems:null,syncFSRequests:0,handleFSError:function(e){if(!(e instanceof FS.ErrnoError))throw e+" : "+stackTrace();return ___setErrNo(e.errno)},lookupPath:function(path,opts){path=PATH.resolve(FS.cwd(),path);opts=opts||{};if(!path)return{path:"",node:null};var defaults={follow_mount:true,recurse_count:0};for(var key in defaults){if(opts[key]===undefined){opts[key]=defaults[key]}}if(opts.recurse_count>8){throw new FS.ErrnoError(40)}var parts=PATH.normalizeArray(path.split("/").filter(function(p){return!!p}),false);var current=FS.root;var current_path="/";for(var i=0;i<parts.length;i++){var islast=i===parts.length-1;if(islast&&opts.parent){break}current=FS.lookupNode(current,parts[i]);current_path=PATH.join2(current_path,parts[i]);if(FS.isMountpoint(current)){if(!islast||islast&&opts.follow_mount){current=current.mounted.root}}if(!islast||opts.follow){var count=0;while(FS.isLink(current.mode)){var link=FS.readlink(current_path);current_path=PATH.resolve(PATH.dirname(current_path),link);var lookup=FS.lookupPath(current_path,{recurse_count:opts.recurse_count});current=lookup.node;if(count++>40){throw new FS.ErrnoError(40)}}}}return{path:current_path,node:current}},getPath:function(node){var path;while(true){if(FS.isRoot(node)){var mount=node.mount.mountpoint;if(!path)return mount;return mount[mount.length-1]!=="/"?mount+"/"+path:mount+path}path=path?node.name+"/"+path:node.name;node=node.parent}},hashName:function(parentid,name){var hash=0;for(var i=0;i<name.length;i++){hash=(hash<<5)-hash+name.charCodeAt(i)|0}return(parentid+hash>>>0)%FS.nameTable.length},hashAddNode:function(node){var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node},hashRemoveNode:function(node){var hash=FS.hashName(node.parent.id,node.name);if(FS.nameTable[hash]===node){FS.nameTable[hash]=node.name_next}else{var current=FS.nameTable[hash];while(current){if(current.name_next===node){current.name_next=node.name_next;break}current=current.name_next}}},lookupNode:function(parent,name){var err=FS.mayLookup(parent);if(err){throw new FS.ErrnoError(err,parent)}var hash=FS.hashName(parent.id,name);for(var node=FS.nameTable[hash];node;node=node.name_next){var nodeName=node.name;if(node.parent.id===parent.id&&nodeName===name){return node}}return FS.lookup(parent,name)},createNode:function(parent,name,mode,rdev){if(!FS.FSNode){FS.FSNode=function(parent,name,mode,rdev){if(!parent){parent=this}this.parent=parent;this.mount=parent.mount;this.mounted=null;this.id=FS.nextInode++;this.name=name;this.mode=mode;this.node_ops={};this.stream_ops={};this.rdev=rdev};FS.FSNode.prototype={};var readMode=292|73;var writeMode=146;Object.defineProperties(FS.FSNode.prototype,{read:{get:function(){return(this.mode&readMode)===readMode},set:function(val){val?this.mode|=readMode:this.mode&=~readMode}},write:{get:function(){return(this.mode&writeMode)===writeMode},set:function(val){val?this.mode|=writeMode:this.mode&=~writeMode}},isFolder:{get:function(){return FS.isDir(this.mode)}},isDevice:{get:function(){return FS.isChrdev(this.mode)}}})}var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode:function(node){FS.hashRemoveNode(node)},isRoot:function(node){return node===node.parent},isMountpoint:function(node){return!!node.mounted},isFile:function(mode){return(mode&61440)===32768},isDir:function(mode){return(mode&61440)===16384},isLink:function(mode){return(mode&61440)===40960},isChrdev:function(mode){return(mode&61440)===8192},isBlkdev:function(mode){return(mode&61440)===24576},isFIFO:function(mode){return(mode&61440)===4096},isSocket:function(mode){return(mode&49152)===49152},flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function(str){var flags=FS.flagModes[str];if(typeof flags==="undefined"){throw new Error("Unknown file open mode: "+str)}return flags},flagsToPermissionString:function(flag){var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w"}return perms},nodePermissions:function(node,perms){if(FS.ignorePermissions){return 0}if(perms.indexOf("r")!==-1&&!(node.mode&292)){return 13}else if(perms.indexOf("w")!==-1&&!(node.mode&146)){return 13}else if(perms.indexOf("x")!==-1&&!(node.mode&73)){return 13}return 0},mayLookup:function(dir){var err=FS.nodePermissions(dir,"x");if(err)return err;if(!dir.node_ops.lookup)return 13;return 0},mayCreate:function(dir,name){try{var node=FS.lookupNode(dir,name);return 17}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete:function(dir,name,isdir){var node;try{node=FS.lookupNode(dir,name)}catch(e){return e.errno}var err=FS.nodePermissions(dir,"wx");if(err){return err}if(isdir){if(!FS.isDir(node.mode)){return 20}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 16}}else{if(FS.isDir(node.mode)){return 21}}return 0},mayOpen:function(node,flags){if(!node){return 2}if(FS.isLink(node.mode)){return 40}else if(FS.isDir(node.mode)){if(FS.flagsToPermissionString(flags)!=="r"||flags&512){return 21}}return FS.nodePermissions(node,FS.flagsToPermissionString(flags))},MAX_OPEN_FDS:4096,nextfd:function(fd_start,fd_end){fd_start=fd_start||0;fd_end=fd_end||FS.MAX_OPEN_FDS;for(var fd=fd_start;fd<=fd_end;fd++){if(!FS.streams[fd]){return fd}}throw new FS.ErrnoError(24)},getStream:function(fd){return FS.streams[fd]},createStream:function(stream,fd_start,fd_end){if(!FS.FSStream){FS.FSStream=function(){};FS.FSStream.prototype={};Object.defineProperties(FS.FSStream.prototype,{object:{get:function(){return this.node},set:function(val){this.node=val}},isRead:{get:function(){return(this.flags&2097155)!==1}},isWrite:{get:function(){return(this.flags&2097155)!==0}},isAppend:{get:function(){return this.flags&1024}}})}var newStream=new FS.FSStream;for(var p in stream){newStream[p]=stream[p]}stream=newStream;var fd=FS.nextfd(fd_start,fd_end);stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream:function(fd){FS.streams[fd]=null},chrdev_stream_ops:{open:function(stream){var device=FS.getDevice(stream.node.rdev);stream.stream_ops=device.stream_ops;if(stream.stream_ops.open){stream.stream_ops.open(stream)}},llseek:function(){throw new FS.ErrnoError(29)}},major:function(dev){return dev>>8},minor:function(dev){return dev&255},makedev:function(ma,mi){return ma<<8|mi},registerDevice:function(dev,ops){FS.devices[dev]={stream_ops:ops}},getDevice:function(dev){return FS.devices[dev]},getMounts:function(mount){var mounts=[];var check=[mount];while(check.length){var m=check.pop();mounts.push(m);check.push.apply(check,m.mounts)}return mounts},syncfs:function(populate,callback){if(typeof populate==="function"){callback=populate;populate=false}FS.syncFSRequests++;if(FS.syncFSRequests>1){console.log("warning: "+FS.syncFSRequests+" FS.syncfs operations in flight at once, probably just doing extra work")}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(err){FS.syncFSRequests--;return callback(err)}function done(err){if(err){if(!done.errored){done.errored=true;return doCallback(err)}return}if(++completed>=mounts.length){doCallback(null)}}mounts.forEach(function(mount){if(!mount.type.syncfs){return done(null)}mount.type.syncfs(mount,populate,done)})},mount:function(type,opts,mountpoint){var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(16)}else if(!root&&!pseudo){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});mountpoint=lookup.path;node=lookup.node;if(FS.isMountpoint(node)){throw new FS.ErrnoError(16)}if(!FS.isDir(node.mode)){throw new FS.ErrnoError(20)}}var mount={type:type,opts:opts,mountpoint:mountpoint,mounts:[]};var mountRoot=type.mount(mount);mountRoot.mount=mount;mount.root=mountRoot;if(root){FS.root=mountRoot}else if(node){node.mounted=mount;if(node.mount){node.mount.mounts.push(mount)}}return mountRoot},unmount:function(mountpoint){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});if(!FS.isMountpoint(lookup.node)){throw new FS.ErrnoError(22)}var node=lookup.node;var mount=node.mounted;var mounts=FS.getMounts(mount);Object.keys(FS.nameTable).forEach(function(hash){var current=FS.nameTable[hash];while(current){var next=current.name_next;if(mounts.indexOf(current.mount)!==-1){FS.destroyNode(current)}current=next}});node.mounted=null;var idx=node.mount.mounts.indexOf(mount);node.mount.mounts.splice(idx,1)},lookup:function(parent,name){return parent.node_ops.lookup(parent,name)},mknod:function(path,mode,dev){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name||name==="."||name===".."){throw new FS.ErrnoError(22)}var err=FS.mayCreate(parent,name);if(err){throw new FS.ErrnoError(err)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(1)}return parent.node_ops.mknod(parent,name,mode,dev)},create:function(path,mode){mode=mode!==undefined?mode:438;mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir:function(path,mode){mode=mode!==undefined?mode:511;mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree:function(path,mode){var dirs=path.split("/");var d="";for(var i=0;i<dirs.length;++i){if(!dirs[i])continue;d+="/"+dirs[i];try{FS.mkdir(d,mode)}catch(e){if(e.errno!=17)throw e}}},mkdev:function(path,mode,dev){if(typeof dev==="undefined"){dev=mode;mode=438}mode|=8192;return FS.mknod(path,mode,dev)},symlink:function(oldpath,newpath){if(!PATH.resolve(oldpath)){throw new FS.ErrnoError(2)}var lookup=FS.lookupPath(newpath,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(2)}var newname=PATH.basename(newpath);var err=FS.mayCreate(parent,newname);if(err){throw new FS.ErrnoError(err)}if(!parent.node_ops.symlink){throw new FS.ErrnoError(1)}return parent.node_ops.symlink(parent,newname,oldpath)},rename:function(old_path,new_path){var old_dirname=PATH.dirname(old_path);var new_dirname=PATH.dirname(new_path);var old_name=PATH.basename(old_path);var new_name=PATH.basename(new_path);var lookup,old_dir,new_dir;try{lookup=FS.lookupPath(old_path,{parent:true});old_dir=lookup.node;lookup=FS.lookupPath(new_path,{parent:true});new_dir=lookup.node}catch(e){throw new FS.ErrnoError(16)}if(!old_dir||!new_dir)throw new FS.ErrnoError(2);if(old_dir.mount!==new_dir.mount){throw new FS.ErrnoError(18)}var old_node=FS.lookupNode(old_dir,old_name);var relative=PATH.relative(old_path,new_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(22)}relative=PATH.relative(new_path,old_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(39)}var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(old_node===new_node){return}var isdir=FS.isDir(old_node.mode);var err=FS.mayDelete(old_dir,old_name,isdir);if(err){throw new FS.ErrnoError(err)}err=new_node?FS.mayDelete(new_dir,new_name,isdir):FS.mayCreate(new_dir,new_name);if(err){throw new FS.ErrnoError(err)}if(!old_dir.node_ops.rename){throw new FS.ErrnoError(1)}if(FS.isMountpoint(old_node)||new_node&&FS.isMountpoint(new_node)){throw new FS.ErrnoError(16)}if(new_dir!==old_dir){err=FS.nodePermissions(old_dir,"w");if(err){throw new FS.ErrnoError(err)}}try{if(FS.trackingDelegate["willMovePath"]){FS.trackingDelegate["willMovePath"](old_path,new_path)}}catch(e){console.log("FS.trackingDelegate['willMovePath']('"+old_path+"', '"+new_path+"') threw an exception: "+e.message)}FS.hashRemoveNode(old_node);try{old_dir.node_ops.rename(old_node,new_dir,new_name)}catch(e){throw e}finally{FS.hashAddNode(old_node)}try{if(FS.trackingDelegate["onMovePath"])FS.trackingDelegate["onMovePath"](old_path,new_path)}catch(e){console.log("FS.trackingDelegate['onMovePath']('"+old_path+"', '"+new_path+"') threw an exception: "+e.message)}},rmdir:function(path){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var err=FS.mayDelete(parent,name,true);if(err){throw new FS.ErrnoError(err)}if(!parent.node_ops.rmdir){throw new FS.ErrnoError(1)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(16)}try{if(FS.trackingDelegate["willDeletePath"]){FS.trackingDelegate["willDeletePath"](path)}}catch(e){console.log("FS.trackingDelegate['willDeletePath']('"+path+"') threw an exception: "+e.message)}parent.node_ops.rmdir(parent,name);FS.destroyNode(node);try{if(FS.trackingDelegate["onDeletePath"])FS.trackingDelegate["onDeletePath"](path)}catch(e){console.log("FS.trackingDelegate['onDeletePath']('"+path+"') threw an exception: "+e.message)}},readdir:function(path){var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;if(!node.node_ops.readdir){throw new FS.ErrnoError(20)}return node.node_ops.readdir(node)},unlink:function(path){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var err=FS.mayDelete(parent,name,false);if(err){throw new FS.ErrnoError(err)}if(!parent.node_ops.unlink){throw new FS.ErrnoError(1)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(16)}try{if(FS.trackingDelegate["willDeletePath"]){FS.trackingDelegate["willDeletePath"](path)}}catch(e){console.log("FS.trackingDelegate['willDeletePath']('"+path+"') threw an exception: "+e.message)}parent.node_ops.unlink(parent,name);FS.destroyNode(node);try{if(FS.trackingDelegate["onDeletePath"])FS.trackingDelegate["onDeletePath"](path)}catch(e){console.log("FS.trackingDelegate['onDeletePath']('"+path+"') threw an exception: "+e.message)}},readlink:function(path){var lookup=FS.lookupPath(path);var link=lookup.node;if(!link){throw new FS.ErrnoError(2)}if(!link.node_ops.readlink){throw new FS.ErrnoError(22)}return PATH.resolve(FS.getPath(link.parent),link.node_ops.readlink(link))},stat:function(path,dontFollow){var lookup=FS.lookupPath(path,{follow:!dontFollow});var node=lookup.node;if(!node){throw new FS.ErrnoError(2)}if(!node.node_ops.getattr){throw new FS.ErrnoError(1)}return node.node_ops.getattr(node)},lstat:function(path){return FS.stat(path,true)},chmod:function(path,mode,dontFollow){var node;if(typeof path==="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(1)}node.node_ops.setattr(node,{mode:mode&4095|node.mode&~4095,timestamp:Date.now()})},lchmod:function(path,mode){FS.chmod(path,mode,true)},fchmod:function(fd,mode){var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(9)}FS.chmod(stream.node,mode)},chown:function(path,uid,gid,dontFollow){var node;if(typeof path==="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(1)}node.node_ops.setattr(node,{timestamp:Date.now()})},lchown:function(path,uid,gid){FS.chown(path,uid,gid,true)},fchown:function(fd,uid,gid){var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(9)}FS.chown(stream.node,uid,gid)},truncate:function(path,len){if(len<0){throw new FS.ErrnoError(22)}var node;if(typeof path==="string"){var lookup=FS.lookupPath(path,{follow:true});node=lookup.node}else{node=path}if(!node.node_ops.setattr){throw new FS.ErrnoError(1)}if(FS.isDir(node.mode)){throw new FS.ErrnoError(21)}if(!FS.isFile(node.mode)){throw new FS.ErrnoError(22)}var err=FS.nodePermissions(node,"w");if(err){throw new FS.ErrnoError(err)}node.node_ops.setattr(node,{size:len,timestamp:Date.now()})},ftruncate:function(fd,len){var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(9)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(22)}FS.truncate(stream.node,len)},utime:function(path,atime,mtime){var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;node.node_ops.setattr(node,{timestamp:Math.max(atime,mtime)})},open:function(path,flags,mode,fd_start,fd_end){if(path===""){throw new FS.ErrnoError(2)}flags=typeof flags==="string"?FS.modeStringToFlags(flags):flags;mode=typeof mode==="undefined"?438:mode;if(flags&64){mode=mode&4095|32768}else{mode=0}var node;if(typeof path==="object"){node=path}else{path=PATH.normalize(path);try{var lookup=FS.lookupPath(path,{follow:!(flags&131072)});node=lookup.node}catch(e){}}var created=false;if(flags&64){if(node){if(flags&128){throw new FS.ErrnoError(17)}}else{node=FS.mknod(path,mode,0);created=true}}if(!node){throw new FS.ErrnoError(2)}if(FS.isChrdev(node.mode)){flags&=~512}if(flags&65536&&!FS.isDir(node.mode)){throw new FS.ErrnoError(20)}if(!created){var err=FS.mayOpen(node,flags);if(err){throw new FS.ErrnoError(err)}}if(flags&512){FS.truncate(node,0)}flags&=~(128|512);var stream=FS.createStream({node:node,path:FS.getPath(node),flags:flags,seekable:true,position:0,stream_ops:node.stream_ops,ungotten:[],error:false},fd_start,fd_end);if(stream.stream_ops.open){stream.stream_ops.open(stream)}if(Module["logReadFiles"]&&!(flags&1)){if(!FS.readFiles)FS.readFiles={};if(!(path in FS.readFiles)){FS.readFiles[path]=1;console.log("FS.trackingDelegate error on read file: "+path)}}try{if(FS.trackingDelegate["onOpenFile"]){var trackingFlags=0;if((flags&2097155)!==1){trackingFlags|=FS.tracking.openFlags.READ}if((flags&2097155)!==0){trackingFlags|=FS.tracking.openFlags.WRITE}FS.trackingDelegate["onOpenFile"](path,trackingFlags)}}catch(e){console.log("FS.trackingDelegate['onOpenFile']('"+path+"', flags) threw an exception: "+e.message)}return stream},close:function(stream){if(FS.isClosed(stream)){throw new FS.ErrnoError(9)}if(stream.getdents)stream.getdents=null;try{if(stream.stream_ops.close){stream.stream_ops.close(stream)}}catch(e){throw e}finally{FS.closeStream(stream.fd)}stream.fd=null},isClosed:function(stream){return stream.fd===null},llseek:function(stream,offset,whence){if(FS.isClosed(stream)){throw new FS.ErrnoError(9)}if(!stream.seekable||!stream.stream_ops.llseek){throw new FS.ErrnoError(29)}if(whence!=0&&whence!=1&&whence!=2){throw new FS.ErrnoError(22)}stream.position=stream.stream_ops.llseek(stream,offset,whence);stream.ungotten=[];return stream.position},read:function(stream,buffer,offset,length,position){if(length<0||position<0){throw new FS.ErrnoError(22)}if(FS.isClosed(stream)){throw new FS.ErrnoError(9)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(9)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(21)}if(!stream.stream_ops.read){throw new FS.ErrnoError(22)}var seeking=typeof position!=="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(29)}var bytesRead=stream.stream_ops.read(stream,buffer,offset,length,position);if(!seeking)stream.position+=bytesRead;return bytesRead},write:function(stream,buffer,offset,length,position,canOwn){if(length<0||position<0){throw new FS.ErrnoError(22)}if(FS.isClosed(stream)){throw new FS.ErrnoError(9)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(9)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(21)}if(!stream.stream_ops.write){throw new FS.ErrnoError(22)}if(stream.flags&1024){FS.llseek(stream,0,2)}var seeking=typeof position!=="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(29)}var bytesWritten=stream.stream_ops.write(stream,buffer,offset,length,position,canOwn);if(!seeking)stream.position+=bytesWritten;try{if(stream.path&&FS.trackingDelegate["onWriteToFile"])FS.trackingDelegate["onWriteToFile"](stream.path)}catch(e){console.log("FS.trackingDelegate['onWriteToFile']('"+stream.path+"') threw an exception: "+e.message)}return bytesWritten},allocate:function(stream,offset,length){if(FS.isClosed(stream)){throw new FS.ErrnoError(9)}if(offset<0||length<=0){throw new FS.ErrnoError(22)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(9)}if(!FS.isFile(stream.node.mode)&&!FS.isDir(stream.node.mode)){throw new FS.ErrnoError(19)}if(!stream.stream_ops.allocate){throw new FS.ErrnoError(95)}stream.stream_ops.allocate(stream,offset,length)},mmap:function(stream,buffer,offset,length,position,prot,flags){if((stream.flags&2097155)===1){throw new FS.ErrnoError(13)}if(!stream.stream_ops.mmap){throw new FS.ErrnoError(19)}return stream.stream_ops.mmap(stream,buffer,offset,length,position,prot,flags)},msync:function(stream,buffer,offset,length,mmapFlags){if(!stream||!stream.stream_ops.msync){return 0}return stream.stream_ops.msync(stream,buffer,offset,length,mmapFlags)},munmap:function(stream){return 0},ioctl:function(stream,cmd,arg){if(!stream.stream_ops.ioctl){throw new FS.ErrnoError(25)}return stream.stream_ops.ioctl(stream,cmd,arg)},readFile:function(path,opts){opts=opts||{};opts.flags=opts.flags||"r";opts.encoding=opts.encoding||"binary";if(opts.encoding!=="utf8"&&opts.encoding!=="binary"){throw new Error('Invalid encoding type "'+opts.encoding+'"')}var ret;var stream=FS.open(path,opts.flags);var stat=FS.stat(path);var length=stat.size;var buf=new Uint8Array(length);FS.read(stream,buf,0,length,0);if(opts.encoding==="utf8"){ret=UTF8ArrayToString(buf,0)}else if(opts.encoding==="binary"){ret=buf}FS.close(stream);return ret},writeFile:function(path,data,opts){opts=opts||{};opts.flags=opts.flags||"w";var stream=FS.open(path,opts.flags,opts.mode);if(typeof data==="string"){var buf=new Uint8Array(lengthBytesUTF8(data)+1);var actualNumBytes=stringToUTF8Array(data,buf,0,buf.length);FS.write(stream,buf,0,actualNumBytes,undefined,opts.canOwn)}else if(ArrayBuffer.isView(data)){FS.write(stream,data,0,data.byteLength,undefined,opts.canOwn)}else{throw new Error("Unsupported data type")}FS.close(stream)},cwd:function(){return FS.currentPath},chdir:function(path){var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(2)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(20)}var err=FS.nodePermissions(lookup.node,"x");if(err){throw new FS.ErrnoError(err)}FS.currentPath=lookup.path},createDefaultDirectories:function(){FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user")},createDefaultDevices:function(){FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:function(){return 0},write:function(stream,buffer,offset,length,pos){return length}});FS.mkdev("/dev/null",FS.makedev(1,3));TTY.register(FS.makedev(5,0),TTY.default_tty_ops);TTY.register(FS.makedev(6,0),TTY.default_tty1_ops);FS.mkdev("/dev/tty",FS.makedev(5,0));FS.mkdev("/dev/tty1",FS.makedev(6,0));var random_device;if(typeof crypto==="object"&&typeof crypto["getRandomValues"]==="function"){var randomBuffer=new Uint8Array(1);random_device=function(){crypto.getRandomValues(randomBuffer);return randomBuffer[0]}}else if(ENVIRONMENT_IS_NODE){try{var crypto_module=require("crypto");random_device=function(){return crypto_module["randomBytes"](1)[0]}}catch(e){}}else{}if(!random_device){random_device=function(){abort("random_device")}}FS.createDevice("/dev","random",random_device);FS.createDevice("/dev","urandom",random_device);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp")},createSpecialDirectories:function(){FS.mkdir("/proc");FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount:function(){var node=FS.createNode("/proc/self","fd",16384|511,73);node.node_ops={lookup:function(parent,name){var fd=+name;var stream=FS.getStream(fd);if(!stream)throw new FS.ErrnoError(9);var ret={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:function(){return stream.path}}};ret.parent=ret;return ret}};return node}},{},"/proc/self/fd")},createStandardStreams:function(){if(Module["stdin"]){FS.createDevice("/dev","stdin",Module["stdin"])}else{FS.symlink("/dev/tty","/dev/stdin")}if(Module["stdout"]){FS.createDevice("/dev","stdout",null,Module["stdout"])}else{FS.symlink("/dev/tty","/dev/stdout")}if(Module["stderr"]){FS.createDevice("/dev","stderr",null,Module["stderr"])}else{FS.symlink("/dev/tty1","/dev/stderr")}var stdin=FS.open("/dev/stdin","r");var stdout=FS.open("/dev/stdout","w");var stderr=FS.open("/dev/stderr","w")},ensureErrnoError:function(){if(FS.ErrnoError)return;FS.ErrnoError=function ErrnoError(errno,node){this.node=node;this.setErrno=function(errno){this.errno=errno};this.setErrno(errno);this.message="FS error";if(this.stack)Object.defineProperty(this,"stack",{value:(new Error).stack,writable:true})};FS.ErrnoError.prototype=new Error;FS.ErrnoError.prototype.constructor=FS.ErrnoError;[2].forEach(function(code){FS.genericErrors[code]=new FS.ErrnoError(code);FS.genericErrors[code].stack="<generic error, no stack>"})},staticInit:function(){FS.ensureErrnoError();FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={"MEMFS":MEMFS,"IDBFS":IDBFS,"NODEFS":NODEFS,"WORKERFS":WORKERFS}},init:function(input,output,error){FS.init.initialized=true;FS.ensureErrnoError();Module["stdin"]=input||Module["stdin"];Module["stdout"]=output||Module["stdout"];Module["stderr"]=error||Module["stderr"];FS.createStandardStreams()},quit:function(){FS.init.initialized=false;var fflush=Module["_fflush"];if(fflush)fflush(0);for(var i=0;i<FS.streams.length;i++){var stream=FS.streams[i];if(!stream){continue}FS.close(stream)}},getMode:function(canRead,canWrite){var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode},joinPath:function(parts,forceRelative){var path=PATH.join.apply(null,parts);if(forceRelative&&path[0]=="/")path=path.substr(1);return path},absolutePath:function(relative,base){return PATH.resolve(base,relative)},standardizePath:function(path){return PATH.normalize(path)},findObject:function(path,dontResolveLastLink){var ret=FS.analyzePath(path,dontResolveLastLink);if(ret.exists){return ret.object}else{___setErrNo(ret.error);return null}},analyzePath:function(path,dontResolveLastLink){try{var lookup=FS.lookupPath(path,{follow:!dontResolveLastLink});path=lookup.path}catch(e){}var ret={isRoot:false,exists:false,error:0,name:null,path:null,object:null,parentExists:false,parentPath:null,parentObject:null};try{var lookup=FS.lookupPath(path,{parent:true});ret.parentExists=true;ret.parentPath=lookup.path;ret.parentObject=lookup.node;ret.name=PATH.basename(path);lookup=FS.lookupPath(path,{follow:!dontResolveLastLink});ret.exists=true;ret.path=lookup.path;ret.object=lookup.node;ret.name=lookup.node.name;ret.isRoot=lookup.path==="/"}catch(e){ret.error=e.errno}return ret},createFolder:function(parent,name,canRead,canWrite){var path=PATH.join2(typeof parent==="string"?parent:FS.getPath(parent),name);var mode=FS.getMode(canRead,canWrite);return FS.mkdir(path,mode)},createPath:function(parent,path,canRead,canWrite){parent=typeof parent==="string"?parent:FS.getPath(parent);var parts=path.split("/").reverse();while(parts.length){var part=parts.pop();if(!part)continue;var current=PATH.join2(parent,part);try{FS.mkdir(current)}catch(e){}parent=current}return current},createFile:function(parent,name,properties,canRead,canWrite){var path=PATH.join2(typeof parent==="string"?parent:FS.getPath(parent),name);var mode=FS.getMode(canRead,canWrite);return FS.create(path,mode)},createDataFile:function(parent,name,data,canRead,canWrite,canOwn){var path=name?PATH.join2(typeof parent==="string"?parent:FS.getPath(parent),name):parent;var mode=FS.getMode(canRead,canWrite);var node=FS.create(path,mode);if(data){if(typeof data==="string"){var arr=new Array(data.length);for(var i=0,len=data.length;i<len;++i)arr[i]=data.charCodeAt(i);data=arr}FS.chmod(node,mode|146);var stream=FS.open(node,"w");FS.write(stream,data,0,data.length,0,canOwn);FS.close(stream);FS.chmod(node,mode)}return node},createDevice:function(parent,name,input,output){var path=PATH.join2(typeof parent==="string"?parent:FS.getPath(parent),name);var mode=FS.getMode(!!input,!!output);if(!FS.createDevice.major)FS.createDevice.major=64;var dev=FS.makedev(FS.createDevice.major++,0);FS.registerDevice(dev,{open:function(stream){stream.seekable=false},close:function(stream){if(output&&output.buffer&&output.buffer.length){output(10)}},read:function(stream,buffer,offset,length,pos){var bytesRead=0;for(var i=0;i<length;i++){var result;try{result=input()}catch(e){throw new FS.ErrnoError(5)}if(result===undefined&&bytesRead===0){throw new FS.ErrnoError(11)}if(result===null||result===undefined)break;bytesRead++;buffer[offset+i]=result}if(bytesRead){stream.node.timestamp=Date.now()}return bytesRead},write:function(stream,buffer,offset,length,pos){for(var i=0;i<length;i++){try{output(buffer[offset+i])}catch(e){throw new FS.ErrnoError(5)}}if(length){stream.node.timestamp=Date.now()}return i}});return FS.mkdev(path,mode,dev)},createLink:function(parent,name,target,canRead,canWrite){var path=PATH.join2(typeof parent==="string"?parent:FS.getPath(parent),name);return FS.symlink(target,path)},forceLoadFile:function(obj){if(obj.isDevice||obj.isFolder||obj.link||obj.contents)return true;var success=true;if(typeof XMLHttpRequest!=="undefined"){throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.")}else if(Module["read"]){try{obj.contents=intArrayFromString(Module["read"](obj.url),true);obj.usedBytes=obj.contents.length}catch(e){success=false}}else{throw new Error("Cannot load without read() or XMLHttpRequest.")}if(!success)___setErrNo(5);return success},createLazyFile:function(parent,name,url,canRead,canWrite){function LazyUint8Array(){this.lengthKnown=false;this.chunks=[]}LazyUint8Array.prototype.get=function LazyUint8Array_get(idx){if(idx>this.length-1||idx<0){return undefined}var chunkOffset=idx%this.chunkSize;var chunkNum=idx/this.chunkSize|0;return this.getter(chunkNum)[chunkOffset]};LazyUint8Array.prototype.setDataGetter=function LazyUint8Array_setDataGetter(getter){this.getter=getter};LazyUint8Array.prototype.cacheLength=function LazyUint8Array_cacheLength(){var xhr=new XMLHttpRequest;xhr.open("HEAD",url,false);xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))throw new Error("Couldn't load "+url+". Status: "+xhr.status);var datalength=Number(xhr.getResponseHeader("Content-length"));var header;var hasByteServing=(header=xhr.getResponseHeader("Accept-Ranges"))&&header==="bytes";var usesGzip=(header=xhr.getResponseHeader("Content-Encoding"))&&header==="gzip";var chunkSize=1024*1024;if(!hasByteServing)chunkSize=datalength;var doXHR=function(from,to){if(from>to)throw new Error("invalid range ("+from+", "+to+") or no bytes requested!");if(to>datalength-1)throw new Error("only "+datalength+" bytes available! programmer error!");var xhr=new XMLHttpRequest;xhr.open("GET",url,false);if(datalength!==chunkSize)xhr.setRequestHeader("Range","bytes="+from+"-"+to);if(typeof Uint8Array!="undefined")xhr.responseType="arraybuffer";if(xhr.overrideMimeType){xhr.overrideMimeType("text/plain; charset=x-user-defined")}xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))throw new Error("Couldn't load "+url+". Status: "+xhr.status);if(xhr.response!==undefined){return new Uint8Array(xhr.response||[])}else{return intArrayFromString(xhr.responseText||"",true)}};var lazyArray=this;lazyArray.setDataGetter(function(chunkNum){var start=chunkNum*chunkSize;var end=(chunkNum+1)*chunkSize-1;end=Math.min(end,datalength-1);if(typeof lazyArray.chunks[chunkNum]==="undefined"){lazyArray.chunks[chunkNum]=doXHR(start,end)}if(typeof lazyArray.chunks[chunkNum]==="undefined")throw new Error("doXHR failed!");return lazyArray.chunks[chunkNum]});if(usesGzip||!datalength){chunkSize=datalength=1;datalength=this.getter(0).length;chunkSize=datalength;console.log("LazyFiles on gzip forces download of the whole file when length is accessed")}this._length=datalength;this._chunkSize=chunkSize;this.lengthKnown=true};if(typeof XMLHttpRequest!=="undefined"){if(!ENVIRONMENT_IS_WORKER)throw"Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";var lazyArray=new LazyUint8Array;Object.defineProperties(lazyArray,{length:{get:function(){if(!this.lengthKnown){this.cacheLength()}return this._length}},chunkSize:{get:function(){if(!this.lengthKnown){this.cacheLength()}return this._chunkSize}}});var properties={isDevice:false,contents:lazyArray}}else{var properties={isDevice:false,url:url}}var node=FS.createFile(parent,name,properties,canRead,canWrite);if(properties.contents){node.contents=properties.contents}else if(properties.url){node.contents=null;node.url=properties.url}Object.defineProperties(node,{usedBytes:{get:function(){return this.contents.length}}});var stream_ops={};var keys=Object.keys(node.stream_ops);keys.forEach(function(key){var fn=node.stream_ops[key];stream_ops[key]=function forceLoadLazyFile(){if(!FS.forceLoadFile(node)){throw new FS.ErrnoError(5)}return fn.apply(null,arguments)}});stream_ops.read=function stream_ops_read(stream,buffer,offset,length,position){if(!FS.forceLoadFile(node)){throw new FS.ErrnoError(5)}var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);if(contents.slice){for(var i=0;i<size;i++){buffer[offset+i]=contents[position+i]}}else{for(var i=0;i<size;i++){buffer[offset+i]=contents.get(position+i)}}return size};node.stream_ops=stream_ops;return node},createPreloadedFile:function(parent,name,url,canRead,canWrite,onload,onerror,dontCreateFile,canOwn,preFinish){Browser.init();var fullname=name?PATH.resolve(PATH.join2(parent,name)):parent;var dep=getUniqueRunDependency("cp "+fullname);function processData(byteArray){function finish(byteArray){if(preFinish)preFinish();if(!dontCreateFile){FS.createDataFile(parent,name,byteArray,canRead,canWrite,canOwn)}if(onload)onload();removeRunDependency(dep)}var handled=false;Module["preloadPlugins"].forEach(function(plugin){if(handled)return;if(plugin["canHandle"](fullname)){plugin["handle"](byteArray,fullname,finish,function(){if(onerror)onerror();removeRunDependency(dep)});handled=true}});if(!handled)finish(byteArray)}addRunDependency(dep);if(typeof url=="string"){Browser.asyncLoad(url,function(byteArray){processData(byteArray)},onerror)}else{processData(url)}},indexedDB:function(){return window.indexedDB||window.mozIndexedDB||window.webkitIndexedDB||window.msIndexedDB},DB_NAME:function(){return"EM_FS_"+window.location.pathname},DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function(paths,onload,onerror){onload=onload||function(){};onerror=onerror||function(){};var indexedDB=FS.indexedDB();try{var openRequest=indexedDB.open(FS.DB_NAME(),FS.DB_VERSION)}catch(e){return onerror(e)}openRequest.onupgradeneeded=function openRequest_onupgradeneeded(){console.log("creating db");var db=openRequest.result;db.createObjectStore(FS.DB_STORE_NAME)};openRequest.onsuccess=function openRequest_onsuccess(){var db=openRequest.result;var transaction=db.transaction([FS.DB_STORE_NAME],"readwrite");var files=transaction.objectStore(FS.DB_STORE_NAME);var ok=0,fail=0,total=paths.length;function finish(){if(fail==0)onload();else onerror()}paths.forEach(function(path){var putRequest=files.put(FS.analyzePath(path).object.contents,path);putRequest.onsuccess=function putRequest_onsuccess(){ok++;if(ok+fail==total)finish()};putRequest.onerror=function putRequest_onerror(){fail++;if(ok+fail==total)finish()}});transaction.onerror=onerror};openRequest.onerror=onerror},loadFilesFromDB:function(paths,onload,onerror){onload=onload||function(){};onerror=onerror||function(){};var indexedDB=FS.indexedDB();try{var openRequest=indexedDB.open(FS.DB_NAME(),FS.DB_VERSION)}catch(e){return onerror(e)}openRequest.onupgradeneeded=onerror;openRequest.onsuccess=function openRequest_onsuccess(){var db=openRequest.result;try{var transaction=db.transaction([FS.DB_STORE_NAME],"readonly")}catch(e){onerror(e);return}var files=transaction.objectStore(FS.DB_STORE_NAME);var ok=0,fail=0,total=paths.length;function finish(){if(fail==0)onload();else onerror()}paths.forEach(function(path){var getRequest=files.get(path);getRequest.onsuccess=function getRequest_onsuccess(){if(FS.analyzePath(path).exists){FS.unlink(path)}FS.createDataFile(PATH.dirname(path),PATH.basename(path),getRequest.result,true,true,true);ok++;if(ok+fail==total)finish()};getRequest.onerror=function getRequest_onerror(){fail++;if(ok+fail==total)finish()}});transaction.onerror=onerror};openRequest.onerror=onerror}};var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};var SYSCALLS={DEFAULT_POLLMASK:5,mappings:{},umask:511,calculateAt:function(dirfd,path){if(path[0]!=="/"){var dir;if(dirfd===-100){dir=FS.cwd()}else{var dirstream=FS.getStream(dirfd);if(!dirstream)throw new FS.ErrnoError(ERRNO_CODES.EBADF);dir=dirstream.path}path=PATH.join2(dir,path)}return path},doStat:function(func,path,buf){try{var stat=func(path)}catch(e){if(e&&e.node&&PATH.normalize(path)!==PATH.normalize(FS.getPath(e.node))){return-ERRNO_CODES.ENOTDIR}throw e}HEAP32[buf>>2]=stat.dev;HEAP32[buf+4>>2]=0;HEAP32[buf+8>>2]=stat.ino;HEAP32[buf+12>>2]=stat.mode;HEAP32[buf+16>>2]=stat.nlink;HEAP32[buf+20>>2]=stat.uid;HEAP32[buf+24>>2]=stat.gid;HEAP32[buf+28>>2]=stat.rdev;HEAP32[buf+32>>2]=0;tempI64=[stat.size>>>0,(tempDouble=stat.size,+Math_abs(tempDouble)>=1?tempDouble>0?(Math_min(+Math_floor(tempDouble/4294967296),4294967295)|0)>>>0:~~+Math_ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+40>>2]=tempI64[0],HEAP32[buf+44>>2]=tempI64[1];HEAP32[buf+48>>2]=4096;HEAP32[buf+52>>2]=stat.blocks;HEAP32[buf+56>>2]=stat.atime.getTime()/1e3|0;HEAP32[buf+60>>2]=0;HEAP32[buf+64>>2]=stat.mtime.getTime()/1e3|0;HEAP32[buf+68>>2]=0;HEAP32[buf+72>>2]=stat.ctime.getTime()/1e3|0;HEAP32[buf+76>>2]=0;tempI64=[stat.ino>>>0,(tempDouble=stat.ino,+Math_abs(tempDouble)>=1?tempDouble>0?(Math_min(+Math_floor(tempDouble/4294967296),4294967295)|0)>>>0:~~+Math_ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+80>>2]=tempI64[0],HEAP32[buf+84>>2]=tempI64[1];return 0},doMsync:function(addr,stream,len,flags){var buffer=new Uint8Array(HEAPU8.subarray(addr,addr+len));FS.msync(stream,buffer,0,len,flags)},doMkdir:function(path,mode){path=PATH.normalize(path);if(path[path.length-1]==="/")path=path.substr(0,path.length-1);FS.mkdir(path,mode,0);return 0},doMknod:function(path,mode,dev){switch(mode&61440){case 32768:case 8192:case 24576:case 4096:case 49152:break;default:return-ERRNO_CODES.EINVAL}FS.mknod(path,mode,dev);return 0},doReadlink:function(path,buf,bufsize){if(bufsize<=0)return-ERRNO_CODES.EINVAL;var ret=FS.readlink(path);var len=Math.min(bufsize,lengthBytesUTF8(ret));var endChar=HEAP8[buf+len];stringToUTF8(ret,buf,bufsize+1);HEAP8[buf+len]=endChar;return len},doAccess:function(path,amode){if(amode&~7){return-ERRNO_CODES.EINVAL}var node;var lookup=FS.lookupPath(path,{follow:true});node=lookup.node;var perms="";if(amode&4)perms+="r";if(amode&2)perms+="w";if(amode&1)perms+="x";if(perms&&FS.nodePermissions(node,perms)){return-ERRNO_CODES.EACCES}return 0},doDup:function(path,flags,suggestFD){var suggest=FS.getStream(suggestFD);if(suggest)FS.close(suggest);return FS.open(path,flags,0,suggestFD,suggestFD).fd},doReadv:function(stream,iov,iovcnt,offset){var ret=0;for(var i=0;i<iovcnt;i++){var ptr=HEAP32[iov+i*8>>2];var len=HEAP32[iov+(i*8+4)>>2];var curr=FS.read(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr<len)break}return ret},doWritev:function(stream,iov,iovcnt,offset){var ret=0;for(var i=0;i<iovcnt;i++){var ptr=HEAP32[iov+i*8>>2];var len=HEAP32[iov+(i*8+4)>>2];var curr=FS.write(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr}return ret},varargs:0,get:function(varargs){SYSCALLS.varargs+=4;var ret=HEAP32[SYSCALLS.varargs-4>>2];return ret},getStr:function(){var ret=UTF8ToString(SYSCALLS.get());return ret},getStreamFromFD:function(){var stream=FS.getStream(SYSCALLS.get());if(!stream)throw new FS.ErrnoError(ERRNO_CODES.EBADF);return stream},getSocketFromFD:function(){var socket=SOCKFS.getSocket(SYSCALLS.get());if(!socket)throw new FS.ErrnoError(ERRNO_CODES.EBADF);return socket},getSocketAddress:function(allowNull){var addrp=SYSCALLS.get(),addrlen=SYSCALLS.get();if(allowNull&&addrp===0)return null;var info=__read_sockaddr(addrp,addrlen);if(info.errno)throw new FS.ErrnoError(info.errno);info.addr=DNS.lookup_addr(info.addr)||info.addr;return info},get64:function(){var low=SYSCALLS.get(),high=SYSCALLS.get();return low},getZero:function(){SYSCALLS.get()}};function ___syscall140(which,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(),offset_high=SYSCALLS.get(),offset_low=SYSCALLS.get(),result=SYSCALLS.get(),whence=SYSCALLS.get();if(!(offset_high==-1&&offset_low<0)&&!(offset_high==0&&offset_low>=0)){return-ERRNO_CODES.EOVERFLOW}var offset=offset_low;FS.llseek(stream,offset,whence);tempI64=[stream.position>>>0,(tempDouble=stream.position,+Math_abs(tempDouble)>=1?tempDouble>0?(Math_min(+Math_floor(tempDouble/4294967296),4294967295)|0)>>>0:~~+Math_ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[result>>2]=tempI64[0],HEAP32[result+4>>2]=tempI64[1];if(stream.getdents&&offset===0&&whence===0)stream.getdents=null;return 0}catch(e){if(typeof FS==="undefined"||!(e instanceof FS.ErrnoError))abort(e);return-e.errno}}function ___syscall145(which,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(),iov=SYSCALLS.get(),iovcnt=SYSCALLS.get();return SYSCALLS.doReadv(stream,iov,iovcnt)}catch(e){if(typeof FS==="undefined"||!(e instanceof FS.ErrnoError))abort(e);return-e.errno}}function ___syscall146(which,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(),iov=SYSCALLS.get(),iovcnt=SYSCALLS.get();return SYSCALLS.doWritev(stream,iov,iovcnt)}catch(e){if(typeof FS==="undefined"||!(e instanceof FS.ErrnoError))abort(e);return-e.errno}}function ___syscall54(which,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(),op=SYSCALLS.get();switch(op){case 21509:case 21505:{if(!stream.tty)return-ERRNO_CODES.ENOTTY;return 0}case 21510:case 21511:case 21512:case 21506:case 21507:case 21508:{if(!stream.tty)return-ERRNO_CODES.ENOTTY;return 0}case 21519:{if(!stream.tty)return-ERRNO_CODES.ENOTTY;var argp=SYSCALLS.get();HEAP32[argp>>2]=0;return 0}case 21520:{if(!stream.tty)return-ERRNO_CODES.ENOTTY;return-ERRNO_CODES.EINVAL}case 21531:{var argp=SYSCALLS.get();return FS.ioctl(stream,op,argp)}case 21523:{if(!stream.tty)return-ERRNO_CODES.ENOTTY;return 0}case 21524:{if(!stream.tty)return-ERRNO_CODES.ENOTTY;return 0}default:abort("bad ioctl syscall "+op)}}catch(e){if(typeof FS==="undefined"||!(e instanceof FS.ErrnoError))abort(e);return-e.errno}}function ___syscall6(which,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD();FS.close(stream);return 0}catch(e){if(typeof FS==="undefined"||!(e instanceof FS.ErrnoError))abort(e);return-e.errno}}function ___syscall91(which,varargs){SYSCALLS.varargs=varargs;try{var addr=SYSCALLS.get(),len=SYSCALLS.get();var info=SYSCALLS.mappings[addr];if(!info)return 0;if(len===info.len){var stream=FS.getStream(info.fd);SYSCALLS.doMsync(addr,stream,len,info.flags);FS.munmap(stream);SYSCALLS.mappings[addr]=null;if(info.allocated){_free(info.malloc)}}return 0}catch(e){if(typeof FS==="undefined"||!(e instanceof FS.ErrnoError))abort(e);return-e.errno}}function ___unlock(){}function getShiftFromSize(size){switch(size){case 1:return 0;case 2:return 1;case 4:return 2;case 8:return 3;default:throw new TypeError("Unknown type size: "+size)}}function embind_init_charCodes(){var codes=new Array(256);for(var i=0;i<256;++i){codes[i]=String.fromCharCode(i)}embind_charCodes=codes}var embind_charCodes=undefined;function readLatin1String(ptr){var ret="";var c=ptr;while(HEAPU8[c]){ret+=embind_charCodes[HEAPU8[c++]]}return ret}var awaitingDependencies={};var registeredTypes={};var typeDependencies={};var char_0=48;var char_9=57;function makeLegalFunctionName(name){if(undefined===name){return"_unknown"}name=name.replace(/[^a-zA-Z0-9_]/g,"$");var f=name.charCodeAt(0);if(f>=char_0&&f<=char_9){return"_"+name}else{return name}}function createNamedFunction(name,body){name=makeLegalFunctionName(name);return new Function("body","return function "+name+"() {\n"+'    "use strict";'+"    return body.apply(this, arguments);\n"+"};\n")(body)}function extendError(baseErrorType,errorName){var errorClass=createNamedFunction(errorName,function(message){this.name=errorName;this.message=message;var stack=new Error(message).stack;if(stack!==undefined){this.stack=this.toString()+"\n"+stack.replace(/^Error(:[^\n]*)?\n/,"")}});errorClass.prototype=Object.create(baseErrorType.prototype);errorClass.prototype.constructor=errorClass;errorClass.prototype.toString=function(){if(this.message===undefined){return this.name}else{return this.name+": "+this.message}};return errorClass}var BindingError=undefined;function throwBindingError(message){throw new BindingError(message)}var InternalError=undefined;function throwInternalError(message){throw new InternalError(message)}function whenDependentTypesAreResolved(myTypes,dependentTypes,getTypeConverters){myTypes.forEach(function(type){typeDependencies[type]=dependentTypes});function onComplete(typeConverters){var myTypeConverters=getTypeConverters(typeConverters);if(myTypeConverters.length!==myTypes.length){throwInternalError("Mismatched type converter count")}for(var i=0;i<myTypes.length;++i){registerType(myTypes[i],myTypeConverters[i])}}var typeConverters=new Array(dependentTypes.length);var unregisteredTypes=[];var registered=0;dependentTypes.forEach(function(dt,i){if(registeredTypes.hasOwnProperty(dt)){typeConverters[i]=registeredTypes[dt]}else{unregisteredTypes.push(dt);if(!awaitingDependencies.hasOwnProperty(dt)){awaitingDependencies[dt]=[]}awaitingDependencies[dt].push(function(){typeConverters[i]=registeredTypes[dt];++registered;if(registered===unregisteredTypes.length){onComplete(typeConverters)}})}});if(0===unregisteredTypes.length){onComplete(typeConverters)}}function registerType(rawType,registeredInstance,options){options=options||{};if(!("argPackAdvance"in registeredInstance)){throw new TypeError("registerType registeredInstance requires argPackAdvance")}var name=registeredInstance.name;if(!rawType){throwBindingError('type "'+name+'" must have a positive integer typeid pointer')}if(registeredTypes.hasOwnProperty(rawType)){if(options.ignoreDuplicateRegistrations){return}else{throwBindingError("Cannot register type '"+name+"' twice")}}registeredTypes[rawType]=registeredInstance;delete typeDependencies[rawType];if(awaitingDependencies.hasOwnProperty(rawType)){var callbacks=awaitingDependencies[rawType];delete awaitingDependencies[rawType];callbacks.forEach(function(cb){cb()})}}function __embind_register_bool(rawType,name,size,trueValue,falseValue){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(wt){return!!wt},"toWireType":function(destructors,o){return o?trueValue:falseValue},"argPackAdvance":8,"readValueFromPointer":function(pointer){var heap;if(size===1){heap=HEAP8}else if(size===2){heap=HEAP16}else if(size===4){heap=HEAP32}else{throw new TypeError("Unknown boolean type size: "+name)}return this["fromWireType"](heap[pointer>>shift])},destructorFunction:null})}function ClassHandle_isAliasOf(other){if(!(this instanceof ClassHandle)){return false}if(!(other instanceof ClassHandle)){return false}var leftClass=this.$$.ptrType.registeredClass;var left=this.$$.ptr;var rightClass=other.$$.ptrType.registeredClass;var right=other.$$.ptr;while(leftClass.baseClass){left=leftClass.upcast(left);leftClass=leftClass.baseClass}while(rightClass.baseClass){right=rightClass.upcast(right);rightClass=rightClass.baseClass}return leftClass===rightClass&&left===right}function shallowCopyInternalPointer(o){return{count:o.count,deleteScheduled:o.deleteScheduled,preservePointerOnDelete:o.preservePointerOnDelete,ptr:o.ptr,ptrType:o.ptrType,smartPtr:o.smartPtr,smartPtrType:o.smartPtrType}}function throwInstanceAlreadyDeleted(obj){function getInstanceTypeName(handle){return handle.$$.ptrType.registeredClass.name}throwBindingError(getInstanceTypeName(obj)+" instance already deleted")}function ClassHandle_clone(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.preservePointerOnDelete){this.$$.count.value+=1;return this}else{var clone=Object.create(Object.getPrototypeOf(this),{$$:{value:shallowCopyInternalPointer(this.$$)}});clone.$$.count.value+=1;clone.$$.deleteScheduled=false;return clone}}function runDestructor(handle){var $$=handle.$$;if($$.smartPtr){$$.smartPtrType.rawDestructor($$.smartPtr)}else{$$.ptrType.registeredClass.rawDestructor($$.ptr)}}function ClassHandle_delete(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.deleteScheduled&&!this.$$.preservePointerOnDelete){throwBindingError("Object already scheduled for deletion")}this.$$.count.value-=1;var toDelete=0===this.$$.count.value;if(toDelete){runDestructor(this)}if(!this.$$.preservePointerOnDelete){this.$$.smartPtr=undefined;this.$$.ptr=undefined}}function ClassHandle_isDeleted(){return!this.$$.ptr}var delayFunction=undefined;var deletionQueue=[];function flushPendingDeletes(){while(deletionQueue.length){var obj=deletionQueue.pop();obj.$$.deleteScheduled=false;obj["delete"]()}}function ClassHandle_deleteLater(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.deleteScheduled&&!this.$$.preservePointerOnDelete){throwBindingError("Object already scheduled for deletion")}deletionQueue.push(this);if(deletionQueue.length===1&&delayFunction){delayFunction(flushPendingDeletes)}this.$$.deleteScheduled=true;return this}function init_ClassHandle(){ClassHandle.prototype["isAliasOf"]=ClassHandle_isAliasOf;ClassHandle.prototype["clone"]=ClassHandle_clone;ClassHandle.prototype["delete"]=ClassHandle_delete;ClassHandle.prototype["isDeleted"]=ClassHandle_isDeleted;ClassHandle.prototype["deleteLater"]=ClassHandle_deleteLater}function ClassHandle(){}var registeredPointers={};function ensureOverloadTable(proto,methodName,humanName){if(undefined===proto[methodName].overloadTable){var prevFunc=proto[methodName];proto[methodName]=function(){if(!proto[methodName].overloadTable.hasOwnProperty(arguments.length)){throwBindingError("Function '"+humanName+"' called with an invalid number of arguments ("+arguments.length+") - expects one of ("+proto[methodName].overloadTable+")!")}return proto[methodName].overloadTable[arguments.length].apply(this,arguments)};proto[methodName].overloadTable=[];proto[methodName].overloadTable[prevFunc.argCount]=prevFunc}}function exposePublicSymbol(name,value,numArguments){if(Module.hasOwnProperty(name)){if(undefined===numArguments||undefined!==Module[name].overloadTable&&undefined!==Module[name].overloadTable[numArguments]){throwBindingError("Cannot register public name '"+name+"' twice")}ensureOverloadTable(Module,name,name);if(Module.hasOwnProperty(numArguments)){throwBindingError("Cannot register multiple overloads of a function with the same number of arguments ("+numArguments+")!")}Module[name].overloadTable[numArguments]=value}else{Module[name]=value;if(undefined!==numArguments){Module[name].numArguments=numArguments}}}function RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast){this.name=name;this.constructor=constructor;this.instancePrototype=instancePrototype;this.rawDestructor=rawDestructor;this.baseClass=baseClass;this.getActualType=getActualType;this.upcast=upcast;this.downcast=downcast;this.pureVirtualFunctions=[]}function upcastPointer(ptr,ptrClass,desiredClass){while(ptrClass!==desiredClass){if(!ptrClass.upcast){throwBindingError("Expected null or instance of "+desiredClass.name+", got an instance of "+ptrClass.name)}ptr=ptrClass.upcast(ptr);ptrClass=ptrClass.baseClass}return ptr}function constNoSmartPtrRawPointerToWireType(destructors,handle){if(handle===null){if(this.isReference){throwBindingError("null is not a valid "+this.name)}return 0}if(!handle.$$){throwBindingError('Cannot pass "'+_embind_repr(handle)+'" as a '+this.name)}if(!handle.$$.ptr){throwBindingError("Cannot pass deleted object as a pointer of type "+this.name)}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function genericPointerToWireType(destructors,handle){var ptr;if(handle===null){if(this.isReference){throwBindingError("null is not a valid "+this.name)}if(this.isSmartPointer){ptr=this.rawConstructor();if(destructors!==null){destructors.push(this.rawDestructor,ptr)}return ptr}else{return 0}}if(!handle.$$){throwBindingError('Cannot pass "'+_embind_repr(handle)+'" as a '+this.name)}if(!handle.$$.ptr){throwBindingError("Cannot pass deleted object as a pointer of type "+this.name)}if(!this.isConst&&handle.$$.ptrType.isConst){throwBindingError("Cannot convert argument of type "+(handle.$$.smartPtrType?handle.$$.smartPtrType.name:handle.$$.ptrType.name)+" to parameter type "+this.name)}var handleClass=handle.$$.ptrType.registeredClass;ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);if(this.isSmartPointer){if(undefined===handle.$$.smartPtr){throwBindingError("Passing raw pointer to smart pointer is illegal")}switch(this.sharingPolicy){case 0:if(handle.$$.smartPtrType===this){ptr=handle.$$.smartPtr}else{throwBindingError("Cannot convert argument of type "+(handle.$$.smartPtrType?handle.$$.smartPtrType.name:handle.$$.ptrType.name)+" to parameter type "+this.name)}break;case 1:ptr=handle.$$.smartPtr;break;case 2:if(handle.$$.smartPtrType===this){ptr=handle.$$.smartPtr}else{var clonedHandle=handle["clone"]();ptr=this.rawShare(ptr,__emval_register(function(){clonedHandle["delete"]()}));if(destructors!==null){destructors.push(this.rawDestructor,ptr)}}break;default:throwBindingError("Unsupporting sharing policy")}}return ptr}function nonConstNoSmartPtrRawPointerToWireType(destructors,handle){if(handle===null){if(this.isReference){throwBindingError("null is not a valid "+this.name)}return 0}if(!handle.$$){throwBindingError('Cannot pass "'+_embind_repr(handle)+'" as a '+this.name)}if(!handle.$$.ptr){throwBindingError("Cannot pass deleted object as a pointer of type "+this.name)}if(handle.$$.ptrType.isConst){throwBindingError("Cannot convert argument of type "+handle.$$.ptrType.name+" to parameter type "+this.name)}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function simpleReadValueFromPointer(pointer){return this["fromWireType"](HEAPU32[pointer>>2])}function RegisteredPointer_getPointee(ptr){if(this.rawGetPointee){ptr=this.rawGetPointee(ptr)}return ptr}function RegisteredPointer_destructor(ptr){if(this.rawDestructor){this.rawDestructor(ptr)}}function RegisteredPointer_deleteObject(handle){if(handle!==null){handle["delete"]()}}function downcastPointer(ptr,ptrClass,desiredClass){if(ptrClass===desiredClass){return ptr}if(undefined===desiredClass.baseClass){return null}var rv=downcastPointer(ptr,ptrClass,desiredClass.baseClass);if(rv===null){return null}return desiredClass.downcast(rv)}function getInheritedInstanceCount(){return Object.keys(registeredInstances).length}function getLiveInheritedInstances(){var rv=[];for(var k in registeredInstances){if(registeredInstances.hasOwnProperty(k)){rv.push(registeredInstances[k])}}return rv}function setDelayFunction(fn){delayFunction=fn;if(deletionQueue.length&&delayFunction){delayFunction(flushPendingDeletes)}}function init_embind(){Module["getInheritedInstanceCount"]=getInheritedInstanceCount;Module["getLiveInheritedInstances"]=getLiveInheritedInstances;Module["flushPendingDeletes"]=flushPendingDeletes;Module["setDelayFunction"]=setDelayFunction}var registeredInstances={};function getBasestPointer(class_,ptr){if(ptr===undefined){throwBindingError("ptr should not be undefined")}while(class_.baseClass){ptr=class_.upcast(ptr);class_=class_.baseClass}return ptr}function getInheritedInstance(class_,ptr){ptr=getBasestPointer(class_,ptr);return registeredInstances[ptr]}function makeClassHandle(prototype,record){if(!record.ptrType||!record.ptr){throwInternalError("makeClassHandle requires ptr and ptrType")}var hasSmartPtrType=!!record.smartPtrType;var hasSmartPtr=!!record.smartPtr;if(hasSmartPtrType!==hasSmartPtr){throwInternalError("Both smartPtrType and smartPtr must be specified")}record.count={value:1};return Object.create(prototype,{$$:{value:record}})}function RegisteredPointer_fromWireType(ptr){var rawPointer=this.getPointee(ptr);if(!rawPointer){this.destructor(ptr);return null}var registeredInstance=getInheritedInstance(this.registeredClass,rawPointer);if(undefined!==registeredInstance){if(0===registeredInstance.$$.count.value){registeredInstance.$$.ptr=rawPointer;registeredInstance.$$.smartPtr=ptr;return registeredInstance["clone"]()}else{var rv=registeredInstance["clone"]();this.destructor(ptr);return rv}}function makeDefaultHandle(){if(this.isSmartPointer){return makeClassHandle(this.registeredClass.instancePrototype,{ptrType:this.pointeeType,ptr:rawPointer,smartPtrType:this,smartPtr:ptr})}else{return makeClassHandle(this.registeredClass.instancePrototype,{ptrType:this,ptr:ptr})}}var actualType=this.registeredClass.getActualType(rawPointer);var registeredPointerRecord=registeredPointers[actualType];if(!registeredPointerRecord){return makeDefaultHandle.call(this)}var toType;if(this.isConst){toType=registeredPointerRecord.constPointerType}else{toType=registeredPointerRecord.pointerType}var dp=downcastPointer(rawPointer,this.registeredClass,toType.registeredClass);if(dp===null){return makeDefaultHandle.call(this)}if(this.isSmartPointer){return makeClassHandle(toType.registeredClass.instancePrototype,{ptrType:toType,ptr:dp,smartPtrType:this,smartPtr:ptr})}else{return makeClassHandle(toType.registeredClass.instancePrototype,{ptrType:toType,ptr:dp})}}function init_RegisteredPointer(){RegisteredPointer.prototype.getPointee=RegisteredPointer_getPointee;RegisteredPointer.prototype.destructor=RegisteredPointer_destructor;RegisteredPointer.prototype["argPackAdvance"]=8;RegisteredPointer.prototype["readValueFromPointer"]=simpleReadValueFromPointer;RegisteredPointer.prototype["deleteObject"]=RegisteredPointer_deleteObject;RegisteredPointer.prototype["fromWireType"]=RegisteredPointer_fromWireType}function RegisteredPointer(name,registeredClass,isReference,isConst,isSmartPointer,pointeeType,sharingPolicy,rawGetPointee,rawConstructor,rawShare,rawDestructor){this.name=name;this.registeredClass=registeredClass;this.isReference=isReference;this.isConst=isConst;this.isSmartPointer=isSmartPointer;this.pointeeType=pointeeType;this.sharingPolicy=sharingPolicy;this.rawGetPointee=rawGetPointee;this.rawConstructor=rawConstructor;this.rawShare=rawShare;this.rawDestructor=rawDestructor;if(!isSmartPointer&&registeredClass.baseClass===undefined){if(isConst){this["toWireType"]=constNoSmartPtrRawPointerToWireType;this.destructorFunction=null}else{this["toWireType"]=nonConstNoSmartPtrRawPointerToWireType;this.destructorFunction=null}}else{this["toWireType"]=genericPointerToWireType}}function replacePublicSymbol(name,value,numArguments){if(!Module.hasOwnProperty(name)){throwInternalError("Replacing nonexistant public symbol")}if(undefined!==Module[name].overloadTable&&undefined!==numArguments){Module[name].overloadTable[numArguments]=value}else{Module[name]=value;Module[name].argCount=numArguments}}function embind__requireFunction(signature,rawFunction){signature=readLatin1String(signature);function makeDynCaller(dynCall){var args=[];for(var i=1;i<signature.length;++i){args.push("a"+i)}var name="dynCall_"+signature+"_"+rawFunction;var body="return function "+name+"("+args.join(", ")+") {\n";body+="    return dynCall(rawFunction"+(args.length?", ":"")+args.join(", ")+");\n";body+="};\n";return new Function("dynCall","rawFunction",body)(dynCall,rawFunction)}var fp;if(Module["FUNCTION_TABLE_"+signature]!==undefined){fp=Module["FUNCTION_TABLE_"+signature][rawFunction]}else if(typeof FUNCTION_TABLE!=="undefined"){fp=FUNCTION_TABLE[rawFunction]}else{var dc=Module["dynCall_"+signature];if(dc===undefined){dc=Module["dynCall_"+signature.replace(/f/g,"d")];if(dc===undefined){throwBindingError("No dynCall invoker for signature: "+signature)}}fp=makeDynCaller(dc)}if(typeof fp!=="function"){throwBindingError("unknown function pointer with signature "+signature+": "+rawFunction)}return fp}var UnboundTypeError=undefined;function getTypeName(type){var ptr=___getTypeName(type);var rv=readLatin1String(ptr);_free(ptr);return rv}function throwUnboundTypeError(message,types){var unboundTypes=[];var seen={};function visit(type){if(seen[type]){return}if(registeredTypes[type]){return}if(typeDependencies[type]){typeDependencies[type].forEach(visit);return}unboundTypes.push(type);seen[type]=true}types.forEach(visit);throw new UnboundTypeError(message+": "+unboundTypes.map(getTypeName).join([", "]))}function __embind_register_class(rawType,rawPointerType,rawConstPointerType,baseClassRawType,getActualTypeSignature,getActualType,upcastSignature,upcast,downcastSignature,downcast,name,destructorSignature,rawDestructor){name=readLatin1String(name);getActualType=embind__requireFunction(getActualTypeSignature,getActualType);if(upcast){upcast=embind__requireFunction(upcastSignature,upcast)}if(downcast){downcast=embind__requireFunction(downcastSignature,downcast)}rawDestructor=embind__requireFunction(destructorSignature,rawDestructor);var legalFunctionName=makeLegalFunctionName(name);exposePublicSymbol(legalFunctionName,function(){throwUnboundTypeError("Cannot construct "+name+" due to unbound types",[baseClassRawType])});whenDependentTypesAreResolved([rawType,rawPointerType,rawConstPointerType],baseClassRawType?[baseClassRawType]:[],function(base){base=base[0];var baseClass;var basePrototype;if(baseClassRawType){baseClass=base.registeredClass;basePrototype=baseClass.instancePrototype}else{basePrototype=ClassHandle.prototype}var constructor=createNamedFunction(legalFunctionName,function(){if(Object.getPrototypeOf(this)!==instancePrototype){throw new BindingError("Use 'new' to construct "+name)}if(undefined===registeredClass.constructor_body){throw new BindingError(name+" has no accessible constructor")}var body=registeredClass.constructor_body[arguments.length];if(undefined===body){throw new BindingError("Tried to invoke ctor of "+name+" with invalid number of parameters ("+arguments.length+") - expected ("+Object.keys(registeredClass.constructor_body).toString()+") parameters instead!")}return body.apply(this,arguments)});var instancePrototype=Object.create(basePrototype,{constructor:{value:constructor}});constructor.prototype=instancePrototype;var registeredClass=new RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast);var referenceConverter=new RegisteredPointer(name,registeredClass,true,false,false);var pointerConverter=new RegisteredPointer(name+"*",registeredClass,false,false,false);var constPointerConverter=new RegisteredPointer(name+" const*",registeredClass,false,true,false);registeredPointers[rawType]={pointerType:pointerConverter,constPointerType:constPointerConverter};replacePublicSymbol(legalFunctionName,constructor);return[referenceConverter,pointerConverter,constPointerConverter]})}function heap32VectorToArray(count,firstElement){var array=[];for(var i=0;i<count;i++){array.push(HEAP32[(firstElement>>2)+i])}return array}function runDestructors(destructors){while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr)}}function __embind_register_class_constructor(rawClassType,argCount,rawArgTypesAddr,invokerSignature,invoker,rawConstructor){var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);invoker=embind__requireFunction(invokerSignature,invoker);whenDependentTypesAreResolved([],[rawClassType],function(classType){classType=classType[0];var humanName="constructor "+classType.name;if(undefined===classType.registeredClass.constructor_body){classType.registeredClass.constructor_body=[]}if(undefined!==classType.registeredClass.constructor_body[argCount-1]){throw new BindingError("Cannot register multiple constructors with identical number of parameters ("+(argCount-1)+") for class '"+classType.name+"'! Overload resolution is currently only performed using the parameter count, not actual type info!")}classType.registeredClass.constructor_body[argCount-1]=function unboundTypeHandler(){throwUnboundTypeError("Cannot construct "+classType.name+" due to unbound types",rawArgTypes)};whenDependentTypesAreResolved([],rawArgTypes,function(argTypes){classType.registeredClass.constructor_body[argCount-1]=function constructor_body(){if(arguments.length!==argCount-1){throwBindingError(humanName+" called with "+arguments.length+" arguments, expected "+(argCount-1))}var destructors=[];var args=new Array(argCount);args[0]=rawConstructor;for(var i=1;i<argCount;++i){args[i]=argTypes[i]["toWireType"](destructors,arguments[i-1])}var ptr=invoker.apply(null,args);runDestructors(destructors);return argTypes[0]["fromWireType"](ptr)};return[]});return[]})}function new_(constructor,argumentList){if(!(constructor instanceof Function)){throw new TypeError("new_ called with constructor type "+typeof constructor+" which is not a function")}var dummy=createNamedFunction(constructor.name||"unknownFunctionName",function(){});dummy.prototype=constructor.prototype;var obj=new dummy;var r=constructor.apply(obj,argumentList);return r instanceof Object?r:obj}function craftInvokerFunction(humanName,argTypes,classType,cppInvokerFunc,cppTargetFunc){var argCount=argTypes.length;if(argCount<2){throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!")}var isClassMethodFunc=argTypes[1]!==null&&classType!==null;var needsDestructorStack=false;for(var i=1;i<argTypes.length;++i){if(argTypes[i]!==null&&argTypes[i].destructorFunction===undefined){needsDestructorStack=true;break}}var returns=argTypes[0].name!=="void";var argsList="";var argsListWired="";for(var i=0;i<argCount-2;++i){argsList+=(i!==0?", ":"")+"arg"+i;argsListWired+=(i!==0?", ":"")+"arg"+i+"Wired"}var invokerFnBody="return function "+makeLegalFunctionName(humanName)+"("+argsList+") {\n"+"if (arguments.length !== "+(argCount-2)+") {\n"+"throwBindingError('function "+humanName+" called with ' + arguments.length + ' arguments, expected "+(argCount-2)+" args!');\n"+"}\n";if(needsDestructorStack){invokerFnBody+="var destructors = [];\n"}var dtorStack=needsDestructorStack?"destructors":"null";var args1=["throwBindingError","invoker","fn","runDestructors","retType","classParam"];var args2=[throwBindingError,cppInvokerFunc,cppTargetFunc,runDestructors,argTypes[0],argTypes[1]];if(isClassMethodFunc){invokerFnBody+="var thisWired = classParam.toWireType("+dtorStack+", this);\n"}for(var i=0;i<argCount-2;++i){invokerFnBody+="var arg"+i+"Wired = argType"+i+".toWireType("+dtorStack+", arg"+i+"); // "+argTypes[i+2].name+"\n";args1.push("argType"+i);args2.push(argTypes[i+2])}if(isClassMethodFunc){argsListWired="thisWired"+(argsListWired.length>0?", ":"")+argsListWired}invokerFnBody+=(returns?"var rv = ":"")+"invoker(fn"+(argsListWired.length>0?", ":"")+argsListWired+");\n";if(needsDestructorStack){invokerFnBody+="runDestructors(destructors);\n"}else{for(var i=isClassMethodFunc?1:2;i<argTypes.length;++i){var paramName=i===1?"thisWired":"arg"+(i-2)+"Wired";if(argTypes[i].destructorFunction!==null){invokerFnBody+=paramName+"_dtor("+paramName+"); // "+argTypes[i].name+"\n";args1.push(paramName+"_dtor");args2.push(argTypes[i].destructorFunction)}}}if(returns){invokerFnBody+="var ret = retType.fromWireType(rv);\n"+"return ret;\n"}else{}invokerFnBody+="}\n";args1.push(invokerFnBody);var invokerFunction=new_(Function,args1).apply(null,args2);return invokerFunction}function __embind_register_class_function(rawClassType,methodName,argCount,rawArgTypesAddr,invokerSignature,rawInvoker,context,isPureVirtual){var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);methodName=readLatin1String(methodName);rawInvoker=embind__requireFunction(invokerSignature,rawInvoker);whenDependentTypesAreResolved([],[rawClassType],function(classType){classType=classType[0];var humanName=classType.name+"."+methodName;if(isPureVirtual){classType.registeredClass.pureVirtualFunctions.push(methodName)}function unboundTypesHandler(){throwUnboundTypeError("Cannot call "+humanName+" due to unbound types",rawArgTypes)}var proto=classType.registeredClass.instancePrototype;var method=proto[methodName];if(undefined===method||undefined===method.overloadTable&&method.className!==classType.name&&method.argCount===argCount-2){unboundTypesHandler.argCount=argCount-2;unboundTypesHandler.className=classType.name;proto[methodName]=unboundTypesHandler}else{ensureOverloadTable(proto,methodName,humanName);proto[methodName].overloadTable[argCount-2]=unboundTypesHandler}whenDependentTypesAreResolved([],rawArgTypes,function(argTypes){var memberFunction=craftInvokerFunction(humanName,argTypes,classType,rawInvoker,context);if(undefined===proto[methodName].overloadTable){memberFunction.argCount=argCount-2;proto[methodName]=memberFunction}else{proto[methodName].overloadTable[argCount-2]=memberFunction}return[]});return[]})}var emval_free_list=[];var emval_handle_array=[{},{value:undefined},{value:null},{value:true},{value:false}];function __emval_decref(handle){if(handle>4&&0===--emval_handle_array[handle].refcount){emval_handle_array[handle]=undefined;emval_free_list.push(handle)}}function count_emval_handles(){var count=0;for(var i=5;i<emval_handle_array.length;++i){if(emval_handle_array[i]!==undefined){++count}}return count}function get_first_emval(){for(var i=5;i<emval_handle_array.length;++i){if(emval_handle_array[i]!==undefined){return emval_handle_array[i]}}return null}function init_emval(){Module["count_emval_handles"]=count_emval_handles;Module["get_first_emval"]=get_first_emval}function __emval_register(value){switch(value){case undefined:{return 1}case null:{return 2}case true:{return 3}case false:{return 4}default:{var handle=emval_free_list.length?emval_free_list.pop():emval_handle_array.length;emval_handle_array[handle]={refcount:1,value:value};return handle}}}function __embind_register_emval(rawType,name){name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(handle){var rv=emval_handle_array[handle].value;__emval_decref(handle);return rv},"toWireType":function(destructors,value){return __emval_register(value)},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:null})}function _embind_repr(v){if(v===null){return"null"}var t=typeof v;if(t==="object"||t==="array"||t==="function"){return v.toString()}else{return""+v}}function floatReadValueFromPointer(name,shift){switch(shift){case 2:return function(pointer){return this["fromWireType"](HEAPF32[pointer>>2])};case 3:return function(pointer){return this["fromWireType"](HEAPF64[pointer>>3])};default:throw new TypeError("Unknown float type: "+name)}}function __embind_register_float(rawType,name,size){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(value){return value},"toWireType":function(destructors,value){if(typeof value!=="number"&&typeof value!=="boolean"){throw new TypeError('Cannot convert "'+_embind_repr(value)+'" to '+this.name)}return value},"argPackAdvance":8,"readValueFromPointer":floatReadValueFromPointer(name,shift),destructorFunction:null})}function __embind_register_function(name,argCount,rawArgTypesAddr,signature,rawInvoker,fn){var argTypes=heap32VectorToArray(argCount,rawArgTypesAddr);name=readLatin1String(name);rawInvoker=embind__requireFunction(signature,rawInvoker);exposePublicSymbol(name,function(){throwUnboundTypeError("Cannot call "+name+" due to unbound types",argTypes)},argCount-1);whenDependentTypesAreResolved([],argTypes,function(argTypes){var invokerArgsArray=[argTypes[0],null].concat(argTypes.slice(1));replacePublicSymbol(name,craftInvokerFunction(name,invokerArgsArray,null,rawInvoker,fn),argCount-1);return[]})}function integerReadValueFromPointer(name,shift,signed){switch(shift){case 0:return signed?function readS8FromPointer(pointer){return HEAP8[pointer]}:function readU8FromPointer(pointer){return HEAPU8[pointer]};case 1:return signed?function readS16FromPointer(pointer){return HEAP16[pointer>>1]}:function readU16FromPointer(pointer){return HEAPU16[pointer>>1]};case 2:return signed?function readS32FromPointer(pointer){return HEAP32[pointer>>2]}:function readU32FromPointer(pointer){return HEAPU32[pointer>>2]};default:throw new TypeError("Unknown integer type: "+name)}}function __embind_register_integer(primitiveType,name,size,minRange,maxRange){name=readLatin1String(name);if(maxRange===-1){maxRange=4294967295}var shift=getShiftFromSize(size);var fromWireType=function(value){return value};if(minRange===0){var bitshift=32-8*size;fromWireType=function(value){return value<<bitshift>>>bitshift}}var isUnsignedType=name.indexOf("unsigned")!=-1;registerType(primitiveType,{name:name,"fromWireType":fromWireType,"toWireType":function(destructors,value){if(typeof value!=="number"&&typeof value!=="boolean"){throw new TypeError('Cannot convert "'+_embind_repr(value)+'" to '+this.name)}if(value<minRange||value>maxRange){throw new TypeError('Passing a number "'+_embind_repr(value)+'" from JS side to C/C++ side to an argument of type "'+name+'", which is outside the valid range ['+minRange+", "+maxRange+"]!")}return isUnsignedType?value>>>0:value|0},"argPackAdvance":8,"readValueFromPointer":integerReadValueFromPointer(name,shift,minRange!==0),destructorFunction:null})}function __embind_register_memory_view(rawType,dataTypeIndex,name){var typeMapping=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array];var TA=typeMapping[dataTypeIndex];function decodeMemoryView(handle){handle=handle>>2;var heap=HEAPU32;var size=heap[handle];var data=heap[handle+1];return new TA(heap["buffer"],data,size)}name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":decodeMemoryView,"argPackAdvance":8,"readValueFromPointer":decodeMemoryView},{ignoreDuplicateRegistrations:true})}function __embind_register_std_string(rawType,name){name=readLatin1String(name);var stdStringIsUTF8=name==="std::string";registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var str;if(stdStringIsUTF8){var endChar=HEAPU8[value+4+length];var endCharSwap=0;if(endChar!=0){endCharSwap=endChar;HEAPU8[value+4+length]=0}var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i;if(HEAPU8[currentBytePtr]==0){var stringSegment=UTF8ToString(decodeStartPtr);if(str===undefined)str=stringSegment;else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+1}}if(endCharSwap!=0)HEAPU8[value+4+length]=endCharSwap}else{var a=new Array(length);for(var i=0;i<length;++i){a[i]=String.fromCharCode(HEAPU8[value+4+i])}str=a.join("")}_free(value);return str},"toWireType":function(destructors,value){if(value instanceof ArrayBuffer){value=new Uint8Array(value)}var getLength;var valueIsOfTypeString=typeof value==="string";if(!(valueIsOfTypeString||value instanceof Uint8Array||value instanceof Uint8ClampedArray||value instanceof Int8Array)){throwBindingError("Cannot pass non-string to std::string")}if(stdStringIsUTF8&&valueIsOfTypeString){getLength=function(){return lengthBytesUTF8(value)}}else{getLength=function(){return value.length}}var length=getLength();var ptr=_malloc(4+length+1);HEAPU32[ptr>>2]=length;if(stdStringIsUTF8&&valueIsOfTypeString){stringToUTF8(value,ptr+4,length+1)}else{if(valueIsOfTypeString){for(var i=0;i<length;++i){var charCode=value.charCodeAt(i);if(charCode>255){_free(ptr);throwBindingError("String has UTF-16 code units that do not fit in 8 bits")}HEAPU8[ptr+4+i]=charCode}}else{for(var i=0;i<length;++i){HEAPU8[ptr+4+i]=value[i]}}}if(destructors!==null){destructors.push(_free,ptr)}return ptr},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:function(ptr){_free(ptr)}})}function __embind_register_std_wstring(rawType,charSize,name){name=readLatin1String(name);var getHeap,shift;if(charSize===2){getHeap=function(){return HEAPU16};shift=1}else if(charSize===4){getHeap=function(){return HEAPU32};shift=2}registerType(rawType,{name:name,"fromWireType":function(value){var HEAP=getHeap();var length=HEAPU32[value>>2];var a=new Array(length);var start=value+4>>shift;for(var i=0;i<length;++i){a[i]=String.fromCharCode(HEAP[start+i])}_free(value);return a.join("")},"toWireType":function(destructors,value){var HEAP=getHeap();var length=value.length;var ptr=_malloc(4+length*charSize);HEAPU32[ptr>>2]=length;var start=ptr+4>>shift;for(var i=0;i<length;++i){HEAP[start+i]=value.charCodeAt(i)}if(destructors!==null){destructors.push(_free,ptr)}return ptr},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:function(ptr){_free(ptr)}})}function __embind_register_void(rawType,name){name=readLatin1String(name);registerType(rawType,{isVoid:true,name:name,"argPackAdvance":0,"fromWireType":function(){return undefined},"toWireType":function(destructors,o){return undefined}})}function requireHandle(handle){if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handle_array[handle].value}function requireRegisteredType(rawType,humanName){var impl=registeredTypes[rawType];if(undefined===impl){throwBindingError(humanName+" has unknown type "+getTypeName(rawType))}return impl}function __emval_as(handle,returnType,destructorsRef){handle=requireHandle(handle);returnType=requireRegisteredType(returnType,"emval::as");var destructors=[];var rd=__emval_register(destructors);HEAP32[destructorsRef>>2]=rd;return returnType["toWireType"](destructors,handle)}var emval_symbols={};function getStringOrSymbol(address){var symbol=emval_symbols[address];if(symbol===undefined){return readLatin1String(address)}else{return symbol}}var emval_methodCallers=[];function __emval_call_void_method(caller,handle,methodName,args){caller=emval_methodCallers[caller];handle=requireHandle(handle);methodName=getStringOrSymbol(methodName);caller(handle,methodName,null,args)}function emval_get_global(){return function(){return Function}()("return this")()}function __emval_get_global(name){if(name===0){return __emval_register(emval_get_global())}else{name=getStringOrSymbol(name);return __emval_register(emval_get_global()[name])}}function __emval_addMethodCaller(caller){var id=emval_methodCallers.length;emval_methodCallers.push(caller);return id}function __emval_lookupTypes(argCount,argTypes,argWireTypes){var a=new Array(argCount);for(var i=0;i<argCount;++i){a[i]=requireRegisteredType(HEAP32[(argTypes>>2)+i],"parameter "+i)}return a}function __emval_get_method_caller(argCount,argTypes){var types=__emval_lookupTypes(argCount,argTypes);var retType=types[0];var signatureName=retType.name+"_$"+types.slice(1).map(function(t){return t.name}).join("_")+"$";var params=["retType"];var args=[retType];var argsList="";for(var i=0;i<argCount-1;++i){argsList+=(i!==0?", ":"")+"arg"+i;params.push("argType"+i);args.push(types[1+i])}var functionName=makeLegalFunctionName("methodCaller_"+signatureName);var functionBody="return function "+functionName+"(handle, name, destructors, args) {\n";var offset=0;for(var i=0;i<argCount-1;++i){functionBody+="    var arg"+i+" = argType"+i+".readValueFromPointer(args"+(offset?"+"+offset:"")+");\n";offset+=types[i+1]["argPackAdvance"]}functionBody+="    var rv = handle[name]("+argsList+");\n";for(var i=0;i<argCount-1;++i){if(types[i+1]["deleteObject"]){functionBody+="    argType"+i+".deleteObject(arg"+i+");\n"}}if(!retType.isVoid){functionBody+="    return retType.toWireType(destructors, rv);\n"}functionBody+="};\n";params.push(functionBody);var invokerFunction=new_(Function,params).apply(null,args);return __emval_addMethodCaller(invokerFunction)}function __emval_get_module_property(name){name=getStringOrSymbol(name);return __emval_register(Module[name])}function __emval_get_property(handle,key){handle=requireHandle(handle);key=requireHandle(key);return __emval_register(handle[key])}function __emval_incref(handle){if(handle>4){emval_handle_array[handle].refcount+=1}}function craftEmvalAllocator(argCount){var argsList="";for(var i=0;i<argCount;++i){argsList+=(i!==0?", ":"")+"arg"+i}var functionBody="return function emval_allocator_"+argCount+"(constructor, argTypes, args) {\n";for(var i=0;i<argCount;++i){functionBody+="var argType"+i+" = requireRegisteredType(Module['HEAP32'][(argTypes >> 2) + "+i+'], "parameter '+i+'");\n'+"var arg"+i+" = argType"+i+".readValueFromPointer(args);\n"+"args += argType"+i+"['argPackAdvance'];\n"}functionBody+="var obj = new constructor("+argsList+");\n"+"return __emval_register(obj);\n"+"}\n";return new Function("requireRegisteredType","Module","__emval_register",functionBody)(requireRegisteredType,Module,__emval_register)}var emval_newers={};function __emval_new(handle,argCount,argTypes,args){handle=requireHandle(handle);var newer=emval_newers[argCount];if(!newer){newer=craftEmvalAllocator(argCount);emval_newers[argCount]=newer}return newer(handle,argTypes,args)}function __emval_new_cstring(v){return __emval_register(getStringOrSymbol(v))}function __emval_run_destructors(handle){var destructors=emval_handle_array[handle].value;runDestructors(destructors);__emval_decref(handle)}function _abort(){Module["abort"]()}function _emscripten_get_heap_size(){return HEAP8.length}function abortOnCannotGrowMemory(requestedSize){abort("OOM")}function emscripten_realloc_buffer(size){var PAGE_MULTIPLE=65536;size=alignUp(size,PAGE_MULTIPLE);var oldSize=buffer.byteLength;try{var result=wasmMemory.grow((size-oldSize)/65536);if(result!==(-1|0)){buffer=wasmMemory.buffer;return true}else{return false}}catch(e){return false}}function _emscripten_resize_heap(requestedSize){var oldSize=_emscripten_get_heap_size();var PAGE_MULTIPLE=65536;var LIMIT=2147483648-PAGE_MULTIPLE;if(requestedSize>LIMIT){return false}var MIN_TOTAL_MEMORY=16777216;var newSize=Math.max(oldSize,MIN_TOTAL_MEMORY);while(newSize<requestedSize){if(newSize<=536870912){newSize=alignUp(2*newSize,PAGE_MULTIPLE)}else{newSize=Math.min(alignUp((3*newSize+2147483648)/4,PAGE_MULTIPLE),LIMIT)}}if(!emscripten_realloc_buffer(newSize)){return false}updateGlobalBufferViews();return true}var ENV={};function _getenv(name){if(name===0)return 0;name=UTF8ToString(name);if(!ENV.hasOwnProperty(name))return 0;if(_getenv.ret)_free(_getenv.ret);_getenv.ret=allocateUTF8(ENV[name]);return _getenv.ret}function _llvm_stackrestore(p){var self=_llvm_stacksave;var ret=self.LLVM_SAVEDSTACKS[p];self.LLVM_SAVEDSTACKS.splice(p,1);stackRestore(ret)}function _llvm_stacksave(){var self=_llvm_stacksave;if(!self.LLVM_SAVEDSTACKS){self.LLVM_SAVEDSTACKS=[]}self.LLVM_SAVEDSTACKS.push(stackSave());return self.LLVM_SAVEDSTACKS.length-1}function _emscripten_memcpy_big(dest,src,num){HEAPU8.set(HEAPU8.subarray(src,src+num),dest)}function _pthread_cond_wait(){return 0}function __isLeapYear(year){return year%4===0&&(year%100!==0||year%400===0)}function __arraySum(array,index){var sum=0;for(var i=0;i<=index;sum+=array[i++]);return sum}var __MONTH_DAYS_LEAP=[31,29,31,30,31,30,31,31,30,31,30,31];var __MONTH_DAYS_REGULAR=[31,28,31,30,31,30,31,31,30,31,30,31];function __addDays(date,days){var newDate=new Date(date.getTime());while(days>0){var leap=__isLeapYear(newDate.getFullYear());var currentMonth=newDate.getMonth();var daysInCurrentMonth=(leap?__MONTH_DAYS_LEAP:__MONTH_DAYS_REGULAR)[currentMonth];if(days>daysInCurrentMonth-newDate.getDate()){days-=daysInCurrentMonth-newDate.getDate()+1;newDate.setDate(1);if(currentMonth<11){newDate.setMonth(currentMonth+1)}else{newDate.setMonth(0);newDate.setFullYear(newDate.getFullYear()+1)}}else{newDate.setDate(newDate.getDate()+days);return newDate}}return newDate}function _strftime(s,maxsize,format,tm){var tm_zone=HEAP32[tm+40>>2];var date={tm_sec:HEAP32[tm>>2],tm_min:HEAP32[tm+4>>2],tm_hour:HEAP32[tm+8>>2],tm_mday:HEAP32[tm+12>>2],tm_mon:HEAP32[tm+16>>2],tm_year:HEAP32[tm+20>>2],tm_wday:HEAP32[tm+24>>2],tm_yday:HEAP32[tm+28>>2],tm_isdst:HEAP32[tm+32>>2],tm_gmtoff:HEAP32[tm+36>>2],tm_zone:tm_zone?UTF8ToString(tm_zone):""};var pattern=UTF8ToString(format);var EXPANSION_RULES_1={"%c":"%a %b %d %H:%M:%S %Y","%D":"%m/%d/%y","%F":"%Y-%m-%d","%h":"%b","%r":"%I:%M:%S %p","%R":"%H:%M","%T":"%H:%M:%S","%x":"%m/%d/%y","%X":"%H:%M:%S"};for(var rule in EXPANSION_RULES_1){pattern=pattern.replace(new RegExp(rule,"g"),EXPANSION_RULES_1[rule])}var WEEKDAYS=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];var MONTHS=["January","February","March","April","May","June","July","August","September","October","November","December"];function leadingSomething(value,digits,character){var str=typeof value==="number"?value.toString():value||"";while(str.length<digits){str=character[0]+str}return str}function leadingNulls(value,digits){return leadingSomething(value,digits,"0")}function compareByDay(date1,date2){function sgn(value){return value<0?-1:value>0?1:0}var compare;if((compare=sgn(date1.getFullYear()-date2.getFullYear()))===0){if((compare=sgn(date1.getMonth()-date2.getMonth()))===0){compare=sgn(date1.getDate()-date2.getDate())}}return compare}function getFirstWeekStartDate(janFourth){switch(janFourth.getDay()){case 0:return new Date(janFourth.getFullYear()-1,11,29);case 1:return janFourth;case 2:return new Date(janFourth.getFullYear(),0,3);case 3:return new Date(janFourth.getFullYear(),0,2);case 4:return new Date(janFourth.getFullYear(),0,1);case 5:return new Date(janFourth.getFullYear()-1,11,31);case 6:return new Date(janFourth.getFullYear()-1,11,30)}}function getWeekBasedYear(date){var thisDate=__addDays(new Date(date.tm_year+1900,0,1),date.tm_yday);var janFourthThisYear=new Date(thisDate.getFullYear(),0,4);var janFourthNextYear=new Date(thisDate.getFullYear()+1,0,4);var firstWeekStartThisYear=getFirstWeekStartDate(janFourthThisYear);var firstWeekStartNextYear=getFirstWeekStartDate(janFourthNextYear);if(compareByDay(firstWeekStartThisYear,thisDate)<=0){if(compareByDay(firstWeekStartNextYear,thisDate)<=0){return thisDate.getFullYear()+1}else{return thisDate.getFullYear()}}else{return thisDate.getFullYear()-1}}var EXPANSION_RULES_2={"%a":function(date){return WEEKDAYS[date.tm_wday].substring(0,3)},"%A":function(date){return WEEKDAYS[date.tm_wday]},"%b":function(date){return MONTHS[date.tm_mon].substring(0,3)},"%B":function(date){return MONTHS[date.tm_mon]},"%C":function(date){var year=date.tm_year+1900;return leadingNulls(year/100|0,2)},"%d":function(date){return leadingNulls(date.tm_mday,2)},"%e":function(date){return leadingSomething(date.tm_mday,2," ")},"%g":function(date){return getWeekBasedYear(date).toString().substring(2)},"%G":function(date){return getWeekBasedYear(date)},"%H":function(date){return leadingNulls(date.tm_hour,2)},"%I":function(date){var twelveHour=date.tm_hour;if(twelveHour==0)twelveHour=12;else if(twelveHour>12)twelveHour-=12;return leadingNulls(twelveHour,2)},"%j":function(date){return leadingNulls(date.tm_mday+__arraySum(__isLeapYear(date.tm_year+1900)?__MONTH_DAYS_LEAP:__MONTH_DAYS_REGULAR,date.tm_mon-1),3)},"%m":function(date){return leadingNulls(date.tm_mon+1,2)},"%M":function(date){return leadingNulls(date.tm_min,2)},"%n":function(){return"\n"},"%p":function(date){if(date.tm_hour>=0&&date.tm_hour<12){return"AM"}else{return"PM"}},"%S":function(date){return leadingNulls(date.tm_sec,2)},"%t":function(){return"\t"},"%u":function(date){var day=new Date(date.tm_year+1900,date.tm_mon+1,date.tm_mday,0,0,0,0);return day.getDay()||7},"%U":function(date){var janFirst=new Date(date.tm_year+1900,0,1);var firstSunday=janFirst.getDay()===0?janFirst:__addDays(janFirst,7-janFirst.getDay());var endDate=new Date(date.tm_year+1900,date.tm_mon,date.tm_mday);if(compareByDay(firstSunday,endDate)<0){var februaryFirstUntilEndMonth=__arraySum(__isLeapYear(endDate.getFullYear())?__MONTH_DAYS_LEAP:__MONTH_DAYS_REGULAR,endDate.getMonth()-1)-31;var firstSundayUntilEndJanuary=31-firstSunday.getDate();var days=firstSundayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate();return leadingNulls(Math.ceil(days/7),2)}return compareByDay(firstSunday,janFirst)===0?"01":"00"},"%V":function(date){var janFourthThisYear=new Date(date.tm_year+1900,0,4);var janFourthNextYear=new Date(date.tm_year+1901,0,4);var firstWeekStartThisYear=getFirstWeekStartDate(janFourthThisYear);var firstWeekStartNextYear=getFirstWeekStartDate(janFourthNextYear);var endDate=__addDays(new Date(date.tm_year+1900,0,1),date.tm_yday);if(compareByDay(endDate,firstWeekStartThisYear)<0){return"53"}if(compareByDay(firstWeekStartNextYear,endDate)<=0){return"01"}var daysDifference;if(firstWeekStartThisYear.getFullYear()<date.tm_year+1900){daysDifference=date.tm_yday+32-firstWeekStartThisYear.getDate()}else{daysDifference=date.tm_yday+1-firstWeekStartThisYear.getDate()}return leadingNulls(Math.ceil(daysDifference/7),2)},"%w":function(date){var day=new Date(date.tm_year+1900,date.tm_mon+1,date.tm_mday,0,0,0,0);return day.getDay()},"%W":function(date){var janFirst=new Date(date.tm_year,0,1);var firstMonday=janFirst.getDay()===1?janFirst:__addDays(janFirst,janFirst.getDay()===0?1:7-janFirst.getDay()+1);var endDate=new Date(date.tm_year+1900,date.tm_mon,date.tm_mday);if(compareByDay(firstMonday,endDate)<0){var februaryFirstUntilEndMonth=__arraySum(__isLeapYear(endDate.getFullYear())?__MONTH_DAYS_LEAP:__MONTH_DAYS_REGULAR,endDate.getMonth()-1)-31;var firstMondayUntilEndJanuary=31-firstMonday.getDate();var days=firstMondayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate();return leadingNulls(Math.ceil(days/7),2)}return compareByDay(firstMonday,janFirst)===0?"01":"00"},"%y":function(date){return(date.tm_year+1900).toString().substring(2)},"%Y":function(date){return date.tm_year+1900},"%z":function(date){var off=date.tm_gmtoff;var ahead=off>=0;off=Math.abs(off)/60;off=off/60*100+off%60;return(ahead?"+":"-")+String("0000"+off).slice(-4)},"%Z":function(date){return date.tm_zone},"%%":function(){return"%"}};for(var rule in EXPANSION_RULES_2){if(pattern.indexOf(rule)>=0){pattern=pattern.replace(new RegExp(rule,"g"),EXPANSION_RULES_2[rule](date))}}var bytes=intArrayFromString(pattern,false);if(bytes.length>maxsize){return 0}writeArrayToMemory(bytes,s);return bytes.length-1}function _strftime_l(s,maxsize,format,tm){return _strftime(s,maxsize,format,tm)}FS.staticInit();if(ENVIRONMENT_IS_NODE){var fs=require("fs");var NODEJS_PATH=require("path");NODEFS.staticInit()}embind_init_charCodes();BindingError=Module["BindingError"]=extendError(Error,"BindingError");InternalError=Module["InternalError"]=extendError(Error,"InternalError");init_ClassHandle();init_RegisteredPointer();init_embind();UnboundTypeError=Module["UnboundTypeError"]=extendError(Error,"UnboundTypeError");init_emval();function intArrayFromString(stringy,dontAddNull,length){var len=length>0?length:lengthBytesUTF8(stringy)+1;var u8array=new Array(len);var numBytesWritten=stringToUTF8Array(stringy,u8array,0,u8array.length);if(dontAddNull)u8array.length=numBytesWritten;return u8array}var asmGlobalArg={};var asmLibraryArg={"c":abort,"z":setTempRet0,"g":___assert_fail,"k":___cxa_allocate_exception,"j":___cxa_throw,"F":___cxa_uncaught_exception,"p":___lock,"y":___map_file,"o":___setErrNo,"x":___syscall140,"w":___syscall145,"v":___syscall146,"X":___syscall54,"W":___syscall6,"V":___syscall91,"n":___unlock,"U":__embind_register_bool,"T":__embind_register_class,"S":__embind_register_class_constructor,"f":__embind_register_class_function,"R":__embind_register_emval,"u":__embind_register_float,"Q":__embind_register_function,"e":__embind_register_integer,"d":__embind_register_memory_view,"t":__embind_register_std_string,"P":__embind_register_std_wstring,"O":__embind_register_void,"s":__emval_as,"r":__emval_call_void_method,"N":__emval_decref,"M":__emval_get_global,"q":__emval_get_method_caller,"L":__emval_get_module_property,"m":__emval_get_property,"K":__emval_incref,"J":__emval_new,"I":__emval_new_cstring,"H":__emval_run_destructors,"b":_abort,"G":_emscripten_get_heap_size,"E":_emscripten_memcpy_big,"D":_emscripten_resize_heap,"l":_getenv,"i":_llvm_stackrestore,"h":_llvm_stacksave,"C":_pthread_cond_wait,"B":_strftime_l,"A":abortOnCannotGrowMemory,"a":DYNAMICTOP_PTR};var asm=Module["asm"](asmGlobalArg,asmLibraryArg,buffer);Module["asm"]=asm;var __ZSt18uncaught_exceptionv=Module["__ZSt18uncaught_exceptionv"]=function(){return Module["asm"]["Y"].apply(null,arguments)};var ___errno_location=Module["___errno_location"]=function(){return Module["asm"]["Z"].apply(null,arguments)};var ___getTypeName=Module["___getTypeName"]=function(){return Module["asm"]["_"].apply(null,arguments)};var _free=Module["_free"]=function(){return Module["asm"]["$"].apply(null,arguments)};var _malloc=Module["_malloc"]=function(){return Module["asm"]["aa"].apply(null,arguments)};var globalCtors=Module["globalCtors"]=function(){return Module["asm"]["wa"].apply(null,arguments)};var stackAlloc=Module["stackAlloc"]=function(){return Module["asm"]["xa"].apply(null,arguments)};var stackRestore=Module["stackRestore"]=function(){return Module["asm"]["ya"].apply(null,arguments)};var stackSave=Module["stackSave"]=function(){return Module["asm"]["za"].apply(null,arguments)};var dynCall_ii=Module["dynCall_ii"]=function(){return Module["asm"]["ba"].apply(null,arguments)};var dynCall_iidiiii=Module["dynCall_iidiiii"]=function(){return Module["asm"]["ca"].apply(null,arguments)};var dynCall_iii=Module["dynCall_iii"]=function(){return Module["asm"]["da"].apply(null,arguments)};var dynCall_iiii=Module["dynCall_iiii"]=function(){return Module["asm"]["ea"].apply(null,arguments)};var dynCall_iiiii=Module["dynCall_iiiii"]=function(){return Module["asm"]["fa"].apply(null,arguments)};var dynCall_iiiiid=Module["dynCall_iiiiid"]=function(){return Module["asm"]["ga"].apply(null,arguments)};var dynCall_iiiiii=Module["dynCall_iiiiii"]=function(){return Module["asm"]["ha"].apply(null,arguments)};var dynCall_iiiiiid=Module["dynCall_iiiiiid"]=function(){return Module["asm"]["ia"].apply(null,arguments)};var dynCall_iiiiiii=Module["dynCall_iiiiiii"]=function(){return Module["asm"]["ja"].apply(null,arguments)};var dynCall_iiiiiiii=Module["dynCall_iiiiiiii"]=function(){return Module["asm"]["ka"].apply(null,arguments)};var dynCall_iiiiiiiii=Module["dynCall_iiiiiiiii"]=function(){return Module["asm"]["la"].apply(null,arguments)};var dynCall_iiiiij=Module["dynCall_iiiiij"]=function(){return Module["asm"]["ma"].apply(null,arguments)};var dynCall_jiji=Module["dynCall_jiji"]=function(){return Module["asm"]["na"].apply(null,arguments)};var dynCall_v=Module["dynCall_v"]=function(){return Module["asm"]["oa"].apply(null,arguments)};var dynCall_vi=Module["dynCall_vi"]=function(){return Module["asm"]["pa"].apply(null,arguments)};var dynCall_vii=Module["dynCall_vii"]=function(){return Module["asm"]["qa"].apply(null,arguments)};var dynCall_viii=Module["dynCall_viii"]=function(){return Module["asm"]["ra"].apply(null,arguments)};var dynCall_viiii=Module["dynCall_viiii"]=function(){return Module["asm"]["sa"].apply(null,arguments)};var dynCall_viiiii=Module["dynCall_viiiii"]=function(){return Module["asm"]["ta"].apply(null,arguments)};var dynCall_viiiiii=Module["dynCall_viiiiii"]=function(){return Module["asm"]["ua"].apply(null,arguments)};var dynCall_viijii=Module["dynCall_viijii"]=function(){return Module["asm"]["va"].apply(null,arguments)};Module["asm"]=asm;function ExitStatus(status){this.name="ExitStatus";this.message="Program terminated with exit("+status+")";this.status=status}ExitStatus.prototype=new Error;ExitStatus.prototype.constructor=ExitStatus;dependenciesFulfilled=function runCaller(){if(!Module["calledRun"])run();if(!Module["calledRun"])dependenciesFulfilled=runCaller};function run(args){args=args||Module["arguments"];if(runDependencies>0){return}preRun();if(runDependencies>0)return;if(Module["calledRun"])return;function doRun(){if(Module["calledRun"])return;Module["calledRun"]=true;if(ABORT)return;ensureInitRuntime();preMain();if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("")},1);doRun()},1)}else{doRun()}}Module["run"]=run;function abort(what){if(Module["onAbort"]){Module["onAbort"](what)}if(what!==undefined){out(what);err(what);what=JSON.stringify(what)}else{what=""}ABORT=true;EXITSTATUS=1;throw"abort("+what+"). Build with -s ASSERTIONS=1 for more info."}Module["abort"]=abort;if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}Module["noExitRuntime"]=true;run();
diff --git a/webgl/gltf-demo/wasm/build/basis_transcoder.wasm b/webgl/gltf-demo/wasm/build/basis_transcoder.wasm
new file mode 100644
index 0000000..e2e7794
--- /dev/null
+++ b/webgl/gltf-demo/wasm/build/basis_transcoder.wasm
Binary files differ