x_ite 8.6.24 → 8.7.0

package/dist/assets/components/Texturing3D.js

@@ -1,7 +1,22 @@
-/* X_ITE v8.6.24 */(() => { // webpackBootstrap
+/* X_ITE v8.7.0 */(() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 109:
+/***/ 460:
+/***/ ((module) => {
+
+function webpackEmptyContext(req) {
+	var e = new Error("Cannot find module '" + req + "'");
+	e.code = 'MODULE_NOT_FOUND';
+	throw e;
+}
+webpackEmptyContext.keys = () => ([]);
+webpackEmptyContext.resolve = webpackEmptyContext;
+webpackEmptyContext.id = 460;
+module.exports = webpackEmptyContext;
+
+/***/ }),
+
+/***/ 990:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 var __dirname = "/";
@@ -38,7 +53,7 @@ var Ib=[cx,_q,cr,Yr,as,fs,hs,Hu,Su,cx,cx,cx,cx,cx,cx,cx];var Jb=[dx,si,gi,Wh,Kh,
 
 /***/ }),
 
-/***/ 256:
+/***/ 881:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 var __dirname = "/";
@@ -72,7 +87,7 @@ var _a=[yj,od,ef,yj];var $a=[zj,Li,di,bi,Kb,Lb,Mb,Nb,Rc,Sc,Uc,jd,xd,Ye,lf,yd,zd,
 
 /***/ }),
 
-/***/ 62:
+/***/ 615:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 /*! dicom-parser - 1.8.12 - 2023-02-20 | (c) 2017 Chris Hafey | https://github.com/cornerstonejs/dicomParser */
@@ -4028,7 +4043,7 @@ module.exports = __WEBPACK_EXTERNAL_MODULE_zlib__;
 
 /***/ }),
 
-/***/ 963:
+/***/ 622:
 /***/ ((module) => {
 
 /* -*- tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- /
@@ -5183,1767 +5198,1183 @@ function decode(jpegData, userOpts = {}) {
 
 /***/ }),
 
