x_ite 9.4.4 → 9.5.0

package/dist/assets/components/Texturing3D.js

@@ -1,7 +1,7 @@
-/* X_ITE v9.4.4 */(() => { // webpackBootstrap
+/* X_ITE v9.5.0 */(() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 544:
+/***/ 470:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 var __dirname = "/";
@@ -38,7 +38,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,
 
 /***/ }),
 
-/***/ 154:
+/***/ 976:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 var __dirname = "/";
@@ -72,7 +72,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,
 
 /***/ }),
 
-/***/ 706:
+/***/ 44:
 /***/ (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 +4028,7 @@ module.exports = __WEBPACK_EXTERNAL_MODULE_zlib__;
 
 /***/ }),
 
-/***/ 306:
+/***/ 80:
 /***/ ((module) => {
 
 /* -*- tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- /
@@ -5183,2774 +5183,2161 @@ function decode(jpegData, userOpts = {}) {
 
 /***/ }),
 
-/***/ 490:
+/***/ 823:
 /***/ ((module) => {
 
-(function(f){if(true){module.exports=f()}else { var g; }})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=undefined;if(!f&&c)return require(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=undefined,i=0;i<t.length;i++)o(t[i]);return o}return r})()({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";
+module.exports = window [Symbol .for ("X_ITE.X3D-9.5.0")] .require ("lib/jquery");
 
-/*** Imports ***/
-var jpeg = jpeg || {};
-jpeg.lossless = jpeg.lossless || {};
+/***/ }),
 
+/***/ 497:
+/***/ (() => {
 
-/*** 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
-};
+/* (ignored) */
 
+/***/ }),
 
-/*** Exports ***/
+/***/ 13:
+/***/ (() => {
 
-var moduleType = typeof module;
-if ((moduleType !== 'undefined') && module.exports) {
-    module.exports = jpeg.lossless.ComponentSpec;
-}
+/* (ignored) */
 
-},{}],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.
- */
+/***/ 722:
+/***/ (() => {
 
-/*jslint browser: true, node: true */
-/*global require, module */
+/* (ignored) */
 
-"use strict";
+/***/ }),
 
-/*** Imports ***/
-var jpeg = jpeg || {};
-jpeg.lossless = jpeg.lossless || {};
+/***/ 978:
+/***/ (() => {
 
+/* (ignored) */
 
-/*** 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);
-    }
-    this.index = 0;
-};
+/***/ }),
 
+/***/ 559:
+/***/ (() => {
 
+/* (ignored) */
 
-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;
-};
+/***/ })
 
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	(() => {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = (module) => {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				() => (module['default']) :
+/******/ 				() => (module);
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be in strict mode.
+(() => {
+"use strict";
 
+// UNUSED EXPORTS: default
 
-jpeg.lossless.DataStream.prototype.get8 = function () {
-    // var value = this.buffer.getUint8(this.index);
-    var value = this.buffer[this.index];
-    this.index += 1;
-    return value;
-};
+;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/Components\")"
+const Components_namespaceObject = window [Symbol .for ("X_ITE.X3D-9.5.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-9.5.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-9.5.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-9.5.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-9.5.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-9.5.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-9.5.0")] .require ("x_ite/Namespace");
+var Namespace_default = /*#__PURE__*/__webpack_require__.n(Namespace_namespaceObject);
+;// CONCATENATED MODULE: ./src/x_ite/Components/Texturing3D/X3DTexture3DNode.js
+/*******************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright create3000, Scheffelstraße 31a, Leipzig, Germany 2011 - 2022.
+ *
+ * All rights reserved. Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * The copyright notice above does not evidence any actual of intended
+ * publication of such source code, and is an unpublished work by create3000.
+ * This material contains CONFIDENTIAL INFORMATION that is the property of
+ * create3000.
+ *
+ * No permission is granted to copy, distribute, or create derivative works from
+ * the contents of this software, in whole or in part, without the prior written
+ * permission of create3000.
+ *
+ * NON-MILITARY USE ONLY
+ *
+ * All create3000 software are effectively free software with a non-military use
+ * restriction. It is free. Well commented source is provided. You may reuse the
+ * source in any way you please with the exception anything that uses it must be
+ * marked to indicate is contains 'non-military use only' components.
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2011 - 2022, Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * This file is part of the X_ITE Project.
+ *
+ * X_ITE is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License version 3 only, as published by the
+ * Free Software Foundation.
+ *
+ * X_ITE is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License version 3 for more
+ * details (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version 3
+ * along with X_ITE.  If not, see <https://www.gnu.org/licenses/gpl.html> for a
+ * copy of the GPLv3 License.
+ *
+ * For Silvio, Joy and Adi.
+ *
+ ******************************************************************************/
 
 
-/*** 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.
- */
+const defaultData = new Uint8Array ([ 255, 255, 255, 255 ]);
 
-/*
- * 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.
- */
+function X3DTexture3DNode (executionContext)
+{
+   X3DSingleTextureNode_default().call (this, executionContext);
 
-/*jslint browser: true, node: true */
-/*global require, module */
+   this .addType ((X3DConstants_default()).X3DTexture3DNode);
 
-"use strict";
+   const gl = this .getBrowser () .getContext ();
 
-/*** 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);
+   this .target = gl .TEXTURE_3D;
+   this .width  = 0;
+   this .height = 0;
+   this .depth  = 0;
+}
 
+Object .assign (Object .setPrototypeOf (X3DTexture3DNode .prototype, (X3DSingleTextureNode_default()).prototype),
+{
+   initialize ()
+   {
+      X3DSingleTextureNode_default().prototype .initialize .call (this);
 
-/*** Constructor ***/
+      this ._repeatS .addInterest ("updateTextureParameters", this);
+      this ._repeatT .addInterest ("updateTextureParameters", this);
+      this ._repeatR .addInterest ("updateTextureParameters", this);
 
-/**
- * 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;
+      const gl = this .getBrowser () .getContext ();
 
-    if (typeof numBytes !== "undefined") {
-        this.numBytes = numBytes;
-    }
-};
+      if (gl .getVersion () < 2)
+         return;
 
+      gl .bindTexture (gl .TEXTURE_3D, this .getTexture ());
+      gl .texImage3D  (gl .TEXTURE_3D, 0, gl .RGBA, 1, 1, 1, 0, gl .RGBA, gl .UNSIGNED_BYTE, defaultData);
+   },
+   getTarget ()
+   {
+      return this .target;
+   },
+   getTextureType ()
+   {
+      return 3;
+   },
+   getWidth ()
+   {
+      return this .width;
+   },
+   setWidth (value)
+   {
+      this .width = value;
+   },
+   getHeight ()
+   {
+      return this .height;
+   },
+   setHeight (value)
+   {
+      this .height = value;
+   },
+   getDepth ()
+   {
+      return this .depth;
+   },
+   setDepth (value)
+   {
+      this .depth = value;
+   },
+   clearTexture ()
+   {
+      const gl = this .getBrowser () .getContext ();
 
-/*** Static Pseudo-constants ***/
+      this .setTextureFromData (1, 1, 1, false, gl .RGBA, defaultData);
+   },
+   setTextureFromData (width, height, depth, transparent, format, data)
+   {
+      this .width  = width;
+      this .height = height;
+      this .depth  = depth;
 
-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;
+      const gl = this .getBrowser () .getContext ();
 
-/*** Prototype Methods ***/
+      if (gl .getVersion () < 2)
+         return;
 
-/**
- * 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 */
+      gl .bindTexture (gl .TEXTURE_3D, this .getTexture ());
+      gl .texImage3D  (gl .TEXTURE_3D, 0, format, width, height, depth, 0, format, gl .UNSIGNED_BYTE, data);
 
-    var current, scanNum = 0, pred = [], i, compN, temp = [], index = [], mcuNum;
+      this .setTransparent (transparent);
+      this .updateTextureParameters ();
+      this .addNodeEvent ();
+   },
+   updateTextureParameters ()
+   {
+      X3DSingleTextureNode_default().prototype .updateTextureParameters .call (this,
+                                                                      this .target,
+                                                                      this ._textureProperties .getValue (),
+                                                                      this .texturePropertiesNode,
+                                                                      this .width,
+                                                                      this .height,
+                                                                      this ._repeatS .getValue (),
+                                                                      this ._repeatT .getValue (),
+                                                                      this ._repeatR .getValue ());
+   },
+   setShaderUniforms (gl, shaderObject, renderObject, channel = shaderObject .x3d_Texture [0])
+   {
+      const textureUnit = this .getBrowser () .getTexture3DUnit ();
 
-    if (typeof buffer !== "undefined") {
-        this.buffer = buffer;
-    }
+      gl .activeTexture (gl .TEXTURE0 + textureUnit);
+      gl .bindTexture (gl .TEXTURE_3D, this .getTexture ());
+      gl .uniform1i (channel .texture3D, textureUnit);
+   },
+});
 
-    if (typeof numBytes !== "undefined") {
-        this.numBytes = numBytes;
-    }
+Object .defineProperties (X3DTexture3DNode,
+{
+   typeName:
+   {
+      value: "X3DTexture3DNode",
+      enumerable: true,
+   },
+   componentInfo:
+   {
+      value: Object .freeze ({ name: "Texturing3D", level: 1 }),
+      enumerable: true,
+   },
+});
 
-    this.stream = new jpeg.lossless.DataStream(this.buffer, offset, length);
-    this.buffer = null;
+const __default__ = X3DTexture3DNode;
+;
 
-    this.xLoc = 0;
-    this.yLoc = 0;
-    current = this.stream.get16();
+Namespace_default().add ("X3DTexture3DNode", "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-9.5.0")] .require ("x_ite/Base/X3DCast");
+var X3DCast_default = /*#__PURE__*/__webpack_require__.n(X3DCast_namespaceObject);
+;// CONCATENATED MODULE: ./src/x_ite/Components/Texturing3D/ComposedTexture3D.js
+/*******************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright create3000, Scheffelstraße 31a, Leipzig, Germany 2011 - 2022.
+ *
+ * All rights reserved. Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * The copyright notice above does not evidence any actual of intended
+ * publication of such source code, and is an unpublished work by create3000.
+ * This material contains CONFIDENTIAL INFORMATION that is the property of
+ * create3000.
+ *
+ * No permission is granted to copy, distribute, or create derivative works from
+ * the contents of this software, in whole or in part, without the prior written
+ * permission of create3000.
+ *
+ * NON-MILITARY USE ONLY
+ *
+ * All create3000 software are effectively free software with a non-military use
+ * restriction. It is free. Well commented source is provided. You may reuse the
+ * source in any way you please with the exception anything that uses it must be
+ * marked to indicate is contains 'non-military use only' components.
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2011 - 2022, Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * This file is part of the X_ITE Project.
+ *
+ * X_ITE is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License version 3 only, as published by the
+ * Free Software Foundation.
+ *
+ * X_ITE is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License version 3 for more
+ * details (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version 3
+ * along with X_ITE.  If not, see <https://www.gnu.org/licenses/gpl.html> for a
+ * copy of the GPLv3 License.
+ *
+ * For Silvio, Joy and Adi.
+ *
+ ******************************************************************************/
 
-    if (current !== 0xFFD8) { // SOI
-        throw new Error("Not a JPEG file");
-    }
 
-    current = this.stream.get16();
 
-    while ((((current >> 4) !== 0x0FFC) || (current === 0xFFC4))) { // SOF 0~15
-        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! (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();
-        }
+function ComposedTexture3D (executionContext)
+{
+   Texturing3D_X3DTexture3DNode .call (this, executionContext);
 
-        this.precision = this.frame.precision;
-        this.components = this.frame.components;
+   this .addType ((X3DConstants_default()).ComposedTexture3D);
 
-        if (!this.numBytes) {
-            this.numBytes = parseInt(Math.ceil(this.precision / 8));
-        }
+   this .addChildObjects ((X3DConstants_default()).inputOutput, "update",    new (Fields_default()).SFTime ());
 
-        if (this.numBytes == 1) {
-            this.mask = 0xFF;
-        } else {
-            this.mask = 0xFFFF;
-        }
+   this .textureNodes = [ ];
+}
 
-        this.scan.read(this.stream);
-        this.numComp = this.scan.numComp;
-        this.selection = this.scan.selection;
+Object .assign (Object .setPrototypeOf (ComposedTexture3D .prototype, Texturing3D_X3DTexture3DNode .prototype),
+{
+   initialize ()
+   {
+      Texturing3D_X3DTexture3DNode .prototype .initialize .call (this);
 
-        if (this.numBytes === 1) {
-            if (this.numComp === 3) {
-                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;
-            }
-        } else {
-            this.getter = this.getValue16;
-            this.setter = this.setValue16;
-            this.output = this.outputSingle;
-        }
+      this ._texture .addInterest ("set_texture__", this);
+      this ._update  .addInterest ("update",        this);
 
-        switch (this.selection) {
-            case 2:
-                this.selector = this.select2;
-                break;
-            case 3:
-                this.selector = this.select3;
-                break;
-            case 4:
-                this.selector = this.select4;
-                break;
-            case 5:
-                this.selector = this.select5;
-                break;
-            case 6:
-                this.selector = this.select6;
-                break;
-            case 7:
-                this.selector = this.select7;
-                break;
-            default:
-                this.selector = this.select1;
-                break;
-        }
+      this .set_texture__ ();
+   },
+   set_texture__ ()
+   {
+      const textureNodes = this .textureNodes;
 
-        this.scanComps = this.scan.components;
-        this.quantTables = this.quantTable.quantTables;
+      for (const textureNode of textureNodes)
+         textureNode .removeInterest ("set_update__", this);
 
-        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];
-        }
+      textureNodes .length = 0;
 
-        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 {
-            this.outputData = new Uint16Array(new ArrayBuffer(this.xDim * this.yDim * this.numBytes * this.numComp));
-        }
+      for (const node of this ._texture)
+      {
+         const textureNode = X3DCast_default() ((X3DConstants_default()).X3DTexture2DNode, node);
 
-        scanNum+=1;
+         if (textureNode)
+            textureNodes .push (textureNode);
+      }
 
-        while (true) { // Decode one scan
-            temp[0] = 0;
-            index[0] = 0;
+      for (const textureNode of textureNodes)
+         textureNode .addInterest ("set_update__", this);
 
-            for (i = 0; i < 10; i+=1) {
-                pred[i] = (1 << (this.precision - 1));
-            }
+      this .set_update__ ();
+   },
+   set_update__ ()
+   {
+      this ._update .addEvent ();
+   },
+   isComplete ()
+   {
+      return this .textureNodes .every (textureNode => textureNode .checkLoadState () === (X3DConstants_default()).COMPLETE_STATE);
+   },
+   update ()
+   {
+      const textureNodes = this .textureNodes
 
-            if (this.restartInterval === 0) {
-                current = this.decodeUnit(pred, temp, index);
+      if (textureNodes .length === 0 || !this .isComplete ())
+      {
+         this .clearTexture ();
+      }
+      else
+      {
+         const
+            gl          = this .getBrowser () .getContext (),
+            width       = textureNodes [0] .getWidth (),
+            height      = textureNodes [0] .getHeight (),
+            depth       = textureNodes .length,
+            frameBuffer = gl .createFramebuffer ();
 
-                while ((current === 0) && ((this.xLoc < this.xDim) && (this.yLoc < this.yDim))) {
-                    this.output(pred);
-                    current = this.decodeUnit(pred, temp, index);
-                }
+         gl .bindFramebuffer (gl .FRAMEBUFFER, frameBuffer);
+         gl .bindTexture (gl .TEXTURE_3D, this .getTexture ());
 
-                break; //current=MARKER
-            }
+         if (width !== this .getWidth () || height !== this .getHeight () || depth !== this .getDepth ())
+         {
+            const defaultData = new Uint8Array (width * height * depth * 4);
 
-            for (mcuNum = 0; mcuNum < this.restartInterval; mcuNum+=1) {
-                this.restarting = (mcuNum == 0);
-                current = this.decodeUnit(pred, temp, index);
-                this.output(pred);
+            gl .texImage3D (gl .TEXTURE_3D, 0, gl .RGBA, width, height, depth, 0, gl .RGBA, gl .UNSIGNED_BYTE, defaultData);
+         }
 
-                if (current !== 0) {
-                    break;
-                }
-            }
+         for (const [i, textureNode] of this .textureNodes .entries ())
+         {
+            if (textureNode .getWidth () === width && textureNode .getHeight () === height)
+            {
+               gl .bindTexture (gl .TEXTURE_2D, textureNode .getTexture ());
+               gl .framebufferTexture2D (gl .FRAMEBUFFER, gl .COLOR_ATTACHMENT0, gl .TEXTURE_2D, textureNode .getTexture (), 0);
 
-            if (current === 0) {
-                if (this.markerIndex !== 0) {
-                    current = (0xFF00 | this.marker);
-                    this.markerIndex = 0;
-                } else {
-                    current = this.stream.get16();
-                }
+               if (textureNode .getTextureType () === 1)
+               {
+                  // Copy and flip Y.
+                  for (let y = 0; y < height; ++ y)
+                     gl .copyTexSubImage3D (gl .TEXTURE_3D, 0, 0, height - y - 1, i, 0, y, width, 1);
+               }
+               else
+               {
+                  gl .copyTexSubImage3D (gl .TEXTURE_3D, 0, 0, 0, i, 0, 0, width, height);
+               }
             }
-
-            if (!((current >= jpeg.lossless.Decoder.RESTART_MARKER_BEGIN) &&
-                (current <= jpeg.lossless.Decoder.RESTART_MARKER_END))) {
-                break; //current=MARKER
+            else
+            {
+               console .warn ("ComposedTexture3D: all textures must have same size.");
             }
-        }
-
-        if ((current === 0xFFDC) && (scanNum === 1)) { //DNL
-            this.readNumber();
-            current = this.stream.get16();
-        }
-    } 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;
-    }
-};
+         }
 
+         gl .deleteFramebuffer (frameBuffer);
 
+         this .setWidth (width);
+         this .setHeight (height);
+         this .setDepth (depth);
+         this .setTransparent (textureNodes .some (textureNode => textureNode .isTransparent ()));
+         this .setLinear (textureNodes .some (textureNode => textureNode .isLinear ()));
+         this .updateTextureParameters ();
+      }
+   },
+});
 
-jpeg.lossless.Decoder.prototype.select1 = function (compOffset) {
-    return this.getPreviousX(compOffset);
-};
-
-
-
-jpeg.lossless.Decoder.prototype.select2 = function (compOffset) {
-    return this.getPreviousY(compOffset);
-};
-
+Object .defineProperties (ComposedTexture3D,
+{
+   typeName:
+   {
+      value: "ComposedTexture3D",
+      enumerable: true,
+   },
+   componentInfo:
+   {
+      value: Object .freeze ({ name: "Texturing3D", level: 1 }),
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "texture",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze ({ from: "3.1", to: "Infinity" }),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new (FieldDefinitionArray_default()) ([
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "metadata",          new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "description",       new (Fields_default()).SFString ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "repeatS",           new (Fields_default()).SFBool ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "repeatT",           new (Fields_default()).SFBool ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "repeatR",           new (Fields_default()).SFBool ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "textureProperties", new (Fields_default()).SFNode ()),
+         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "texture",           new (Fields_default()).MFNode ()),
+      ]),
+      enumerable: true,
+   },
+});
 
+const ComposedTexture3D_default_ = ComposedTexture3D;
+;
 
-jpeg.lossless.Decoder.prototype.select3 = function (compOffset) {
-    return this.getPreviousXY(compOffset);
-};
+Namespace_default().add ("ComposedTexture3D", "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-9.5.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-9.5.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__(823);
+var jquery_default = /*#__PURE__*/__webpack_require__.n(jquery_);
+;// CONCATENATED MODULE: ./src/x_ite/Browser/Texturing3D/NRRDParser.js
+/*******************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright create3000, Scheffelstraße 31a, Leipzig, Germany 2011 - 2022.
+ *
+ * All rights reserved. Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * The copyright notice above does not evidence any actual of intended
+ * publication of such source code, and is an unpublished work by create3000.
+ * This material contains CONFIDENTIAL INFORMATION that is the property of
+ * create3000.
+ *
+ * No permission is granted to copy, distribute, or create derivative works from
+ * the contents of this software, in whole or in part, without the prior written
+ * permission of create3000.
+ *
+ * NON-MILITARY USE ONLY
+ *
+ * All create3000 software are effectively free software with a non-military use
+ * restriction. It is free. Well commented source is provided. You may reuse the
+ * source in any way you please with the exception anything that uses it must be
+ * marked to indicate is contains 'non-military use only' components.
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2011 - 2022, Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * This file is part of the X_ITE Project.
+ *
+ * X_ITE is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License version 3 only, as published by the
+ * Free Software Foundation.
+ *
+ * X_ITE is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License version 3 for more
+ * details (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version 3
+ * along with X_ITE.  If not, see <https://www.gnu.org/licenses/gpl.html> for a
+ * copy of the GPLv3 License.
+ *
+ * For Silvio, Joy and Adi.
+ *
+ ******************************************************************************/
 
 
 
-jpeg.lossless.Decoder.prototype.select4 = function (compOffset) {
-    return (this.getPreviousX(compOffset) + this.getPreviousY(compOffset)) - this.getPreviousXY(compOffset);
-};
 
+// Grammar
 
+const Grammar = Expressions_default() ({
+   NRRD: /^NRRD(\d+)\n/gy,
+   field: /([\w\s]+):\s*(.+?)\n/gy,
+   comment: /#[^\n]*\n/gy,
+   newLine: /\n/gy,
+   data: /(.*)$/sgy,
+});
 
-jpeg.lossless.Decoder.prototype.select5 = function (compOffset) {
-    return this.getPreviousX(compOffset) + ((this.getPreviousY(compOffset) - this.getPreviousXY(compOffset)) >> 1);
-};
+// Parser
 
+function NRRDParser ()
+{
+   this .fieldFunction = new Map ([
+      ["type",      this .getType],
+      ["encoding",  this .getEncoding],
+      ["dimension", this .getDimension],
+      ["sizes",     this .getSizes],
+      ["endian",    this .getEndian],
+   ]);
+}
 
+Object .assign (NRRDParser .prototype,
+{
+   parse (input)
+   {
+      this .setInput (input);
 
-jpeg.lossless.Decoder.prototype.select6 = function (compOffset) {
-    return this.getPreviousY(compOffset) + ((this.getPreviousX(compOffset) - this.getPreviousXY(compOffset)) >> 1);
-};
+      if (this .getNRRD ())
+      {
+         this .getFields ();
+         this .getData ();
+      }
 
+      return this .nrrd;
+   },
+   setInput (value)
+   {
+      this .dataView     = new DataView (value);
+      this .input        = jquery_default().decodeText (value);
+      this .lastIndex    = 0;
+      this .nrrd         = { };
+      this .littleEndian = true;
+   },
+   getNRRD ()
+   {
+      if (Grammar .NRRD .parse (this))
+      {
+         this .nrrd .nrrd    = true;
+         this .nrrd .version = parseInt (this .result [1]);
+         return true;
+      }
 
+      this .nrrd .nrrd = false;
+      return false;
+   },
+   getFields ()
+   {
+      while (Grammar .comment .parse (this))
+         ;
 
-jpeg.lossless.Decoder.prototype.select7 = function (compOffset) {
-    return ((this.getPreviousX(compOffset) + this.getPreviousY(compOffset)) / 2);
-};
+      while (Grammar .field .parse (this))
+      {
+         const
+            key   = this .result [1] .toLowerCase (),
+            value = this .result [2] .trim () .toLowerCase (),
+            fun   = this .fieldFunction .get (key);
 
+         if (fun)
+            fun .call (this, value);
 
+         while (Grammar .comment .parse (this))
+            ;
+      }
+   },
+   getType: (() =>
+   {
+      const types = new Map ([
+         ["signed char",        ["signed char", 1]],
+         ["int8",               ["signed char", 1]],
+         ["int8_t",             ["signed char", 1]],
+         ["uchar",              ["unsigned char", 1]],
+         ["unsigned char",      ["unsigned char", 1]],
+         ["uint8",              ["unsigned char", 1]],
+         ["uint8_t",            ["unsigned char", 1]],
+         ["short",              ["signed short", 2]],
+         ["short int",          ["signed short", 2]],
+         ["signed short",       ["signed short", 2]],
+         ["signed short int",   ["signed short", 2]],
+         ["int16",              ["signed short", 2]],
+         ["int16_t",            ["signed short", 2]],
+         ["ushort",             ["unsigned short", 2]],
+         ["unsigned short",     ["unsigned short", 2]],
+         ["unsigned short int", ["unsigned short", 2]],
+         ["uint16",             ["unsigned short", 2]],
+         ["uint16_t",           ["unsigned short", 2]],
+         ["int",                ["signed int", 4]],
+         ["signed int",         ["signed int", 4]],
+         ["int32",              ["signed int", 4]],
+         ["int32_t",            ["signed int", 4]],
+         ["uint",               ["unsigned int", 4]],
+         ["unsigned int",       ["unsigned int", 4]],
+         ["uint32",             ["unsigned int", 4]],
+         ["uint32_t",           ["unsigned int", 4]],
+         ["float",              ["float", 4]],
+         ["double",             ["double", 8]],
+      ]);
 
-jpeg.lossless.Decoder.prototype.decodeRGB = function (prev, temp, index) {
-    /*jslint bitwise: true */
+      return function (value)
+      {
+         const type = types .get (value);
 
-    var value, actab, dctab, qtab, ctrC, i, k, j;
+         if (type === undefined)
+            throw new Error ("Unsupported NRRD type '" + value + "'.");
 
-    prev[0] = this.selector(0);
-    prev[1] = this.selector(1);
-    prev[2] = this.selector(2);
+         this .byteType = type [0];
+         this .bytes    = type [1];
+      };
+   })(),
+   getEncoding: (() =>
+   {
+      const encodings = new Map ([
+         ["ascii", "ascii"],
+         ["txt",   "ascii"],
+         ["text",  "ascii"],
+         ["raw",   "raw"],
+         ["hex",   "hex"],
+         ["gz",    "gzip"],
+         ["gzip",  "gzip"],
+      ]);
 
-    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;
-            }
+      return function (value)
+      {
+         const encoding = encodings .get (value);
 
-            value = this.getHuffmanValue(dctab, temp, index);
+         if (encoding === undefined)
+            throw new Error ("Unsupported NRRD encoding '" + value + "'.");
 
-            if (value >= 0xFF00) {
-                return value;
-            }
+         this .encoding = encoding;
+      };
+   })(),
+   getDimension (value)
+   {
+      const result = value .match (/(\d+)/);
 
-            prev[ctrC] = this.IDCT_Source[0] = prev[ctrC] + this.getn(index, value, temp, index);
-            this.IDCT_Source[0] *= qtab[0];
+      if (result)
+      {
+         const value = parseInt (result [1]);
 
-            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];
-                }
-            }
-        }
-    }
-
-    return 0;
-};
+         switch (value)
+         {
+            case 1:
+            case 2:
+            case 3:
+            case 4:
+               this .dimension = value;
+               return;
+         }
+      }
 