-/***/ 767:
-/***/ ((module) => {
-
-(function(f){if(true){module.exports=f()}else { var g; }})(function(){var define,module,exports;return (function(){function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=undefined;if(!u&&a)return require(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=undefined;for(var o=0;o<r.length;o++)s(r[o]);return s}return e})()({1:[function(require,module,exports){
-/*
- * Copyright (C) 2015 Michael Martinez
- * Changes: Added support for selection values 2-7, fixed minor bugs &
- * warnings, split into multiple class files, and general clean up.
- *
- * 08-25-2015: Helmut Dersch agreed to a license change from LGPL to MIT.
- */
-
-/*
- * Copyright (C) Helmut Dersch
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
-
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
-
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-/*jslint browser: true, node: true */
-/*global require, module */
-
-"use strict";
-
-/*** Imports ***/
-var jpeg = jpeg || {};
-jpeg.lossless = jpeg.lossless || {};
-
-
-/*** Constructor ***/
-jpeg.lossless.ComponentSpec = jpeg.lossless.ComponentSpec || function () {
-    this.hSamp = 0; // Horizontal sampling factor
-    this.quantTableSel = 0; // Quantization table destination selector
-    this.vSamp = 0; // Vertical
-};
-
-
-/*** Exports ***/
-
-var moduleType = typeof module;
-if ((moduleType !== 'undefined') && module.exports) {
-    module.exports = jpeg.lossless.ComponentSpec;
-}
-
-},{}],2:[function(require,module,exports){
-/*
- * Copyright (C) 2015 Michael Martinez
- * Changes: Added support for selection values 2-7, fixed minor bugs &
- * warnings, split into multiple class files, and general clean up.
- *
- * 08-25-2015: Helmut Dersch agreed to a license change from LGPL to MIT.
- */
-
-/*
- * Copyright (C) Helmut Dersch
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
-
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
-
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-/*jslint browser: true, node: true */
-/*global require, module */
+/***/ 782:
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 
-/*** Imports ***/
-var jpeg = jpeg || {};
-jpeg.lossless = jpeg.lossless || {};
-
+(() => {
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __require = /* @__PURE__ */ ((x) =>  true ? __webpack_require__(460) : 0)(function(x) {
+    if (true)
+      return __webpack_require__(460).apply(this, arguments);
+    throw new Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
 
-/*** Constructor ***/
-jpeg.lossless.DataStream = jpeg.lossless.DataStream || function (data, offset, length) {
-    if (offset === undefined && length === undefined) { // Old api
-        this.buffer = new Uint8Array(data);
-    } else {
-        this.buffer = new Uint8Array(data, offset, length);
+  // src/component-spec.js
+  var require_component_spec = __commonJS({
+    "src/component-spec.js"(exports, module) {
+      "use strict";
+      var jpeg = jpeg || {};
+      jpeg.lossless = jpeg.lossless || {};
+      jpeg.lossless.ComponentSpec = jpeg.lossless.ComponentSpec || function() {
+        this.hSamp = 0;
+        this.quantTableSel = 0;
+        this.vSamp = 0;
+      };
+      var moduleType = typeof module;
+      if (moduleType !== "undefined" && module.exports) {
+        module.exports = jpeg.lossless.ComponentSpec;
+      }
     }
-    this.index = 0;
-};
-
-
-
-jpeg.lossless.DataStream.prototype.get16 = function () {
-    // var value = this.buffer.getUint16(this.index, false);
-    var value = (this.buffer[this.index] << 8) + this.buffer[this.index + 1]; // DataView is big-endian by default
-    this.index += 2;
-    return value;
-};
-
-
-
-jpeg.lossless.DataStream.prototype.get8 = function () {
-    // var value = this.buffer.getUint8(this.index);
-    var value = this.buffer[this.index];
-    this.index += 1;
-    return value;
-};
-
-
-/*** Exports ***/
-
-var moduleType = typeof module;
-if ((moduleType !== 'undefined') && module.exports) {
-    module.exports = jpeg.lossless.DataStream;
-}
-
-},{}],3:[function(require,module,exports){
-/*
- * Copyright (C) 2015 Michael Martinez
- * Changes: Added support for selection values 2-7, fixed minor bugs &
- * warnings, split into multiple class files, and general clean up.
- *
- * 08-25-2015: Helmut Dersch agreed to a license change from LGPL to MIT.
- */
-
-/*
- * Copyright (C) Helmut Dersch
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
-
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
-
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-/*jslint browser: true, node: true */
-/*global require, module */
-
-"use strict";
-
-/*** Imports ***/
-var jpeg = jpeg || {};
-jpeg.lossless = jpeg.lossless || {};
-jpeg.lossless.DataStream = jpeg.lossless.DataStream || ((typeof require !== 'undefined') ? require('./data-stream.js') : null);
-jpeg.lossless.HuffmanTable = jpeg.lossless.HuffmanTable || ((typeof require !== 'undefined') ? require('./huffman-table.js') : null);
-jpeg.lossless.QuantizationTable = jpeg.lossless.QuantizationTable || ((typeof require !== 'undefined') ? require('./quantization-table.js') : null);
-jpeg.lossless.ScanHeader = jpeg.lossless.ScanHeader || ((typeof require !== 'undefined') ? require('./scan-header.js') : null);
-jpeg.lossless.FrameHeader = jpeg.lossless.FrameHeader || ((typeof require !== 'undefined') ? require('./frame-header.js') : null);
-jpeg.lossless.Utils = jpeg.lossless.Utils || ((typeof require !== 'undefined') ? require('./utils.js') : null);
-
-
-/*** Constructor ***/
-
-/**
- * The Decoder constructor.
- * @property {number} xDim - size of x dimension
- * @property {number} yDim - size of y dimension
- * @property {number} numComp - number of components
- * @property {number} numBytes - number of bytes per component
- * @type {Function}
- */
-jpeg.lossless.Decoder = jpeg.lossless.Decoder || function (buffer, numBytes) {
-    this.buffer = buffer;
-    this.frame = new jpeg.lossless.FrameHeader();
-    this.huffTable = new jpeg.lossless.HuffmanTable();
-    this.quantTable = new jpeg.lossless.QuantizationTable();
-    this.scan = new jpeg.lossless.ScanHeader();
-    this.DU = jpeg.lossless.Utils.createArray(10, 4, 64); // at most 10 data units in a MCU, at most 4 data units in one component
-    this.HuffTab = jpeg.lossless.Utils.createArray(4, 2, 50 * 256);
-    this.IDCT_Source = [];
-    this.nBlock = []; // number of blocks in the i-th Comp in a scan
-    this.acTab = jpeg.lossless.Utils.createArray(10, 1); // ac HuffTab for the i-th Comp in a scan
-    this.dcTab = jpeg.lossless.Utils.createArray(10, 1); // dc HuffTab for the i-th Comp in a scan
-    this.qTab = jpeg.lossless.Utils.createArray(10, 1); // quantization table for the i-th Comp in a scan
-    this.marker = 0;
-    this.markerIndex = 0;
-    this.numComp = 0;
-    this.restartInterval = 0;
-    this.selection = 0;
-    this.xDim = 0;
-    this.yDim = 0;
-    this.xLoc = 0;
-    this.yLoc = 0;
-    this.numBytes = 0;
-    this.outputData = null;
-    this.restarting = false;
-    this.mask = 0;
-
-    if (typeof numBytes !== "undefined") {
-        this.numBytes = numBytes;
+  });
+
+  // src/data-stream.js
+  var require_data_stream = __commonJS({
+    "src/data-stream.js"(exports, module) {
+      "use strict";
+      var jpeg = jpeg || {};
+      jpeg.lossless = jpeg.lossless || {};
+      jpeg.lossless.DataStream = jpeg.lossless.DataStream || function(data, offset, length) {
+        if (offset === void 0 && length === void 0) {
+          this.buffer = new Uint8Array(data);
+        } else {
+          this.buffer = new Uint8Array(data, offset, length);
+        }
+        this.index = 0;
+      };
+      jpeg.lossless.DataStream.prototype.get16 = function() {
+        var value = (this.buffer[this.index] << 8) + this.buffer[this.index + 1];
+        this.index += 2;
+        return value;
+      };
+      jpeg.lossless.DataStream.prototype.get8 = function() {
+        var value = this.buffer[this.index];
+        this.index += 1;
+        return value;
+      };
+      var moduleType = typeof module;
+      if (moduleType !== "undefined" && module.exports) {
+        module.exports = jpeg.lossless.DataStream;
+      }
     }
-};
-
-
-/*** Static Pseudo-constants ***/
-
-jpeg.lossless.Decoder.IDCT_P = [0, 5, 40, 16, 45, 2, 7, 42, 21, 56, 8, 61, 18, 47, 1, 4, 41, 23, 58, 13, 32, 24, 37, 10, 63, 17, 44, 3, 6, 43, 20,
-    57, 15, 34, 29, 48, 53, 26, 39, 9, 60, 19, 46, 22, 59, 12, 33, 31, 50, 55, 25, 36, 11, 62, 14, 35, 28, 49, 52, 27, 38, 30, 51, 54];
-jpeg.lossless.Decoder.TABLE = [0, 1, 5, 6, 14, 15, 27, 28, 2, 4, 7, 13, 16, 26, 29, 42, 3, 8, 12, 17, 25, 30, 41, 43, 9, 11, 18, 24, 31, 40, 44, 53,
-    10, 19, 23, 32, 39, 45, 52, 54, 20, 22, 33, 38, 46, 51, 55, 60, 21, 34, 37, 47, 50, 56, 59, 61, 35, 36, 48, 49, 57, 58, 62, 63];
-jpeg.lossless.Decoder.MAX_HUFFMAN_SUBTREE = 50;
-jpeg.lossless.Decoder.MSB = 0x80000000;
-jpeg.lossless.Decoder.RESTART_MARKER_BEGIN = 0xFFD0;
-jpeg.lossless.Decoder.RESTART_MARKER_END = 0xFFD7;
-
-/*** Prototype Methods ***/
-
-/**
- * Returns decompressed data.
- * @param {ArrayBuffer} buffer
- * @param {number} [offset]
- * @param {number} [length]
- * @returns {ArrayBufer}
- */
-jpeg.lossless.Decoder.prototype.decompress = function (buffer, offset, length) {
-    return this.decode(buffer, offset, length).buffer;
-};
-
-
-
-jpeg.lossless.Decoder.prototype.decode = function (buffer, offset, length, numBytes) {
-    /*jslint bitwise: true */
-
-    var current, scanNum = 0, pred = [], i, compN, temp = [], index = [], mcuNum;
-
-    if (typeof buffer !== "undefined") {
-        this.buffer = buffer;
+  });
+
+  // src/utils.js
+  var require_utils = __commonJS({
+    "src/utils.js"(exports, module) {
+      "use strict";
+      var jpeg = jpeg || {};
+      jpeg.lossless = jpeg.lossless || {};
+      jpeg.lossless.Utils = jpeg.lossless.Utils || {};
+      jpeg.lossless.Utils.createArray = function(length) {
+        var arr = new Array(length || 0), i = length;
+        if (arguments.length > 1) {
+          var args = Array.prototype.slice.call(arguments, 1);
+          while (i--)
+            arr[length - 1 - i] = jpeg.lossless.Utils.createArray.apply(this, args);
+        }
+        return arr;
+      };
+      jpeg.lossless.Utils.makeCRCTable = function() {
+        var c;
+        var crcTable = [];
+        for (var n = 0; n < 256; n++) {
+          c = n;
+          for (var k = 0; k < 8; k++) {
+            c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+          }
+          crcTable[n] = c;
+        }
+        return crcTable;
+      };
+      jpeg.lossless.Utils.crc32 = function(dataView) {
+        var uint8view = new Uint8Array(dataView.buffer);
+        var crcTable = jpeg.lossless.Utils.crcTable || (jpeg.lossless.Utils.crcTable = jpeg.lossless.Utils.makeCRCTable());
+        var crc = 0 ^ -1;
+        for (var i = 0; i < uint8view.length; i++) {
+          crc = crc >>> 8 ^ crcTable[(crc ^ uint8view[i]) & 255];
+        }
+        return (crc ^ -1) >>> 0;
+      };
+      var moduleType = typeof module;
+      if (moduleType !== "undefined" && module.exports) {
+        module.exports = jpeg.lossless.Utils;
+      }
     }
-
-    if (typeof numBytes !== "undefined") {
-        this.numBytes = numBytes;
+  });
+
+  // src/huffman-table.js
+  var require_huffman_table = __commonJS({
+    "src/huffman-table.js"(exports, module) {
+      "use strict";
+      var jpeg = jpeg || {};
+      jpeg.lossless = jpeg.lossless || {};
+      jpeg.lossless.DataStream = jpeg.lossless.DataStream || (typeof __require !== "undefined" ? require_data_stream() : null);
+      jpeg.lossless.Utils = jpeg.lossless.Utils || (typeof __require !== "undefined" ? require_utils() : null);
+      jpeg.lossless.HuffmanTable = jpeg.lossless.HuffmanTable || function() {
+        this.l = jpeg.lossless.Utils.createArray(4, 2, 16);
+        this.th = [];
+        this.v = jpeg.lossless.Utils.createArray(4, 2, 16, 200);
+        this.tc = jpeg.lossless.Utils.createArray(4, 2);
+        this.tc[0][0] = 0;
+        this.tc[1][0] = 0;
+        this.tc[2][0] = 0;
+        this.tc[3][0] = 0;
+        this.tc[0][1] = 0;
+        this.tc[1][1] = 0;
+        this.tc[2][1] = 0;
+        this.tc[3][1] = 0;
+        this.th[0] = 0;
+        this.th[1] = 0;
+        this.th[2] = 0;
+        this.th[3] = 0;
+      };
+      jpeg.lossless.HuffmanTable.MSB = 2147483648;
+      jpeg.lossless.HuffmanTable.prototype.read = function(data, HuffTab) {
+        var count = 0, length, temp, t, c, i, j;
+        length = data.get16();
+        count += 2;
+        while (count < length) {
+          temp = data.get8();
+          count += 1;
+          t = temp & 15;
+          if (t > 3) {
+            throw new Error("ERROR: Huffman table ID > 3");
+          }
+          c = temp >> 4;
+          if (c > 2) {
+            throw new Error("ERROR: Huffman table [Table class > 2 ]");
+          }
+          this.th[t] = 1;
+          this.tc[t][c] = 1;
+          for (i = 0; i < 16; i += 1) {
+            this.l[t][c][i] = data.get8();
+            count += 1;
+          }
+          for (i = 0; i < 16; i += 1) {
+            for (j = 0; j < this.l[t][c][i]; j += 1) {
+              if (count > length) {
+                throw new Error("ERROR: Huffman table format error [count>Lh]");
+              }
+              this.v[t][c][i][j] = data.get8();
+              count += 1;
+            }
+          }
+        }
+        if (count !== length) {
+          throw new Error("ERROR: Huffman table format error [count!=Lf]");
+        }
+        for (i = 0; i < 4; i += 1) {
+          for (j = 0; j < 2; j += 1) {
+            if (this.tc[i][j] !== 0) {
+              this.buildHuffTable(HuffTab[i][j], this.l[i][j], this.v[i][j]);
+            }
+          }
+        }
+        return 1;
+      };
+      jpeg.lossless.HuffmanTable.prototype.buildHuffTable = function(tab, L, V) {
+        var currentTable, temp, k, i, j, n;
+        temp = 256;
+        k = 0;
+        for (i = 0; i < 8; i += 1) {
+          for (j = 0; j < L[i]; j += 1) {
+            for (n = 0; n < temp >> i + 1; n += 1) {
+              tab[k] = V[i][j] | i + 1 << 8;
+              k += 1;
+            }
+          }
+        }
+        for (i = 1; k < 256; i += 1, k += 1) {
+          tab[k] = i | jpeg.lossless.HuffmanTable.MSB;
+        }
+        currentTable = 1;
+        k = 0;
+        for (i = 8; i < 16; i += 1) {
+          for (j = 0; j < L[i]; j += 1) {
+            for (n = 0; n < temp >> i - 7; n += 1) {
+              tab[currentTable * 256 + k] = V[i][j] | i + 1 << 8;
+              k += 1;
+            }
+            if (k >= 256) {
+              if (k > 256) {
+                throw new Error("ERROR: Huffman table error(1)!");
+              }
+              k = 0;
+              currentTable += 1;
+            }
+          }
+        }
+      };
+      var moduleType = typeof module;
+      if (moduleType !== "undefined" && module.exports) {
+        module.exports = jpeg.lossless.HuffmanTable;
+      }
     }
-
-    this.stream = new jpeg.lossless.DataStream(this.buffer, offset, length);
-    this.buffer = null;
-
-    this.xLoc = 0;
-    this.yLoc = 0;
-    current = this.stream.get16();
-
-    if (current !== 0xFFD8) { // SOI
-        throw new Error("Not a JPEG file");
+  });
+
+  // src/quantization-table.js
+  var require_quantization_table = __commonJS({
+    "src/quantization-table.js"(exports, module) {
+      "use strict";
+      var jpeg = jpeg || {};
+      jpeg.lossless = jpeg.lossless || {};
+      jpeg.lossless.DataStream = jpeg.lossless.DataStream || (typeof __require !== "undefined" ? require_data_stream() : null);
+      jpeg.lossless.Utils = jpeg.lossless.Utils || (typeof __require !== "undefined" ? require_utils() : null);
+      jpeg.lossless.QuantizationTable = jpeg.lossless.QuantizationTable || function() {
+        this.precision = [];
+        this.tq = [];
+        this.quantTables = jpeg.lossless.Utils.createArray(4, 64);
+        this.tq[0] = 0;
+        this.tq[1] = 0;
+        this.tq[2] = 0;
+        this.tq[3] = 0;
+      };
+      jpeg.lossless.QuantizationTable.enhanceQuantizationTable = function(qtab, table) {
+        var i;
+        for (i = 0; i < 8; i += 1) {
+          qtab[table[0 * 8 + i]] *= 90;
+          qtab[table[4 * 8 + i]] *= 90;
+          qtab[table[2 * 8 + i]] *= 118;
+          qtab[table[6 * 8 + i]] *= 49;
+          qtab[table[5 * 8 + i]] *= 71;
+          qtab[table[1 * 8 + i]] *= 126;
+          qtab[table[7 * 8 + i]] *= 25;
+          qtab[table[3 * 8 + i]] *= 106;
+        }
+        for (i = 0; i < 8; i += 1) {
+          qtab[table[0 + 8 * i]] *= 90;
+          qtab[table[4 + 8 * i]] *= 90;
+          qtab[table[2 + 8 * i]] *= 118;
+          qtab[table[6 + 8 * i]] *= 49;
+          qtab[table[5 + 8 * i]] *= 71;
+          qtab[table[1 + 8 * i]] *= 126;
+          qtab[table[7 + 8 * i]] *= 25;
+          qtab[table[3 + 8 * i]] *= 106;
+        }
+        for (i = 0; i < 64; i += 1) {
+          qtab[i] >>= 6;
+        }
+      };
+      jpeg.lossless.QuantizationTable.prototype.read = function(data, table) {
+        var count = 0, length, temp, t, i;
+        length = data.get16();
+        count += 2;
+        while (count < length) {
+          temp = data.get8();
+          count += 1;
+          t = temp & 15;
+          if (t > 3) {
+            throw new Error("ERROR: Quantization table ID > 3");
+          }
+          this.precision[t] = temp >> 4;
+          if (this.precision[t] === 0) {
+            this.precision[t] = 8;
+          } else if (this.precision[t] === 1) {
+            this.precision[t] = 16;
+          } else {
+            throw new Error("ERROR: Quantization table precision error");
+          }
+          this.tq[t] = 1;
+          if (this.precision[t] === 8) {
+            for (i = 0; i < 64; i += 1) {
+              if (count > length) {
+                throw new Error("ERROR: Quantization table format error");
+              }
+              this.quantTables[t][i] = data.get8();
+              count += 1;
+            }
+            jpeg.lossless.QuantizationTable.enhanceQuantizationTable(this.quantTables[t], table);
+          } else {
+            for (i = 0; i < 64; i += 1) {
+              if (count > length) {
+                throw new Error("ERROR: Quantization table format error");
+              }
+              this.quantTables[t][i] = data.get16();
+              count += 2;
+            }
+            jpeg.lossless.QuantizationTable.enhanceQuantizationTable(this.quantTables[t], table);
+          }
+        }
+        if (count !== length) {
+          throw new Error("ERROR: Quantization table error [count!=Lq]");
+        }
+        return 1;
+      };
+      var moduleType = typeof module;
+      if (moduleType !== "undefined" && module.exports) {
+        module.exports = jpeg.lossless.QuantizationTable;
+      }
     }
-
-    current = this.stream.get16();
-
-    while ((((current >> 4) !== 0x0FFC) || (current === 0xFFC4))) { // SOF 0~15
-        switch (current) {
-            case 0xFFC4: // DHT
+  });
+
+  // src/scan-component.js
+  var require_scan_component = __commonJS({
+    "src/scan-component.js"(exports, module) {
+      "use strict";
+      var jpeg = jpeg || {};
+      jpeg.lossless = jpeg.lossless || {};
+      jpeg.lossless.ScanComponent = jpeg.lossless.ScanComponent || function() {
+        this.acTabSel = 0;
+        this.dcTabSel = 0;
+        this.scanCompSel = 0;
+      };
+      var moduleType = typeof module;
+      if (moduleType !== "undefined" && module.exports) {
+        module.exports = jpeg.lossless.ScanComponent;
+      }
+    }
+  });
+
+  // src/scan-header.js
+  var require_scan_header = __commonJS({
+    "src/scan-header.js"(exports, module) {
+      "use strict";
+      var jpeg = jpeg || {};
+      jpeg.lossless = jpeg.lossless || {};
+      jpeg.lossless.DataStream = jpeg.lossless.DataStream || (typeof __require !== "undefined" ? require_data_stream() : null);
+      jpeg.lossless.ScanComponent = jpeg.lossless.ScanComponent || (typeof __require !== "undefined" ? require_scan_component() : null);
+      jpeg.lossless.ScanHeader = jpeg.lossless.ScanHeader || function() {
+        this.ah = 0;
+        this.al = 0;
+        this.numComp = 0;
+        this.selection = 0;
+        this.spectralEnd = 0;
+        this.components = [];
+      };
+      jpeg.lossless.ScanHeader.prototype.read = function(data) {
+        var count = 0, length, i, temp;
+        length = data.get16();
+        count += 2;
+        this.numComp = data.get8();
+        count += 1;
+        for (i = 0; i < this.numComp; i += 1) {
+          this.components[i] = new jpeg.lossless.ScanComponent();
+          if (count > length) {
+            throw new Error("ERROR: scan header format error");
+          }
+          this.components[i].scanCompSel = data.get8();
+          count += 1;
+          temp = data.get8();
+          count += 1;
+          this.components[i].dcTabSel = temp >> 4;
+          this.components[i].acTabSel = temp & 15;
+        }
+        this.selection = data.get8();
+        count += 1;
+        this.spectralEnd = data.get8();
+        count += 1;
+        temp = data.get8();
+        this.ah = temp >> 4;
+        this.al = temp & 15;
+        count += 1;
+        if (count !== length) {
+          throw new Error("ERROR: scan header format error [count!=Ns]");
+        }
+        return 1;
+      };
+      var moduleType = typeof module;
+      if (moduleType !== "undefined" && module.exports) {
+        module.exports = jpeg.lossless.ScanHeader;
+      }
+    }
+  });
+
+  // src/frame-header.js
+  var require_frame_header = __commonJS({
+    "src/frame-header.js"(exports, module) {
+      "use strict";
+      var jpeg = jpeg || {};
+      jpeg.lossless = jpeg.lossless || {};
+      jpeg.lossless.ComponentSpec = jpeg.lossless.ComponentSpec || (typeof __require !== "undefined" ? require_component_spec() : null);
+      jpeg.lossless.DataStream = jpeg.lossless.DataStream || (typeof __require !== "undefined" ? require_data_stream() : null);
+      jpeg.lossless.FrameHeader = jpeg.lossless.FrameHeader || function() {
+        this.components = [];
+        this.dimX = 0;
+        this.dimY = 0;
+        this.numComp = 0;
+        this.precision = 0;
+      };
+      jpeg.lossless.FrameHeader.prototype.read = function(data) {
+        var count = 0, length, i, c, temp;
+        length = data.get16();
+        count += 2;
+        this.precision = data.get8();
+        count += 1;
+        this.dimY = data.get16();
+        count += 2;
+        this.dimX = data.get16();
+        count += 2;
+        this.numComp = data.get8();
+        count += 1;
+        for (i = 1; i <= this.numComp; i += 1) {
+          if (count > length) {
+            throw new Error("ERROR: frame format error");
+          }
+          c = data.get8();
+          count += 1;
+          if (count >= length) {
+            throw new Error("ERROR: frame format error [c>=Lf]");
+          }
+          temp = data.get8();
+          count += 1;
+          if (!this.components[c]) {
+            this.components[c] = new jpeg.lossless.ComponentSpec();
+          }
+          this.components[c].hSamp = temp >> 4;
+          this.components[c].vSamp = temp & 15;
+          this.components[c].quantTableSel = data.get8();
+          count += 1;
+        }
+        if (count !== length) {
+          throw new Error("ERROR: frame format error [Lf!=count]");
+        }
+        return 1;
+      };
+      var moduleType = typeof module;
+      if (moduleType !== "undefined" && module.exports) {
+        module.exports = jpeg.lossless.FrameHeader;
+      }
+    }
+  });
+
+  // src/decoder.js
+  var require_decoder = __commonJS({
+    "src/decoder.js"(exports, module) {
+      "use strict";
+      var jpeg = jpeg || {};
+      jpeg.lossless = jpeg.lossless || {};
+      jpeg.lossless.DataStream = jpeg.lossless.DataStream || (typeof __require !== "undefined" ? require_data_stream() : null);
+      jpeg.lossless.HuffmanTable = jpeg.lossless.HuffmanTable || (typeof __require !== "undefined" ? require_huffman_table() : null);
+      jpeg.lossless.QuantizationTable = jpeg.lossless.QuantizationTable || (typeof __require !== "undefined" ? require_quantization_table() : null);
+      jpeg.lossless.ScanHeader = jpeg.lossless.ScanHeader || (typeof __require !== "undefined" ? require_scan_header() : null);
+      jpeg.lossless.FrameHeader = jpeg.lossless.FrameHeader || (typeof __require !== "undefined" ? require_frame_header() : null);
+      jpeg.lossless.Utils = jpeg.lossless.Utils || (typeof __require !== "undefined" ? require_utils() : null);
+      jpeg.lossless.Decoder = jpeg.lossless.Decoder || function(buffer, numBytes) {
+        this.buffer = buffer;
+        this.frame = new jpeg.lossless.FrameHeader();
+        this.huffTable = new jpeg.lossless.HuffmanTable();
+        this.quantTable = new jpeg.lossless.QuantizationTable();
+        this.scan = new jpeg.lossless.ScanHeader();
+        this.DU = jpeg.lossless.Utils.createArray(10, 4, 64);
+        this.HuffTab = jpeg.lossless.Utils.createArray(4, 2, 50 * 256);
+        this.IDCT_Source = [];
+        this.nBlock = [];
+        this.acTab = jpeg.lossless.Utils.createArray(10, 1);
+        this.dcTab = jpeg.lossless.Utils.createArray(10, 1);
+        this.qTab = jpeg.lossless.Utils.createArray(10, 1);
+        this.marker = 0;
+        this.markerIndex = 0;
+        this.numComp = 0;
+        this.restartInterval = 0;
+        this.selection = 0;
+        this.xDim = 0;
+        this.yDim = 0;
+        this.xLoc = 0;
+        this.yLoc = 0;
+        this.numBytes = 0;
+        this.outputData = null;
+        this.restarting = false;
+        this.mask = 0;
+        if (typeof numBytes !== "undefined") {
+          this.numBytes = numBytes;
+        }
+      };
+      jpeg.lossless.Decoder.IDCT_P = [
+        0,
+        5,
+        40,
+        16,
+        45,
+        2,
+        7,
+        42,
+        21,
+        56,
+        8,
+        61,
+        18,
+        47,
+        1,
+        4,
+        41,
+        23,
+        58,
+        13,
+        32,
+        24,
+        37,
+        10,
+        63,
+        17,
+        44,
+        3,
+        6,
+        43,
+        20,
+        57,
+        15,
+        34,
+        29,
+        48,
+        53,
+        26,
+        39,
+        9,
+        60,
+        19,
+        46,
+        22,
+        59,
+        12,
+        33,
+        31,
+        50,
+        55,
+        25,
+        36,
+        11,
+        62,
+        14,
+        35,
+        28,
+        49,
+        52,
+        27,
+        38,
+        30,
+        51,
+        54
+      ];
+      jpeg.lossless.Decoder.TABLE = [
+        0,
+        1,
+        5,
+        6,
+        14,
+        15,
+        27,
+        28,
+        2,
+        4,
+        7,
+        13,
+        16,
+        26,
+        29,
+        42,
+        3,
+        8,
+        12,
+        17,
+        25,
+        30,
+        41,
+        43,
+        9,
+        11,
+        18,
+        24,
+        31,
+        40,
+        44,
+        53,
+        10,
+        19,
+        23,
+        32,
+        39,
+        45,
+        52,
+        54,
+        20,
+        22,
+        33,
+        38,
+        46,
+        51,
+        55,
+        60,
+        21,
+        34,
+        37,
+        47,
+        50,
+        56,
+        59,
+        61,
+        35,
+        36,
+        48,
+        49,
+        57,
+        58,
+        62,
+        63
+      ];
+      jpeg.lossless.Decoder.MAX_HUFFMAN_SUBTREE = 50;
+      jpeg.lossless.Decoder.MSB = 2147483648;
+      jpeg.lossless.Decoder.RESTART_MARKER_BEGIN = 65488;
+      jpeg.lossless.Decoder.RESTART_MARKER_END = 65495;
+      jpeg.lossless.Decoder.prototype.decompress = function(buffer, offset, length) {
+        return this.decode(buffer, offset, length).buffer;
+      };
+      jpeg.lossless.Decoder.prototype.decode = function(buffer, offset, length, numBytes) {
+        var current, scanNum = 0, pred = [], i, compN, temp = [], index = [], mcuNum;
+        if (typeof buffer !== "undefined") {
+          this.buffer = buffer;
+        }
+        if (typeof numBytes !== "undefined") {
+          this.numBytes = numBytes;
+        }
+        this.stream = new jpeg.lossless.DataStream(this.buffer, offset, length);
+        this.buffer = null;
+        this.xLoc = 0;
+        this.yLoc = 0;
+        current = this.stream.get16();
+        if (current !== 65496) {
+          throw new Error("Not a JPEG file");
+        }
+        current = this.stream.get16();
+        while (current >> 4 !== 4092 || current === 65476) {
+          switch (current) {
+            case 65476:
+              this.huffTable.read(this.stream, this.HuffTab);
+              break;
+            case 65484:
+              throw new Error("Program doesn't support arithmetic coding. (format throw new IOException)");
+            case 65499:
+              this.quantTable.read(this.stream, jpeg.lossless.Decoder.TABLE);
+              break;
+            case 65501:
+              this.restartInterval = this.readNumber();
+              break;
+            case 65504:
+            case 65505:
+            case 65506:
+            case 65507:
+            case 65508:
+            case 65509:
+            case 65510:
+            case 65511:
+            case 65512:
+            case 65513:
+            case 65514:
+            case 65515:
+            case 65516:
+            case 65517:
+            case 65518:
+            case 65519:
+              this.readApp();
+              break;
+            case 65534:
+              this.readComment();
+              break;
+            default:
+              if (current >> 8 !== 255) {
+                throw new Error("ERROR: format throw new IOException! (decode)");
+              }
+          }
+          current = this.stream.get16();
+        }
+        if (current < 65472 || current > 65479) {
+          throw new Error("ERROR: could not handle arithmetic code!");
+        }
+        this.frame.read(this.stream);
+        current = this.stream.get16();
+        do {
+          while (current !== 65498) {
+            switch (current) {
+              case 65476:
                 this.huffTable.read(this.stream, this.HuffTab);
                 break;
-            case 0xFFCC: // DAC
+              case 65484:
                 throw new Error("Program doesn't support arithmetic coding. (format throw new IOException)");
-            case 0xFFDB:
+              case 65499:
                 this.quantTable.read(this.stream, jpeg.lossless.Decoder.TABLE);
                 break;
-            case 0xFFDD:
+              case 65501:
                 this.restartInterval = this.readNumber();
                 break;
-            case 0xFFE0:
-            case 0xFFE1:
-            case 0xFFE2:
-            case 0xFFE3:
-            case 0xFFE4:
-            case 0xFFE5:
-            case 0xFFE6:
-            case 0xFFE7:
-            case 0xFFE8:
-            case 0xFFE9:
-            case 0xFFEA:
-            case 0xFFEB:
-            case 0xFFEC:
-            case 0xFFED:
-            case 0xFFEE:
-            case 0xFFEF:
+              case 65504:
+              case 65505:
+              case 65506:
+              case 65507:
+              case 65508:
+              case 65509:
+              case 65510:
+              case 65511:
+              case 65512:
+              case 65513:
+              case 65514:
+              case 65515:
+              case 65516:
+              case 65517:
+              case 65518:
+              case 65519:
                 this.readApp();
                 break;
-            case 0xFFFE:
+              case 65534:
                 this.readComment();
                 break;
-            default:
-                if ((current >> 8) !== 0xFF) {
-                    throw new Error("ERROR: format throw new IOException! (decode)");
+              default:
+                if (current >> 8 !== 255) {
+                  throw new Error("ERROR: format throw new IOException! (Parser.decode)");
                 }
-        }
-
-        current = this.stream.get16();
-    }
-
-    if ((current < 0xFFC0) || (current > 0xFFC7)) {
-        throw new Error("ERROR: could not handle arithmetic code!");
-    }
-
-    this.frame.read(this.stream);
-    current = this.stream.get16();
-
-    do {
-        while (current !== 0x0FFDA) { // SOS
-            switch (current) {
-                case 0xFFC4: // DHT
-                    this.huffTable.read(this.stream, this.HuffTab);
-                    break;
-                case 0xFFCC: // DAC
-                    throw new Error("Program doesn't support arithmetic coding. (format throw new IOException)");
-                case 0xFFDB:
-                    this.quantTable.read(this.stream, jpeg.lossless.Decoder.TABLE);
-                    break;
-                case 0xFFDD:
-                    this.restartInterval = this.readNumber();
-                    break;
-                case 0xFFE0:
-                case 0xFFE1:
-                case 0xFFE2:
-                case 0xFFE3:
-                case 0xFFE4:
-                case 0xFFE5:
-                case 0xFFE6:
-                case 0xFFE7:
-                case 0xFFE8:
-                case 0xFFE9:
-                case 0xFFEA:
-                case 0xFFEB:
-                case 0xFFEC:
-                case 0xFFED:
-                case 0xFFEE:
-                case 0xFFEF:
-                    this.readApp();
-                    break;
-                case 0xFFFE:
-                    this.readComment();
-                    break;
-                default:
-                    if ((current >> 8) !== 0xFF) {
-                        throw new Error("ERROR: format throw new IOException! (Parser.decode)");
-                    }
             }
-
             current = this.stream.get16();
-        }
-
-        this.precision = this.frame.precision;
-        this.components = this.frame.components;
-
-        if (!this.numBytes) {
+          }
+          this.precision = this.frame.precision;
+          this.components = this.frame.components;
+          if (!this.numBytes) {
             this.numBytes = parseInt(Math.ceil(this.precision / 8));
-        }
-
-        if (this.numBytes == 1) {
-            this.mask = 0xFF;
-        } else {
-            this.mask = 0xFFFF;
-        }
-
-        this.scan.read(this.stream);
-        this.numComp = this.scan.numComp;
-        this.selection = this.scan.selection;
-
-        if (this.numBytes === 1) {
+          }
+          if (this.numBytes == 1) {
+            this.mask = 255;
+          } else {
+            this.mask = 65535;
+          }
+          this.scan.read(this.stream);
+          this.numComp = this.scan.numComp;
+          this.selection = this.scan.selection;
+          if (this.numBytes === 1) {
             if (this.numComp === 3) {
-                this.getter = this.getValueRGB;
-                this.setter = this.setValueRGB;
-                this.output = this.outputRGB;
+              this.getter = this.getValueRGB;
+              this.setter = this.setValueRGB;
+              this.output = this.outputRGB;
             } else {
-                this.getter = this.getValue8;
-                this.setter = this.setValue8;
-                this.output = this.outputSingle;
+              this.getter = this.getValue8;
+              this.setter = this.setValue8;
+              this.output = this.outputSingle;
             }
-        } else {
+          } else {
             this.getter = this.getValue16;
             this.setter = this.setValue16;
             this.output = this.outputSingle;
-        }
-
-        switch (this.selection) {
+          }
+          switch (this.selection) {
             case 2:
-                this.selector = this.select2;
-                break;
+              this.selector = this.select2;
+              break;
             case 3:
-                this.selector = this.select3;
-                break;
+              this.selector = this.select3;
+              break;
             case 4:
-                this.selector = this.select4;
-                break;
+              this.selector = this.select4;
+              break;
             case 5:
-                this.selector = this.select5;
-                break;
+              this.selector = this.select5;
+              break;
             case 6:
-                this.selector = this.select6;
-                break;
+              this.selector = this.select6;
+              break;
             case 7:
-                this.selector = this.select7;
-                break;
+              this.selector = this.select7;
+              break;
             default:
-                this.selector = this.select1;
-                break;
-        }
-
-        this.scanComps = this.scan.components;
-        this.quantTables = this.quantTable.quantTables;
-
-        for (i = 0; i < this.numComp; i+=1) {
+              this.selector = this.select1;
+              break;
+          }
+          this.scanComps = this.scan.components;
+          this.quantTables = this.quantTable.quantTables;
+          for (i = 0; i < this.numComp; i += 1) {
             compN = this.scanComps[i].scanCompSel;
             this.qTab[i] = this.quantTables[this.components[compN].quantTableSel];
             this.nBlock[i] = this.components[compN].vSamp * this.components[compN].hSamp;
             this.dcTab[i] = this.HuffTab[this.scanComps[i].dcTabSel][0];
             this.acTab[i] = this.HuffTab[this.scanComps[i].acTabSel][1];
-        }
-
-        this.xDim = this.frame.dimX;
-        this.yDim = this.frame.dimY;
-        if (this.numBytes == 1) {
+          }
+          this.xDim = this.frame.dimX;
+          this.yDim = this.frame.dimY;
+          if (this.numBytes == 1) {
             this.outputData = new Uint8Array(new ArrayBuffer(this.xDim * this.yDim * this.numBytes * this.numComp));
-        } else {
+          } else {
             this.outputData = new Uint16Array(new ArrayBuffer(this.xDim * this.yDim * this.numBytes * this.numComp));
-        }
-
-        scanNum+=1;
-
-        while (true) { // Decode one scan
+          }
+          scanNum += 1;
+          while (true) {
             temp[0] = 0;
             index[0] = 0;
-
-            for (i = 0; i < 10; i+=1) {
-                pred[i] = (1 << (this.precision - 1));
+            for (i = 0; i < 10; i += 1) {
+              pred[i] = 1 << this.precision - 1;
             }
-
             if (this.restartInterval === 0) {
+              current = this.decodeUnit(pred, temp, index);
+              while (current === 0 && (this.xLoc < this.xDim && this.yLoc < this.yDim)) {
+                this.output(pred);
                 current = this.decodeUnit(pred, temp, index);
-
-                while ((current === 0) && ((this.xLoc < this.xDim) && (this.yLoc < this.yDim))) {
-                    this.output(pred);
-                    current = this.decodeUnit(pred, temp, index);
-                }
-
-                break; //current=MARKER
+              }
+              break;
             }
-
-            for (mcuNum = 0; mcuNum < this.restartInterval; mcuNum+=1) {
-                this.restarting = (mcuNum == 0);
-                current = this.decodeUnit(pred, temp, index);
-                this.output(pred);
-
-                if (current !== 0) {
-                    break;
-                }
+            for (mcuNum = 0; mcuNum < this.restartInterval; mcuNum += 1) {
+              this.restarting = mcuNum == 0;
+              current = this.decodeUnit(pred, temp, index);
+              this.output(pred);
+              if (current !== 0) {
+                break;
+              }
             }
-
             if (current === 0) {
-                if (this.markerIndex !== 0) {
-                    current = (0xFF00 | this.marker);
-                    this.markerIndex = 0;
-                } else {
-                    current = this.stream.get16();
-                }
+              if (this.markerIndex !== 0) {
+                current = 65280 | this.marker;
+                this.markerIndex = 0;
+              } else {
+                current = this.stream.get16();
+              }
             }
-
-            if (!((current >= jpeg.lossless.Decoder.RESTART_MARKER_BEGIN) &&
-                (current <= jpeg.lossless.Decoder.RESTART_MARKER_END))) {
-                break; //current=MARKER
+            if (!(current >= jpeg.lossless.Decoder.RESTART_MARKER_BEGIN && current <= jpeg.lossless.Decoder.RESTART_MARKER_END)) {
+              break;
             }
-        }
-
-        if ((current === 0xFFDC) && (scanNum === 1)) { //DNL
+          }
+          if (current === 65500 && scanNum === 1) {
             this.readNumber();
             current = this.stream.get16();
+          }
+        } while (current !== 65497 && (this.xLoc < this.xDim && this.yLoc < this.yDim) && scanNum === 0);
+        return this.outputData;
+      };
+      jpeg.lossless.Decoder.prototype.decodeUnit = function(prev, temp, index) {
+        if (this.numComp == 1) {
+          return this.decodeSingle(prev, temp, index);
+        } else if (this.numComp == 3) {
+          return this.decodeRGB(prev, temp, index);
+        } else {
+          return -1;
         }
-    } while ((current !== 0xFFD9) && ((this.xLoc < this.xDim) && (this.yLoc < this.yDim)) && (scanNum === 0));
-
-    return this.outputData;
-};
-
-
-
-jpeg.lossless.Decoder.prototype.decodeUnit = function (prev, temp, index) {
-    if (this.numComp == 1) {
-        return this.decodeSingle(prev, temp, index);
-    } else if (this.numComp == 3) {
-        return this.decodeRGB(prev, temp, index);
-    } else {
-        return -1;
-    }
-};
-
-
-
-jpeg.lossless.Decoder.prototype.select1 = function (compOffset) {
-    return this.getPreviousX(compOffset);
-};
-
-
-
-jpeg.lossless.Decoder.prototype.select2 = function (compOffset) {
-    return this.getPreviousY(compOffset);
-};
-
-
-
-jpeg.lossless.Decoder.prototype.select3 = function (compOffset) {
-    return this.getPreviousXY(compOffset);
-};
-
-
-
-jpeg.lossless.Decoder.prototype.select4 = function (compOffset) {
-    return (this.getPreviousX(compOffset) + this.getPreviousY(compOffset)) - this.getPreviousXY(compOffset);
-};
-
-
-
-jpeg.lossless.Decoder.prototype.select5 = function (compOffset) {
-    return this.getPreviousX(compOffset) + ((this.getPreviousY(compOffset) - this.getPreviousXY(compOffset)) >> 1);
-};
-
-
-
-jpeg.lossless.Decoder.prototype.select6 = function (compOffset) {
-    return this.getPreviousY(compOffset) + ((this.getPreviousX(compOffset) - this.getPreviousXY(compOffset)) >> 1);
-};
-
-
-
-jpeg.lossless.Decoder.prototype.select7 = function (compOffset) {
-    return ((this.getPreviousX(compOffset) + this.getPreviousY(compOffset)) / 2);
-};
-
-
-
-jpeg.lossless.Decoder.prototype.decodeRGB = function (prev, temp, index) {
-    /*jslint bitwise: true */
-
-    var value, actab, dctab, qtab, ctrC, i, k, j;
-
-    prev[0] = this.selector(0);
-    prev[1] = this.selector(1);
-    prev[2] = this.selector(2);
-
-    for (ctrC = 0; ctrC < this.numComp; ctrC+=1) {
-        qtab = this.qTab[ctrC];
-        actab = this.acTab[ctrC];
-        dctab = this.dcTab[ctrC];
-        for (i = 0; i < this.nBlock[ctrC]; i+=1) {
-            for (k = 0; k < this.IDCT_Source.length; k+=1) {
-                this.IDCT_Source[k] = 0;
+      };
+      jpeg.lossless.Decoder.prototype.select1 = function(compOffset) {
+        return this.getPreviousX(compOffset);
+      };
+      jpeg.lossless.Decoder.prototype.select2 = function(compOffset) {
+        return this.getPreviousY(compOffset);
+      };
+      jpeg.lossless.Decoder.prototype.select3 = function(compOffset) {
+        return this.getPreviousXY(compOffset);
+      };
+      jpeg.lossless.Decoder.prototype.select4 = function(compOffset) {
+        return this.getPreviousX(compOffset) + this.getPreviousY(compOffset) - this.getPreviousXY(compOffset);
+      };
+      jpeg.lossless.Decoder.prototype.select5 = function(compOffset) {
+        return this.getPreviousX(compOffset) + (this.getPreviousY(compOffset) - this.getPreviousXY(compOffset) >> 1);
+      };
+      jpeg.lossless.Decoder.prototype.select6 = function(compOffset) {
+        return this.getPreviousY(compOffset) + (this.getPreviousX(compOffset) - this.getPreviousXY(compOffset) >> 1);
+      };
+      jpeg.lossless.Decoder.prototype.select7 = function(compOffset) {
+        return (this.getPreviousX(compOffset) + this.getPreviousY(compOffset)) / 2;
+      };
+      jpeg.lossless.Decoder.prototype.decodeRGB = function(prev, temp, index) {
+        var value, actab, dctab, qtab, ctrC, i, k, j;
+        prev[0] = this.selector(0);
+        prev[1] = this.selector(1);
+        prev[2] = this.selector(2);
+        for (ctrC = 0; ctrC < this.numComp; ctrC += 1) {
+          qtab = this.qTab[ctrC];
+          actab = this.acTab[ctrC];
+          dctab = this.dcTab[ctrC];
+          for (i = 0; i < this.nBlock[ctrC]; i += 1) {
+            for (k = 0; k < this.IDCT_Source.length; k += 1) {
+              this.IDCT_Source[k] = 0;
             }
-
             value = this.getHuffmanValue(dctab, temp, index);
-
-            if (value >= 0xFF00) {
-                return value;
+            if (value >= 65280) {
+              return value;
             }
-
             prev[ctrC] = this.IDCT_Source[0] = prev[ctrC] + this.getn(index, value, temp, index);
             this.IDCT_Source[0] *= qtab[0];
-
-            for (j = 1; j < 64; j+=1) {
-                value = this.getHuffmanValue(actab, temp, index);
-
-                if (value >= 0xFF00) {
-                    return value;
-                }
-
-                j += (value >> 4);
-
-                if ((value & 0x0F) === 0) {
-                    if ((value >> 4) === 0) {
-                        break;
-                    }
-                } else {
-                    this.IDCT_Source[jpeg.lossless.Decoder.IDCT_P[j]] = this.getn(index, value & 0x0F, temp, index) * qtab[j];
+            for (j = 1; j < 64; j += 1) {
+              value = this.getHuffmanValue(actab, temp, index);
+              if (value >= 65280) {
+                return value;
+              }
+              j += value >> 4;
+              if ((value & 15) === 0) {
+                if (value >> 4 === 0) {
+                  break;
                 }
+              } else {
+                this.IDCT_Source[jpeg.lossless.Decoder.IDCT_P[j]] = this.getn(index, value & 15, temp, index) * qtab[j];
+              }
             }
+          }
         }
-    }
-
-    return 0;
-};
-
-
-
-jpeg.lossless.Decoder.prototype.decodeSingle = function (prev, temp, index) {
-    /*jslint bitwise: true */
-
-    var value, i, n, nRestart;
-
-    if (this.restarting) {
-        this.restarting = false;
-        prev[0] = (1 << (this.frame.precision - 1));
-    } else {
-        prev[0] = this.selector();
-    }
-
-    for (i = 0; i < this.nBlock[0]; i+=1) {
-        value = this.getHuffmanValue(this.dcTab[0], temp, index);
-        if (value >= 0xFF00) {
-            return value;
+        return 0;
+      };
+      jpeg.lossless.Decoder.prototype.decodeSingle = function(prev, temp, index) {
+        var value, i, n, nRestart;
+        if (this.restarting) {
+          this.restarting = false;
+          prev[0] = 1 << this.frame.precision - 1;
+        } else {
+          prev[0] = this.selector();
         }
-
-        n = this.getn(prev, value, temp, index);
-        nRestart = (n >> 8);
-
-        if ((nRestart >= jpeg.lossless.Decoder.RESTART_MARKER_BEGIN) && (nRestart <= jpeg.lossless.Decoder.RESTART_MARKER_END)) {
+        for (i = 0; i < this.nBlock[0]; i += 1) {
+          value = this.getHuffmanValue(this.dcTab[0], temp, index);
+          if (value >= 65280) {
+            return value;
+          }
+          n = this.getn(prev, value, temp, index);
+          nRestart = n >> 8;
+          if (nRestart >= jpeg.lossless.Decoder.RESTART_MARKER_BEGIN && nRestart <= jpeg.lossless.Decoder.RESTART_MARKER_END) {
             return nRestart;
+          }
+          prev[0] += n;
         }
-
-        prev[0] += n;
-    }
-
-    return 0;
-};
-
-
-
-//	Huffman table for fast search: (HuffTab) 8-bit Look up table 2-layer search architecture, 1st-layer represent 256 node (8 bits) if codeword-length > 8
-//	bits, then the entry of 1st-layer = (# of 2nd-layer table) | MSB and it is stored in the 2nd-layer Size of tables in each layer are 256.
-//	HuffTab[*][*][0-256] is always the only 1st-layer table.
-//
-//	An entry can be: (1) (# of 2nd-layer table) | MSB , for code length > 8 in 1st-layer (2) (Code length) << 8 | HuffVal
-//
-//	HuffmanValue(table   HuffTab[x][y] (ex) HuffmanValue(HuffTab[1][0],...)
-//	                ):
-//	    return: Huffman Value of table
-//	            0xFF?? if it receives a MARKER
-//	    Parameter:  table   HuffTab[x][y] (ex) HuffmanValue(HuffTab[1][0],...)
-//	                temp    temp storage for remainded bits
-//	                index   index to bit of temp
-//	                in      FILE pointer
-//	    Effect:
-//	        temp  store new remainded bits
-//	        index change to new index
-//	        in    change to new position
-//	    NOTE:
-//	      Initial by   temp=0; index=0;
-//	    NOTE: (explain temp and index)
-//	      temp: is always in the form at calling time or returning time
-//	       |  byte 4  |  byte 3  |  byte 2  |  byte 1  |
-//	       |     0    |     0    | 00000000 | 00000??? |  if not a MARKER
-//	                                               ^index=3 (from 0 to 15)
-//	                                               321
-//	    NOTE (marker and marker_index):
-//	      If get a MARKER from 'in', marker=the low-byte of the MARKER
-//	        and marker_index=9
-//	      If marker_index=9 then index is always > 8, or HuffmanValue()
-//	        will not be called
-jpeg.lossless.Decoder.prototype.getHuffmanValue = function (table, temp, index) {
-    /*jslint bitwise: true */
-
-    var code, input, mask;
-    mask = 0xFFFF;
-
-    if (index[0] < 8) {
-        temp[0] <<= 8;
-        input = this.stream.get8();
-        if (input === 0xFF) {
+        return 0;
+      };
+      jpeg.lossless.Decoder.prototype.getHuffmanValue = function(table, temp, index) {
+        var code, input, mask;
+        mask = 65535;
+        if (index[0] < 8) {
+          temp[0] <<= 8;
+          input = this.stream.get8();
+          if (input === 255) {
             this.marker = this.stream.get8();
             if (this.marker !== 0) {
-                this.markerIndex = 9;
+              this.markerIndex = 9;
             }
+          }
+          temp[0] |= input;
+        } else {
+          index[0] -= 8;
         }
-        temp[0] |= input;
-    } else {
-        index[0] -= 8;
-    }
-
-    code = table[temp[0] >> index[0]];
-
-    if ((code & jpeg.lossless.Decoder.MSB) !== 0) {
-        if (this.markerIndex !== 0) {
+        code = table[temp[0] >> index[0]];
+        if ((code & jpeg.lossless.Decoder.MSB) !== 0) {
+          if (this.markerIndex !== 0) {
             this.markerIndex = 0;
-            return 0xFF00 | this.marker;
-        }
-
-        temp[0] &= (mask >> (16 - index[0]));
-        temp[0] <<= 8;
-        input = this.stream.get8();
-
-        if (input === 0xFF) {
+            return 65280 | this.marker;
+          }
+          temp[0] &= mask >> 16 - index[0];
+          temp[0] <<= 8;
+          input = this.stream.get8();
+          if (input === 255) {
             this.marker = this.stream.get8();
             if (this.marker !== 0) {
-                this.markerIndex = 9;
+              this.markerIndex = 9;
             }
+          }
+          temp[0] |= input;
+          code = table[(code & 255) * 256 + (temp[0] >> index[0])];
+          index[0] += 8;
         }
-
-        temp[0] |= input;
-        code = table[((code & 0xFF) * 256) + (temp[0] >> index[0])];
-        index[0] += 8;
-    }
-
-    index[0] += 8 - (code >> 8);
-
-    if (index[0] < 0) {
-        throw new Error("index=" + index[0] + " temp=" + temp[0] + " code=" + code + " in HuffmanValue()");
-    }
-
-    if (index[0] < this.markerIndex) {
-        this.markerIndex = 0;
-        return 0xFF00 | this.marker;
-    }
-
-    temp[0] &= (mask >> (16 - index[0]));
-    return code & 0xFF;
-};
-
-
-
-jpeg.lossless.Decoder.prototype.getn = function (PRED, n, temp, index) {
-    /*jslint bitwise: true */
-
-    var result, one, n_one, mask, input;
-    one = 1;
-    n_one = -1;
-    mask = 0xFFFF;
-
-    if (n === 0) {
-        return 0;
-    }
-
-    if (n === 16) {
-        if (PRED[0] >= 0) {
+        index[0] += 8 - (code >> 8);
+        if (index[0] < 0) {
+          throw new Error("index=" + index[0] + " temp=" + temp[0] + " code=" + code + " in HuffmanValue()");
+        }
+        if (index[0] < this.markerIndex) {
+          this.markerIndex = 0;
+          return 65280 | this.marker;
+        }
+        temp[0] &= mask >> 16 - index[0];
+        return code & 255;
+      };
+      jpeg.lossless.Decoder.prototype.getn = function(PRED, n, temp, index) {
+        var result, one, n_one, mask, input;
+        one = 1;
+        n_one = -1;
+        mask = 65535;
+        if (n === 0) {
+          return 0;
+        }
+        if (n === 16) {
+          if (PRED[0] >= 0) {
             return -32768;
-        } else {
+          } else {
             return 32768;
+          }
         }
-    }
-
-    index[0] -= n;
-
-    if (index[0] >= 0) {
-        if ((index[0] < this.markerIndex) && !this.isLastPixel()) { // this was corrupting the last pixel in some cases
+        index[0] -= n;
+        if (index[0] >= 0) {
+          if (index[0] < this.markerIndex && !this.isLastPixel()) {
             this.markerIndex = 0;
-            return (0xFF00 | this.marker) << 8;
-        }
-
-        result = temp[0] >> index[0];
-        temp[0] &= (mask >> (16 - index[0]));
-    } else {
-        temp[0] <<= 8;
-        input = this.stream.get8();
-
-        if (input === 0xFF) {
+            return (65280 | this.marker) << 8;
+          }
+          result = temp[0] >> index[0];
+          temp[0] &= mask >> 16 - index[0];
+        } else {
+          temp[0] <<= 8;
+          input = this.stream.get8();
+          if (input === 255) {
             this.marker = this.stream.get8();
             if (this.marker !== 0) {
-                this.markerIndex = 9;
+              this.markerIndex = 9;
             }
-        }
-
-        temp[0] |= input;
-        index[0] += 8;
-
-        if (index[0] < 0) {
+          }
+          temp[0] |= input;
+          index[0] += 8;
+          if (index[0] < 0) {
             if (this.markerIndex !== 0) {
-                this.markerIndex = 0;
-                return (0xFF00 | this.marker) << 8;
+              this.markerIndex = 0;
+              return (65280 | this.marker) << 8;
             }
-
             temp[0] <<= 8;
             input = this.stream.get8();
-
-            if (input === 0xFF) {
-                this.marker = this.stream.get8();
-                if (this.marker !== 0) {
-                    this.markerIndex = 9;
-                }
+            if (input === 255) {
+              this.marker = this.stream.get8();
+              if (this.marker !== 0) {
+                this.markerIndex = 9;
+              }
             }
-
             temp[0] |= input;
             index[0] += 8;
-        }
-
-        if (index[0] < 0) {
+          }
+          if (index[0] < 0) {
             throw new Error("index=" + index[0] + " in getn()");
-        }
-
-        if (index[0] < this.markerIndex) {
+          }
+          if (index[0] < this.markerIndex) {
             this.markerIndex = 0;
-            return (0xFF00 | this.marker) << 8;
+            return (65280 | this.marker) << 8;
+          }
+          result = temp[0] >> index[0];
+          temp[0] &= mask >> 16 - index[0];
         }
-
-        result = temp[0] >> index[0];
-        temp[0] &= (mask >> (16 - index[0]));
-    }
-
-    if (result < (one << (n - 1))) {
-        result += (n_one << n) + 1;
-    }
-
-    return result;
-};
-
-
-
-jpeg.lossless.Decoder.prototype.getPreviousX = function (compOffset) {
-    /*jslint bitwise: true */
-
-    if (this.xLoc > 0) {
-        return this.getter((((this.yLoc * this.xDim) + this.xLoc) - 1), compOffset);
-    } else if (this.yLoc > 0) {
-        return this.getPreviousY(compOffset);
-    } else {
-        return (1 << (this.frame.precision - 1));
-    }
-};
-
-
-
-jpeg.lossless.Decoder.prototype.getPreviousXY = function (compOffset) {
-    /*jslint bitwise: true */
-
-    if ((this.xLoc > 0) && (this.yLoc > 0)) {
-        return this.getter(((((this.yLoc - 1) * this.xDim) + this.xLoc) - 1), compOffset);
-    } else {
-        return this.getPreviousY(compOffset);
-    }
-};
-
-
-
-jpeg.lossless.Decoder.prototype.getPreviousY = function (compOffset) {
-    /*jslint bitwise: true */
-
-    if (this.yLoc > 0) {
-        return this.getter((((this.yLoc - 1) * this.xDim) + this.xLoc), compOffset);
-    } else {
-        return this.getPreviousX(compOffset);
-    }
-};
-
-
-
-jpeg.lossless.Decoder.prototype.isLastPixel = function () {
-    return (this.xLoc === (this.xDim - 1)) && (this.yLoc === (this.yDim - 1));
-};
-
-
-
-jpeg.lossless.Decoder.prototype.outputSingle = function (PRED) {
-    if ((this.xLoc < this.xDim) && (this.yLoc < this.yDim)) {
-        this.setter((((this.yLoc * this.xDim) + this.xLoc)), this.mask & PRED[0]);
-
-        this.xLoc+=1;
-
-        if (this.xLoc >= this.xDim) {
-            this.yLoc+=1;
-            this.xLoc = 0;
+        if (result < one << n - 1) {
+          result += (n_one << n) + 1;
         }
-    }
-};
-
-
-
-jpeg.lossless.Decoder.prototype.outputRGB = function (PRED) {
-    var offset = ((this.yLoc * this.xDim) + this.xLoc);
-
-    if ((this.xLoc < this.xDim) && (this.yLoc < this.yDim)) {
-        this.setter(offset, PRED[0], 0);
-        this.setter(offset, PRED[1], 1);
-        this.setter(offset, PRED[2], 2);
-
-        this.xLoc+=1;
-
-        if (this.xLoc >= this.xDim) {
-            this.yLoc+=1;
-            this.xLoc = 0;
+        return result;
+      };
+      jpeg.lossless.Decoder.prototype.getPreviousX = function(compOffset) {
+        if (this.xLoc > 0) {
+          return this.getter(this.yLoc * this.xDim + this.xLoc - 1, compOffset);
+        } else if (this.yLoc > 0) {
+          return this.getPreviousY(compOffset);
+        } else {
+          return 1 << this.frame.precision - 1;
         }
-    }
-};
-
-jpeg.lossless.Decoder.prototype.setValue8 = function (index, val) {
-    this.outputData[index] = val; 
-};
-
-jpeg.lossless.Decoder.prototype.getValue8 = function (index) {
-    return this.outputData[index]; // mask should not be necessary because outputData is either Int8Array or Int16Array
-};
-
-var littleEndian = (function() {
-    var buffer = new ArrayBuffer(2);
-    new DataView(buffer).setInt16(0, 256, true /* littleEndian */);
-    // Int16Array uses the platform's endianness.
-    return new Int16Array(buffer)[0] === 256;
-})();
-
-if (littleEndian) {
-    // just reading from an array is fine then. Int16Array will use platform endianness.
-    jpeg.lossless.Decoder.prototype.setValue16 = jpeg.lossless.Decoder.prototype.setValue8; 
-    jpeg.lossless.Decoder.prototype.getValue16 = jpeg.lossless.Decoder.prototype.getValue8;
-} 
-else {
-    // If platform is big-endian, we will need to convert to little-endian 
-    jpeg.lossless.Decoder.prototype.setValue16 = function (index, val) {
-        this.outputData[index] = ((val & 0xFF) << 8) | ((val >> 8) & 0xFF); 
-    };
-
-    jpeg.lossless.Decoder.prototype.getValue16 = function (index) {
-        var val = this.outputData[index];
-        return ((val & 0xFF) << 8) | ((val >> 8) & 0xFF);
-    };
-}
-
-jpeg.lossless.Decoder.prototype.setValueRGB = function (index, val, compOffset) {
-    // this.outputData.setUint8(index * 3 + compOffset, val);
-    this.outputData[index * 3 + compOffset] = val;
-};
-
-jpeg.lossless.Decoder.prototype.getValueRGB = function (index, compOffset) {
-    // return this.outputData.getUint8(index * 3 + compOffset);
-    return this.outputData[index * 3 + compOffset];
-};
-
-
-
-jpeg.lossless.Decoder.prototype.readApp = function() {
-    var count = 0, length = this.stream.get16();
-    count += 2;
-
-    while (count < length) {
-        this.stream.get8();
-        count+=1;
-    }
-
-    return length;
-};
-
-
-
-jpeg.lossless.Decoder.prototype.readComment = function () {
-    var sb = "", count = 0, length;
-
-    length = this.stream.get16();
-    count += 2;
-
-    while (count < length) {
-        sb += this.stream.get8();
-        count+=1;
-    }
-
-    return sb;
-};
-
-
-
-jpeg.lossless.Decoder.prototype.readNumber = function() {
-    var Ld = this.stream.get16();
-
-    if (Ld !== 4) {
-        throw new Error("ERROR: Define number format throw new IOException [Ld!=4]");
-    }
-
-    return this.stream.get16();
-};
-
-
-
-/*** Exports ***/
-
-var moduleType = typeof module;
-if ((moduleType !== 'undefined') && module.exports) {
-    module.exports = jpeg.lossless.Decoder;
-}
-
-},{"./data-stream.js":2,"./frame-header.js":4,"./huffman-table.js":5,"./quantization-table.js":7,"./scan-header.js":9,"./utils.js":10}],4:[function(require,module,exports){
-/*
- * Copyright (C) 2015 Michael Martinez
- * Changes: Added support for selection values 2-7, fixed minor bugs &
- * warnings, split into multiple class files, and general clean up.
- *
- * 08-25-2015: Helmut Dersch agreed to a license change from LGPL to MIT.
- */
-
-/*
- * Copyright (C) Helmut Dersch
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
-
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
-
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-/*jslint browser: true, node: true */
-/*global require, module */
-
-"use strict";
-
-/*** Imports ***/
-var jpeg = jpeg || {};
-jpeg.lossless = jpeg.lossless || {};
-jpeg.lossless.ComponentSpec = jpeg.lossless.ComponentSpec || ((typeof require !== 'undefined') ? require('./component-spec.js') : null);
-jpeg.lossless.DataStream = jpeg.lossless.DataStream || ((typeof require !== 'undefined') ? require('./data-stream.js') : null);
-
-
-/*** Constructor ***/
-jpeg.lossless.FrameHeader = jpeg.lossless.FrameHeader || function () {
-    this.components = []; // Components
-    this.dimX = 0; // Number of samples per line
-    this.dimY = 0; // Number of lines
-    this.numComp = 0; // Number of component in the frame
-    this.precision = 0; // Sample Precision (from the original image)
-};
-
-
-
-/*** Prototype Methods ***/
-
-jpeg.lossless.FrameHeader.prototype.read = function (data) {
-    /*jslint bitwise: true */
-
-    var count = 0, length, i, c, temp;
-
-    length = data.get16();
-    count += 2;
-
-    this.precision = data.get8();
-    count+=1;
-
-    this.dimY = data.get16();
-    count += 2;
-
-    this.dimX = data.get16();
-    count += 2;
-
-    this.numComp = data.get8();
-    count+=1;
-    for (i = 1; i <= this.numComp; i+=1) {
-        if (count > length) {
-            throw new Error("ERROR: frame format error");
-        }
-
-        c = data.get8();
-        count+=1;
-
-        if (count >= length) {
-            throw new Error("ERROR: frame format error [c>=Lf]");
-        }
-
-        temp = data.get8();
-        count+=1;
-
-        if (!this.components[c]) {
-            this.components[c] = new jpeg.lossless.ComponentSpec();
-        }
-
-        this.components[c].hSamp = temp >> 4;
-        this.components[c].vSamp = temp & 0x0F;
-        this.components[c].quantTableSel = data.get8();
-        count+=1;
-    }
-
-    if (count !== length) {
-        throw new Error("ERROR: frame format error [Lf!=count]");
-    }
-
-    return 1;
-};
-
-
-/*** Exports ***/
-
-var moduleType = typeof module;
-if ((moduleType !== 'undefined') && module.exports) {
-    module.exports = jpeg.lossless.FrameHeader;
-}
-
-},{"./component-spec.js":1,"./data-stream.js":2}],5:[function(require,module,exports){
-/*
- * Copyright (C) 2015 Michael Martinez
- * Changes: Added support for selection values 2-7, fixed minor bugs &
- * warnings, split into multiple class files, and general clean up.
- *
- * 08-25-2015: Helmut Dersch agreed to a license change from LGPL to MIT.
- */
-
-/*
- * Copyright (C) Helmut Dersch
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
-
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
-
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-/*jslint browser: true, node: true */
-/*global require, module */
-
-"use strict";
-
-/*** Imports ***/
-var jpeg = jpeg || {};
-jpeg.lossless = jpeg.lossless || {};
-jpeg.lossless.DataStream = jpeg.lossless.DataStream || ((typeof require !== 'undefined') ? require('./data-stream.js') : null);
-jpeg.lossless.Utils = jpeg.lossless.Utils || ((typeof require !== 'undefined') ? require('./utils.js') : null);
-
-
-/*** Constructor ***/
-jpeg.lossless.HuffmanTable = jpeg.lossless.HuffmanTable || function () {
-    this.l = jpeg.lossless.Utils.createArray(4, 2, 16);
-    this.th = [];
-    this.v = jpeg.lossless.Utils.createArray(4, 2, 16, 200);
-    this.tc = jpeg.lossless.Utils.createArray(4, 2);
-
-    this.tc[0][0] = 0;
-    this.tc[1][0] = 0;
-    this.tc[2][0] = 0;
-    this.tc[3][0] = 0;
-    this.tc[0][1] = 0;
-    this.tc[1][1] = 0;
-    this.tc[2][1] = 0;
-    this.tc[3][1] = 0;
-    this.th[0] = 0;
-    this.th[1] = 0;
-    this.th[2] = 0;
-    this.th[3] = 0;
-};
-
-
-
-/*** Static Pseudo-constants ***/
-
-jpeg.lossless.HuffmanTable.MSB = 0x80000000;
-
-
-/*** Prototype Methods ***/
-
-jpeg.lossless.HuffmanTable.prototype.read = function(data, HuffTab) {
-    /*jslint bitwise: true */
-
-    var count = 0, length, temp, t, c, i, j;
-
-    length = data.get16();
-    count += 2;
-
-    while (count < length) {
-        temp = data.get8();
-        count+=1;
-        t = temp & 0x0F;
-        if (t > 3) {
-            throw new Error("ERROR: Huffman table ID > 3");
-        }
-
-        c = temp >> 4;
-        if (c > 2) {
-            throw new Error("ERROR: Huffman table [Table class > 2 ]");
-        }
-
-        this.th[t] = 1;
-        this.tc[t][c] = 1;
-
-        for (i = 0; i < 16; i+=1) {
-            this.l[t][c][i] = data.get8();
-            count+=1;
-        }
-
-        for (i = 0; i < 16; i+=1) {
-            for (j = 0; j < this.l[t][c][i]; j+=1) {
-                if (count > length) {
-                    throw new Error("ERROR: Huffman table format error [count>Lh]");
-                }
-
-                this.v[t][c][i][j] = data.get8();
-                count+=1;
-            }
-        }
-    }
-
-    if (count !== length) {
-        throw new Error("ERROR: Huffman table format error [count!=Lf]");
-    }
-
-    for (i = 0; i < 4; i+=1) {
-        for (j = 0; j < 2; j+=1) {
-            if (this.tc[i][j] !== 0) {
-                this.buildHuffTable(HuffTab[i][j], this.l[i][j], this.v[i][j]);
-            }
-        }
-    }
-
-    return 1;
-};
-
-
-
-//	Build_HuffTab()
-//	Parameter:  t       table ID
-//	            c       table class ( 0 for DC, 1 for AC )
-//	            L[i]    # of codewords which length is i
-//	            V[i][j] Huffman Value (length=i)
-//	Effect:
-//	    build up HuffTab[t][c] using L and V.
-jpeg.lossless.HuffmanTable.prototype.buildHuffTable = function(tab, L, V) {
-    /*jslint bitwise: true */
-
-    var currentTable, temp, k, i, j, n;
-    temp = 256;
-    k = 0;
-
-    for (i = 0; i < 8; i+=1) { // i+1 is Code length
-        for (j = 0; j < L[i]; j+=1) {
-            for (n = 0; n < (temp >> (i + 1)); n+=1) {
-                tab[k] = V[i][j] | ((i + 1) << 8);
-                k+=1;
-            }
+      };
+      jpeg.lossless.Decoder.prototype.getPreviousXY = function(compOffset) {
+        if (this.xLoc > 0 && this.yLoc > 0) {
+          return this.getter((this.yLoc - 1) * this.xDim + this.xLoc - 1, compOffset);
+        } else {
+          return this.getPreviousY(compOffset);
         }
-    }
-
-    for (i = 1; k < 256; i+=1, k+=1) {
-        tab[k] = i | jpeg.lossless.HuffmanTable.MSB;
-    }
-
-    currentTable = 1;
-    k = 0;
-
-    for (i = 8; i < 16; i+=1) { // i+1 is Code length
-        for (j = 0; j < L[i]; j+=1) {
-            for (n = 0; n < (temp >> (i - 7)); n+=1) {
-                tab[(currentTable * 256) + k] = V[i][j] | ((i + 1) << 8);
-                k+=1;
-            }
-
-            if (k >= 256) {
-                if (k > 256) {
-                    throw new Error("ERROR: Huffman table error(1)!");
-                }
-
-                k = 0;
-                currentTable+=1;
-            }
+      };
+      jpeg.lossless.Decoder.prototype.getPreviousY = function(compOffset) {
+        if (this.yLoc > 0) {
+          return this.getter((this.yLoc - 1) * this.xDim + this.xLoc, compOffset);
+        } else {
+          return this.getPreviousX(compOffset);
         }
-    }
-};
-
-
-/*** Exports ***/
-
-var moduleType = typeof module;
-if ((moduleType !== 'undefined') && module.exports) {
-    module.exports = jpeg.lossless.HuffmanTable;
-}
-
-},{"./data-stream.js":2,"./utils.js":10}],6:[function(require,module,exports){
-/*jslint browser: true, node: true */
-/*global require, module */
-
-"use strict";
-
-/*** Imports ****/
-
-/**
- * jpeg
-  * @type {*|{}}
- */
-var jpeg = jpeg || {};
-
-/**
- * jpeg.lossless
- * @type {*|{}}
- */
-jpeg.lossless = jpeg.lossless || {};
-
-
-jpeg.lossless.ComponentSpec = jpeg.lossless.ComponentSpec || ((typeof require !== 'undefined') ? require('./component-spec.js') : null);
-jpeg.lossless.DataStream = jpeg.lossless.DataStream || ((typeof require !== 'undefined') ? require('./data-stream.js') : null);
-jpeg.lossless.Decoder = jpeg.lossless.Decoder || ((typeof require !== 'undefined') ? require('./decoder.js') : null);
-jpeg.lossless.FrameHeader = jpeg.lossless.FrameHeader || ((typeof require !== 'undefined') ? require('./frame-header.js') : null);
-jpeg.lossless.HuffmanTable = jpeg.lossless.HuffmanTable || ((typeof require !== 'undefined') ? require('./huffman-table.js') : null);
-jpeg.lossless.QuantizationTable = jpeg.lossless.QuantizationTable || ((typeof require !== 'undefined') ? require('./quantization-table.js') : null);
-jpeg.lossless.ScanComponent = jpeg.lossless.ScanComponent || ((typeof require !== 'undefined') ? require('./scan-component.js') : null);
-jpeg.lossless.ScanHeader = jpeg.lossless.ScanHeader || ((typeof require !== 'undefined') ? require('./scan-header.js') : null);
-jpeg.lossless.Utils = jpeg.lossless.Utils || ((typeof require !== 'undefined') ? require('./utils.js') : null);
-
-
-/*** Exports ***/
-var moduleType = typeof module;
-if ((moduleType !== 'undefined') && module.exports) {
-    module.exports = jpeg;
-}
-
-},{"./component-spec.js":1,"./data-stream.js":2,"./decoder.js":3,"./frame-header.js":4,"./huffman-table.js":5,"./quantization-table.js":7,"./scan-component.js":8,"./scan-header.js":9,"./utils.js":10}],7:[function(require,module,exports){
-/*
- * Copyright (C) 2015 Michael Martinez
- * Changes: Added support for selection values 2-7, fixed minor bugs &
- * warnings, split into multiple class files, and general clean up.
- *
- * 08-25-2015: Helmut Dersch agreed to a license change from LGPL to MIT.
- */
-
-/*
- * Copyright (C) Helmut Dersch
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
-
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
-
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-/*jslint browser: true, node: true */
-/*global require, module */
-
-"use strict";
-
-/*** Imports ***/
-var jpeg = jpeg || {};
-jpeg.lossless = jpeg.lossless || {};
-jpeg.lossless.DataStream = jpeg.lossless.DataStream || ((typeof require !== 'undefined') ? require('./data-stream.js') : null);
-jpeg.lossless.Utils = jpeg.lossless.Utils || ((typeof require !== 'undefined') ? require('./utils.js') : null);
-
-
-/*** Constructor ***/
-jpeg.lossless.QuantizationTable = jpeg.lossless.QuantizationTable || function () {
-    this.precision = []; // Quantization precision 8 or 16
-    this.tq = []; // 1: this table is presented
-    this.quantTables = jpeg.lossless.Utils.createArray(4, 64); // Tables
-
-    this.tq[0] = 0;
-    this.tq[1] = 0;
-    this.tq[2] = 0;
-    this.tq[3] = 0;
-};
-
-
-
-/*** Static Methods ***/
-
-jpeg.lossless.QuantizationTable.enhanceQuantizationTable = function(qtab, table) {
-    /*jslint bitwise: true */
-
-    var i;
-
-    for (i = 0; i < 8; i+=1) {
-        qtab[table[(0 * 8) + i]] *= 90;
-        qtab[table[(4 * 8) + i]] *= 90;
-        qtab[table[(2 * 8) + i]] *= 118;
-        qtab[table[(6 * 8) + i]] *= 49;
-        qtab[table[(5 * 8) + i]] *= 71;
-        qtab[table[(1 * 8) + i]] *= 126;
-        qtab[table[(7 * 8) + i]] *= 25;
-        qtab[table[(3 * 8) + i]] *= 106;
-    }
-
-    for (i = 0; i < 8; i+=1) {
-        qtab[table[0 + (8 * i)]] *= 90;
-        qtab[table[4 + (8 * i)]] *= 90;
-        qtab[table[2 + (8 * i)]] *= 118;
-        qtab[table[6 + (8 * i)]] *= 49;
-        qtab[table[5 + (8 * i)]] *= 71;
-        qtab[table[1 + (8 * i)]] *= 126;
-        qtab[table[7 + (8 * i)]] *= 25;
-        qtab[table[3 + (8 * i)]] *= 106;
-    }
-
-    for (i = 0; i < 64; i+=1) {
-        qtab[i] >>= 6;
-    }
-};
-
-
-/*** Prototype Methods ***/
-
-jpeg.lossless.QuantizationTable.prototype.read = function (data, table) {
-    /*jslint bitwise: true */
-
-    var count = 0, length, temp, t, i;
-
-    length = data.get16();
-    count += 2;
-
-    while (count < length) {
-        temp = data.get8();
-        count+=1;
-        t = temp & 0x0F;
-
-        if (t > 3) {
-            throw new Error("ERROR: Quantization table ID > 3");
+      };
+      jpeg.lossless.Decoder.prototype.isLastPixel = function() {
+        return this.xLoc === this.xDim - 1 && this.yLoc === this.yDim - 1;
+      };
+      jpeg.lossless.Decoder.prototype.outputSingle = function(PRED) {
+        if (this.xLoc < this.xDim && this.yLoc < this.yDim) {
+          this.setter(this.yLoc * this.xDim + this.xLoc, this.mask & PRED[0]);
+          this.xLoc += 1;
+          if (this.xLoc >= this.xDim) {
+            this.yLoc += 1;
+            this.xLoc = 0;
+          }
         }
-
-        this.precision[t] = temp >> 4;
-
-        if (this.precision[t] === 0) {
-            this.precision[t] = 8;
-        } else if (this.precision[t] === 1) {
-            this.precision[t] = 16;
-        } else {
-            throw new Error("ERROR: Quantization table precision error");
+      };
+      jpeg.lossless.Decoder.prototype.outputRGB = function(PRED) {
+        var offset = this.yLoc * this.xDim + this.xLoc;
+        if (this.xLoc < this.xDim && this.yLoc < this.yDim) {
+          this.setter(offset, PRED[0], 0);
+          this.setter(offset, PRED[1], 1);
+          this.setter(offset, PRED[2], 2);
+          this.xLoc += 1;
+          if (this.xLoc >= this.xDim) {
+            this.yLoc += 1;
+            this.xLoc = 0;
+          }
         }
-
-        this.tq[t] = 1;
-
-        if (this.precision[t] === 8) {
-            for (i = 0; i < 64; i+=1) {
-                if (count > length) {
-                    throw new Error("ERROR: Quantization table format error");
-                }
-
-                this.quantTables[t][i] = data.get8();
-                count+=1;
-            }
-
-            jpeg.lossless.QuantizationTable.enhanceQuantizationTable(this.quantTables[t], table);
-        } else {
-            for (i = 0; i < 64; i+=1) {
-                if (count > length) {
-                    throw new Error("ERROR: Quantization table format error");
-                }
-
-                this.quantTables[t][i] = data.get16();
-                count += 2;
-            }
-
-            jpeg.lossless.QuantizationTable.enhanceQuantizationTable(this.quantTables[t], table);
+      };
+      jpeg.lossless.Decoder.prototype.setValue8 = function(index, val) {
+        this.outputData[index] = val;
+      };
+      jpeg.lossless.Decoder.prototype.getValue8 = function(index) {
+        return this.outputData[index];
+      };
+      var littleEndian = function() {
+        var buffer = new ArrayBuffer(2);
+        new DataView(buffer).setInt16(
+          0,
+          256,
+          true
+          /* littleEndian */
+        );
+        return new Int16Array(buffer)[0] === 256;
+      }();
+      if (littleEndian) {
+        jpeg.lossless.Decoder.prototype.setValue16 = jpeg.lossless.Decoder.prototype.setValue8;
+        jpeg.lossless.Decoder.prototype.getValue16 = jpeg.lossless.Decoder.prototype.getValue8;
+      } else {
+        jpeg.lossless.Decoder.prototype.setValue16 = function(index, val) {
+          this.outputData[index] = (val & 255) << 8 | val >> 8 & 255;
+        };
+        jpeg.lossless.Decoder.prototype.getValue16 = function(index) {
+          var val = this.outputData[index];
+          return (val & 255) << 8 | val >> 8 & 255;
+        };
+      }
+      jpeg.lossless.Decoder.prototype.setValueRGB = function(index, val, compOffset) {
+        this.outputData[index * 3 + compOffset] = val;
+      };
+      jpeg.lossless.Decoder.prototype.getValueRGB = function(index, compOffset) {
+        return this.outputData[index * 3 + compOffset];
+      };
+      jpeg.lossless.Decoder.prototype.readApp = function() {
+        var count = 0, length = this.stream.get16();
+        count += 2;
+        while (count < length) {
+          this.stream.get8();
+          count += 1;
         }
-    }
-
-    if (count !== length) {
-        throw new Error("ERROR: Quantization table error [count!=Lq]");
-    }
-
-    return 1;
-};
-
-
-
-/*** Exports ***/
-
-var moduleType = typeof module;
-if ((moduleType !== 'undefined') && module.exports) {
-    module.exports = jpeg.lossless.QuantizationTable;
-}
-
-},{"./data-stream.js":2,"./utils.js":10}],8:[function(require,module,exports){
-/*
- * Copyright (C) 2015 Michael Martinez
- * Changes: Added support for selection values 2-7, fixed minor bugs &
- * warnings, split into multiple class files, and general clean up.
- *
- * 08-25-2015: Helmut Dersch agreed to a license change from LGPL to MIT.
- */
-
-/*
- * Copyright (C) Helmut Dersch
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
-
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
-
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-/*jslint browser: true, node: true */
-/*global require, module */
-
-"use strict";
-
-/*** Imports ***/
-var jpeg = jpeg || {};
-jpeg.lossless = jpeg.lossless || {};
-
-
-/*** Constructor ***/
-jpeg.lossless.ScanComponent = jpeg.lossless.ScanComponent || function () {
-    this.acTabSel = 0; // AC table selector
-    this.dcTabSel = 0; // DC table selector
-    this.scanCompSel = 0; // Scan component selector
-};
-
-
-
-/*** Exports ***/
-
-var moduleType = typeof module;
-if ((moduleType !== 'undefined') && module.exports) {
-    module.exports = jpeg.lossless.ScanComponent;
-}
-
-},{}],9:[function(require,module,exports){
-/*
- * Copyright (C) 2015 Michael Martinez
- * Changes: Added support for selection values 2-7, fixed minor bugs &
- * warnings, split into multiple class files, and general clean up.
- *
- * 08-25-2015: Helmut Dersch agreed to a license change from LGPL to MIT.
- */
-
-/*
- * Copyright (C) Helmut Dersch
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
-
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
-
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-/*jslint browser: true, node: true */
-/*global require, module */
-
-"use strict";
-
-/*** Imports ***/
-var jpeg = jpeg || {};
-jpeg.lossless = jpeg.lossless || {};
-jpeg.lossless.DataStream = jpeg.lossless.DataStream || ((typeof require !== 'undefined') ? require('./data-stream.js') : null);
-jpeg.lossless.ScanComponent = jpeg.lossless.ScanComponent || ((typeof require !== 'undefined') ? require('./scan-component.js') : null);
-
-
-/*** Constructor ***/
-jpeg.lossless.ScanHeader = jpeg.lossless.ScanHeader || function () {
-    this.ah = 0;
-    this.al = 0;
-    this.numComp = 0; // Number of components in the scan
-    this.selection = 0; // Start of spectral or predictor selection
-    this.spectralEnd = 0; // End of spectral selection
-    this.components = [];
-};
-
-
-/*** Prototype Methods ***/
-
-jpeg.lossless.ScanHeader.prototype.read = function(data) {
-    /*jslint bitwise: true */
-
-    var count = 0, length, i, temp;
-
-    length = data.get16();
-    count += 2;
-
-    this.numComp = data.get8();
-    count+=1;
-
-    for (i = 0; i < this.numComp; i+=1) {
-        this.components[i] = new jpeg.lossless.ScanComponent();
-
-        if (count > length) {
-            throw new Error("ERROR: scan header format error");
+        return length;
+      };
+      jpeg.lossless.Decoder.prototype.readComment = function() {
+        var sb = "", count = 0, length;
+        length = this.stream.get16();
+        count += 2;
+        while (count < length) {
+          sb += this.stream.get8();
+          count += 1;
         }
-
-        this.components[i].scanCompSel = data.get8();
-        count+=1;
-
-        temp = data.get8();
-        count+=1;
-
-        this.components[i].dcTabSel = (temp >> 4);
-        this.components[i].acTabSel = (temp & 0x0F);
-    }
-
-    this.selection = data.get8();
-    count+=1;
-
-    this.spectralEnd = data.get8();
-    count+=1;
-
-    temp = data.get8();
-    this.ah = (temp >> 4);
-    this.al = (temp & 0x0F);
-    count+=1;
-
-    if (count !== length) {
-        throw new Error("ERROR: scan header format error [count!=Ns]");
-    }
-
-    return 1;
-};
-
-
-
-/*** Exports ***/
-
-var moduleType = typeof module;
-if ((moduleType !== 'undefined') && module.exports) {
-    module.exports = jpeg.lossless.ScanHeader;
-}
-
-},{"./data-stream.js":2,"./scan-component.js":8}],10:[function(require,module,exports){
-/*
- * Copyright (C) 2015 Michael Martinez
- * Changes: Added support for selection values 2-7, fixed minor bugs &
- * warnings, split into multiple class files, and general clean up.
- *
- * 08-25-2015: Helmut Dersch agreed to a license change from LGPL to MIT.
- */
-
-/*
- * Copyright (C) Helmut Dersch
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
-
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
-
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-/*jslint browser: true, node: true */
-/*global require, module */
-
-"use strict";
-
-/*** Imports ***/
-var jpeg = jpeg || {};
-jpeg.lossless = jpeg.lossless || {};
-
-
-/*** Constructor ***/
-jpeg.lossless.Utils = jpeg.lossless.Utils || {};
-
-
-/*** Static methods ***/
-
-// http://stackoverflow.com/questions/966225/how-can-i-create-a-two-dimensional-array-in-javascript
-jpeg.lossless.Utils.createArray = function (length) {
-    var arr = new Array(length || 0),
-        i = length;
-
-    if (arguments.length > 1) {
-        var args = Array.prototype.slice.call(arguments, 1);
-        while(i--) arr[length-1 - i] = jpeg.lossless.Utils.createArray.apply(this, args);
-    }
-
-    return arr;
-};
-
-
-// http://stackoverflow.com/questions/18638900/javascript-crc32
-jpeg.lossless.Utils.makeCRCTable = function(){
-    var c;
-    var crcTable = [];
-    for(var n =0; n < 256; n++){
-        c = n;
-        for(var k =0; k < 8; k++){
-            c = ((c&1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
+        return sb;
+      };
+      jpeg.lossless.Decoder.prototype.readNumber = function() {
+        var Ld = this.stream.get16();
+        if (Ld !== 4) {
+          throw new Error("ERROR: Define number format throw new IOException [Ld!=4]");
         }
-        crcTable[n] = c;
+        return this.stream.get16();
+      };
+      var moduleType = typeof module;
+      if (moduleType !== "undefined" && module.exports) {
+        module.exports = jpeg.lossless.Decoder;
+      }
     }
-    return crcTable;
-};
-
-jpeg.lossless.Utils.crc32 = function(dataView) {
-    var uint8view = new Uint8Array(dataView.buffer);
-    var crcTable = jpeg.lossless.Utils.crcTable || (jpeg.lossless.Utils.crcTable = jpeg.lossless.Utils.makeCRCTable());
-    var crc = 0 ^ (-1);
-
-    for (var i = 0; i < uint8view.length; i++ ) {
-        crc = (crc >>> 8) ^ crcTable[(crc ^ uint8view[i]) & 0xFF];
+  });
+
+  // src/main.js
+  var require_main = __commonJS({
+    "src/main.js"(exports, module) {
+      var jpeg = jpeg || {};
+      jpeg.lossless = jpeg.lossless || {};
+      jpeg.lossless.ComponentSpec = jpeg.lossless.ComponentSpec || (typeof __require !== "undefined" ? require_component_spec() : null);
+      jpeg.lossless.DataStream = jpeg.lossless.DataStream || (typeof __require !== "undefined" ? require_data_stream() : null);
+      jpeg.lossless.Decoder = jpeg.lossless.Decoder || (typeof __require !== "undefined" ? require_decoder() : null);
+      jpeg.lossless.FrameHeader = jpeg.lossless.FrameHeader || (typeof __require !== "undefined" ? require_frame_header() : null);
+      jpeg.lossless.HuffmanTable = jpeg.lossless.HuffmanTable || (typeof __require !== "undefined" ? require_huffman_table() : null);
+      jpeg.lossless.QuantizationTable = jpeg.lossless.QuantizationTable || (typeof __require !== "undefined" ? require_quantization_table() : null);
+      jpeg.lossless.ScanComponent = jpeg.lossless.ScanComponent || (typeof __require !== "undefined" ? require_scan_component() : null);
+      jpeg.lossless.ScanHeader = jpeg.lossless.ScanHeader || (typeof __require !== "undefined" ? require_scan_header() : null);
+      jpeg.lossless.Utils = jpeg.lossless.Utils || (typeof __require !== "undefined" ? require_utils() : null);
+      var moduleType = typeof module;
+      if (moduleType !== "undefined" && module.exports) {
+        module.exports = jpeg;
+      }
     }
-
-    return (crc ^ (-1)) >>> 0;
-};
-
-
-/*** Exports ***/
-
-var moduleType = typeof module;
-if ((moduleType !== 'undefined') && module.exports) {
-    module.exports = jpeg.lossless.Utils;
-}
-
-},{}]},{},[6])(6)
-});
+  });
+  require_main();
+})();
 
 
 /***/ }),
@@ -6952,7 +6383,7 @@ if ((moduleType !== 'undefined') && module.exports) {
 /***/ ((module) => {
 
 "use strict";
-module.exports = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("lib/jquery");
+module.exports = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("lib/jquery");
 
 /***/ }),
 
@@ -7056,25 +6487,25 @@ var __webpack_exports__ = {};
 // UNUSED EXPORTS: default
 
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components\")"
-const Components_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("x_ite/Components");
+const Components_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("x_ite/Components");
 var Components_default = /*#__PURE__*/__webpack_require__.n(Components_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Fields\")"
-const Fields_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("x_ite/Fields");
+const Fields_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("x_ite/Fields");
 var Fields_default = /*#__PURE__*/__webpack_require__.n(Fields_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Base/X3DFieldDefinition\")"
-const X3DFieldDefinition_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("x_ite/Base/X3DFieldDefinition");
+const X3DFieldDefinition_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("x_ite/Base/X3DFieldDefinition");
 var X3DFieldDefinition_default = /*#__PURE__*/__webpack_require__.n(X3DFieldDefinition_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Base/FieldDefinitionArray\")"
-const FieldDefinitionArray_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("x_ite/Base/FieldDefinitionArray");
+const FieldDefinitionArray_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("x_ite/Base/FieldDefinitionArray");
 var FieldDefinitionArray_default = /*#__PURE__*/__webpack_require__.n(FieldDefinitionArray_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components/Texturing/X3DSingleTextureNode\")"
-const X3DSingleTextureNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("x_ite/Components/Texturing/X3DSingleTextureNode");
+const X3DSingleTextureNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("x_ite/Components/Texturing/X3DSingleTextureNode");
 var X3DSingleTextureNode_default = /*#__PURE__*/__webpack_require__.n(X3DSingleTextureNode_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Base/X3DConstants\")"
-const X3DConstants_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("x_ite/Base/X3DConstants");
+const X3DConstants_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("x_ite/Base/X3DConstants");
 var X3DConstants_default = /*#__PURE__*/__webpack_require__.n(X3DConstants_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Namespace\")"
-const Namespace_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("x_ite/Namespace");
+const Namespace_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("x_ite/Namespace");
 var Namespace_default = /*#__PURE__*/__webpack_require__.n(Namespace_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Components/Texturing3D/X3DTexture3DNode.js
 /*******************************************************************************
@@ -7242,7 +6673,7 @@ const __default__ = X3DTexture3DNode;
 Namespace_default().set ("x_ite/Components/Texturing3D/X3DTexture3DNode", __default__);
 /* harmony default export */ const Texturing3D_X3DTexture3DNode = (__default__);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Base/X3DCast\")"
-const X3DCast_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("x_ite/Base/X3DCast");
+const X3DCast_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("x_ite/Base/X3DCast");
 var X3DCast_default = /*#__PURE__*/__webpack_require__.n(X3DCast_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Components/Texturing3D/ComposedTexture3D.js
 /*******************************************************************************
@@ -7440,10 +6871,10 @@ const ComposedTexture3D_default_ = ComposedTexture3D;
 Namespace_default().set ("x_ite/Components/Texturing3D/ComposedTexture3D", ComposedTexture3D_default_);
 /* harmony default export */ const Texturing3D_ComposedTexture3D = (ComposedTexture3D_default_);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components/Networking/X3DUrlObject\")"
-const X3DUrlObject_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("x_ite/Components/Networking/X3DUrlObject");
+const X3DUrlObject_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("x_ite/Components/Networking/X3DUrlObject");
 var X3DUrlObject_default = /*#__PURE__*/__webpack_require__.n(X3DUrlObject_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Parser/Expressions\")"
-const Expressions_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("x_ite/Parser/Expressions");
+const Expressions_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("x_ite/Parser/Expressions");
 var Expressions_default = /*#__PURE__*/__webpack_require__.n(Expressions_namespaceObject);
 // EXTERNAL MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"lib/jquery\")"
 var jquery_ = __webpack_require__(355);
@@ -7912,11 +7343,11 @@ const NRRDParser_default_ = NRRDParser;
 Namespace_default().set ("x_ite/Browser/Texturing3D/NRRDParser", NRRDParser_default_);
 /* harmony default export */ const Texturing3D_NRRDParser = (NRRDParser_default_);
 ;// CONCATENATED MODULE: ./src/x_ite/Browser/Texturing3D/DICOMParser.js
-/* provided dependency */ var dicomParser = __webpack_require__(62);
-/* provided dependency */ var JpegImage = __webpack_require__(963);
-/* provided dependency */ var jpeg = __webpack_require__(767);
-/* provided dependency */ var CharLS = __webpack_require__(109);
-/* provided dependency */ var OpenJPEG = __webpack_require__(256);
+/* provided dependency */ var dicomParser = __webpack_require__(615);
+/* provided dependency */ var JpegImage = __webpack_require__(622);
+/* provided dependency */ var jpeg = __webpack_require__(782);
+/* provided dependency */ var CharLS = __webpack_require__(990);
+/* provided dependency */ var OpenJPEG = __webpack_require__(881);
 /*******************************************************************************
  *
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
@@ -9019,7 +8450,7 @@ const DICOMParser_default_ = DicomParser;
 Namespace_default().set ("x_ite/Browser/Texturing3D/DICOMParser", DICOMParser_default_);
 /* harmony default export */ const DICOMParser = (DICOMParser_default_);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/InputOutput/FileLoader\")"
-const FileLoader_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("x_ite/InputOutput/FileLoader");
+const FileLoader_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("x_ite/InputOutput/FileLoader");
 var FileLoader_default = /*#__PURE__*/__webpack_require__.n(FileLoader_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Components/Texturing3D/ImageTexture3D.js
 /*******************************************************************************
@@ -9199,7 +8630,7 @@ const ImageTexture3D_default_ = ImageTexture3D;
 Namespace_default().set ("x_ite/Components/Texturing3D/ImageTexture3D", ImageTexture3D_default_);
 /* harmony default export */ const Texturing3D_ImageTexture3D = (ImageTexture3D_default_);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/DEBUG\")"
-const DEBUG_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("x_ite/DEBUG");
+const DEBUG_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("x_ite/DEBUG");
 var DEBUG_default = /*#__PURE__*/__webpack_require__.n(DEBUG_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Components/Texturing3D/ImageTextureAtlas.js
 /* provided dependency */ var $ = __webpack_require__(355);
@@ -9657,10 +9088,10 @@ const PixelTexture3D_default_ = PixelTexture3D;
 Namespace_default().set ("x_ite/Components/Texturing3D/PixelTexture3D", PixelTexture3D_default_);
 /* harmony default export */ const Texturing3D_PixelTexture3D = (PixelTexture3D_default_);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components/Texturing/X3DSingleTextureCoordinateNode\")"
-const X3DSingleTextureCoordinateNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("x_ite/Components/Texturing/X3DSingleTextureCoordinateNode");
+const X3DSingleTextureCoordinateNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("x_ite/Components/Texturing/X3DSingleTextureCoordinateNode");
 var X3DSingleTextureCoordinateNode_default = /*#__PURE__*/__webpack_require__.n(X3DSingleTextureCoordinateNode_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"standard/Math/Numbers/Vector4\")"
-const Vector4_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("standard/Math/Numbers/Vector4");
+const Vector4_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("standard/Math/Numbers/Vector4");
 ;// CONCATENATED MODULE: ./src/x_ite/Components/Texturing3D/TextureCoordinate3D.js
 /*******************************************************************************
  *
@@ -10008,16 +9439,16 @@ const TextureCoordinate4D_default_ = TextureCoordinate4D;
 Namespace_default().set ("x_ite/Components/Texturing3D/TextureCoordinate4D", TextureCoordinate4D_default_);
 /* harmony default export */ const Texturing3D_TextureCoordinate4D = (TextureCoordinate4D_default_);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components/Texturing/X3DSingleTextureTransformNode\")"
-const X3DSingleTextureTransformNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("x_ite/Components/Texturing/X3DSingleTextureTransformNode");
+const X3DSingleTextureTransformNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("x_ite/Components/Texturing/X3DSingleTextureTransformNode");
 var X3DSingleTextureTransformNode_default = /*#__PURE__*/__webpack_require__.n(X3DSingleTextureTransformNode_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"standard/Math/Numbers/Vector3\")"
-const Vector3_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("standard/Math/Numbers/Vector3");
+const Vector3_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("standard/Math/Numbers/Vector3");
 var Vector3_default = /*#__PURE__*/__webpack_require__.n(Vector3_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"standard/Math/Numbers/Rotation4\")"
-const Rotation4_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("standard/Math/Numbers/Rotation4");
+const Rotation4_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("standard/Math/Numbers/Rotation4");
 var Rotation4_default = /*#__PURE__*/__webpack_require__.n(Rotation4_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"standard/Math/Numbers/Matrix4\")"
-const Matrix4_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.6.24")] .require ("standard/Math/Numbers/Matrix4");
+const Matrix4_namespaceObject = window [Symbol .for ("X_ITE.X3D-8.7.0")] .require ("standard/Math/Numbers/Matrix4");
 var Matrix4_default = /*#__PURE__*/__webpack_require__.n(Matrix4_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Components/Texturing3D/TextureTransform3D.js
 /*******************************************************************************