+      throw new Error (`Unsupported NRRD dimension '${result ?.[1]}', must be 1, 2, 3, or 4.`);
+   },
+   getSizes (value)
+   {
+      const
+         num   = /\s*(\d+)/gy,
+         sizes = [ ];
 
+      let result;
 
-jpeg.lossless.Decoder.prototype.decodeSingle = function (prev, temp, index) {
-    /*jslint bitwise: true */
+      while (result = num .exec (value))
+      {
+         sizes .push (parseInt (result [1]));
+      }
 
-    var value, i, n, nRestart;
+      switch (sizes .length)
+      {
+         case 1:
+         {
+            this .nrrd .components = 1;
+            this .nrrd .width      = sizes [0];
+            this .nrrd .height     = 1;
+            this .nrrd .depth      = 1;
+            return;
+         }
+         case 2:
+         {
+            this .nrrd .components = 1;
+            this .nrrd .width      = sizes [0];
+            this .nrrd .height     = sizes [1];
+            this .nrrd .depth      = 1;
+            return;
+         }
+         case 3:
+         {
+            this .nrrd .components = 1;
+            this .nrrd .width      = sizes [0];
+            this .nrrd .height     = sizes [1];
+            this .nrrd .depth      = sizes [2];
+            return;
+         }
+         case 4:
+         {
+            this .nrrd .components = sizes [0];
+            this .nrrd .width      = sizes [1];
+            this .nrrd .height     = sizes [2];
+            this .nrrd .depth      = sizes [3];
+            return;
+         }
+         default:
+            throw new Error ("Unsupported NRRD sizes.");
+      }
+   },
+   getEndian (value)
+   {
+      if (value === "little")
+      {
+         this .littleEndian = true;
+         return;
+      }
 
-    if (this.restarting) {
-        this.restarting = false;
-        prev[0] = (1 << (this.frame.precision - 1));
-    } else {
-        prev[0] = this.selector();
-    }
+      if (value === "big")
+      {
+         this .littleEndian = false;
+         return;
+      }
 
-    for (i = 0; i < this.nBlock[0]; i+=1) {
-        value = this.getHuffmanValue(this.dcTab[0], temp, index);
-        if (value >= 0xFF00) {
-            return value;
-        }
+      throw new Error ("Unsupported NRRD endian, must be either 'little' or 'big'.");
+   },
+   getData ()
+   {
+      switch (this .encoding)
+      {
+         case "ascii":
+         {
+            this .ascii ();
+            break;
+         }
+         case "raw":
+         {
+            this .raw ();
+            break;
+         }
+         case "hex":
+         {
+            this .hex ();
+            break;
+         }
+         case "gzip":
+         {
+            this .gzip ();
+            break;
+         }
+      }
+   },
+   ascii ()
+   {
+      const
+         dataLength = this .nrrd .components * this .nrrd .width * this .nrrd .height * this .nrrd .depth,
+         data       = new Uint8Array (dataLength);
 
-        n = this.getn(prev, value, temp, index);
-        nRestart = (n >> 8);
+      this .nrrd .data = data;
 
-        if ((nRestart >= jpeg.lossless.Decoder.RESTART_MARKER_BEGIN) && (nRestart <= jpeg.lossless.Decoder.RESTART_MARKER_END)) {
-            return nRestart;
-        }
+      if (!Grammar .data .parse (this))
+         return;
 
-        prev[0] += n;
-    }
+      const
+         numbers    = this .result [1] .trim () .split (/\s+/),
+         numNumbers = numbers .length;
 
-    return 0;
-};
+      switch (this .byteType)
+      {
+         case "signed char":
+         case "unsigned char":
+         {
+            for (let i = 0; i < numNumbers; ++ i)
+               data [i] = parseInt (numbers [i]);
 
+            return;
+         }
+         case "signed short":
+         case "unsigned short":
+         {
+            for (let i = 0; i < numNumbers; ++ i)
+               data [i] = parseInt (numbers [i]) / 256;
 
+            return;
+         }
+         case "signed int":
+         case "unsigned int":
+         {
+            for (let i = 0; i < numNumbers; ++ i)
+               data [i] = parseInt (numbers [i]) / 16777216;
 
-//	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;
+            return;
+         }
+         case "float":
+         {
+            for (let i = 0; i < numNumbers; ++ i)
+               data [i] = parseFloat (numbers [i]) / 256;
 
-    if (index[0] < 8) {
-        temp[0] <<= 8;
-        input = this.stream.get8();
-        if (input === 0xFF) {
-            this.marker = this.stream.get8();
-            if (this.marker !== 0) {
-                this.markerIndex = 9;
-            }
-        }
-        temp[0] |= input;
-    } else {
-        index[0] -= 8;
-    }
+            return;
+         }
+         case "double":
+         {
+            for (let i = 0; i < numNumbers; ++ i)
+               data [i] = parseFloat (numbers [i]) / 16777216;
 
-    code = table[temp[0] >> index[0]];
+            return;
+         }
+      }
+   },
+   raw ()
+   {
+      const
+         dataView   = this .dataView,
+         byteLength = dataView .byteLength,
+         dataLength = this .nrrd .components * this .nrrd .width * this .nrrd .height * this .nrrd .depth,
+         length     = dataLength * this .bytes,
+         data       = new Uint8Array (dataLength);
 
-    if ((code & jpeg.lossless.Decoder.MSB) !== 0) {
-        if (this.markerIndex !== 0) {
-            this.markerIndex = 0;
-            return 0xFF00 | this.marker;
-        }
+      this .nrrd .data = data;
 
-        temp[0] &= (mask >> (16 - index[0]));
-        temp[0] <<= 8;
-        input = this.stream.get8();
+      switch (this .byteType)
+      {
+         case "signed char":
+         case "unsigned char":
+         {
+            for (let i = byteLength - length, d = 0; i < byteLength; ++ i, ++ d)
+               data [d] = dataView .getUint8 (i);
 
-        if (input === 0xFF) {
-            this.marker = this.stream.get8();
-            if (this.marker !== 0) {
-                this.markerIndex = 9;
-            }
-        }
+            return;
+         }
+         case "signed short":
+         case "unsigned short":
+         {
+            for (let i = byteLength - length, d = 0; i < byteLength; i += 2, ++ d)
+               data [d] = dataView .getUint16 (i, this .littleEndian) / 256;
 
-        temp[0] |= input;
-        code = table[((code & 0xFF) * 256) + (temp[0] >> index[0])];
-        index[0] += 8;
-    }
+            return;
+         }
+         case "signed int":
+         case "unsigned int":
+         {
+            for (let i = byteLength - length, d = 0; i < byteLength; i += 4, ++ d)
+               data [d] = dataView .getUint32 (i, this .littleEndian) / 16777216;
 
-    index[0] += 8 - (code >> 8);
+            return;
+         }
+         case "float":
+         {
+            for (let i = byteLength - length, d = 0; i < byteLength; i += 4, ++ d)
+               data [d] = dataView .getFloat32 (i, this .littleEndian) / 256;
 
-    if (index[0] < 0) {
-        throw new Error("index=" + index[0] + " temp=" + temp[0] + " code=" + code + " in HuffmanValue()");
-    }
+            return;
+         }
+         case "double":
+         {
+            for (let i = byteLength - length, d = 0; i < byteLength; i += 8, ++ d)
+               data [d] = dataView .getFloat64 (i, this .littleEndian) / 16777216;
 
-    if (index[0] < this.markerIndex) {
-        this.markerIndex = 0;
-        return 0xFF00 | this.marker;
-    }
+            return;
+         }
+      }
+   },
+   hex ()
+   {
+      if (Grammar .data .parse (this))
+      {
+         const match = this .result [1] .match (/([0-9a-fA-F]{2})/g);
 
-    temp[0] &= (mask >> (16 - index[0]));
-    return code & 0xFF;
-};
+         if (match)
+         {
+            const array = Uint8Array .from (match, value => parseInt (value, 16));
 
+            this .dataView = new DataView (array .buffer);
 
+            this .raw ();
+            return;
+         }
+      }
 
-jpeg.lossless.Decoder.prototype.getn = function (PRED, n, temp, index) {
-    /*jslint bitwise: true */
+      throw new Error ("Invalid NRRD data.");
+   },
+   gzip ()
+   {
+      try
+      {
+         if (!Grammar .newLine .parse (this))
+            throw new Error ("Invalid NRRD data.");
 
-    var result, one, n_one, mask, input;
-    one = 1;
-    n_one = -1;
-    mask = 0xFFFF;
+         const
+            input       = this .dataView .buffer .slice (this .lastIndex),
+            arrayBuffer = jquery_default().ungzip (input);
 
-    if (n === 0) {
-        return 0;
-    }
+         this .dataView = new DataView (arrayBuffer);
 
-    if (n === 16) {
-        if (PRED[0] >= 0) {
-            return -32768;
-        } 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
-            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) {
-            this.marker = this.stream.get8();
-            if (this.marker !== 0) {
-                this.markerIndex = 9;
-            }
-        }
-
-        temp[0] |= input;
-        index[0] += 8;
-
-        if (index[0] < 0) {
-            if (this.markerIndex !== 0) {
-                this.markerIndex = 0;
-                return (0xFF00 | 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;
-                }
-            }
-
-            temp[0] |= input;
-            index[0] += 8;
-        }
-
-        if (index[0] < 0) {
-            throw new Error("index=" + index[0] + " in getn()");
-        }
-
-        if (index[0] < this.markerIndex) {
-            this.markerIndex = 0;
-            return (0xFF00 | this.marker) << 8;
-        }
-
-        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;
-        }
-    }
-};
-
-
-
-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;
-        }
-    }
-};
-
-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;
+         this .raw ();
+      }
+      catch (error)
+      {
+         throw new Error (`Invalid NRRD data: ${error}.`);
+      }
+   },
+});
 
-    while (count < length) {
-        sb += this.stream.get8();
-        count+=1;
-    }
+const NRRDParser_default_ = NRRDParser;
+;
 
-    return sb;
+Namespace_default().add ("NRRDParser", "x_ite/Browser/Texturing3D/NRRDParser", NRRDParser_default_);
+/* harmony default export */ const Texturing3D_NRRDParser = (NRRDParser_default_);
+;// CONCATENATED MODULE: ./node_modules/jpeg-lossless-decoder-js/release/lossless.js
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-
-
-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();
+// src/component-spec.ts
+var ComponentSpec = {
+  hSamp: 0,
+  quantTableSel: 0,
+  vSamp: 0
 };
 
-
-
-/*** 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)
+// src/data-stream.ts
+var DataStream = class {
+  buffer;
+  index;
+  constructor(data, offset, length) {
+    this.buffer = new Uint8Array(data, offset, length);
+    this.index = 0;
+  }
+  get16() {
+    const value = (this.buffer[this.index] << 8) + this.buffer[this.index + 1];
+    this.index += 2;
+    return value;
+  }
+  get8() {
+    const value = this.buffer[this.index];
+    this.index += 1;
+    return value;
+  }
 };
 
-
-
-/*** Prototype Methods ***/
-
-jpeg.lossless.FrameHeader.prototype.read = function (data) {
-    /*jslint bitwise: true */
-
-    var count = 0, length, i, c, temp;
-
-    length = data.get16();
+// src/frame-header.ts
+var FrameHeader = class {
+  dimX = 0;
+  dimY = 0;
+  numComp = 0;
+  precision = 0;
+  components = [];
+  read(data) {
+    let count = 0;
+    let temp;
+    const length = data.get16();
     count += 2;
-
     this.precision = data.get8();
-    count+=1;
-
+    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;
+    count += 1;
+    for (let i = 1; i <= this.numComp; i += 1) {
+      if (count > length) {
+        throw new Error("ERROR: frame format error");
+      }
+      const 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] = { ...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]");
+      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;
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  crc32: () => crc32,
+  crcTable: () => crcTable,
+  createArray: () => createArray,
+  makeCRCTable: () => makeCRCTable
+});
+var createArray = (...dimensions) => {
+  if (dimensions.length > 1) {
+    const dim = dimensions[0];
+    const rest = dimensions.slice(1);
+    const newArray = [];
+    for (let i = 0; i < dim; i++) {
+      newArray[i] = createArray(...rest);
+    }
+    return newArray;
+  } else {
+    return Array(dimensions[0]).fill(void 0);
+  }
+};
+var makeCRCTable = function() {
+  let c;
+  const crcTable2 = [];
+  for (let n = 0; n < 256; n++) {
+    c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    crcTable2[n] = c;
+  }
+  return crcTable2;
+};
+var crcTable = makeCRCTable();
+var crc32 = function(buffer) {
+  const uint8view = new Uint8Array(buffer);
+  let crc = 0 ^ -1;
+  for (let i = 0; i < uint8view.length; i++) {
+    crc = crc >>> 8 ^ crcTable[(crc ^ uint8view[i]) & 255];
+  }
+  return (crc ^ -1) >>> 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();
+// src/huffman-table.ts
+var HuffmanTable = class _HuffmanTable {
+  static MSB = 2147483648;
+  l;
+  th;
+  v;
+  tc;
+  constructor() {
+    this.l = createArray(4, 2, 16);
+    this.th = [0, 0, 0, 0];
+    this.v = createArray(4, 2, 16, 200);
+    this.tc = [
+      [0, 0],
+      [0, 0],
+      [0, 0],
+      [0, 0]
+    ];
+  }
+  read(data, HuffTab) {
+    let count = 0;
+    let temp;
+    let t;
+    let c;
+    let i;
+    let j;
+    const 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;
-            }
+      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]");
+      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]);
-            }
+    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;
+  }
+  //	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.
+  buildHuffTable(tab, L, V) {
+    let currentTable, k, i, j, n;
+    const 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;
-            }
+    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;
+    for (i = 1; k < 256; i += 1, k += 1) {
+      tab[k] = i | _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;
-            }
+    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;
+        }
+      }
     }
+  }
 };
 
-
-/*** 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();
+// src/quantization-table.ts
+var QuantizationTable = class _QuantizationTable {
+  precision = [];
+  // Quantization precision 8 or 16
+  tq = [0, 0, 0, 0];
+  // 1: this table is presented
+  quantTables = createArray(4, 64);
+  // Tables
+  static enhanceQuantizationTable = function(qtab, table) {
+    for (let 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 (let 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 (let i = 0; i < 64; i += 1) {
+      qtab[i] >>= 6;
+    }
+  };
+  read(data, table) {
+    let count = 0;
+    let temp;
+    let t;
+    let i;
+    const 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");
-        }
-
-        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");
+      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;
         }
-
-        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);
+        _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;
         }
+        _QuantizationTable.enhanceQuantizationTable(this.quantTables[t], table);
+      }
     }
-
     if (count !== length) {
-        throw new Error("ERROR: Quantization table error [count!=Lq]");
+      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 = [];
+// src/scan-component.ts
+var ScanComponent = {
+  acTabSel: 0,
+  // AC table selector
+  dcTabSel: 0,
+  // DC table selector
+  scanCompSel: 0
+  // Scan component selector
 };
 
-
-/*** Prototype Methods ***/
-
-jpeg.lossless.ScanHeader.prototype.read = function(data) {
-    /*jslint bitwise: true */
-
-    var count = 0, length, i, temp;
-
-    length = data.get16();
+// src/scan-header.ts
+var ScanHeader = class {
+  ah = 0;
+  al = 0;
+  numComp = 0;
+  // Number of components in the scan
+  selection = 0;
+  // Start of spectral or predictor selection
+  spectralEnd = 0;
+  // End of spectral selection
+  components = [];
+  read(data) {
+    let count = 0;
+    let i;
+    let temp;
+    const 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 & 0x0F);
+    count += 1;
+    for (i = 0; i < this.numComp; i += 1) {
+      this.components[i] = { ...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;
-
+    count += 1;
     this.spectralEnd = data.get8();
-    count+=1;
-
+    count += 1;
     temp = data.get8();
-    this.ah = (temp >> 4);
-    this.al = (temp & 0x0F);
-    count+=1;
-
+    this.ah = temp >> 4;
+    this.al = temp & 15;
+    count += 1;
     if (count !== length) {
-        throw new Error("ERROR: scan header format error [count!=Ns]");
+      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);
+// src/decoder.ts
+var littleEndian = function() {
+  const buffer = new ArrayBuffer(2);
+  new DataView(buffer).setInt16(
+    0,
+    256,
+    true
+    /* littleEndian */
+  );
+  return new Int16Array(buffer)[0] === 256;
+}();
+var Decoder = class _Decoder {
+  static 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
+  ];
+  static 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
+  ];
+  static MAX_HUFFMAN_SUBTREE = 50;
+  static MSB = 2147483648;
+  static RESTART_MARKER_BEGIN = 65488;
+  static RESTART_MARKER_END = 65495;
+  buffer = null;
+  stream = null;
+  frame = new FrameHeader();
+  huffTable = new HuffmanTable();
+  quantTable = new QuantizationTable();
+  scan = new ScanHeader();
+  DU = createArray(10, 4, 64);
+  // at most 10 data units in a MCU, at most 4 data units in one component
+  HuffTab = createArray(4, 2, 50 * 256);
+  IDCT_Source = [];
+  nBlock = [];
+  // number of blocks in the i-th Comp in a scan
+  acTab = createArray(10, 1);
+  // ac HuffTab for the i-th Comp in a scan
+  dcTab = createArray(10, 1);
+  // dc HuffTab for the i-th Comp in a scan
+  qTab = createArray(10, 1);
+  // quantization table for the i-th Comp in a scan
+  marker = 0;
+  markerIndex = 0;
+  numComp = 0;
+  restartInterval = 0;
+  selection = 0;
+  xDim = 0;
+  yDim = 0;
+  xLoc = 0;
+  yLoc = 0;
+  outputData = null;
+  restarting = false;
+  mask = 0;
+  numBytes = 0;
+  precision = void 0;
+  components = [];
+  getter = null;
+  setter = null;
+  output = null;
+  selector = null;
+  /**
+   * The Decoder constructor.
+   * @property {number} numBytes - number of bytes per component
+   * @type {Function}
+   */
+  constructor(buffer, numBytes) {
+    this.buffer = buffer ?? null;
+    this.numBytes = numBytes ?? 0;
+  }
+  /**
+   * Returns decompressed data.
+   */
+  decompress(buffer, offset, length) {
+    const result = this.decode(buffer, offset, length);
+    return result.buffer;
+  }
+  decode(buffer, offset, length, numBytes) {
+    let scanNum = 0;
+    const pred = [];
+    let i;
+    let compN;
+    const temp = [];
+    const index = [];
+    let mcuNum;
+    if (buffer) {
+      this.buffer = buffer;
+    }
+    if (numBytes !== void 0) {
+      this.numBytes = numBytes;
+    }
+    this.stream = new DataStream(this.buffer, offset, length);
+    this.buffer = null;
+    this.xLoc = 0;
+    this.yLoc = 0;
+    let current = this.stream.get16();
+    if (current !== 65496) {
+      throw new Error("Not a JPEG file");
     }
-
-    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));
-        }
-        crcTable[n] = c;
+    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, _Decoder.TABLE);
+          break;
+        case 65501:
+          this.restartInterval = this.readNumber() ?? 0;
+          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();
     }
-    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];
+    if (current < 65472 || current > 65479) {
+      throw new Error("ERROR: could not handle arithmetic code!");
     }
-
-    return (crc ^ (-1)) >>> 0;
-};
-
-
-/*** Exports ***/
-
-var moduleType = typeof module;
-if ((moduleType !== 'undefined') && module.exports) {
-    module.exports = jpeg.lossless.Utils;
-}
-
-},{}]},{},[6])(6)
-});
-
-
-/***/ }),
-
-/***/ 823:
-/***/ ((module) => {
-
-"use strict";
-module.exports = window [Symbol .for ("X_ITE.X3D-9.4.4")] .require ("lib/jquery");
-
-/***/ }),
-
-/***/ 497:
-/***/ (() => {
-
-/* (ignored) */
-
-/***/ }),
-
-/***/ 13:
-/***/ (() => {
-
-/* (ignored) */
-
-/***/ }),
-
-/***/ 722:
-/***/ (() => {
-
-/* (ignored) */
-
-/***/ }),
-
-/***/ 978:
-/***/ (() => {
-
-/* (ignored) */
-
-/***/ }),
-
-/***/ 559:
-/***/ (() => {
-
-/* (ignored) */
-
-/***/ })
-
-/******/ 	});
-/************************************************************************/
-/******/ 	// The module cache
-/******/ 	var __webpack_module_cache__ = {};
-/******/ 	
-/******/ 	// The require function
-/******/ 	function __webpack_require__(moduleId) {
-/******/ 		// Check if module is in cache
-/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
-/******/ 		if (cachedModule !== undefined) {
-/******/ 			return cachedModule.exports;
-/******/ 		}
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = __webpack_module_cache__[moduleId] = {
-/******/ 			// no module.id needed
-/******/ 			// no module.loaded needed
-/******/ 			exports: {}
-/******/ 		};
-/******/ 	
-/******/ 		// Execute the module function
-/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-/******/ 	
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
-/******/ 	
-/************************************************************************/
-/******/ 	/* webpack/runtime/compat get default export */
-/******/ 	(() => {
-/******/ 		// getDefaultExport function for compatibility with non-harmony modules
-/******/ 		__webpack_require__.n = (module) => {
-/******/ 			var getter = module && module.__esModule ?
-/******/ 				() => (module['default']) :
-/******/ 				() => (module);
-/******/ 			__webpack_require__.d(getter, { a: getter });
-/******/ 			return getter;
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/define property getters */
-/******/ 	(() => {
-/******/ 		// define getter functions for harmony exports
-/******/ 		__webpack_require__.d = (exports, definition) => {
-/******/ 			for(var key in definition) {
-/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
-/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
-/******/ 				}
-/******/ 			}
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
-/******/ 	(() => {
-/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
-/******/ 	})();
-/******/ 	
-/************************************************************************/
-var __webpack_exports__ = {};
-// This entry need to be wrapped in an IIFE because it need to be in strict mode.
-(() => {
-"use strict";
-
-// 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-9.4.4")] .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-9.4.4")] .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-9.4.4")] .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-9.4.4")] .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-9.4.4")] .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-9.4.4")] .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-9.4.4")] .require ("x_ite/Namespace");
-var Namespace_default = /*#__PURE__*/__webpack_require__.n(Namespace_namespaceObject);
-;// CONCATENATED MODULE: ./src/x_ite/Components/Texturing3D/X3DTexture3DNode.js
-/*******************************************************************************
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright create3000, Scheffelstraße 31a, Leipzig, Germany 2011 - 2022.
- *
- * All rights reserved. Holger Seelig <holger.seelig@yahoo.de>.
- *
- * The copyright notice above does not evidence any actual of intended
- * publication of such source code, and is an unpublished work by create3000.
- * This material contains CONFIDENTIAL INFORMATION that is the property of
- * create3000.
- *
- * No permission is granted to copy, distribute, or create derivative works from
- * the contents of this software, in whole or in part, without the prior written
- * permission of create3000.
- *
- * NON-MILITARY USE ONLY
- *
- * All create3000 software are effectively free software with a non-military use
- * restriction. It is free. Well commented source is provided. You may reuse the
- * source in any way you please with the exception anything that uses it must be
- * marked to indicate is contains 'non-military use only' components.
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright 2011 - 2022, Holger Seelig <holger.seelig@yahoo.de>.
- *
- * This file is part of the X_ITE Project.
- *
- * X_ITE is free software: you can redistribute it and/or modify it under the
- * terms of the GNU General Public License version 3 only, as published by the
- * Free Software Foundation.
- *
- * X_ITE is distributed in the hope that it will be useful, but WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU General Public License version 3 for more
- * details (a copy is included in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version 3
- * along with X_ITE.  If not, see <https://www.gnu.org/licenses/gpl.html> for a
- * copy of the GPLv3 License.
- *
- * For Silvio, Joy and Adi.
- *
- ******************************************************************************/
-
-
-
-
-const defaultData = new Uint8Array ([ 255, 255, 255, 255 ]);
-
-function X3DTexture3DNode (executionContext)
-{
-   X3DSingleTextureNode_default().call (this, executionContext);
-
-   this .addType ((X3DConstants_default()).X3DTexture3DNode);
-
-   const gl = this .getBrowser () .getContext ();
-
-   this .target = gl .TEXTURE_3D;
-   this .width  = 0;
-   this .height = 0;
-   this .depth  = 0;
-}
-
-Object .assign (Object .setPrototypeOf (X3DTexture3DNode .prototype, (X3DSingleTextureNode_default()).prototype),
-{
-   initialize ()
-   {
-      X3DSingleTextureNode_default().prototype .initialize .call (this);
-
-      this ._repeatS .addInterest ("updateTextureParameters", this);
-      this ._repeatT .addInterest ("updateTextureParameters", this);
-      this ._repeatR .addInterest ("updateTextureParameters", this);
-
-      const gl = this .getBrowser () .getContext ();
-
-      if (gl .getVersion () < 2)
-         return;
-
-      gl .bindTexture (gl .TEXTURE_3D, this .getTexture ());
-      gl .texImage3D  (gl .TEXTURE_3D, 0, gl .RGBA, 1, 1, 1, 0, gl .RGBA, gl .UNSIGNED_BYTE, defaultData);
-   },
-   getTarget ()
-   {
-      return this .target;
-   },
-   getTextureType ()
-   {
-      return 3;
-   },
-   getWidth ()
-   {
-      return this .width;
-   },
-   setWidth (value)
-   {
-      this .width = value;
-   },
-   getHeight ()
-   {
-      return this .height;
-   },
-   setHeight (value)
-   {
-      this .height = value;
-   },
-   getDepth ()
-   {
-      return this .depth;
-   },
-   setDepth (value)
-   {
-      this .depth = value;
-   },
-   clearTexture ()
-   {
-      const gl = this .getBrowser () .getContext ();
-
-      this .setTextureFromData (1, 1, 1, false, gl .RGBA, defaultData);
-   },
-   setTextureFromData (width, height, depth, transparent, format, data)
-   {
-      this .width  = width;
-      this .height = height;
-      this .depth  = depth;
-
-      const gl = this .getBrowser () .getContext ();
-
-      if (gl .getVersion () < 2)
-         return;
-
-      gl .bindTexture (gl .TEXTURE_3D, this .getTexture ());
-      gl .texImage3D  (gl .TEXTURE_3D, 0, format, width, height, depth, 0, format, gl .UNSIGNED_BYTE, data);
-
-      this .setTransparent (transparent);
-      this .updateTextureParameters ();
-      this .addNodeEvent ();
-   },
-   updateTextureParameters ()
-   {
-      X3DSingleTextureNode_default().prototype .updateTextureParameters .call (this,
-                                                                      this .target,
-                                                                      this ._textureProperties .getValue (),
-                                                                      this .texturePropertiesNode,
-                                                                      this .width,
-                                                                      this .height,
-                                                                      this ._repeatS .getValue (),
-                                                                      this ._repeatT .getValue (),
-                                                                      this ._repeatR .getValue ());
-   },
-   setShaderUniforms (gl, shaderObject, renderObject, channel = shaderObject .x3d_Texture [0])
-   {
-      const textureUnit = this .getBrowser () .getTexture3DUnit ();
-
-      gl .activeTexture (gl .TEXTURE0 + textureUnit);
-      gl .bindTexture (gl .TEXTURE_3D, this .getTexture ());
-      gl .uniform1i (channel .texture3D, textureUnit);
-   },
-});
-
-Object .defineProperties (X3DTexture3DNode,
-{
-   typeName:
-   {
-      value: "X3DTexture3DNode",
-      enumerable: true,
-   },
-   componentInfo:
-   {
-      value: Object .freeze ({ name: "Texturing3D", level: 1 }),
-      enumerable: true,
-   },
-});
-
-const __default__ = X3DTexture3DNode;
-;
-
-Namespace_default().add ("X3DTexture3DNode", "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-9.4.4")] .require ("x_ite/Base/X3DCast");
-var X3DCast_default = /*#__PURE__*/__webpack_require__.n(X3DCast_namespaceObject);
-;// CONCATENATED MODULE: ./src/x_ite/Components/Texturing3D/ComposedTexture3D.js
-/*******************************************************************************
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright create3000, Scheffelstraße 31a, Leipzig, Germany 2011 - 2022.
- *
- * All rights reserved. Holger Seelig <holger.seelig@yahoo.de>.
- *
- * The copyright notice above does not evidence any actual of intended
- * publication of such source code, and is an unpublished work by create3000.
- * This material contains CONFIDENTIAL INFORMATION that is the property of
- * create3000.
- *
- * No permission is granted to copy, distribute, or create derivative works from
- * the contents of this software, in whole or in part, without the prior written
- * permission of create3000.
- *
- * NON-MILITARY USE ONLY
- *
- * All create3000 software are effectively free software with a non-military use
- * restriction. It is free. Well commented source is provided. You may reuse the
- * source in any way you please with the exception anything that uses it must be
- * marked to indicate is contains 'non-military use only' components.
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright 2011 - 2022, Holger Seelig <holger.seelig@yahoo.de>.
- *
- * This file is part of the X_ITE Project.
- *
- * X_ITE is free software: you can redistribute it and/or modify it under the
- * terms of the GNU General Public License version 3 only, as published by the
- * Free Software Foundation.
- *
- * X_ITE is distributed in the hope that it will be useful, but WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU General Public License version 3 for more
- * details (a copy is included in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version 3
- * along with X_ITE.  If not, see <https://www.gnu.org/licenses/gpl.html> for a
- * copy of the GPLv3 License.
- *
- * For Silvio, Joy and Adi.
- *
- ******************************************************************************/
-
-
-
-
-
-
-
-
-function ComposedTexture3D (executionContext)
-{
-   Texturing3D_X3DTexture3DNode .call (this, executionContext);
-
-   this .addType ((X3DConstants_default()).ComposedTexture3D);
-
-   this .addChildObjects ((X3DConstants_default()).inputOutput, "update",    new (Fields_default()).SFTime ());
-
-   this .textureNodes = [ ];
-}
-
-Object .assign (Object .setPrototypeOf (ComposedTexture3D .prototype, Texturing3D_X3DTexture3DNode .prototype),
-{
-   initialize ()
-   {
-      Texturing3D_X3DTexture3DNode .prototype .initialize .call (this);
-
-      this ._texture .addInterest ("set_texture__", this);
-      this ._update  .addInterest ("update",        this);
-
-      this .set_texture__ ();
-   },
-   set_texture__ ()
-   {
-      const textureNodes = this .textureNodes;
-
-      for (const textureNode of textureNodes)
-         textureNode .removeInterest ("set_update__", this);
-
-      textureNodes .length = 0;
-
-      for (const node of this ._texture)
-      {
-         const textureNode = X3DCast_default() ((X3DConstants_default()).X3DTexture2DNode, node);
-
-         if (textureNode)
-            textureNodes .push (textureNode);
+    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 65484:
+            throw new Error("Program doesn't support arithmetic coding. (format throw new IOException)");
+          case 65499:
+            this.quantTable.read(this.stream, _Decoder.TABLE);
+            break;
+          case 65501:
+            this.restartInterval = this.readNumber() ?? 0;
+            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! (Parser.decode)");
+            }
+        }
+        current = this.stream.get16();
       }
-
-      for (const textureNode of textureNodes)
-         textureNode .addInterest ("set_update__", this);
-
-      this .set_update__ ();
-   },
-   set_update__ ()
-   {
-      this ._update .addEvent ();
-   },
-   isComplete ()
-   {
-      return this .textureNodes .every (textureNode => textureNode .checkLoadState () === (X3DConstants_default()).COMPLETE_STATE);
-   },
-   update ()
-   {
-      const textureNodes = this .textureNodes
-
-      if (textureNodes .length === 0 || !this .isComplete ())
-      {
-         this .clearTexture ();
+      this.precision = this.frame.precision;
+      this.components = this.frame.components;
+      if (!this.numBytes) {
+        this.numBytes = Math.round(Math.ceil(this.precision / 8));
       }
-      else
-      {
-         const
-            gl          = this .getBrowser () .getContext (),
-            width       = textureNodes [0] .getWidth (),
-            height      = textureNodes [0] .getHeight (),
-            depth       = textureNodes .length,
-            frameBuffer = gl .createFramebuffer ();
-
-         gl .bindFramebuffer (gl .FRAMEBUFFER, frameBuffer);
-         gl .bindTexture (gl .TEXTURE_3D, this .getTexture ());
-
-         if (width !== this .getWidth () || height !== this .getHeight () || depth !== this .getDepth ())
-         {
-            const defaultData = new Uint8Array (width * height * depth * 4);
-
-            gl .texImage3D (gl .TEXTURE_3D, 0, gl .RGBA, width, height, depth, 0, gl .RGBA, gl .UNSIGNED_BYTE, defaultData);
-         }
-
-         for (const [i, textureNode] of this .textureNodes .entries ())
-         {
-            if (textureNode .getWidth () === width && textureNode .getHeight () === height)
-            {
-               gl .bindTexture (gl .TEXTURE_2D, textureNode .getTexture ());
-               gl .framebufferTexture2D (gl .FRAMEBUFFER, gl .COLOR_ATTACHMENT0, gl .TEXTURE_2D, textureNode .getTexture (), 0);
-
-               if (textureNode .getTextureType () === 1)
-               {
-                  // Copy and flip Y.
-                  for (let y = 0; y < height; ++ y)
-                     gl .copyTexSubImage3D (gl .TEXTURE_3D, 0, 0, height - y - 1, i, 0, y, width, 1);
-               }
-               else
-               {
-                  gl .copyTexSubImage3D (gl .TEXTURE_3D, 0, 0, 0, i, 0, 0, width, height);
-               }
-            }
-            else
-            {
-               console .warn ("ComposedTexture3D: all textures must have same size.");
-            }
-         }
-
-         gl .deleteFramebuffer (frameBuffer);
-
-         this .setWidth (width);
-         this .setHeight (height);
-         this .setDepth (depth);
-         this .setTransparent (textureNodes .some (textureNode => textureNode .isTransparent ()));
-         this .setLinear (textureNodes .some (textureNode => textureNode .isLinear ()));
-         this .updateTextureParameters ();
+      if (this.numBytes === 1) {
+        this.mask = 255;
+      } else {
+        this.mask = 65535;
       }
-   },
-});
-
-Object .defineProperties (ComposedTexture3D,
-{
-   typeName:
-   {
-      value: "ComposedTexture3D",
-      enumerable: true,
-   },
-   componentInfo:
-   {
-      value: Object .freeze ({ name: "Texturing3D", level: 1 }),
-      enumerable: true,
-   },
-   containerField:
-   {
-      value: "texture",
-      enumerable: true,
-   },
-   specificationRange:
-   {
-      value: Object .freeze ({ from: "3.1", to: "Infinity" }),
-      enumerable: true,
-   },
-   fieldDefinitions:
-   {
-      value: new (FieldDefinitionArray_default()) ([
-         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "metadata",          new (Fields_default()).SFNode ()),
-         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "description",       new (Fields_default()).SFString ()),
-         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "repeatS",           new (Fields_default()).SFBool ()),
-         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "repeatT",           new (Fields_default()).SFBool ()),
-         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "repeatR",           new (Fields_default()).SFBool ()),
-         new (X3DFieldDefinition_default()) ((X3DConstants_default()).initializeOnly, "textureProperties", new (Fields_default()).SFNode ()),
-         new (X3DFieldDefinition_default()) ((X3DConstants_default()).inputOutput,    "texture",           new (Fields_default()).MFNode ()),
-      ]),
-      enumerable: true,
-   },
-});
-
-const ComposedTexture3D_default_ = ComposedTexture3D;
-;
-
-Namespace_default().add ("ComposedTexture3D", "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-9.4.4")] .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-9.4.4")] .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__(823);
-var jquery_default = /*#__PURE__*/__webpack_require__.n(jquery_);
-;// CONCATENATED MODULE: ./src/x_ite/Browser/Texturing3D/NRRDParser.js
-/*******************************************************************************
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright create3000, Scheffelstraße 31a, Leipzig, Germany 2011 - 2022.
- *
- * All rights reserved. Holger Seelig <holger.seelig@yahoo.de>.
- *
- * The copyright notice above does not evidence any actual of intended
- * publication of such source code, and is an unpublished work by create3000.
- * This material contains CONFIDENTIAL INFORMATION that is the property of
- * create3000.
- *
- * No permission is granted to copy, distribute, or create derivative works from
- * the contents of this software, in whole or in part, without the prior written
- * permission of create3000.
- *
- * NON-MILITARY USE ONLY
- *
- * All create3000 software are effectively free software with a non-military use
- * restriction. It is free. Well commented source is provided. You may reuse the
- * source in any way you please with the exception anything that uses it must be
- * marked to indicate is contains 'non-military use only' components.
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright 2011 - 2022, Holger Seelig <holger.seelig@yahoo.de>.
- *
- * This file is part of the X_ITE Project.
- *
- * X_ITE is free software: you can redistribute it and/or modify it under the
- * terms of the GNU General Public License version 3 only, as published by the
- * Free Software Foundation.
- *
- * X_ITE is distributed in the hope that it will be useful, but WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU General Public License version 3 for more
- * details (a copy is included in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version 3
- * along with X_ITE.  If not, see <https://www.gnu.org/licenses/gpl.html> for a
- * copy of the GPLv3 License.
- *
- * For Silvio, Joy and Adi.
- *
- ******************************************************************************/
-
-
-
-
-// Grammar
-
-const Grammar = Expressions_default() ({
-   NRRD: /^NRRD(\d+)\n/gy,
-   field: /([\w\s]+):\s*(.+?)\n/gy,
-   comment: /#[^\n]*\n/gy,
-   newLine: /\n/gy,
-   data: /(.*)$/sgy,
-});
-
-// Parser
-
-function NRRDParser ()
-{
-   this .fieldFunction = new Map ([
-      ["type",      this .getType],
-      ["encoding",  this .getEncoding],
-      ["dimension", this .getDimension],
-      ["sizes",     this .getSizes],
-      ["endian",    this .getEndian],
-   ]);
-}
-
-Object .assign (NRRDParser .prototype,
-{
-   parse (input)
-   {
-      this .setInput (input);
-
-      if (this .getNRRD ())
-      {
-         this .getFields ();
-         this .getData ();
+      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;
+        } else {
+          this.getter = this.getValue8;
+          this.setter = this.setValue8;
+          this.output = this.outputSingle;
+        }
+      } else {
+        this.getter = this.getValue8;
+        this.setter = this.setValue8;
+        this.output = this.outputSingle;
+      }
+      switch (this.selection) {
+        case 2:
+          this.selector = this.select2;
+          break;
+        case 3:
+          this.selector = this.select3;
+          break;
+        case 4:
+          this.selector = this.select4;
+          break;
+        case 5:
+          this.selector = this.select5;
+          break;
+        case 6:
+          this.selector = this.select6;
+          break;
+        case 7:
+          this.selector = this.select7;
+          break;
+        default:
+          this.selector = this.select1;
+          break;
       }
-
-      return this .nrrd;
-   },
-   setInput (value)
-   {
-      this .dataView     = new DataView (value);
-      this .input        = jquery_default().decodeText (value);
-      this .lastIndex    = 0;
-      this .nrrd         = { };
-      this .littleEndian = true;
-   },
-   getNRRD ()
-   {
-      if (Grammar .NRRD .parse (this))
-      {
-         this .nrrd .nrrd    = true;
-         this .nrrd .version = parseInt (this .result [1]);
-         return true;
+      for (i = 0; i < this.numComp; i += 1) {
+        compN = this.scan.components[i].scanCompSel;
+        this.qTab[i] = this.quantTable.quantTables[this.components[compN].quantTableSel];
+        this.nBlock[i] = this.components[compN].vSamp * this.components[compN].hSamp;
+        this.dcTab[i] = this.HuffTab[this.scan.components[i].dcTabSel][0];
+        this.acTab[i] = this.HuffTab[this.scan.components[i].acTabSel][1];
       }
-
-      this .nrrd .nrrd = false;
-      return false;
-   },
-   getFields ()
-   {
-      while (Grammar .comment .parse (this))
-         ;
-
-      while (Grammar .field .parse (this))
-      {
-         const
-            key   = this .result [1] .toLowerCase (),
-            value = this .result [2] .trim () .toLowerCase (),
-            fun   = this .fieldFunction .get (key);
-
-         if (fun)
-            fun .call (this, value);
-
-         while (Grammar .comment .parse (this))
-            ;
+      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 {
+        this.outputData = new Uint16Array(new ArrayBuffer(this.xDim * this.yDim * this.numBytes * this.numComp));
       }
-   },
-   getType: (() =>
-   {
-      const types = new Map ([
-         ["signed char",        ["signed char", 1]],
-         ["int8",               ["signed char", 1]],
-         ["int8_t",             ["signed char", 1]],
-         ["uchar",              ["unsigned char", 1]],
-         ["unsigned char",      ["unsigned char", 1]],
-         ["uint8",              ["unsigned char", 1]],
-         ["uint8_t",            ["unsigned char", 1]],
-         ["short",              ["signed short", 2]],
-         ["short int",          ["signed short", 2]],
-         ["signed short",       ["signed short", 2]],
-         ["signed short int",   ["signed short", 2]],
-         ["int16",              ["signed short", 2]],
-         ["int16_t",            ["signed short", 2]],
-         ["ushort",             ["unsigned short", 2]],
-         ["unsigned short",     ["unsigned short", 2]],
-         ["unsigned short int", ["unsigned short", 2]],
-         ["uint16",             ["unsigned short", 2]],
-         ["uint16_t",           ["unsigned short", 2]],
-         ["int",                ["signed int", 4]],
-         ["signed int",         ["signed int", 4]],
-         ["int32",              ["signed int", 4]],
-         ["int32_t",            ["signed int", 4]],
-         ["uint",               ["unsigned int", 4]],
-         ["unsigned int",       ["unsigned int", 4]],
-         ["uint32",             ["unsigned int", 4]],
-         ["uint32_t",           ["unsigned int", 4]],
-         ["float",              ["float", 4]],
-         ["double",             ["double", 8]],
-      ]);
-
-      return function (value)
-      {
-         const type = types .get (value);
-
-         if (type === undefined)
-            throw new Error ("Unsupported NRRD type '" + value + "'.");
-
-         this .byteType = type [0];
-         this .bytes    = type [1];
-      };
-   })(),
-   getEncoding: (() =>
-   {
-      const encodings = new Map ([
-         ["ascii", "ascii"],
-         ["txt",   "ascii"],
-         ["text",  "ascii"],
-         ["raw",   "raw"],
-         ["hex",   "hex"],
-         ["gz",    "gzip"],
-         ["gzip",  "gzip"],
-      ]);
-
-      return function (value)
-      {
-         const encoding = encodings .get (value);
-
-         if (encoding === undefined)
-            throw new Error ("Unsupported NRRD encoding '" + value + "'.");
-
-         this .encoding = encoding;
-      };
-   })(),
-   getDimension (value)
-   {
-      const result = value .match (/(\d+)/);
-
-      if (result)
-      {
-         const value = parseInt (result [1]);
-
-         switch (value)
-         {
-            case 1:
-            case 2:
-            case 3:
-            case 4:
-               this .dimension = value;
-               return;
-         }
+      scanNum += 1;
+      while (true) {
+        temp[0] = 0;
+        index[0] = 0;
+        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);
+          }
+          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 = 65280 | this.marker;
+            this.markerIndex = 0;
+          } else {
+            current = this.stream.get16();
+          }
+        }
+        if (!(current >= _Decoder.RESTART_MARKER_BEGIN && current <= _Decoder.RESTART_MARKER_END)) {
+          break;
+        }
       }
-
-      throw new Error (`Unsupported NRRD dimension '${result ?.[1]}', must be 1, 2, 3, or 4.`);
-   },
-   getSizes (value)
-   {
-      const
-         num   = /\s*(\d+)/gy,
-         sizes = [ ];
-
-      let result;
-
-      while (result = num .exec (value))
-      {
-         sizes .push (parseInt (result [1]));
+      if (current === 65500 && scanNum === 1) {
+        this.readNumber();
+        current = this.stream.get16();
       }
-
-      switch (sizes .length)
-      {
-         case 1:
-         {
-            this .nrrd .components = 1;
-            this .nrrd .width      = sizes [0];
-            this .nrrd .height     = 1;
-            this .nrrd .depth      = 1;
-            return;
-         }
-         case 2:
-         {
-            this .nrrd .components = 1;
-            this .nrrd .width      = sizes [0];
-            this .nrrd .height     = sizes [1];
-            this .nrrd .depth      = 1;
-            return;
-         }
-         case 3:
-         {
-            this .nrrd .components = 1;
-            this .nrrd .width      = sizes [0];
-            this .nrrd .height     = sizes [1];
-            this .nrrd .depth      = sizes [2];
-            return;
-         }
-         case 4:
-         {
-            this .nrrd .components = sizes [0];
-            this .nrrd .width      = sizes [1];
-            this .nrrd .height     = sizes [2];
-            this .nrrd .depth      = sizes [3];
-            return;
-         }
-         default:
-            throw new Error ("Unsupported NRRD sizes.");
+    } while (current !== 65497 && this.xLoc < this.xDim && this.yLoc < this.yDim && scanNum === 0);
+    return this.outputData;
+  }
+  decodeUnit(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;
+    }
+  }
+  select1(compOffset) {
+    return this.getPreviousX(compOffset);
+  }
+  select2(compOffset) {
+    return this.getPreviousY(compOffset);
+  }
+  select3(compOffset) {
+    return this.getPreviousXY(compOffset);
+  }
+  select4(compOffset) {
+    return this.getPreviousX(compOffset) + this.getPreviousY(compOffset) - this.getPreviousXY(compOffset);
+  }
+  select5(compOffset) {
+    return this.getPreviousX(compOffset) + (this.getPreviousY(compOffset) - this.getPreviousXY(compOffset) >> 1);
+  }
+  select6(compOffset) {
+    return this.getPreviousY(compOffset) + (this.getPreviousX(compOffset) - this.getPreviousXY(compOffset) >> 1);
+  }
+  select7(compOffset) {
+    return (this.getPreviousX(compOffset) + this.getPreviousY(compOffset)) / 2;
+  }
+  decodeRGB(prev, temp, index) {
+    if (this.selector === null)
+      throw new Error("decode hasn't run yet");
+    let 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;
+        }
+        let value = this.getHuffmanValue(dctab, temp, index);
+        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 >= 65280) {
+            return value;
+          }
+          j += value >> 4;
+          if ((value & 15) === 0) {
+            if (value >> 4 === 0) {
+              break;
+            }
+          } else {
+            this.IDCT_Source[_Decoder.IDCT_P[j]] = this.getn(index, value & 15, temp, index) * qtab[j];
+          }
+        }
       }
-   },
-   getEndian (value)
-   {
-      if (value === "little")
-      {
-         this .littleEndian = true;
-         return;
+    }
+    return 0;
+  }
+  decodeSingle(prev, temp, index) {
+    if (this.selector === null)
+      throw new Error("decode hasn't run yet");
+    let 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 >= 65280) {
+        return value;
+      }
+      n = this.getn(prev, value, temp, index);
+      nRestart = n >> 8;
+      if (nRestart >= _Decoder.RESTART_MARKER_BEGIN && nRestart <= _Decoder.RESTART_MARKER_END) {
+        return nRestart;
+      }
+      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
+  getHuffmanValue(table, temp, index) {
+    let code, input;
+    const mask = 65535;
+    if (!this.stream)
+      throw new Error("stream not initialized");
+    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;
+        }
+      }
+      temp[0] |= input;
+    } else {
+      index[0] -= 8;
+    }
+    code = table[temp[0] >> index[0]];
+    if ((code & _Decoder.MSB) !== 0) {
+      if (this.markerIndex !== 0) {
+        this.markerIndex = 0;
+        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;
+        }
+      }
+      temp[0] |= input;
+      code = table[(code & 255) * 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 65280 | this.marker;
+    }
+    temp[0] &= mask >> 16 - index[0];
+    return code & 255;
+  }
+  getn(PRED, n, temp, index) {
+    let result, input;
+    const one = 1;
+    const n_one = -1;
+    const mask = 65535;
+    if (this.stream === null)
+      throw new Error("stream not initialized");
+    if (n === 0) {
+      return 0;
+    }
+    if (n === 16) {
+      if (PRED[0] >= 0) {
+        return -32768;
+      } else {
+        return 32768;
       }
-
-      if (value === "big")
-      {
-         this .littleEndian = false;
-         return;
+    }
+    index[0] -= n;
+    if (index[0] >= 0) {
+      if (index[0] < this.markerIndex && !this.isLastPixel()) {
+        this.markerIndex = 0;
+        return (65280 | this.marker) << 8;
       }
-
-      throw new Error ("Unsupported NRRD endian, must be either 'little' or 'big'.");
-   },
-   getData ()
-   {
-      switch (this .encoding)
-      {
-         case "ascii":
-         {
-            this .ascii ();
-            break;
-         }
-         case "raw":
-         {
-            this .raw ();
-            break;
-         }
-         case "hex":
-         {
-            this .hex ();
-            break;
-         }
-         case "gzip":
-         {
-            this .gzip ();
-            break;
-         }
+      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;
+        }
       }
-   },
-   ascii ()
-   {
-      const
-         dataLength = this .nrrd .components * this .nrrd .width * this .nrrd .height * this .nrrd .depth,
-         data       = new Uint8Array (dataLength);
-
-      this .nrrd .data = data;
-
-      if (!Grammar .data .parse (this))
-         return;
-
-      const
-         numbers    = this .result [1] .trim () .split (/\s+/),
-         numNumbers = numbers .length;
-
-      switch (this .byteType)
-      {
-         case "signed char":
-         case "unsigned char":
-         {
-            for (let i = 0; i < numNumbers; ++ i)
-               data [i] = parseInt (numbers [i]);
-
-            return;
-         }
-         case "signed short":
-         case "unsigned short":
-         {
-            for (let i = 0; i < numNumbers; ++ i)
-               data [i] = parseInt (numbers [i]) / 256;
-
-            return;
-         }
-         case "signed int":
-         case "unsigned int":
-         {
-            for (let i = 0; i < numNumbers; ++ i)
-               data [i] = parseInt (numbers [i]) / 16777216;
-
-            return;
-         }
-         case "float":
-         {
-            for (let i = 0; i < numNumbers; ++ i)
-               data [i] = parseFloat (numbers [i]) / 256;
-
-            return;
-         }
-         case "double":
-         {
-            for (let i = 0; i < numNumbers; ++ i)
-               data [i] = parseFloat (numbers [i]) / 16777216;
-
-            return;
-         }
+      temp[0] |= input;
+      index[0] += 8;
+      if (index[0] < 0) {
+        if (this.markerIndex !== 0) {
+          this.markerIndex = 0;
+          return (65280 | this.marker) << 8;
+        }
+        temp[0] <<= 8;
+        input = this.stream.get8();
+        if (input === 255) {
+          this.marker = this.stream.get8();
+          if (this.marker !== 0) {
+            this.markerIndex = 9;
+          }
+        }
+        temp[0] |= input;
+        index[0] += 8;
       }
-   },
-   raw ()
-   {
-      const
-         dataView   = this .dataView,
-         byteLength = dataView .byteLength,
-         dataLength = this .nrrd .components * this .nrrd .width * this .nrrd .height * this .nrrd .depth,
-         length     = dataLength * this .bytes,
-         data       = new Uint8Array (dataLength);
-
-      this .nrrd .data = data;
-
-      switch (this .byteType)
-      {
-         case "signed char":
-         case "unsigned char":
-         {
-            for (let i = byteLength - length, d = 0; i < byteLength; ++ i, ++ d)
-               data [d] = dataView .getUint8 (i);
-
-            return;
-         }
-         case "signed short":
-         case "unsigned short":
-         {
-            for (let i = byteLength - length, d = 0; i < byteLength; i += 2, ++ d)
-               data [d] = dataView .getUint16 (i, this .littleEndian) / 256;
-
-            return;
-         }
-         case "signed int":
-         case "unsigned int":
-         {
-            for (let i = byteLength - length, d = 0; i < byteLength; i += 4, ++ d)
-               data [d] = dataView .getUint32 (i, this .littleEndian) / 16777216;
-
-            return;
-         }
-         case "float":
-         {
-            for (let i = byteLength - length, d = 0; i < byteLength; i += 4, ++ d)
-               data [d] = dataView .getFloat32 (i, this .littleEndian) / 256;
-
-            return;
-         }
-         case "double":
-         {
-            for (let i = byteLength - length, d = 0; i < byteLength; i += 8, ++ d)
-               data [d] = dataView .getFloat64 (i, this .littleEndian) / 16777216;
-
-            return;
-         }
+      if (index[0] < 0) {
+        throw new Error("index=" + index[0] + " in getn()");
       }
-   },
-   hex ()
-   {
-      if (Grammar .data .parse (this))
-      {
-         const match = this .result [1] .match (/([0-9a-fA-F]{2})/g);
-
-         if (match)
-         {
-            const array = Uint8Array .from (match, value => parseInt (value, 16));
-
-            this .dataView = new DataView (array .buffer);
-
-            this .raw ();
-            return;
-         }
+      if (index[0] < this.markerIndex) {
+        this.markerIndex = 0;
+        return (65280 | this.marker) << 8;
       }
-
-      throw new Error ("Invalid NRRD data.");
-   },
-   gzip ()
-   {
-      try
-      {
-         if (!Grammar .newLine .parse (this))
-            throw new Error ("Invalid NRRD data.");
-
-         const
-            input       = this .dataView .buffer .slice (this .lastIndex),
-            arrayBuffer = jquery_default().ungzip (input);
-
-         this .dataView = new DataView (arrayBuffer);
-
-         this .raw ();
+      result = temp[0] >> index[0];
+      temp[0] &= mask >> 16 - index[0];
+    }
+    if (result < one << n - 1) {
+      result += (n_one << n) + 1;
+    }
+    return result;
+  }
+  getPreviousX(compOffset = 0) {
+    if (this.getter === null)
+      throw new Error("decode hasn't run yet");
+    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;
+    }
+  }
+  getPreviousXY(compOffset = 0) {
+    if (this.getter === null)
+      throw new Error("decode hasn't run yet");
+    if (this.xLoc > 0 && this.yLoc > 0) {
+      return this.getter((this.yLoc - 1) * this.xDim + this.xLoc - 1, compOffset);
+    } else {
+      return this.getPreviousY(compOffset);
+    }
+  }
+  getPreviousY(compOffset = 0) {
+    if (this.getter === null)
+      throw new Error("decode hasn't run yet");
+    if (this.yLoc > 0) {
+      return this.getter((this.yLoc - 1) * this.xDim + this.xLoc, compOffset);
+    } else {
+      return this.getPreviousX(compOffset);
+    }
+  }
+  isLastPixel() {
+    return this.xLoc === this.xDim - 1 && this.yLoc === this.yDim - 1;
+  }
+  outputSingle(PRED) {
+    if (this.setter === null)
+      throw new Error("decode hasn't run yet");
+    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;
       }
-      catch (error)
-      {
-         throw new Error (`Invalid NRRD data: ${error}.`);
+    }
+  }
+  outputRGB(PRED) {
+    if (this.setter === null)
+      throw new Error("decode hasn't run yet");
+    const 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;
       }
-   },
-});
-
-const NRRDParser_default_ = NRRDParser;
-;
+    }
+  }
+  setValue8(index, val) {
+    if (!this.outputData)
+      throw new Error("output data not ready");
+    if (littleEndian) {
+      this.outputData[index] = val;
+    } else {
+      this.outputData[index] = (val & 255) << 8 | val >> 8 & 255;
+    }
+  }
+  getValue8(index) {
+    if (this.outputData === null)
+      throw new Error("output data not ready");
+    if (littleEndian) {
+      return this.outputData[index];
+    } else {
+      const val = this.outputData[index];
+      return (val & 255) << 8 | val >> 8 & 255;
+    }
+  }
+  setValueRGB(index, val, compOffset = 0) {
+    if (this.outputData === null)
+      return;
+    this.outputData[index * 3 + compOffset] = val;
+  }
+  getValueRGB(index, compOffset) {
+    if (this.outputData === null)
+      throw new Error("output data not ready");
+    return this.outputData[index * 3 + compOffset];
+  }
+  readApp() {
+    if (this.stream === null)
+      return null;
+    let count = 0;
+    const length = this.stream.get16();
+    count += 2;
+    while (count < length) {
+      this.stream.get8();
+      count += 1;
+    }
+    return length;
+  }
+  readComment() {
+    if (this.stream === null)
+      return null;
+    let sb = "";
+    let count = 0;
+    const length = this.stream.get16();
+    count += 2;
+    while (count < length) {
+      sb += this.stream.get8();
+      count += 1;
+    }
+    return sb;
+  }
+  readNumber() {
+    if (this.stream === null)
+      return null;
+    const Ld = this.stream.get16();
+    if (Ld !== 4) {
+      throw new Error("ERROR: Define number format throw new IOException [Ld!=4]");
+    }
+    return this.stream.get16();
+  }
+};
 
-Namespace_default().add ("NRRDParser", "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__(706);
-/* provided dependency */ var JpegImage = __webpack_require__(306);
-/* provided dependency */ var jpeg = __webpack_require__(490);
-/* provided dependency */ var CharLS = __webpack_require__(544);
-/* provided dependency */ var OpenJPEG = __webpack_require__(154);
+/* provided dependency */ var dicomParser = __webpack_require__(44);
+/* provided dependency */ var JpegImage = __webpack_require__(80);
+/* provided dependency */ var CharLS = __webpack_require__(470);
+/* provided dependency */ var OpenJPEG = __webpack_require__(976);
 /*******************************************************************************
  *
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
@@ -7998,6 +7385,8 @@ Namespace_default().add ("NRRDParser", "x_ite/Browser/Texturing3D/NRRDParser", N
  *
  ******************************************************************************/
 
+
+
 function DicomParser ()
 {
    this .dicom = { dicom: false };
@@ -8646,7 +8035,7 @@ Object .assign (DicomParser .prototype,
     decodeJPEGLossless (pixelData)
     {
       const
-         decoder = new jpeg .lossless .Decoder (),
+         decoder = new Decoder (),
          buffer  = decoder .decompress (pixelData);
 
       return new Uint8Array (buffer);
@@ -9052,10 +8441,10 @@ const DICOMParser_default_ = DicomParser;
 Namespace_default().add ("DICOMParser", "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-9.4.4")] .require ("x_ite/InputOutput/FileLoader");
+const FileLoader_namespaceObject = window [Symbol .for ("X_ITE.X3D-9.5.0")] .require ("x_ite/InputOutput/FileLoader");
 var FileLoader_default = /*#__PURE__*/__webpack_require__.n(FileLoader_namespaceObject);
 ;// CONCATENATED MODULE: external "window [Symbol .for (\"X_ITE.X3D\")] .require (\"x_ite/DEVELOPMENT\")"
-const DEVELOPMENT_namespaceObject = window [Symbol .for ("X_ITE.X3D-9.4.4")] .require ("x_ite/DEVELOPMENT");
+const DEVELOPMENT_namespaceObject = window [Symbol .for ("X_ITE.X3D-9.5.0")] .require ("x_ite/DEVELOPMENT");
 var DEVELOPMENT_default = /*#__PURE__*/__webpack_require__.n(DEVELOPMENT_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Components/Texturing3D/ImageTexture3D.js
 /*******************************************************************************
@@ -9756,10 +9145,10 @@ const PixelTexture3D_default_ = PixelTexture3D;
 Namespace_default().add ("PixelTexture3D", "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-9.4.4")] .require ("x_ite/Components/Texturing/X3DSingleTextureCoordinateNode");
+const X3DSingleTextureCoordinateNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-9.5.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-9.4.4")] .require ("standard/Math/Numbers/Vector4");
+const Vector4_namespaceObject = window [Symbol .for ("X_ITE.X3D-9.5.0")] .require ("standard/Math/Numbers/Vector4");
 ;// CONCATENATED MODULE: ./src/x_ite/Components/Texturing3D/TextureCoordinate3D.js
 /*******************************************************************************
  *
@@ -10063,16 +9452,16 @@ const TextureCoordinate4D_default_ = TextureCoordinate4D;
 Namespace_default().add ("TextureCoordinate4D", "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-9.4.4")] .require ("x_ite/Components/Texturing/X3DSingleTextureTransformNode");
+const X3DSingleTextureTransformNode_namespaceObject = window [Symbol .for ("X_ITE.X3D-9.5.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-9.4.4")] .require ("standard/Math/Numbers/Vector3");
+const Vector3_namespaceObject = window [Symbol .for ("X_ITE.X3D-9.5.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-9.4.4")] .require ("standard/Math/Numbers/Rotation4");
+const Rotation4_namespaceObject = window [Symbol .for ("X_ITE.X3D-9.5.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-9.4.4")] .require ("standard/Math/Numbers/Matrix4");
+const Matrix4_namespaceObject = window [Symbol .for ("X_ITE.X3D-9.5.0")] .require ("standard/Math/Numbers/Matrix4");
 var Matrix4_default = /*#__PURE__*/__webpack_require__.n(Matrix4_namespaceObject);
 ;// CONCATENATED MODULE: ./src/x_ite/Components/Texturing3D/TextureTransform3D.js
 /*******************************************************************************