npm - @ohif/app - Versions diffs - 3.8.0 → 3.8.2 - Mend

@ohif/app 3.8.0 → 3.8.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

package/dist/cornerstoneDICOMImageLoader.min.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"cornerstoneDICOMImageLoader.min.js","mappings":"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","sources":["webpack:///webpack/universalModuleDefinition","webpack:///../../../node_modules/pako/lib/inflate.js","webpack:///../../../node_modules/pako/lib/utils/common.js","webpack:///../../../node_modules/pako/lib/utils/strings.js","webpack:///../../../node_modules/pako/lib/zlib/adler32.js","webpack:///../../../node_modules/pako/lib/zlib/constants.js","webpack:///../../../node_modules/pako/lib/zlib/crc32.js","webpack:///../../../node_modules/pako/lib/zlib/gzheader.js","webpack:///../../../node_modules/pako/lib/zlib/inffast.js","webpack:///../../../node_modules/pako/lib/zlib/inflate.js","webpack:///../../../node_modules/pako/lib/zlib/inftrees.js","webpack:///../../../node_modules/pako/lib/zlib/messages.js","webpack:///../../../node_modules/pako/lib/zlib/zstream.js","webpack:///external umd \"@cornerstonejs/core\"","webpack:///external umd {\"commonjs\":\"dicom-parser\",\"commonjs2\":\"dicom-parser\",\"amd\":\"dicom-parser\",\"root\":\"dicomParser\"}","webpack:///webpack/bootstrap","webpack:///webpack/runtime/define property getters","webpack:///webpack/runtime/global","webpack:///webpack/runtime/hasOwnProperty shorthand","webpack:///webpack/runtime/make namespace object","webpack:///webpack/runtime/publicPath","webpack:///./imageLoader/colorSpaceConverters/convertRGBColorByPixel.ts","webpack:///./imageLoader/colorSpaceConverters/convertRGBColorByPlane.ts","webpack:///./imageLoader/colorSpaceConverters/convertYBRFullByPixel.ts","webpack:///./imageLoader/colorSpaceConverters/convertYBRFullByPlane.ts","webpack:///./imageLoader/wadors/metaData/getValue.ts","webpack:///./imageLoader/wadors/metaData/getNumberString.ts","webpack:///./imageLoader/wadors/metaData/getNumberValue.ts","webpack:///./imageLoader/wadors/metaData/getNumberValues.ts","webpack:///./imageLoader/imageIdToURI.ts","webpack:///./imageLoader/wadors/getTagValue.ts","webpack:///./imageLoader/wadors/combineFrameInstance.ts","webpack:///./imageLoader/wadors/retrieveMultiframeMetadata.ts","webpack:///./imageLoader/wadors/metaDataManager.ts","webpack:///./imageLoader/isNMReconstructable.ts","webpack:///./imageLoader/wadors/metaData/NMHelpers.ts","webpack:///./imageLoader/wadors/metaData/extractPositioningFromMetadata.ts","webpack:///./imageLoader/getInstanceModule.ts","webpack:///./imageLoader/wadors/metaData/getFirstNumberValue.ts","webpack:///./imageLoader/wadors/metaData/getSequenceItems.ts","webpack:///./imageLoader/wadors/metaData/USHelpers.ts","webpack:///./imageLoader/wadors/metaData/metaDataProvider.ts","webpack:///./imageLoader/wadors/metaData/getOverlayPlaneModule.ts","webpack:///./imageLoader/wadors/findIndexOfString.ts","webpack:///./imageLoader/internal/options.ts","webpack:///./imageLoader/internal/xhrRequest.ts","webpack:///./imageLoader/internal/index.ts","webpack:///./imageLoader/wadors/extractMultipart.ts","webpack:///./imageLoader/wadors/getImageQualityStatus.ts","webpack:///./imageLoader/internal/streamRequest.ts","webpack:///./imageLoader/internal/rangeRequest.ts","webpack:///./imageLoader/wadors/getPixelData.ts","webpack:///./shared/getMinMax.ts","webpack:///./imageLoader/convertColorSpace.ts","webpack:///./imageLoader/colorSpaceConverters/convertYBRFull422ByPixel.ts","webpack:///./imageLoader/decodeJPEGBaseline8BitColor.ts","webpack:///./webWorker/index.worker.ts","webpack:///./imageLoader/webWorkerManager.ts","webpack:///./imageLoader/decodeImageFrame.ts","webpack:///./imageLoader/getImageFrame.ts","webpack:///./shared/isColorImage.ts","webpack:///./imageLoader/createImage.ts","webpack:///./shared/getPixelDataTypeFromMinMax.ts","webpack:///./imageLoader/getScalingParameters.ts","webpack:///./imageLoader/wadors/loadImage.ts","webpack:///./imageLoader/wadors/index.ts","webpack:///./imageLoader/wadors/register.ts","webpack:///./imageLoader/wadouri/metaData/getImagePixelModule.ts","webpack:///./imageLoader/wadouri/metaData/getLUTs.ts","webpack:///./imageLoader/wadouri/metaData/getModalityLUTOutputPixelRepresentation.ts","webpack:///./imageLoader/wadouri/metaData/getNumberValues.ts","webpack:///./imageLoader/wadouri/parseImageId.ts","webpack:///./imageLoader/wadouri/dataset-from-partial-content.ts","webpack:///./imageLoader/wadouri/combineFrameInstanceDataset.ts","webpack:///./imageLoader/wadouri/retrieveMultiframeDataset.ts","webpack:///./imageLoader/wadouri/dataSetCacheManager.ts","webpack:///./imageLoader/wadouri/metaData/extractPositioningFromDataset.ts","webpack:///./imageLoader/wadouri/metaData/metaDataProvider.ts","webpack:///./imageLoader/wadouri/metaData/getOverlayPlaneModule.ts","webpack:///./imageLoader/wadouri/fileManager.ts","webpack:///./imageLoader/wadouri/getEncapsulatedImageFrame.ts","webpack:///./imageLoader/wadouri/unpackBinaryFrame.ts","webpack:///./imageLoader/wadouri/getUncompressedImageFrame.ts","webpack:///./imageLoader/wadouri/loadFileRequest.ts","webpack:///./imageLoader/wadouri/getPixelData.ts","webpack:///./imageLoader/wadouri/loadImage.ts","webpack:///./imageLoader/wadouri/index.ts","webpack:///./imageLoader/wadouri/register.ts","webpack:///./imageLoader/registerLoaders.ts","webpack:///./externalModules.ts","webpack:///./imageLoader/colorSpaceConverters/convertPALETTECOLOR.ts","webpack:///./imageLoader/configure.ts","webpack:///./imageLoader/isJPEGBaseline8BitColor.ts","webpack:///./imageLoader/index.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"@cornerstonejs/core\"), require(\"dicom-parser\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"cornerstoneDICOMImageLoader\", [\"@cornerstonejs/core\", \"dicom-parser\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"cornerstoneDICOMImageLoader\"] = factory(require(\"@cornerstonejs/core\"), require(\"dicom-parser\"));\n\telse\n\t\troot[\"cornerstoneDICOMImageLoader\"] = factory(root[\"@cornerstonejs/core\"], root[\"dicomParser\"]);\n})(this, (__WEBPACK_EXTERNAL_MODULE__464__, __WEBPACK_EXTERNAL_MODULE__713__) => {\nreturn ","'use strict';\n\n\nconst zlib_inflate = require('./zlib/inflate');\nconst utils = require('./utils/common');\nconst strings = require('./utils/strings');\nconst msg = require('./zlib/messages');\nconst ZStream = require('./zlib/zstream');\nconst GZheader = require('./zlib/gzheader');\n\nconst toString = Object.prototype.toString;\n\n/* Public constants ==========================================================/\n/ ===========================================================================/\n\nconst {\n Z_NO_FLUSH, Z_FINISH,\n Z_OK, Z_STREAM_END, Z_NEED_DICT, Z_STREAM_ERROR, Z_DATA_ERROR, Z_MEM_ERROR\n} = require('./zlib/constants');\n\n/ ===========================================================================/\n\n\n/\n class Inflate\n \n Generic JS-style wrapper for zlib calls. If you don't need\n * streaming behaviour - use more simple functions: [[inflate]]\n * and [[inflateRaw]].\n */\n\n/ internal\n * inflate.chunks -> Array\n \n Chunks of output data, if [[Inflate#onData]] not overridden.\n /\n\n/\n * Inflate.result -> Uint8Array\|String\n \n Uncompressed result, generated by default [[Inflate#onData]]\n * and [[Inflate#onEnd]] handlers. Filled after you push last chunk\n * (call [[Inflate#push]] with `Z_FINISH` / `true` param).\n /\n\n/\n * Inflate.err -> Number\n \n Error code after inflate finished. 0 (Z_OK) on success.\n * Should be checked if broken data possible.\n /\n\n/\n * Inflate.msg -> String\n \n Error message, if [[Inflate.err]] != 0\n /\n\n\n/\n * new Inflate(options)\n * - options (Object): zlib inflate options.\n \n Creates new inflator instance with specified params. Throws exception\n * on bad params. Supported options:\n \n - `windowBits`\n * - `dictionary`\n \n [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n * for more information on these.\n \n Additional options, for internal needs:\n \n - `chunkSize` - size of generated data chunks (16K by default)\n * - `raw` (Boolean) - do raw inflate\n * - `to` (String) - if equal to 'string', then result will be converted\n * from utf8 to utf16 (javascript) string. When string output requested,\n * chunk length can differ from `chunkSize`, depending on content.\n \n By default, when no options set, autodetect deflate/gzip data format via\n * wrapper header.\n \n ##### Example:\n \n ```javascript\n * const pako = require('pako')\n * const chunk1 = new Uint8Array([1,2,3,4,5,6,7,8,9])\n * const chunk2 = new Uint8Array([10,11,12,13,14,15,16,17,18,19]);\n \n const inflate = new pako.Inflate({ level: 3});\n \n inflate.push(chunk1, false);\n * inflate.push(chunk2, true); // true -> last chunk\n \n if (inflate.err) { throw new Error(inflate.err); }\n \n console.log(inflate.result);\n * ```\n */\nfunction Inflate(options) {\n this.options = utils.assign({\n chunkSize: 1024 64,\n windowBits: 15,\n to: ''\n }, options \|\| {});\n\n const opt = this.options;\n\n // Force window size for `raw` data, if not set directly,\n // because we have no header for autodetect.\n if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) {\n opt.windowBits = -opt.windowBits;\n if (opt.windowBits === 0) { opt.windowBits = -15; }\n }\n\n // If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate\n if ((opt.windowBits >= 0) && (opt.windowBits < 16) &&\n !(options && options.windowBits)) {\n opt.windowBits += 32;\n }\n\n // Gzip header has no info about windows size, we can do autodetect only\n // for deflate. So, if window size not set, force it to max when gzip possible\n if ((opt.windowBits > 15) && (opt.windowBits < 48)) {\n // bit 3 (16) -> gzipped data\n // bit 4 (32) -> autodetect gzip/deflate\n if ((opt.windowBits & 15) === 0) {\n opt.windowBits \|= 15;\n }\n }\n\n this.err = 0; // error code, if happens (0 = Z_OK)\n this.msg = ''; // error message\n this.ended = false; // used to avoid multiple onEnd() calls\n this.chunks = []; // chunks of compressed data\n\n this.strm = new ZStream();\n this.strm.avail_out = 0;\n\n let status = zlib_inflate.inflateInit2(\n this.strm,\n opt.windowBits\n );\n\n if (status !== Z_OK) {\n throw new Error(msg[status]);\n }\n\n this.header = new GZheader();\n\n zlib_inflate.inflateGetHeader(this.strm, this.header);\n\n // Setup dictionary\n if (opt.dictionary) {\n // Convert data if needed\n if (typeof opt.dictionary === 'string') {\n opt.dictionary = strings.string2buf(opt.dictionary);\n } else if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {\n opt.dictionary = new Uint8Array(opt.dictionary);\n }\n if (opt.raw) { //In raw mode we need to set the dictionary early\n status = zlib_inflate.inflateSetDictionary(this.strm, opt.dictionary);\n if (status !== Z_OK) {\n throw new Error(msg[status]);\n }\n }\n }\n}\n\n/*\n Inflate#push(data[, flush_mode]) -> Boolean\n * - data (Uint8Array\|ArrayBuffer): input data\n * - flush_mode (Number\|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE\n * flush modes. See constants. Skipped or `false` means Z_NO_FLUSH,\n * `true` means Z_FINISH.\n \n Sends input data to inflate pipe, generating [[Inflate#onData]] calls with\n * new output chunks. Returns `true` on success. If end of stream detected,\n * [[Inflate#onEnd]] will be called.\n \n `flush_mode` is not needed for normal operation, because end of stream\n * detected automatically. You may try to use it for advanced things, but\n * this functionality was not tested.\n \n On fail call [[Inflate#onEnd]] with error code and return false.\n \n ##### Example\n \n ```javascript\n * push(chunk, false); // push one of data chunks\n * ...\n * push(chunk, true); // push last chunk\n * ```\n /\nInflate.prototype.push = function (data, flush_mode) {\n const strm = this.strm;\n const chunkSize = this.options.chunkSize;\n const dictionary = this.options.dictionary;\n let status, _flush_mode, last_avail_out;\n\n if (this.ended) return false;\n\n if (flush_mode === ~~flush_mode) _flush_mode = flush_mode;\n else _flush_mode = flush_mode === true ? Z_FINISH : Z_NO_FLUSH;\n\n // Convert data if needed\n if (toString.call(data) === '[object ArrayBuffer]') {\n strm.input = new Uint8Array(data);\n } else {\n strm.input = data;\n }\n\n strm.next_in = 0;\n strm.avail_in = strm.input.length;\n\n for (;;) {\n if (strm.avail_out === 0) {\n strm.output = new Uint8Array(chunkSize);\n strm.next_out = 0;\n strm.avail_out = chunkSize;\n }\n\n status = zlib_inflate.inflate(strm, _flush_mode);\n\n if (status === Z_NEED_DICT && dictionary) {\n status = zlib_inflate.inflateSetDictionary(strm, dictionary);\n\n if (status === Z_OK) {\n status = zlib_inflate.inflate(strm, _flush_mode);\n } else if (status === Z_DATA_ERROR) {\n // Replace code with more verbose\n status = Z_NEED_DICT;\n }\n }\n\n // Skip snyc markers if more data follows and not raw mode\n while (strm.avail_in > 0 &&\n status === Z_STREAM_END &&\n strm.state.wrap > 0 &&\n data[strm.next_in] !== 0)\n {\n zlib_inflate.inflateReset(strm);\n status = zlib_inflate.inflate(strm, _flush_mode);\n }\n\n switch (status) {\n case Z_STREAM_ERROR:\n case Z_DATA_ERROR:\n case Z_NEED_DICT:\n case Z_MEM_ERROR:\n this.onEnd(status);\n this.ended = true;\n return false;\n }\n\n // Remember real `avail_out` value, because we may patch out buffer content\n // to align utf8 strings boundaries.\n last_avail_out = strm.avail_out;\n\n if (strm.next_out) {\n if (strm.avail_out === 0 \|\| status === Z_STREAM_END) {\n\n if (this.options.to === 'string') {\n\n let next_out_utf8 = strings.utf8border(strm.output, strm.next_out);\n\n let tail = strm.next_out - next_out_utf8;\n let utf8str = strings.buf2string(strm.output, next_out_utf8);\n\n // move tail & realign counters\n strm.next_out = tail;\n strm.avail_out = chunkSize - tail;\n if (tail) strm.output.set(strm.output.subarray(next_out_utf8, next_out_utf8 + tail), 0);\n\n this.onData(utf8str);\n\n } else {\n this.onData(strm.output.length === strm.next_out ? strm.output : strm.output.subarray(0, strm.next_out));\n }\n }\n }\n\n // Must repeat iteration if out buffer is full\n if (status === Z_OK && last_avail_out === 0) continue;\n\n // Finalize if end of stream reached.\n if (status === Z_STREAM_END) {\n status = zlib_inflate.inflateEnd(this.strm);\n this.onEnd(status);\n this.ended = true;\n return true;\n }\n\n if (strm.avail_in === 0) break;\n }\n\n return true;\n};\n\n\n/\n * Inflate#onData(chunk) -> Void\n * - chunk (Uint8Array\|String): output data. When string output requested,\n * each chunk will be string.\n \n By default, stores data blocks in `chunks[]` property and glue\n * those in `onEnd`. Override this handler, if you need another behaviour.\n /\nInflate.prototype.onData = function (chunk) {\n this.chunks.push(chunk);\n};\n\n\n/\n * Inflate#onEnd(status) -> Void\n * - status (Number): inflate status. 0 (Z_OK) on success,\n * other if not.\n \n Called either after you tell inflate that the input stream is\n * complete (Z_FINISH). By default - join collected chunks,\n * free memory and fill `results` / `err` properties.\n /\nInflate.prototype.onEnd = function (status) {\n // On success - join\n if (status === Z_OK) {\n if (this.options.to === 'string') {\n this.result = this.chunks.join('');\n } else {\n this.result = utils.flattenChunks(this.chunks);\n }\n }\n this.chunks = [];\n this.err = status;\n this.msg = this.strm.msg;\n};\n\n\n/\n * inflate(data[, options]) -> Uint8Array\|String\n * - data (Uint8Array\|ArrayBuffer): input data to decompress.\n * - options (Object): zlib inflate options.\n \n Decompress `data` with inflate/ungzip and `options`. Autodetect\n * format via wrapper header by default. That's why we don't provide\n * separate `ungzip` method.\n \n Supported options are:\n \n - windowBits\n \n [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n * for more information.\n \n Sugar (options):\n \n - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify\n * negative windowBits implicitly.\n * - `to` (String) - if equal to 'string', then result will be converted\n * from utf8 to utf16 (javascript) string. When string output requested,\n * chunk length can differ from `chunkSize`, depending on content.\n \n \n * ##### Example:\n \n ```javascript\n * const pako = require('pako');\n * const input = pako.deflate(new Uint8Array([1,2,3,4,5,6,7,8,9]));\n * let output;\n \n try {\n * output = pako.inflate(input);\n * } catch (err) {\n * console.log(err);\n * }\n * ```\n /\nfunction inflate(input, options) {\n const inflator = new Inflate(options);\n\n inflator.push(input);\n\n // That will never happens, if you don't cheat with options :)\n if (inflator.err) throw inflator.msg \|\| msg[inflator.err];\n\n return inflator.result;\n}\n\n\n/\n * inflateRaw(data[, options]) -> Uint8Array\|String\n * - data (Uint8Array\|ArrayBuffer): input data to decompress.\n * - options (Object): zlib inflate options.\n \n The same as [[inflate]], but creates raw data, without wrapper\n * (header and adler32 crc).\n /\nfunction inflateRaw(input, options) {\n options = options \|\| {};\n options.raw = true;\n return inflate(input, options);\n}\n\n\n/\n * ungzip(data[, options]) -> Uint8Array\|String\n * - data (Uint8Array\|ArrayBuffer): input data to decompress.\n * - options (Object): zlib inflate options.\n \n Just shortcut to [[inflate]], because it autodetects format\n * by header.content. Done for convenience.\n */\n\n\nmodule.exports.Inflate = Inflate;\nmodule.exports.inflate = inflate;\nmodule.exports.inflateRaw = inflateRaw;\nmodule.exports.ungzip = inflate;\nmodule.exports.constants = require('./zlib/constants');\n","'use strict';\n\n\nconst _has = (obj, key) => {\n return Object.prototype.hasOwnProperty.call(obj, key);\n};\n\nmodule.exports.assign = function (obj /from1, from2, from3, .../) {\n const sources = Array.prototype.slice.call(arguments, 1);\n while (sources.length) {\n const source = sources.shift();\n if (!source) { continue; }\n\n if (typeof source !== 'object') {\n throw new TypeError(source + 'must be non-object');\n }\n\n for (const p in source) {\n if (_has(source, p)) {\n obj[p] = source[p];\n }\n }\n }\n\n return obj;\n};\n\n\n// Join array of chunks to single array.\nmodule.exports.flattenChunks = (chunks) => {\n // calculate data length\n let len = 0;\n\n for (let i = 0, l = chunks.length; i < l; i++) {\n len += chunks[i].length;\n }\n\n // join chunks\n const result = new Uint8Array(len);\n\n for (let i = 0, pos = 0, l = chunks.length; i < l; i++) {\n let chunk = chunks[i];\n result.set(chunk, pos);\n pos += chunk.length;\n }\n\n return result;\n};\n","// String encode/decode helpers\n'use strict';\n\n\n// Quick check if we can use fast array to bin string conversion\n//\n// - apply(Array) can fail on Android 2.2\n// - apply(Uint8Array) can fail on iOS 5.1 Safari\n//\nlet STR_APPLY_UIA_OK = true;\n\ntry { String.fromCharCode.apply(null, new Uint8Array(1)); } catch (__) { STR_APPLY_UIA_OK = false; }\n\n\n// Table with utf8 lengths (calculated by first byte of sequence)\n// Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,\n// because max possible codepoint is 0x10ffff\nconst _utf8len = new Uint8Array(256);\nfor (let q = 0; q < 256; q++) {\n _utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1);\n}\n_utf8len[254] = _utf8len[254] = 1; // Invalid sequence start\n\n\n// convert string to array (typed, when possible)\nmodule.exports.string2buf = (str) => {\n if (typeof TextEncoder === 'function' && TextEncoder.prototype.encode) {\n return new TextEncoder().encode(str);\n }\n\n let buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;\n\n // count binary size\n for (m_pos = 0; m_pos < str_len; m_pos++) {\n c = str.charCodeAt(m_pos);\n if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {\n c2 = str.charCodeAt(m_pos + 1);\n if ((c2 & 0xfc00) === 0xdc00) {\n c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n m_pos++;\n }\n }\n buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;\n }\n\n // allocate buffer\n buf = new Uint8Array(buf_len);\n\n // convert\n for (i = 0, m_pos = 0; i < buf_len; m_pos++) {\n c = str.charCodeAt(m_pos);\n if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {\n c2 = str.charCodeAt(m_pos + 1);\n if ((c2 & 0xfc00) === 0xdc00) {\n c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n m_pos++;\n }\n }\n if (c < 0x80) {\n / one byte /\n buf[i++] = c;\n } else if (c < 0x800) {\n / two bytes /\n buf[i++] = 0xC0 \| (c >>> 6);\n buf[i++] = 0x80 \| (c & 0x3f);\n } else if (c < 0x10000) {\n / three bytes /\n buf[i++] = 0xE0 \| (c >>> 12);\n buf[i++] = 0x80 \| (c >>> 6 & 0x3f);\n buf[i++] = 0x80 \| (c & 0x3f);\n } else {\n / four bytes /\n buf[i++] = 0xf0 \| (c >>> 18);\n buf[i++] = 0x80 \| (c >>> 12 & 0x3f);\n buf[i++] = 0x80 \| (c >>> 6 & 0x3f);\n buf[i++] = 0x80 \| (c & 0x3f);\n }\n }\n\n return buf;\n};\n\n// Helper\nconst buf2binstring = (buf, len) => {\n // On Chrome, the arguments in a function call that are allowed is `65534`.\n // If the length of the buffer is smaller than that, we can use this optimization,\n // otherwise we will take a slower path.\n if (len < 65534) {\n if (buf.subarray && STR_APPLY_UIA_OK) {\n return String.fromCharCode.apply(null, buf.length === len ? buf : buf.subarray(0, len));\n }\n }\n\n let result = '';\n for (let i = 0; i < len; i++) {\n result += String.fromCharCode(buf[i]);\n }\n return result;\n};\n\n\n// convert array to string\nmodule.exports.buf2string = (buf, max) => {\n const len = max \|\| buf.length;\n\n if (typeof TextDecoder === 'function' && TextDecoder.prototype.decode) {\n return new TextDecoder().decode(buf.subarray(0, max));\n }\n\n let i, out;\n\n // Reserve max possible length (2 words per char)\n // NB: by unknown reasons, Array is significantly faster for\n // String.fromCharCode.apply than Uint16Array.\n const utf16buf = new Array(len 2);\n\n for (out = 0, i = 0; i < len;) {\n let c = buf[i++];\n // quick process ascii\n if (c < 0x80) { utf16buf[out++] = c; continue; }\n\n let c_len = _utf8len[c];\n // skip 5 & 6 byte codes\n if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len - 1; continue; }\n\n // apply mask on first byte\n c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;\n // join the rest\n while (c_len > 1 && i < len) {\n c = (c << 6) \| (buf[i++] & 0x3f);\n c_len--;\n }\n\n // terminated by end of string?\n if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }\n\n if (c < 0x10000) {\n utf16buf[out++] = c;\n } else {\n c -= 0x10000;\n utf16buf[out++] = 0xd800 \| ((c >> 10) & 0x3ff);\n utf16buf[out++] = 0xdc00 \| (c & 0x3ff);\n }\n }\n\n return buf2binstring(utf16buf, out);\n};\n\n\n// Calculate max possible position in utf8 buffer,\n// that will not break sequence. If that's not possible\n// - (very small limits) return max size as is.\n//\n// buf[] - utf8 bytes array\n// max - length limit (mandatory);\nmodule.exports.utf8border = (buf, max) => {\n\n max = max \|\| buf.length;\n if (max > buf.length) { max = buf.length; }\n\n // go back from last position, until start of sequence found\n let pos = max - 1;\n while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }\n\n // Very small and broken sequence,\n // return max, because we should return something anyway.\n if (pos < 0) { return max; }\n\n // If we came to start of buffer - that means buffer is too small,\n // return max too.\n if (pos === 0) { return max; }\n\n return (pos + _utf8len[buf[pos]] > max) ? pos : max;\n};\n","'use strict';\n\n// Note: adler32 takes 12% for level 0 and 2% for level 6.\n// It isn't worth it to make additional optimizations as in original.\n// Small size is preferable.\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nconst adler32 = (adler, buf, len, pos) => {\n let s1 = (adler & 0xffff) \|0,\n s2 = ((adler >>> 16) & 0xffff) \|0,\n n = 0;\n\n while (len !== 0) {\n // Set limit ~ twice less than 5552, to keep\n // s2 in 31-bits, because we force signed ints.\n // in other case %= will fail.\n n = len > 2000 ? 2000 : len;\n len -= n;\n\n do {\n s1 = (s1 + buf[pos++]) \|0;\n s2 = (s2 + s1) \|0;\n } while (--n);\n\n s1 %= 65521;\n s2 %= 65521;\n }\n\n return (s1 \| (s2 << 16)) \|0;\n};\n\n\nmodule.exports = adler32;\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nmodule.exports = {\n\n /* Allowed flush values; see deflate() and inflate() below for details /\n Z_NO_FLUSH: 0,\n Z_PARTIAL_FLUSH: 1,\n Z_SYNC_FLUSH: 2,\n Z_FULL_FLUSH: 3,\n Z_FINISH: 4,\n Z_BLOCK: 5,\n Z_TREES: 6,\n\n / Return codes for the compression/decompression functions. Negative values\n * are errors, positive values are used for special but normal events.\n /\n Z_OK: 0,\n Z_STREAM_END: 1,\n Z_NEED_DICT: 2,\n Z_ERRNO: -1,\n Z_STREAM_ERROR: -2,\n Z_DATA_ERROR: -3,\n Z_MEM_ERROR: -4,\n Z_BUF_ERROR: -5,\n //Z_VERSION_ERROR: -6,\n\n / compression levels /\n Z_NO_COMPRESSION: 0,\n Z_BEST_SPEED: 1,\n Z_BEST_COMPRESSION: 9,\n Z_DEFAULT_COMPRESSION: -1,\n\n\n Z_FILTERED: 1,\n Z_HUFFMAN_ONLY: 2,\n Z_RLE: 3,\n Z_FIXED: 4,\n Z_DEFAULT_STRATEGY: 0,\n\n / Possible values of the data_type field (though see inflate()) /\n Z_BINARY: 0,\n Z_TEXT: 1,\n //Z_ASCII: 1, // = Z_TEXT (deprecated)\n Z_UNKNOWN: 2,\n\n / The deflate compression method /\n Z_DEFLATED: 8\n //Z_NULL: null // Use -1 or null inline, depending on var type\n};\n","'use strict';\n\n// Note: we can't get significant speed boost here.\n// So write code to minimize size - no pregenerated tables\n// and array tools dependencies.\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\n// Use ordinary array, since untyped makes no boost here\nconst makeTable = () => {\n let c, table = [];\n\n for (var n = 0; n < 256; n++) {\n c = n;\n for (var k = 0; k < 8; k++) {\n c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));\n }\n table[n] = c;\n }\n\n return table;\n};\n\n// Create table on load. Just 255 signed longs. Not a problem.\nconst crcTable = new Uint32Array(makeTable());\n\n\nconst crc32 = (crc, buf, len, pos) => {\n const t = crcTable;\n const end = pos + len;\n\n crc ^= -1;\n\n for (let i = pos; i < end; i++) {\n crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];\n }\n\n return (crc ^ (-1)); // >>> 0;\n};\n\n\nmodule.exports = crc32;\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nfunction GZheader() {\n / true if compressed data believed to be text /\n this.text = 0;\n / modification time /\n this.time = 0;\n / extra flags (not used when writing a gzip file) /\n this.xflags = 0;\n / operating system /\n this.os = 0;\n / pointer to extra field or Z_NULL if none /\n this.extra = null;\n / extra field length (valid if extra != Z_NULL) /\n this.extra_len = 0; // Actually, we don't need it in JS,\n // but leave for few code modifications\n\n //\n // Setup limits is not necessary because in js we should not preallocate memory\n // for inflate use constant limit in 65536 bytes\n //\n\n / space at extra (only when reading header) /\n // this.extra_max = 0;\n / pointer to zero-terminated file name or Z_NULL /\n this.name = '';\n / space at name (only when reading header) /\n // this.name_max = 0;\n / pointer to zero-terminated comment or Z_NULL /\n this.comment = '';\n / space at comment (only when reading header) /\n // this.comm_max = 0;\n / true if there was or will be a header crc /\n this.hcrc = 0;\n / true when done reading gzip header (not used when writing a gzip file) /\n this.done = false;\n}\n\nmodule.exports = GZheader;\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\n// See state defs from inflate.js\nconst BAD = 16209; / got a data error -- remain here until reset /\nconst TYPE = 16191; / i: waiting for type bits, including last-flag bit /\n\n/\n Decode literal, length, and distance codes and write out the resulting\n literal and match bytes until either not enough input or output is\n available, an end-of-block is encountered, or a data error is encountered.\n When large enough input and output buffers are supplied to inflate(), for\n example, a 16K input buffer and a 64K output buffer, more than 95% of the\n inflate execution time is spent in this routine.\n\n Entry assumptions:\n\n state.mode === LEN\n strm.avail_in >= 6\n strm.avail_out >= 258\n start >= strm.avail_out\n state.bits < 8\n\n On return, state.mode is one of:\n\n LEN -- ran out of enough output space or enough available input\n TYPE -- reached end of block code, inflate() to interpret next block\n BAD -- error in block data\n\n Notes:\n\n - The maximum input bits used by a length/distance pair is 15 bits for the\n length code, 5 bits for the length extra, 15 bits for the distance code,\n and 13 bits for the distance extra. This totals 48 bits, or six bytes.\n Therefore if strm.avail_in >= 6, then there is enough input to avoid\n checking for available input while decoding.\n\n - The maximum bytes that a single length/distance pair can output is 258\n bytes, which is the maximum length that can be coded. inflate_fast()\n requires strm.avail_out >= 258 for each loop to avoid checking for\n output space.\n /\nmodule.exports = function inflate_fast(strm, start) {\n let _in; / local strm.input /\n let last; / have enough input while in < last /\n let _out; / local strm.output /\n let beg; / inflate()'s initial strm.output /\n let end; / while out < end, enough space available /\n//#ifdef INFLATE_STRICT\n let dmax; / maximum distance from zlib header /\n//#endif\n let wsize; / window size or zero if not using window /\n let whave; / valid bytes in the window /\n let wnext; / window write index /\n // Use `s_window` instead `window`, avoid conflict with instrumentation tools\n let s_window; / allocated sliding window, if wsize != 0 /\n let hold; / local strm.hold /\n let bits; / local strm.bits /\n let lcode; / local strm.lencode /\n let dcode; / local strm.distcode /\n let lmask; / mask for first level of length codes /\n let dmask; / mask for first level of distance codes /\n let here; / retrieved table entry /\n let op; / code bits, operation, extra bits, or /\n / window position, window bytes to copy /\n let len; / match length, unused bytes /\n let dist; / match distance /\n let from; / where to copy match from /\n let from_source;\n\n\n let input, output; // JS specific, because we have no pointers\n\n / copy state to local variables /\n const state = strm.state;\n //here = state.here;\n _in = strm.next_in;\n input = strm.input;\n last = _in + (strm.avail_in - 5);\n _out = strm.next_out;\n output = strm.output;\n beg = _out - (start - strm.avail_out);\n end = _out + (strm.avail_out - 257);\n//#ifdef INFLATE_STRICT\n dmax = state.dmax;\n//#endif\n wsize = state.wsize;\n whave = state.whave;\n wnext = state.wnext;\n s_window = state.window;\n hold = state.hold;\n bits = state.bits;\n lcode = state.lencode;\n dcode = state.distcode;\n lmask = (1 << state.lenbits) - 1;\n dmask = (1 << state.distbits) - 1;\n\n\n / decode literals and length/distances until end-of-block or not enough\n input data or output space /\n\n top:\n do {\n if (bits < 15) {\n hold += input[_in++] << bits;\n bits += 8;\n hold += input[_in++] << bits;\n bits += 8;\n }\n\n here = lcode[hold & lmask];\n\n dolen:\n for (;;) { // Goto emulation\n op = here >>> 24/here.bits/;\n hold >>>= op;\n bits -= op;\n op = (here >>> 16) & 0xff/here.op/;\n if (op === 0) { / literal /\n //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?\n // \"inflate: literal '%c'\\n\" :\n // \"inflate: literal 0x%02x\\n\", here.val));\n output[_out++] = here & 0xffff/here.val/;\n }\n else if (op & 16) { / length base /\n len = here & 0xffff/here.val/;\n op &= 15; / number of extra bits /\n if (op) {\n if (bits < op) {\n hold += input[_in++] << bits;\n bits += 8;\n }\n len += hold & ((1 << op) - 1);\n hold >>>= op;\n bits -= op;\n }\n //Tracevv((stderr, \"inflate: length %u\\n\", len));\n if (bits < 15) {\n hold += input[_in++] << bits;\n bits += 8;\n hold += input[_in++] << bits;\n bits += 8;\n }\n here = dcode[hold & dmask];\n\n dodist:\n for (;;) { // goto emulation\n op = here >>> 24/here.bits/;\n hold >>>= op;\n bits -= op;\n op = (here >>> 16) & 0xff/here.op/;\n\n if (op & 16) { / distance base /\n dist = here & 0xffff/here.val/;\n op &= 15; / number of extra bits /\n if (bits < op) {\n hold += input[_in++] << bits;\n bits += 8;\n if (bits < op) {\n hold += input[_in++] << bits;\n bits += 8;\n }\n }\n dist += hold & ((1 << op) - 1);\n//#ifdef INFLATE_STRICT\n if (dist > dmax) {\n strm.msg = 'invalid distance too far back';\n state.mode = BAD;\n break top;\n }\n//#endif\n hold >>>= op;\n bits -= op;\n //Tracevv((stderr, \"inflate: distance %u\\n\", dist));\n op = _out - beg; / max distance in output /\n if (dist > op) { / see if copy from window /\n op = dist - op; / distance back in window /\n if (op > whave) {\n if (state.sane) {\n strm.msg = 'invalid distance too far back';\n state.mode = BAD;\n break top;\n }\n\n// (!) This block is disabled in zlib defaults,\n// don't enable it for binary compatibility\n//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR\n// if (len <= op - whave) {\n// do {\n// output[_out++] = 0;\n// } while (--len);\n// continue top;\n// }\n// len -= op - whave;\n// do {\n// output[_out++] = 0;\n// } while (--op > whave);\n// if (op === 0) {\n// from = _out - dist;\n// do {\n// output[_out++] = output[from++];\n// } while (--len);\n// continue top;\n// }\n//#endif\n }\n from = 0; // window index\n from_source = s_window;\n if (wnext === 0) { / very common case /\n from += wsize - op;\n if (op < len) { / some from window /\n len -= op;\n do {\n output[_out++] = s_window[from++];\n } while (--op);\n from = _out - dist; / rest from output /\n from_source = output;\n }\n }\n else if (wnext < op) { / wrap around window /\n from += wsize + wnext - op;\n op -= wnext;\n if (op < len) { / some from end of window /\n len -= op;\n do {\n output[_out++] = s_window[from++];\n } while (--op);\n from = 0;\n if (wnext < len) { / some from start of window /\n op = wnext;\n len -= op;\n do {\n output[_out++] = s_window[from++];\n } while (--op);\n from = _out - dist; / rest from output /\n from_source = output;\n }\n }\n }\n else { / contiguous in window /\n from += wnext - op;\n if (op < len) { / some from window /\n len -= op;\n do {\n output[_out++] = s_window[from++];\n } while (--op);\n from = _out - dist; / rest from output /\n from_source = output;\n }\n }\n while (len > 2) {\n output[_out++] = from_source[from++];\n output[_out++] = from_source[from++];\n output[_out++] = from_source[from++];\n len -= 3;\n }\n if (len) {\n output[_out++] = from_source[from++];\n if (len > 1) {\n output[_out++] = from_source[from++];\n }\n }\n }\n else {\n from = _out - dist; / copy direct from output /\n do { / minimum length is three /\n output[_out++] = output[from++];\n output[_out++] = output[from++];\n output[_out++] = output[from++];\n len -= 3;\n } while (len > 2);\n if (len) {\n output[_out++] = output[from++];\n if (len > 1) {\n output[_out++] = output[from++];\n }\n }\n }\n }\n else if ((op & 64) === 0) { / 2nd level distance code /\n here = dcode[(here & 0xffff)/here.val/ + (hold & ((1 << op) - 1))];\n continue dodist;\n }\n else {\n strm.msg = 'invalid distance code';\n state.mode = BAD;\n break top;\n }\n\n break; // need to emulate goto via \"continue\"\n }\n }\n else if ((op & 64) === 0) { / 2nd level length code /\n here = lcode[(here & 0xffff)/here.val/ + (hold & ((1 << op) - 1))];\n continue dolen;\n }\n else if (op & 32) { / end-of-block /\n //Tracevv((stderr, \"inflate: end of block\\n\"));\n state.mode = TYPE;\n break top;\n }\n else {\n strm.msg = 'invalid literal/length code';\n state.mode = BAD;\n break top;\n }\n\n break; // need to emulate goto via \"continue\"\n }\n } while (_in < last && _out < end);\n\n / return unused bytes (on entry, bits < 8, so in won't go too far back) /\n len = bits >> 3;\n _in -= len;\n bits -= len << 3;\n hold &= (1 << bits) - 1;\n\n / update state and return /\n strm.next_in = _in;\n strm.next_out = _out;\n strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));\n strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));\n state.hold = hold;\n state.bits = bits;\n return;\n};\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nconst adler32 = require('./adler32');\nconst crc32 = require('./crc32');\nconst inflate_fast = require('./inffast');\nconst inflate_table = require('./inftrees');\n\nconst CODES = 0;\nconst LENS = 1;\nconst DISTS = 2;\n\n/ Public constants ==========================================================/\n/ ===========================================================================/\n\nconst {\n Z_FINISH, Z_BLOCK, Z_TREES,\n Z_OK, Z_STREAM_END, Z_NEED_DICT, Z_STREAM_ERROR, Z_DATA_ERROR, Z_MEM_ERROR, Z_BUF_ERROR,\n Z_DEFLATED\n} = require('./constants');\n\n\n/ STATES ====================================================================/\n/ ===========================================================================/\n\n\nconst HEAD = 16180; / i: waiting for magic header /\nconst FLAGS = 16181; / i: waiting for method and flags (gzip) /\nconst TIME = 16182; / i: waiting for modification time (gzip) /\nconst OS = 16183; / i: waiting for extra flags and operating system (gzip) /\nconst EXLEN = 16184; / i: waiting for extra length (gzip) /\nconst EXTRA = 16185; / i: waiting for extra bytes (gzip) /\nconst NAME = 16186; / i: waiting for end of file name (gzip) /\nconst COMMENT = 16187; / i: waiting for end of comment (gzip) /\nconst HCRC = 16188; / i: waiting for header crc (gzip) /\nconst DICTID = 16189; / i: waiting for dictionary check value /\nconst DICT = 16190; / waiting for inflateSetDictionary() call /\nconst TYPE = 16191; / i: waiting for type bits, including last-flag bit /\nconst TYPEDO = 16192; / i: same, but skip check to exit inflate on new block /\nconst STORED = 16193; / i: waiting for stored size (length and complement) /\nconst COPY_ = 16194; / i/o: same as COPY below, but only first time in /\nconst COPY = 16195; / i/o: waiting for input or output to copy stored block /\nconst TABLE = 16196; / i: waiting for dynamic block table lengths /\nconst LENLENS = 16197; / i: waiting for code length code lengths /\nconst CODELENS = 16198; / i: waiting for length/lit and distance code lengths /\nconst LEN_ = 16199; / i: same as LEN below, but only first time in /\nconst LEN = 16200; / i: waiting for length/lit/eob code /\nconst LENEXT = 16201; / i: waiting for length extra bits /\nconst DIST = 16202; / i: waiting for distance code /\nconst DISTEXT = 16203; / i: waiting for distance extra bits /\nconst MATCH = 16204; / o: waiting for output space to copy string /\nconst LIT = 16205; / o: waiting for output space to write literal /\nconst CHECK = 16206; / i: waiting for 32-bit check value /\nconst LENGTH = 16207; / i: waiting for 32-bit length (gzip) /\nconst DONE = 16208; / finished check, done -- remain here until reset /\nconst BAD = 16209; / got a data error -- remain here until reset /\nconst MEM = 16210; / got an inflate() memory error -- remain here until reset /\nconst SYNC = 16211; / looking for synchronization bytes to restart inflate() /\n\n/ ===========================================================================/\n\n\n\nconst ENOUGH_LENS = 852;\nconst ENOUGH_DISTS = 592;\n//const ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);\n\nconst MAX_WBITS = 15;\n/ 32K LZ77 window /\nconst DEF_WBITS = MAX_WBITS;\n\n\nconst zswap32 = (q) => {\n\n return (((q >>> 24) & 0xff) +\n ((q >>> 8) & 0xff00) +\n ((q & 0xff00) << 8) +\n ((q & 0xff) << 24));\n};\n\n\nfunction InflateState() {\n this.strm = null; / pointer back to this zlib stream /\n this.mode = 0; / current inflate mode /\n this.last = false; / true if processing last block /\n this.wrap = 0; / bit 0 true for zlib, bit 1 true for gzip,\n bit 2 true to validate check value /\n this.havedict = false; / true if dictionary provided /\n this.flags = 0; / gzip header method and flags (0 if zlib), or\n -1 if raw or no header yet /\n this.dmax = 0; / zlib header max distance (INFLATE_STRICT) /\n this.check = 0; / protected copy of check value /\n this.total = 0; / protected copy of output count /\n // TODO: may be {}\n this.head = null; / where to save gzip header information /\n\n / sliding window /\n this.wbits = 0; / log base 2 of requested window size /\n this.wsize = 0; / window size or zero if not using window /\n this.whave = 0; / valid bytes in the window /\n this.wnext = 0; / window write index /\n this.window = null; / allocated sliding window, if needed /\n\n / bit accumulator /\n this.hold = 0; / input bit accumulator /\n this.bits = 0; / number of bits in \"in\" /\n\n / for string and stored block copying /\n this.length = 0; / literal or length of data to copy /\n this.offset = 0; / distance back to copy string from /\n\n / for table and code decoding /\n this.extra = 0; / extra bits needed /\n\n / fixed and dynamic code tables /\n this.lencode = null; / starting table for length/literal codes /\n this.distcode = null; / starting table for distance codes /\n this.lenbits = 0; / index bits for lencode /\n this.distbits = 0; / index bits for distcode /\n\n / dynamic table building /\n this.ncode = 0; / number of code length code lengths /\n this.nlen = 0; / number of length code lengths /\n this.ndist = 0; / number of distance code lengths /\n this.have = 0; / number of code lengths in lens[] /\n this.next = null; / next available space in codes[] /\n\n this.lens = new Uint16Array(320); / temporary storage for code lengths /\n this.work = new Uint16Array(288); / work area for code table building /\n\n /\n because we don't have pointers in js, we use lencode and distcode directly\n as buffers so we don't need codes\n /\n //this.codes = new Int32Array(ENOUGH); / space for code tables /\n this.lendyn = null; / dynamic table for length/literal codes (JS specific) /\n this.distdyn = null; / dynamic table for distance codes (JS specific) /\n this.sane = 0; / if false, allow invalid distance too far /\n this.back = 0; / bits back of last unprocessed length/lit /\n this.was = 0; / initial length of match /\n}\n\n\nconst inflateStateCheck = (strm) => {\n\n if (!strm) {\n return 1;\n }\n const state = strm.state;\n if (!state \|\| state.strm !== strm \|\|\n state.mode < HEAD \|\| state.mode > SYNC) {\n return 1;\n }\n return 0;\n};\n\n\nconst inflateResetKeep = (strm) => {\n\n if (inflateStateCheck(strm)) { return Z_STREAM_ERROR; }\n const state = strm.state;\n strm.total_in = strm.total_out = state.total = 0;\n strm.msg = ''; /Z_NULL/\n if (state.wrap) { / to support ill-conceived Java test suite /\n strm.adler = state.wrap & 1;\n }\n state.mode = HEAD;\n state.last = 0;\n state.havedict = 0;\n state.flags = -1;\n state.dmax = 32768;\n state.head = null/Z_NULL/;\n state.hold = 0;\n state.bits = 0;\n //state.lencode = state.distcode = state.next = state.codes;\n state.lencode = state.lendyn = new Int32Array(ENOUGH_LENS);\n state.distcode = state.distdyn = new Int32Array(ENOUGH_DISTS);\n\n state.sane = 1;\n state.back = -1;\n //Tracev((stderr, \"inflate: reset\\n\"));\n return Z_OK;\n};\n\n\nconst inflateReset = (strm) => {\n\n if (inflateStateCheck(strm)) { return Z_STREAM_ERROR; }\n const state = strm.state;\n state.wsize = 0;\n state.whave = 0;\n state.wnext = 0;\n return inflateResetKeep(strm);\n\n};\n\n\nconst inflateReset2 = (strm, windowBits) => {\n let wrap;\n\n / get the state /\n if (inflateStateCheck(strm)) { return Z_STREAM_ERROR; }\n const state = strm.state;\n\n / extract wrap request from windowBits parameter /\n if (windowBits < 0) {\n wrap = 0;\n windowBits = -windowBits;\n }\n else {\n wrap = (windowBits >> 4) + 5;\n if (windowBits < 48) {\n windowBits &= 15;\n }\n }\n\n / set number of window bits, free window if different /\n if (windowBits && (windowBits < 8 \|\| windowBits > 15)) {\n return Z_STREAM_ERROR;\n }\n if (state.window !== null && state.wbits !== windowBits) {\n state.window = null;\n }\n\n / update state and reset the rest of it /\n state.wrap = wrap;\n state.wbits = windowBits;\n return inflateReset(strm);\n};\n\n\nconst inflateInit2 = (strm, windowBits) => {\n\n if (!strm) { return Z_STREAM_ERROR; }\n //strm.msg = Z_NULL; / in case we return an error /\n\n const state = new InflateState();\n\n //if (state === Z_NULL) return Z_MEM_ERROR;\n //Tracev((stderr, \"inflate: allocated\\n\"));\n strm.state = state;\n state.strm = strm;\n state.window = null/Z_NULL/;\n state.mode = HEAD; / to pass state test in inflateReset2() /\n const ret = inflateReset2(strm, windowBits);\n if (ret !== Z_OK) {\n strm.state = null/Z_NULL/;\n }\n return ret;\n};\n\n\nconst inflateInit = (strm) => {\n\n return inflateInit2(strm, DEF_WBITS);\n};\n\n\n/\n Return state with length and distance decoding tables and index sizes set to\n fixed code decoding. Normally this returns fixed tables from inffixed.h.\n If BUILDFIXED is defined, then instead this routine builds the tables the\n first time it's called, and returns those tables the first time and\n thereafter. This reduces the size of the code by about 2K bytes, in\n exchange for a little execution time. However, BUILDFIXED should not be\n used for threaded applications, since the rewriting of the tables and virgin\n may not be thread-safe.\n /\nlet virgin = true;\n\nlet lenfix, distfix; // We have no pointers in JS, so keep tables separate\n\n\nconst fixedtables = (state) => {\n\n / build fixed huffman tables if first call (may not be thread safe) /\n if (virgin) {\n lenfix = new Int32Array(512);\n distfix = new Int32Array(32);\n\n / literal/length table /\n let sym = 0;\n while (sym < 144) { state.lens[sym++] = 8; }\n while (sym < 256) { state.lens[sym++] = 9; }\n while (sym < 280) { state.lens[sym++] = 7; }\n while (sym < 288) { state.lens[sym++] = 8; }\n\n inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });\n\n / distance table /\n sym = 0;\n while (sym < 32) { state.lens[sym++] = 5; }\n\n inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });\n\n / do this just once /\n virgin = false;\n }\n\n state.lencode = lenfix;\n state.lenbits = 9;\n state.distcode = distfix;\n state.distbits = 5;\n};\n\n\n/\n Update the window with the last wsize (normally 32K) bytes written before\n returning. If window does not exist yet, create it. This is only called\n when a window is already in use, or when output has been written during this\n inflate call, but the end of the deflate stream has not been reached yet.\n It is also called to create a window for dictionary data when a dictionary\n is loaded.\n\n Providing output buffers larger than 32K to inflate() should provide a speed\n advantage, since only the last 32K of output is copied to the sliding window\n upon return from inflate(), and since all distances after the first 32K of\n output will fall in the output data, making match copies simpler and faster.\n The advantage may be dependent on the size of the processor's data caches.\n /\nconst updatewindow = (strm, src, end, copy) => {\n\n let dist;\n const state = strm.state;\n\n / if it hasn't been done already, allocate space for the window /\n if (state.window === null) {\n state.wsize = 1 << state.wbits;\n state.wnext = 0;\n state.whave = 0;\n\n state.window = new Uint8Array(state.wsize);\n }\n\n / copy state->wsize or less output bytes into the circular window /\n if (copy >= state.wsize) {\n state.window.set(src.subarray(end - state.wsize, end), 0);\n state.wnext = 0;\n state.whave = state.wsize;\n }\n else {\n dist = state.wsize - state.wnext;\n if (dist > copy) {\n dist = copy;\n }\n //zmemcpy(state->window + state->wnext, end - copy, dist);\n state.window.set(src.subarray(end - copy, end - copy + dist), state.wnext);\n copy -= dist;\n if (copy) {\n //zmemcpy(state->window, end - copy, copy);\n state.window.set(src.subarray(end - copy, end), 0);\n state.wnext = copy;\n state.whave = state.wsize;\n }\n else {\n state.wnext += dist;\n if (state.wnext === state.wsize) { state.wnext = 0; }\n if (state.whave < state.wsize) { state.whave += dist; }\n }\n }\n return 0;\n};\n\n\nconst inflate = (strm, flush) => {\n\n let state;\n let input, output; // input/output buffers\n let next; / next input INDEX /\n let put; / next output INDEX /\n let have, left; / available input and output /\n let hold; / bit buffer /\n let bits; / bits in bit buffer /\n let _in, _out; / save starting available input and output /\n let copy; / number of stored or match bytes to copy /\n let from; / where to copy match bytes from /\n let from_source;\n let here = 0; / current decoding table entry /\n let here_bits, here_op, here_val; // paked \"here\" denormalized (JS specific)\n //let last; / parent table entry /\n let last_bits, last_op, last_val; // paked \"last\" denormalized (JS specific)\n let len; / length to copy for repeats, bits to drop /\n let ret; / return code /\n const hbuf = new Uint8Array(4); / buffer for gzip header crc calculation /\n let opts;\n\n let n; // temporary variable for NEED_BITS\n\n const order = / permutation of code lengths /\n new Uint8Array([ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ]);\n\n\n if (inflateStateCheck(strm) \|\| !strm.output \|\|\n (!strm.input && strm.avail_in !== 0)) {\n return Z_STREAM_ERROR;\n }\n\n state = strm.state;\n if (state.mode === TYPE) { state.mode = TYPEDO; } / skip check /\n\n\n //--- LOAD() ---\n put = strm.next_out;\n output = strm.output;\n left = strm.avail_out;\n next = strm.next_in;\n input = strm.input;\n have = strm.avail_in;\n hold = state.hold;\n bits = state.bits;\n //---\n\n _in = have;\n _out = left;\n ret = Z_OK;\n\n inf_leave: // goto emulation\n for (;;) {\n switch (state.mode) {\n case HEAD:\n if (state.wrap === 0) {\n state.mode = TYPEDO;\n break;\n }\n //=== NEEDBITS(16);\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if ((state.wrap & 2) && hold === 0x8b1f) { / gzip header /\n if (state.wbits === 0) {\n state.wbits = 15;\n }\n state.check = 0/crc32(0L, Z_NULL, 0)/;\n //=== CRC2(state.check, hold);\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n state.check = crc32(state.check, hbuf, 2, 0);\n //===//\n\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = FLAGS;\n break;\n }\n if (state.head) {\n state.head.done = false;\n }\n if (!(state.wrap & 1) \|\| / check if zlib header allowed /\n (((hold & 0xff)/BITS(8)/ << 8) + (hold >> 8)) % 31) {\n strm.msg = 'incorrect header check';\n state.mode = BAD;\n break;\n }\n if ((hold & 0x0f)/BITS(4)/ !== Z_DEFLATED) {\n strm.msg = 'unknown compression method';\n state.mode = BAD;\n break;\n }\n //--- DROPBITS(4) ---//\n hold >>>= 4;\n bits -= 4;\n //---//\n len = (hold & 0x0f)/BITS(4)/ + 8;\n if (state.wbits === 0) {\n state.wbits = len;\n }\n if (len > 15 \|\| len > state.wbits) {\n strm.msg = 'invalid window size';\n state.mode = BAD;\n break;\n }\n\n // !!! pako patch. Force use `options.windowBits` if passed.\n // Required to always use max window size by default.\n state.dmax = 1 << state.wbits;\n //state.dmax = 1 << len;\n\n state.flags = 0; / indicate zlib header /\n //Tracev((stderr, \"inflate: zlib header ok\\n\"));\n strm.adler = state.check = 1/adler32(0L, Z_NULL, 0)/;\n state.mode = hold & 0x200 ? DICTID : TYPE;\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n break;\n case FLAGS:\n //=== NEEDBITS(16); /\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.flags = hold;\n if ((state.flags & 0xff) !== Z_DEFLATED) {\n strm.msg = 'unknown compression method';\n state.mode = BAD;\n break;\n }\n if (state.flags & 0xe000) {\n strm.msg = 'unknown header flags set';\n state.mode = BAD;\n break;\n }\n if (state.head) {\n state.head.text = ((hold >> 8) & 1);\n }\n if ((state.flags & 0x0200) && (state.wrap & 4)) {\n //=== CRC2(state.check, hold);\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n state.check = crc32(state.check, hbuf, 2, 0);\n //===//\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = TIME;\n /* falls through /\n case TIME:\n //=== NEEDBITS(32); /\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if (state.head) {\n state.head.time = hold;\n }\n if ((state.flags & 0x0200) && (state.wrap & 4)) {\n //=== CRC4(state.check, hold)\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n hbuf[2] = (hold >>> 16) & 0xff;\n hbuf[3] = (hold >>> 24) & 0xff;\n state.check = crc32(state.check, hbuf, 4, 0);\n //===\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = OS;\n /* falls through /\n case OS:\n //=== NEEDBITS(16); /\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if (state.head) {\n state.head.xflags = (hold & 0xff);\n state.head.os = (hold >> 8);\n }\n if ((state.flags & 0x0200) && (state.wrap & 4)) {\n //=== CRC2(state.check, hold);\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n state.check = crc32(state.check, hbuf, 2, 0);\n //===//\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = EXLEN;\n /* falls through /\n case EXLEN:\n if (state.flags & 0x0400) {\n //=== NEEDBITS(16); /\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.length = hold;\n if (state.head) {\n state.head.extra_len = hold;\n }\n if ((state.flags & 0x0200) && (state.wrap & 4)) {\n //=== CRC2(state.check, hold);\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n state.check = crc32(state.check, hbuf, 2, 0);\n //===//\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n }\n else if (state.head) {\n state.head.extra = null/Z_NULL/;\n }\n state.mode = EXTRA;\n /* falls through /\n case EXTRA:\n if (state.flags & 0x0400) {\n copy = state.length;\n if (copy > have) { copy = have; }\n if (copy) {\n if (state.head) {\n len = state.head.extra_len - state.length;\n if (!state.head.extra) {\n // Use untyped array for more convenient processing later\n state.head.extra = new Uint8Array(state.head.extra_len);\n }\n state.head.extra.set(\n input.subarray(\n next,\n // extra field is limited to 65536 bytes\n // - no need for additional size check\n next + copy\n ),\n /len + copy > state.head.extra_max - len ? state.head.extra_max : copy,/\n len\n );\n //zmemcpy(state.head.extra + len, next,\n // len + copy > state.head.extra_max ?\n // state.head.extra_max - len : copy);\n }\n if ((state.flags & 0x0200) && (state.wrap & 4)) {\n state.check = crc32(state.check, input, copy, next);\n }\n have -= copy;\n next += copy;\n state.length -= copy;\n }\n if (state.length) { break inf_leave; }\n }\n state.length = 0;\n state.mode = NAME;\n / falls through /\n case NAME:\n if (state.flags & 0x0800) {\n if (have === 0) { break inf_leave; }\n copy = 0;\n do {\n // TODO: 2 or 1 bytes?\n len = input[next + copy++];\n / use constant limit because in js we should not preallocate memory /\n if (state.head && len &&\n (state.length < 65536 /state.head.name_max/)) {\n state.head.name += String.fromCharCode(len);\n }\n } while (len && copy < have);\n\n if ((state.flags & 0x0200) && (state.wrap & 4)) {\n state.check = crc32(state.check, input, copy, next);\n }\n have -= copy;\n next += copy;\n if (len) { break inf_leave; }\n }\n else if (state.head) {\n state.head.name = null;\n }\n state.length = 0;\n state.mode = COMMENT;\n / falls through /\n case COMMENT:\n if (state.flags & 0x1000) {\n if (have === 0) { break inf_leave; }\n copy = 0;\n do {\n len = input[next + copy++];\n / use constant limit because in js we should not preallocate memory /\n if (state.head && len &&\n (state.length < 65536 /state.head.comm_max/)) {\n state.head.comment += String.fromCharCode(len);\n }\n } while (len && copy < have);\n if ((state.flags & 0x0200) && (state.wrap & 4)) {\n state.check = crc32(state.check, input, copy, next);\n }\n have -= copy;\n next += copy;\n if (len) { break inf_leave; }\n }\n else if (state.head) {\n state.head.comment = null;\n }\n state.mode = HCRC;\n / falls through /\n case HCRC:\n if (state.flags & 0x0200) {\n //=== NEEDBITS(16); /\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if ((state.wrap & 4) && hold !== (state.check & 0xffff)) {\n strm.msg = 'header crc mismatch';\n state.mode = BAD;\n break;\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n }\n if (state.head) {\n state.head.hcrc = ((state.flags >> 9) & 1);\n state.head.done = true;\n }\n strm.adler = state.check = 0;\n state.mode = TYPE;\n break;\n case DICTID:\n //=== NEEDBITS(32); /\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n strm.adler = state.check = zswap32(hold);\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = DICT;\n / falls through /\n case DICT:\n if (state.havedict === 0) {\n //--- RESTORE() ---\n strm.next_out = put;\n strm.avail_out = left;\n strm.next_in = next;\n strm.avail_in = have;\n state.hold = hold;\n state.bits = bits;\n //---\n return Z_NEED_DICT;\n }\n strm.adler = state.check = 1/adler32(0L, Z_NULL, 0)/;\n state.mode = TYPE;\n / falls through /\n case TYPE:\n if (flush === Z_BLOCK \|\| flush === Z_TREES) { break inf_leave; }\n / falls through /\n case TYPEDO:\n if (state.last) {\n //--- BYTEBITS() ---//\n hold >>>= bits & 7;\n bits -= bits & 7;\n //---//\n state.mode = CHECK;\n break;\n }\n //=== NEEDBITS(3); /\n while (bits < 3) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.last = (hold & 0x01)/BITS(1)/;\n //--- DROPBITS(1) ---//\n hold >>>= 1;\n bits -= 1;\n //---//\n\n switch ((hold & 0x03)/BITS(2)/) {\n case 0: /* stored block /\n //Tracev((stderr, \"inflate: stored block%s\\n\",\n // state.last ? \" (last)\" : \"\"));\n state.mode = STORED;\n break;\n case 1: / fixed block /\n fixedtables(state);\n //Tracev((stderr, \"inflate: fixed codes block%s\\n\",\n // state.last ? \" (last)\" : \"\"));\n state.mode = LEN_; / decode codes /\n if (flush === Z_TREES) {\n //--- DROPBITS(2) ---//\n hold >>>= 2;\n bits -= 2;\n //---//\n break inf_leave;\n }\n break;\n case 2: / dynamic block /\n //Tracev((stderr, \"inflate: dynamic codes block%s\\n\",\n // state.last ? \" (last)\" : \"\"));\n state.mode = TABLE;\n break;\n case 3:\n strm.msg = 'invalid block type';\n state.mode = BAD;\n }\n //--- DROPBITS(2) ---//\n hold >>>= 2;\n bits -= 2;\n //---//\n break;\n case STORED:\n //--- BYTEBITS() ---// / go to byte boundary /\n hold >>>= bits & 7;\n bits -= bits & 7;\n //---//\n //=== NEEDBITS(32); /\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) {\n strm.msg = 'invalid stored block lengths';\n state.mode = BAD;\n break;\n }\n state.length = hold & 0xffff;\n //Tracev((stderr, \"inflate: stored length %u\\n\",\n // state.length));\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = COPY_;\n if (flush === Z_TREES) { break inf_leave; }\n /* falls through /\n case COPY_:\n state.mode = COPY;\n / falls through /\n case COPY:\n copy = state.length;\n if (copy) {\n if (copy > have) { copy = have; }\n if (copy > left) { copy = left; }\n if (copy === 0) { break inf_leave; }\n //--- zmemcpy(put, next, copy); ---\n output.set(input.subarray(next, next + copy), put);\n //---//\n have -= copy;\n next += copy;\n left -= copy;\n put += copy;\n state.length -= copy;\n break;\n }\n //Tracev((stderr, \"inflate: stored end\\n\"));\n state.mode = TYPE;\n break;\n case TABLE:\n //=== NEEDBITS(14); /\n while (bits < 14) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.nlen = (hold & 0x1f)/BITS(5)/ + 257;\n //--- DROPBITS(5) ---//\n hold >>>= 5;\n bits -= 5;\n //---//\n state.ndist = (hold & 0x1f)/BITS(5)/ + 1;\n //--- DROPBITS(5) ---//\n hold >>>= 5;\n bits -= 5;\n //---//\n state.ncode = (hold & 0x0f)/BITS(4)/ + 4;\n //--- DROPBITS(4) ---//\n hold >>>= 4;\n bits -= 4;\n //---//\n//#ifndef PKZIP_BUG_WORKAROUND\n if (state.nlen > 286 \|\| state.ndist > 30) {\n strm.msg = 'too many length or distance symbols';\n state.mode = BAD;\n break;\n }\n//#endif\n //Tracev((stderr, \"inflate: table sizes ok\\n\"));\n state.have = 0;\n state.mode = LENLENS;\n /* falls through /\n case LENLENS:\n while (state.have < state.ncode) {\n //=== NEEDBITS(3);\n while (bits < 3) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.lens[order[state.have++]] = (hold & 0x07);//BITS(3);\n //--- DROPBITS(3) ---//\n hold >>>= 3;\n bits -= 3;\n //---//\n }\n while (state.have < 19) {\n state.lens[order[state.have++]] = 0;\n }\n // We have separate tables & no pointers. 2 commented lines below not needed.\n //state.next = state.codes;\n //state.lencode = state.next;\n // Switch to use dynamic table\n state.lencode = state.lendyn;\n state.lenbits = 7;\n\n opts = { bits: state.lenbits };\n ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);\n state.lenbits = opts.bits;\n\n if (ret) {\n strm.msg = 'invalid code lengths set';\n state.mode = BAD;\n break;\n }\n //Tracev((stderr, \"inflate: code lengths ok\\n\"));\n state.have = 0;\n state.mode = CODELENS;\n / falls through /\n case CODELENS:\n while (state.have < state.nlen + state.ndist) {\n for (;;) {\n here = state.lencode[hold & ((1 << state.lenbits) - 1)];/BITS(state.lenbits)/\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if ((here_bits) <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n if (here_val < 16) {\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n state.lens[state.have++] = here_val;\n }\n else {\n if (here_val === 16) {\n //=== NEEDBITS(here.bits + 2);\n n = here_bits + 2;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n if (state.have === 0) {\n strm.msg = 'invalid bit length repeat';\n state.mode = BAD;\n break;\n }\n len = state.lens[state.have - 1];\n copy = 3 + (hold & 0x03);//BITS(2);\n //--- DROPBITS(2) ---//\n hold >>>= 2;\n bits -= 2;\n //---//\n }\n else if (here_val === 17) {\n //=== NEEDBITS(here.bits + 3);\n n = here_bits + 3;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n len = 0;\n copy = 3 + (hold & 0x07);//BITS(3);\n //--- DROPBITS(3) ---//\n hold >>>= 3;\n bits -= 3;\n //---//\n }\n else {\n //=== NEEDBITS(here.bits + 7);\n n = here_bits + 7;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n len = 0;\n copy = 11 + (hold & 0x7f);//BITS(7);\n //--- DROPBITS(7) ---//\n hold >>>= 7;\n bits -= 7;\n //---//\n }\n if (state.have + copy > state.nlen + state.ndist) {\n strm.msg = 'invalid bit length repeat';\n state.mode = BAD;\n break;\n }\n while (copy--) {\n state.lens[state.have++] = len;\n }\n }\n }\n\n / handle error breaks in while /\n if (state.mode === BAD) { break; }\n\n / check for end-of-block code (better have one) /\n if (state.lens[256] === 0) {\n strm.msg = 'invalid code -- missing end-of-block';\n state.mode = BAD;\n break;\n }\n\n / build code tables -- note: do not change the lenbits or distbits\n values here (9 and 6) without reading the comments in inftrees.h\n concerning the ENOUGH constants, which depend on those values /\n state.lenbits = 9;\n\n opts = { bits: state.lenbits };\n ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);\n // We have separate tables & no pointers. 2 commented lines below not needed.\n // state.next_index = opts.table_index;\n state.lenbits = opts.bits;\n // state.lencode = state.next;\n\n if (ret) {\n strm.msg = 'invalid literal/lengths set';\n state.mode = BAD;\n break;\n }\n\n state.distbits = 6;\n //state.distcode.copy(state.codes);\n // Switch to use dynamic table\n state.distcode = state.distdyn;\n opts = { bits: state.distbits };\n ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);\n // We have separate tables & no pointers. 2 commented lines below not needed.\n // state.next_index = opts.table_index;\n state.distbits = opts.bits;\n // state.distcode = state.next;\n\n if (ret) {\n strm.msg = 'invalid distances set';\n state.mode = BAD;\n break;\n }\n //Tracev((stderr, 'inflate: codes ok\\n'));\n state.mode = LEN_;\n if (flush === Z_TREES) { break inf_leave; }\n / falls through /\n case LEN_:\n state.mode = LEN;\n / falls through /\n case LEN:\n if (have >= 6 && left >= 258) {\n //--- RESTORE() ---\n strm.next_out = put;\n strm.avail_out = left;\n strm.next_in = next;\n strm.avail_in = have;\n state.hold = hold;\n state.bits = bits;\n //---\n inflate_fast(strm, _out);\n //--- LOAD() ---\n put = strm.next_out;\n output = strm.output;\n left = strm.avail_out;\n next = strm.next_in;\n input = strm.input;\n have = strm.avail_in;\n hold = state.hold;\n bits = state.bits;\n //---\n\n if (state.mode === TYPE) {\n state.back = -1;\n }\n break;\n }\n state.back = 0;\n for (;;) {\n here = state.lencode[hold & ((1 << state.lenbits) - 1)]; /BITS(state.lenbits)/\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if (here_bits <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n if (here_op && (here_op & 0xf0) === 0) {\n last_bits = here_bits;\n last_op = here_op;\n last_val = here_val;\n for (;;) {\n here = state.lencode[last_val +\n ((hold & ((1 << (last_bits + last_op)) - 1))/BITS(last.bits + last.op)/ >> last_bits)];\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if ((last_bits + here_bits) <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n //--- DROPBITS(last.bits) ---//\n hold >>>= last_bits;\n bits -= last_bits;\n //---//\n state.back += last_bits;\n }\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n state.back += here_bits;\n state.length = here_val;\n if (here_op === 0) {\n //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?\n // \"inflate: literal '%c'\\n\" :\n // \"inflate: literal 0x%02x\\n\", here.val));\n state.mode = LIT;\n break;\n }\n if (here_op & 32) {\n //Tracevv((stderr, \"inflate: end of block\\n\"));\n state.back = -1;\n state.mode = TYPE;\n break;\n }\n if (here_op & 64) {\n strm.msg = 'invalid literal/length code';\n state.mode = BAD;\n break;\n }\n state.extra = here_op & 15;\n state.mode = LENEXT;\n / falls through /\n case LENEXT:\n if (state.extra) {\n //=== NEEDBITS(state.extra);\n n = state.extra;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.length += hold & ((1 << state.extra) - 1)/BITS(state.extra)/;\n //--- DROPBITS(state.extra) ---//\n hold >>>= state.extra;\n bits -= state.extra;\n //---//\n state.back += state.extra;\n }\n //Tracevv((stderr, \"inflate: length %u\\n\", state.length));\n state.was = state.length;\n state.mode = DIST;\n / falls through /\n case DIST:\n for (;;) {\n here = state.distcode[hold & ((1 << state.distbits) - 1)];/BITS(state.distbits)/\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if ((here_bits) <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n if ((here_op & 0xf0) === 0) {\n last_bits = here_bits;\n last_op = here_op;\n last_val = here_val;\n for (;;) {\n here = state.distcode[last_val +\n ((hold & ((1 << (last_bits + last_op)) - 1))/BITS(last.bits + last.op)/ >> last_bits)];\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if ((last_bits + here_bits) <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n //--- DROPBITS(last.bits) ---//\n hold >>>= last_bits;\n bits -= last_bits;\n //---//\n state.back += last_bits;\n }\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n state.back += here_bits;\n if (here_op & 64) {\n strm.msg = 'invalid distance code';\n state.mode = BAD;\n break;\n }\n state.offset = here_val;\n state.extra = (here_op) & 15;\n state.mode = DISTEXT;\n / falls through /\n case DISTEXT:\n if (state.extra) {\n //=== NEEDBITS(state.extra);\n n = state.extra;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.offset += hold & ((1 << state.extra) - 1)/BITS(state.extra)/;\n //--- DROPBITS(state.extra) ---//\n hold >>>= state.extra;\n bits -= state.extra;\n //---//\n state.back += state.extra;\n }\n//#ifdef INFLATE_STRICT\n if (state.offset > state.dmax) {\n strm.msg = 'invalid distance too far back';\n state.mode = BAD;\n break;\n }\n//#endif\n //Tracevv((stderr, \"inflate: distance %u\\n\", state.offset));\n state.mode = MATCH;\n / falls through /\n case MATCH:\n if (left === 0) { break inf_leave; }\n copy = _out - left;\n if (state.offset > copy) { / copy from window /\n copy = state.offset - copy;\n if (copy > state.whave) {\n if (state.sane) {\n strm.msg = 'invalid distance too far back';\n state.mode = BAD;\n break;\n }\n// (!) This block is disabled in zlib defaults,\n// don't enable it for binary compatibility\n//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR\n// Trace((stderr, \"inflate.c too far\\n\"));\n// copy -= state.whave;\n// if (copy > state.length) { copy = state.length; }\n// if (copy > left) { copy = left; }\n// left -= copy;\n// state.length -= copy;\n// do {\n// output[put++] = 0;\n// } while (--copy);\n// if (state.length === 0) { state.mode = LEN; }\n// break;\n//#endif\n }\n if (copy > state.wnext) {\n copy -= state.wnext;\n from = state.wsize - copy;\n }\n else {\n from = state.wnext - copy;\n }\n if (copy > state.length) { copy = state.length; }\n from_source = state.window;\n }\n else { / copy from output /\n from_source = output;\n from = put - state.offset;\n copy = state.length;\n }\n if (copy > left) { copy = left; }\n left -= copy;\n state.length -= copy;\n do {\n output[put++] = from_source[from++];\n } while (--copy);\n if (state.length === 0) { state.mode = LEN; }\n break;\n case LIT:\n if (left === 0) { break inf_leave; }\n output[put++] = state.length;\n left--;\n state.mode = LEN;\n break;\n case CHECK:\n if (state.wrap) {\n //=== NEEDBITS(32);\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n // Use '\|' instead of '+' to make sure that result is signed\n hold \|= input[next++] << bits;\n bits += 8;\n }\n //===//\n _out -= left;\n strm.total_out += _out;\n state.total += _out;\n if ((state.wrap & 4) && _out) {\n strm.adler = state.check =\n /UPDATE_CHECK(state.check, put - _out, _out);/\n (state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out));\n\n }\n _out = left;\n // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too\n if ((state.wrap & 4) && (state.flags ? hold : zswap32(hold)) !== state.check) {\n strm.msg = 'incorrect data check';\n state.mode = BAD;\n break;\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n //Tracev((stderr, \"inflate: check matches trailer\\n\"));\n }\n state.mode = LENGTH;\n / falls through /\n case LENGTH:\n if (state.wrap && state.flags) {\n //=== NEEDBITS(32);\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if ((state.wrap & 4) && hold !== (state.total & 0xffffffff)) {\n strm.msg = 'incorrect length check';\n state.mode = BAD;\n break;\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n //Tracev((stderr, \"inflate: length matches trailer\\n\"));\n }\n state.mode = DONE;\n / falls through /\n case DONE:\n ret = Z_STREAM_END;\n break inf_leave;\n case BAD:\n ret = Z_DATA_ERROR;\n break inf_leave;\n case MEM:\n return Z_MEM_ERROR;\n case SYNC:\n / falls through /\n default:\n return Z_STREAM_ERROR;\n }\n }\n\n // inf_leave <- here is real place for \"goto inf_leave\", emulated via \"break inf_leave\"\n\n /\n Return from inflate(), updating the total counts and the check value.\n If there was no progress during the inflate() call, return a buffer\n error. Call updatewindow() to create and/or update the window state.\n Note: a memory error from inflate() is non-recoverable.\n /\n\n //--- RESTORE() ---\n strm.next_out = put;\n strm.avail_out = left;\n strm.next_in = next;\n strm.avail_in = have;\n state.hold = hold;\n state.bits = bits;\n //---\n\n if (state.wsize \|\| (_out !== strm.avail_out && state.mode < BAD &&\n (state.mode < CHECK \|\| flush !== Z_FINISH))) {\n if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) {\n state.mode = MEM;\n return Z_MEM_ERROR;\n }\n }\n _in -= strm.avail_in;\n _out -= strm.avail_out;\n strm.total_in += _in;\n strm.total_out += _out;\n state.total += _out;\n if ((state.wrap & 4) && _out) {\n strm.adler = state.check = /UPDATE_CHECK(state.check, strm.next_out - _out, _out);/\n (state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out));\n }\n strm.data_type = state.bits + (state.last ? 64 : 0) +\n (state.mode === TYPE ? 128 : 0) +\n (state.mode === LEN_ \|\| state.mode === COPY_ ? 256 : 0);\n if (((_in === 0 && _out === 0) \|\| flush === Z_FINISH) && ret === Z_OK) {\n ret = Z_BUF_ERROR;\n }\n return ret;\n};\n\n\nconst inflateEnd = (strm) => {\n\n if (inflateStateCheck(strm)) {\n return Z_STREAM_ERROR;\n }\n\n let state = strm.state;\n if (state.window) {\n state.window = null;\n }\n strm.state = null;\n return Z_OK;\n};\n\n\nconst inflateGetHeader = (strm, head) => {\n\n / check state /\n if (inflateStateCheck(strm)) { return Z_STREAM_ERROR; }\n const state = strm.state;\n if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; }\n\n / save header structure /\n state.head = head;\n head.done = false;\n return Z_OK;\n};\n\n\nconst inflateSetDictionary = (strm, dictionary) => {\n const dictLength = dictionary.length;\n\n let state;\n let dictid;\n let ret;\n\n / check state /\n if (inflateStateCheck(strm)) { return Z_STREAM_ERROR; }\n state = strm.state;\n\n if (state.wrap !== 0 && state.mode !== DICT) {\n return Z_STREAM_ERROR;\n }\n\n / check for correct dictionary identifier /\n if (state.mode === DICT) {\n dictid = 1; / adler32(0, null, 0)/\n / dictid = adler32(dictid, dictionary, dictLength); /\n dictid = adler32(dictid, dictionary, dictLength, 0);\n if (dictid !== state.check) {\n return Z_DATA_ERROR;\n }\n }\n / copy dictionary to window using updatewindow(), which will amend the\n existing dictionary if appropriate /\n ret = updatewindow(strm, dictionary, dictLength, dictLength);\n if (ret) {\n state.mode = MEM;\n return Z_MEM_ERROR;\n }\n state.havedict = 1;\n // Tracev((stderr, \"inflate: dictionary set\\n\"));\n return Z_OK;\n};\n\n\nmodule.exports.inflateReset = inflateReset;\nmodule.exports.inflateReset2 = inflateReset2;\nmodule.exports.inflateResetKeep = inflateResetKeep;\nmodule.exports.inflateInit = inflateInit;\nmodule.exports.inflateInit2 = inflateInit2;\nmodule.exports.inflate = inflate;\nmodule.exports.inflateEnd = inflateEnd;\nmodule.exports.inflateGetHeader = inflateGetHeader;\nmodule.exports.inflateSetDictionary = inflateSetDictionary;\nmodule.exports.inflateInfo = 'pako inflate (from Nodeca project)';\n\n/ Not implemented\nmodule.exports.inflateCodesUsed = inflateCodesUsed;\nmodule.exports.inflateCopy = inflateCopy;\nmodule.exports.inflateGetDictionary = inflateGetDictionary;\nmodule.exports.inflateMark = inflateMark;\nmodule.exports.inflatePrime = inflatePrime;\nmodule.exports.inflateSync = inflateSync;\nmodule.exports.inflateSyncPoint = inflateSyncPoint;\nmodule.exports.inflateUndermine = inflateUndermine;\nmodule.exports.inflateValidate = inflateValidate;\n/\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nconst MAXBITS = 15;\nconst ENOUGH_LENS = 852;\nconst ENOUGH_DISTS = 592;\n//const ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);\n\nconst CODES = 0;\nconst LENS = 1;\nconst DISTS = 2;\n\nconst lbase = new Uint16Array([ / Length codes 257..285 base /\n 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,\n 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0\n]);\n\nconst lext = new Uint8Array([ / Length codes 257..285 extra /\n 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,\n 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78\n]);\n\nconst dbase = new Uint16Array([ / Distance codes 0..29 base /\n 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,\n 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,\n 8193, 12289, 16385, 24577, 0, 0\n]);\n\nconst dext = new Uint8Array([ / Distance codes 0..29 extra /\n 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,\n 23, 23, 24, 24, 25, 25, 26, 26, 27, 27,\n 28, 28, 29, 29, 64, 64\n]);\n\nconst inflate_table = (type, lens, lens_index, codes, table, table_index, work, opts) =>\n{\n const bits = opts.bits;\n //here = opts.here; / table entry for duplication /\n\n let len = 0; / a code's length in bits /\n let sym = 0; / index of code symbols /\n let min = 0, max = 0; / minimum and maximum code lengths /\n let root = 0; / number of index bits for root table /\n let curr = 0; / number of index bits for current table /\n let drop = 0; / code bits to drop for sub-table /\n let left = 0; / number of prefix codes available /\n let used = 0; / code entries in table used /\n let huff = 0; / Huffman code /\n let incr; / for incrementing code, index /\n let fill; / index for replicating entries /\n let low; / low bits for current root entry /\n let mask; / mask for low root bits /\n let next; / next available space in table /\n let base = null; / base value table to use /\n// let shoextra; / extra bits table to use /\n let match; / use base and extra for symbol >= match /\n const count = new Uint16Array(MAXBITS + 1); //[MAXBITS+1]; / number of codes of each length /\n const offs = new Uint16Array(MAXBITS + 1); //[MAXBITS+1]; / offsets in table for each length /\n let extra = null;\n\n let here_bits, here_op, here_val;\n\n /\n Process a set of code lengths to create a canonical Huffman code. The\n code lengths are lens[0..codes-1]. Each length corresponds to the\n symbols 0..codes-1. The Huffman code is generated by first sorting the\n symbols by length from short to long, and retaining the symbol order\n for codes with equal lengths. Then the code starts with all zero bits\n for the first code of the shortest length, and the codes are integer\n increments for the same length, and zeros are appended as the length\n increases. For the deflate format, these bits are stored backwards\n from their more natural integer increment ordering, and so when the\n decoding tables are built in the large loop below, the integer codes\n are incremented backwards.\n\n This routine assumes, but does not check, that all of the entries in\n lens[] are in the range 0..MAXBITS. The caller must assure this.\n 1..MAXBITS is interpreted as that code length. zero means that that\n symbol does not occur in this code.\n\n The codes are sorted by computing a count of codes for each length,\n creating from that a table of starting indices for each length in the\n sorted table, and then entering the symbols in order in the sorted\n table. The sorted table is work[], with that space being provided by\n the caller.\n\n The length counts are used for other purposes as well, i.e. finding\n the minimum and maximum length codes, determining if there are any\n codes at all, checking for a valid set of lengths, and looking ahead\n at length counts to determine sub-table sizes when building the\n decoding tables.\n /\n\n / accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) /\n for (len = 0; len <= MAXBITS; len++) {\n count[len] = 0;\n }\n for (sym = 0; sym < codes; sym++) {\n count[lens[lens_index + sym]]++;\n }\n\n / bound code lengths, force root to be within code lengths /\n root = bits;\n for (max = MAXBITS; max >= 1; max--) {\n if (count[max] !== 0) { break; }\n }\n if (root > max) {\n root = max;\n }\n if (max === 0) { / no symbols to code at all /\n //table.op[opts.table_index] = 64; //here.op = (var char)64; / invalid code marker /\n //table.bits[opts.table_index] = 1; //here.bits = (var char)1;\n //table.val[opts.table_index++] = 0; //here.val = (var short)0;\n table[table_index++] = (1 << 24) \| (64 << 16) \| 0;\n\n\n //table.op[opts.table_index] = 64;\n //table.bits[opts.table_index] = 1;\n //table.val[opts.table_index++] = 0;\n table[table_index++] = (1 << 24) \| (64 << 16) \| 0;\n\n opts.bits = 1;\n return 0; / no symbols, but wait for decoding to report error /\n }\n for (min = 1; min < max; min++) {\n if (count[min] !== 0) { break; }\n }\n if (root < min) {\n root = min;\n }\n\n / check for an over-subscribed or incomplete set of lengths /\n left = 1;\n for (len = 1; len <= MAXBITS; len++) {\n left <<= 1;\n left -= count[len];\n if (left < 0) {\n return -1;\n } / over-subscribed /\n }\n if (left > 0 && (type === CODES \|\| max !== 1)) {\n return -1; / incomplete set /\n }\n\n / generate offsets into symbol table for each length for sorting /\n offs[1] = 0;\n for (len = 1; len < MAXBITS; len++) {\n offs[len + 1] = offs[len] + count[len];\n }\n\n / sort symbols by length, by symbol order within each length /\n for (sym = 0; sym < codes; sym++) {\n if (lens[lens_index + sym] !== 0) {\n work[offs[lens[lens_index + sym]]++] = sym;\n }\n }\n\n /\n Create and fill in decoding tables. In this loop, the table being\n filled is at next and has curr index bits. The code being used is huff\n with length len. That code is converted to an index by dropping drop\n bits off of the bottom. For codes where len is less than drop + curr,\n those top drop + curr - len bits are incremented through all values to\n fill the table with replicated entries.\n\n root is the number of index bits for the root table. When len exceeds\n root, sub-tables are created pointed to by the root entry with an index\n of the low root bits of huff. This is saved in low to check for when a\n new sub-table should be started. drop is zero when the root table is\n being filled, and drop is root when sub-tables are being filled.\n\n When a new sub-table is needed, it is necessary to look ahead in the\n code lengths to determine what size sub-table is needed. The length\n counts are used for this, and so count[] is decremented as codes are\n entered in the tables.\n\n used keeps track of how many table entries have been allocated from the\n provided table space. It is checked for LENS and DIST tables against\n the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in\n the initial root table size constants. See the comments in inftrees.h\n for more information.\n\n sym increments through all symbols, and the loop terminates when\n all codes of length max, i.e. all codes, have been processed. This\n routine permits incomplete codes, so another loop after this one fills\n in the rest of the decoding tables with invalid code markers.\n /\n\n /* set up for code type /\n // poor man optimization - use if-else instead of switch,\n // to avoid deopts in old v8\n if (type === CODES) {\n base = extra = work; / dummy value--not used /\n match = 20;\n\n } else if (type === LENS) {\n base = lbase;\n extra = lext;\n match = 257;\n\n } else { / DISTS /\n base = dbase;\n extra = dext;\n match = 0;\n }\n\n / initialize opts for loop /\n huff = 0; / starting code /\n sym = 0; / starting code symbol /\n len = min; / starting code length /\n next = table_index; / current table to fill in /\n curr = root; / current table index bits /\n drop = 0; / current bits to drop from code for index /\n low = -1; / trigger new sub-table when len > root /\n used = 1 << root; / use root table entries /\n mask = used - 1; / mask for comparing low /\n\n / check available table space /\n if ((type === LENS && used > ENOUGH_LENS) \|\|\n (type === DISTS && used > ENOUGH_DISTS)) {\n return 1;\n }\n\n / process all codes and make table entries /\n for (;;) {\n / create table entry /\n here_bits = len - drop;\n if (work[sym] + 1 < match) {\n here_op = 0;\n here_val = work[sym];\n }\n else if (work[sym] >= match) {\n here_op = extra[work[sym] - match];\n here_val = base[work[sym] - match];\n }\n else {\n here_op = 32 + 64; / end of block /\n here_val = 0;\n }\n\n / replicate for those indices with low len bits equal to huff /\n incr = 1 << (len - drop);\n fill = 1 << curr;\n min = fill; / save offset to next table /\n do {\n fill -= incr;\n table[next + (huff >> drop) + fill] = (here_bits << 24) \| (here_op << 16) \| here_val \|0;\n } while (fill !== 0);\n\n / backwards increment the len-bit code huff /\n incr = 1 << (len - 1);\n while (huff & incr) {\n incr >>= 1;\n }\n if (incr !== 0) {\n huff &= incr - 1;\n huff += incr;\n } else {\n huff = 0;\n }\n\n / go to next symbol, update count, len /\n sym++;\n if (--count[len] === 0) {\n if (len === max) { break; }\n len = lens[lens_index + work[sym]];\n }\n\n / create new sub-table if needed /\n if (len > root && (huff & mask) !== low) {\n / if first time, transition to sub-tables /\n if (drop === 0) {\n drop = root;\n }\n\n / increment past last table /\n next += min; / here min is 1 << curr /\n\n / determine length of next table /\n curr = len - drop;\n left = 1 << curr;\n while (curr + drop < max) {\n left -= count[curr + drop];\n if (left <= 0) { break; }\n curr++;\n left <<= 1;\n }\n\n / check for enough space /\n used += 1 << curr;\n if ((type === LENS && used > ENOUGH_LENS) \|\|\n (type === DISTS && used > ENOUGH_DISTS)) {\n return 1;\n }\n\n / point entry in root table to sub-table /\n low = huff & mask;\n /table.op[low] = curr;\n table.bits[low] = root;\n table.val[low] = next - opts.table_index;/\n table[low] = (root << 24) \| (curr << 16) \| (next - table_index) \|0;\n }\n }\n\n / fill in remaining table entry if code is incomplete (guaranteed to have\n at most one remaining entry, since if the code is incomplete, the\n maximum code length that was allowed to get this far is one bit) /\n if (huff !== 0) {\n //table.op[next + huff] = 64; / invalid code marker /\n //table.bits[next + huff] = len - drop;\n //table.val[next + huff] = 0;\n table[next + huff] = ((len - drop) << 24) \| (64 << 16) \|0;\n }\n\n / set return parameters /\n //opts.table_index += used;\n opts.bits = root;\n return 0;\n};\n\n\nmodule.exports = inflate_table;\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nmodule.exports = {\n 2: 'need dictionary', / Z_NEED_DICT 2 /\n 1: 'stream end', / Z_STREAM_END 1 /\n 0: '', / Z_OK 0 /\n '-1': 'file error', / Z_ERRNO (-1) /\n '-2': 'stream error', / Z_STREAM_ERROR (-2) /\n '-3': 'data error', / Z_DATA_ERROR (-3) /\n '-4': 'insufficient memory', / Z_MEM_ERROR (-4) /\n '-5': 'buffer error', / Z_BUF_ERROR (-5) /\n '-6': 'incompatible version' / Z_VERSION_ERROR (-6) /\n};\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nfunction ZStream() {\n / next input byte /\n this.input = null; // JS specific, because we have no pointers\n this.next_in = 0;\n / number of bytes available at input /\n this.avail_in = 0;\n / total number of input bytes read so far /\n this.total_in = 0;\n / next output byte should be put there /\n this.output = null; // JS specific, because we have no pointers\n this.next_out = 0;\n / remaining free space at output /\n this.avail_out = 0;\n / total number of bytes output so far /\n this.total_out = 0;\n / last error message, NULL if no error /\n this.msg = ''/Z_NULL/;\n / not visible by applications /\n this.state = null;\n / best guess about the data type: binary or text /\n this.data_type = 2/Z_UNKNOWN/;\n / adler32 value of the uncompressed data /\n this.adler = 0;\n}\n\nmodule.exports = ZStream;\n","module.exports = __WEBPACK_EXTERNAL_MODULE__464__;","module.exports = __WEBPACK_EXTERNAL_MODULE__713__;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this \|\| new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","var scriptUrl;\nif (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + \"\";\nvar document = __webpack_require__.g.document;\nif (!scriptUrl && document) {\n\tif (document.currentScript)\n\t\tscriptUrl = document.currentScript.src;\n\tif (!scriptUrl) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tif(scripts.length) {\n\t\t\tvar i = scripts.length - 1;\n\t\t\twhile (i > -1 && !scriptUrl) scriptUrl = scripts[i--].src;\n\t\t}\n\t}\n}\n// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration\n// or pass an empty string (\"\") and set the __webpack_public_path__ variable from your code to use your own logic.\nif (!scriptUrl) throw new Error(\"Automatic publicPath is not supported in this browser\");\nscriptUrl = scriptUrl.replace(/#.$/, \"\").replace(/\\?.$/, \"\").replace(/\\/[^\\/]+$/, \"/\");\n__webpack_require__.p = scriptUrl;","import { ByteArray } from 'dicom-parser';\n\nexport default function (\n imageFrame: ByteArray,\n colorBuffer: ByteArray,\n useRGBA: boolean\n): void {\n if (imageFrame === undefined) {\n throw new Error('decodeRGB: rgbBuffer must not be undefined');\n }\n if (imageFrame.length % 3 !== 0) {\n throw new Error('decodeRGB: rgbBuffer length must be divisible by 3');\n }\n\n const numPixels = imageFrame.length / 3;\n\n let rgbIndex = 0;\n\n let bufferIndex = 0;\n\n if (useRGBA) {\n for (let i = 0; i < numPixels; i++) {\n colorBuffer[bufferIndex++] = imageFrame[rgbIndex++]; // red\n colorBuffer[bufferIndex++] = imageFrame[rgbIndex++]; // green\n colorBuffer[bufferIndex++] = imageFrame[rgbIndex++]; // blue\n colorBuffer[bufferIndex++] = 255; // alpha\n }\n\n return;\n }\n\n // if RGB buffer\n colorBuffer.set(imageFrame);\n}\n","import { ByteArray } from 'dicom-parser';\n\nexport default function (\n imageFrame: ByteArray,\n colorBuffer: ByteArray,\n useRGBA: boolean\n): void {\n if (imageFrame === undefined) {\n throw new Error('decodeRGB: rgbBuffer must not be undefined');\n }\n if (imageFrame.length % 3 !== 0) {\n throw new Error('decodeRGB: rgbBuffer length must be divisible by 3');\n }\n\n const numPixels = imageFrame.length / 3;\n\n let bufferIndex = 0;\n\n let rIndex = 0;\n\n let gIndex = numPixels;\n\n let bIndex = numPixels 2;\n\n if (useRGBA) {\n for (let i = 0; i < numPixels; i++) {\n colorBuffer[bufferIndex++] = imageFrame[rIndex++]; // red\n colorBuffer[bufferIndex++] = imageFrame[gIndex++]; // green\n colorBuffer[bufferIndex++] = imageFrame[bIndex++]; // blue\n colorBuffer[bufferIndex++] = 255; // alpha\n }\n } else {\n for (let i = 0; i < numPixels; i++) {\n colorBuffer[bufferIndex++] = imageFrame[rIndex++]; // red\n colorBuffer[bufferIndex++] = imageFrame[gIndex++]; // green\n colorBuffer[bufferIndex++] = imageFrame[bIndex++]; // blue\n }\n }\n}\n","import { ByteArray } from 'dicom-parser';\n\nexport default function (\n imageFrame: ByteArray,\n colorBuffer: ByteArray,\n useRGBA: boolean\n): void {\n if (imageFrame === undefined) {\n throw new Error('decodeRGB: ybrBuffer must not be undefined');\n }\n if (imageFrame.length % 3 !== 0) {\n throw new Error('decodeRGB: ybrBuffer length must be divisble by 3');\n }\n\n const numPixels = imageFrame.length / 3;\n\n let ybrIndex = 0;\n\n let bufferIndex = 0;\n\n if (useRGBA) {\n for (let i = 0; i < numPixels; i++) {\n const y = imageFrame[ybrIndex++];\n const cb = imageFrame[ybrIndex++];\n const cr = imageFrame[ybrIndex++];\n\n colorBuffer[bufferIndex++] = y + 1.402 * (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y + 1.772 * (cb - 128); // blue\n colorBuffer[bufferIndex++] = 255; // alpha\n }\n\n return;\n }\n\n for (let i = 0; i < numPixels; i++) {\n const y = imageFrame[ybrIndex++];\n const cb = imageFrame[ybrIndex++];\n const cr = imageFrame[ybrIndex++];\n\n colorBuffer[bufferIndex++] = y + 1.402 * (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y + 1.772 * (cb - 128); // blue\n }\n}\n","import { ByteArray } from 'dicom-parser';\n\nexport default function (\n imageFrame: ByteArray,\n colorBuffer: ByteArray,\n useRGBA: boolean\n): void {\n if (imageFrame === undefined) {\n throw new Error('decodeRGB: ybrBuffer must not be undefined');\n }\n if (imageFrame.length % 3 !== 0) {\n throw new Error('decodeRGB: ybrBuffer length must be divisble by 3');\n }\n\n const numPixels = imageFrame.length / 3;\n\n let bufferIndex = 0;\n\n let yIndex = 0;\n\n let cbIndex = numPixels;\n\n let crIndex = numPixels * 2;\n\n if (useRGBA) {\n for (let i = 0; i < numPixels; i++) {\n const y = imageFrame[yIndex++];\n const cb = imageFrame[cbIndex++];\n const cr = imageFrame[crIndex++];\n\n colorBuffer[bufferIndex++] = y + 1.402 * (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y + 1.772 * (cb - 128); // blue\n colorBuffer[bufferIndex++] = 255; // alpha\n }\n\n return;\n }\n\n for (let i = 0; i < numPixels; i++) {\n const y = imageFrame[yIndex++];\n const cb = imageFrame[cbIndex++];\n const cr = imageFrame[crIndex++];\n\n colorBuffer[bufferIndex++] = y + 1.402 * (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y + 1.772 * (cb - 128); // blue\n }\n}\n","import { WADORSMetaDataElement } from '../../../types';\n\n/*\n Returns the raw value\n \n @param element - The javascript object for the specified element in the metadata\n * @param [index] - the index of the value in a multi-valued element, default is 0\n * @param [defaultValue] - The default value to return if the element does not exist\n * @returns {}\n /\nfunction getValue<ReturnType = unknown>(\n element: WADORSMetaDataElement,\n index?: number,\n defaultValue?: ReturnType\n): ReturnType {\n index = index \|\| 0;\n if (!element) {\n return defaultValue;\n }\n // Value is not present if the attribute has a zero length value\n if (!element.Value) {\n return defaultValue;\n }\n // make sure we have the specified index\n if ((element.Value as any).length <= index) {\n return defaultValue;\n }\n\n return element.Value[index];\n}\n\nexport default getValue;\n","import { WADORSMetaDataElement } from '../../../types';\nimport getValue from './getValue';\n\n/*\n Returns the first string value as a Javascript number\n \n @param element - The javascript object for the specified element in the metadata\n * @param [index] - the index of the value in a multi-valued element, default is 0\n * @param [defaultValue] - The default value to return if the element does not exist\n * @returns {}\n /\nfunction getNumberString(\n element: WADORSMetaDataElement,\n index: number,\n defaultValue: number\n): number {\n const value = getValue<any>(element, index, defaultValue);\n\n if (value === undefined) {\n return;\n }\n\n return parseFloat(value);\n}\n\nexport default getNumberString;\n","import { WADORSMetaDataElement } from '../../../types';\nimport getValue from './getValue';\n\nfunction getNumberValue(\n element: WADORSMetaDataElement,\n index?: number\n): number {\n const value = getValue<any>(element, index);\n\n if (value === undefined) {\n return;\n }\n\n return parseFloat(value);\n}\n\nexport default getNumberValue;\n","import { WADORSMetaDataElement } from '../../../types';\n\n/*\n Returns the values as an array of javascript numbers\n \n @param element - The javascript object for the specified element in the metadata\n * @param [minimumLength] - the minimum number of values\n * @returns {}\n /\nfunction getNumberValues(\n element: WADORSMetaDataElement,\n minimumLength?: number\n): number[] {\n if (!element) {\n return;\n }\n // Value is not present if the attribute has a zero length value\n if (!element.Value) {\n return;\n }\n // Make sure the Value is an array\n if (!Array.isArray(element.Value)) {\n return;\n }\n // make sure we have the expected length\n if (minimumLength && element.Value.length < minimumLength) {\n return;\n }\n\n const values: number[] = [];\n\n for (let i = 0; i < element.Value.length; i++) {\n // @ts-expect-error\n values.push(parseFloat(element.Value[i]));\n }\n\n return values;\n}\n\nexport default getNumberValues;\n","/*\n Removes the data loader scheme from the imageId\n \n @param {string} imageId Image ID\n * @returns {string} imageId without the data loader scheme\n * @memberof Cache\n /\nexport default function imageIdToURI(imageId: string): string {\n const colonIndex = imageId.indexOf(':');\n\n return imageId.substring(colonIndex + 1);\n}\n","export default function getTagValue(tag, justElement = true) {\n if (tag && tag.Value) {\n if (tag.Value[0] && justElement) {\n return tag.Value[0];\n }\n\n return tag.Value;\n }\n\n return tag;\n}\n","import getTagValue from './getTagValue';\n\nfunction getFrameInformation(\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n frameNumber\n) {\n const shared = (\n SharedFunctionalGroupsSequence\n ? Object.values(SharedFunctionalGroupsSequence[0])\n : []\n )\n .map((it) => it[0])\n .filter((it) => it !== undefined && typeof it === 'object');\n const perFrame = (\n PerFrameFunctionalGroupsSequence\n ? Object.values(PerFrameFunctionalGroupsSequence[frameNumber - 1])\n : []\n )\n .map((it: any) => it.Value[0])\n .filter((it) => it !== undefined && typeof it === 'object');\n\n return {\n shared,\n perFrame,\n };\n}\n\nfunction getMultiframeInformation(metaData) {\n let {\n 52009230: PerFrameFunctionalGroupsSequence,\n 52009229: SharedFunctionalGroupsSequence,\n '00280008': NumberOfFrames,\n // eslint-disable-next-line prefer-const\n ...rest\n } = metaData;\n\n PerFrameFunctionalGroupsSequence = getTagValue(\n PerFrameFunctionalGroupsSequence,\n false\n );\n SharedFunctionalGroupsSequence = getTagValue(\n SharedFunctionalGroupsSequence,\n false\n );\n NumberOfFrames = getTagValue(NumberOfFrames);\n\n return {\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n NumberOfFrames,\n rest,\n };\n}\n// function that retrieves specific frame metadata information from multiframe\n// metadata\nfunction combineFrameInstance(frameNumber, instance) {\n const {\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n NumberOfFrames,\n rest,\n } = getMultiframeInformation(instance);\n\n if (PerFrameFunctionalGroupsSequence \|\| NumberOfFrames > 1) {\n const { shared, perFrame } = getFrameInformation(\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n frameNumber\n );\n\n const newInstance = Object.assign(instance, { frameNumber });\n\n // merge the shared first then the per frame to override\n [...shared, ...perFrame].forEach((item) => {\n Object.entries(item).forEach(([key, value]) => {\n newInstance[key] = value;\n });\n });\n\n return Object.assign(rest, { '00280008': NumberOfFrames }, newInstance);\n }\n\n return instance;\n}\n\nexport { combineFrameInstance, getMultiframeInformation, getFrameInformation };\n","import getValue from './metaData/getValue';\nimport imageIdToURI from '../imageIdToURI';\nimport { metadataByImageURI } from './metaDataManager';\n\n// get metadata information for the first frame\nfunction _retrieveMultiframeMetadata(imageURI) {\n const lastSlashIdx = imageURI.indexOf('/frames/') + 8;\n // imageid string without frame number\n const imageIdFrameless = imageURI.slice(0, lastSlashIdx);\n // calculating frame number\n const frame = parseInt(imageURI.slice(lastSlashIdx), 10);\n // retrieving the frame 1 that contains multiframe information\n\n const metadata = metadataByImageURI[`${imageIdFrameless}1`];\n\n return {\n metadata,\n frame,\n };\n}\n\nfunction retrieveMultiframeMetadata(imageId) {\n const imageURI = imageIdToURI(imageId);\n\n return _retrieveMultiframeMetadata(imageURI);\n}\n\nfunction isMultiframe(metadata) {\n // Checks if dicomTag NumberOf Frames exists and it is greater than one\n const numberOfFrames = getValue<number>(metadata['00280008']);\n\n return numberOfFrames && numberOfFrames > 1;\n}\n\nexport default {\n _retrieveMultiframeMetadata,\n retrieveMultiframeMetadata,\n isMultiframe,\n};\n","import { WADORSMetaData } from '../../types';\nimport imageIdToURI from '../imageIdToURI';\nimport { combineFrameInstance } from './combineFrameInstance';\nimport multiframeMetadata from './retrieveMultiframeMetadata';\n\nlet metadataByImageURI = [];\nlet multiframeMetadataByImageURI = {};\n\nfunction add(imageId: string, metadata: WADORSMetaData) {\n const imageURI = imageIdToURI(imageId);\n\n // @ts-ignore\n metadata.isMultiframe = multiframeMetadata.isMultiframe(metadata);\n\n metadataByImageURI[imageURI] = metadata;\n}\n\n// multiframes images will have only one imageId returned by the dicomweb\n// client and registered in metadataByImageURI for all the n frames. If an\n// imageId does not have metadata, or it does not have at all, or the imageID\n// belongs to a frame, not registered in metadataByImageURI\nfunction get(imageId: string): WADORSMetaData {\n const imageURI = imageIdToURI(imageId);\n\n // Check if the metadata is already available\n const metadata = metadataByImageURI[imageURI];\n\n if (metadata && !metadata?.isMultiframe) {\n // Return the metadata for single-frame images\n return metadata;\n }\n\n const cachedMetadata = multiframeMetadataByImageURI[imageURI];\n\n if (cachedMetadata) {\n return cachedMetadata;\n }\n\n // Try to get the metadata for a specific frame of a multiframe image\n const retrievedMetadata =\n multiframeMetadata._retrieveMultiframeMetadata(imageURI);\n\n if (!retrievedMetadata \|\| !retrievedMetadata.metadata) {\n return;\n }\n\n const { metadata: firstFrameMetadata, frame } = retrievedMetadata;\n\n if (firstFrameMetadata) {\n // Combine the metadata from the first frame with the metadata from the specified frame\n const combined = combineFrameInstance(frame, firstFrameMetadata);\n\n multiframeMetadataByImageURI[imageURI] = combined;\n\n return combined;\n }\n}\n\nfunction remove(imageId) {\n const imageURI = imageIdToURI(imageId);\n\n metadataByImageURI[imageURI] = undefined;\n\n multiframeMetadataByImageURI[imageURI] = undefined;\n}\n\nfunction purge() {\n metadataByImageURI = [];\n multiframeMetadataByImageURI = {};\n}\n\nexport { metadataByImageURI };\n\nexport default {\n add,\n get,\n remove,\n purge,\n};\n","export default function isNMReconstructable(imageSubType) {\n return imageSubType === 'RECON TOMO' \|\| imageSubType === 'RECON GATED TOMO';\n}\n","import getTagValue from '../getTagValue';\nimport getValue from './getValue';\nimport isNMReconstructable from '../../isNMReconstructable';\nimport getNumberValues from './getNumberValues';\n\nfunction isNMModality(metaData) {\n const modality = getValue(metaData['00080060']);\n\n return modality.includes('NM');\n}\n\n/\n Get a subpart of Image Type dicom tag defined by index\n * @param {} metaData\n @param {} index 0 based index of the subtype\n /\nfunction getImageTypeSubItemFromMetadata(metaData, index) {\n const imageType = getTagValue(metaData['00080008'], false);\n\n if (imageType) {\n // const subTypes = imageType.split('\\\\');\n\n // if (subTypes.length > index) {\n // return subTypes[index];\n // }\n return imageType[index];\n }\n\n return undefined;\n}\n/*\n Extracts the orientation from NM multiframe metadata, if image type\n * equal to RECON TOMO or RECON GATED TOMO\n * @param {} metaData\n @returns\n /\nfunction extractOrientationFromNMMultiframeMetadata(metaData) {\n let imageOrientationPatient;\n const imageSubType = getImageTypeSubItemFromMetadata(metaData, 2);\n\n if (imageSubType && isNMReconstructable(imageSubType)) {\n const detectorInformationSequence = getTagValue(metaData['00540022']);\n\n if (detectorInformationSequence) {\n imageOrientationPatient = getNumberValues(\n detectorInformationSequence['00200037'],\n 6\n );\n }\n }\n\n return imageOrientationPatient;\n}\n\n/\n Extracts the position from NM multiframe dataset, if image type\n * equal to RECON TOMO or RECON GATED TOMO\n * @param {} metaData\n @returns\n /\nfunction extractPositionFromNMMultiframeMetadata(metaData) {\n let imagePositionPatient;\n const imageSubType = getImageTypeSubItemFromMetadata(metaData, 2);\n\n if (imageSubType && isNMReconstructable(imageSubType)) {\n const detectorInformationSequence = getTagValue(metaData['00540022']);\n\n if (detectorInformationSequence) {\n imagePositionPatient = getNumberValues(\n detectorInformationSequence['00200032'],\n 3\n );\n }\n }\n\n return imagePositionPatient;\n}\n\nexport {\n extractOrientationFromNMMultiframeMetadata,\n extractPositionFromNMMultiframeMetadata,\n isNMModality,\n getImageTypeSubItemFromMetadata,\n};\n","import getNumberValues from './getNumberValues';\nimport {\n extractOrientationFromNMMultiframeMetadata,\n extractPositionFromNMMultiframeMetadata,\n isNMModality,\n} from './NMHelpers';\n\n/\n Extract orientation information from a metadata. It tries to get the orientation\n * from the Detector Information Sequence (for NM images) if image type equal\n * to RECON TOMO or RECON GATED TOMO\n * @param {} metaData\n @returns\n /\nfunction extractOrientationFromMetadata(metaData) {\n let imageOrientationPatient = getNumberValues(metaData['00200037'], 6);\n\n // If orientation not valid to this point, trying to get the orientation\n // from the Detector Information Sequence (for NM images) with image type\n // equal to RECON TOMO or RECON GATED TOMO\n\n if (!imageOrientationPatient && isNMModality(metaData)) {\n imageOrientationPatient =\n extractOrientationFromNMMultiframeMetadata(metaData);\n }\n\n return imageOrientationPatient;\n}\n\n/\n Extract position information from a metaData. It tries to get the position\n * from the Detector Information Sequence (for NM images) if image type equal\n * to RECON TOMO or RECON GATED TOMO\n * @param {} metaData\n @returns\n /\nfunction extractPositionFromMetadata(metaData) {\n let imagePositionPatient = getNumberValues(metaData['00200032'], 3);\n\n // If position not valid to this point, trying to get the position\n // from the Detector Information Sequence (for NM images)\n if (!imagePositionPatient && isNMModality(metaData)) {\n imagePositionPatient = extractPositionFromNMMultiframeMetadata(metaData);\n }\n\n return imagePositionPatient;\n}\n\nexport { extractOrientationFromMetadata, extractPositionFromMetadata };\n","/\n Retrieves metadata from a DICOM image and returns it as an object with capitalized keys.\n * @param imageId - the imageId\n * @param metaDataProvider - The metadata provider either wadors or wadouri\n * @param types - An array of metadata types to retrieve.\n * @returns An object containing the retrieved metadata with capitalized keys.\n /\nfunction getInstanceModule(\n imageId: string,\n metaDataProvider: any,\n types: string[]\n): object;\nfunction getInstanceModule(imageId, metaDataProvider, types) {\n const result = {};\n for (const t of types) {\n try {\n const data = metaDataProvider(t, imageId);\n if (data) {\n const capitalizedData = {};\n for (const key in data) {\n if (key in data) {\n // each tag should get capitalized to match dcmjs style. Todo: move all of the tags to dcmjs style\n const capitalizedKey = capitalizeTag(key);\n capitalizedData[capitalizedKey] = data[key];\n }\n }\n Object.assign(result, capitalizedData);\n }\n } catch (error) {\n console.error(`Error retrieving ${t} data:`, error);\n }\n }\n\n return result;\n}\n\nconst capitalizeTag = (tag: string) =>\n tag.charAt(0).toUpperCase() + tag.slice(1);\n\nconst instanceModuleNames = [\n 'multiframeModule',\n 'generalSeriesModule',\n 'patientStudyModule',\n 'imagePlaneModule',\n 'nmMultiframeGeometryModule',\n 'imagePixelModule',\n 'modalityLutModule',\n 'voiLutModule',\n 'sopCommonModule',\n 'petIsotopeModule',\n 'overlayPlaneModule',\n 'transferSyntax',\n 'petSeriesModule',\n 'petImageModule',\n];\n\nexport { getInstanceModule, instanceModuleNames };\n","import getNumberValues from './getNumberValues';\n\n/\n This helper function retrieves the first number value from the provided sequence for the given key.\n * @param sequence - The sequence from which to retrieve the number value.\n * @param key - The key for which to retrieve the number value.\n * @returns The first number value for the given key, or null if no value is found.\n /\nfunction getFirstNumberValue(sequence: any, key: string): number \| null {\n const values = getNumberValues(sequence[key]);\n return values ? values[0] : null;\n}\n\nexport { getFirstNumberValue };\n","import { WADORSMetaDataElement } from 'dicomImageLoader/src/types';\n\nfunction getSequenceItems(element: any): WADORSMetaDataElement[] {\n // Value is not present if the attribute has a zero length value\n if (!element?.Value?.length) {\n return [];\n }\n\n if (!Array.isArray(element.Value)) {\n // If the Value is an object, encapsulate it in an array and log a warning message\n if (typeof element.Value === 'object') {\n console.warn(\n 'Warning: Value should be an array, but an object was found. Encapsulating the object in an array.'\n );\n return [element.Value];\n }\n return [];\n }\n return element.Value;\n}\n\nexport default getSequenceItems;\n","import { getFirstNumberValue } from './getFirstNumberValue';\nimport getSequenceItems from './getSequenceItems';\n\n/\n This function retrieves the ultrasound regions from the provided metadata.\n * @param metadata - The metadata from which to retrieve the ultrasound regions.\n * @returns An array of ultrasound regions, or null if no regions are found.\n /\nfunction getUSEnhancedRegions(metadata) {\n const sequenceOfUltrasoundRegions = getSequenceItems(metadata['00186011']);\n\n if (!sequenceOfUltrasoundRegions \|\| !sequenceOfUltrasoundRegions.length) {\n return null;\n }\n\n const regions = sequenceOfUltrasoundRegions.map((sequence) => {\n const physicalDeltaX = getFirstNumberValue(sequence, '0018602C');\n const physicalDeltaY = getFirstNumberValue(sequence, '0018602E');\n const physicalUnitsXDirection = getFirstNumberValue(sequence, '00186024');\n const physicalUnitsYDirection = getFirstNumberValue(sequence, '00186026');\n\n const regionLocationMinY0 = getFirstNumberValue(sequence, '0018601A');\n const regionLocationMaxY1 = getFirstNumberValue(sequence, '0018601E');\n const regionLocationMinX0 = getFirstNumberValue(sequence, '00186018');\n const regionLocationMaxX1 = getFirstNumberValue(sequence, '0018601C');\n const referencePixelX0 = getFirstNumberValue(sequence, '00186020');\n const referencePixelY0 = getFirstNumberValue(sequence, '00186022');\n\n const referencePhysicalPixelValueY = getFirstNumberValue(\n sequence,\n '0018602A'\n );\n const referencePhysicalPixelValueX = getFirstNumberValue(\n sequence,\n '00186028'\n );\n const regionSpatialFormat = getFirstNumberValue(sequence, '00186012');\n\n const regionDataType = getFirstNumberValue(sequence, '00186014');\n const regionFlags = getFirstNumberValue(sequence, '00186016');\n const transducerFrequency = getFirstNumberValue(sequence, '00186030');\n\n return {\n regionLocationMinY0,\n regionLocationMaxY1,\n regionLocationMinX0,\n regionLocationMaxX1,\n referencePixelX0,\n referencePixelY0,\n physicalDeltaX,\n physicalDeltaY,\n physicalUnitsXDirection,\n physicalUnitsYDirection,\n referencePhysicalPixelValueY,\n referencePhysicalPixelValueX,\n regionSpatialFormat,\n regionDataType,\n regionFlags,\n transducerFrequency,\n };\n });\n\n return regions;\n}\nexport { getUSEnhancedRegions };\n","import external from '../../../externalModules';\nimport getNumberValues from './getNumberValues';\nimport getNumberValue from './getNumberValue';\nimport getOverlayPlaneModule from './getOverlayPlaneModule';\nimport metaDataManager from '../metaDataManager';\nimport getValue from './getValue';\nimport {\n getMultiframeInformation,\n getFrameInformation,\n} from '../combineFrameInstance';\nimport multiframeMetadata from '../retrieveMultiframeMetadata';\nimport {\n extractOrientationFromMetadata,\n extractPositionFromMetadata,\n} from './extractPositioningFromMetadata';\nimport { getImageTypeSubItemFromMetadata } from './NMHelpers';\nimport isNMReconstructable from '../../isNMReconstructable';\nimport {\n getInstanceModule,\n instanceModuleNames,\n} from '../../getInstanceModule';\nimport { getUSEnhancedRegions } from './USHelpers';\n\nfunction metaDataProvider(type, imageId) {\n const { MetadataModules } = external.cornerstone.Enums;\n const { dicomParser } = external;\n\n if (type === MetadataModules.MULTIFRAME) {\n // the get function removes the PerFrameFunctionalGroupsSequence\n const { metadata, frame } =\n multiframeMetadata.retrieveMultiframeMetadata(imageId);\n\n if (!metadata) {\n return;\n }\n const {\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n NumberOfFrames,\n } = getMultiframeInformation(metadata);\n\n if (PerFrameFunctionalGroupsSequence \|\| NumberOfFrames > 1) {\n const { shared, perFrame } = getFrameInformation(\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n frame\n );\n\n return {\n NumberOfFrames,\n //PerFrameFunctionalGroupsSequence,\n PerFrameFunctionalInformation: perFrame,\n SharedFunctionalInformation: shared,\n };\n }\n\n return {\n NumberOfFrames,\n //PerFrameFunctionalGroupsSequence,\n };\n }\n\n const metaData = metaDataManager.get(imageId);\n\n if (!metaData) {\n return;\n }\n\n if (type === MetadataModules.GENERAL_STUDY) {\n return {\n studyDescription: getValue<string>(metaData['00081030']),\n studyDate: dicomParser.parseDA(getValue<string>(metaData['00080020'])),\n studyTime: dicomParser.parseTM(\n getValue<string>(metaData['00080030'], 0, '')\n ),\n accessionNumber: getValue<string>(metaData['00080050']),\n };\n }\n\n if (type === MetadataModules.GENERAL_SERIES) {\n return {\n modality: getValue<string>(metaData['00080060']),\n seriesInstanceUID: getValue<string>(metaData['0020000E']),\n seriesNumber: getNumberValue(metaData['00200011']),\n studyInstanceUID: getValue<string>(metaData['0020000D']),\n seriesDate: dicomParser.parseDA(getValue<string>(metaData['00080021'])),\n seriesTime: dicomParser.parseTM(\n getValue<string>(metaData['00080031'], 0, '')\n ),\n acquisitionDate: dicomParser.parseDA(\n getValue<string>(metaData['00080022'])\n ),\n acquisitionTime: dicomParser.parseTM(\n getValue<string>(metaData['00080032'], 0, '')\n ),\n };\n }\n\n if (type === MetadataModules.GENERAL_IMAGE) {\n return {\n sopInstanceUID: getValue<string>(metaData['00080018']),\n instanceNumber: getNumberValue(metaData['00200013']),\n lossyImageCompression: getValue<string>(metaData['00282110']),\n lossyImageCompressionRatio: getNumberValue(metaData['00282112']),\n lossyImageCompressionMethod: getValue<string>(metaData['00282114']),\n };\n }\n\n if (type === MetadataModules.PATIENT) {\n return {\n patientID: getValue<string>(metaData['00100020']),\n patientName: getValue<string>(metaData['00100010']),\n };\n }\n\n if (type === MetadataModules.PATIENT_STUDY) {\n return {\n patientAge: getNumberValue(metaData['00101010']),\n patientSize: getNumberValue(metaData['00101020']),\n patientSex: getValue<'M' \| 'F'>(metaData['00100040']),\n patientWeight: getNumberValue(metaData['00101030']),\n };\n }\n\n if (type === MetadataModules.NM_MULTIFRAME_GEOMETRY) {\n const modality = getValue(metaData['00080060']);\n const imageSubType = getImageTypeSubItemFromMetadata(metaData, 2);\n\n return {\n modality,\n imageType: getValue(metaData['00080008']),\n imageSubType,\n imageOrientationPatient: extractOrientationFromMetadata(metaData),\n imagePositionPatient: extractPositionFromMetadata(metaData),\n sliceThickness: getNumberValue(metaData['00180050']),\n pixelSpacing: getNumberValues(metaData['00280030'], 2),\n numberOfFrames: getNumberValue(metaData['00280008']),\n isNMReconstructable:\n isNMReconstructable(imageSubType) && modality.includes('NM'),\n };\n }\n\n if (type === MetadataModules.IMAGE_PLANE) {\n //metaData = fixNMMetadata(metaData);\n const imageOrientationPatient = extractOrientationFromMetadata(metaData);\n const imagePositionPatient = extractPositionFromMetadata(metaData);\n const pixelSpacing = getNumberValues(metaData['00280030'], 2);\n\n let columnPixelSpacing = null;\n\n let rowPixelSpacing = null;\n\n if (pixelSpacing) {\n rowPixelSpacing = pixelSpacing[0];\n columnPixelSpacing = pixelSpacing[1];\n }\n\n let rowCosines = null;\n\n let columnCosines = null;\n\n if (imageOrientationPatient) {\n rowCosines = [\n // @ts-expect-error\n parseFloat(imageOrientationPatient[0]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[1]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[2]),\n ];\n columnCosines = [\n // @ts-expect-error\n parseFloat(imageOrientationPatient[3]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[4]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[5]),\n ];\n }\n\n return {\n frameOfReferenceUID: getValue<string>(metaData['00200052']),\n rows: getNumberValue(metaData['00280010']),\n columns: getNumberValue(metaData['00280011']),\n imageOrientationPatient,\n rowCosines,\n columnCosines,\n imagePositionPatient,\n sliceThickness: getNumberValue(metaData['00180050']),\n sliceLocation: getNumberValue(metaData['00201041']),\n pixelSpacing,\n rowPixelSpacing,\n columnPixelSpacing,\n };\n }\n\n if (type === MetadataModules.ULTRASOUND_ENHANCED_REGION) {\n return getUSEnhancedRegions(metaData);\n }\n\n if (type === MetadataModules.CALIBRATION) {\n const modality = getValue(metaData['00080060']);\n\n if (modality === 'US') {\n const enhancedRegion = getUSEnhancedRegions(metaData);\n return {\n sequenceOfUltrasoundRegions: enhancedRegion,\n };\n }\n }\n\n if (type === MetadataModules.IMAGE_URL) {\n return getImageUrlModule(imageId, metaData);\n }\n\n if (type === MetadataModules.CINE) {\n return getCineModule(imageId, metaData);\n }\n\n if (type === MetadataModules.IMAGE_PIXEL) {\n return {\n samplesPerPixel: getNumberValue(metaData['00280002']),\n photometricInterpretation: getValue(metaData['00280004']),\n rows: getNumberValue(metaData['00280010']),\n columns: getNumberValue(metaData['00280011']),\n bitsAllocated: getNumberValue(metaData['00280100']),\n bitsStored: getNumberValue(metaData['00280101']),\n highBit: getValue(metaData['00280102']),\n pixelRepresentation: getNumberValue(metaData['00280103']),\n planarConfiguration: getNumberValue(metaData['00280006']),\n pixelAspectRatio: getValue(metaData['00280034']),\n smallestPixelValue: getNumberValue(metaData['00280106']),\n largestPixelValue: getNumberValue(metaData['00280107']),\n redPaletteColorLookupTableDescriptor: getNumberValues(\n metaData['00281101']\n ),\n greenPaletteColorLookupTableDescriptor: getNumberValues(\n metaData['00281102']\n ),\n bluePaletteColorLookupTableDescriptor: getNumberValues(\n metaData['00281103']\n ),\n redPaletteColorLookupTableData: getNumberValues(metaData['00281201']),\n greenPaletteColorLookupTableData: getNumberValues(metaData['00281202']),\n bluePaletteColorLookupTableData: getNumberValues(metaData['00281203']),\n };\n }\n\n if (type === MetadataModules.VOI_LUT) {\n return {\n // TODO VOT LUT Sequence\n windowCenter: getNumberValues(metaData['00281050'], 1),\n windowWidth: getNumberValues(metaData['00281051'], 1),\n };\n }\n\n if (type === MetadataModules.MODALITY_LUT) {\n return {\n // TODO VOT LUT Sequence\n rescaleIntercept: getNumberValue(metaData['00281052']),\n rescaleSlope: getNumberValue(metaData['00281053']),\n rescaleType: getValue(metaData['00281054']),\n };\n }\n\n if (type === MetadataModules.SOP_COMMON) {\n return {\n sopClassUID: getValue<string>(metaData['00080016']),\n sopInstanceUID: getValue<string>(metaData['00080018']),\n };\n }\n\n if (type === MetadataModules.PET_ISOTOPE) {\n const radiopharmaceuticalInfo = getValue(metaData['00540016']);\n\n if (radiopharmaceuticalInfo === undefined) {\n return;\n }\n\n return {\n radiopharmaceuticalInfo: {\n radiopharmaceuticalStartTime: dicomParser.parseTM(\n getValue(radiopharmaceuticalInfo['00181072'], 0, '')\n ),\n radiopharmaceuticalStartDateTime: getValue(\n radiopharmaceuticalInfo['00181078'],\n 0,\n ''\n ),\n radionuclideTotalDose: getNumberValue(\n radiopharmaceuticalInfo['00181074']\n ),\n radionuclideHalfLife: getNumberValue(\n radiopharmaceuticalInfo['00181075']\n ),\n },\n };\n }\n\n if (type === MetadataModules.OVERLAY_PLANE) {\n return getOverlayPlaneModule(metaData);\n }\n\n // Note: this is not a DICOM module, but a useful metadata that can be\n // retrieved from the image\n if (type === 'transferSyntax') {\n return getTransferSyntax(imageId, metaData);\n }\n\n if (type === MetadataModules.PET_SERIES) {\n return {\n correctedImage: getValue(metaData['00280051']),\n units: getValue(metaData['00541001']),\n decayCorrection: getValue(metaData['00541102']),\n };\n }\n\n if (type === MetadataModules.PET_IMAGE) {\n return {\n frameReferenceTime: getNumberValue(metaData['00541300']),\n actualFrameDuration: getNumberValue(metaData['00181242']),\n };\n }\n\n // Note: this is not a DICOM module, but rather an aggregation on all others\n if (type === 'instance') {\n return getInstanceModule(imageId, metaDataProvider, instanceModuleNames);\n }\n}\n\nexport function getImageUrlModule(imageId, metaData) {\n const { transferSyntaxUID } = getTransferSyntax(imageId, metaData);\n const isVideo =\n external.cornerstone.utilities.isVideoTransferSyntax(transferSyntaxUID);\n const imageUrl = imageId.substring(7);\n const thumbnail = imageUrl.replace('/frames/', '/thumbnail/');\n let rendered = imageUrl.replace('/frames/', '/rendered/');\n if (isVideo) {\n rendered = rendered.replace('/rendered/1', '/rendered');\n }\n return {\n isVideo,\n rendered,\n thumbnail,\n };\n}\n\nexport function getCineModule(imageId, metaData) {\n const cineRate = getValue<string>(metaData['00180040']);\n return {\n cineRate,\n numberOfFrames: getNumberValue(metaData['00280008']),\n };\n}\n\nexport function getTransferSyntax(imageId, metaData) {\n // Use either the FMI, which is NOT permitted in the DICOMweb data, but\n // is sometimes found there anyways, or the available transfer syntax, which\n // is the recommended way of getting it.\n return {\n transferSyntaxUID:\n getValue<string>(metaData['00020010']) \|\|\n getValue<string>(metaData['00083002']),\n };\n}\n\nexport default metaDataProvider;\n","import getValue from './getValue';\nimport getNumberValue from './getNumberValue';\nimport { WADORSMetaData } from '../../../types';\n\nexport default function getOverlayPlaneModule(metaData: WADORSMetaData) {\n const overlays = [];\n\n for (let overlayGroup = 0x00; overlayGroup <= 0x1e; overlayGroup += 0x02) {\n let groupStr = `x60${overlayGroup.toString(16)}`;\n\n if (groupStr.length === 4) {\n groupStr = `x600${overlayGroup.toString(16)}`;\n }\n\n /\n @todo there is a type issue with WADORSMetaData. Currently WADORSMetaData\n * on includes string[] \| number[] \| boolean. from the look of this, data\n * is a more complex type\n /\n const data = getValue<any>(metaData[`${groupStr}3000`]);\n\n if (!data) {\n continue;\n }\n\n const pixelData = [];\n\n for (let i = 0; i < data.length; i++) {\n for (let k = 0; k < 8; k++) {\n const byte_as_int = metaData.Value[data.dataOffset + i];\n\n pixelData[i 8 + k] = (byte_as_int >> k) & 0b1; // eslint-disable-line no-bitwise\n }\n }\n\n overlays.push({\n rows: getNumberValue(metaData[`${groupStr}0010`]),\n columns: getNumberValue(metaData[`${groupStr}0011`]),\n type: getValue(metaData[`${groupStr}0040`]),\n x: getNumberValue(metaData[`${groupStr}0050`], 1) - 1,\n y: getNumberValue(metaData[`${groupStr}0050`], 0) - 1,\n pixelData,\n description: getValue(metaData[`${groupStr}0022`]),\n label: getValue(metaData[`${groupStr}1500`]),\n roiArea: getValue(metaData[`${groupStr}1301`]),\n roiMean: getValue(metaData[`${groupStr}1302`]),\n roiStandardDeviation: getValue(metaData[`${groupStr}1303`]),\n });\n }\n\n return {\n overlays,\n };\n}\n","function checkToken(token, data, dataOffset): boolean {\n if (dataOffset + token.length > data.length) {\n return false;\n }\n\n let endIndex = dataOffset;\n\n for (let i = 0; i < token.length; i++) {\n if (token[i] !== data[endIndex++]) {\n return false;\n }\n }\n\n return true;\n}\n\nfunction stringToUint8Array(str: string): Uint8Array {\n const uint = new Uint8Array(str.length);\n\n for (let i = 0, j = str.length; i < j; i++) {\n uint[i] = str.charCodeAt(i);\n }\n\n return uint;\n}\n\nfunction findIndexOfString(\n data: Uint8Array,\n str: string,\n offset?: number\n): number {\n offset = offset \|\| 0;\n\n const token = stringToUint8Array(str);\n\n for (let i = offset; i < data.length; i++) {\n if (token[0] === data[i]) {\n // console.log('match @', i);\n if (checkToken(token, data, i)) {\n return i;\n }\n }\n }\n\n return -1;\n}\nexport default findIndexOfString;\n","import { LoaderOptions } from '../../types';\n\nlet options: LoaderOptions = {\n // callback to open the object\n open(xhr, url) {\n xhr.open('get', url, true);\n },\n // callback allowing customization of the xhr (e.g. adding custom auth headers, cors, etc)\n beforeSend(/* xhr, imageId /) {\n // before send code\n },\n // callback allowing modification of the xhr response before creating image objects\n beforeProcessing(xhr: XMLHttpRequest) {\n return Promise.resolve(xhr.response as ArrayBuffer);\n },\n // callback allowing modification of newly created image objects\n imageCreated(/ image /) {\n // image created code\n },\n strict: false,\n decodeConfig: {\n convertFloatPixelDataToInt: true,\n use16BitDataType: false,\n },\n};\n\nexport function setOptions(newOptions: LoaderOptions): void {\n options = Object.assign(options, newOptions);\n}\n\nexport function getOptions(): LoaderOptions {\n return options;\n}\n","import external from '../../externalModules';\nimport { getOptions } from './options';\nimport {\n LoaderXhrRequestError,\n LoaderXhrRequestParams,\n LoaderXhrRequestPromise,\n} from '../../types';\n\nfunction xhrRequest(\n url: string,\n imageId: string,\n defaultHeaders: Record<string, string> = {},\n params: LoaderXhrRequestParams = {}\n): LoaderXhrRequestPromise<ArrayBuffer> {\n const { cornerstone } = external;\n const options = getOptions();\n\n const errorInterceptor = (xhr: XMLHttpRequest) => {\n if (typeof options.errorInterceptor === 'function') {\n const error = new Error('request failed') as LoaderXhrRequestError;\n\n error.request = xhr;\n error.response = xhr.response;\n error.status = xhr.status;\n options.errorInterceptor(error);\n }\n };\n\n const xhr = new XMLHttpRequest();\n\n // Make the request for the DICOM P10 SOP Instance\n const promise: LoaderXhrRequestPromise<ArrayBuffer> =\n new Promise<ArrayBuffer>((resolve, reject) => {\n options.open(xhr, url, defaultHeaders, params);\n const beforeSendHeaders = options.beforeSend(\n xhr,\n imageId,\n defaultHeaders,\n params\n );\n\n xhr.responseType = 'arraybuffer';\n\n const headers = Object.assign({}, defaultHeaders, beforeSendHeaders);\n\n Object.keys(headers).forEach(function (key) {\n if (headers[key] === null) {\n return;\n }\n if (key === 'Accept' && url.indexOf('accept=') !== -1) {\n return;\n }\n xhr.setRequestHeader(key, headers[key]);\n });\n\n params.deferred = {\n resolve,\n reject,\n };\n params.url = url;\n params.imageId = imageId;\n\n // Event triggered when downloading an image starts\n xhr.onloadstart = function (event) {\n // Action\n if (options.onloadstart) {\n options.onloadstart(event, params);\n }\n\n // Event\n const eventData = {\n url,\n imageId,\n };\n\n cornerstone.triggerEvent(\n (cornerstone as any).events,\n 'cornerstoneimageloadstart',\n eventData\n );\n };\n\n // Event triggered when downloading an image ends\n xhr.onloadend = function (event) {\n // Action\n if (options.onloadend) {\n options.onloadend(event, params);\n }\n\n const eventData = {\n url,\n imageId,\n };\n\n // Event\n cornerstone.triggerEvent(\n (cornerstone as any).events,\n 'cornerstoneimageloadend',\n eventData\n );\n };\n\n // handle response data\n xhr.onreadystatechange = function (event) {\n // Action\n if (options.onreadystatechange) {\n options.onreadystatechange(event, params);\n\n return;\n }\n\n // Default action\n // TODO: consider sending out progress messages here as we receive\n // the pixel data\n if (xhr.readyState === 4) {\n // Status OK (200) and partial content (206) are both handled\n if (xhr.status === 200 \|\| xhr.status === 206) {\n options\n .beforeProcessing(xhr)\n .then(resolve)\n .catch(() => {\n errorInterceptor(xhr);\n // request failed, reject the Promise\n reject(xhr);\n });\n } else {\n errorInterceptor(xhr);\n // request failed, reject the Promise\n reject(xhr);\n }\n }\n };\n\n // Event triggered when downloading an image progresses\n xhr.onprogress = function (oProgress) {\n // console.log('progress:',oProgress)\n const loaded = oProgress.loaded; // evt.loaded the bytes browser receive\n\n let total: number;\n\n let percentComplete: number;\n\n if (oProgress.lengthComputable) {\n total = oProgress.total; // evt.total the total bytes seted by the header\n percentComplete = Math.round((loaded / total) 100);\n }\n\n // Action\n if (options.onprogress) {\n options.onprogress(oProgress, params);\n }\n };\n xhr.onerror = function () {\n errorInterceptor(xhr);\n reject(xhr);\n };\n\n xhr.onabort = function () {\n errorInterceptor(xhr);\n reject(xhr);\n };\n xhr.send();\n });\n\n promise.xhr = xhr;\n\n return promise;\n}\n\nexport default xhrRequest;\n","import { default as xhrRequest } from './xhrRequest';\nimport { setOptions, getOptions } from './options';\n\nconst internal = {\n xhrRequest,\n setOptions,\n getOptions,\n};\n\nexport { setOptions, getOptions, xhrRequest, internal };\n","import { Enums } from '@cornerstonejs/core';\nimport findIndexOfString from './findIndexOfString';\n\nconst { ImageQualityStatus } = Enums;\n/*\n Extracts multipart/related data or single part data from a response byte\n * array.\n \n @param contentType - guess of the root content type\n * @param imageFrameAsArrayBuffer - array buffer containing the image frame\n * @param options - contains already computed values from\n * earlier calls, allowing additional calls to be made to fetch\n * additional data.\n * @param isPartial - indicates the file may end partially\n * @returns a compressed image frame containing the pixel data.\n /\nexport default function extractMultipart(\n contentType: string,\n imageFrameAsArrayBuffer,\n options?\n) {\n options \|\|= {};\n // request succeeded, Parse the multi-part mime response\n const response = new Uint8Array(imageFrameAsArrayBuffer);\n const isPartial = !!options?.isPartial;\n if (contentType.indexOf('multipart') === -1) {\n return {\n contentType,\n imageQualityStatus: isPartial\n ? ImageQualityStatus.SUBRESOLUTION\n : ImageQualityStatus.FULL_RESOLUTION,\n pixelData: response,\n };\n }\n\n let { tokenIndex, responseHeaders, boundary, multipartContentType } = options;\n\n // First look for the multipart mime header\n tokenIndex \|\|= findIndexOfString(response, '\\r\\n\\r\\n');\n\n if (tokenIndex === -1) {\n throw new Error('invalid response - no multipart mime header');\n }\n\n if (!boundary) {\n const header = uint8ArrayToString(response, 0, tokenIndex);\n // Now find the boundary marker\n responseHeaders = header.split('\\r\\n');\n boundary = findBoundary(responseHeaders);\n\n if (!boundary) {\n throw new Error('invalid response - no boundary marker');\n }\n }\n const offset = tokenIndex + 4; // skip over the \\r\\n\\r\\n\n\n // find the terminal boundary marker\n const endIndex = findIndexOfString(response, boundary, offset);\n\n if (endIndex === -1 && !isPartial) {\n throw new Error('invalid response - terminating boundary not found');\n }\n\n multipartContentType \|\|= findContentType(responseHeaders);\n\n options.tokenIndex = tokenIndex;\n options.boundary = boundary;\n options.responseHeaders = responseHeaders;\n options.multipartContentType = multipartContentType;\n options.isPartial = endIndex === -1;\n\n // return the info for this pixel data\n return {\n contentType: multipartContentType,\n // done indicates if the read has finished the entire image, not if\n // the image is completely available\n extractDone: !isPartial \|\| endIndex !== -1,\n tokenIndex,\n responseHeaders,\n boundary,\n multipartContentType,\n // Exclude the \\r\\n as well as the boundary\n pixelData: imageFrameAsArrayBuffer.slice(offset, endIndex - 2),\n };\n}\n\nexport function findBoundary(header: string[]): string {\n for (let i = 0; i < header.length; i++) {\n if (header[i].substr(0, 2) === '--') {\n return header[i];\n }\n }\n}\n\nexport function findContentType(header: string[]): string {\n for (let i = 0; i < header.length; i++) {\n if (header[i].substr(0, 13) === 'Content-Type:') {\n return header[i].substr(13).trim();\n }\n }\n}\n\nexport function uint8ArrayToString(data, offset, length) {\n offset = offset \|\| 0;\n length = length \|\| data.length - offset;\n let str = '';\n\n for (let i = offset; i < offset + length; i++) {\n str += String.fromCharCode(data[i]);\n }\n\n return str;\n}\n","import { Types, Enums } from '@cornerstonejs/core';\n\nconst { ImageQualityStatus } = Enums;\n\n/* Gets the status of returned images /\nexport function getImageQualityStatus(\n retrieveOptions: Types.RetrieveOptions,\n done = true\n) {\n if (!done) {\n return ImageQualityStatus.SUBRESOLUTION;\n }\n return (\n retrieveOptions.imageQualityStatus ?? ImageQualityStatus.FULL_RESOLUTION\n );\n}\n","import { Types, utilities } from '@cornerstonejs/core';\nimport { getOptions } from './options';\nimport { LoaderXhrRequestError } from '../../types';\nimport extractMultipart from '../wadors/extractMultipart';\nimport { getImageQualityStatus } from '../wadors/getImageQualityStatus';\n\nconst { ProgressiveIterator } = utilities;\ntype RetrieveOptions = Types.RetrieveOptions;\n\n/\n This function does a streaming parse from an http request, delivering\n * combined/subsequent parts of the result as iterations on a\n * ProgressiveIterator instance.\n \n @param url - to request and parse as either multipart or singlepart.\n * @param imageId\n * @param defaultHeaders\n * @returns\n /\nexport default function streamRequest(\n url: string,\n imageId: string,\n defaultHeaders: Record<string, string> = {},\n options: CornerstoneWadoRsLoaderOptions = {}\n) {\n const globalOptions = getOptions();\n const { retrieveOptions = {}, streamingData = {} } = options;\n const minChunkSize = retrieveOptions.minChunkSize \|\| 128 1024;\n\n const errorInterceptor = (err: any) => {\n if (typeof globalOptions.errorInterceptor === 'function') {\n const error = new Error('request failed') as LoaderXhrRequestError;\n globalOptions.errorInterceptor(error);\n }\n };\n\n // Make the request for the streamable image frame (i.e. HTJ2K)\n const loadIterator = new ProgressiveIterator('streamRequest');\n loadIterator.generate(async (iterator, reject) => {\n const headers = Object.assign({}, defaultHeaders /* beforeSendHeaders /);\n\n Object.keys(headers).forEach(function (key) {\n if (headers[key] === null) {\n headers[key] = undefined;\n }\n if (key === 'Accept' && url.indexOf('accept=') !== -1) {\n headers[key] = undefined;\n }\n });\n\n try {\n const response = await fetch(url, {\n headers: defaultHeaders,\n signal: undefined,\n });\n\n // Response is expected to be a 200 status response\n if (response.status !== 200) {\n throw new Error(\n `Couldn't retrieve ${url} got status ${response.status}`\n );\n }\n const responseReader = response.body.getReader();\n const responseHeaders = response.headers;\n\n const contentType = responseHeaders.get('content-type');\n\n const totalBytes = Number(responseHeaders.get('Content-Length'));\n\n let readDone = false;\n let encodedData = streamingData.encodedData;\n let lastSize = streamingData.lastSize \|\| 0;\n streamingData.isPartial = true;\n\n while (!readDone) {\n const { done, value } = await responseReader.read();\n encodedData = appendChunk(encodedData, value);\n if (!encodedData) {\n if (readDone) {\n throw new Error(`Done but no image frame available ${imageId}`);\n }\n continue;\n }\n readDone = done \|\| encodedData.byteLength === totalBytes;\n if (!readDone && encodedData.length < lastSize + minChunkSize) {\n continue;\n }\n lastSize = encodedData.length;\n streamingData.isPartial = !done;\n const extracted = extractMultipart(\n contentType,\n encodedData,\n streamingData\n );\n const imageQualityStatus = getImageQualityStatus(\n retrieveOptions,\n readDone\n );\n const detail = {\n url,\n imageId,\n ...extracted,\n percentComplete: done\n ? 100\n : (extracted.pixelData?.length 100) / totalBytes,\n imageQualityStatus,\n done: readDone,\n };\n\n // All of the image load events will be handled by the imageLoader\n // this simply delivers the raw data as it becomes available.\n iterator.add(detail, readDone);\n }\n } catch (err) {\n errorInterceptor(err);\n console.error(err);\n reject(err);\n }\n });\n\n return loadIterator.getNextPromise();\n}\n\nfunction appendChunk(existing: Uint8Array, chunk?: Uint8Array) {\n // that imageId\n if (!existing) {\n return chunk;\n }\n if (!chunk) {\n return existing;\n }\n const newDataArray = new Uint8Array(existing.length + chunk.length);\n newDataArray.set(existing, 0);\n newDataArray.set(chunk, existing.length);\n return newDataArray;\n}\n","import { Types, Enums } from '@cornerstonejs/core';\nimport { getOptions } from './options';\nimport { LoaderXhrRequestError, LoaderXhrRequestPromise } from '../../types';\nimport metaDataManager from '../wadors/metaDataManager';\nimport extractMultipart from '../wadors/extractMultipart';\nimport { getImageQualityStatus } from '../wadors/getImageQualityStatus';\nimport { CornerstoneWadoRsLoaderOptions } from '../wadors/loadImage';\n\ntype RangeRetrieveOptions = Types.RangeRetrieveOptions;\n\n/*\n Performs a range request to fetch part of an encoded image, typically\n * so that partial resolution images can be fetched.\n * The configuration of exactly what is requested is based on the transfer\n * syntax provided.\n * Note this generates 1 response for each call, and those reponses may or may\n * not be combined with each other depending on the configuration applied.\n \n * HTJ2K Streaming TSUID -> Use actual range requests, and set it up for streaming\n * image decoding of byte range requests\n * * JLS and Non-streaming HTJ2K -> Use a sub-resolution (or thumbnail) endpoint\n * followed by normal endpoint\n \n @param url - including an fsiz parameter\n * @param imageId - to fetch for\n * @param defaultHeaders - to add to the request\n * @returns Compressed image data\n /\nexport default function rangeRequest(\n url: string,\n imageId: string,\n defaultHeaders: Record<string, string> = {},\n options: CornerstoneWadoRsLoaderOptions = {}\n): LoaderXhrRequestPromise<{\n contentType: string;\n pixelData: Uint8Array;\n imageQualityStatus: Enums.ImageQualityStatus;\n percentComplete: number;\n}> {\n const globalOptions = getOptions();\n const { retrieveOptions = {}, streamingData } = options;\n const chunkSize =\n streamingData.chunkSize \|\|\n getValue(imageId, retrieveOptions, 'chunkSize') \|\|\n 65536;\n\n const errorInterceptor = (err: any) => {\n if (typeof globalOptions.errorInterceptor === 'function') {\n const error = new Error('request failed') as LoaderXhrRequestError;\n globalOptions.errorInterceptor(error);\n } else {\n console.warn('rangeRequest:Caught', err);\n }\n };\n\n // Make the request for the streamable image frame (i.e. HTJ2K)\n const promise = new Promise<{\n contentType: string;\n pixelData: Uint8Array;\n percentComplete: number;\n imageQualityStatus: Enums.ImageQualityStatus;\n }>(async (resolve, reject) => {\n const headers = Object.assign(\n {},\n defaultHeaders\n / beforeSendHeaders /\n );\n\n Object.keys(headers).forEach(function (key) {\n if (headers[key] === null \|\| headers[key] === undefined) {\n delete headers[key];\n }\n });\n\n try {\n if (!streamingData.encodedData) {\n streamingData.chunkSize = chunkSize;\n streamingData.rangesFetched = 0;\n }\n const byteRange = getByteRange(streamingData, retrieveOptions);\n\n const { encodedData, responseHeaders } = await fetchRangeAndAppend(\n url,\n headers,\n byteRange,\n streamingData\n );\n\n // Resolve promise with the first range, so it can be passed through to\n // cornerstone via the usual image loading pathway. All subsequent\n // ranges will be passed and decoded via events.\n const contentType = responseHeaders.get('content-type');\n const { totalBytes } = streamingData;\n const doneAllBytes = totalBytes === encodedData.byteLength;\n const extract = extractMultipart(contentType, encodedData, {\n isPartial: true,\n });\n\n // Allow over-writing the done status to indicate complete on partial\n const imageQualityStatus = getImageQualityStatus(\n retrieveOptions,\n doneAllBytes \|\| extract.extractDone\n );\n resolve({\n ...extract,\n imageQualityStatus,\n percentComplete: extract.extractDone\n ? 100\n : (chunkSize 100) / totalBytes,\n });\n } catch (err: any) {\n errorInterceptor(err);\n console.error(err);\n reject(err);\n }\n });\n\n return promise;\n}\n\nasync function fetchRangeAndAppend(\n url: string,\n headers: any,\n range: [number, number \| ''],\n streamingData\n) {\n if (range) {\n headers = Object.assign(headers, {\n Range: `bytes=${range[0]}-${range[1]}`,\n });\n }\n let { encodedData } = streamingData;\n if (range[1] && encodedData?.byteLength > range[1]) {\n return streamingData;\n }\n const response = await fetch(url, {\n headers,\n signal: undefined,\n });\n\n const responseArrayBuffer = await response.arrayBuffer();\n const responseTypedArray = new Uint8Array(responseArrayBuffer);\n const { status } = response;\n\n // Append new data\n let newByteArray: Uint8Array;\n if (encodedData) {\n newByteArray = new Uint8Array(\n encodedData.length + responseTypedArray.length\n );\n newByteArray.set(encodedData, 0);\n newByteArray.set(responseTypedArray, encodedData.length);\n streamingData.rangesFetched = 1;\n } else {\n newByteArray = new Uint8Array(responseTypedArray.length);\n newByteArray.set(responseTypedArray, 0);\n streamingData.rangesFetched++;\n }\n streamingData.encodedData = encodedData = newByteArray;\n streamingData.responseHeaders = response.headers;\n\n const contentRange = response.headers.get('Content-Range');\n if (contentRange) {\n streamingData.totalBytes = Number(contentRange.split('/')[1]);\n } else if (status !== 206 \|\| !range) {\n streamingData.totalBytes = encodedData?.byteLength;\n } else if (range[1] === '' \|\| encodedData?.length < range[1]) {\n streamingData.totalBytes = encodedData.byteLength;\n } else {\n streamingData.totalBytes = Number.MAX_SAFE_INTEGER;\n }\n\n return streamingData;\n}\n\nfunction getValue(imageId: string, src, attr: string) {\n const value = src[attr];\n if (typeof value !== 'function') {\n return value;\n }\n const metaData = metaDataManager.get(imageId);\n return value(metaData, imageId);\n}\n\nfunction getByteRange(\n streamingData,\n retrieveOptions: RangeRetrieveOptions\n): [number, number \| ''] {\n const { totalBytes, encodedData, chunkSize = 65536 } = streamingData;\n const { rangeIndex = 0 } = retrieveOptions;\n if (rangeIndex === -1 && (!totalBytes \|\| !encodedData)) {\n return [0, ''];\n }\n if (rangeIndex === -1 \|\| encodedData?.byteLength > totalBytes - chunkSize) {\n return [encodedData?.byteLength \|\| 0, ''];\n }\n // Note the byte range is inclusive at both ends and zero based,\n // so the byteLength is the next index to fetch.\n return [encodedData?.byteLength \|\| 0, chunkSize * (rangeIndex + 1) - 1];\n}\n","import { xhrRequest } from '../internal/index';\n// import rangeRequest from '../internal/rangeRequest';\nimport streamRequest from '../internal/streamRequest';\nimport rangeRequest from '../internal/rangeRequest';\nimport extractMultipart from './extractMultipart';\nimport { getImageQualityStatus } from './getImageQualityStatus';\nimport { CornerstoneWadoRsLoaderOptions } from './loadImage';\nimport { RangeRetrieveOptions } from 'core/dist/types/types';\n\nfunction getPixelData(\n uri: string,\n imageId: string,\n mediaType = 'application/octet-stream',\n options?: CornerstoneWadoRsLoaderOptions\n) {\n const { streamingData, retrieveOptions = {} } = options \|\| {};\n const headers = {\n Accept: mediaType,\n };\n\n // Add urlArguments to the url for retrieving - allows accept and other\n // parameters to be added.\n let url = retrieveOptions.urlArguments\n ? `${uri}${uri.indexOf('?') === -1 ? '?' : '&'}${\n retrieveOptions.urlArguments\n }`\n : uri;\n\n // Replace the /frames/ part of the path with another path to choose\n // a different resource type.\n if (retrieveOptions.framesPath) {\n url = url.replace('/frames/', retrieveOptions.framesPath);\n }\n\n // Swap the streaming data out if a new instance starts.\n if (streamingData?.url !== url) {\n options.streamingData = { url };\n }\n\n if ((retrieveOptions as RangeRetrieveOptions).rangeIndex !== undefined) {\n return rangeRequest(url, imageId, headers, options);\n }\n\n // Use the streaming parser only when configured to do so\n if (retrieveOptions.streaming) {\n return streamRequest(url, imageId, headers, options);\n }\n\n /*\n Not progressively rendering, use regular xhr request.\n /\n const loadPromise = xhrRequest(url, imageId, headers);\n const { xhr } = loadPromise;\n\n return loadPromise.then(function (imageFrameAsArrayBuffer / , xhr/) {\n const contentType =\n xhr.getResponseHeader('Content-Type') \|\| 'application/octet-stream';\n const extracted = extractMultipart(\n contentType,\n new Uint8Array(imageFrameAsArrayBuffer)\n );\n extracted.imageQualityStatus = getImageQualityStatus(retrieveOptions, true);\n return extracted;\n });\n}\n\nexport default getPixelData;\n","import { PixelDataTypedArray } from '../types';\n\n/\n Calculate the minimum and maximum values in an Array\n \n @param {Number[]} storedPixelData\n * @return {{min: Number, max: Number}}\n /\nfunction getMinMax(storedPixelData: PixelDataTypedArray): {\n min: number;\n max: number;\n} {\n // we always calculate the min max values since they are not always\n // present in DICOM and we don't want to trust them anyway as cornerstone\n // depends on us providing reliable values for these\n let min = storedPixelData[0];\n\n let max = storedPixelData[0];\n\n let storedPixel;\n const numPixels = storedPixelData.length;\n\n for (let index = 1; index < numPixels; index++) {\n storedPixel = storedPixelData[index];\n min = Math.min(min, storedPixel);\n max = Math.max(max, storedPixel);\n }\n\n return {\n min,\n max,\n };\n}\n\nexport default getMinMax;\n","import {\n convertRGBColorByPixel,\n convertRGBColorByPlane,\n convertYBRFullByPixel,\n convertYBRFull422ByPixel,\n convertYBRFullByPlane,\n convertPALETTECOLOR,\n} from './colorSpaceConverters/index';\n\nfunction convertRGB(imageFrame, colorBuffer, useRGBA) {\n if (imageFrame.planarConfiguration === 0) {\n convertRGBColorByPixel(imageFrame.pixelData, colorBuffer, useRGBA);\n } else {\n convertRGBColorByPlane(imageFrame.pixelData, colorBuffer, useRGBA);\n }\n}\n\nfunction convertYBRFull(imageFrame, colorBuffer, useRGBA) {\n if (imageFrame.planarConfiguration === 0) {\n convertYBRFullByPixel(imageFrame.pixelData, colorBuffer, useRGBA);\n } else {\n convertYBRFullByPlane(imageFrame.pixelData, colorBuffer, useRGBA);\n }\n}\n\nexport default function convertColorSpace(imageFrame, colorBuffer, useRGBA) {\n // convert based on the photometric interpretation\n if (imageFrame.photometricInterpretation === 'RGB') {\n convertRGB(imageFrame, colorBuffer, useRGBA);\n } else if (imageFrame.photometricInterpretation === 'YBR_RCT') {\n convertRGB(imageFrame, colorBuffer, useRGBA);\n } else if (imageFrame.photometricInterpretation === 'YBR_ICT') {\n convertRGB(imageFrame, colorBuffer, useRGBA);\n } else if (imageFrame.photometricInterpretation === 'PALETTE COLOR') {\n convertPALETTECOLOR(imageFrame, colorBuffer, useRGBA);\n } else if (imageFrame.photometricInterpretation === 'YBR_FULL_422') {\n convertYBRFull422ByPixel(imageFrame.pixelData, colorBuffer, useRGBA);\n } else if (imageFrame.photometricInterpretation === 'YBR_FULL') {\n convertYBRFull(imageFrame, colorBuffer, useRGBA);\n } else {\n // TODO - handle YBR_PARTIAL and 420 colour spaces\n throw new Error(\n `No color space conversion for photometric interpretation ${imageFrame.photometricInterpretation}`\n );\n }\n}\n","import { ByteArray } from 'dicom-parser';\n\nexport default function (\n imageFrame: ByteArray,\n colorBuffer: ByteArray,\n useRGBA: boolean\n): void {\n if (imageFrame === undefined) {\n throw new Error('decodeRGB: ybrBuffer must not be undefined');\n }\n if (imageFrame.length % 2 !== 0) {\n throw new Error('decodeRGB: ybrBuffer length must be divisble by 2');\n }\n\n const numPixels = imageFrame.length / 2;\n\n let ybrIndex = 0;\n\n let bufferIndex = 0;\n\n if (useRGBA) {\n for (let i = 0; i < numPixels; i += 2) {\n const y1 = imageFrame[ybrIndex++];\n const y2 = imageFrame[ybrIndex++];\n const cb = imageFrame[ybrIndex++];\n const cr = imageFrame[ybrIndex++];\n\n colorBuffer[bufferIndex++] = y1 + 1.402 (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y1 - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y1 + 1.772 * (cb - 128); // blue\n colorBuffer[bufferIndex++] = 255; // alpha\n\n colorBuffer[bufferIndex++] = y2 + 1.402 * (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y2 - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y2 + 1.772 * (cb - 128); // blue\n colorBuffer[bufferIndex++] = 255; // alpha\n }\n\n return;\n }\n\n for (let i = 0; i < numPixels; i += 2) {\n const y1 = imageFrame[ybrIndex++];\n const y2 = imageFrame[ybrIndex++];\n const cb = imageFrame[ybrIndex++];\n const cr = imageFrame[ybrIndex++];\n\n colorBuffer[bufferIndex++] = y1 + 1.402 * (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y1 - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y1 + 1.772 * (cb - 128); // blue\n\n colorBuffer[bufferIndex++] = y2 + 1.402 * (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y2 - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y2 + 1.772 * (cb - 128); // blue\n }\n}\n","import { ByteArray } from 'dicom-parser';\nimport getMinMax from '../shared/getMinMax';\nimport { ImageFrame } from '../types';\n\n/*\n Special decoder for 8 bit jpeg that leverages the browser's built in JPEG decoder for increased performance\n /\n\nfunction arrayBufferToString(buffer: ArrayBuffer) {\n return binaryToString(\n String.fromCharCode.apply(\n null,\n Array.prototype.slice.apply(new Uint8Array(buffer))\n )\n );\n}\n\nfunction binaryToString(binary: string) {\n let error;\n\n try {\n return decodeURIComponent(escape(binary));\n } catch (_error) {\n error = _error;\n if (error instanceof URIError) {\n return binary;\n }\n throw error;\n }\n}\n\nfunction decodeJPEGBaseline8BitColor(\n imageFrame: ImageFrame,\n pixelData: ByteArray,\n canvas: HTMLCanvasElement\n): Promise<ImageFrame> {\n const start = new Date().getTime();\n const imgBlob = new Blob([pixelData], { type: 'image/jpeg' });\n\n return new Promise((resolve, reject) => {\n const fileReader = new FileReader();\n\n if (fileReader.readAsBinaryString === undefined) {\n fileReader.readAsArrayBuffer(imgBlob);\n } else {\n fileReader.readAsBinaryString(imgBlob); // doesn't work on IE11\n }\n\n fileReader.onload = function () {\n const img = new Image();\n\n img.onload = function () {\n canvas.height = img.height;\n canvas.width = img.width;\n imageFrame.rows = img.height;\n imageFrame.columns = img.width;\n const context = canvas.getContext('2d');\n\n /\n @todo check this context\n /\n context.drawImage(this as any, 0, 0);\n const imageData = context.getImageData(0, 0, img.width, img.height);\n const end = new Date().getTime();\n\n imageFrame.pixelData = new Uint8Array(imageData.data.buffer);\n imageFrame.imageData = imageData;\n imageFrame.decodeTimeInMS = end - start;\n\n // calculate smallest and largest PixelValue\n const minMax = getMinMax(imageFrame.pixelData as any);\n\n imageFrame.smallestPixelValue = minMax.min;\n imageFrame.largestPixelValue = minMax.max;\n imageFrame.pixelDataLength = imageFrame.pixelData.length;\n\n resolve(imageFrame);\n };\n\n img.onerror = function (error) {\n reject(error);\n };\n\n if (fileReader.readAsBinaryString === undefined) {\n img.src = `data:image/jpeg;base64,${window.btoa(\n arrayBufferToString(fileReader.result as ArrayBuffer)\n )}`;\n } else {\n img.src = `data:image/jpeg;base64,${window.btoa(\n fileReader.result as string\n )}`; // doesn't work on IE11\n }\n };\n\n fileReader.onerror = (e) => {\n reject(e);\n };\n });\n}\n\nexport default decodeJPEGBaseline8BitColor;\n","export default function Worker_fn() {\n return new Worker(__webpack_public_path__ + \"index.worker.f4bda803c15bc6359d5f.worker.js\");\n}\n","// Not sure why but webpack isn't splitting this out unless we explicitly use worker-loader!\n// eslint-disable-next-line\n// import cornerstoneDICOMImageLoaderWebWorker from 'worker-loader!../webWorker/index.worker';\nimport cornerstoneDICOMImageLoaderWebWorker from '../webWorker/index.worker';\n\nimport {\n WebWorkerOptions,\n WorkerTaskTypes,\n WorkerTask,\n WebWorkerDecodeTaskData,\n WebWorkerResponse,\n WebWorkerDeferredObject,\n} from '../types';\n\n// This is for the Webpack 5 approch but it's currently broken\n// so we will continue relying on worker-loader for now\n// https://github.com/webpack/webpack/issues/13899\n/ const cornerstoneDICOMImageLoaderWebWorkerPath = new URL(\n '../webWorker/index',\n import.meta.url\n);/\n\nimport { getOptions } from './internal/options';\n\n// the taskId to assign to the next task added via addTask()\nlet nextTaskId = 0;\n\nconst tasks: WorkerTask[] = [];\n\n// array of web workers to dispatch decode tasks to\nconst webWorkers: {\n worker: Worker;\n status: 'ready' \| 'busy' \| 'initializing';\n task?: WorkerTask;\n}[] = [];\n\n// The options for cornerstoneDICOMImageLoader\nconst options = getOptions();\n\nconst defaultConfig: WebWorkerOptions = {\n maxWebWorkers: navigator.hardwareConcurrency \|\| 1,\n startWebWorkersOnDemand: true,\n webWorkerTaskPaths: [],\n taskConfiguration: {\n decodeTask: {\n initializeCodecsOnStartup: false,\n strict: options.strict,\n },\n },\n};\n\nlet config: WebWorkerOptions;\n\nconst statistics = {\n maxWebWorkers: 0,\n numWebWorkers: 0,\n numTasksQueued: 0,\n numTasksExecuting: 0,\n numTasksCompleted: 0,\n totalTaskTimeInMS: 0,\n totalTimeDelayedInMS: 0,\n};\n\n/\n Function to start a task on a web worker\n /\nfunction startTaskOnWebWorker() {\n // return immediately if no decode tasks to do\n if (!tasks.length) {\n return;\n }\n\n // look for a web worker that is ready\n for (let i = 0; i < webWorkers.length; i++) {\n if (webWorkers[i].status === 'ready') {\n // mark it as busy so tasks are not assigned to it\n webWorkers[i].status = 'busy';\n\n // get the highest priority task\n const task = tasks.shift();\n\n task.start = new Date().getTime();\n\n // update stats with how long this task was delayed (waiting in queue)\n const end = new Date().getTime();\n\n statistics.totalTimeDelayedInMS += end - task.added;\n\n // assign this task to this web worker and send the web worker\n // a message to execute it\n webWorkers[i].task = task;\n webWorkers[i].worker.postMessage(\n {\n taskType: task.taskType,\n workerIndex: i,\n data: task.data,\n },\n task.transferList\n );\n statistics.numTasksExecuting++;\n\n return;\n }\n }\n\n // if no available web workers and we haven't started max web workers, start a new one\n if (webWorkers.length < config.maxWebWorkers) {\n spawnWebWorker();\n }\n}\n\n/\n Function to handle a message from a web worker\n * @param msg\n /\nfunction handleMessageFromWorker(msg: MessageEvent<WebWorkerResponse>) {\n // console.log('handleMessageFromWorker', msg.data);\n if (msg.data.taskType === 'initialize') {\n webWorkers[msg.data.workerIndex].status = 'ready';\n startTaskOnWebWorker();\n } else {\n const start = webWorkers[msg.data.workerIndex].task.start;\n\n const action = msg.data.status === 'success' ? 'resolve' : 'reject';\n\n try {\n webWorkers[msg.data.workerIndex].task.deferred[action](msg.data.result);\n } catch (e) {\n // Do a catch here to ensure the web worker is available\n console.warn('Caught error delivering response', e);\n }\n\n webWorkers[msg.data.workerIndex].task = undefined;\n\n statistics.numTasksExecuting--;\n webWorkers[msg.data.workerIndex].status = 'ready';\n statistics.numTasksCompleted++;\n\n const end = new Date().getTime();\n\n statistics.totalTaskTimeInMS += end - start;\n\n startTaskOnWebWorker();\n }\n}\n\n/\n Spawns a new web worker\n /\nfunction spawnWebWorker() {\n // prevent exceeding maxWebWorkers\n if (webWorkers.length >= config.maxWebWorkers) {\n return;\n }\n\n // spawn the webworker\n const worker: Worker = new (cornerstoneDICOMImageLoaderWebWorker as any)();\n\n // This is for the Webpack 5 approach but it's currently broken\n / const worker = new Worker(cornerstoneDICOMImageLoaderWebWorkerPath, {\n name: `cornerstoneDICOMImageLoaderWebWorkerPath-${webWorkers.length + 1}`,\n type: 'module',\n });/\n\n // const worker = new Worker(\n // './cornerstoneDICOMImageLoaderWebWorker.bundle.min',\n // {\n // name: `cornerstoneDICOMImageLoaderWebWorkerPath-${webWorkers.length + 1}`,\n // }\n // );\n\n webWorkers.push({\n worker,\n status: 'initializing',\n });\n worker.addEventListener('message', handleMessageFromWorker);\n worker.postMessage({\n taskType: 'initialize',\n workerIndex: webWorkers.length - 1,\n config,\n });\n}\n\n/\n Initialization function for the web worker manager - spawns web workers\n * @param configObject\n /\nfunction initialize(configObject?: WebWorkerOptions): void {\n configObject = configObject \|\| defaultConfig;\n\n // prevent being initialized more than once\n if (config) {\n // throw new Error('WebWorkerManager already initialized');\n }\n\n config = configObject;\n\n config.maxWebWorkers =\n config.maxWebWorkers \|\| navigator.hardwareConcurrency \|\| 1;\n\n // Spawn new web workers\n if (!config.startWebWorkersOnDemand) {\n for (let i = 0; i < config.maxWebWorkers; i++) {\n spawnWebWorker();\n }\n }\n}\n\n/\n Terminate all running web workers.\n /\nfunction terminate(): void {\n for (let i = 0; i < webWorkers.length; i++) {\n webWorkers[i].worker.terminate();\n }\n webWorkers.length = 0;\n config = undefined;\n}\n\n/\n dynamically loads a web worker task\n * @param sourcePath\n * @param taskConfig\n /\nfunction loadWebWorkerTask(sourcePath: string, taskConfig): void {\n // add it to the list of web worker tasks paths so on demand web workers\n // load this properly\n config.webWorkerTaskPaths.push(sourcePath);\n\n // if a task specific configuration is provided, merge it into the config\n if (taskConfig) {\n config.taskConfiguration = Object.assign(\n config.taskConfiguration,\n taskConfig\n );\n }\n\n // tell each spawned web worker to load this task\n for (let i = 0; i < webWorkers.length; i++) {\n webWorkers[i].worker.postMessage({\n taskType: 'loadWebWorkerTask',\n workerIndex: webWorkers.length - 1,\n sourcePath,\n config,\n });\n }\n}\n\n/\n Function to add a decode task to be performed\n \n @param taskType - the taskType for this task\n * @param data - data specific to the task\n * @param priority - optional priority of the task (defaults to 0), > 0 is higher, < 0 is lower\n * @param transferList - optional array of data to transfer to web worker\n * @returns {}\n /\nfunction addTask<T = any>(\n taskType: WorkerTaskTypes,\n data: WebWorkerDecodeTaskData,\n priority = 0,\n transferList: Transferable[]\n): { taskId: number; promise: Promise<T> } {\n if (!config) {\n initialize();\n }\n\n let deferred: WebWorkerDeferredObject<T> = {\n resolve: undefined,\n reject: undefined,\n };\n const promise = new Promise<T>((resolve, reject) => {\n deferred = {\n resolve,\n reject,\n };\n });\n\n // find the right spot to insert this decode task (based on priority)\n let i: number;\n\n for (i = 0; i < tasks.length; i++) {\n if (tasks[i].priority < priority) {\n break;\n }\n }\n\n const taskId = nextTaskId++;\n\n // insert the decode task at position i\n tasks.splice(i, 0, {\n taskId,\n taskType,\n status: 'ready',\n added: new Date().getTime(),\n data,\n deferred,\n priority,\n transferList,\n });\n\n // try to start a task on the web worker since we just added a new task and a web worker may be available\n startTaskOnWebWorker();\n\n return {\n taskId,\n promise,\n };\n}\n\n/*\n Changes the priority of a queued task\n * @param taskId - the taskId to change the priority of\n * @param priority - priority of the task (defaults to 0), > 0 is higher, < 0 is lower\n * @returns boolean - true on success, false if taskId not found\n /\nfunction setTaskPriority(taskId: number, priority = 0): boolean {\n // search for this taskId\n for (let i = 0; i < tasks.length; i++) {\n if (tasks[i].taskId === taskId) {\n // taskId found, remove it\n const task = tasks.splice(i, 1)[0];\n\n // set its priority\n task.priority = priority;\n\n // find the right spot to insert this decode task (based on priority)\n for (i = 0; i < tasks.length; i++) {\n if (tasks[i].priority < priority) {\n break;\n }\n }\n\n // insert the decode task at position i\n tasks.splice(i, 0, task);\n\n return true;\n }\n }\n\n return false;\n}\n\n/\n Cancels a queued task and rejects\n * @param taskId - the taskId to cancel\n * @param reason - optional reason the task was rejected\n * @returns boolean - true on success, false if taskId not found\n /\nfunction cancelTask(taskId: number, reason: string): boolean {\n // search for this taskId\n for (let i = 0; i < tasks.length; i++) {\n if (tasks[i].taskId === taskId) {\n // taskId found, remove it\n /\n @todo Check if this is a bug. Splice returns an array but task is\n * treated as a single task object\n /\n const task = tasks.splice(i, 1);\n\n (task as any).deferred.reject(reason);\n\n return true;\n }\n }\n\n return false;\n}\n\n/\n Function to return the statistics on running web workers\n * @returns object containing statistics\n /\nfunction getStatistics(): typeof config {\n statistics.maxWebWorkers = config.maxWebWorkers;\n statistics.numWebWorkers = webWorkers.length;\n statistics.numTasksQueued = tasks.length;\n\n return statistics;\n}\n\nexport default {\n initialize,\n loadWebWorkerTask,\n addTask,\n getStatistics,\n setTaskPriority,\n cancelTask,\n webWorkers,\n terminate,\n};\n","import decodeJPEGBaseline8BitColor from './decodeJPEGBaseline8BitColor';\nimport webWorkerManager from './webWorkerManager';\n\n// dicomParser requires pako for browser-side decoding of deflate transfer syntax\n// We only need one function though, so lets import that so we don't make our bundle\n// too large.\nimport { ByteArray } from 'dicom-parser';\nimport { inflateRaw } from 'pako/lib/inflate';\nimport { ImageFrame, LoaderDecodeOptions } from '../types';\n\n(window as any).pako = { inflateRaw };\n\nfunction processDecodeTask(\n imageFrame: ImageFrame,\n transferSyntax: string,\n pixelData: ByteArray,\n srcOptions,\n decodeConfig: LoaderDecodeOptions\n): Promise<ImageFrame> {\n const options = { ...srcOptions };\n // If a loader is specified, it can't be passed through because it is a function\n // and can't be safely cloned/copied externally.\n delete options.loader;\n // Similarly, the streamData may contain larger data information and\n // although it can be passed to the decoder, it isn't needed and is slow\n delete options.streamingData;\n\n const priority = options.priority \|\| undefined;\n const transferList = options.transferPixelData\n ? [pixelData.buffer]\n : undefined;\n\n return webWorkerManager.addTask(\n 'decodeTask',\n {\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig,\n },\n priority,\n transferList\n ).promise;\n}\n\nfunction decodeImageFrame(\n imageFrame,\n transferSyntax,\n pixelData,\n canvas,\n options = {},\n decodeConfig\n) {\n switch (transferSyntax) {\n case '1.2.840.10008.1.2':\n // Implicit VR Little Endian\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.1':\n // Explicit VR Little Endian\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.2':\n // Explicit VR Big Endian (retired)\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.1.99':\n // Deflate transfer syntax (deflated by dicomParser)\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.5':\n // RLE Lossless\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.50':\n // JPEG Baseline lossy process 1 (8 bit)\n\n // Handle 8-bit JPEG Baseline color images using the browser's built-in\n // JPEG decoding\n if (\n imageFrame.bitsAllocated === 8 &&\n (imageFrame.samplesPerPixel === 3 \|\| imageFrame.samplesPerPixel === 4)\n ) {\n return decodeJPEGBaseline8BitColor(imageFrame, pixelData, canvas);\n }\n\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.51':\n // JPEG Baseline lossy process 2 & 4 (12 bit)\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.57':\n // JPEG Lossless, Nonhierarchical (Processes 14)\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.70':\n // JPEG Lossless, Nonhierarchical (Processes 14 [Selection 1])\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.80':\n // JPEG-LS Lossless Image Compression\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.81':\n // JPEG-LS Lossy (Near-Lossless) Image Compression\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.90':\n // JPEG 2000 Lossless\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.91':\n // JPEG 2000 Lossy\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n\n case '3.2.840.10008.1.2.4.96':\n case '1.2.840.10008.1.2.4.201':\n case '1.2.840.10008.1.2.4.202':\n case '1.2.840.10008.1.2.4.203':\n // HTJ2K\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n }\n\n / Don't know if these work...\n // JPEG 2000 Part 2 Multicomponent Image Compression (Lossless Only)\n else if(transferSyntax === \"1.2.840.10008.1.2.4.92\")\n {\n return cornerstoneDICOMImageLoader.decodeJPEG2000(dataSet, frame);\n }\n // JPEG 2000 Part 2 Multicomponent Image Compression\n else if(transferSyntax === \"1.2.840.10008.1.2.4.93\")\n {\n return cornerstoneDICOMImageLoader.decodeJPEG2000(dataSet, frame);\n }\n /\n\n return Promise.reject(\n new Error(`No decoder for transfer syntax ${transferSyntax}`)\n );\n}\n\nexport default decodeImageFrame;\n","import external from '../externalModules';\nimport { ImageFrame, MetadataImagePixelModule } from '../types';\n\nfunction getImageFrame(imageId: string): ImageFrame {\n const { cornerstone } = external;\n const imagePixelModule: MetadataImagePixelModule = cornerstone.metaData.get(\n 'imagePixelModule',\n imageId\n );\n\n return {\n samplesPerPixel: imagePixelModule.samplesPerPixel,\n photometricInterpretation: imagePixelModule.photometricInterpretation,\n planarConfiguration: imagePixelModule.planarConfiguration,\n rows: imagePixelModule.rows,\n columns: imagePixelModule.columns,\n bitsAllocated: imagePixelModule.bitsAllocated,\n bitsStored: imagePixelModule.bitsStored,\n pixelRepresentation: imagePixelModule.pixelRepresentation, // 0 = unsigned,\n smallestPixelValue: imagePixelModule.smallestPixelValue,\n largestPixelValue: imagePixelModule.largestPixelValue,\n redPaletteColorLookupTableDescriptor:\n imagePixelModule.redPaletteColorLookupTableDescriptor,\n greenPaletteColorLookupTableDescriptor:\n imagePixelModule.greenPaletteColorLookupTableDescriptor,\n bluePaletteColorLookupTableDescriptor:\n imagePixelModule.bluePaletteColorLookupTableDescriptor,\n redPaletteColorLookupTableData:\n imagePixelModule.redPaletteColorLookupTableData,\n greenPaletteColorLookupTableData:\n imagePixelModule.greenPaletteColorLookupTableData,\n bluePaletteColorLookupTableData:\n imagePixelModule.bluePaletteColorLookupTableData,\n pixelData: undefined, // populated later after decoding\n imageId,\n };\n}\n\nexport default getImageFrame;\n","export default function (photoMetricInterpretation: string): boolean {\n return (\n photoMetricInterpretation === 'RGB' \|\|\n photoMetricInterpretation === 'PALETTE COLOR' \|\|\n photoMetricInterpretation === 'YBR_FULL' \|\|\n photoMetricInterpretation === 'YBR_FULL_422' \|\|\n photoMetricInterpretation === 'YBR_PARTIAL_422' \|\|\n photoMetricInterpretation === 'YBR_PARTIAL_420' \|\|\n photoMetricInterpretation === 'YBR_RCT' \|\|\n photoMetricInterpretation === 'YBR_ICT'\n );\n}\n","import { ByteArray } from 'dicom-parser';\nimport external from '../externalModules';\nimport getMinMax from '../shared/getMinMax';\nimport getPixelDataTypeFromMinMax from '../shared/getPixelDataTypeFromMinMax';\nimport {\n DICOMLoaderImageOptions,\n MetadataImagePlaneModule,\n MetadataSopCommonModule,\n DICOMLoaderIImage,\n ImageFrame,\n PixelDataTypedArray,\n} from '../types';\nimport convertColorSpace from './convertColorSpace';\nimport decodeImageFrame from './decodeImageFrame';\nimport getImageFrame from './getImageFrame';\nimport getScalingParameters from './getScalingParameters';\nimport { getOptions } from './internal/options';\nimport isColorImageFn from '../shared/isColorImage';\n\n/\n When using typical decompressors to decompress compressed color images,\n * the resulting output is in RGB or RGBA format. Additionally, these images\n * are in planar configuration 0, meaning they are arranged by plane rather\n * than by color. Consequently, the images only require a transformation from\n * RGBA to RGB without needing to use the photometric interpretation to convert\n * to RGB or adjust the planar configuration.\n /\nconst TRANSFER_SYNTAX_USING_PHOTOMETRIC_COLOR = {\n '1.2.840.10008.1.2.1': 'application/octet-stream',\n '1.2.840.10008.1.2': 'application/octet-stream',\n '1.2.840.10008.1.2.2': 'application/octet-stream',\n '1.2.840.10008.1.2.5': 'image/dicom-rle',\n};\n\nlet lastImageIdDrawn = '';\n\nfunction isModalityLUTForDisplay(sopClassUid: string): boolean {\n // special case for XA and XRF\n // https://groups.google.com/forum/#!searchin/comp.protocols.dicom/Modality$20LUT$20XA/comp.protocols.dicom/UBxhOZ2anJ0/D0R_QP8V2wIJ\n return (\n sopClassUid !== '1.2.840.10008.5.1.4.1.1.12.1' && // XA\n sopClassUid !== '1.2.840.10008.5.1.4.1.1.12.2.1'\n ); // XRF\n}\n\n/\n Helper function to set pixel d2023-03-17-16-35-04.pngata to the right typed array.\n * This is needed because web workers can transfer array buffers but not typed arrays\n \n Here we are setting the pixel data to the right typed array based on the final\n * min and max values\n /\nfunction setPixelDataType(imageFrame) {\n const minValue = imageFrame.smallestPixelValue;\n const maxValue = imageFrame.largestPixelValue;\n\n const TypedArray = getPixelDataTypeFromMinMax(minValue, maxValue);\n\n if (TypedArray) {\n const typedArray = new TypedArray(imageFrame.pixelData);\n imageFrame.pixelData = typedArray;\n } else {\n throw new Error('Could not apply a typed array to the pixel data');\n }\n}\n\n/\n Removes the A from RGBA to return RGB buffer, this is used when the\n * decoding happens with browser API which results in RGBA, but if useRGBA flag\n * is set to false, we want to return RGB\n \n @param pixelData - decoded image in RGBA\n * @param targetBuffer - target buffer to write to\n /\nfunction removeAFromRGBA(\n pixelData: PixelDataTypedArray,\n targetBuffer: Uint8ClampedArray \| Uint8Array\n) {\n const numPixels = pixelData.length / 4;\n\n let rgbIndex = 0;\n\n let bufferIndex = 0;\n\n for (let i = 0; i < numPixels; i++) {\n targetBuffer[bufferIndex++] = pixelData[rgbIndex++]; // red\n targetBuffer[bufferIndex++] = pixelData[rgbIndex++]; // green\n targetBuffer[bufferIndex++] = pixelData[rgbIndex++]; // blue\n rgbIndex++; // skip alpha\n }\n\n return targetBuffer;\n}\n\nfunction createImage(\n imageId: string,\n pixelData: ByteArray,\n transferSyntax: string,\n options: DICOMLoaderImageOptions = {}\n): Promise<DICOMLoaderIImage \| ImageFrame> {\n // whether to use RGBA for color images, default true as cs-legacy uses RGBA\n // but we don't need RGBA in cs3d, and it's faster, and memory-efficient\n // in cs3d\n const useRGBA = options.useRGBA;\n\n // always preScale the pixel array unless it is asked not to\n options.preScale = {\n enabled:\n options.preScale && options.preScale.enabled !== undefined\n ? options.preScale.enabled\n : false,\n };\n\n if (!pixelData?.length) {\n return Promise.reject(new Error('The pixel data is missing'));\n }\n\n const { cornerstone } = external;\n const { MetadataModules } = cornerstone.Enums;\n const canvas = document.createElement('canvas');\n const imageFrame = getImageFrame(imageId);\n imageFrame.decodeLevel = options.decodeLevel;\n\n options.allowFloatRendering = cornerstone.canRenderFloatTextures();\n\n // Get the scaling parameters from the metadata\n if (options.preScale.enabled) {\n const scalingParameters = getScalingParameters(\n cornerstone.metaData,\n imageId\n );\n\n if (scalingParameters) {\n options.preScale = {\n ...options.preScale,\n scalingParameters,\n };\n }\n }\n\n // we need to identify if the target buffer is a SharedArrayBuffer\n // since inside the webworker we don't have access to the window\n // to say if it is a SharedArrayBuffer or not with instanceof\n options.isSharedArrayBuffer =\n options.targetBuffer?.arrayBuffer &&\n options.targetBuffer.arrayBuffer instanceof SharedArrayBuffer;\n\n const { decodeConfig } = getOptions();\n\n // check if the options to use the 16 bit data type is set\n // on the image load options, and prefer that over the global\n // options of the dicom loader\n decodeConfig.use16BitDataType =\n (options && options.targetBuffer?.type === 'Uint16Array') \|\|\n options.targetBuffer?.type === 'Int16Array'\n ? true\n : options.useNativeDataType \|\| decodeConfig.use16BitDataType;\n\n const decodePromise = decodeImageFrame(\n imageFrame,\n transferSyntax,\n pixelData,\n canvas,\n options,\n decodeConfig\n );\n\n const { use16BitDataType } = decodeConfig;\n const isColorImage = isColorImageFn(imageFrame.photometricInterpretation);\n\n return new Promise<DICOMLoaderIImage \| ImageFrame>((resolve, reject) => {\n // eslint-disable-next-line complexity\n decodePromise.then(function (imageFrame: ImageFrame) {\n // if it is desired to skip creating image, return the imageFrame\n // after the decode. This might be useful for some applications\n // that only need the decoded pixel data and not the image object\n if (options.skipCreateImage) {\n return resolve(imageFrame);\n }\n // If we have a target buffer that was written to in the\n // Decode task, point the image to it here.\n // We can't have done it within the thread incase it was a SharedArrayBuffer.\n let alreadyTyped = false;\n // We can safely render color image in 8 bit, so no need to convert\n if (options.targetBuffer && options.targetBuffer.type && !isColorImage) {\n const {\n arrayBuffer,\n type,\n offset: rawOffset = 0,\n length: rawLength,\n } = options.targetBuffer;\n\n const imageFrameLength = imageFrame.pixelDataLength;\n\n const offset = rawOffset;\n const length =\n rawLength !== null && rawLength !== undefined\n ? rawLength\n : imageFrameLength - offset;\n\n const typedArrayConstructors = {\n Uint8Array,\n Uint16Array: use16BitDataType ? Uint16Array : undefined,\n Int16Array: use16BitDataType ? Int16Array : undefined,\n Float32Array,\n };\n\n if (length !== imageFrame.pixelDataLength) {\n throw new Error(\n `target array for image does not have the same length (${length}) as the decoded image length (${imageFrame.pixelDataLength}).`\n );\n }\n\n const TypedArrayConstructor = typedArrayConstructors[type];\n\n // TypedArray.Set is api level and ~50x faster than copying elements even for\n // Arrays of different types, which aren't simply memcpy ops.\n const typedArray = arrayBuffer\n ? new TypedArrayConstructor(arrayBuffer, offset, length)\n : new TypedArrayConstructor(imageFrame.pixelData);\n\n if (length !== imageFrame.pixelDataLength) {\n throw new Error(\n 'target array for image does not have the same length as the decoded image length.'\n );\n }\n\n imageFrame.pixelData = typedArray;\n alreadyTyped = true;\n }\n\n if (!alreadyTyped) {\n setPixelDataType(imageFrame);\n }\n\n const imagePlaneModule: MetadataImagePlaneModule =\n cornerstone.metaData.get(MetadataModules.IMAGE_PLANE, imageId) \|\| {};\n const voiLutModule =\n cornerstone.metaData.get(MetadataModules.VOI_LUT, imageId) \|\| {};\n const modalityLutModule =\n cornerstone.metaData.get(MetadataModules.MODALITY_LUT, imageId) \|\| {};\n const sopCommonModule: MetadataSopCommonModule =\n cornerstone.metaData.get(MetadataModules.SOP_COMMON, imageId) \|\| {};\n const calibrationModule =\n cornerstone.metaData.get(MetadataModules.CALIBRATION, imageId) \|\| {};\n\n if (isColorImage) {\n const { rows, columns } = imageFrame;\n if (TRANSFER_SYNTAX_USING_PHOTOMETRIC_COLOR[transferSyntax]) {\n canvas.height = imageFrame.rows;\n canvas.width = imageFrame.columns;\n const context = canvas.getContext('2d');\n let imageData = context.createImageData(\n imageFrame.columns,\n imageFrame.rows\n );\n if (!useRGBA) {\n imageData = {\n ...imageData,\n data: new Uint8ClampedArray(\n imageFrame.samplesPerPixel \n imageFrame.columns \n imageFrame.rows\n ),\n };\n }\n convertColorSpace(imageFrame, imageData.data, useRGBA);\n imageFrame.imageData = imageData;\n imageFrame.pixelData = imageData.data;\n imageFrame.pixelDataLength = imageData.data.length;\n } else if (\n !useRGBA &&\n imageFrame.pixelDataLength === 4 rows * columns\n ) {\n // This case is the case where we need RGB (that is !useRGBA), and\n // we have RGBA (that is 4 values per pixel, not 3). For this case,\n // remove the A value.\n // Note: rendering libraries like vtk expect Uint8Array for RGB images\n // otherwise they will convert them to Float32Array which might be slow\n const colorBuffer = new Uint8Array(\n (imageFrame.pixelData.length / 4) * 3\n );\n\n // remove the A from the RGBA of the imageFrame\n imageFrame.pixelData = removeAFromRGBA(\n imageFrame.pixelData,\n colorBuffer\n );\n\n imageFrame.pixelDataLength = imageFrame.pixelData.length;\n }\n // else {\n // No need to do any conversion - already RGB\n // Consider RGB to RGBA conversion?\n\n /** @todo check as any /\n // calculate smallest and largest PixelValue of the converted pixelData\n const minMax = getMinMax(imageFrame.pixelData as any);\n\n imageFrame.smallestPixelValue = minMax.min;\n imageFrame.largestPixelValue = minMax.max;\n }\n\n const image: DICOMLoaderIImage = {\n imageId,\n color: isColorImage,\n calibration: calibrationModule,\n columnPixelSpacing: imagePlaneModule.columnPixelSpacing,\n columns: imageFrame.columns,\n height: imageFrame.rows,\n preScale: imageFrame.preScale,\n intercept: modalityLutModule.rescaleIntercept\n ? modalityLutModule.rescaleIntercept\n : 0,\n slope: modalityLutModule.rescaleSlope\n ? modalityLutModule.rescaleSlope\n : 1,\n invert: imageFrame.photometricInterpretation === 'MONOCHROME1',\n minPixelValue: imageFrame.smallestPixelValue,\n maxPixelValue: imageFrame.largestPixelValue,\n rowPixelSpacing: imagePlaneModule.rowPixelSpacing,\n rows: imageFrame.rows,\n sizeInBytes: imageFrame.pixelData.byteLength,\n width: imageFrame.columns,\n // use the first value for rendering, if other values\n // are needed later, it can be grabbed again from the voiLUtModule\n windowCenter: voiLutModule.windowCenter\n ? voiLutModule.windowCenter[0]\n : undefined,\n windowWidth: voiLutModule.windowWidth\n ? voiLutModule.windowWidth[0]\n : undefined,\n voiLUTFunction: voiLutModule.voiLUTFunction\n ? voiLutModule.voiLUTFunction\n : undefined,\n decodeTimeInMS: imageFrame.decodeTimeInMS,\n floatPixelData: undefined,\n imageFrame,\n rgba: isColorImage && useRGBA,\n getPixelData: () => imageFrame.pixelData,\n getCanvas: undefined,\n numComps: undefined,\n };\n\n if (image.color) {\n image.getCanvas = function () {\n // the getCanvas function is used in the CPU rendering path\n // and it is used to use the canvas api to draw the image\n // instead of looping through the pixel data and drawing each pixel\n // to use the canvas api, we need to convert the pixel data to a\n // Uint8ClampedArray (which is what the canvas api expects)\n // and then we can use the putImageData api to draw the image\n // However, if the image already was loaded without the alpha channel\n // we need to add the alpha channel back in\n if (lastImageIdDrawn === imageId) {\n return canvas;\n }\n\n const width = image.columns;\n const height = image.rows;\n\n canvas.height = height;\n canvas.width = width;\n const ctx = canvas.getContext('2d');\n const imageData = ctx.createImageData(width, height);\n\n const arr = imageFrame.pixelData;\n\n if (arr.length === width height * 4) {\n for (let i = 0; i < arr.length; i++) {\n imageData.data[i] = arr[i];\n }\n }\n // Set pixel data for RGB array\n else if (arr.length === width * height * 3) {\n let j = 0;\n for (let i = 0; i < arr.length; i += 3) {\n imageData.data[j++] = arr[i];\n imageData.data[j++] = arr[i + 1];\n imageData.data[j++] = arr[i + 2];\n imageData.data[j++] = 255;\n }\n }\n\n imageFrame.pixelData = imageData.data;\n imageFrame.pixelDataLength = imageData.data.length;\n\n imageFrame.imageData = imageData;\n ctx.putImageData(imageFrame.imageData, 0, 0);\n lastImageIdDrawn = imageId;\n\n return canvas;\n };\n }\n\n // Modality LUT\n if (\n modalityLutModule.modalityLUTSequence &&\n modalityLutModule.modalityLUTSequence.length > 0 &&\n isModalityLUTForDisplay(sopCommonModule.sopClassUID)\n ) {\n image.modalityLUT = modalityLutModule.modalityLUTSequence[0];\n }\n\n // VOI LUT\n if (\n voiLutModule.voiLUTSequence &&\n voiLutModule.voiLUTSequence.length > 0\n ) {\n image.voiLUT = voiLutModule.voiLUTSequence[0];\n }\n\n if (image.color) {\n // Note that by the DICOM definition, the window width and center are\n // 256/128 for an identity transform.\n image.windowWidth = 256;\n image.windowCenter = 128;\n }\n\n // set the ww/wc to cover the dynamic range of the image if no values are supplied\n if (image.windowCenter === undefined \|\| image.windowWidth === undefined) {\n const minVoi = image.imageFrame.minAfterScale;\n const maxVoi = image.imageFrame.maxAfterScale;\n\n image.windowWidth = maxVoi - minVoi;\n image.windowCenter = (maxVoi + minVoi) / 2;\n }\n resolve(image);\n }, reject);\n });\n}\n\nexport default createImage;\n","import { PixelDataTypedArray } from '../types';\n\nexport default function getPixelDataTypeFromMinMax(\n min: number,\n max: number\n): PixelDataTypedArray {\n let pixelDataType;\n if (Number.isInteger(min) && Number.isInteger(max)) {\n if (min >= 0) {\n if (max <= 255) {\n pixelDataType = Uint8Array;\n } else if (max <= 65535) {\n pixelDataType = Uint16Array;\n }\n } else {\n if (min >= -128 && max <= 127) {\n pixelDataType = Int8Array;\n } else if (min >= -32768 && max <= 32767) {\n pixelDataType = Int16Array;\n }\n }\n }\n\n return pixelDataType \|\| Float32Array;\n}\n","import { MetadataGeneralSeriesModule } from '../types';\n\n/*\n It returns the scaling parameters for the image with the given imageId. This can be\n * used to get passed (as an option) to the imageLoader in order to apply scaling to the image inside\n * the imageLoader.\n * @param imageId - The imageId of the image\n * @returns ScalingParameters\n /\nexport default function getScalingParameters(metaData: any, imageId: string) {\n const modalityLutModule = metaData.get('modalityLutModule', imageId) \|\| {};\n\n const generalSeriesModule: MetadataGeneralSeriesModule =\n metaData.get('generalSeriesModule', imageId) \|\| {};\n\n const { modality } = generalSeriesModule;\n\n const scalingParameters = {\n rescaleSlope: modalityLutModule.rescaleSlope,\n rescaleIntercept: modalityLutModule.rescaleIntercept,\n modality,\n };\n\n const suvFactor = metaData.get('scalingModule', imageId) \|\| {};\n\n return {\n ...scalingParameters,\n ...(modality === 'PT' && { suvbw: suvFactor.suvbw }),\n };\n}\n","import { Enums, utilities, metaData } from '@cornerstonejs/core';\nimport type { Types, RetrieveOptions } from '@cornerstonejs/core';\n\nimport external from '../../externalModules';\nimport createImage from '../createImage';\nimport getPixelData from './getPixelData';\nimport { DICOMLoaderIImage, DICOMLoaderImageOptions } from '../../types';\n\nconst { ProgressiveIterator } = utilities;\nconst { ImageQualityStatus } = Enums;\nconst streamableTransferSyntaxes = new Set<string>([\n // Private HTJ2K\n '3.2.840.10008.1.2.4.96',\n // Released HTJ2K - only the RPCL one is definitely streamable.\n '1.2.840.10008.1.2.4.202',\n // HTJ2K lossy might be streamable, so try it. If it fails it is ok as it will\n // proceed and eventually work.\n '1.2.840.10008.1.2.4.203',\n]);\n\n/\n Helper method to extract the transfer-syntax from the response of the server.\n * @param {string} contentType The value of the content-type header as returned by the WADO-RS server.\n * @return The transfer-syntax as announced by the server, or Implicit Little Endian by default.\n /\nexport function getTransferSyntaxForContentType(contentType: string): string {\n const defaultTransferSyntax = '1.2.840.10008.1.2'; // Default is Implicit Little Endian.\n if (!contentType) {\n return defaultTransferSyntax;\n }\n\n // Browse through the content type parameters\n const parameters = contentType.split(';');\n const params: Record<string, string> = {};\n\n parameters.forEach((parameter) => {\n // Look for a transfer-syntax=XXXX pair\n const parameterValues = parameter.split('=');\n\n if (parameterValues.length !== 2) {\n return;\n }\n\n const value = parameterValues[1].trim().replace(/\"/g, '');\n\n params[parameterValues[0].trim()] = value;\n });\n\n // This is useful if the PACS doesn't respond with a syntax\n // in the content type.\n // http://dicom.nema.org/medical/dicom/current/output/chtml/part18/chapter_6.html#table_6.1.1.8-3b\n const defaultTransferSyntaxByType = {\n 'image/jpeg': '1.2.840.10008.1.2.4.50',\n 'image/x-dicom-rle': '1.2.840.10008.1.2.5',\n 'image/x-jls': '1.2.840.10008.1.2.4.80',\n 'image/jls': '1.2.840.10008.1.2.4.80',\n 'image/jll': '1.2.840.10008.1.2.4.70',\n 'image/jp2': '1.2.840.10008.1.2.4.90',\n 'image/jpx': '1.2.840.10008.1.2.4.92',\n // Temporary types, until ratified by DICOM committed - TODO\n 'image/jphc': '3.2.840.10008.1.2.4.96',\n 'image/jxl': '1.2.840.10008.1.2.4.140',\n };\n\n if (params['transfer-syntax']) {\n return params['transfer-syntax'];\n } else if (\n contentType &&\n !Object.keys(params).length &&\n defaultTransferSyntaxByType[contentType]\n ) {\n // dcm4che seems to be reporting the content type as just 'image/jp2'?\n return defaultTransferSyntaxByType[contentType];\n } else if (params.type && defaultTransferSyntaxByType[params.type]) {\n return defaultTransferSyntaxByType[params.type];\n } else if (defaultTransferSyntaxByType[contentType]) {\n return defaultTransferSyntaxByType[contentType];\n }\n\n return defaultTransferSyntax;\n}\n\nfunction getImageRetrievalPool() {\n return external.cornerstone.imageRetrievalPoolManager;\n}\n\nexport interface StreamingData {\n url: string;\n encodedData?: Uint8Array;\n // Some values used by instances of streaming data for range\n totalBytes?: number;\n chunkSize?: number;\n totalRanges?: number;\n rangesFetched?: number;\n}\n\nexport interface CornerstoneWadoRsLoaderOptions\n extends DICOMLoaderImageOptions {\n requestType?: string;\n additionalDetails?: {\n imageId: string;\n };\n priority?: number;\n addToBeginning?: boolean;\n retrieveType?: string;\n transferSyntaxUID?: string;\n // Retrieve options are stored to provide sub-options for nested calls\n retrieveOptions?: RetrieveOptions;\n // Streaming data adds information about already streamed results.\n streamingData?: StreamingData;\n}\n\n// TODO: load bulk data items that we might need\n\n// Uncomment this on to test jpegls codec in OHIF\n// const mediaType = 'multipart/related; type=\"image/x-jls\"';\n// const mediaType = 'multipart/related; type=\"application/octet-stream\"; transfer-syntax=\"image/x-jls\"';\nconst mediaType =\n 'multipart/related; type=application/octet-stream; transfer-syntax=';\n\nfunction loadImage(\n imageId: string,\n options: CornerstoneWadoRsLoaderOptions = {}\n): Types.IImageLoadObject {\n const imageRetrievalPool = getImageRetrievalPool();\n\n const start = new Date().getTime();\n\n const uncompressedIterator = new ProgressiveIterator<DICOMLoaderIImage>(\n 'decompress'\n );\n async function sendXHR(imageURI: string, imageId: string, mediaType: string) {\n uncompressedIterator.generate(async (it) => {\n // get the pixel data from the server\n const compressedIt = ProgressiveIterator.as(\n getPixelData(imageURI, imageId, mediaType, options)\n );\n let lastDecodeLevel = 10;\n for await (const result of compressedIt) {\n const {\n pixelData,\n imageQualityStatus = ImageQualityStatus.FULL_RESOLUTION,\n percentComplete,\n done = true,\n extractDone = true,\n } = result;\n const transferSyntax = getTransferSyntaxForContentType(\n result.contentType\n );\n if (!extractDone && !streamableTransferSyntaxes.has(transferSyntax)) {\n continue;\n }\n const decodeLevel =\n result.decodeLevel ??\n (imageQualityStatus === ImageQualityStatus.FULL_RESOLUTION\n ? 0\n : decodeLevelFromComplete(\n percentComplete,\n options.retrieveOptions?.decodeLevel\n ));\n if (!done && lastDecodeLevel <= decodeLevel) {\n // No point trying again yet\n continue;\n }\n\n try {\n const useOptions = {\n ...options,\n decodeLevel,\n };\n const image = (await createImage(\n imageId,\n pixelData,\n transferSyntax,\n useOptions\n )) as DICOMLoaderIImage;\n\n // add the loadTimeInMS property\n const end = new Date().getTime();\n\n image.loadTimeInMS = end - start;\n image.transferSyntaxUID = transferSyntax;\n image.imageQualityStatus = imageQualityStatus;\n // The iteration is done even if the image itself isn't done yet\n it.add(image, done);\n lastDecodeLevel = decodeLevel;\n } catch (e) {\n if (extractDone) {\n console.warn(\"Couldn't decode\", e);\n throw e;\n }\n }\n }\n });\n }\n\n const requestType = options.requestType \|\| 'interaction';\n const additionalDetails = options.additionalDetails \|\| { imageId };\n const priority = options.priority === undefined ? 5 : options.priority;\n const addToBeginning = options.addToBeginning \|\| false;\n const uri = imageId.substring(7);\n\n imageRetrievalPool.addRequest(\n sendXHR.bind(this, uri, imageId, mediaType),\n requestType,\n additionalDetails,\n priority,\n addToBeginning\n );\n\n return {\n promise: uncompressedIterator.getDonePromise(),\n cancelFn: undefined,\n };\n}\n\n/** The decode level is based on how much of hte data is needed for\n * each level. It is a square function, so\n * level 4 only needs 1/25 of the data (eg (4+1)^2). Add 2% to ensure\n * there is enough space\n /\nfunction decodeLevelFromComplete(percent: number, retrieveDecodeLevel = 4) {\n const testSize = percent / 100 - 0.02;\n if (testSize > 1 / 4) {\n return Math.min(retrieveDecodeLevel, 0);\n }\n if (testSize > 1 / 16) {\n return Math.min(retrieveDecodeLevel, 1);\n }\n if (testSize > 1 / 64) {\n return Math.min(retrieveDecodeLevel, 2);\n }\n return Math.min(retrieveDecodeLevel, 3);\n}\n\nexport default loadImage;\n","import {\n getNumberString,\n getNumberValue,\n getNumberValues,\n getValue,\n metaDataProvider,\n} from './metaData/index';\n\nimport findIndexOfString from './findIndexOfString';\nimport getPixelData from './getPixelData';\nimport metaDataManager from './metaDataManager';\nimport loadImage from './loadImage';\nimport register from './register';\n\nconst metaData = {\n getNumberString,\n getNumberValue,\n getNumberValues,\n getValue,\n metaDataProvider,\n};\n\nexport default {\n metaData,\n findIndexOfString,\n getPixelData,\n loadImage,\n metaDataManager,\n register,\n};\n","import loadImage from './loadImage';\nimport { metaDataProvider } from './metaData/index';\n\nexport default function (cornerstone) {\n // register wadors scheme and metadata provider\n cornerstone.registerImageLoader('wadors', loadImage);\n cornerstone.metaData.addProvider(metaDataProvider);\n}\n","import { MetadataImagePixelModule } from '../../../types';\nimport { DataSet } from 'dicom-parser';\n\nfunction getLutDescriptor(dataSet: DataSet, tag: string) {\n if (!dataSet.elements[tag] \|\| dataSet.elements[tag].length !== 6) {\n return;\n }\n\n return [\n dataSet.uint16(tag, 0),\n dataSet.uint16(tag, 1),\n dataSet.uint16(tag, 2),\n ];\n}\n\nfunction getLutData(lutDataSet: DataSet, tag: string, lutDescriptor): number[] {\n const lut = [];\n const lutData = lutDataSet.elements[tag];\n\n for (let i = 0; i < lutDescriptor[0]; i++) {\n // Output range is always unsigned\n if (lutDescriptor[2] === 16) {\n lut[i] = lutDataSet.uint16(tag, i);\n } else {\n lut[i] = lutDataSet.byteArray[i + lutData.dataOffset];\n }\n }\n\n return lut;\n}\n\nfunction populatePaletteColorLut(\n dataSet: DataSet,\n imagePixelModule: MetadataImagePixelModule\n) {\n imagePixelModule.redPaletteColorLookupTableDescriptor = getLutDescriptor(\n dataSet,\n 'x00281101'\n );\n imagePixelModule.greenPaletteColorLookupTableDescriptor = getLutDescriptor(\n dataSet,\n 'x00281102'\n );\n imagePixelModule.bluePaletteColorLookupTableDescriptor = getLutDescriptor(\n dataSet,\n 'x00281103'\n );\n\n // The first Palette Color Lookup Table Descriptor value is the number of entries in the lookup table.\n // When the number of table entries is equal to 2ˆ16 then this value shall be 0.\n // See http://dicom.nema.org/MEDICAL/DICOM/current/output/chtml/part03/sect_C.7.6.3.html#sect_C.7.6.3.1.5\n if (imagePixelModule.redPaletteColorLookupTableDescriptor[0] === 0) {\n imagePixelModule.redPaletteColorLookupTableDescriptor[0] = 65536;\n imagePixelModule.greenPaletteColorLookupTableDescriptor[0] = 65536;\n imagePixelModule.bluePaletteColorLookupTableDescriptor[0] = 65536;\n }\n\n // The third Palette Color Lookup Table Descriptor value specifies the number of bits for each entry in the Lookup Table Data.\n // It shall take the value of 8 or 16.\n // The LUT Data shall be stored in a format equivalent to 8 bits allocated when the number of bits for each entry is 8, and 16 bits allocated when the number of bits for each entry is 16, where in both cases the high bit is equal to bits allocated-1.\n // The third value shall be identical for each of the Red, Green and Blue Palette Color Lookup Table Descriptors.\n //\n // Note: Some implementations have encoded 8 bit entries with 16 bits allocated, padding the high bits;\n // this can be detected by comparing the number of entries specified in the LUT Descriptor with the actual value length of the LUT Data entry.\n // The value length in bytes should equal the number of entries if bits allocated is 8, and be twice as long if bits allocated is 16.\n const numLutEntries =\n imagePixelModule.redPaletteColorLookupTableDescriptor[0];\n const lutData = dataSet.elements.x00281201;\n const lutBitsAllocated = lutData.length === numLutEntries ? 8 : 16;\n\n // If the descriptors do not appear to have the correct values, correct them\n if (\n imagePixelModule.redPaletteColorLookupTableDescriptor[2] !==\n lutBitsAllocated\n ) {\n imagePixelModule.redPaletteColorLookupTableDescriptor[2] = lutBitsAllocated;\n imagePixelModule.greenPaletteColorLookupTableDescriptor[2] =\n lutBitsAllocated;\n imagePixelModule.bluePaletteColorLookupTableDescriptor[2] =\n lutBitsAllocated;\n }\n\n imagePixelModule.redPaletteColorLookupTableData = getLutData(\n dataSet,\n 'x00281201',\n imagePixelModule.redPaletteColorLookupTableDescriptor\n );\n imagePixelModule.greenPaletteColorLookupTableData = getLutData(\n dataSet,\n 'x00281202',\n imagePixelModule.greenPaletteColorLookupTableDescriptor\n );\n imagePixelModule.bluePaletteColorLookupTableData = getLutData(\n dataSet,\n 'x00281203',\n imagePixelModule.bluePaletteColorLookupTableDescriptor\n );\n}\n\nfunction populateSmallestLargestPixelValues(\n dataSet: DataSet,\n imagePixelModule: MetadataImagePixelModule\n) {\n const pixelRepresentation = dataSet.uint16('x00280103');\n\n if (pixelRepresentation === 0) {\n imagePixelModule.smallestPixelValue = dataSet.uint16('x00280106');\n imagePixelModule.largestPixelValue = dataSet.uint16('x00280107');\n } else {\n imagePixelModule.smallestPixelValue = dataSet.int16('x00280106');\n imagePixelModule.largestPixelValue = dataSet.int16('x00280107');\n }\n}\n\nfunction getImagePixelModule(dataSet: DataSet): MetadataImagePixelModule {\n const imagePixelModule = {\n samplesPerPixel: dataSet.uint16('x00280002'),\n photometricInterpretation: dataSet.string('x00280004'),\n rows: dataSet.uint16('x00280010'),\n columns: dataSet.uint16('x00280011'),\n bitsAllocated: dataSet.uint16('x00280100'),\n bitsStored: dataSet.uint16('x00280101'),\n highBit: dataSet.uint16('x00280102'),\n pixelRepresentation: dataSet.uint16('x00280103'),\n planarConfiguration: dataSet.uint16('x00280006'),\n pixelAspectRatio: dataSet.string('x00280034'),\n } as MetadataImagePixelModule;\n\n populateSmallestLargestPixelValues(dataSet, imagePixelModule);\n\n if (\n imagePixelModule.photometricInterpretation === 'PALETTE COLOR' &&\n dataSet.elements.x00281101\n ) {\n populatePaletteColorLut(dataSet, imagePixelModule);\n }\n\n return imagePixelModule;\n}\n\nexport default getImagePixelModule;\n","import { DataSet, Element } from 'dicom-parser';\nimport { LutType } from '../../../types';\n\nfunction getLUT(pixelRepresentation: number, lutDataSet: DataSet): LutType {\n let numLUTEntries = lutDataSet.uint16('x00283002', 0);\n\n if (numLUTEntries === 0) {\n numLUTEntries = 65535;\n }\n let firstValueMapped = 0;\n\n if (pixelRepresentation === 0) {\n firstValueMapped = lutDataSet.uint16('x00283002', 1);\n } else {\n firstValueMapped = lutDataSet.int16('x00283002', 1);\n }\n const numBitsPerEntry = lutDataSet.uint16('x00283002', 2);\n // console.log('LUT(', numLUTEntries, ',', firstValueMapped, ',', numBitsPerEntry, ')');\n const lut = {\n id: '1',\n firstValueMapped,\n numBitsPerEntry,\n lut: [],\n };\n\n // console.log(\"minValue=\", minValue, \"; maxValue=\", maxValue);\n for (let i = 0; i < numLUTEntries; i++) {\n if (pixelRepresentation === 0) {\n lut.lut[i] = lutDataSet.uint16('x00283006', i);\n } else {\n lut.lut[i] = lutDataSet.int16('x00283006', i);\n }\n }\n\n return lut;\n}\n\nfunction getLUTs(pixelRepresentation: number, lutSequence: Element): LutType[] {\n if (!lutSequence \|\| !lutSequence.items \|\| !lutSequence.items.length) {\n return;\n }\n const luts: LutType[] = [];\n\n for (let i = 0; i < lutSequence.items.length; i++) {\n const lutDataSet = lutSequence.items[i].dataSet;\n const lut = getLUT(pixelRepresentation, lutDataSet);\n\n if (lut) {\n luts.push(lut);\n }\n }\n\n return luts;\n}\n\nexport default getLUTs;\n","/ eslint no-bitwise: 0 /\n\nimport { DataSet } from 'dicom-parser';\n\nfunction getMinStoredPixelValue(dataSet: DataSet) {\n const pixelRepresentation = dataSet.uint16('x00280103');\n const bitsStored = dataSet.uint16('x00280101');\n\n if (pixelRepresentation === 0) {\n return 0;\n }\n\n return -1 << (bitsStored - 1);\n}\n\n// 0 = unsigned / US, 1 = signed / SS\nfunction getModalityLUTOutputPixelRepresentation(dataSet: DataSet) {\n // CT SOP Classes are always signed\n const sopClassUID = dataSet.string('x00080016');\n\n if (\n sopClassUID === '1.2.840.10008.5.1.4.1.1.2' \|\|\n sopClassUID === '1.2.840.10008.5.1.4.1.1.2.1'\n ) {\n return 1;\n }\n\n // if rescale intercept and rescale slope are present, pass the minimum stored\n // pixel value through them to see if we get a signed output range\n const rescaleIntercept = dataSet.floatString('x00281052');\n const rescaleSlope = dataSet.floatString('x00281053');\n\n if (rescaleIntercept !== undefined && rescaleSlope !== undefined) {\n const minStoredPixelValue = getMinStoredPixelValue(dataSet); //\n const minModalityLutValue =\n minStoredPixelValue rescaleSlope + rescaleIntercept;\n\n if (minModalityLutValue < 0) {\n return 1;\n }\n\n return 0;\n }\n\n // Output of non linear modality lut is always unsigned\n if (dataSet.elements.x00283000 && dataSet.elements.x00283000.length > 0) {\n return 0;\n }\n\n // If no modality lut transform, output is same as pixel representation\n return dataSet.uint16('x00280103');\n}\n\nexport default getModalityLUTOutputPixelRepresentation;\n","import { DataSet } from 'dicom-parser';\n\nfunction getNumberValues(\n dataSet: DataSet,\n tag: string,\n minimumLength: number\n): number[] {\n const values = [];\n const valueAsString = dataSet.string(tag);\n\n if (!valueAsString) {\n return;\n }\n const split = valueAsString.split('\\\\');\n\n if (minimumLength && split.length < minimumLength) {\n return;\n }\n for (let i = 0; i < split.length; i++) {\n values.push(parseFloat(split[i]));\n }\n\n return values;\n}\n\nexport default getNumberValues;\n","export interface CornerstoneImageUrl {\n scheme: string;\n url: string;\n frame: number;\n pixelDataFrame: number;\n}\n\nfunction parseImageId(imageId: string): CornerstoneImageUrl {\n // build a url by parsing out the url scheme and frame index from the imageId\n const firstColonIndex = imageId.indexOf(':');\n\n let url = imageId.substring(firstColonIndex + 1);\n const frameIndex = url.indexOf('frame=');\n\n let frame;\n\n if (frameIndex !== -1) {\n const frameStr = url.substring(frameIndex + 6);\n\n frame = parseInt(frameStr, 10);\n url = url.substring(0, frameIndex - 1);\n }\n\n const scheme = imageId.substring(0, firstColonIndex);\n /*\n Why we adjust frameNumber? since in the above we are extracting the\n * frame number from the imageId (from the metadata), and the frame number\n * starts from 1, but in the loader which uses the dicomParser\n * the frame number starts from 0.\n /\n\n const adjustedFrame = frame !== undefined ? frame - 1 : undefined;\n\n return {\n scheme,\n url,\n frame,\n pixelDataFrame: adjustedFrame,\n };\n}\n\nexport default parseImageId;\n","import { DataSet } from 'dicom-parser';\nimport external from '../../externalModules';\nimport {\n LoadRequestFunction,\n DICOMLoaderDataSetWithFetchMore,\n} from '../../types';\n\nfunction fixFragments(dataSet: DataSet) {\n // The partially parsed pixelData element has incorrect fragment\n // lengths because the byte array is truncated, so we manually set\n // it to the actual length.\n const fragments = dataSet.elements.x7fe00010.fragments;\n const totalLength = dataSet.byteArray.length;\n\n for (const fragment of fragments) {\n const { position, length } = fragment;\n\n if (length > totalLength - position) {\n console.log(\n `Truncated fragment, changing fragment length from ${\n fragment.length\n } to ${totalLength - position}`\n );\n fragment.length = totalLength - position;\n }\n }\n\n return dataSet;\n}\n\nfunction parsePartialByteArray(byteArray: Uint8Array) {\n const { dicomParser } = external;\n /\n First parse just up to pixelData. This will make sure the\n * metadata header is correctly parsed (assuming no other error is\n * thrown during parsing). Then, parse again using the whole partial\n * arraybuffer. This will error, but still kick out the parsed\n * partial pixel data in the error object.\n /\n\n let dataSet = dicomParser.parseDicom(byteArray, {\n untilTag: 'x7fe00010',\n });\n\n if (!dataSet.elements.x7fe00010) {\n console.warn('Pixel data not found!');\n // Re-fetch more of the file\n }\n\n let pixelDataSet: DataSet;\n\n try {\n // This is expected to fail, since the file is incomplete, but\n // dicomParser helpfully spits out the parsed partial dataset in\n // the error object. The problem is, the dataset here is\n // incomplete, because dicomParser throws before* combining the\n // metadata header and regular datasets, so transfer syntax and\n // other metadata headers aren't included.\n pixelDataSet = dicomParser.parseDicom(byteArray);\n } catch (err: any) {\n // Todo: This is probably invalid handling - it expects the only reason to\n // fail is a partial dataset\n console.error(err);\n console.log('pixel data dataset:', err.dataSet);\n pixelDataSet = err.dataSet;\n }\n\n // Add the parsed partial pixel data element to the dataset\n // including the metadata headers.\n dataSet.elements.x7fe00010 = pixelDataSet.elements.x7fe00010;\n\n dataSet = fixFragments(dataSet);\n\n return dataSet;\n}\n\nexport default async function dataSetFromPartialContent(\n byteArray: Uint8Array,\n loadRequest: LoadRequestFunction,\n metadata: {\n uri: string;\n imageId: string;\n fileTotalLength: number \| null;\n }\n): Promise<DICOMLoaderDataSetWithFetchMore> {\n const dataSet: DICOMLoaderDataSetWithFetchMore =\n parsePartialByteArray(byteArray);\n const { uri, imageId, fileTotalLength } = metadata;\n\n // Allow re-fetching of more of the file\n dataSet.fetchMore = async function (fetchOptions) {\n // Default to fetching the rest of the file if no lengthToFetch is set. Also\n // default to fetching the same URI/imageId\n const _options = Object.assign(\n {\n uri,\n imageId,\n fetchedLength: byteArray.length, // Not sure if this would ever need to be configurable tbh\n lengthToFetch: fileTotalLength - byteArray.length,\n },\n fetchOptions\n );\n const { fetchedLength, lengthToFetch } = _options;\n\n // Use passed xhr loader to re-fetch new byte range\n\n // Todo: the following might be wrong, does it return array buffer or\n // something else?\n // @ts-ignore\n const { arrayBuffer } = await loadRequest(uri, imageId, {\n byteRange: `${fetchedLength}-${fetchedLength + lengthToFetch}`,\n });\n\n // Combine byte ranges\n const byteArrayToAppend = new Uint8Array(arrayBuffer);\n const combinedByteArray = new Uint8Array(\n dataSet.byteArray.length + byteArrayToAppend.length\n );\n\n combinedByteArray.set(dataSet.byteArray);\n combinedByteArray.set(byteArrayToAppend, dataSet.byteArray.length);\n\n // Re-parse potentially partial byte range and return\n return dataSetFromPartialContent(combinedByteArray, loadRequest, metadata);\n };\n\n return dataSet;\n}\n","function getDirectFrameInformation(dataSet, frame) {\n if (!dataSet) {\n return;\n }\n\n const {\n NumberOfFrames,\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n } = getMultiframeInformation(dataSet);\n\n if (PerFrameFunctionalGroupsSequence \|\| NumberOfFrames > 1) {\n const { shared, perFrame } = getFrameInformation(\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n frame\n );\n\n return {\n NumberOfFrames,\n PerFrameFunctionalInformation: perFrame,\n SharedFunctionalInformation: shared,\n };\n }\n\n return {\n NumberOfFrames,\n };\n}\n\nfunction getFrameInformation(\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n frameNumber\n) {\n const shared = {};\n\n (SharedFunctionalGroupsSequence\n ? Object.values(SharedFunctionalGroupsSequence.items[0].dataSet.elements)\n : []\n ).map((it: any) => (shared[it.tag] = it));\n\n const perFrame = {};\n\n (PerFrameFunctionalGroupsSequence\n ? Object.values(\n PerFrameFunctionalGroupsSequence.items[frameNumber - 1].dataSet.elements\n )\n : []\n ).map((it: any) => (perFrame[it.tag] = it));\n\n return {\n shared,\n perFrame,\n };\n}\n\nfunction getMultiframeInformation(dataSet) {\n if (!dataSet) {\n return;\n }\n const { elements, ...otherAttributtes } = dataSet;\n const {\n x52009230: PerFrameFunctionalGroupsSequence,\n x52009229: SharedFunctionalGroupsSequence,\n ...otherElements\n } = elements;\n\n const NumberOfFrames = dataSet.intString('x00280008');\n\n return {\n NumberOfFrames,\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n otherElements,\n otherAttributtes,\n };\n}\n\n// function that retrieves specific frame metadata information from multiframe\n// metadata\nfunction combineFrameInstanceDataset(frameNumber, dataSet) {\n if (!dataSet) {\n return;\n }\n\n const {\n NumberOfFrames,\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n otherElements,\n } = getMultiframeInformation(dataSet);\n\n if (PerFrameFunctionalGroupsSequence \|\| NumberOfFrames > 1) {\n const { shared, perFrame } = getFrameInformation(\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n frameNumber\n );\n\n // creating a new copy of the dataset to remove the two multiframe dicom tags\n const newElements = {\n elements: {\n ...otherElements,\n ...shared,\n ...perFrame,\n },\n };\n\n const clonedDataset = Object.create(dataSet);\n const newDataset = Object.assign(clonedDataset, newElements);\n\n return newDataset;\n }\n\n return dataSet;\n}\n\nexport {\n combineFrameInstanceDataset,\n getMultiframeInformation,\n getFrameInformation,\n getDirectFrameInformation,\n};\n","import { loadedDataSets } from './dataSetCacheManager';\n\nfunction _get(uri) {\n if (!loadedDataSets[uri]) {\n return;\n }\n\n return loadedDataSets[uri];\n}\n\nfunction isMultiframeDataset(uri) {\n const dataSet = _get(uri);\n\n return _isMultiframeDataset(dataSet);\n}\n\nfunction _isMultiframeDataset(dataSet) {\n // Checks if dicomTag NumberOf Frames exists and it is greater than one\n if (!dataSet) {\n return false;\n }\n\n const numberOfFrames = dataSet.intString('x00280008');\n\n return numberOfFrames && numberOfFrames > 1;\n}\n\nfunction retrieveFrameParameterIndex(uri) {\n return uri.indexOf('&frame=');\n}\n\nfunction retrieveMultiframeDataset(uri) {\n const frameParameterIndex = retrieveFrameParameterIndex(uri);\n const multiframeURI =\n frameParameterIndex === -1 ? uri : uri.slice(0, frameParameterIndex);\n const frame = parseInt(uri.slice(frameParameterIndex + 7), 10) \|\| 1;\n\n let dataSet;\n\n if (loadedDataSets[multiframeURI]) {\n dataSet = loadedDataSets[multiframeURI].dataSet;\n } else {\n dataSet = undefined;\n }\n\n return {\n dataSet,\n frame,\n };\n}\n\nfunction generateMultiframeWADOURIs(uri) {\n const listWADOURIs = [];\n\n const dataSet = _get(uri);\n\n if (_isMultiframeDataset(dataSet)) {\n const numberOfFrames = (dataSet as any).intString('x00280008');\n\n for (let i = 1; i <= numberOfFrames; i++) {\n listWADOURIs.push(`${uri}&frame=${i}`);\n }\n } else {\n listWADOURIs.push(uri);\n }\n\n return listWADOURIs;\n}\n\nexport default {\n _get,\n generateMultiframeWADOURIs,\n retrieveMultiframeDataset,\n isMultiframeDataset,\n};\n","import { DataSet } from 'dicom-parser';\nimport external from '../../externalModules';\nimport { xhrRequest } from '../internal/index';\nimport dataSetFromPartialContent from './dataset-from-partial-content';\nimport {\n LoadRequestFunction,\n DICOMLoaderDataSetWithFetchMore,\n} from '../../types';\nimport { combineFrameInstanceDataset } from './combineFrameInstanceDataset';\nimport multiframeDataset from './retrieveMultiframeDataset';\n\nexport interface CornerstoneWadoLoaderCacheManagerInfoResponse {\n cacheSizeInBytes: number;\n numberOfDataSetsCached: number;\n}\n\nexport interface CornerstoneWadoLoaderCachedPromise\n extends Promise<DataSet \| DICOMLoaderDataSetWithFetchMore> {\n cacheCount?: number;\n}\n\n/*\n This object supports loading of DICOM P10 dataset from a uri and caching it so it can be accessed\n * by the caller. This allows a caller to access the datasets without having to go through cornerstone's\n * image loader mechanism. One reason a caller may need to do this is to determine the number of frames\n * in a multiframe sop instance so it can create the imageId's correctly.\n /\nlet cacheSizeInBytes = 0;\n\nlet loadedDataSets: Record<string, { dataSet: DataSet; cacheCount: number }> =\n {};\n\nlet promises: Record<string, CornerstoneWadoLoaderCachedPromise> = {};\n\n// returns true if the wadouri for the specified index has been loaded\nfunction isLoaded(uri: string): boolean {\n return loadedDataSets[uri] !== undefined;\n}\n\nfunction get(uri: string): DataSet {\n let dataSet;\n\n if (uri.includes('&frame=')) {\n const { frame, dataSet: multiframeDataSet } =\n multiframeDataset.retrieveMultiframeDataset(uri);\n\n dataSet = combineFrameInstanceDataset(frame, multiframeDataSet);\n } else if (loadedDataSets[uri]) {\n dataSet = loadedDataSets[uri].dataSet;\n }\n\n return dataSet;\n}\n\nfunction update(uri: string, dataSet: DataSet) {\n const loadedDataSet = loadedDataSets[uri];\n\n if (!loadedDataSet) {\n console.error(`No loaded dataSet for uri ${uri}`);\n\n return;\n }\n // Update dataset\n cacheSizeInBytes -= loadedDataSet.dataSet.byteArray.length;\n loadedDataSet.dataSet = dataSet;\n cacheSizeInBytes += dataSet.byteArray.length;\n\n external.cornerstone.triggerEvent(\n (external.cornerstone as any).events,\n 'datasetscachechanged',\n {\n uri,\n action: 'updated',\n cacheInfo: getInfo(),\n }\n );\n}\n\n// loads the dicom dataset from the wadouri sp\nfunction load(\n uri: string,\n loadRequest: LoadRequestFunction = xhrRequest,\n imageId: string\n): CornerstoneWadoLoaderCachedPromise {\n const { cornerstone, dicomParser } = external;\n\n // if already loaded return it right away\n if (loadedDataSets[uri]) {\n // console.log('using loaded dataset ' + uri);\n return new Promise((resolve) => {\n loadedDataSets[uri].cacheCount++;\n resolve(loadedDataSets[uri].dataSet);\n });\n }\n\n // if we are currently loading this uri, increment the cacheCount and return its promise\n if (promises[uri]) {\n // console.log('returning existing load promise for ' + uri);\n promises[uri].cacheCount++;\n\n return promises[uri];\n }\n\n // This uri is not loaded or being loaded, load it via an xhrRequest\n const loadDICOMPromise = loadRequest(uri, imageId);\n\n // handle success and failure of the XHR request load\n const promise: CornerstoneWadoLoaderCachedPromise = new Promise(\n (resolve, reject) => {\n loadDICOMPromise\n .then(async function (dicomPart10AsArrayBuffer: any / , xhr/) {\n const partialContent = {\n isPartialContent: false,\n fileTotalLength: null,\n };\n\n // Allow passing extra data with the loader promise so as not to change\n // the API\n if (!(dicomPart10AsArrayBuffer instanceof ArrayBuffer)) {\n if (!dicomPart10AsArrayBuffer.arrayBuffer) {\n return reject(\n new Error(\n 'If not returning ArrayBuffer, must return object with `arrayBuffer` parameter'\n )\n );\n }\n partialContent.isPartialContent =\n dicomPart10AsArrayBuffer.flags.isPartialContent;\n partialContent.fileTotalLength =\n dicomPart10AsArrayBuffer.flags.fileTotalLength;\n dicomPart10AsArrayBuffer = dicomPart10AsArrayBuffer.arrayBuffer;\n }\n\n const byteArray = new Uint8Array(dicomPart10AsArrayBuffer);\n\n // Reject the promise if parsing the dicom file fails\n let dataSet: DataSet \| DICOMLoaderDataSetWithFetchMore;\n\n try {\n if (partialContent.isPartialContent) {\n // This dataSet object will include a fetchMore function,\n dataSet = await dataSetFromPartialContent(\n byteArray,\n loadRequest,\n {\n uri,\n imageId,\n fileTotalLength: partialContent.fileTotalLength,\n }\n );\n } else {\n dataSet = dicomParser.parseDicom(byteArray);\n }\n } catch (error) {\n return reject(error);\n }\n\n loadedDataSets[uri] = {\n dataSet,\n cacheCount: promise.cacheCount,\n };\n cacheSizeInBytes += dataSet.byteArray.length;\n resolve(dataSet);\n\n cornerstone.triggerEvent(\n (cornerstone as any).events,\n 'datasetscachechanged',\n {\n uri,\n action: 'loaded',\n cacheInfo: getInfo(),\n }\n );\n }, reject)\n .then(\n () => {\n // Remove the promise if success\n delete promises[uri];\n },\n () => {\n // Remove the promise if failure\n delete promises[uri];\n }\n );\n }\n );\n\n promise.cacheCount = 1;\n\n promises[uri] = promise;\n\n return promise;\n}\n\n// remove the cached/loaded dicom dataset for the specified wadouri to free up memory\nfunction unload(uri: string): void {\n const { cornerstone } = external;\n\n // console.log('unload for ' + uri);\n if (loadedDataSets[uri]) {\n loadedDataSets[uri].cacheCount--;\n if (loadedDataSets[uri].cacheCount === 0) {\n // console.log('removing loaded dataset for ' + uri);\n cacheSizeInBytes -= loadedDataSets[uri].dataSet.byteArray.length;\n delete loadedDataSets[uri];\n\n cornerstone.triggerEvent(\n (cornerstone as any).events,\n 'datasetscachechanged',\n {\n uri,\n action: 'unloaded',\n cacheInfo: getInfo(),\n }\n );\n }\n }\n}\n\nexport function getInfo(): CornerstoneWadoLoaderCacheManagerInfoResponse {\n return {\n cacheSizeInBytes,\n numberOfDataSetsCached: Object.keys(loadedDataSets).length,\n };\n}\n\n// removes all cached datasets from memory\nfunction purge(): void {\n loadedDataSets = {};\n promises = {};\n cacheSizeInBytes = 0;\n}\n\nexport default {\n isLoaded,\n load,\n unload,\n getInfo,\n purge,\n get,\n update,\n};\n\nexport { loadedDataSets };\n","import getNumberValues from './getNumberValues';\nimport isNMReconstructable from '../../isNMReconstructable';\n\n/\n Get a subpart of Image Type dicom tag defined by index\n * @param {} dataSet\n @param {} index 0 based index of the subtype\n /\nfunction getImageTypeSubItemFromDataset(dataSet, index) {\n const imageType = dataSet.string('x00080008');\n\n if (imageType) {\n const subTypes = imageType.split('\\\\');\n\n if (subTypes.length > index) {\n return subTypes[index];\n }\n }\n\n return undefined;\n}\n/*\n Extracts the orientation from NM multiframe dataset, if image type\n * equal to RECON TOMO or RECON GATED TOMO\n * @param {} dataSet\n @returns\n /\nfunction extractOrientationFromNMMultiframeDataset(dataSet) {\n let imageOrientationPatient;\n const modality = dataSet.string('x00080060');\n\n if (modality?.includes('NM')) {\n const imageSubType = getImageTypeSubItemFromDataset(dataSet, 2);\n\n if (imageSubType && isNMReconstructable(imageSubType)) {\n if (dataSet.elements.x00540022) {\n imageOrientationPatient = getNumberValues(\n dataSet.elements.x00540022.items[0].dataSet,\n 'x00200037',\n 6\n );\n }\n }\n }\n\n return imageOrientationPatient;\n}\n\n/\n Extracts the position from NM multiframe dataset, if image type\n * equal to RECON TOMO or RECON GATED TOMO\n * @param {} dataSet\n @returns\n /\nfunction extractPositionFromNMMultiframeDataset(dataSet) {\n let imagePositionPatient;\n const modality = dataSet.string('x00080060');\n\n if (modality?.includes('NM')) {\n const imageSubType = getImageTypeSubItemFromDataset(dataSet, 2);\n\n if (imageSubType && isNMReconstructable(imageSubType)) {\n if (dataSet.elements.x00540022) {\n imagePositionPatient = getNumberValues(\n dataSet.elements.x00540022.items[0].dataSet,\n 'x00200032',\n 3\n );\n }\n }\n }\n\n return imagePositionPatient;\n}\n\n/\n Extract orientation information from a dataset. It tries to get the orientation\n * from the Detector Information Sequence (for NM images) if image type equal\n * to RECON TOMO or RECON GATED TOMO\n * @param {} dataSet\n @returns\n /\nfunction extractOrientationFromDataset(dataSet) {\n let imageOrientationPatient = getNumberValues(dataSet, 'x00200037', 6);\n\n // Trying to get the orientation from the Plane Orientation Sequence\n if (!imageOrientationPatient && dataSet.elements.x00209116) {\n imageOrientationPatient = getNumberValues(\n dataSet.elements.x00209116.items[0].dataSet,\n 'x00200037',\n 6\n );\n }\n\n // If orientation not valid to this point, trying to get the orientation\n // from the Detector Information Sequence (for NM images) with image type\n // equal to RECON TOMO or RECON GATED TOMO\n\n if (!imageOrientationPatient) {\n imageOrientationPatient =\n extractOrientationFromNMMultiframeDataset(dataSet);\n }\n\n return imageOrientationPatient;\n}\n\n/\n Extract position information from a dataset. It tries to get the position\n * from the Detector Information Sequence (for NM images) if image type equal\n * to RECON TOMO or RECON GATED TOMO\n * @param {} dataSet\n @returns\n /\nfunction extractPositionFromDataset(dataSet) {\n let imagePositionPatient = getNumberValues(dataSet, 'x00200032', 3);\n\n // Trying to get the position from the Plane Position Sequence\n if (!imagePositionPatient && dataSet.elements.x00209113) {\n imagePositionPatient = getNumberValues(\n dataSet.elements.x00209113.items[0].dataSet,\n 'x00200032',\n 3\n );\n }\n\n // If position not valid to this point, trying to get the position\n // from the Detector Information Sequence (for NM images)\n if (!imagePositionPatient) {\n imagePositionPatient = extractPositionFromNMMultiframeDataset(dataSet);\n }\n\n return imagePositionPatient;\n}\n\n/\n Extract the pixelSpacing information. If exists, extracts this information\n * from Pixel Measures Sequence\n * @param {} dataSet\n @returns\n /\nfunction extractSpacingFromDataset(dataSet) {\n let pixelSpacing = getNumberValues(dataSet, 'x00280030', 2);\n\n // If pixelSpacing not valid to this point, trying to get the spacing\n // from the Pixel Measures Sequence\n if (!pixelSpacing && dataSet.elements.x00289110) {\n pixelSpacing = getNumberValues(\n dataSet.elements.x00289110.items[0].dataSet,\n 'x00280030',\n 2\n );\n }\n\n return pixelSpacing;\n}\n\n/\n Extract the sliceThickness information. If exists, extracts this information\n * from Pixel Measures Sequence\n * @param {} dataSet\n @returns\n /\nfunction extractSliceThicknessFromDataset(dataSet) {\n let sliceThickness;\n\n if (dataSet.elements.x00180050) {\n sliceThickness = dataSet.floatString('x00180050');\n } else if (\n dataSet.elements.x00289110 &&\n dataSet.elements.x00289110.items.length &&\n dataSet.elements.x00289110.items[0].dataSet.elements.x00180050\n ) {\n sliceThickness =\n dataSet.elements.x00289110.items[0].dataSet.floatString('x00180050');\n }\n\n return sliceThickness;\n}\n\nexport {\n getImageTypeSubItemFromDataset,\n extractOrientationFromDataset,\n extractPositionFromDataset,\n extractSpacingFromDataset,\n extractSliceThicknessFromDataset,\n};\n","import external from '../../../externalModules';\nimport getNumberValues from './getNumberValues';\nimport parseImageId from '../parseImageId';\nimport dataSetCacheManager from '../dataSetCacheManager';\nimport getImagePixelModule from './getImagePixelModule';\nimport getOverlayPlaneModule from './getOverlayPlaneModule';\nimport getLUTs from './getLUTs';\nimport getModalityLUTOutputPixelRepresentation from './getModalityLUTOutputPixelRepresentation';\nimport { getDirectFrameInformation } from '../combineFrameInstanceDataset';\nimport multiframeDataset from '../retrieveMultiframeDataset';\nimport {\n getImageTypeSubItemFromDataset,\n extractOrientationFromDataset,\n extractPositionFromDataset,\n extractSpacingFromDataset,\n extractSliceThicknessFromDataset,\n} from './extractPositioningFromDataset';\nimport isNMReconstructable from '../../isNMReconstructable';\nimport {\n getInstanceModule,\n instanceModuleNames,\n} from '../../getInstanceModule';\n\nfunction metaDataProvider(type, imageId) {\n const { MetadataModules } = external.cornerstone.Enums;\n const { dicomParser } = external;\n\n // Several providers use array queries\n if (Array.isArray(imageId)) {\n return;\n }\n\n const parsedImageId = parseImageId(imageId);\n\n if (type === MetadataModules.MULTIFRAME) {\n const multiframeData = multiframeDataset.retrieveMultiframeDataset(\n parsedImageId.url\n );\n\n if (!multiframeData.dataSet) {\n return;\n }\n\n const multiframeInfo = getDirectFrameInformation(\n multiframeData.dataSet,\n multiframeData.frame\n );\n\n return multiframeInfo;\n }\n\n let url = parsedImageId.url;\n\n if (parsedImageId.frame) {\n url = `${url}&frame=${parsedImageId.frame}`;\n }\n\n const dataSet = dataSetCacheManager.get(url);\n\n if (!dataSet) {\n return;\n }\n\n if (type === MetadataModules.GENERAL_STUDY) {\n return {\n studyDescription: dataSet.string('x00081030'),\n studyDate: dicomParser.parseDA(dataSet.string('x00080020')),\n studyTime: dicomParser.parseTM(dataSet.string('x00080030') \|\| ''),\n accessionNumber: dataSet.string('x00080050'),\n };\n }\n\n if (type === MetadataModules.GENERAL_SERIES) {\n return {\n modality: dataSet.string('x00080060'),\n seriesInstanceUID: dataSet.string('x0020000e'),\n seriesNumber: dataSet.intString('x00200011'),\n studyInstanceUID: dataSet.string('x0020000d'),\n seriesDate: dicomParser.parseDA(dataSet.string('x00080021')),\n seriesTime: dicomParser.parseTM(dataSet.string('x00080031') \|\| ''),\n acquisitionDate: dicomParser.parseDA(dataSet.string('x00080022')),\n acquisitionTime: dicomParser.parseTM(dataSet.string('x00080032') \|\| ''),\n };\n }\n\n if (type === MetadataModules.GENERAL_IMAGE) {\n return {\n sopInstanceUID: dataSet.string('x00080018'),\n instanceNumber: dataSet.intString('x00200013'),\n lossyImageCompression: dataSet.string('x00282110'),\n lossyImageCompressionRatio: dataSet.floatString('x00282112'),\n lossyImageCompressionMethod: dataSet.string('x00282114'),\n };\n }\n\n if (type === MetadataModules.PATIENT) {\n return {\n patientID: dataSet.string('x00100020'),\n patientName: dataSet.string('x00100010'),\n };\n }\n\n if (type === MetadataModules.PATIENT_STUDY) {\n return {\n patientAge: dataSet.intString('x00101010'),\n patientSize: dataSet.floatString('x00101020'),\n patientSex: dataSet.string('x00100040'),\n patientWeight: dataSet.floatString('x00101030'),\n };\n }\n\n if (type === MetadataModules.NM_MULTIFRAME_GEOMETRY) {\n const modality = dataSet.string('x00080060');\n const imageSubType = getImageTypeSubItemFromDataset(dataSet, 2);\n\n return {\n modality,\n imageType: dataSet.string('x00080008'),\n imageSubType,\n imageOrientationPatient: extractOrientationFromDataset(dataSet),\n imagePositionPatient: extractPositionFromDataset(dataSet),\n sliceThickness: extractSliceThicknessFromDataset(dataSet),\n pixelSpacing: extractSpacingFromDataset(dataSet),\n numberOfFrames: dataSet.uint16('x00280008'),\n isNMReconstructable:\n isNMReconstructable(imageSubType) && modality.includes('NM'),\n };\n }\n\n if (type === MetadataModules.IMAGE_PLANE) {\n const imageOrientationPatient = extractOrientationFromDataset(dataSet);\n const imagePositionPatient = extractPositionFromDataset(dataSet);\n const pixelSpacing = extractSpacingFromDataset(dataSet);\n const sliceThickness = extractSliceThicknessFromDataset(dataSet);\n\n let columnPixelSpacing = null;\n\n let rowPixelSpacing = null;\n\n if (pixelSpacing) {\n rowPixelSpacing = pixelSpacing[0];\n columnPixelSpacing = pixelSpacing[1];\n }\n\n let rowCosines = null;\n\n let columnCosines = null;\n\n if (imageOrientationPatient) {\n rowCosines = [\n // @ts-expect-error\n parseFloat(imageOrientationPatient[0]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[1]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[2]),\n ];\n columnCosines = [\n // @ts-expect-error\n parseFloat(imageOrientationPatient[3]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[4]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[5]),\n ];\n }\n\n return {\n frameOfReferenceUID: dataSet.string('x00200052'),\n rows: dataSet.uint16('x00280010'),\n columns: dataSet.uint16('x00280011'),\n imageOrientationPatient,\n rowCosines,\n columnCosines,\n imagePositionPatient,\n sliceThickness,\n sliceLocation: dataSet.floatString('x00201041'),\n pixelSpacing,\n rowPixelSpacing,\n columnPixelSpacing,\n };\n }\n\n if (type === MetadataModules.CINE) {\n return {\n frameTime: dataSet.floatString('x00181063'),\n };\n }\n\n if (type === MetadataModules.IMAGE_PIXEL) {\n return getImagePixelModule(dataSet);\n }\n\n if (type === MetadataModules.VOI_LUT) {\n const modalityLUTOutputPixelRepresentation =\n getModalityLUTOutputPixelRepresentation(dataSet);\n\n return {\n windowCenter: getNumberValues(dataSet, 'x00281050', 1),\n windowWidth: getNumberValues(dataSet, 'x00281051', 1),\n voiLUTSequence: getLUTs(\n modalityLUTOutputPixelRepresentation,\n dataSet.elements.x00283010\n ),\n };\n }\n\n if (type === MetadataModules.MODALITY_LUT) {\n return {\n rescaleIntercept: dataSet.floatString('x00281052'),\n rescaleSlope: dataSet.floatString('x00281053'),\n rescaleType: dataSet.string('x00281054'),\n modalityLUTSequence: getLUTs(\n dataSet.uint16('x00280103'),\n dataSet.elements.x00283000\n ),\n };\n }\n\n if (type === MetadataModules.SOP_COMMON) {\n return {\n sopClassUID: dataSet.string('x00080016'),\n sopInstanceUID: dataSet.string('x00080018'),\n };\n }\n\n if (type === MetadataModules.PET_ISOTOPE) {\n const radiopharmaceuticalInfo = dataSet.elements.x00540016;\n\n if (radiopharmaceuticalInfo === undefined) {\n return;\n }\n\n const firstRadiopharmaceuticalInfoDataSet =\n radiopharmaceuticalInfo.items[0].dataSet;\n\n return {\n radiopharmaceuticalInfo: {\n radiopharmaceuticalStartTime: dicomParser.parseTM(\n firstRadiopharmaceuticalInfoDataSet.string('x00181072') \|\| ''\n ),\n radionuclideTotalDose:\n firstRadiopharmaceuticalInfoDataSet.floatString('x00181074'),\n radionuclideHalfLife:\n firstRadiopharmaceuticalInfoDataSet.floatString('x00181075'),\n },\n };\n }\n\n if (type === MetadataModules.OVERLAY_PLANE) {\n return getOverlayPlaneModule(dataSet);\n }\n\n // Note: this is not a DICOM module, but a useful metadata that can be\n // retrieved from the image\n if (type === 'transferSyntax') {\n return {\n transferSyntaxUID: dataSet.string('x00020010'),\n };\n }\n\n if (type === MetadataModules.PET_SERIES) {\n return {\n correctedImage: dataSet.string('x00280051'),\n units: dataSet.string('x00541001'),\n decayCorrection: dataSet.string('x00541102'),\n };\n }\n\n if (type === MetadataModules.PET_IMAGE) {\n return {\n frameReferenceTime: dataSet.floatString(\n dataSet.string('x00541300') \|\| ''\n ),\n actualFrameDuration: dataSet.intString(dataSet.string('x00181242')),\n };\n }\n\n // Note: this is not a DICOM module, but rather an aggregation on all others\n if (type === 'instance') {\n return getInstanceModule(imageId, metaDataProvider, instanceModuleNames);\n }\n}\n\nexport default metaDataProvider;\n","import { DataSet } from 'dicom-parser';\n\nexport default function getOverlayPlaneModule(dataSet: DataSet) {\n const overlays = [];\n\n for (let overlayGroup = 0x00; overlayGroup <= 0x1e; overlayGroup += 0x02) {\n let groupStr = `x60${overlayGroup.toString(16)}`;\n\n if (groupStr.length === 4) {\n groupStr = `x600${overlayGroup.toString(16)}`;\n }\n\n const data = dataSet.elements[`${groupStr}3000`];\n\n if (!data) {\n continue;\n }\n\n const pixelData = [];\n\n for (let i = 0; i < data.length; i++) {\n for (let k = 0; k < 8; k++) {\n const byte_as_int = dataSet.byteArray[data.dataOffset + i];\n\n pixelData[i 8 + k] = (byte_as_int >> k) & 0b1; // eslint-disable-line no-bitwise\n }\n }\n\n overlays.push({\n rows: dataSet.uint16(`${groupStr}0010`),\n columns: dataSet.uint16(`${groupStr}0011`),\n type: dataSet.string(`${groupStr}0040`),\n x: dataSet.int16(`${groupStr}0050`, 1) - 1,\n y: dataSet.int16(`${groupStr}0050`, 0) - 1,\n pixelData,\n description: dataSet.string(`${groupStr}0022`),\n label: dataSet.string(`${groupStr}1500`),\n roiArea: dataSet.string(`${groupStr}1301`),\n roiMean: dataSet.string(`${groupStr}1302`),\n roiStandardDeviation: dataSet.string(`${groupStr}1303`),\n });\n }\n\n return {\n overlays,\n };\n}\n","let files: Blob[] = [];\n\nfunction add(file: Blob): string {\n const fileIndex = files.push(file);\n\n return `dicomfile:${fileIndex - 1}`;\n}\n\nfunction get(index: number): Blob {\n return files[index];\n}\n\nfunction remove(index: number): void {\n files[index] = undefined;\n}\n\nfunction purge(): void {\n files = [];\n}\n\nexport default {\n add,\n get,\n remove,\n purge,\n};\n","import { ByteArray, DataSet, ByteStream, readSequenceItem } from 'dicom-parser';\nimport external from '../../externalModules';\n\n/*\n Function to deal with extracting an image frame from an encapsulated data set.\n /\n\nfunction framesAreFragmented(dataSet: DataSet) {\n const numberOfFrames = dataSet.intString('x00280008');\n const pixelDataElement = dataSet.elements.x7fe00010;\n\n return numberOfFrames !== pixelDataElement.fragments.length;\n}\n\nexport default function getEncapsulatedImageFrame(\n dataSet: DataSet,\n frameIndex: number\n): ByteArray {\n const { dicomParser } = external;\n\n if (\n dataSet.elements.x7fe00010 &&\n dataSet.elements.x7fe00010.basicOffsetTable.length\n ) {\n // Basic Offset Table is not empty\n return dicomParser.readEncapsulatedImageFrame(\n dataSet,\n dataSet.elements.x7fe00010,\n frameIndex\n );\n }\n\n // Empty basic offset table\n\n if (framesAreFragmented(dataSet)) {\n const basicOffsetTable = dicomParser.createJPEGBasicOffsetTable(\n dataSet,\n dataSet.elements.x7fe00010\n );\n\n return dicomParser.readEncapsulatedImageFrame(\n dataSet,\n dataSet.elements.x7fe00010,\n frameIndex,\n basicOffsetTable\n );\n }\n\n // the following code is pretty much a duplicate of the logic here\n // https://github.com/cornerstonejs/dicomParser/blob/master/src/readEncapsulatedPixelDataFromFragments.js\n // but it takes care of slicing the array buffer to be sent to the worker. We can't\n // get a view of the buffer because the buffer since it will still have the\n // array buffer, which can be in some cases huge to be sent to the worker.\n // Todo: a better approach would be to transfer the buffer to the worker by having the\n // transferPixelData option set to true, but for some reason it is giving an error\n // in the dicomParser library.\n const fragments = dataSet.elements.x7fe00010.fragments;\n\n // create byte stream on the data for this pixel data element\n const byteStream = new ByteStream(\n dataSet.byteArrayParser,\n dataSet.byteArray,\n dataSet.elements.x7fe00010.dataOffset\n );\n\n // seek past the basic offset table (no need to parse it again since we already have)\n const basicOffsetTable = readSequenceItem(byteStream);\n\n if (basicOffsetTable.tag !== 'xfffee000') {\n throw 'dicomParser.readEncapsulatedPixelData: missing basic offset table xfffee000';\n }\n\n byteStream.seek(basicOffsetTable.length);\n\n const fragmentZeroPosition = byteStream.position;\n\n // we should check that the number of frames + 1 is equal to the number of fragments\n // since there might be a situation where any frame before the one we are looking for\n // here is split into multiple fragments\n if (frameIndex + 1 > fragments.length) {\n throw 'dicomParser.readEncapsulatedPixelData: frame exceeds number of fragments';\n }\n\n const fragmentHeaderSize = 8;\n const byteOffset =\n fragmentZeroPosition + fragments[frameIndex].offset + fragmentHeaderSize;\n const length = fragments[frameIndex].length;\n\n // Grab ONLY the portion of the byteArray containing the frame for decoding since\n // it will be impossible to decode the entire image everytime (this return will go\n // to the decodeImageFrame function in cornerstoneWADOImageLoader which runs in a\n // web worker)\n return new Uint8Array(\n byteStream.byteArray.buffer.slice(\n byteStream.byteArray.byteOffset + byteOffset,\n byteStream.byteArray.byteOffset + byteOffset + length\n )\n );\n}\n","/ eslint no-bitwise: 0 /\n\nimport { ByteArray } from 'dicom-parser';\n\nfunction isBitSet(byte: number, bitPos: number) {\n return byte & (1 << bitPos);\n}\n\n/\n Function to deal with unpacking a binary frame\n /\nfunction unpackBinaryFrame(\n byteArray: ByteArray,\n frameOffset: number,\n pixelsPerFrame: number\n): Uint8Array {\n // Create a new pixel array given the image size\n const pixelData = new Uint8Array(pixelsPerFrame);\n\n for (let i = 0; i < pixelsPerFrame; i++) {\n // Compute byte position\n const bytePos = Math.floor(i / 8);\n\n // Get the current byte\n const byte = byteArray[bytePos + frameOffset];\n\n // Bit position (0-7) within byte\n const bitPos = i % 8;\n\n // Check whether bit at bitpos is set\n pixelData[i] = isBitSet(byte, bitPos) ? 1 : 0;\n }\n\n return pixelData;\n}\n\nexport default unpackBinaryFrame;\n","import { DataSet } from 'dicom-parser';\nimport unpackBinaryFrame from './unpackBinaryFrame';\n\n/\n Function to deal with extracting an image frame from an encapsulated data set.\n /\n\nfunction getUncompressedImageFrame(\n dataSet: DataSet,\n frameIndex: number\n): Uint8Array {\n const pixelDataElement =\n dataSet.elements.x7fe00010 \|\| dataSet.elements.x7fe00008;\n const bitsAllocated = dataSet.uint16('x00280100');\n const rows = dataSet.uint16('x00280010');\n const columns = dataSet.uint16('x00280011');\n\n let samplesPerPixel = dataSet.uint16('x00280002');\n\n /\n From: http://dicom.nema.org/medical/dicom/current/output/chtml/part03/sect_C.7.6.3.html\n \n Though the chrominance channels are downsampled, there are still nominally\n * three channels, hence Samples per Pixel (0028,0002) has a value of 3, not\n * 2. I.e., for pixel data in a Native (uncompressed) format, the Value Length\n * of Pixel Data (7FE0,0010) is not:\n \n Rows (0028,0010) * Columns (0028,0011) * Number of Frames (0028,0008) \n Samples per Pixel (0028,0002) * (⌊(Bits Allocated (0028,0100)-1)/8⌋+1)\n \n padded to an even length, as it would otherwise be, but rather is:\n \n Rows (0028,0010) * Columns (0028,0011) * Number of Frames (0028,0008) * 2 \n (⌊(Bits Allocated (0028,0100)-1)/8⌋+1)\n \n padded to an even length.\n /\n const photometricInterpretation = dataSet.string('x00280004');\n\n if (photometricInterpretation === 'YBR_FULL_422') {\n samplesPerPixel = 2;\n console.warn(\n `Using SamplesPerPixel of 2 for YBR_FULL_422 photometric interpretation.\n See http://dicom.nema.org/medical/dicom/current/output/chtml/part03/sect_C.7.6.3.html for more information.`\n );\n }\n\n const pixelDataOffset = pixelDataElement.dataOffset;\n const pixelsPerFrame = rows columns * samplesPerPixel;\n\n let frameOffset;\n\n if (bitsAllocated === 8) {\n frameOffset = pixelDataOffset + frameIndex * pixelsPerFrame;\n if (frameOffset >= dataSet.byteArray.length) {\n throw new Error('frame exceeds size of pixelData');\n }\n\n return new Uint8Array(\n dataSet.byteArray.buffer.slice(frameOffset, frameOffset + pixelsPerFrame)\n );\n } else if (bitsAllocated === 16) {\n frameOffset = pixelDataOffset + frameIndex * pixelsPerFrame * 2;\n if (frameOffset >= dataSet.byteArray.length) {\n throw new Error('frame exceeds size of pixelData');\n }\n\n return new Uint8Array(\n dataSet.byteArray.buffer.slice(\n frameOffset,\n frameOffset + pixelsPerFrame * 2\n )\n );\n } else if (bitsAllocated === 1) {\n frameOffset = pixelDataOffset + frameIndex * pixelsPerFrame * 0.125;\n if (frameOffset >= dataSet.byteArray.length) {\n throw new Error('frame exceeds size of pixelData');\n }\n\n return unpackBinaryFrame(dataSet.byteArray, frameOffset, pixelsPerFrame);\n } else if (bitsAllocated === 32) {\n frameOffset = pixelDataOffset + frameIndex * pixelsPerFrame * 4;\n if (frameOffset >= dataSet.byteArray.length) {\n throw new Error('frame exceeds size of pixelData');\n }\n\n return new Uint8Array(\n dataSet.byteArray.buffer.slice(\n frameOffset,\n frameOffset + pixelsPerFrame * 4\n )\n );\n }\n\n throw new Error('unsupported pixel format');\n}\n\nexport default getUncompressedImageFrame;\n","import parseImageId from './parseImageId';\nimport fileManager from './fileManager';\n\nfunction loadFileRequest(uri: string): Promise<ArrayBuffer> {\n const parsedImageId = parseImageId(uri);\n const fileIndex = parseInt(parsedImageId.url, 10);\n const file = fileManager.get(fileIndex);\n\n return new Promise<ArrayBuffer>((resolve, reject) => {\n const fileReader = new FileReader();\n\n fileReader.onload = (e) => {\n const dicomPart10AsArrayBuffer = e.target.result as ArrayBuffer;\n\n resolve(dicomPart10AsArrayBuffer);\n };\n\n fileReader.onerror = reject;\n\n fileReader.readAsArrayBuffer(file);\n });\n}\n\nexport default loadFileRequest;\n","import { ByteArray, DataSet } from 'dicom-parser';\nimport getEncapsulatedImageFrame from './getEncapsulatedImageFrame';\nimport getUncompressedImageFrame from './getUncompressedImageFrame';\n\nfunction getPixelData(dataSet: DataSet, frameIndex = 0): ByteArray {\n const pixelDataElement =\n dataSet.elements.x7fe00010 \|\| dataSet.elements.x7fe00008;\n\n if (!pixelDataElement) {\n return null;\n }\n\n if (pixelDataElement.encapsulatedPixelData) {\n return getEncapsulatedImageFrame(dataSet, frameIndex);\n }\n\n return getUncompressedImageFrame(dataSet, frameIndex);\n}\n\nexport default getPixelData;\n","import { DataSet } from 'dicom-parser';\nimport { Types } from '@cornerstonejs/core';\nimport createImage from '../createImage';\nimport { xhrRequest } from '../internal/index';\nimport dataSetCacheManager from './dataSetCacheManager';\nimport {\n LoadRequestFunction,\n DICOMLoaderIImage,\n DICOMLoaderImageOptions,\n ImageFrame,\n} from '../../types';\nimport getPixelData from './getPixelData';\nimport loadFileRequest from './loadFileRequest';\nimport parseImageId from './parseImageId';\n\n// add a decache callback function to clear out our dataSetCacheManager\nfunction addDecache(imageLoadObject: Types.IImageLoadObject, imageId: string) {\n imageLoadObject.decache = function () {\n // console.log('decache');\n const parsedImageId = parseImageId(imageId);\n\n dataSetCacheManager.unload(parsedImageId.url);\n };\n}\n\n/*\n Given the dataSetPromise and imageId this will return a promise to be\n * resolved with an image object containing the loaded image.\n \n @param dataSetPromise - A promise that resolves to a DataSet object.\n * @param imageId - The imageId of the image to be loaded.\n * @param frame - The frame number to be loaded in case of multiframe. it should\n * be noted that this is used to extract the pixelData from dicomParser and\n * dicomParser is 0-based index (the first pixelData is frame 0); however,\n * in metadata and imageId frame is 1-based index (the first frame is frame 1).\n * @param sharedCacheKey - A key to be used to cache the loaded image.\n * @param options - Options to be used when loading the image.\n * @param callbacks - Callbacks to be called when the image is loaded.\n * @returns An object containing a promise to be resolved with the loaded image\n /\nfunction loadImageFromPromise(\n dataSetPromise: Promise<DataSet>,\n imageId: string,\n frame = 0,\n sharedCacheKey: string,\n options: DICOMLoaderImageOptions,\n callbacks?: {\n imageDoneCallback: (image: DICOMLoaderIImage) => void;\n }\n): Types.IImageLoadObject {\n const start = new Date().getTime();\n const imageLoadObject: Types.IImageLoadObject = {\n cancelFn: undefined,\n promise: undefined,\n };\n\n imageLoadObject.promise = new Promise((resolve, reject) => {\n dataSetPromise.then(\n (dataSet / , xhr/) => {\n const pixelData = getPixelData(dataSet, frame);\n const transferSyntax = dataSet.string('x00020010');\n const loadEnd = new Date().getTime();\n const imagePromise = createImage(\n imageId,\n pixelData,\n transferSyntax,\n options\n );\n\n addDecache(imageLoadObject, imageId);\n\n imagePromise.then(\n (image) => {\n image = image as DICOMLoaderIImage;\n image.data = dataSet;\n image.sharedCacheKey = sharedCacheKey;\n const end = new Date().getTime();\n\n image.loadTimeInMS = loadEnd - start;\n image.totalTimeInMS = end - start;\n if (\n callbacks !== undefined &&\n callbacks.imageDoneCallback !== undefined\n ) {\n callbacks.imageDoneCallback(image);\n }\n resolve(image);\n },\n function (error) {\n // Reject the error, and the dataSet\n reject({\n error,\n dataSet,\n });\n }\n );\n },\n function (error) {\n // Reject the error\n reject({\n error,\n });\n }\n );\n });\n\n return imageLoadObject;\n}\n\nfunction loadImageFromDataSet(\n dataSet,\n imageId: string,\n frame = 0,\n sharedCacheKey: string,\n options\n): Types.IImageLoadObject {\n const start = new Date().getTime();\n\n const promise = new Promise<DICOMLoaderIImage \| ImageFrame>(\n (resolve, reject) => {\n const loadEnd = new Date().getTime();\n\n let imagePromise: Promise<DICOMLoaderIImage \| ImageFrame>;\n\n try {\n const pixelData = getPixelData(dataSet, frame);\n const transferSyntax = dataSet.string('x00020010');\n\n imagePromise = createImage(imageId, pixelData, transferSyntax, options);\n } catch (error) {\n // Reject the error, and the dataSet\n reject({\n error,\n dataSet,\n });\n\n return;\n }\n\n imagePromise.then((image) => {\n image = image as DICOMLoaderIImage;\n\n image.data = dataSet;\n image.sharedCacheKey = sharedCacheKey;\n const end = new Date().getTime();\n\n image.loadTimeInMS = loadEnd - start;\n image.totalTimeInMS = end - start;\n resolve(image);\n }, reject);\n }\n );\n\n return {\n promise: promise as Promise<any>,\n cancelFn: undefined,\n };\n}\n\nfunction getLoaderForScheme(scheme: string): LoadRequestFunction {\n if (scheme === 'dicomweb' \|\| scheme === 'wadouri') {\n return xhrRequest;\n } else if (scheme === 'dicomfile') {\n return loadFileRequest;\n }\n}\n\nfunction loadImage(\n imageId: string,\n options: DICOMLoaderImageOptions = {}\n): Types.IImageLoadObject {\n const parsedImageId = parseImageId(imageId);\n\n options = Object.assign({}, options);\n\n // IMPORTANT: if you have a custom loader that you want to use for a specific\n // scheme, you should create your own loader and register it with the scheme\n // in the image loader, and NOT just pass it in as an option. This is because\n // the scheme is used to determine the loader to use and is more maintainable\n\n // The loader isn't transferable, so ensure it is deleted\n delete options.loader;\n // The options might have a loader above, but it is a loader into the cache,\n // so not the scheme loader, which is separate and defined by the scheme here\n const schemeLoader = getLoaderForScheme(parsedImageId.scheme);\n\n // if the dataset for this url is already loaded, use it, in case of multiframe\n // images, we need to extract the frame pixelData from the dataset although the\n // image is loaded\n if (dataSetCacheManager.isLoaded(parsedImageId.url)) {\n /\n @todo The arguments to the dataSetCacheManager below are incorrect.\n /\n const dataSet: DataSet = (dataSetCacheManager as any).get(\n parsedImageId.url,\n schemeLoader,\n imageId\n );\n\n return loadImageFromDataSet(\n dataSet,\n imageId,\n parsedImageId.pixelDataFrame,\n parsedImageId.url,\n options\n );\n }\n\n // load the dataSet via the dataSetCacheManager\n const dataSetPromise = dataSetCacheManager.load(\n parsedImageId.url,\n schemeLoader,\n imageId\n );\n\n return loadImageFromPromise(\n dataSetPromise,\n imageId,\n parsedImageId.frame,\n parsedImageId.url,\n options\n );\n}\n\nexport { loadImageFromPromise, getLoaderForScheme, loadImage };\n","import {\n getImagePixelModule,\n getLUTs,\n getModalityLUTOutputPixelRepresentation,\n getNumberValues,\n metaDataProvider,\n} from './metaData/index';\n\nimport dataSetCacheManager from './dataSetCacheManager';\nimport fileManager from './fileManager';\nimport getEncapsulatedImageFrame from './getEncapsulatedImageFrame';\nimport getUncompressedImageFrame from './getUncompressedImageFrame';\nimport loadFileRequest from './loadFileRequest';\nimport {\n loadImageFromPromise,\n getLoaderForScheme,\n loadImage,\n} from './loadImage';\nimport parseImageId from './parseImageId';\nimport unpackBinaryFrame from './unpackBinaryFrame';\nimport register from './register';\n\nconst metaData = {\n getImagePixelModule,\n getLUTs,\n getModalityLUTOutputPixelRepresentation,\n getNumberValues,\n metaDataProvider,\n};\n\nexport default {\n metaData,\n dataSetCacheManager,\n fileManager,\n getEncapsulatedImageFrame,\n getUncompressedImageFrame,\n loadFileRequest,\n loadImageFromPromise,\n getLoaderForScheme,\n loadImage,\n parseImageId,\n unpackBinaryFrame,\n register,\n};\n","import as cornerstoneImport from '@cornerstonejs/core';\nimport { loadImage } from './loadImage';\nimport { metaDataProvider } from './metaData/index';\n\nexport default function (cornerstone: typeof cornerstoneImport): void {\n // register dicomweb and wadouri image loader prefixes\n cornerstone.registerImageLoader('dicomweb', loadImage);\n cornerstone.registerImageLoader('wadouri', loadImage);\n cornerstone.registerImageLoader('dicomfile', loadImage);\n\n // add wadouri metadata provider\n cornerstone.metaData.addProvider(metaDataProvider);\n}\n","import wadors from './wadors/index';\nimport wadouri from './wadouri/index';\n\n/*\n Register the WADO-URI and WADO-RS image loaders and metaData providers\n * with an instance of Cornerstone Core.\n \n @param cornerstone The Cornerstone Core library to register the image loaders with\n /\nfunction registerLoaders(cornerstone: any): void {\n wadors.register(cornerstone);\n wadouri.register(cornerstone);\n}\n\nexport default registerLoaders;\n","/ eslint import/extensions:0 /\nimport registerLoaders from './imageLoader/registerLoaders';\n\nlet cornerstone;\nlet dicomParser;\n\nconst external = {\n set cornerstone(cs) {\n cornerstone = cs;\n\n registerLoaders(cornerstone);\n },\n get cornerstone() {\n if (!cornerstone) {\n cornerstone = window && (window as any).cornerstone;\n\n if (!cornerstone) {\n throw new Error(\n 'cornerstoneDICOMImageLoader requires a copy of Cornerstone to work properly. Please add cornerstoneDICOMImageLoader.external.cornerstone = cornerstone; to your application.'\n );\n }\n\n registerLoaders(cornerstone);\n }\n\n return cornerstone;\n },\n set dicomParser(dp) {\n dicomParser = dp;\n },\n get dicomParser() {\n if (!dicomParser) {\n if (window && (window as any).dicomParser) {\n dicomParser = (window as any).dicomParser;\n } else {\n throw new Error(\n 'cornerstoneDICOMImageLoader requires a copy of dicomParser to work properly. Please add cornerstoneDICOMImageLoader.external.dicomParser = dicomParser; to your application.'\n );\n }\n }\n\n return dicomParser;\n },\n};\n\nexport default external;\n","import { ByteArray } from 'dicom-parser';\nimport { ImageFrame } from '../../types';\nimport external from '../../externalModules';\n\nfunction convertLUTto8Bit(lut: number[], shift: number) {\n const numEntries = lut.length;\n const cleanedLUT = new Uint8ClampedArray(numEntries);\n\n for (let i = 0; i < numEntries; ++i) {\n cleanedLUT[i] = lut[i] >> shift;\n }\n\n return cleanedLUT;\n}\n\n/\n Convert pixel data with PALETTE COLOR Photometric Interpretation to RGBA\n \n @param imageFrame - The ImageFrame to convert\n * @param colorBuffer - The buffer to write the converted pixel data to\n * @returns\n /\nexport default function (\n imageFrame: ImageFrame,\n colorBuffer: ByteArray,\n useRGBA: boolean\n): void {\n const numPixels = imageFrame.columns imageFrame.rows;\n const pixelData = imageFrame.pixelData;\n let rData = imageFrame.redPaletteColorLookupTableData;\n\n if (!rData) {\n // request from metadata provider since it might grab it from bulkdataURI\n rData = external.cornerstone.metaData.get(\n 'imagePixelModule',\n imageFrame.imageId\n )?.redPaletteColorLookupTableData;\n }\n\n let gData = imageFrame.greenPaletteColorLookupTableData;\n\n if (!gData) {\n gData = external.cornerstone.metaData.get(\n 'imagePixelModule',\n imageFrame.imageId\n )?.greenPaletteColorLookupTableData;\n }\n\n let bData = imageFrame.bluePaletteColorLookupTableData;\n\n if (!bData) {\n bData = external.cornerstone.metaData.get(\n 'imagePixelModule',\n imageFrame.imageId\n )?.bluePaletteColorLookupTableData;\n }\n\n if (!rData \|\| !gData \|\| !bData) {\n throw new Error(\n 'The image does not have a complete color palette. R, G, and B palette data are required.'\n );\n }\n\n const len = imageFrame.redPaletteColorLookupTableData.length;\n\n let palIndex = 0;\n\n let bufferIndex = 0;\n\n const start = imageFrame.redPaletteColorLookupTableDescriptor[1];\n const shift =\n imageFrame.redPaletteColorLookupTableDescriptor[2] === 8 ? 0 : 8;\n\n const rDataCleaned = convertLUTto8Bit(rData, shift);\n const gDataCleaned = convertLUTto8Bit(gData, shift);\n const bDataCleaned = convertLUTto8Bit(bData, shift);\n\n if (useRGBA) {\n for (let i = 0; i < numPixels; ++i) {\n let value = pixelData[palIndex++];\n\n if (value < start) {\n value = 0;\n } else if (value > start + len - 1) {\n value = len - 1;\n } else {\n value -= start;\n }\n\n colorBuffer[bufferIndex++] = rDataCleaned[value];\n colorBuffer[bufferIndex++] = gDataCleaned[value];\n colorBuffer[bufferIndex++] = bDataCleaned[value];\n colorBuffer[bufferIndex++] = 255;\n }\n\n return;\n }\n\n for (let i = 0; i < numPixels; ++i) {\n let value = pixelData[palIndex++];\n\n if (value < start) {\n value = 0;\n } else if (value > start + len - 1) {\n value = len - 1;\n } else {\n value -= start;\n }\n\n colorBuffer[bufferIndex++] = rDataCleaned[value];\n colorBuffer[bufferIndex++] = gDataCleaned[value];\n colorBuffer[bufferIndex++] = bDataCleaned[value];\n }\n}\n","import { setOptions } from './internal/index';\nimport { LoaderOptions } from '../types';\n\nfunction configure(options: LoaderOptions): void {\n setOptions(options);\n}\n\nexport default configure;\n","import { ImageFrame } from '../types';\n\nfunction isJPEGBaseline8BitColor(\n imageFrame: ImageFrame,\n transferSyntax: string\n): boolean {\n /** @todo check as any */\n transferSyntax = transferSyntax \|\| (imageFrame as any).transferSyntax;\n\n if (\n imageFrame.bitsAllocated === 8 &&\n transferSyntax === '1.2.840.10008.1.2.4.50' &&\n (imageFrame.samplesPerPixel === 3 \|\| imageFrame.samplesPerPixel === 4)\n ) {\n return true;\n }\n}\n\nexport default isJPEGBaseline8BitColor;\n","import {\n convertRGBColorByPixel,\n convertRGBColorByPlane,\n convertYBRFullByPixel,\n convertYBRFullByPlane,\n convertPALETTECOLOR,\n} from './colorSpaceConverters/index';\n\nimport { default as wadouri } from './wadouri/index';\nimport { default as wadors } from './wadors/index';\nimport { default as configure } from './configure';\nimport { default as convertColorSpace } from './convertColorSpace';\nimport { default as createImage } from './createImage';\nimport { default as decodeImageFrame } from './decodeImageFrame';\nimport { default as decodeJPEGBaseline8BitColor } from './decodeJPEGBaseline8BitColor';\nimport { default as getImageFrame } from './getImageFrame';\nimport { default as getMinMax } from '../shared/getMinMax';\nimport { default as isColorImage } from '../shared/isColorImage';\nimport { default as isJPEGBaseline8BitColor } from './isJPEGBaseline8BitColor';\nimport { default as webWorkerManager } from './webWorkerManager';\nimport { default as getPixelData } from './wadors/getPixelData';\nimport { internal } from './internal/index';\nimport { default as external } from '../externalModules';\n\nconst cornerstoneDICOMImageLoader = {\n convertRGBColorByPixel,\n convertRGBColorByPlane,\n convertYBRFullByPixel,\n convertYBRFullByPlane,\n convertPALETTECOLOR,\n wadouri,\n wadors,\n configure,\n convertColorSpace,\n createImage,\n decodeImageFrame,\n decodeJPEGBaseline8BitColor,\n getImageFrame,\n getPixelData,\n getMinMax,\n isColorImage,\n isJPEGBaseline8BitColor,\n webWorkerManager,\n internal,\n external,\n};\n\nexport {\n convertRGBColorByPixel,\n convertRGBColorByPlane,\n convertYBRFullByPixel,\n convertYBRFullByPlane,\n convertPALETTECOLOR,\n wadouri,\n wadors,\n configure,\n convertColorSpace,\n createImage,\n decodeImageFrame,\n decodeJPEGBaseline8BitColor,\n getImageFrame,\n getPixelData,\n getMinMax,\n isColorImage,\n isJPEGBaseline8BitColor,\n webWorkerManager,\n internal,\n external,\n};\n\nexport default cornerstoneDICOMImageLoader;\n"],"names":["root","factory","exports","module","require","define","amd","this","__WEBPACK_EXTERNAL_MODULE__464__","__WEBPACK_EXTERNAL_MODULE__713__","zlib_inflate","utils","strings","msg","ZStream","GZheader","toString","Object","prototype","Z_NO_FLUSH","Z_FINISH","Z_OK","Z_STREAM_END","Z_NEED_DICT","Z_STREAM_ERROR","Z_DATA_ERROR","Z_MEM_ERROR","Inflate","options","assign","chunkSize","windowBits","to","opt","raw","err","ended","chunks","strm","avail_out","status","inflateInit2","Error","header","inflateGetHeader","dictionary","string2buf","call","Uint8Array","inflateSetDictionary","inflate","input","inflator","push","result","data","flush_mode","_flush_mode","last_avail_out","next_in","avail_in","length","output","next_out","state","wrap","inflateReset","onEnd","next_out_utf8","utf8border","tail","utf8str","buf2string","set","subarray","onData","inflateEnd","chunk","join","flattenChunks","_has","obj","key","hasOwnProperty","sources","Array","slice","arguments","source","shift","TypeError","p","len","i","l","pos","STR_APPLY_UIA_OK","String","fromCharCode","apply","__","_utf8len","q","str","TextEncoder","encode","buf","c","c2","m_pos","str_len","buf_len","charCodeAt","max","TextDecoder","decode","out","utf16buf","c_len","buf2binstring","adler","s1","s2","n","Z_PARTIAL_FLUSH","Z_SYNC_FLUSH","Z_FULL_FLUSH","Z_BLOCK","Z_TREES","Z_ERRNO","Z_BUF_ERROR","Z_NO_COMPRESSION","Z_BEST_SPEED","Z_BEST_COMPRESSION","Z_DEFAULT_COMPRESSION","Z_FILTERED","Z_HUFFMAN_ONLY","Z_RLE","Z_FIXED","Z_DEFAULT_STRATEGY","Z_BINARY","Z_TEXT","Z_UNKNOWN","Z_DEFLATED","crcTable","Uint32Array","table","k","makeTable","crc","t","end","text","time","xflags","os","extra","extra_len","name","comment","hcrc","done","BAD","start","_in","last","_out","beg","dmax","wsize","whave","wnext","s_window","hold","bits","lcode","dcode","lmask","dmask","here","op","dist","from","from_source","window","lencode","distcode","lenbits","distbits","top","dolen","mode","dodist","sane","adler32","crc32","inflate_fast","inflate_table","HEAD","DICT","TYPE","TYPEDO","COPY_","LEN_","LEN","CHECK","MEM","zswap32","InflateState","havedict","flags","check","total","head","wbits","offset","ncode","nlen","ndist","have","next","lens","Uint16Array","work","lendyn","distdyn","back","was","inflateStateCheck","inflateResetKeep","total_in","total_out","Int32Array","inflateReset2","ret","lenfix","distfix","virgin","fixedtables","sym","updatewindow","src","copy","inflateInit","flush","put","left","here_bits","here_op","here_val","last_bits","last_op","last_val","hbuf","opts","order","inf_leave","data_type","dictLength","dictid","inflateInfo","MAXBITS","lbase","lext","dbase","dext","type","lens_index","codes","table_index","incr","fill","low","mask","match","min","curr","drop","used","huff","base","count","offs","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","__webpack_modules__","d","definition","o","defineProperty","enumerable","get","g","globalThis","Function","e","prop","r","Symbol","toStringTag","value","scriptUrl","importScripts","location","document","currentScript","scripts","getElementsByTagName","replace","imageFrame","colorBuffer","useRGBA","numPixels","rgbIndex","bufferIndex","rIndex","gIndex","bIndex","ybrIndex","y","cb","cr","yIndex","cbIndex","crIndex","element","index","defaultValue","Value","getValue","parseFloat","minimumLength","isArray","values","imageIdToURI","imageId","colonIndex","indexOf","substring","getTagValue","tag","justElement","getFrameInformation","PerFrameFunctionalGroupsSequence","SharedFunctionalGroupsSequence","frameNumber","shared","map","it","filter","perFrame","getMultiframeInformation","metaData","NumberOfFrames","rest","_retrieveMultiframeMetadata","imageURI","lastSlashIdx","imageIdFrameless","frame","parseInt","metadata","metadataByImageURI","retrieveMultiframeMetadata","isMultiframe","numberOfFrames","multiframeMetadataByImageURI","add","multiframeMetadata","cachedMetadata","retrievedMetadata","firstFrameMetadata","combined","instance","newInstance","forEach","item","entries","combineFrameInstance","remove","purge","isNMReconstructable","imageSubType","isNMModality","includes","getImageTypeSubItemFromMetadata","imageType","extractOrientationFromMetadata","imageOrientationPatient","getNumberValues","detectorInformationSequence","extractOrientationFromNMMultiframeMetadata","extractPositionFromMetadata","imagePositionPatient","extractPositionFromNMMultiframeMetadata","getInstanceModule","metaDataProvider","types","capitalizedData","capitalizeTag","error","console","charAt","toUpperCase","instanceModuleNames","getFirstNumberValue","sequence","warn","getUSEnhancedRegions","sequenceOfUltrasoundRegions","getSequenceItems","physicalDeltaX","physicalDeltaY","physicalUnitsXDirection","physicalUnitsYDirection","regionLocationMinY0","regionLocationMaxY1","regionLocationMinX0","regionLocationMaxX1","referencePixelX0","referencePixelY0","referencePhysicalPixelValueY","referencePhysicalPixelValueX","regionSpatialFormat","regionDataType","regionFlags","transducerFrequency","getTransferSyntax","transferSyntaxUID","MetadataModules","external","dicomParser","MULTIFRAME","PerFrameFunctionalInformation","SharedFunctionalInformation","metaDataManager","GENERAL_STUDY","studyDescription","studyDate","parseDA","studyTime","parseTM","accessionNumber","GENERAL_SERIES","modality","seriesInstanceUID","seriesNumber","getNumberValue","studyInstanceUID","seriesDate","seriesTime","acquisitionDate","acquisitionTime","GENERAL_IMAGE","sopInstanceUID","instanceNumber","lossyImageCompression","lossyImageCompressionRatio","lossyImageCompressionMethod","PATIENT","patientID","patientName","PATIENT_STUDY","patientAge","patientSize","patientSex","patientWeight","NM_MULTIFRAME_GEOMETRY","sliceThickness","pixelSpacing","IMAGE_PLANE","columnPixelSpacing","rowPixelSpacing","rowCosines","columnCosines","frameOfReferenceUID","rows","columns","sliceLocation","ULTRASOUND_ENHANCED_REGION","CALIBRATION","IMAGE_URL","isVideo","imageUrl","thumbnail","rendered","getImageUrlModule","CINE","cineRate","getCineModule","IMAGE_PIXEL","samplesPerPixel","photometricInterpretation","bitsAllocated","bitsStored","highBit","pixelRepresentation","planarConfiguration","pixelAspectRatio","smallestPixelValue","largestPixelValue","redPaletteColorLookupTableDescriptor","greenPaletteColorLookupTableDescriptor","bluePaletteColorLookupTableDescriptor","redPaletteColorLookupTableData","greenPaletteColorLookupTableData","bluePaletteColorLookupTableData","VOI_LUT","windowCenter","windowWidth","MODALITY_LUT","rescaleIntercept","rescaleSlope","rescaleType","SOP_COMMON","sopClassUID","PET_ISOTOPE","radiopharmaceuticalInfo","radiopharmaceuticalStartTime","radiopharmaceuticalStartDateTime","radionuclideTotalDose","radionuclideHalfLife","OVERLAY_PLANE","overlays","overlayGroup","groupStr","pixelData","byte_as_int","dataOffset","x","description","label","roiArea","roiMean","roiStandardDeviation","getOverlayPlaneModule","PET_SERIES","correctedImage","units","decayCorrection","PET_IMAGE","frameReferenceTime","actualFrameDuration","checkToken","token","endIndex","uint","j","stringToUint8Array","open","xhr","url","beforeSend","beforeProcessing","Promise","resolve","response","imageCreated","strict","decodeConfig","convertFloatPixelDataToInt","use16BitDataType","setOptions","newOptions","getOptions","defaultHeaders","params","cornerstone","errorInterceptor","request","XMLHttpRequest","promise","reject","beforeSendHeaders","responseType","headers","keys","setRequestHeader","deferred","onloadstart","event","eventData","triggerEvent","events","onloadend","onreadystatechange","readyState","then","catch","onprogress","oProgress","loaded","percentComplete","lengthComputable","Math","round","onerror","onabort","send","internal","xhrRequest","ImageQualityStatus","Enums","extractMultipart","contentType","imageFrameAsArrayBuffer","isPartial","imageQualityStatus","SUBRESOLUTION","FULL_RESOLUTION","tokenIndex","responseHeaders","boundary","multipartContentType","findIndexOfString","uint8ArrayToString","split","substr","findBoundary","trim","findContentType","extractDone","getImageQualityStatus","retrieveOptions","ProgressiveIterator","utilities","streamRequest","globalOptions","streamingData","minChunkSize","loadIterator","generate","async","iterator","fetch","signal","responseReader","body","getReader","totalBytes","Number","readDone","encodedData","lastSize","read","appendChunk","byteLength","extracted","detail","getNextPromise","existing","newDataArray","rangeRequest","attr","rangesFetched","byteRange","rangeIndex","getByteRange","range","Range","responseArrayBuffer","arrayBuffer","responseTypedArray","newByteArray","contentRange","MAX_SAFE_INTEGER","fetchRangeAndAppend","doneAllBytes","extract","uri","mediaType","Accept","urlArguments","framesPath","streaming","loadPromise","getResponseHeader","storedPixelData","storedPixel","convertRGB","convertRGBColorByPixel","convertRGBColorByPlane","convertColorSpace","convertPALETTECOLOR","y1","y2","convertYBRFull422ByPixel","convertYBRFullByPixel","convertYBRFullByPlane","convertYBRFull","arrayBufferToString","buffer","binary","decodeURIComponent","escape","_error","URIError","binaryToString","canvas","Date","getTime","imgBlob","Blob","fileReader","FileReader","readAsBinaryString","readAsArrayBuffer","onload","img","Image","height","width","context","getContext","drawImage","imageData","getImageData","decodeTimeInMS","minMax","getMinMax","pixelDataLength","btoa","Worker_fn","Worker","nextTaskId","tasks","webWorkers","defaultConfig","maxWebWorkers","navigator","hardwareConcurrency","startWebWorkersOnDemand","webWorkerTaskPaths","taskConfiguration","decodeTask","initializeCodecsOnStartup","config","statistics","numWebWorkers","numTasksQueued","numTasksExecuting","numTasksCompleted","totalTaskTimeInMS","totalTimeDelayedInMS","startTaskOnWebWorker","task","added","worker","postMessage","taskType","workerIndex","transferList","spawnWebWorker","handleMessageFromWorker","action","cornerstoneDICOMImageLoaderWebWorker","addEventListener","initialize","configObject","loadWebWorkerTask","sourcePath","taskConfig","addTask","priority","taskId","splice","getStatistics","setTaskPriority","cancelTask","reason","terminate","processDecodeTask","transferSyntax","srcOptions","loader","transferPixelData","webWorkerManager","pako","inflateRaw","decodeJPEGBaseline8BitColor","imagePixelModule","photoMetricInterpretation","TRANSFER_SYNTAX_USING_PHOTOMETRIC_COLOR","lastImageIdDrawn","setPixelDataType","TypedArray","pixelDataType","isInteger","Int8Array","Int16Array","Float32Array","getPixelDataTypeFromMinMax","typedArray","preScale","enabled","createElement","getImageFrame","decodeLevel","allowFloatRendering","canRenderFloatTextures","scalingParameters","modalityLutModule","generalSeriesModule","suvFactor","suvbw","getScalingParameters","isSharedArrayBuffer","targetBuffer","SharedArrayBuffer","useNativeDataType","decodePromise","decodeImageFrame","isColorImage","isColorImageFn","skipCreateImage","alreadyTyped","rawOffset","rawLength","imageFrameLength","typedArrayConstructors","TypedArrayConstructor","imagePlaneModule","voiLutModule","sopCommonModule","calibrationModule","createImageData","Uint8ClampedArray","removeAFromRGBA","image","color","calibration","intercept","slope","invert","minPixelValue","maxPixelValue","sizeInBytes","voiLUTFunction","floatPixelData","rgba","getPixelData","getCanvas","numComps","sopClassUid","ctx","arr","putImageData","modalityLUTSequence","modalityLUT","voiLUTSequence","voiLUT","minVoi","minAfterScale","maxVoi","maxAfterScale","streamableTransferSyntaxes","Set","getTransferSyntaxForContentType","defaultTransferSyntax","parameters","parameter","parameterValues","defaultTransferSyntaxByType","decodeLevelFromComplete","percent","retrieveDecodeLevel","testSize","imageRetrievalPool","uncompressedIterator","requestType","additionalDetails","addToBeginning","addRequest","compressedIt","as","lastDecodeLevel","has","useOptions","createImage","loadTimeInMS","bind","getDonePromise","cancelFn","getNumberString","loadImage","register","registerImageLoader","addProvider","getLutDescriptor","dataSet","elements","uint16","getLutData","lutDataSet","lutDescriptor","lut","lutData","byteArray","string","int16","populateSmallestLargestPixelValues","x00281101","numLutEntries","lutBitsAllocated","x00281201","populatePaletteColorLut","getLUT","numLUTEntries","firstValueMapped","id","numBitsPerEntry","lutSequence","items","luts","floatString","minStoredPixelValue","getMinStoredPixelValue","x00283000","valueAsString","firstColonIndex","frameIndex","frameStr","scheme","pixelDataFrame","parsePartialByteArray","pixelDataSet","parseDicom","untilTag","x7fe00010","log","fragments","totalLength","fragment","position","fixFragments","dataSetFromPartialContent","loadRequest","fileTotalLength","fetchMore","fetchOptions","_options","fetchedLength","lengthToFetch","byteArrayToAppend","combinedByteArray","otherAttributtes","x52009230","x52009229","otherElements","intString","_get","loadedDataSets","_isMultiframeDataset","generateMultiframeWADOURIs","listWADOURIs","retrieveMultiframeDataset","frameParameterIndex","retrieveFrameParameterIndex","multiframeURI","isMultiframeDataset","cacheSizeInBytes","promises","getInfo","numberOfDataSetsCached","isLoaded","load","cacheCount","loadDICOMPromise","dicomPart10AsArrayBuffer","partialContent","isPartialContent","ArrayBuffer","cacheInfo","unload","multiframeDataSet","multiframeDataset","newElements","clonedDataset","create","combineFrameInstanceDataset","update","loadedDataSet","getImageTypeSubItemFromDataset","subTypes","extractOrientationFromDataset","x00209116","x00540022","extractOrientationFromNMMultiframeDataset","extractPositionFromDataset","x00209113","extractPositionFromNMMultiframeDataset","extractSpacingFromDataset","x00289110","extractSliceThicknessFromDataset","x00180050","parsedImageId","parseImageId","multiframeData","multiframeInfo","getDirectFrameInformation","dataSetCacheManager","frameTime","getImagePixelModule","modalityLUTOutputPixelRepresentation","getModalityLUTOutputPixelRepresentation","getLUTs","x00283010","x00540016","firstRadiopharmaceuticalInfoDataSet","files","file","getEncapsulatedImageFrame","basicOffsetTable","readEncapsulatedImageFrame","framesAreFragmented","createJPEGBasicOffsetTable","byteStream","ByteStream","byteArrayParser","readSequenceItem","seek","fragmentZeroPosition","byteOffset","isBitSet","byte","bitPos","frameOffset","pixelsPerFrame","floor","pixelDataElement","x7fe00008","pixelDataOffset","unpackBinaryFrame","fileIndex","fileManager","target","encapsulatedPixelData","getUncompressedImageFrame","loadImageFromPromise","dataSetPromise","sharedCacheKey","callbacks","imageLoadObject","loadEnd","imagePromise","decache","addDecache","totalTimeInMS","imageDoneCallback","getLoaderForScheme","loadFileRequest","schemeLoader","loadImageFromDataSet","wadors","wadouri","cs","registerLoaders","dp","convertLUTto8Bit","numEntries","cleanedLUT","rData","gData","bData","palIndex","rDataCleaned","gDataCleaned","bDataCleaned","configure","isJPEGBaseline8BitColor"],"sourceRoot":""}
1	+ {"version":3,"file":"cornerstoneDICOMImageLoader.min.js","mappings":"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","sources":["webpack:///webpack/universalModuleDefinition","webpack:///../../../node_modules/pako/lib/inflate.js","webpack:///../../../node_modules/pako/lib/utils/common.js","webpack:///../../../node_modules/pako/lib/utils/strings.js","webpack:///../../../node_modules/pako/lib/zlib/adler32.js","webpack:///../../../node_modules/pako/lib/zlib/constants.js","webpack:///../../../node_modules/pako/lib/zlib/crc32.js","webpack:///../../../node_modules/pako/lib/zlib/gzheader.js","webpack:///../../../node_modules/pako/lib/zlib/inffast.js","webpack:///../../../node_modules/pako/lib/zlib/inflate.js","webpack:///../../../node_modules/pako/lib/zlib/inftrees.js","webpack:///../../../node_modules/pako/lib/zlib/messages.js","webpack:///../../../node_modules/pako/lib/zlib/zstream.js","webpack:///external umd \"@cornerstonejs/core\"","webpack:///external umd {\"commonjs\":\"dicom-parser\",\"commonjs2\":\"dicom-parser\",\"amd\":\"dicom-parser\",\"root\":\"dicomParser\"}","webpack:///webpack/bootstrap","webpack:///webpack/runtime/define property getters","webpack:///webpack/runtime/global","webpack:///webpack/runtime/hasOwnProperty shorthand","webpack:///webpack/runtime/make namespace object","webpack:///webpack/runtime/publicPath","webpack:///./imageLoader/colorSpaceConverters/convertRGBColorByPixel.ts","webpack:///./imageLoader/colorSpaceConverters/convertRGBColorByPlane.ts","webpack:///./imageLoader/colorSpaceConverters/convertYBRFullByPixel.ts","webpack:///./imageLoader/colorSpaceConverters/convertYBRFullByPlane.ts","webpack:///./imageLoader/wadors/metaData/getValue.ts","webpack:///./imageLoader/wadors/metaData/getNumberString.ts","webpack:///./imageLoader/wadors/metaData/getNumberValue.ts","webpack:///./imageLoader/wadors/metaData/getNumberValues.ts","webpack:///./imageLoader/imageIdToURI.ts","webpack:///./imageLoader/wadors/getTagValue.ts","webpack:///./imageLoader/wadors/combineFrameInstance.ts","webpack:///./imageLoader/wadors/retrieveMultiframeMetadata.ts","webpack:///./imageLoader/wadors/metaDataManager.ts","webpack:///./imageLoader/isNMReconstructable.ts","webpack:///./imageLoader/wadors/metaData/NMHelpers.ts","webpack:///./imageLoader/wadors/metaData/extractPositioningFromMetadata.ts","webpack:///./imageLoader/getInstanceModule.ts","webpack:///./imageLoader/wadors/metaData/getFirstNumberValue.ts","webpack:///./imageLoader/wadors/metaData/getSequenceItems.ts","webpack:///./imageLoader/wadors/metaData/USHelpers.ts","webpack:///./imageLoader/wadors/metaData/metaDataProvider.ts","webpack:///./imageLoader/wadors/metaData/getOverlayPlaneModule.ts","webpack:///./imageLoader/wadors/findIndexOfString.ts","webpack:///./imageLoader/internal/options.ts","webpack:///./imageLoader/internal/xhrRequest.ts","webpack:///./imageLoader/internal/index.ts","webpack:///./imageLoader/wadors/extractMultipart.ts","webpack:///./imageLoader/wadors/getImageQualityStatus.ts","webpack:///./imageLoader/internal/streamRequest.ts","webpack:///./imageLoader/internal/rangeRequest.ts","webpack:///./imageLoader/wadors/getPixelData.ts","webpack:///./shared/getMinMax.ts","webpack:///./imageLoader/convertColorSpace.ts","webpack:///./imageLoader/colorSpaceConverters/convertYBRFull422ByPixel.ts","webpack:///./imageLoader/decodeJPEGBaseline8BitColor.ts","webpack:///./webWorker/index.worker.ts","webpack:///./imageLoader/webWorkerManager.ts","webpack:///./imageLoader/decodeImageFrame.ts","webpack:///./imageLoader/getImageFrame.ts","webpack:///./shared/isColorImage.ts","webpack:///./imageLoader/createImage.ts","webpack:///./shared/getPixelDataTypeFromMinMax.ts","webpack:///./imageLoader/getScalingParameters.ts","webpack:///./imageLoader/isColorConversionRequired.ts","webpack:///./imageLoader/wadors/loadImage.ts","webpack:///./imageLoader/wadors/index.ts","webpack:///./imageLoader/wadors/register.ts","webpack:///./imageLoader/wadouri/metaData/getImagePixelModule.ts","webpack:///./imageLoader/wadouri/metaData/getLUTs.ts","webpack:///./imageLoader/wadouri/metaData/getModalityLUTOutputPixelRepresentation.ts","webpack:///./imageLoader/wadouri/metaData/getNumberValues.ts","webpack:///./imageLoader/wadouri/parseImageId.ts","webpack:///./imageLoader/wadouri/dataset-from-partial-content.ts","webpack:///./imageLoader/wadouri/combineFrameInstanceDataset.ts","webpack:///./imageLoader/wadouri/retrieveMultiframeDataset.ts","webpack:///./imageLoader/wadouri/dataSetCacheManager.ts","webpack:///./imageLoader/wadouri/metaData/extractPositioningFromDataset.ts","webpack:///./imageLoader/wadouri/metaData/metaDataProvider.ts","webpack:///./imageLoader/wadouri/metaData/getOverlayPlaneModule.ts","webpack:///./imageLoader/wadouri/fileManager.ts","webpack:///./imageLoader/wadouri/getEncapsulatedImageFrame.ts","webpack:///./imageLoader/wadouri/unpackBinaryFrame.ts","webpack:///./imageLoader/wadouri/getUncompressedImageFrame.ts","webpack:///./imageLoader/wadouri/loadFileRequest.ts","webpack:///./imageLoader/wadouri/getPixelData.ts","webpack:///./imageLoader/wadouri/loadImage.ts","webpack:///./imageLoader/wadouri/index.ts","webpack:///./imageLoader/wadouri/register.ts","webpack:///./imageLoader/registerLoaders.ts","webpack:///./externalModules.ts","webpack:///./imageLoader/colorSpaceConverters/convertPALETTECOLOR.ts","webpack:///./imageLoader/configure.ts","webpack:///./imageLoader/isJPEGBaseline8BitColor.ts","webpack:///./imageLoader/index.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"@cornerstonejs/core\"), require(\"dicom-parser\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"cornerstoneDICOMImageLoader\", [\"@cornerstonejs/core\", \"dicom-parser\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"cornerstoneDICOMImageLoader\"] = factory(require(\"@cornerstonejs/core\"), require(\"dicom-parser\"));\n\telse\n\t\troot[\"cornerstoneDICOMImageLoader\"] = factory(root[\"@cornerstonejs/core\"], root[\"dicomParser\"]);\n})(this, (__WEBPACK_EXTERNAL_MODULE__464__, __WEBPACK_EXTERNAL_MODULE__713__) => {\nreturn ","'use strict';\n\n\nconst zlib_inflate = require('./zlib/inflate');\nconst utils = require('./utils/common');\nconst strings = require('./utils/strings');\nconst msg = require('./zlib/messages');\nconst ZStream = require('./zlib/zstream');\nconst GZheader = require('./zlib/gzheader');\n\nconst toString = Object.prototype.toString;\n\n/* Public constants ==========================================================/\n/ ===========================================================================/\n\nconst {\n Z_NO_FLUSH, Z_FINISH,\n Z_OK, Z_STREAM_END, Z_NEED_DICT, Z_STREAM_ERROR, Z_DATA_ERROR, Z_MEM_ERROR\n} = require('./zlib/constants');\n\n/ ===========================================================================/\n\n\n/\n class Inflate\n \n Generic JS-style wrapper for zlib calls. If you don't need\n * streaming behaviour - use more simple functions: [[inflate]]\n * and [[inflateRaw]].\n */\n\n/ internal\n * inflate.chunks -> Array\n \n Chunks of output data, if [[Inflate#onData]] not overridden.\n /\n\n/\n * Inflate.result -> Uint8Array\|String\n \n Uncompressed result, generated by default [[Inflate#onData]]\n * and [[Inflate#onEnd]] handlers. Filled after you push last chunk\n * (call [[Inflate#push]] with `Z_FINISH` / `true` param).\n /\n\n/\n * Inflate.err -> Number\n \n Error code after inflate finished. 0 (Z_OK) on success.\n * Should be checked if broken data possible.\n /\n\n/\n * Inflate.msg -> String\n \n Error message, if [[Inflate.err]] != 0\n /\n\n\n/\n * new Inflate(options)\n * - options (Object): zlib inflate options.\n \n Creates new inflator instance with specified params. Throws exception\n * on bad params. Supported options:\n \n - `windowBits`\n * - `dictionary`\n \n [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n * for more information on these.\n \n Additional options, for internal needs:\n \n - `chunkSize` - size of generated data chunks (16K by default)\n * - `raw` (Boolean) - do raw inflate\n * - `to` (String) - if equal to 'string', then result will be converted\n * from utf8 to utf16 (javascript) string. When string output requested,\n * chunk length can differ from `chunkSize`, depending on content.\n \n By default, when no options set, autodetect deflate/gzip data format via\n * wrapper header.\n \n ##### Example:\n \n ```javascript\n * const pako = require('pako')\n * const chunk1 = new Uint8Array([1,2,3,4,5,6,7,8,9])\n * const chunk2 = new Uint8Array([10,11,12,13,14,15,16,17,18,19]);\n \n const inflate = new pako.Inflate({ level: 3});\n \n inflate.push(chunk1, false);\n * inflate.push(chunk2, true); // true -> last chunk\n \n if (inflate.err) { throw new Error(inflate.err); }\n \n console.log(inflate.result);\n * ```\n */\nfunction Inflate(options) {\n this.options = utils.assign({\n chunkSize: 1024 64,\n windowBits: 15,\n to: ''\n }, options \|\| {});\n\n const opt = this.options;\n\n // Force window size for `raw` data, if not set directly,\n // because we have no header for autodetect.\n if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) {\n opt.windowBits = -opt.windowBits;\n if (opt.windowBits === 0) { opt.windowBits = -15; }\n }\n\n // If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate\n if ((opt.windowBits >= 0) && (opt.windowBits < 16) &&\n !(options && options.windowBits)) {\n opt.windowBits += 32;\n }\n\n // Gzip header has no info about windows size, we can do autodetect only\n // for deflate. So, if window size not set, force it to max when gzip possible\n if ((opt.windowBits > 15) && (opt.windowBits < 48)) {\n // bit 3 (16) -> gzipped data\n // bit 4 (32) -> autodetect gzip/deflate\n if ((opt.windowBits & 15) === 0) {\n opt.windowBits \|= 15;\n }\n }\n\n this.err = 0; // error code, if happens (0 = Z_OK)\n this.msg = ''; // error message\n this.ended = false; // used to avoid multiple onEnd() calls\n this.chunks = []; // chunks of compressed data\n\n this.strm = new ZStream();\n this.strm.avail_out = 0;\n\n let status = zlib_inflate.inflateInit2(\n this.strm,\n opt.windowBits\n );\n\n if (status !== Z_OK) {\n throw new Error(msg[status]);\n }\n\n this.header = new GZheader();\n\n zlib_inflate.inflateGetHeader(this.strm, this.header);\n\n // Setup dictionary\n if (opt.dictionary) {\n // Convert data if needed\n if (typeof opt.dictionary === 'string') {\n opt.dictionary = strings.string2buf(opt.dictionary);\n } else if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {\n opt.dictionary = new Uint8Array(opt.dictionary);\n }\n if (opt.raw) { //In raw mode we need to set the dictionary early\n status = zlib_inflate.inflateSetDictionary(this.strm, opt.dictionary);\n if (status !== Z_OK) {\n throw new Error(msg[status]);\n }\n }\n }\n}\n\n/*\n Inflate#push(data[, flush_mode]) -> Boolean\n * - data (Uint8Array\|ArrayBuffer): input data\n * - flush_mode (Number\|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE\n * flush modes. See constants. Skipped or `false` means Z_NO_FLUSH,\n * `true` means Z_FINISH.\n \n Sends input data to inflate pipe, generating [[Inflate#onData]] calls with\n * new output chunks. Returns `true` on success. If end of stream detected,\n * [[Inflate#onEnd]] will be called.\n \n `flush_mode` is not needed for normal operation, because end of stream\n * detected automatically. You may try to use it for advanced things, but\n * this functionality was not tested.\n \n On fail call [[Inflate#onEnd]] with error code and return false.\n \n ##### Example\n \n ```javascript\n * push(chunk, false); // push one of data chunks\n * ...\n * push(chunk, true); // push last chunk\n * ```\n /\nInflate.prototype.push = function (data, flush_mode) {\n const strm = this.strm;\n const chunkSize = this.options.chunkSize;\n const dictionary = this.options.dictionary;\n let status, _flush_mode, last_avail_out;\n\n if (this.ended) return false;\n\n if (flush_mode === ~~flush_mode) _flush_mode = flush_mode;\n else _flush_mode = flush_mode === true ? Z_FINISH : Z_NO_FLUSH;\n\n // Convert data if needed\n if (toString.call(data) === '[object ArrayBuffer]') {\n strm.input = new Uint8Array(data);\n } else {\n strm.input = data;\n }\n\n strm.next_in = 0;\n strm.avail_in = strm.input.length;\n\n for (;;) {\n if (strm.avail_out === 0) {\n strm.output = new Uint8Array(chunkSize);\n strm.next_out = 0;\n strm.avail_out = chunkSize;\n }\n\n status = zlib_inflate.inflate(strm, _flush_mode);\n\n if (status === Z_NEED_DICT && dictionary) {\n status = zlib_inflate.inflateSetDictionary(strm, dictionary);\n\n if (status === Z_OK) {\n status = zlib_inflate.inflate(strm, _flush_mode);\n } else if (status === Z_DATA_ERROR) {\n // Replace code with more verbose\n status = Z_NEED_DICT;\n }\n }\n\n // Skip snyc markers if more data follows and not raw mode\n while (strm.avail_in > 0 &&\n status === Z_STREAM_END &&\n strm.state.wrap > 0 &&\n data[strm.next_in] !== 0)\n {\n zlib_inflate.inflateReset(strm);\n status = zlib_inflate.inflate(strm, _flush_mode);\n }\n\n switch (status) {\n case Z_STREAM_ERROR:\n case Z_DATA_ERROR:\n case Z_NEED_DICT:\n case Z_MEM_ERROR:\n this.onEnd(status);\n this.ended = true;\n return false;\n }\n\n // Remember real `avail_out` value, because we may patch out buffer content\n // to align utf8 strings boundaries.\n last_avail_out = strm.avail_out;\n\n if (strm.next_out) {\n if (strm.avail_out === 0 \|\| status === Z_STREAM_END) {\n\n if (this.options.to === 'string') {\n\n let next_out_utf8 = strings.utf8border(strm.output, strm.next_out);\n\n let tail = strm.next_out - next_out_utf8;\n let utf8str = strings.buf2string(strm.output, next_out_utf8);\n\n // move tail & realign counters\n strm.next_out = tail;\n strm.avail_out = chunkSize - tail;\n if (tail) strm.output.set(strm.output.subarray(next_out_utf8, next_out_utf8 + tail), 0);\n\n this.onData(utf8str);\n\n } else {\n this.onData(strm.output.length === strm.next_out ? strm.output : strm.output.subarray(0, strm.next_out));\n }\n }\n }\n\n // Must repeat iteration if out buffer is full\n if (status === Z_OK && last_avail_out === 0) continue;\n\n // Finalize if end of stream reached.\n if (status === Z_STREAM_END) {\n status = zlib_inflate.inflateEnd(this.strm);\n this.onEnd(status);\n this.ended = true;\n return true;\n }\n\n if (strm.avail_in === 0) break;\n }\n\n return true;\n};\n\n\n/\n * Inflate#onData(chunk) -> Void\n * - chunk (Uint8Array\|String): output data. When string output requested,\n * each chunk will be string.\n \n By default, stores data blocks in `chunks[]` property and glue\n * those in `onEnd`. Override this handler, if you need another behaviour.\n /\nInflate.prototype.onData = function (chunk) {\n this.chunks.push(chunk);\n};\n\n\n/\n * Inflate#onEnd(status) -> Void\n * - status (Number): inflate status. 0 (Z_OK) on success,\n * other if not.\n \n Called either after you tell inflate that the input stream is\n * complete (Z_FINISH). By default - join collected chunks,\n * free memory and fill `results` / `err` properties.\n /\nInflate.prototype.onEnd = function (status) {\n // On success - join\n if (status === Z_OK) {\n if (this.options.to === 'string') {\n this.result = this.chunks.join('');\n } else {\n this.result = utils.flattenChunks(this.chunks);\n }\n }\n this.chunks = [];\n this.err = status;\n this.msg = this.strm.msg;\n};\n\n\n/\n * inflate(data[, options]) -> Uint8Array\|String\n * - data (Uint8Array\|ArrayBuffer): input data to decompress.\n * - options (Object): zlib inflate options.\n \n Decompress `data` with inflate/ungzip and `options`. Autodetect\n * format via wrapper header by default. That's why we don't provide\n * separate `ungzip` method.\n \n Supported options are:\n \n - windowBits\n \n [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n * for more information.\n \n Sugar (options):\n \n - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify\n * negative windowBits implicitly.\n * - `to` (String) - if equal to 'string', then result will be converted\n * from utf8 to utf16 (javascript) string. When string output requested,\n * chunk length can differ from `chunkSize`, depending on content.\n \n \n * ##### Example:\n \n ```javascript\n * const pako = require('pako');\n * const input = pako.deflate(new Uint8Array([1,2,3,4,5,6,7,8,9]));\n * let output;\n \n try {\n * output = pako.inflate(input);\n * } catch (err) {\n * console.log(err);\n * }\n * ```\n /\nfunction inflate(input, options) {\n const inflator = new Inflate(options);\n\n inflator.push(input);\n\n // That will never happens, if you don't cheat with options :)\n if (inflator.err) throw inflator.msg \|\| msg[inflator.err];\n\n return inflator.result;\n}\n\n\n/\n * inflateRaw(data[, options]) -> Uint8Array\|String\n * - data (Uint8Array\|ArrayBuffer): input data to decompress.\n * - options (Object): zlib inflate options.\n \n The same as [[inflate]], but creates raw data, without wrapper\n * (header and adler32 crc).\n /\nfunction inflateRaw(input, options) {\n options = options \|\| {};\n options.raw = true;\n return inflate(input, options);\n}\n\n\n/\n * ungzip(data[, options]) -> Uint8Array\|String\n * - data (Uint8Array\|ArrayBuffer): input data to decompress.\n * - options (Object): zlib inflate options.\n \n Just shortcut to [[inflate]], because it autodetects format\n * by header.content. Done for convenience.\n */\n\n\nmodule.exports.Inflate = Inflate;\nmodule.exports.inflate = inflate;\nmodule.exports.inflateRaw = inflateRaw;\nmodule.exports.ungzip = inflate;\nmodule.exports.constants = require('./zlib/constants');\n","'use strict';\n\n\nconst _has = (obj, key) => {\n return Object.prototype.hasOwnProperty.call(obj, key);\n};\n\nmodule.exports.assign = function (obj /from1, from2, from3, .../) {\n const sources = Array.prototype.slice.call(arguments, 1);\n while (sources.length) {\n const source = sources.shift();\n if (!source) { continue; }\n\n if (typeof source !== 'object') {\n throw new TypeError(source + 'must be non-object');\n }\n\n for (const p in source) {\n if (_has(source, p)) {\n obj[p] = source[p];\n }\n }\n }\n\n return obj;\n};\n\n\n// Join array of chunks to single array.\nmodule.exports.flattenChunks = (chunks) => {\n // calculate data length\n let len = 0;\n\n for (let i = 0, l = chunks.length; i < l; i++) {\n len += chunks[i].length;\n }\n\n // join chunks\n const result = new Uint8Array(len);\n\n for (let i = 0, pos = 0, l = chunks.length; i < l; i++) {\n let chunk = chunks[i];\n result.set(chunk, pos);\n pos += chunk.length;\n }\n\n return result;\n};\n","// String encode/decode helpers\n'use strict';\n\n\n// Quick check if we can use fast array to bin string conversion\n//\n// - apply(Array) can fail on Android 2.2\n// - apply(Uint8Array) can fail on iOS 5.1 Safari\n//\nlet STR_APPLY_UIA_OK = true;\n\ntry { String.fromCharCode.apply(null, new Uint8Array(1)); } catch (__) { STR_APPLY_UIA_OK = false; }\n\n\n// Table with utf8 lengths (calculated by first byte of sequence)\n// Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,\n// because max possible codepoint is 0x10ffff\nconst _utf8len = new Uint8Array(256);\nfor (let q = 0; q < 256; q++) {\n _utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1);\n}\n_utf8len[254] = _utf8len[254] = 1; // Invalid sequence start\n\n\n// convert string to array (typed, when possible)\nmodule.exports.string2buf = (str) => {\n if (typeof TextEncoder === 'function' && TextEncoder.prototype.encode) {\n return new TextEncoder().encode(str);\n }\n\n let buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;\n\n // count binary size\n for (m_pos = 0; m_pos < str_len; m_pos++) {\n c = str.charCodeAt(m_pos);\n if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {\n c2 = str.charCodeAt(m_pos + 1);\n if ((c2 & 0xfc00) === 0xdc00) {\n c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n m_pos++;\n }\n }\n buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;\n }\n\n // allocate buffer\n buf = new Uint8Array(buf_len);\n\n // convert\n for (i = 0, m_pos = 0; i < buf_len; m_pos++) {\n c = str.charCodeAt(m_pos);\n if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {\n c2 = str.charCodeAt(m_pos + 1);\n if ((c2 & 0xfc00) === 0xdc00) {\n c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n m_pos++;\n }\n }\n if (c < 0x80) {\n / one byte /\n buf[i++] = c;\n } else if (c < 0x800) {\n / two bytes /\n buf[i++] = 0xC0 \| (c >>> 6);\n buf[i++] = 0x80 \| (c & 0x3f);\n } else if (c < 0x10000) {\n / three bytes /\n buf[i++] = 0xE0 \| (c >>> 12);\n buf[i++] = 0x80 \| (c >>> 6 & 0x3f);\n buf[i++] = 0x80 \| (c & 0x3f);\n } else {\n / four bytes /\n buf[i++] = 0xf0 \| (c >>> 18);\n buf[i++] = 0x80 \| (c >>> 12 & 0x3f);\n buf[i++] = 0x80 \| (c >>> 6 & 0x3f);\n buf[i++] = 0x80 \| (c & 0x3f);\n }\n }\n\n return buf;\n};\n\n// Helper\nconst buf2binstring = (buf, len) => {\n // On Chrome, the arguments in a function call that are allowed is `65534`.\n // If the length of the buffer is smaller than that, we can use this optimization,\n // otherwise we will take a slower path.\n if (len < 65534) {\n if (buf.subarray && STR_APPLY_UIA_OK) {\n return String.fromCharCode.apply(null, buf.length === len ? buf : buf.subarray(0, len));\n }\n }\n\n let result = '';\n for (let i = 0; i < len; i++) {\n result += String.fromCharCode(buf[i]);\n }\n return result;\n};\n\n\n// convert array to string\nmodule.exports.buf2string = (buf, max) => {\n const len = max \|\| buf.length;\n\n if (typeof TextDecoder === 'function' && TextDecoder.prototype.decode) {\n return new TextDecoder().decode(buf.subarray(0, max));\n }\n\n let i, out;\n\n // Reserve max possible length (2 words per char)\n // NB: by unknown reasons, Array is significantly faster for\n // String.fromCharCode.apply than Uint16Array.\n const utf16buf = new Array(len 2);\n\n for (out = 0, i = 0; i < len;) {\n let c = buf[i++];\n // quick process ascii\n if (c < 0x80) { utf16buf[out++] = c; continue; }\n\n let c_len = _utf8len[c];\n // skip 5 & 6 byte codes\n if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len - 1; continue; }\n\n // apply mask on first byte\n c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;\n // join the rest\n while (c_len > 1 && i < len) {\n c = (c << 6) \| (buf[i++] & 0x3f);\n c_len--;\n }\n\n // terminated by end of string?\n if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }\n\n if (c < 0x10000) {\n utf16buf[out++] = c;\n } else {\n c -= 0x10000;\n utf16buf[out++] = 0xd800 \| ((c >> 10) & 0x3ff);\n utf16buf[out++] = 0xdc00 \| (c & 0x3ff);\n }\n }\n\n return buf2binstring(utf16buf, out);\n};\n\n\n// Calculate max possible position in utf8 buffer,\n// that will not break sequence. If that's not possible\n// - (very small limits) return max size as is.\n//\n// buf[] - utf8 bytes array\n// max - length limit (mandatory);\nmodule.exports.utf8border = (buf, max) => {\n\n max = max \|\| buf.length;\n if (max > buf.length) { max = buf.length; }\n\n // go back from last position, until start of sequence found\n let pos = max - 1;\n while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }\n\n // Very small and broken sequence,\n // return max, because we should return something anyway.\n if (pos < 0) { return max; }\n\n // If we came to start of buffer - that means buffer is too small,\n // return max too.\n if (pos === 0) { return max; }\n\n return (pos + _utf8len[buf[pos]] > max) ? pos : max;\n};\n","'use strict';\n\n// Note: adler32 takes 12% for level 0 and 2% for level 6.\n// It isn't worth it to make additional optimizations as in original.\n// Small size is preferable.\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nconst adler32 = (adler, buf, len, pos) => {\n let s1 = (adler & 0xffff) \|0,\n s2 = ((adler >>> 16) & 0xffff) \|0,\n n = 0;\n\n while (len !== 0) {\n // Set limit ~ twice less than 5552, to keep\n // s2 in 31-bits, because we force signed ints.\n // in other case %= will fail.\n n = len > 2000 ? 2000 : len;\n len -= n;\n\n do {\n s1 = (s1 + buf[pos++]) \|0;\n s2 = (s2 + s1) \|0;\n } while (--n);\n\n s1 %= 65521;\n s2 %= 65521;\n }\n\n return (s1 \| (s2 << 16)) \|0;\n};\n\n\nmodule.exports = adler32;\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nmodule.exports = {\n\n /* Allowed flush values; see deflate() and inflate() below for details /\n Z_NO_FLUSH: 0,\n Z_PARTIAL_FLUSH: 1,\n Z_SYNC_FLUSH: 2,\n Z_FULL_FLUSH: 3,\n Z_FINISH: 4,\n Z_BLOCK: 5,\n Z_TREES: 6,\n\n / Return codes for the compression/decompression functions. Negative values\n * are errors, positive values are used for special but normal events.\n /\n Z_OK: 0,\n Z_STREAM_END: 1,\n Z_NEED_DICT: 2,\n Z_ERRNO: -1,\n Z_STREAM_ERROR: -2,\n Z_DATA_ERROR: -3,\n Z_MEM_ERROR: -4,\n Z_BUF_ERROR: -5,\n //Z_VERSION_ERROR: -6,\n\n / compression levels /\n Z_NO_COMPRESSION: 0,\n Z_BEST_SPEED: 1,\n Z_BEST_COMPRESSION: 9,\n Z_DEFAULT_COMPRESSION: -1,\n\n\n Z_FILTERED: 1,\n Z_HUFFMAN_ONLY: 2,\n Z_RLE: 3,\n Z_FIXED: 4,\n Z_DEFAULT_STRATEGY: 0,\n\n / Possible values of the data_type field (though see inflate()) /\n Z_BINARY: 0,\n Z_TEXT: 1,\n //Z_ASCII: 1, // = Z_TEXT (deprecated)\n Z_UNKNOWN: 2,\n\n / The deflate compression method /\n Z_DEFLATED: 8\n //Z_NULL: null // Use -1 or null inline, depending on var type\n};\n","'use strict';\n\n// Note: we can't get significant speed boost here.\n// So write code to minimize size - no pregenerated tables\n// and array tools dependencies.\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\n// Use ordinary array, since untyped makes no boost here\nconst makeTable = () => {\n let c, table = [];\n\n for (var n = 0; n < 256; n++) {\n c = n;\n for (var k = 0; k < 8; k++) {\n c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));\n }\n table[n] = c;\n }\n\n return table;\n};\n\n// Create table on load. Just 255 signed longs. Not a problem.\nconst crcTable = new Uint32Array(makeTable());\n\n\nconst crc32 = (crc, buf, len, pos) => {\n const t = crcTable;\n const end = pos + len;\n\n crc ^= -1;\n\n for (let i = pos; i < end; i++) {\n crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];\n }\n\n return (crc ^ (-1)); // >>> 0;\n};\n\n\nmodule.exports = crc32;\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nfunction GZheader() {\n / true if compressed data believed to be text /\n this.text = 0;\n / modification time /\n this.time = 0;\n / extra flags (not used when writing a gzip file) /\n this.xflags = 0;\n / operating system /\n this.os = 0;\n / pointer to extra field or Z_NULL if none /\n this.extra = null;\n / extra field length (valid if extra != Z_NULL) /\n this.extra_len = 0; // Actually, we don't need it in JS,\n // but leave for few code modifications\n\n //\n // Setup limits is not necessary because in js we should not preallocate memory\n // for inflate use constant limit in 65536 bytes\n //\n\n / space at extra (only when reading header) /\n // this.extra_max = 0;\n / pointer to zero-terminated file name or Z_NULL /\n this.name = '';\n / space at name (only when reading header) /\n // this.name_max = 0;\n / pointer to zero-terminated comment or Z_NULL /\n this.comment = '';\n / space at comment (only when reading header) /\n // this.comm_max = 0;\n / true if there was or will be a header crc /\n this.hcrc = 0;\n / true when done reading gzip header (not used when writing a gzip file) /\n this.done = false;\n}\n\nmodule.exports = GZheader;\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\n// See state defs from inflate.js\nconst BAD = 16209; / got a data error -- remain here until reset /\nconst TYPE = 16191; / i: waiting for type bits, including last-flag bit /\n\n/\n Decode literal, length, and distance codes and write out the resulting\n literal and match bytes until either not enough input or output is\n available, an end-of-block is encountered, or a data error is encountered.\n When large enough input and output buffers are supplied to inflate(), for\n example, a 16K input buffer and a 64K output buffer, more than 95% of the\n inflate execution time is spent in this routine.\n\n Entry assumptions:\n\n state.mode === LEN\n strm.avail_in >= 6\n strm.avail_out >= 258\n start >= strm.avail_out\n state.bits < 8\n\n On return, state.mode is one of:\n\n LEN -- ran out of enough output space or enough available input\n TYPE -- reached end of block code, inflate() to interpret next block\n BAD -- error in block data\n\n Notes:\n\n - The maximum input bits used by a length/distance pair is 15 bits for the\n length code, 5 bits for the length extra, 15 bits for the distance code,\n and 13 bits for the distance extra. This totals 48 bits, or six bytes.\n Therefore if strm.avail_in >= 6, then there is enough input to avoid\n checking for available input while decoding.\n\n - The maximum bytes that a single length/distance pair can output is 258\n bytes, which is the maximum length that can be coded. inflate_fast()\n requires strm.avail_out >= 258 for each loop to avoid checking for\n output space.\n /\nmodule.exports = function inflate_fast(strm, start) {\n let _in; / local strm.input /\n let last; / have enough input while in < last /\n let _out; / local strm.output /\n let beg; / inflate()'s initial strm.output /\n let end; / while out < end, enough space available /\n//#ifdef INFLATE_STRICT\n let dmax; / maximum distance from zlib header /\n//#endif\n let wsize; / window size or zero if not using window /\n let whave; / valid bytes in the window /\n let wnext; / window write index /\n // Use `s_window` instead `window`, avoid conflict with instrumentation tools\n let s_window; / allocated sliding window, if wsize != 0 /\n let hold; / local strm.hold /\n let bits; / local strm.bits /\n let lcode; / local strm.lencode /\n let dcode; / local strm.distcode /\n let lmask; / mask for first level of length codes /\n let dmask; / mask for first level of distance codes /\n let here; / retrieved table entry /\n let op; / code bits, operation, extra bits, or /\n / window position, window bytes to copy /\n let len; / match length, unused bytes /\n let dist; / match distance /\n let from; / where to copy match from /\n let from_source;\n\n\n let input, output; // JS specific, because we have no pointers\n\n / copy state to local variables /\n const state = strm.state;\n //here = state.here;\n _in = strm.next_in;\n input = strm.input;\n last = _in + (strm.avail_in - 5);\n _out = strm.next_out;\n output = strm.output;\n beg = _out - (start - strm.avail_out);\n end = _out + (strm.avail_out - 257);\n//#ifdef INFLATE_STRICT\n dmax = state.dmax;\n//#endif\n wsize = state.wsize;\n whave = state.whave;\n wnext = state.wnext;\n s_window = state.window;\n hold = state.hold;\n bits = state.bits;\n lcode = state.lencode;\n dcode = state.distcode;\n lmask = (1 << state.lenbits) - 1;\n dmask = (1 << state.distbits) - 1;\n\n\n / decode literals and length/distances until end-of-block or not enough\n input data or output space /\n\n top:\n do {\n if (bits < 15) {\n hold += input[_in++] << bits;\n bits += 8;\n hold += input[_in++] << bits;\n bits += 8;\n }\n\n here = lcode[hold & lmask];\n\n dolen:\n for (;;) { // Goto emulation\n op = here >>> 24/here.bits/;\n hold >>>= op;\n bits -= op;\n op = (here >>> 16) & 0xff/here.op/;\n if (op === 0) { / literal /\n //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?\n // \"inflate: literal '%c'\\n\" :\n // \"inflate: literal 0x%02x\\n\", here.val));\n output[_out++] = here & 0xffff/here.val/;\n }\n else if (op & 16) { / length base /\n len = here & 0xffff/here.val/;\n op &= 15; / number of extra bits /\n if (op) {\n if (bits < op) {\n hold += input[_in++] << bits;\n bits += 8;\n }\n len += hold & ((1 << op) - 1);\n hold >>>= op;\n bits -= op;\n }\n //Tracevv((stderr, \"inflate: length %u\\n\", len));\n if (bits < 15) {\n hold += input[_in++] << bits;\n bits += 8;\n hold += input[_in++] << bits;\n bits += 8;\n }\n here = dcode[hold & dmask];\n\n dodist:\n for (;;) { // goto emulation\n op = here >>> 24/here.bits/;\n hold >>>= op;\n bits -= op;\n op = (here >>> 16) & 0xff/here.op/;\n\n if (op & 16) { / distance base /\n dist = here & 0xffff/here.val/;\n op &= 15; / number of extra bits /\n if (bits < op) {\n hold += input[_in++] << bits;\n bits += 8;\n if (bits < op) {\n hold += input[_in++] << bits;\n bits += 8;\n }\n }\n dist += hold & ((1 << op) - 1);\n//#ifdef INFLATE_STRICT\n if (dist > dmax) {\n strm.msg = 'invalid distance too far back';\n state.mode = BAD;\n break top;\n }\n//#endif\n hold >>>= op;\n bits -= op;\n //Tracevv((stderr, \"inflate: distance %u\\n\", dist));\n op = _out - beg; / max distance in output /\n if (dist > op) { / see if copy from window /\n op = dist - op; / distance back in window /\n if (op > whave) {\n if (state.sane) {\n strm.msg = 'invalid distance too far back';\n state.mode = BAD;\n break top;\n }\n\n// (!) This block is disabled in zlib defaults,\n// don't enable it for binary compatibility\n//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR\n// if (len <= op - whave) {\n// do {\n// output[_out++] = 0;\n// } while (--len);\n// continue top;\n// }\n// len -= op - whave;\n// do {\n// output[_out++] = 0;\n// } while (--op > whave);\n// if (op === 0) {\n// from = _out - dist;\n// do {\n// output[_out++] = output[from++];\n// } while (--len);\n// continue top;\n// }\n//#endif\n }\n from = 0; // window index\n from_source = s_window;\n if (wnext === 0) { / very common case /\n from += wsize - op;\n if (op < len) { / some from window /\n len -= op;\n do {\n output[_out++] = s_window[from++];\n } while (--op);\n from = _out - dist; / rest from output /\n from_source = output;\n }\n }\n else if (wnext < op) { / wrap around window /\n from += wsize + wnext - op;\n op -= wnext;\n if (op < len) { / some from end of window /\n len -= op;\n do {\n output[_out++] = s_window[from++];\n } while (--op);\n from = 0;\n if (wnext < len) { / some from start of window /\n op = wnext;\n len -= op;\n do {\n output[_out++] = s_window[from++];\n } while (--op);\n from = _out - dist; / rest from output /\n from_source = output;\n }\n }\n }\n else { / contiguous in window /\n from += wnext - op;\n if (op < len) { / some from window /\n len -= op;\n do {\n output[_out++] = s_window[from++];\n } while (--op);\n from = _out - dist; / rest from output /\n from_source = output;\n }\n }\n while (len > 2) {\n output[_out++] = from_source[from++];\n output[_out++] = from_source[from++];\n output[_out++] = from_source[from++];\n len -= 3;\n }\n if (len) {\n output[_out++] = from_source[from++];\n if (len > 1) {\n output[_out++] = from_source[from++];\n }\n }\n }\n else {\n from = _out - dist; / copy direct from output /\n do { / minimum length is three /\n output[_out++] = output[from++];\n output[_out++] = output[from++];\n output[_out++] = output[from++];\n len -= 3;\n } while (len > 2);\n if (len) {\n output[_out++] = output[from++];\n if (len > 1) {\n output[_out++] = output[from++];\n }\n }\n }\n }\n else if ((op & 64) === 0) { / 2nd level distance code /\n here = dcode[(here & 0xffff)/here.val/ + (hold & ((1 << op) - 1))];\n continue dodist;\n }\n else {\n strm.msg = 'invalid distance code';\n state.mode = BAD;\n break top;\n }\n\n break; // need to emulate goto via \"continue\"\n }\n }\n else if ((op & 64) === 0) { / 2nd level length code /\n here = lcode[(here & 0xffff)/here.val/ + (hold & ((1 << op) - 1))];\n continue dolen;\n }\n else if (op & 32) { / end-of-block /\n //Tracevv((stderr, \"inflate: end of block\\n\"));\n state.mode = TYPE;\n break top;\n }\n else {\n strm.msg = 'invalid literal/length code';\n state.mode = BAD;\n break top;\n }\n\n break; // need to emulate goto via \"continue\"\n }\n } while (_in < last && _out < end);\n\n / return unused bytes (on entry, bits < 8, so in won't go too far back) /\n len = bits >> 3;\n _in -= len;\n bits -= len << 3;\n hold &= (1 << bits) - 1;\n\n / update state and return /\n strm.next_in = _in;\n strm.next_out = _out;\n strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));\n strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));\n state.hold = hold;\n state.bits = bits;\n return;\n};\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nconst adler32 = require('./adler32');\nconst crc32 = require('./crc32');\nconst inflate_fast = require('./inffast');\nconst inflate_table = require('./inftrees');\n\nconst CODES = 0;\nconst LENS = 1;\nconst DISTS = 2;\n\n/ Public constants ==========================================================/\n/ ===========================================================================/\n\nconst {\n Z_FINISH, Z_BLOCK, Z_TREES,\n Z_OK, Z_STREAM_END, Z_NEED_DICT, Z_STREAM_ERROR, Z_DATA_ERROR, Z_MEM_ERROR, Z_BUF_ERROR,\n Z_DEFLATED\n} = require('./constants');\n\n\n/ STATES ====================================================================/\n/ ===========================================================================/\n\n\nconst HEAD = 16180; / i: waiting for magic header /\nconst FLAGS = 16181; / i: waiting for method and flags (gzip) /\nconst TIME = 16182; / i: waiting for modification time (gzip) /\nconst OS = 16183; / i: waiting for extra flags and operating system (gzip) /\nconst EXLEN = 16184; / i: waiting for extra length (gzip) /\nconst EXTRA = 16185; / i: waiting for extra bytes (gzip) /\nconst NAME = 16186; / i: waiting for end of file name (gzip) /\nconst COMMENT = 16187; / i: waiting for end of comment (gzip) /\nconst HCRC = 16188; / i: waiting for header crc (gzip) /\nconst DICTID = 16189; / i: waiting for dictionary check value /\nconst DICT = 16190; / waiting for inflateSetDictionary() call /\nconst TYPE = 16191; / i: waiting for type bits, including last-flag bit /\nconst TYPEDO = 16192; / i: same, but skip check to exit inflate on new block /\nconst STORED = 16193; / i: waiting for stored size (length and complement) /\nconst COPY_ = 16194; / i/o: same as COPY below, but only first time in /\nconst COPY = 16195; / i/o: waiting for input or output to copy stored block /\nconst TABLE = 16196; / i: waiting for dynamic block table lengths /\nconst LENLENS = 16197; / i: waiting for code length code lengths /\nconst CODELENS = 16198; / i: waiting for length/lit and distance code lengths /\nconst LEN_ = 16199; / i: same as LEN below, but only first time in /\nconst LEN = 16200; / i: waiting for length/lit/eob code /\nconst LENEXT = 16201; / i: waiting for length extra bits /\nconst DIST = 16202; / i: waiting for distance code /\nconst DISTEXT = 16203; / i: waiting for distance extra bits /\nconst MATCH = 16204; / o: waiting for output space to copy string /\nconst LIT = 16205; / o: waiting for output space to write literal /\nconst CHECK = 16206; / i: waiting for 32-bit check value /\nconst LENGTH = 16207; / i: waiting for 32-bit length (gzip) /\nconst DONE = 16208; / finished check, done -- remain here until reset /\nconst BAD = 16209; / got a data error -- remain here until reset /\nconst MEM = 16210; / got an inflate() memory error -- remain here until reset /\nconst SYNC = 16211; / looking for synchronization bytes to restart inflate() /\n\n/ ===========================================================================/\n\n\n\nconst ENOUGH_LENS = 852;\nconst ENOUGH_DISTS = 592;\n//const ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);\n\nconst MAX_WBITS = 15;\n/ 32K LZ77 window /\nconst DEF_WBITS = MAX_WBITS;\n\n\nconst zswap32 = (q) => {\n\n return (((q >>> 24) & 0xff) +\n ((q >>> 8) & 0xff00) +\n ((q & 0xff00) << 8) +\n ((q & 0xff) << 24));\n};\n\n\nfunction InflateState() {\n this.strm = null; / pointer back to this zlib stream /\n this.mode = 0; / current inflate mode /\n this.last = false; / true if processing last block /\n this.wrap = 0; / bit 0 true for zlib, bit 1 true for gzip,\n bit 2 true to validate check value /\n this.havedict = false; / true if dictionary provided /\n this.flags = 0; / gzip header method and flags (0 if zlib), or\n -1 if raw or no header yet /\n this.dmax = 0; / zlib header max distance (INFLATE_STRICT) /\n this.check = 0; / protected copy of check value /\n this.total = 0; / protected copy of output count /\n // TODO: may be {}\n this.head = null; / where to save gzip header information /\n\n / sliding window /\n this.wbits = 0; / log base 2 of requested window size /\n this.wsize = 0; / window size or zero if not using window /\n this.whave = 0; / valid bytes in the window /\n this.wnext = 0; / window write index /\n this.window = null; / allocated sliding window, if needed /\n\n / bit accumulator /\n this.hold = 0; / input bit accumulator /\n this.bits = 0; / number of bits in \"in\" /\n\n / for string and stored block copying /\n this.length = 0; / literal or length of data to copy /\n this.offset = 0; / distance back to copy string from /\n\n / for table and code decoding /\n this.extra = 0; / extra bits needed /\n\n / fixed and dynamic code tables /\n this.lencode = null; / starting table for length/literal codes /\n this.distcode = null; / starting table for distance codes /\n this.lenbits = 0; / index bits for lencode /\n this.distbits = 0; / index bits for distcode /\n\n / dynamic table building /\n this.ncode = 0; / number of code length code lengths /\n this.nlen = 0; / number of length code lengths /\n this.ndist = 0; / number of distance code lengths /\n this.have = 0; / number of code lengths in lens[] /\n this.next = null; / next available space in codes[] /\n\n this.lens = new Uint16Array(320); / temporary storage for code lengths /\n this.work = new Uint16Array(288); / work area for code table building /\n\n /\n because we don't have pointers in js, we use lencode and distcode directly\n as buffers so we don't need codes\n /\n //this.codes = new Int32Array(ENOUGH); / space for code tables /\n this.lendyn = null; / dynamic table for length/literal codes (JS specific) /\n this.distdyn = null; / dynamic table for distance codes (JS specific) /\n this.sane = 0; / if false, allow invalid distance too far /\n this.back = 0; / bits back of last unprocessed length/lit /\n this.was = 0; / initial length of match /\n}\n\n\nconst inflateStateCheck = (strm) => {\n\n if (!strm) {\n return 1;\n }\n const state = strm.state;\n if (!state \|\| state.strm !== strm \|\|\n state.mode < HEAD \|\| state.mode > SYNC) {\n return 1;\n }\n return 0;\n};\n\n\nconst inflateResetKeep = (strm) => {\n\n if (inflateStateCheck(strm)) { return Z_STREAM_ERROR; }\n const state = strm.state;\n strm.total_in = strm.total_out = state.total = 0;\n strm.msg = ''; /Z_NULL/\n if (state.wrap) { / to support ill-conceived Java test suite /\n strm.adler = state.wrap & 1;\n }\n state.mode = HEAD;\n state.last = 0;\n state.havedict = 0;\n state.flags = -1;\n state.dmax = 32768;\n state.head = null/Z_NULL/;\n state.hold = 0;\n state.bits = 0;\n //state.lencode = state.distcode = state.next = state.codes;\n state.lencode = state.lendyn = new Int32Array(ENOUGH_LENS);\n state.distcode = state.distdyn = new Int32Array(ENOUGH_DISTS);\n\n state.sane = 1;\n state.back = -1;\n //Tracev((stderr, \"inflate: reset\\n\"));\n return Z_OK;\n};\n\n\nconst inflateReset = (strm) => {\n\n if (inflateStateCheck(strm)) { return Z_STREAM_ERROR; }\n const state = strm.state;\n state.wsize = 0;\n state.whave = 0;\n state.wnext = 0;\n return inflateResetKeep(strm);\n\n};\n\n\nconst inflateReset2 = (strm, windowBits) => {\n let wrap;\n\n / get the state /\n if (inflateStateCheck(strm)) { return Z_STREAM_ERROR; }\n const state = strm.state;\n\n / extract wrap request from windowBits parameter /\n if (windowBits < 0) {\n wrap = 0;\n windowBits = -windowBits;\n }\n else {\n wrap = (windowBits >> 4) + 5;\n if (windowBits < 48) {\n windowBits &= 15;\n }\n }\n\n / set number of window bits, free window if different /\n if (windowBits && (windowBits < 8 \|\| windowBits > 15)) {\n return Z_STREAM_ERROR;\n }\n if (state.window !== null && state.wbits !== windowBits) {\n state.window = null;\n }\n\n / update state and reset the rest of it /\n state.wrap = wrap;\n state.wbits = windowBits;\n return inflateReset(strm);\n};\n\n\nconst inflateInit2 = (strm, windowBits) => {\n\n if (!strm) { return Z_STREAM_ERROR; }\n //strm.msg = Z_NULL; / in case we return an error /\n\n const state = new InflateState();\n\n //if (state === Z_NULL) return Z_MEM_ERROR;\n //Tracev((stderr, \"inflate: allocated\\n\"));\n strm.state = state;\n state.strm = strm;\n state.window = null/Z_NULL/;\n state.mode = HEAD; / to pass state test in inflateReset2() /\n const ret = inflateReset2(strm, windowBits);\n if (ret !== Z_OK) {\n strm.state = null/Z_NULL/;\n }\n return ret;\n};\n\n\nconst inflateInit = (strm) => {\n\n return inflateInit2(strm, DEF_WBITS);\n};\n\n\n/\n Return state with length and distance decoding tables and index sizes set to\n fixed code decoding. Normally this returns fixed tables from inffixed.h.\n If BUILDFIXED is defined, then instead this routine builds the tables the\n first time it's called, and returns those tables the first time and\n thereafter. This reduces the size of the code by about 2K bytes, in\n exchange for a little execution time. However, BUILDFIXED should not be\n used for threaded applications, since the rewriting of the tables and virgin\n may not be thread-safe.\n /\nlet virgin = true;\n\nlet lenfix, distfix; // We have no pointers in JS, so keep tables separate\n\n\nconst fixedtables = (state) => {\n\n / build fixed huffman tables if first call (may not be thread safe) /\n if (virgin) {\n lenfix = new Int32Array(512);\n distfix = new Int32Array(32);\n\n / literal/length table /\n let sym = 0;\n while (sym < 144) { state.lens[sym++] = 8; }\n while (sym < 256) { state.lens[sym++] = 9; }\n while (sym < 280) { state.lens[sym++] = 7; }\n while (sym < 288) { state.lens[sym++] = 8; }\n\n inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });\n\n / distance table /\n sym = 0;\n while (sym < 32) { state.lens[sym++] = 5; }\n\n inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });\n\n / do this just once /\n virgin = false;\n }\n\n state.lencode = lenfix;\n state.lenbits = 9;\n state.distcode = distfix;\n state.distbits = 5;\n};\n\n\n/\n Update the window with the last wsize (normally 32K) bytes written before\n returning. If window does not exist yet, create it. This is only called\n when a window is already in use, or when output has been written during this\n inflate call, but the end of the deflate stream has not been reached yet.\n It is also called to create a window for dictionary data when a dictionary\n is loaded.\n\n Providing output buffers larger than 32K to inflate() should provide a speed\n advantage, since only the last 32K of output is copied to the sliding window\n upon return from inflate(), and since all distances after the first 32K of\n output will fall in the output data, making match copies simpler and faster.\n The advantage may be dependent on the size of the processor's data caches.\n /\nconst updatewindow = (strm, src, end, copy) => {\n\n let dist;\n const state = strm.state;\n\n / if it hasn't been done already, allocate space for the window /\n if (state.window === null) {\n state.wsize = 1 << state.wbits;\n state.wnext = 0;\n state.whave = 0;\n\n state.window = new Uint8Array(state.wsize);\n }\n\n / copy state->wsize or less output bytes into the circular window /\n if (copy >= state.wsize) {\n state.window.set(src.subarray(end - state.wsize, end), 0);\n state.wnext = 0;\n state.whave = state.wsize;\n }\n else {\n dist = state.wsize - state.wnext;\n if (dist > copy) {\n dist = copy;\n }\n //zmemcpy(state->window + state->wnext, end - copy, dist);\n state.window.set(src.subarray(end - copy, end - copy + dist), state.wnext);\n copy -= dist;\n if (copy) {\n //zmemcpy(state->window, end - copy, copy);\n state.window.set(src.subarray(end - copy, end), 0);\n state.wnext = copy;\n state.whave = state.wsize;\n }\n else {\n state.wnext += dist;\n if (state.wnext === state.wsize) { state.wnext = 0; }\n if (state.whave < state.wsize) { state.whave += dist; }\n }\n }\n return 0;\n};\n\n\nconst inflate = (strm, flush) => {\n\n let state;\n let input, output; // input/output buffers\n let next; / next input INDEX /\n let put; / next output INDEX /\n let have, left; / available input and output /\n let hold; / bit buffer /\n let bits; / bits in bit buffer /\n let _in, _out; / save starting available input and output /\n let copy; / number of stored or match bytes to copy /\n let from; / where to copy match bytes from /\n let from_source;\n let here = 0; / current decoding table entry /\n let here_bits, here_op, here_val; // paked \"here\" denormalized (JS specific)\n //let last; / parent table entry /\n let last_bits, last_op, last_val; // paked \"last\" denormalized (JS specific)\n let len; / length to copy for repeats, bits to drop /\n let ret; / return code /\n const hbuf = new Uint8Array(4); / buffer for gzip header crc calculation /\n let opts;\n\n let n; // temporary variable for NEED_BITS\n\n const order = / permutation of code lengths /\n new Uint8Array([ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ]);\n\n\n if (inflateStateCheck(strm) \|\| !strm.output \|\|\n (!strm.input && strm.avail_in !== 0)) {\n return Z_STREAM_ERROR;\n }\n\n state = strm.state;\n if (state.mode === TYPE) { state.mode = TYPEDO; } / skip check /\n\n\n //--- LOAD() ---\n put = strm.next_out;\n output = strm.output;\n left = strm.avail_out;\n next = strm.next_in;\n input = strm.input;\n have = strm.avail_in;\n hold = state.hold;\n bits = state.bits;\n //---\n\n _in = have;\n _out = left;\n ret = Z_OK;\n\n inf_leave: // goto emulation\n for (;;) {\n switch (state.mode) {\n case HEAD:\n if (state.wrap === 0) {\n state.mode = TYPEDO;\n break;\n }\n //=== NEEDBITS(16);\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if ((state.wrap & 2) && hold === 0x8b1f) { / gzip header /\n if (state.wbits === 0) {\n state.wbits = 15;\n }\n state.check = 0/crc32(0L, Z_NULL, 0)/;\n //=== CRC2(state.check, hold);\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n state.check = crc32(state.check, hbuf, 2, 0);\n //===//\n\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = FLAGS;\n break;\n }\n if (state.head) {\n state.head.done = false;\n }\n if (!(state.wrap & 1) \|\| / check if zlib header allowed /\n (((hold & 0xff)/BITS(8)/ << 8) + (hold >> 8)) % 31) {\n strm.msg = 'incorrect header check';\n state.mode = BAD;\n break;\n }\n if ((hold & 0x0f)/BITS(4)/ !== Z_DEFLATED) {\n strm.msg = 'unknown compression method';\n state.mode = BAD;\n break;\n }\n //--- DROPBITS(4) ---//\n hold >>>= 4;\n bits -= 4;\n //---//\n len = (hold & 0x0f)/BITS(4)/ + 8;\n if (state.wbits === 0) {\n state.wbits = len;\n }\n if (len > 15 \|\| len > state.wbits) {\n strm.msg = 'invalid window size';\n state.mode = BAD;\n break;\n }\n\n // !!! pako patch. Force use `options.windowBits` if passed.\n // Required to always use max window size by default.\n state.dmax = 1 << state.wbits;\n //state.dmax = 1 << len;\n\n state.flags = 0; / indicate zlib header /\n //Tracev((stderr, \"inflate: zlib header ok\\n\"));\n strm.adler = state.check = 1/adler32(0L, Z_NULL, 0)/;\n state.mode = hold & 0x200 ? DICTID : TYPE;\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n break;\n case FLAGS:\n //=== NEEDBITS(16); /\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.flags = hold;\n if ((state.flags & 0xff) !== Z_DEFLATED) {\n strm.msg = 'unknown compression method';\n state.mode = BAD;\n break;\n }\n if (state.flags & 0xe000) {\n strm.msg = 'unknown header flags set';\n state.mode = BAD;\n break;\n }\n if (state.head) {\n state.head.text = ((hold >> 8) & 1);\n }\n if ((state.flags & 0x0200) && (state.wrap & 4)) {\n //=== CRC2(state.check, hold);\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n state.check = crc32(state.check, hbuf, 2, 0);\n //===//\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = TIME;\n /* falls through /\n case TIME:\n //=== NEEDBITS(32); /\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if (state.head) {\n state.head.time = hold;\n }\n if ((state.flags & 0x0200) && (state.wrap & 4)) {\n //=== CRC4(state.check, hold)\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n hbuf[2] = (hold >>> 16) & 0xff;\n hbuf[3] = (hold >>> 24) & 0xff;\n state.check = crc32(state.check, hbuf, 4, 0);\n //===\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = OS;\n /* falls through /\n case OS:\n //=== NEEDBITS(16); /\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if (state.head) {\n state.head.xflags = (hold & 0xff);\n state.head.os = (hold >> 8);\n }\n if ((state.flags & 0x0200) && (state.wrap & 4)) {\n //=== CRC2(state.check, hold);\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n state.check = crc32(state.check, hbuf, 2, 0);\n //===//\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = EXLEN;\n /* falls through /\n case EXLEN:\n if (state.flags & 0x0400) {\n //=== NEEDBITS(16); /\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.length = hold;\n if (state.head) {\n state.head.extra_len = hold;\n }\n if ((state.flags & 0x0200) && (state.wrap & 4)) {\n //=== CRC2(state.check, hold);\n hbuf[0] = hold & 0xff;\n hbuf[1] = (hold >>> 8) & 0xff;\n state.check = crc32(state.check, hbuf, 2, 0);\n //===//\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n }\n else if (state.head) {\n state.head.extra = null/Z_NULL/;\n }\n state.mode = EXTRA;\n /* falls through /\n case EXTRA:\n if (state.flags & 0x0400) {\n copy = state.length;\n if (copy > have) { copy = have; }\n if (copy) {\n if (state.head) {\n len = state.head.extra_len - state.length;\n if (!state.head.extra) {\n // Use untyped array for more convenient processing later\n state.head.extra = new Uint8Array(state.head.extra_len);\n }\n state.head.extra.set(\n input.subarray(\n next,\n // extra field is limited to 65536 bytes\n // - no need for additional size check\n next + copy\n ),\n /len + copy > state.head.extra_max - len ? state.head.extra_max : copy,/\n len\n );\n //zmemcpy(state.head.extra + len, next,\n // len + copy > state.head.extra_max ?\n // state.head.extra_max - len : copy);\n }\n if ((state.flags & 0x0200) && (state.wrap & 4)) {\n state.check = crc32(state.check, input, copy, next);\n }\n have -= copy;\n next += copy;\n state.length -= copy;\n }\n if (state.length) { break inf_leave; }\n }\n state.length = 0;\n state.mode = NAME;\n / falls through /\n case NAME:\n if (state.flags & 0x0800) {\n if (have === 0) { break inf_leave; }\n copy = 0;\n do {\n // TODO: 2 or 1 bytes?\n len = input[next + copy++];\n / use constant limit because in js we should not preallocate memory /\n if (state.head && len &&\n (state.length < 65536 /state.head.name_max/)) {\n state.head.name += String.fromCharCode(len);\n }\n } while (len && copy < have);\n\n if ((state.flags & 0x0200) && (state.wrap & 4)) {\n state.check = crc32(state.check, input, copy, next);\n }\n have -= copy;\n next += copy;\n if (len) { break inf_leave; }\n }\n else if (state.head) {\n state.head.name = null;\n }\n state.length = 0;\n state.mode = COMMENT;\n / falls through /\n case COMMENT:\n if (state.flags & 0x1000) {\n if (have === 0) { break inf_leave; }\n copy = 0;\n do {\n len = input[next + copy++];\n / use constant limit because in js we should not preallocate memory /\n if (state.head && len &&\n (state.length < 65536 /state.head.comm_max/)) {\n state.head.comment += String.fromCharCode(len);\n }\n } while (len && copy < have);\n if ((state.flags & 0x0200) && (state.wrap & 4)) {\n state.check = crc32(state.check, input, copy, next);\n }\n have -= copy;\n next += copy;\n if (len) { break inf_leave; }\n }\n else if (state.head) {\n state.head.comment = null;\n }\n state.mode = HCRC;\n / falls through /\n case HCRC:\n if (state.flags & 0x0200) {\n //=== NEEDBITS(16); /\n while (bits < 16) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if ((state.wrap & 4) && hold !== (state.check & 0xffff)) {\n strm.msg = 'header crc mismatch';\n state.mode = BAD;\n break;\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n }\n if (state.head) {\n state.head.hcrc = ((state.flags >> 9) & 1);\n state.head.done = true;\n }\n strm.adler = state.check = 0;\n state.mode = TYPE;\n break;\n case DICTID:\n //=== NEEDBITS(32); /\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n strm.adler = state.check = zswap32(hold);\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = DICT;\n / falls through /\n case DICT:\n if (state.havedict === 0) {\n //--- RESTORE() ---\n strm.next_out = put;\n strm.avail_out = left;\n strm.next_in = next;\n strm.avail_in = have;\n state.hold = hold;\n state.bits = bits;\n //---\n return Z_NEED_DICT;\n }\n strm.adler = state.check = 1/adler32(0L, Z_NULL, 0)/;\n state.mode = TYPE;\n / falls through /\n case TYPE:\n if (flush === Z_BLOCK \|\| flush === Z_TREES) { break inf_leave; }\n / falls through /\n case TYPEDO:\n if (state.last) {\n //--- BYTEBITS() ---//\n hold >>>= bits & 7;\n bits -= bits & 7;\n //---//\n state.mode = CHECK;\n break;\n }\n //=== NEEDBITS(3); /\n while (bits < 3) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.last = (hold & 0x01)/BITS(1)/;\n //--- DROPBITS(1) ---//\n hold >>>= 1;\n bits -= 1;\n //---//\n\n switch ((hold & 0x03)/BITS(2)/) {\n case 0: /* stored block /\n //Tracev((stderr, \"inflate: stored block%s\\n\",\n // state.last ? \" (last)\" : \"\"));\n state.mode = STORED;\n break;\n case 1: / fixed block /\n fixedtables(state);\n //Tracev((stderr, \"inflate: fixed codes block%s\\n\",\n // state.last ? \" (last)\" : \"\"));\n state.mode = LEN_; / decode codes /\n if (flush === Z_TREES) {\n //--- DROPBITS(2) ---//\n hold >>>= 2;\n bits -= 2;\n //---//\n break inf_leave;\n }\n break;\n case 2: / dynamic block /\n //Tracev((stderr, \"inflate: dynamic codes block%s\\n\",\n // state.last ? \" (last)\" : \"\"));\n state.mode = TABLE;\n break;\n case 3:\n strm.msg = 'invalid block type';\n state.mode = BAD;\n }\n //--- DROPBITS(2) ---//\n hold >>>= 2;\n bits -= 2;\n //---//\n break;\n case STORED:\n //--- BYTEBITS() ---// / go to byte boundary /\n hold >>>= bits & 7;\n bits -= bits & 7;\n //---//\n //=== NEEDBITS(32); /\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) {\n strm.msg = 'invalid stored block lengths';\n state.mode = BAD;\n break;\n }\n state.length = hold & 0xffff;\n //Tracev((stderr, \"inflate: stored length %u\\n\",\n // state.length));\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n state.mode = COPY_;\n if (flush === Z_TREES) { break inf_leave; }\n /* falls through /\n case COPY_:\n state.mode = COPY;\n / falls through /\n case COPY:\n copy = state.length;\n if (copy) {\n if (copy > have) { copy = have; }\n if (copy > left) { copy = left; }\n if (copy === 0) { break inf_leave; }\n //--- zmemcpy(put, next, copy); ---\n output.set(input.subarray(next, next + copy), put);\n //---//\n have -= copy;\n next += copy;\n left -= copy;\n put += copy;\n state.length -= copy;\n break;\n }\n //Tracev((stderr, \"inflate: stored end\\n\"));\n state.mode = TYPE;\n break;\n case TABLE:\n //=== NEEDBITS(14); /\n while (bits < 14) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.nlen = (hold & 0x1f)/BITS(5)/ + 257;\n //--- DROPBITS(5) ---//\n hold >>>= 5;\n bits -= 5;\n //---//\n state.ndist = (hold & 0x1f)/BITS(5)/ + 1;\n //--- DROPBITS(5) ---//\n hold >>>= 5;\n bits -= 5;\n //---//\n state.ncode = (hold & 0x0f)/BITS(4)/ + 4;\n //--- DROPBITS(4) ---//\n hold >>>= 4;\n bits -= 4;\n //---//\n//#ifndef PKZIP_BUG_WORKAROUND\n if (state.nlen > 286 \|\| state.ndist > 30) {\n strm.msg = 'too many length or distance symbols';\n state.mode = BAD;\n break;\n }\n//#endif\n //Tracev((stderr, \"inflate: table sizes ok\\n\"));\n state.have = 0;\n state.mode = LENLENS;\n /* falls through /\n case LENLENS:\n while (state.have < state.ncode) {\n //=== NEEDBITS(3);\n while (bits < 3) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.lens[order[state.have++]] = (hold & 0x07);//BITS(3);\n //--- DROPBITS(3) ---//\n hold >>>= 3;\n bits -= 3;\n //---//\n }\n while (state.have < 19) {\n state.lens[order[state.have++]] = 0;\n }\n // We have separate tables & no pointers. 2 commented lines below not needed.\n //state.next = state.codes;\n //state.lencode = state.next;\n // Switch to use dynamic table\n state.lencode = state.lendyn;\n state.lenbits = 7;\n\n opts = { bits: state.lenbits };\n ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);\n state.lenbits = opts.bits;\n\n if (ret) {\n strm.msg = 'invalid code lengths set';\n state.mode = BAD;\n break;\n }\n //Tracev((stderr, \"inflate: code lengths ok\\n\"));\n state.have = 0;\n state.mode = CODELENS;\n / falls through /\n case CODELENS:\n while (state.have < state.nlen + state.ndist) {\n for (;;) {\n here = state.lencode[hold & ((1 << state.lenbits) - 1)];/BITS(state.lenbits)/\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if ((here_bits) <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n if (here_val < 16) {\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n state.lens[state.have++] = here_val;\n }\n else {\n if (here_val === 16) {\n //=== NEEDBITS(here.bits + 2);\n n = here_bits + 2;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n if (state.have === 0) {\n strm.msg = 'invalid bit length repeat';\n state.mode = BAD;\n break;\n }\n len = state.lens[state.have - 1];\n copy = 3 + (hold & 0x03);//BITS(2);\n //--- DROPBITS(2) ---//\n hold >>>= 2;\n bits -= 2;\n //---//\n }\n else if (here_val === 17) {\n //=== NEEDBITS(here.bits + 3);\n n = here_bits + 3;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n len = 0;\n copy = 3 + (hold & 0x07);//BITS(3);\n //--- DROPBITS(3) ---//\n hold >>>= 3;\n bits -= 3;\n //---//\n }\n else {\n //=== NEEDBITS(here.bits + 7);\n n = here_bits + 7;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n len = 0;\n copy = 11 + (hold & 0x7f);//BITS(7);\n //--- DROPBITS(7) ---//\n hold >>>= 7;\n bits -= 7;\n //---//\n }\n if (state.have + copy > state.nlen + state.ndist) {\n strm.msg = 'invalid bit length repeat';\n state.mode = BAD;\n break;\n }\n while (copy--) {\n state.lens[state.have++] = len;\n }\n }\n }\n\n / handle error breaks in while /\n if (state.mode === BAD) { break; }\n\n / check for end-of-block code (better have one) /\n if (state.lens[256] === 0) {\n strm.msg = 'invalid code -- missing end-of-block';\n state.mode = BAD;\n break;\n }\n\n / build code tables -- note: do not change the lenbits or distbits\n values here (9 and 6) without reading the comments in inftrees.h\n concerning the ENOUGH constants, which depend on those values /\n state.lenbits = 9;\n\n opts = { bits: state.lenbits };\n ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);\n // We have separate tables & no pointers. 2 commented lines below not needed.\n // state.next_index = opts.table_index;\n state.lenbits = opts.bits;\n // state.lencode = state.next;\n\n if (ret) {\n strm.msg = 'invalid literal/lengths set';\n state.mode = BAD;\n break;\n }\n\n state.distbits = 6;\n //state.distcode.copy(state.codes);\n // Switch to use dynamic table\n state.distcode = state.distdyn;\n opts = { bits: state.distbits };\n ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);\n // We have separate tables & no pointers. 2 commented lines below not needed.\n // state.next_index = opts.table_index;\n state.distbits = opts.bits;\n // state.distcode = state.next;\n\n if (ret) {\n strm.msg = 'invalid distances set';\n state.mode = BAD;\n break;\n }\n //Tracev((stderr, 'inflate: codes ok\\n'));\n state.mode = LEN_;\n if (flush === Z_TREES) { break inf_leave; }\n / falls through /\n case LEN_:\n state.mode = LEN;\n / falls through /\n case LEN:\n if (have >= 6 && left >= 258) {\n //--- RESTORE() ---\n strm.next_out = put;\n strm.avail_out = left;\n strm.next_in = next;\n strm.avail_in = have;\n state.hold = hold;\n state.bits = bits;\n //---\n inflate_fast(strm, _out);\n //--- LOAD() ---\n put = strm.next_out;\n output = strm.output;\n left = strm.avail_out;\n next = strm.next_in;\n input = strm.input;\n have = strm.avail_in;\n hold = state.hold;\n bits = state.bits;\n //---\n\n if (state.mode === TYPE) {\n state.back = -1;\n }\n break;\n }\n state.back = 0;\n for (;;) {\n here = state.lencode[hold & ((1 << state.lenbits) - 1)]; /BITS(state.lenbits)/\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if (here_bits <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n if (here_op && (here_op & 0xf0) === 0) {\n last_bits = here_bits;\n last_op = here_op;\n last_val = here_val;\n for (;;) {\n here = state.lencode[last_val +\n ((hold & ((1 << (last_bits + last_op)) - 1))/BITS(last.bits + last.op)/ >> last_bits)];\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if ((last_bits + here_bits) <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n //--- DROPBITS(last.bits) ---//\n hold >>>= last_bits;\n bits -= last_bits;\n //---//\n state.back += last_bits;\n }\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n state.back += here_bits;\n state.length = here_val;\n if (here_op === 0) {\n //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?\n // \"inflate: literal '%c'\\n\" :\n // \"inflate: literal 0x%02x\\n\", here.val));\n state.mode = LIT;\n break;\n }\n if (here_op & 32) {\n //Tracevv((stderr, \"inflate: end of block\\n\"));\n state.back = -1;\n state.mode = TYPE;\n break;\n }\n if (here_op & 64) {\n strm.msg = 'invalid literal/length code';\n state.mode = BAD;\n break;\n }\n state.extra = here_op & 15;\n state.mode = LENEXT;\n / falls through /\n case LENEXT:\n if (state.extra) {\n //=== NEEDBITS(state.extra);\n n = state.extra;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.length += hold & ((1 << state.extra) - 1)/BITS(state.extra)/;\n //--- DROPBITS(state.extra) ---//\n hold >>>= state.extra;\n bits -= state.extra;\n //---//\n state.back += state.extra;\n }\n //Tracevv((stderr, \"inflate: length %u\\n\", state.length));\n state.was = state.length;\n state.mode = DIST;\n / falls through /\n case DIST:\n for (;;) {\n here = state.distcode[hold & ((1 << state.distbits) - 1)];/BITS(state.distbits)/\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if ((here_bits) <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n if ((here_op & 0xf0) === 0) {\n last_bits = here_bits;\n last_op = here_op;\n last_val = here_val;\n for (;;) {\n here = state.distcode[last_val +\n ((hold & ((1 << (last_bits + last_op)) - 1))/BITS(last.bits + last.op)/ >> last_bits)];\n here_bits = here >>> 24;\n here_op = (here >>> 16) & 0xff;\n here_val = here & 0xffff;\n\n if ((last_bits + here_bits) <= bits) { break; }\n //--- PULLBYTE() ---//\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n //---//\n }\n //--- DROPBITS(last.bits) ---//\n hold >>>= last_bits;\n bits -= last_bits;\n //---//\n state.back += last_bits;\n }\n //--- DROPBITS(here.bits) ---//\n hold >>>= here_bits;\n bits -= here_bits;\n //---//\n state.back += here_bits;\n if (here_op & 64) {\n strm.msg = 'invalid distance code';\n state.mode = BAD;\n break;\n }\n state.offset = here_val;\n state.extra = (here_op) & 15;\n state.mode = DISTEXT;\n / falls through /\n case DISTEXT:\n if (state.extra) {\n //=== NEEDBITS(state.extra);\n n = state.extra;\n while (bits < n) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n state.offset += hold & ((1 << state.extra) - 1)/BITS(state.extra)/;\n //--- DROPBITS(state.extra) ---//\n hold >>>= state.extra;\n bits -= state.extra;\n //---//\n state.back += state.extra;\n }\n//#ifdef INFLATE_STRICT\n if (state.offset > state.dmax) {\n strm.msg = 'invalid distance too far back';\n state.mode = BAD;\n break;\n }\n//#endif\n //Tracevv((stderr, \"inflate: distance %u\\n\", state.offset));\n state.mode = MATCH;\n / falls through /\n case MATCH:\n if (left === 0) { break inf_leave; }\n copy = _out - left;\n if (state.offset > copy) { / copy from window /\n copy = state.offset - copy;\n if (copy > state.whave) {\n if (state.sane) {\n strm.msg = 'invalid distance too far back';\n state.mode = BAD;\n break;\n }\n// (!) This block is disabled in zlib defaults,\n// don't enable it for binary compatibility\n//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR\n// Trace((stderr, \"inflate.c too far\\n\"));\n// copy -= state.whave;\n// if (copy > state.length) { copy = state.length; }\n// if (copy > left) { copy = left; }\n// left -= copy;\n// state.length -= copy;\n// do {\n// output[put++] = 0;\n// } while (--copy);\n// if (state.length === 0) { state.mode = LEN; }\n// break;\n//#endif\n }\n if (copy > state.wnext) {\n copy -= state.wnext;\n from = state.wsize - copy;\n }\n else {\n from = state.wnext - copy;\n }\n if (copy > state.length) { copy = state.length; }\n from_source = state.window;\n }\n else { / copy from output /\n from_source = output;\n from = put - state.offset;\n copy = state.length;\n }\n if (copy > left) { copy = left; }\n left -= copy;\n state.length -= copy;\n do {\n output[put++] = from_source[from++];\n } while (--copy);\n if (state.length === 0) { state.mode = LEN; }\n break;\n case LIT:\n if (left === 0) { break inf_leave; }\n output[put++] = state.length;\n left--;\n state.mode = LEN;\n break;\n case CHECK:\n if (state.wrap) {\n //=== NEEDBITS(32);\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n // Use '\|' instead of '+' to make sure that result is signed\n hold \|= input[next++] << bits;\n bits += 8;\n }\n //===//\n _out -= left;\n strm.total_out += _out;\n state.total += _out;\n if ((state.wrap & 4) && _out) {\n strm.adler = state.check =\n /UPDATE_CHECK(state.check, put - _out, _out);/\n (state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out));\n\n }\n _out = left;\n // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too\n if ((state.wrap & 4) && (state.flags ? hold : zswap32(hold)) !== state.check) {\n strm.msg = 'incorrect data check';\n state.mode = BAD;\n break;\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n //Tracev((stderr, \"inflate: check matches trailer\\n\"));\n }\n state.mode = LENGTH;\n / falls through /\n case LENGTH:\n if (state.wrap && state.flags) {\n //=== NEEDBITS(32);\n while (bits < 32) {\n if (have === 0) { break inf_leave; }\n have--;\n hold += input[next++] << bits;\n bits += 8;\n }\n //===//\n if ((state.wrap & 4) && hold !== (state.total & 0xffffffff)) {\n strm.msg = 'incorrect length check';\n state.mode = BAD;\n break;\n }\n //=== INITBITS();\n hold = 0;\n bits = 0;\n //===//\n //Tracev((stderr, \"inflate: length matches trailer\\n\"));\n }\n state.mode = DONE;\n / falls through /\n case DONE:\n ret = Z_STREAM_END;\n break inf_leave;\n case BAD:\n ret = Z_DATA_ERROR;\n break inf_leave;\n case MEM:\n return Z_MEM_ERROR;\n case SYNC:\n / falls through /\n default:\n return Z_STREAM_ERROR;\n }\n }\n\n // inf_leave <- here is real place for \"goto inf_leave\", emulated via \"break inf_leave\"\n\n /\n Return from inflate(), updating the total counts and the check value.\n If there was no progress during the inflate() call, return a buffer\n error. Call updatewindow() to create and/or update the window state.\n Note: a memory error from inflate() is non-recoverable.\n /\n\n //--- RESTORE() ---\n strm.next_out = put;\n strm.avail_out = left;\n strm.next_in = next;\n strm.avail_in = have;\n state.hold = hold;\n state.bits = bits;\n //---\n\n if (state.wsize \|\| (_out !== strm.avail_out && state.mode < BAD &&\n (state.mode < CHECK \|\| flush !== Z_FINISH))) {\n if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) {\n state.mode = MEM;\n return Z_MEM_ERROR;\n }\n }\n _in -= strm.avail_in;\n _out -= strm.avail_out;\n strm.total_in += _in;\n strm.total_out += _out;\n state.total += _out;\n if ((state.wrap & 4) && _out) {\n strm.adler = state.check = /UPDATE_CHECK(state.check, strm.next_out - _out, _out);/\n (state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out));\n }\n strm.data_type = state.bits + (state.last ? 64 : 0) +\n (state.mode === TYPE ? 128 : 0) +\n (state.mode === LEN_ \|\| state.mode === COPY_ ? 256 : 0);\n if (((_in === 0 && _out === 0) \|\| flush === Z_FINISH) && ret === Z_OK) {\n ret = Z_BUF_ERROR;\n }\n return ret;\n};\n\n\nconst inflateEnd = (strm) => {\n\n if (inflateStateCheck(strm)) {\n return Z_STREAM_ERROR;\n }\n\n let state = strm.state;\n if (state.window) {\n state.window = null;\n }\n strm.state = null;\n return Z_OK;\n};\n\n\nconst inflateGetHeader = (strm, head) => {\n\n / check state /\n if (inflateStateCheck(strm)) { return Z_STREAM_ERROR; }\n const state = strm.state;\n if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; }\n\n / save header structure /\n state.head = head;\n head.done = false;\n return Z_OK;\n};\n\n\nconst inflateSetDictionary = (strm, dictionary) => {\n const dictLength = dictionary.length;\n\n let state;\n let dictid;\n let ret;\n\n / check state /\n if (inflateStateCheck(strm)) { return Z_STREAM_ERROR; }\n state = strm.state;\n\n if (state.wrap !== 0 && state.mode !== DICT) {\n return Z_STREAM_ERROR;\n }\n\n / check for correct dictionary identifier /\n if (state.mode === DICT) {\n dictid = 1; / adler32(0, null, 0)/\n / dictid = adler32(dictid, dictionary, dictLength); /\n dictid = adler32(dictid, dictionary, dictLength, 0);\n if (dictid !== state.check) {\n return Z_DATA_ERROR;\n }\n }\n / copy dictionary to window using updatewindow(), which will amend the\n existing dictionary if appropriate /\n ret = updatewindow(strm, dictionary, dictLength, dictLength);\n if (ret) {\n state.mode = MEM;\n return Z_MEM_ERROR;\n }\n state.havedict = 1;\n // Tracev((stderr, \"inflate: dictionary set\\n\"));\n return Z_OK;\n};\n\n\nmodule.exports.inflateReset = inflateReset;\nmodule.exports.inflateReset2 = inflateReset2;\nmodule.exports.inflateResetKeep = inflateResetKeep;\nmodule.exports.inflateInit = inflateInit;\nmodule.exports.inflateInit2 = inflateInit2;\nmodule.exports.inflate = inflate;\nmodule.exports.inflateEnd = inflateEnd;\nmodule.exports.inflateGetHeader = inflateGetHeader;\nmodule.exports.inflateSetDictionary = inflateSetDictionary;\nmodule.exports.inflateInfo = 'pako inflate (from Nodeca project)';\n\n/ Not implemented\nmodule.exports.inflateCodesUsed = inflateCodesUsed;\nmodule.exports.inflateCopy = inflateCopy;\nmodule.exports.inflateGetDictionary = inflateGetDictionary;\nmodule.exports.inflateMark = inflateMark;\nmodule.exports.inflatePrime = inflatePrime;\nmodule.exports.inflateSync = inflateSync;\nmodule.exports.inflateSyncPoint = inflateSyncPoint;\nmodule.exports.inflateUndermine = inflateUndermine;\nmodule.exports.inflateValidate = inflateValidate;\n/\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nconst MAXBITS = 15;\nconst ENOUGH_LENS = 852;\nconst ENOUGH_DISTS = 592;\n//const ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);\n\nconst CODES = 0;\nconst LENS = 1;\nconst DISTS = 2;\n\nconst lbase = new Uint16Array([ / Length codes 257..285 base /\n 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,\n 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0\n]);\n\nconst lext = new Uint8Array([ / Length codes 257..285 extra /\n 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,\n 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78\n]);\n\nconst dbase = new Uint16Array([ / Distance codes 0..29 base /\n 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,\n 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,\n 8193, 12289, 16385, 24577, 0, 0\n]);\n\nconst dext = new Uint8Array([ / Distance codes 0..29 extra /\n 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,\n 23, 23, 24, 24, 25, 25, 26, 26, 27, 27,\n 28, 28, 29, 29, 64, 64\n]);\n\nconst inflate_table = (type, lens, lens_index, codes, table, table_index, work, opts) =>\n{\n const bits = opts.bits;\n //here = opts.here; / table entry for duplication /\n\n let len = 0; / a code's length in bits /\n let sym = 0; / index of code symbols /\n let min = 0, max = 0; / minimum and maximum code lengths /\n let root = 0; / number of index bits for root table /\n let curr = 0; / number of index bits for current table /\n let drop = 0; / code bits to drop for sub-table /\n let left = 0; / number of prefix codes available /\n let used = 0; / code entries in table used /\n let huff = 0; / Huffman code /\n let incr; / for incrementing code, index /\n let fill; / index for replicating entries /\n let low; / low bits for current root entry /\n let mask; / mask for low root bits /\n let next; / next available space in table /\n let base = null; / base value table to use /\n// let shoextra; / extra bits table to use /\n let match; / use base and extra for symbol >= match /\n const count = new Uint16Array(MAXBITS + 1); //[MAXBITS+1]; / number of codes of each length /\n const offs = new Uint16Array(MAXBITS + 1); //[MAXBITS+1]; / offsets in table for each length /\n let extra = null;\n\n let here_bits, here_op, here_val;\n\n /\n Process a set of code lengths to create a canonical Huffman code. The\n code lengths are lens[0..codes-1]. Each length corresponds to the\n symbols 0..codes-1. The Huffman code is generated by first sorting the\n symbols by length from short to long, and retaining the symbol order\n for codes with equal lengths. Then the code starts with all zero bits\n for the first code of the shortest length, and the codes are integer\n increments for the same length, and zeros are appended as the length\n increases. For the deflate format, these bits are stored backwards\n from their more natural integer increment ordering, and so when the\n decoding tables are built in the large loop below, the integer codes\n are incremented backwards.\n\n This routine assumes, but does not check, that all of the entries in\n lens[] are in the range 0..MAXBITS. The caller must assure this.\n 1..MAXBITS is interpreted as that code length. zero means that that\n symbol does not occur in this code.\n\n The codes are sorted by computing a count of codes for each length,\n creating from that a table of starting indices for each length in the\n sorted table, and then entering the symbols in order in the sorted\n table. The sorted table is work[], with that space being provided by\n the caller.\n\n The length counts are used for other purposes as well, i.e. finding\n the minimum and maximum length codes, determining if there are any\n codes at all, checking for a valid set of lengths, and looking ahead\n at length counts to determine sub-table sizes when building the\n decoding tables.\n /\n\n / accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) /\n for (len = 0; len <= MAXBITS; len++) {\n count[len] = 0;\n }\n for (sym = 0; sym < codes; sym++) {\n count[lens[lens_index + sym]]++;\n }\n\n / bound code lengths, force root to be within code lengths /\n root = bits;\n for (max = MAXBITS; max >= 1; max--) {\n if (count[max] !== 0) { break; }\n }\n if (root > max) {\n root = max;\n }\n if (max === 0) { / no symbols to code at all /\n //table.op[opts.table_index] = 64; //here.op = (var char)64; / invalid code marker /\n //table.bits[opts.table_index] = 1; //here.bits = (var char)1;\n //table.val[opts.table_index++] = 0; //here.val = (var short)0;\n table[table_index++] = (1 << 24) \| (64 << 16) \| 0;\n\n\n //table.op[opts.table_index] = 64;\n //table.bits[opts.table_index] = 1;\n //table.val[opts.table_index++] = 0;\n table[table_index++] = (1 << 24) \| (64 << 16) \| 0;\n\n opts.bits = 1;\n return 0; / no symbols, but wait for decoding to report error /\n }\n for (min = 1; min < max; min++) {\n if (count[min] !== 0) { break; }\n }\n if (root < min) {\n root = min;\n }\n\n / check for an over-subscribed or incomplete set of lengths /\n left = 1;\n for (len = 1; len <= MAXBITS; len++) {\n left <<= 1;\n left -= count[len];\n if (left < 0) {\n return -1;\n } / over-subscribed /\n }\n if (left > 0 && (type === CODES \|\| max !== 1)) {\n return -1; / incomplete set /\n }\n\n / generate offsets into symbol table for each length for sorting /\n offs[1] = 0;\n for (len = 1; len < MAXBITS; len++) {\n offs[len + 1] = offs[len] + count[len];\n }\n\n / sort symbols by length, by symbol order within each length /\n for (sym = 0; sym < codes; sym++) {\n if (lens[lens_index + sym] !== 0) {\n work[offs[lens[lens_index + sym]]++] = sym;\n }\n }\n\n /\n Create and fill in decoding tables. In this loop, the table being\n filled is at next and has curr index bits. The code being used is huff\n with length len. That code is converted to an index by dropping drop\n bits off of the bottom. For codes where len is less than drop + curr,\n those top drop + curr - len bits are incremented through all values to\n fill the table with replicated entries.\n\n root is the number of index bits for the root table. When len exceeds\n root, sub-tables are created pointed to by the root entry with an index\n of the low root bits of huff. This is saved in low to check for when a\n new sub-table should be started. drop is zero when the root table is\n being filled, and drop is root when sub-tables are being filled.\n\n When a new sub-table is needed, it is necessary to look ahead in the\n code lengths to determine what size sub-table is needed. The length\n counts are used for this, and so count[] is decremented as codes are\n entered in the tables.\n\n used keeps track of how many table entries have been allocated from the\n provided table space. It is checked for LENS and DIST tables against\n the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in\n the initial root table size constants. See the comments in inftrees.h\n for more information.\n\n sym increments through all symbols, and the loop terminates when\n all codes of length max, i.e. all codes, have been processed. This\n routine permits incomplete codes, so another loop after this one fills\n in the rest of the decoding tables with invalid code markers.\n /\n\n /* set up for code type /\n // poor man optimization - use if-else instead of switch,\n // to avoid deopts in old v8\n if (type === CODES) {\n base = extra = work; / dummy value--not used /\n match = 20;\n\n } else if (type === LENS) {\n base = lbase;\n extra = lext;\n match = 257;\n\n } else { / DISTS /\n base = dbase;\n extra = dext;\n match = 0;\n }\n\n / initialize opts for loop /\n huff = 0; / starting code /\n sym = 0; / starting code symbol /\n len = min; / starting code length /\n next = table_index; / current table to fill in /\n curr = root; / current table index bits /\n drop = 0; / current bits to drop from code for index /\n low = -1; / trigger new sub-table when len > root /\n used = 1 << root; / use root table entries /\n mask = used - 1; / mask for comparing low /\n\n / check available table space /\n if ((type === LENS && used > ENOUGH_LENS) \|\|\n (type === DISTS && used > ENOUGH_DISTS)) {\n return 1;\n }\n\n / process all codes and make table entries /\n for (;;) {\n / create table entry /\n here_bits = len - drop;\n if (work[sym] + 1 < match) {\n here_op = 0;\n here_val = work[sym];\n }\n else if (work[sym] >= match) {\n here_op = extra[work[sym] - match];\n here_val = base[work[sym] - match];\n }\n else {\n here_op = 32 + 64; / end of block /\n here_val = 0;\n }\n\n / replicate for those indices with low len bits equal to huff /\n incr = 1 << (len - drop);\n fill = 1 << curr;\n min = fill; / save offset to next table /\n do {\n fill -= incr;\n table[next + (huff >> drop) + fill] = (here_bits << 24) \| (here_op << 16) \| here_val \|0;\n } while (fill !== 0);\n\n / backwards increment the len-bit code huff /\n incr = 1 << (len - 1);\n while (huff & incr) {\n incr >>= 1;\n }\n if (incr !== 0) {\n huff &= incr - 1;\n huff += incr;\n } else {\n huff = 0;\n }\n\n / go to next symbol, update count, len /\n sym++;\n if (--count[len] === 0) {\n if (len === max) { break; }\n len = lens[lens_index + work[sym]];\n }\n\n / create new sub-table if needed /\n if (len > root && (huff & mask) !== low) {\n / if first time, transition to sub-tables /\n if (drop === 0) {\n drop = root;\n }\n\n / increment past last table /\n next += min; / here min is 1 << curr /\n\n / determine length of next table /\n curr = len - drop;\n left = 1 << curr;\n while (curr + drop < max) {\n left -= count[curr + drop];\n if (left <= 0) { break; }\n curr++;\n left <<= 1;\n }\n\n / check for enough space /\n used += 1 << curr;\n if ((type === LENS && used > ENOUGH_LENS) \|\|\n (type === DISTS && used > ENOUGH_DISTS)) {\n return 1;\n }\n\n / point entry in root table to sub-table /\n low = huff & mask;\n /table.op[low] = curr;\n table.bits[low] = root;\n table.val[low] = next - opts.table_index;/\n table[low] = (root << 24) \| (curr << 16) \| (next - table_index) \|0;\n }\n }\n\n / fill in remaining table entry if code is incomplete (guaranteed to have\n at most one remaining entry, since if the code is incomplete, the\n maximum code length that was allowed to get this far is one bit) /\n if (huff !== 0) {\n //table.op[next + huff] = 64; / invalid code marker /\n //table.bits[next + huff] = len - drop;\n //table.val[next + huff] = 0;\n table[next + huff] = ((len - drop) << 24) \| (64 << 16) \|0;\n }\n\n / set return parameters /\n //opts.table_index += used;\n opts.bits = root;\n return 0;\n};\n\n\nmodule.exports = inflate_table;\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nmodule.exports = {\n 2: 'need dictionary', / Z_NEED_DICT 2 /\n 1: 'stream end', / Z_STREAM_END 1 /\n 0: '', / Z_OK 0 /\n '-1': 'file error', / Z_ERRNO (-1) /\n '-2': 'stream error', / Z_STREAM_ERROR (-2) /\n '-3': 'data error', / Z_DATA_ERROR (-3) /\n '-4': 'insufficient memory', / Z_MEM_ERROR (-4) /\n '-5': 'buffer error', / Z_BUF_ERROR (-5) /\n '-6': 'incompatible version' / Z_VERSION_ERROR (-6) /\n};\n","'use strict';\n\n// (C) 1995-2013 Jean-loup Gailly and Mark Adler\n// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n//\n// This software is provided 'as-is', without any express or implied\n// warranty. In no event will the authors be held liable for any damages\n// arising from the use of this software.\n//\n// Permission is granted to anyone to use this software for any purpose,\n// including commercial applications, and to alter it and redistribute it\n// freely, subject to the following restrictions:\n//\n// 1. The origin of this software must not be misrepresented; you must not\n// claim that you wrote the original software. If you use this software\n// in a product, an acknowledgment in the product documentation would be\n// appreciated but is not required.\n// 2. Altered source versions must be plainly marked as such, and must not be\n// misrepresented as being the original software.\n// 3. This notice may not be removed or altered from any source distribution.\n\nfunction ZStream() {\n / next input byte /\n this.input = null; // JS specific, because we have no pointers\n this.next_in = 0;\n / number of bytes available at input /\n this.avail_in = 0;\n / total number of input bytes read so far /\n this.total_in = 0;\n / next output byte should be put there /\n this.output = null; // JS specific, because we have no pointers\n this.next_out = 0;\n / remaining free space at output /\n this.avail_out = 0;\n / total number of bytes output so far /\n this.total_out = 0;\n / last error message, NULL if no error /\n this.msg = ''/Z_NULL/;\n / not visible by applications /\n this.state = null;\n / best guess about the data type: binary or text /\n this.data_type = 2/Z_UNKNOWN/;\n / adler32 value of the uncompressed data /\n this.adler = 0;\n}\n\nmodule.exports = ZStream;\n","module.exports = __WEBPACK_EXTERNAL_MODULE__464__;","module.exports = __WEBPACK_EXTERNAL_MODULE__713__;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this \|\| new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","var scriptUrl;\nif (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + \"\";\nvar document = __webpack_require__.g.document;\nif (!scriptUrl && document) {\n\tif (document.currentScript)\n\t\tscriptUrl = document.currentScript.src;\n\tif (!scriptUrl) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tif(scripts.length) {\n\t\t\tvar i = scripts.length - 1;\n\t\t\twhile (i > -1 && !scriptUrl) scriptUrl = scripts[i--].src;\n\t\t}\n\t}\n}\n// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration\n// or pass an empty string (\"\") and set the __webpack_public_path__ variable from your code to use your own logic.\nif (!scriptUrl) throw new Error(\"Automatic publicPath is not supported in this browser\");\nscriptUrl = scriptUrl.replace(/#.$/, \"\").replace(/\\?.$/, \"\").replace(/\\/[^\\/]+$/, \"/\");\n__webpack_require__.p = scriptUrl;","import { ByteArray } from 'dicom-parser';\n\nexport default function (\n imageFrame: ByteArray,\n colorBuffer: ByteArray,\n useRGBA: boolean\n): void {\n if (imageFrame === undefined) {\n throw new Error('decodeRGB: rgbBuffer must be defined');\n }\n if (imageFrame.length % 3 !== 0) {\n throw new Error(\n `decodeRGB: rgbBuffer length ${imageFrame.length} must be divisible by 3`\n );\n }\n\n const numPixels = imageFrame.length / 3;\n\n let rgbIndex = 0;\n\n let bufferIndex = 0;\n\n if (useRGBA) {\n for (let i = 0; i < numPixels; i++) {\n colorBuffer[bufferIndex++] = imageFrame[rgbIndex++]; // red\n colorBuffer[bufferIndex++] = imageFrame[rgbIndex++]; // green\n colorBuffer[bufferIndex++] = imageFrame[rgbIndex++]; // blue\n colorBuffer[bufferIndex++] = 255; // alpha\n }\n\n return;\n }\n\n // if RGB buffer\n colorBuffer.set(imageFrame);\n}\n","import { ByteArray } from 'dicom-parser';\n\nexport default function (\n imageFrame: ByteArray,\n colorBuffer: ByteArray,\n useRGBA: boolean\n): void {\n if (imageFrame === undefined) {\n throw new Error('decodeRGB: rgbBuffer must be defined');\n }\n if (imageFrame.length % 3 !== 0) {\n throw new Error(\n `decodeRGB: rgbBuffer length ${imageFrame.length} must be divisible by 3`\n );\n }\n\n const numPixels = imageFrame.length / 3;\n\n let bufferIndex = 0;\n\n let rIndex = 0;\n\n let gIndex = numPixels;\n\n let bIndex = numPixels 2;\n\n if (useRGBA) {\n for (let i = 0; i < numPixels; i++) {\n colorBuffer[bufferIndex++] = imageFrame[rIndex++]; // red\n colorBuffer[bufferIndex++] = imageFrame[gIndex++]; // green\n colorBuffer[bufferIndex++] = imageFrame[bIndex++]; // blue\n colorBuffer[bufferIndex++] = 255; // alpha\n }\n } else {\n for (let i = 0; i < numPixels; i++) {\n colorBuffer[bufferIndex++] = imageFrame[rIndex++]; // red\n colorBuffer[bufferIndex++] = imageFrame[gIndex++]; // green\n colorBuffer[bufferIndex++] = imageFrame[bIndex++]; // blue\n }\n }\n}\n","import { ByteArray } from 'dicom-parser';\n\nexport default function (\n imageFrame: ByteArray,\n colorBuffer: ByteArray,\n useRGBA: boolean\n): void {\n if (imageFrame === undefined) {\n throw new Error('convertYBRFullByPixel: ybrBuffer must be defined');\n }\n if (imageFrame.length % 3 !== 0) {\n throw new Error(\n `convertYBRFullByPixel: ybrBuffer length ${imageFrame.length} must be divisible by 3`\n );\n }\n\n const numPixels = imageFrame.length / 3;\n\n let ybrIndex = 0;\n\n let bufferIndex = 0;\n\n if (useRGBA) {\n for (let i = 0; i < numPixels; i++) {\n const y = imageFrame[ybrIndex++];\n const cb = imageFrame[ybrIndex++];\n const cr = imageFrame[ybrIndex++];\n\n colorBuffer[bufferIndex++] = y + 1.402 * (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y + 1.772 * (cb - 128); // blue\n colorBuffer[bufferIndex++] = 255; // alpha\n }\n\n return;\n }\n\n for (let i = 0; i < numPixels; i++) {\n const y = imageFrame[ybrIndex++];\n const cb = imageFrame[ybrIndex++];\n const cr = imageFrame[ybrIndex++];\n\n colorBuffer[bufferIndex++] = y + 1.402 * (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y + 1.772 * (cb - 128); // blue\n }\n}\n","import { ByteArray } from 'dicom-parser';\n\nexport default function (\n imageFrame: ByteArray,\n colorBuffer: ByteArray,\n useRGBA: boolean\n): void {\n if (imageFrame === undefined) {\n throw new Error('convertYBRFullByPlane: ybrBuffer must be defined');\n }\n if (imageFrame.length % 3 !== 0) {\n throw new Error(\n `convertYBRFullByPlane: ybrBuffer length ${imageFrame.length} must be divisible by 3`\n );\n }\n\n const numPixels = imageFrame.length / 3;\n\n let bufferIndex = 0;\n\n let yIndex = 0;\n\n let cbIndex = numPixels;\n\n let crIndex = numPixels * 2;\n\n if (useRGBA) {\n for (let i = 0; i < numPixels; i++) {\n const y = imageFrame[yIndex++];\n const cb = imageFrame[cbIndex++];\n const cr = imageFrame[crIndex++];\n\n colorBuffer[bufferIndex++] = y + 1.402 * (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y + 1.772 * (cb - 128); // blue\n colorBuffer[bufferIndex++] = 255; // alpha\n }\n\n return;\n }\n\n for (let i = 0; i < numPixels; i++) {\n const y = imageFrame[yIndex++];\n const cb = imageFrame[cbIndex++];\n const cr = imageFrame[crIndex++];\n\n colorBuffer[bufferIndex++] = y + 1.402 * (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y + 1.772 * (cb - 128); // blue\n }\n}\n","import { WADORSMetaDataElement } from '../../../types';\n\n/*\n Returns the raw value\n \n @param element - The javascript object for the specified element in the metadata\n * @param [index] - the index of the value in a multi-valued element, default is 0\n * @param [defaultValue] - The default value to return if the element does not exist\n * @returns {}\n /\nfunction getValue<ReturnType = unknown>(\n element: WADORSMetaDataElement,\n index?: number,\n defaultValue?: ReturnType\n): ReturnType {\n index = index \|\| 0;\n if (!element) {\n return defaultValue;\n }\n // Value is not present if the attribute has a zero length value\n if (!element.Value) {\n return defaultValue;\n }\n // make sure we have the specified index\n if ((element.Value as any).length <= index) {\n return defaultValue;\n }\n\n return element.Value[index];\n}\n\nexport default getValue;\n","import { WADORSMetaDataElement } from '../../../types';\nimport getValue from './getValue';\n\n/*\n Returns the first string value as a Javascript number\n \n @param element - The javascript object for the specified element in the metadata\n * @param [index] - the index of the value in a multi-valued element, default is 0\n * @param [defaultValue] - The default value to return if the element does not exist\n * @returns {}\n /\nfunction getNumberString(\n element: WADORSMetaDataElement,\n index: number,\n defaultValue: number\n): number {\n const value = getValue<any>(element, index, defaultValue);\n\n if (value === undefined) {\n return;\n }\n\n return parseFloat(value);\n}\n\nexport default getNumberString;\n","import { WADORSMetaDataElement } from '../../../types';\nimport getValue from './getValue';\n\nfunction getNumberValue(\n element: WADORSMetaDataElement,\n index?: number\n): number {\n const value = getValue<any>(element, index);\n\n if (value === undefined) {\n return;\n }\n\n return parseFloat(value);\n}\n\nexport default getNumberValue;\n","import { WADORSMetaDataElement } from '../../../types';\n\n/*\n Returns the values as an array of javascript numbers\n \n @param element - The javascript object for the specified element in the metadata\n * @param [minimumLength] - the minimum number of values\n * @returns {}\n /\nfunction getNumberValues(\n element: WADORSMetaDataElement,\n minimumLength?: number\n): number[] {\n if (!element) {\n return;\n }\n // Value is not present if the attribute has a zero length value\n if (!element.Value) {\n return;\n }\n // Make sure the Value is an array\n if (!Array.isArray(element.Value)) {\n return;\n }\n // make sure we have the expected length\n if (minimumLength && element.Value.length < minimumLength) {\n return;\n }\n\n const values: number[] = [];\n\n for (let i = 0; i < element.Value.length; i++) {\n // @ts-expect-error\n values.push(parseFloat(element.Value[i]));\n }\n\n return values;\n}\n\nexport default getNumberValues;\n","/*\n Removes the data loader scheme from the imageId\n \n @param {string} imageId Image ID\n * @returns {string} imageId without the data loader scheme\n * @memberof Cache\n /\nexport default function imageIdToURI(imageId: string): string {\n const colonIndex = imageId.indexOf(':');\n\n return imageId.substring(colonIndex + 1);\n}\n","export default function getTagValue(tag, justElement = true) {\n if (tag && tag.Value) {\n if (tag.Value[0] && justElement) {\n return tag.Value[0];\n }\n\n return tag.Value;\n }\n\n return tag;\n}\n","import getTagValue from './getTagValue';\n\nfunction getFrameInformation(\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n frameNumber\n) {\n const shared = (\n SharedFunctionalGroupsSequence\n ? Object.values(SharedFunctionalGroupsSequence[0])\n : []\n )\n .map((it) => it[0])\n .filter((it) => it !== undefined && typeof it === 'object');\n const perFrame = (\n PerFrameFunctionalGroupsSequence\n ? Object.values(PerFrameFunctionalGroupsSequence[frameNumber - 1])\n : []\n )\n .map((it: any) => it.Value[0])\n .filter((it) => it !== undefined && typeof it === 'object');\n\n return {\n shared,\n perFrame,\n };\n}\n\nfunction getMultiframeInformation(metaData) {\n let {\n 52009230: PerFrameFunctionalGroupsSequence,\n 52009229: SharedFunctionalGroupsSequence,\n '00280008': NumberOfFrames,\n // eslint-disable-next-line prefer-const\n ...rest\n } = metaData;\n\n PerFrameFunctionalGroupsSequence = getTagValue(\n PerFrameFunctionalGroupsSequence,\n false\n );\n SharedFunctionalGroupsSequence = getTagValue(\n SharedFunctionalGroupsSequence,\n false\n );\n NumberOfFrames = getTagValue(NumberOfFrames);\n\n return {\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n NumberOfFrames,\n rest,\n };\n}\n// function that retrieves specific frame metadata information from multiframe\n// metadata\nfunction combineFrameInstance(frameNumber, instance) {\n const {\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n NumberOfFrames,\n rest,\n } = getMultiframeInformation(instance);\n\n if (PerFrameFunctionalGroupsSequence \|\| NumberOfFrames > 1) {\n const { shared, perFrame } = getFrameInformation(\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n frameNumber\n );\n\n const newInstance = Object.assign(instance, { frameNumber });\n\n // merge the shared first then the per frame to override\n [...shared, ...perFrame].forEach((item) => {\n Object.entries(item).forEach(([key, value]) => {\n newInstance[key] = value;\n });\n });\n\n return Object.assign(rest, { '00280008': NumberOfFrames }, newInstance);\n }\n\n return instance;\n}\n\nexport { combineFrameInstance, getMultiframeInformation, getFrameInformation };\n","import getValue from './metaData/getValue';\nimport imageIdToURI from '../imageIdToURI';\nimport { metadataByImageURI } from './metaDataManager';\n\n// get metadata information for the first frame\nfunction _retrieveMultiframeMetadata(imageURI) {\n const lastSlashIdx = imageURI.indexOf('/frames/') + 8;\n // imageid string without frame number\n const imageIdFrameless = imageURI.slice(0, lastSlashIdx);\n // calculating frame number\n const frame = parseInt(imageURI.slice(lastSlashIdx), 10);\n // retrieving the frame 1 that contains multiframe information\n\n const metadata = metadataByImageURI[`${imageIdFrameless}1`];\n\n return {\n metadata,\n frame,\n };\n}\n\nfunction retrieveMultiframeMetadata(imageId) {\n const imageURI = imageIdToURI(imageId);\n\n return _retrieveMultiframeMetadata(imageURI);\n}\n\nfunction isMultiframe(metadata) {\n // Checks if dicomTag NumberOf Frames exists and it is greater than one\n const numberOfFrames = getValue<number>(metadata['00280008']);\n\n return numberOfFrames && numberOfFrames > 1;\n}\n\nexport default {\n _retrieveMultiframeMetadata,\n retrieveMultiframeMetadata,\n isMultiframe,\n};\n","import { WADORSMetaData } from '../../types';\nimport imageIdToURI from '../imageIdToURI';\nimport { combineFrameInstance } from './combineFrameInstance';\nimport multiframeMetadata from './retrieveMultiframeMetadata';\n\nlet metadataByImageURI = [];\nlet multiframeMetadataByImageURI = {};\n\nfunction add(imageId: string, metadata: WADORSMetaData) {\n const imageURI = imageIdToURI(imageId);\n\n // @ts-ignore\n metadata.isMultiframe = multiframeMetadata.isMultiframe(metadata);\n\n metadataByImageURI[imageURI] = metadata;\n}\n\n// multiframes images will have only one imageId returned by the dicomweb\n// client and registered in metadataByImageURI for all the n frames. If an\n// imageId does not have metadata, or it does not have at all, or the imageID\n// belongs to a frame, not registered in metadataByImageURI\nfunction get(imageId: string): WADORSMetaData {\n const imageURI = imageIdToURI(imageId);\n\n // Check if the metadata is already available\n const metadata = metadataByImageURI[imageURI];\n\n if (metadata && !metadata?.isMultiframe) {\n // Return the metadata for single-frame images\n return metadata;\n }\n\n const cachedMetadata = multiframeMetadataByImageURI[imageURI];\n\n if (cachedMetadata) {\n return cachedMetadata;\n }\n\n // Try to get the metadata for a specific frame of a multiframe image\n const retrievedMetadata =\n multiframeMetadata._retrieveMultiframeMetadata(imageURI);\n\n if (!retrievedMetadata \|\| !retrievedMetadata.metadata) {\n return;\n }\n\n const { metadata: firstFrameMetadata, frame } = retrievedMetadata;\n\n if (firstFrameMetadata) {\n // Combine the metadata from the first frame with the metadata from the specified frame\n const combined = combineFrameInstance(frame, firstFrameMetadata);\n\n multiframeMetadataByImageURI[imageURI] = combined;\n\n return combined;\n }\n}\n\nfunction remove(imageId) {\n const imageURI = imageIdToURI(imageId);\n\n metadataByImageURI[imageURI] = undefined;\n\n multiframeMetadataByImageURI[imageURI] = undefined;\n}\n\nfunction purge() {\n metadataByImageURI = [];\n multiframeMetadataByImageURI = {};\n}\n\nexport { metadataByImageURI };\n\nexport default {\n add,\n get,\n remove,\n purge,\n};\n","export default function isNMReconstructable(imageSubType) {\n return imageSubType === 'RECON TOMO' \|\| imageSubType === 'RECON GATED TOMO';\n}\n","import getTagValue from '../getTagValue';\nimport getValue from './getValue';\nimport isNMReconstructable from '../../isNMReconstructable';\nimport getNumberValues from './getNumberValues';\n\nfunction isNMModality(metaData) {\n const modality = getValue(metaData['00080060']);\n\n return modality.includes('NM');\n}\n\n/\n Get a subpart of Image Type dicom tag defined by index\n * @param {} metaData\n @param {} index 0 based index of the subtype\n /\nfunction getImageTypeSubItemFromMetadata(metaData, index) {\n const imageType = getTagValue(metaData['00080008'], false);\n\n if (imageType) {\n // const subTypes = imageType.split('\\\\');\n\n // if (subTypes.length > index) {\n // return subTypes[index];\n // }\n return imageType[index];\n }\n\n return undefined;\n}\n/*\n Extracts the orientation from NM multiframe metadata, if image type\n * equal to RECON TOMO or RECON GATED TOMO\n * @param {} metaData\n @returns\n /\nfunction extractOrientationFromNMMultiframeMetadata(metaData) {\n let imageOrientationPatient;\n const imageSubType = getImageTypeSubItemFromMetadata(metaData, 2);\n\n if (imageSubType && isNMReconstructable(imageSubType)) {\n const detectorInformationSequence = getTagValue(metaData['00540022']);\n\n if (detectorInformationSequence) {\n imageOrientationPatient = getNumberValues(\n detectorInformationSequence['00200037'],\n 6\n );\n }\n }\n\n return imageOrientationPatient;\n}\n\n/\n Extracts the position from NM multiframe dataset, if image type\n * equal to RECON TOMO or RECON GATED TOMO\n * @param {} metaData\n @returns\n /\nfunction extractPositionFromNMMultiframeMetadata(metaData) {\n let imagePositionPatient;\n const imageSubType = getImageTypeSubItemFromMetadata(metaData, 2);\n\n if (imageSubType && isNMReconstructable(imageSubType)) {\n const detectorInformationSequence = getTagValue(metaData['00540022']);\n\n if (detectorInformationSequence) {\n imagePositionPatient = getNumberValues(\n detectorInformationSequence['00200032'],\n 3\n );\n }\n }\n\n return imagePositionPatient;\n}\n\nexport {\n extractOrientationFromNMMultiframeMetadata,\n extractPositionFromNMMultiframeMetadata,\n isNMModality,\n getImageTypeSubItemFromMetadata,\n};\n","import getNumberValues from './getNumberValues';\nimport {\n extractOrientationFromNMMultiframeMetadata,\n extractPositionFromNMMultiframeMetadata,\n isNMModality,\n} from './NMHelpers';\n\n/\n Extract orientation information from a metadata. It tries to get the orientation\n * from the Detector Information Sequence (for NM images) if image type equal\n * to RECON TOMO or RECON GATED TOMO\n * @param {} metaData\n @returns\n /\nfunction extractOrientationFromMetadata(metaData) {\n let imageOrientationPatient = getNumberValues(metaData['00200037'], 6);\n\n // If orientation not valid to this point, trying to get the orientation\n // from the Detector Information Sequence (for NM images) with image type\n // equal to RECON TOMO or RECON GATED TOMO\n\n if (!imageOrientationPatient && isNMModality(metaData)) {\n imageOrientationPatient =\n extractOrientationFromNMMultiframeMetadata(metaData);\n }\n\n return imageOrientationPatient;\n}\n\n/\n Extract position information from a metaData. It tries to get the position\n * from the Detector Information Sequence (for NM images) if image type equal\n * to RECON TOMO or RECON GATED TOMO\n * @param {} metaData\n @returns\n /\nfunction extractPositionFromMetadata(metaData) {\n let imagePositionPatient = getNumberValues(metaData['00200032'], 3);\n\n // If position not valid to this point, trying to get the position\n // from the Detector Information Sequence (for NM images)\n if (!imagePositionPatient && isNMModality(metaData)) {\n imagePositionPatient = extractPositionFromNMMultiframeMetadata(metaData);\n }\n\n return imagePositionPatient;\n}\n\nexport { extractOrientationFromMetadata, extractPositionFromMetadata };\n","/\n Retrieves metadata from a DICOM image and returns it as an object with capitalized keys.\n * @param imageId - the imageId\n * @param metaDataProvider - The metadata provider either wadors or wadouri\n * @param types - An array of metadata types to retrieve.\n * @returns An object containing the retrieved metadata with capitalized keys.\n /\nfunction getInstanceModule(\n imageId: string,\n metaDataProvider: any,\n types: string[]\n): object;\nfunction getInstanceModule(imageId, metaDataProvider, types) {\n const result = {};\n for (const t of types) {\n try {\n const data = metaDataProvider(t, imageId);\n if (data) {\n const capitalizedData = {};\n for (const key in data) {\n if (key in data) {\n // each tag should get capitalized to match dcmjs style. Todo: move all of the tags to dcmjs style\n const capitalizedKey = capitalizeTag(key);\n capitalizedData[capitalizedKey] = data[key];\n }\n }\n Object.assign(result, capitalizedData);\n }\n } catch (error) {\n console.error(`Error retrieving ${t} data:`, error);\n }\n }\n\n return result;\n}\n\nconst capitalizeTag = (tag: string) =>\n tag.charAt(0).toUpperCase() + tag.slice(1);\n\nconst instanceModuleNames = [\n 'multiframeModule',\n 'generalSeriesModule',\n 'patientStudyModule',\n 'imagePlaneModule',\n 'nmMultiframeGeometryModule',\n 'imagePixelModule',\n 'modalityLutModule',\n 'voiLutModule',\n 'sopCommonModule',\n 'petIsotopeModule',\n 'overlayPlaneModule',\n 'transferSyntax',\n 'petSeriesModule',\n 'petImageModule',\n];\n\nexport { getInstanceModule, instanceModuleNames };\n","import getNumberValues from './getNumberValues';\n\n/\n This helper function retrieves the first number value from the provided sequence for the given key.\n * @param sequence - The sequence from which to retrieve the number value.\n * @param key - The key for which to retrieve the number value.\n * @returns The first number value for the given key, or null if no value is found.\n /\nfunction getFirstNumberValue(sequence: any, key: string): number \| null {\n const values = getNumberValues(sequence[key]);\n return values ? values[0] : null;\n}\n\nexport { getFirstNumberValue };\n","import { WADORSMetaDataElement } from 'dicomImageLoader/src/types';\n\nfunction getSequenceItems(element: any): WADORSMetaDataElement[] {\n // Value is not present if the attribute has a zero length value\n if (!element?.Value?.length) {\n return [];\n }\n\n if (!Array.isArray(element.Value)) {\n // If the Value is an object, encapsulate it in an array and log a warning message\n if (typeof element.Value === 'object') {\n console.warn(\n 'Warning: Value should be an array, but an object was found. Encapsulating the object in an array.'\n );\n return [element.Value];\n }\n return [];\n }\n return element.Value;\n}\n\nexport default getSequenceItems;\n","import { getFirstNumberValue } from './getFirstNumberValue';\nimport getSequenceItems from './getSequenceItems';\n\n/\n This function retrieves the ultrasound regions from the provided metadata.\n * @param metadata - The metadata from which to retrieve the ultrasound regions.\n * @returns An array of ultrasound regions, or null if no regions are found.\n /\nfunction getUSEnhancedRegions(metadata) {\n const sequenceOfUltrasoundRegions = getSequenceItems(metadata['00186011']);\n\n if (!sequenceOfUltrasoundRegions \|\| !sequenceOfUltrasoundRegions.length) {\n return null;\n }\n\n const regions = sequenceOfUltrasoundRegions.map((sequence) => {\n const physicalDeltaX = getFirstNumberValue(sequence, '0018602C');\n const physicalDeltaY = getFirstNumberValue(sequence, '0018602E');\n const physicalUnitsXDirection = getFirstNumberValue(sequence, '00186024');\n const physicalUnitsYDirection = getFirstNumberValue(sequence, '00186026');\n\n const regionLocationMinY0 = getFirstNumberValue(sequence, '0018601A');\n const regionLocationMaxY1 = getFirstNumberValue(sequence, '0018601E');\n const regionLocationMinX0 = getFirstNumberValue(sequence, '00186018');\n const regionLocationMaxX1 = getFirstNumberValue(sequence, '0018601C');\n const referencePixelX0 = getFirstNumberValue(sequence, '00186020');\n const referencePixelY0 = getFirstNumberValue(sequence, '00186022');\n\n const referencePhysicalPixelValueY = getFirstNumberValue(\n sequence,\n '0018602A'\n );\n const referencePhysicalPixelValueX = getFirstNumberValue(\n sequence,\n '00186028'\n );\n const regionSpatialFormat = getFirstNumberValue(sequence, '00186012');\n\n const regionDataType = getFirstNumberValue(sequence, '00186014');\n const regionFlags = getFirstNumberValue(sequence, '00186016');\n const transducerFrequency = getFirstNumberValue(sequence, '00186030');\n\n return {\n regionLocationMinY0,\n regionLocationMaxY1,\n regionLocationMinX0,\n regionLocationMaxX1,\n referencePixelX0,\n referencePixelY0,\n physicalDeltaX,\n physicalDeltaY,\n physicalUnitsXDirection,\n physicalUnitsYDirection,\n referencePhysicalPixelValueY,\n referencePhysicalPixelValueX,\n regionSpatialFormat,\n regionDataType,\n regionFlags,\n transducerFrequency,\n };\n });\n\n return regions;\n}\nexport { getUSEnhancedRegions };\n","import external from '../../../externalModules';\nimport getNumberValues from './getNumberValues';\nimport getNumberValue from './getNumberValue';\nimport getOverlayPlaneModule from './getOverlayPlaneModule';\nimport metaDataManager from '../metaDataManager';\nimport getValue from './getValue';\nimport {\n getMultiframeInformation,\n getFrameInformation,\n} from '../combineFrameInstance';\nimport multiframeMetadata from '../retrieveMultiframeMetadata';\nimport {\n extractOrientationFromMetadata,\n extractPositionFromMetadata,\n} from './extractPositioningFromMetadata';\nimport { getImageTypeSubItemFromMetadata } from './NMHelpers';\nimport isNMReconstructable from '../../isNMReconstructable';\nimport {\n getInstanceModule,\n instanceModuleNames,\n} from '../../getInstanceModule';\nimport { getUSEnhancedRegions } from './USHelpers';\n\nfunction metaDataProvider(type, imageId) {\n const { MetadataModules } = external.cornerstone.Enums;\n const { dicomParser } = external;\n\n if (type === MetadataModules.MULTIFRAME) {\n // the get function removes the PerFrameFunctionalGroupsSequence\n const { metadata, frame } =\n multiframeMetadata.retrieveMultiframeMetadata(imageId);\n\n if (!metadata) {\n return;\n }\n const {\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n NumberOfFrames,\n } = getMultiframeInformation(metadata);\n\n if (PerFrameFunctionalGroupsSequence \|\| NumberOfFrames > 1) {\n const { shared, perFrame } = getFrameInformation(\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n frame\n );\n\n return {\n NumberOfFrames,\n //PerFrameFunctionalGroupsSequence,\n PerFrameFunctionalInformation: perFrame,\n SharedFunctionalInformation: shared,\n };\n }\n\n return {\n NumberOfFrames,\n //PerFrameFunctionalGroupsSequence,\n };\n }\n\n const metaData = metaDataManager.get(imageId);\n\n if (!metaData) {\n return;\n }\n\n if (type === MetadataModules.GENERAL_STUDY) {\n return {\n studyDescription: getValue<string>(metaData['00081030']),\n studyDate: dicomParser.parseDA(getValue<string>(metaData['00080020'])),\n studyTime: dicomParser.parseTM(\n getValue<string>(metaData['00080030'], 0, '')\n ),\n accessionNumber: getValue<string>(metaData['00080050']),\n };\n }\n\n if (type === MetadataModules.GENERAL_SERIES) {\n return {\n modality: getValue<string>(metaData['00080060']),\n seriesInstanceUID: getValue<string>(metaData['0020000E']),\n seriesNumber: getNumberValue(metaData['00200011']),\n studyInstanceUID: getValue<string>(metaData['0020000D']),\n seriesDate: dicomParser.parseDA(getValue<string>(metaData['00080021'])),\n seriesTime: dicomParser.parseTM(\n getValue<string>(metaData['00080031'], 0, '')\n ),\n acquisitionDate: dicomParser.parseDA(\n getValue<string>(metaData['00080022'])\n ),\n acquisitionTime: dicomParser.parseTM(\n getValue<string>(metaData['00080032'], 0, '')\n ),\n };\n }\n\n if (type === MetadataModules.GENERAL_IMAGE) {\n return {\n sopInstanceUID: getValue<string>(metaData['00080018']),\n instanceNumber: getNumberValue(metaData['00200013']),\n lossyImageCompression: getValue<string>(metaData['00282110']),\n lossyImageCompressionRatio: getNumberValue(metaData['00282112']),\n lossyImageCompressionMethod: getValue<string>(metaData['00282114']),\n };\n }\n\n if (type === MetadataModules.PATIENT) {\n return {\n patientID: getValue<string>(metaData['00100020']),\n patientName: getValue<string>(metaData['00100010']),\n };\n }\n\n if (type === MetadataModules.PATIENT_STUDY) {\n return {\n patientAge: getNumberValue(metaData['00101010']),\n patientSize: getNumberValue(metaData['00101020']),\n patientSex: getValue<'M' \| 'F'>(metaData['00100040']),\n patientWeight: getNumberValue(metaData['00101030']),\n };\n }\n\n if (type === MetadataModules.NM_MULTIFRAME_GEOMETRY) {\n const modality = getValue(metaData['00080060']);\n const imageSubType = getImageTypeSubItemFromMetadata(metaData, 2);\n\n return {\n modality,\n imageType: getValue(metaData['00080008']),\n imageSubType,\n imageOrientationPatient: extractOrientationFromMetadata(metaData),\n imagePositionPatient: extractPositionFromMetadata(metaData),\n sliceThickness: getNumberValue(metaData['00180050']),\n spacingBetweenSlices: getNumberValue(metaData['00180088']),\n pixelSpacing: getNumberValues(metaData['00280030'], 2),\n numberOfFrames: getNumberValue(metaData['00280008']),\n isNMReconstructable:\n isNMReconstructable(imageSubType) && modality.includes('NM'),\n };\n }\n\n if (type === MetadataModules.IMAGE_PLANE) {\n //metaData = fixNMMetadata(metaData);\n const imageOrientationPatient = extractOrientationFromMetadata(metaData);\n const imagePositionPatient = extractPositionFromMetadata(metaData);\n const pixelSpacing = getNumberValues(metaData['00280030'], 2);\n\n let columnPixelSpacing = null;\n\n let rowPixelSpacing = null;\n\n if (pixelSpacing) {\n rowPixelSpacing = pixelSpacing[0];\n columnPixelSpacing = pixelSpacing[1];\n }\n\n let rowCosines = null;\n\n let columnCosines = null;\n\n if (imageOrientationPatient) {\n rowCosines = [\n // @ts-expect-error\n parseFloat(imageOrientationPatient[0]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[1]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[2]),\n ];\n columnCosines = [\n // @ts-expect-error\n parseFloat(imageOrientationPatient[3]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[4]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[5]),\n ];\n }\n\n return {\n frameOfReferenceUID: getValue<string>(metaData['00200052']),\n rows: getNumberValue(metaData['00280010']),\n columns: getNumberValue(metaData['00280011']),\n imageOrientationPatient,\n rowCosines,\n columnCosines,\n imagePositionPatient,\n sliceThickness: getNumberValue(metaData['00180050']),\n sliceLocation: getNumberValue(metaData['00201041']),\n pixelSpacing,\n rowPixelSpacing,\n columnPixelSpacing,\n };\n }\n\n if (type === MetadataModules.ULTRASOUND_ENHANCED_REGION) {\n return getUSEnhancedRegions(metaData);\n }\n\n if (type === MetadataModules.CALIBRATION) {\n const modality = getValue(metaData['00080060']);\n\n if (modality === 'US') {\n const enhancedRegion = getUSEnhancedRegions(metaData);\n return {\n sequenceOfUltrasoundRegions: enhancedRegion,\n };\n }\n }\n\n if (type === MetadataModules.IMAGE_URL) {\n return getImageUrlModule(imageId, metaData);\n }\n\n if (type === MetadataModules.CINE) {\n return getCineModule(imageId, metaData);\n }\n\n if (type === MetadataModules.IMAGE_PIXEL) {\n return {\n samplesPerPixel: getNumberValue(metaData['00280002']),\n photometricInterpretation: getValue(metaData['00280004']),\n rows: getNumberValue(metaData['00280010']),\n columns: getNumberValue(metaData['00280011']),\n bitsAllocated: getNumberValue(metaData['00280100']),\n bitsStored: getNumberValue(metaData['00280101']),\n highBit: getValue(metaData['00280102']),\n pixelRepresentation: getNumberValue(metaData['00280103']),\n planarConfiguration: getNumberValue(metaData['00280006']),\n pixelAspectRatio: getValue(metaData['00280034']),\n smallestPixelValue: getNumberValue(metaData['00280106']),\n largestPixelValue: getNumberValue(metaData['00280107']),\n redPaletteColorLookupTableDescriptor: getNumberValues(\n metaData['00281101']\n ),\n greenPaletteColorLookupTableDescriptor: getNumberValues(\n metaData['00281102']\n ),\n bluePaletteColorLookupTableDescriptor: getNumberValues(\n metaData['00281103']\n ),\n redPaletteColorLookupTableData: getNumberValues(metaData['00281201']),\n greenPaletteColorLookupTableData: getNumberValues(metaData['00281202']),\n bluePaletteColorLookupTableData: getNumberValues(metaData['00281203']),\n };\n }\n\n if (type === MetadataModules.VOI_LUT) {\n return {\n // TODO VOT LUT Sequence\n windowCenter: getNumberValues(metaData['00281050'], 1),\n windowWidth: getNumberValues(metaData['00281051'], 1),\n };\n }\n\n if (type === MetadataModules.MODALITY_LUT) {\n return {\n // TODO VOT LUT Sequence\n rescaleIntercept: getNumberValue(metaData['00281052']),\n rescaleSlope: getNumberValue(metaData['00281053']),\n rescaleType: getValue(metaData['00281054']),\n };\n }\n\n if (type === MetadataModules.SOP_COMMON) {\n return {\n sopClassUID: getValue<string>(metaData['00080016']),\n sopInstanceUID: getValue<string>(metaData['00080018']),\n };\n }\n\n if (type === MetadataModules.PET_ISOTOPE) {\n const radiopharmaceuticalInfo = getValue(metaData['00540016']);\n\n if (radiopharmaceuticalInfo === undefined) {\n return;\n }\n\n return {\n radiopharmaceuticalInfo: {\n radiopharmaceuticalStartTime: dicomParser.parseTM(\n getValue(radiopharmaceuticalInfo['00181072'], 0, '')\n ),\n radiopharmaceuticalStartDateTime: getValue(\n radiopharmaceuticalInfo['00181078'],\n 0,\n ''\n ),\n radionuclideTotalDose: getNumberValue(\n radiopharmaceuticalInfo['00181074']\n ),\n radionuclideHalfLife: getNumberValue(\n radiopharmaceuticalInfo['00181075']\n ),\n },\n };\n }\n\n if (type === MetadataModules.OVERLAY_PLANE) {\n return getOverlayPlaneModule(metaData);\n }\n\n // Note: this is not a DICOM module, but a useful metadata that can be\n // retrieved from the image\n if (type === 'transferSyntax') {\n return getTransferSyntax(imageId, metaData);\n }\n\n if (type === MetadataModules.PET_SERIES) {\n return {\n correctedImage: getValue(metaData['00280051']),\n units: getValue(metaData['00541001']),\n decayCorrection: getValue(metaData['00541102']),\n };\n }\n\n if (type === MetadataModules.PET_IMAGE) {\n return {\n frameReferenceTime: getNumberValue(metaData['00541300']),\n actualFrameDuration: getNumberValue(metaData['00181242']),\n };\n }\n\n // Note: this is not a DICOM module, but rather an aggregation on all others\n if (type === 'instance') {\n return getInstanceModule(imageId, metaDataProvider, instanceModuleNames);\n }\n}\n\nexport function getImageUrlModule(imageId, metaData) {\n const { transferSyntaxUID } = getTransferSyntax(imageId, metaData);\n const isVideo =\n external.cornerstone.utilities.isVideoTransferSyntax(transferSyntaxUID);\n const imageUrl = imageId.substring(7);\n const thumbnail = imageUrl.replace('/frames/', '/thumbnail/');\n let rendered = imageUrl.replace('/frames/', '/rendered/');\n if (isVideo) {\n rendered = rendered.replace('/rendered/1', '/rendered');\n }\n return {\n isVideo,\n rendered,\n thumbnail,\n };\n}\n\nexport function getCineModule(imageId, metaData) {\n const cineRate = getValue<string>(metaData['00180040']);\n return {\n cineRate,\n numberOfFrames: getNumberValue(metaData['00280008']),\n };\n}\n\nexport function getTransferSyntax(imageId, metaData) {\n // Use either the FMI, which is NOT permitted in the DICOMweb data, but\n // is sometimes found there anyways, or the available transfer syntax, which\n // is the recommended way of getting it.\n return {\n transferSyntaxUID:\n getValue<string>(metaData['00020010']) \|\|\n getValue<string>(metaData['00083002']),\n };\n}\n\nexport default metaDataProvider;\n","import getValue from './getValue';\nimport getNumberValue from './getNumberValue';\nimport { WADORSMetaData } from '../../../types';\n\nexport default function getOverlayPlaneModule(metaData: WADORSMetaData) {\n const overlays = [];\n\n for (let overlayGroup = 0x00; overlayGroup <= 0x1e; overlayGroup += 0x02) {\n let groupStr = `x60${overlayGroup.toString(16)}`;\n\n if (groupStr.length === 4) {\n groupStr = `x600${overlayGroup.toString(16)}`;\n }\n\n /\n @todo there is a type issue with WADORSMetaData. Currently WADORSMetaData\n * on includes string[] \| number[] \| boolean. from the look of this, data\n * is a more complex type\n /\n const data = getValue<any>(metaData[`${groupStr}3000`]);\n\n if (!data) {\n continue;\n }\n\n const pixelData = [];\n\n for (let i = 0; i < data.length; i++) {\n for (let k = 0; k < 8; k++) {\n const byte_as_int = metaData.Value[data.dataOffset + i];\n\n pixelData[i 8 + k] = (byte_as_int >> k) & 0b1; // eslint-disable-line no-bitwise\n }\n }\n\n overlays.push({\n rows: getNumberValue(metaData[`${groupStr}0010`]),\n columns: getNumberValue(metaData[`${groupStr}0011`]),\n type: getValue(metaData[`${groupStr}0040`]),\n x: getNumberValue(metaData[`${groupStr}0050`], 1) - 1,\n y: getNumberValue(metaData[`${groupStr}0050`], 0) - 1,\n pixelData,\n description: getValue(metaData[`${groupStr}0022`]),\n label: getValue(metaData[`${groupStr}1500`]),\n roiArea: getValue(metaData[`${groupStr}1301`]),\n roiMean: getValue(metaData[`${groupStr}1302`]),\n roiStandardDeviation: getValue(metaData[`${groupStr}1303`]),\n });\n }\n\n return {\n overlays,\n };\n}\n","function checkToken(token, data, dataOffset): boolean {\n if (dataOffset + token.length > data.length) {\n return false;\n }\n\n let endIndex = dataOffset;\n\n for (let i = 0; i < token.length; i++) {\n if (token[i] !== data[endIndex++]) {\n return false;\n }\n }\n\n return true;\n}\n\nfunction stringToUint8Array(str: string): Uint8Array {\n const uint = new Uint8Array(str.length);\n\n for (let i = 0, j = str.length; i < j; i++) {\n uint[i] = str.charCodeAt(i);\n }\n\n return uint;\n}\n\nfunction findIndexOfString(\n data: Uint8Array,\n str: string,\n offset?: number\n): number {\n offset = offset \|\| 0;\n\n const token = stringToUint8Array(str);\n\n for (let i = offset; i < data.length; i++) {\n if (token[0] === data[i]) {\n // console.log('match @', i);\n if (checkToken(token, data, i)) {\n return i;\n }\n }\n }\n\n return -1;\n}\nexport default findIndexOfString;\n","import { LoaderOptions } from '../../types';\n\nlet options: LoaderOptions = {\n // callback to open the object\n open(xhr, url) {\n xhr.open('get', url, true);\n },\n // callback allowing customization of the xhr (e.g. adding custom auth headers, cors, etc)\n beforeSend(/* xhr, imageId /) {\n // before send code\n },\n // callback allowing modification of the xhr response before creating image objects\n beforeProcessing(xhr: XMLHttpRequest) {\n return Promise.resolve(xhr.response as ArrayBuffer);\n },\n // callback allowing modification of newly created image objects\n imageCreated(/ image /) {\n // image created code\n },\n strict: false,\n decodeConfig: {\n convertFloatPixelDataToInt: true,\n use16BitDataType: false,\n },\n};\n\nexport function setOptions(newOptions: LoaderOptions): void {\n options = Object.assign(options, newOptions);\n}\n\nexport function getOptions(): LoaderOptions {\n return options;\n}\n","import external from '../../externalModules';\nimport { getOptions } from './options';\nimport {\n LoaderXhrRequestError,\n LoaderXhrRequestParams,\n LoaderXhrRequestPromise,\n} from '../../types';\n\nfunction xhrRequest(\n url: string,\n imageId: string,\n defaultHeaders: Record<string, string> = {},\n params: LoaderXhrRequestParams = {}\n): LoaderXhrRequestPromise<ArrayBuffer> {\n const { cornerstone } = external;\n const options = getOptions();\n\n const errorInterceptor = (xhr: XMLHttpRequest) => {\n if (typeof options.errorInterceptor === 'function') {\n const error = new Error('request failed') as LoaderXhrRequestError;\n\n error.request = xhr;\n error.response = xhr.response;\n error.status = xhr.status;\n options.errorInterceptor(error);\n }\n };\n\n const xhr = new XMLHttpRequest();\n\n // Make the request for the DICOM P10 SOP Instance\n const promise: LoaderXhrRequestPromise<ArrayBuffer> =\n new Promise<ArrayBuffer>((resolve, reject) => {\n options.open(xhr, url, defaultHeaders, params);\n const beforeSendHeaders = options.beforeSend(\n xhr,\n imageId,\n defaultHeaders,\n params\n );\n\n xhr.responseType = 'arraybuffer';\n\n const headers = Object.assign({}, defaultHeaders, beforeSendHeaders);\n\n Object.keys(headers).forEach(function (key) {\n if (headers[key] === null) {\n return;\n }\n if (key === 'Accept' && url.indexOf('accept=') !== -1) {\n return;\n }\n xhr.setRequestHeader(key, headers[key]);\n });\n\n params.deferred = {\n resolve,\n reject,\n };\n params.url = url;\n params.imageId = imageId;\n\n // Event triggered when downloading an image starts\n xhr.onloadstart = function (event) {\n // Action\n if (options.onloadstart) {\n options.onloadstart(event, params);\n }\n\n // Event\n const eventData = {\n url,\n imageId,\n };\n\n cornerstone.triggerEvent(\n (cornerstone as any).events,\n 'cornerstoneimageloadstart',\n eventData\n );\n };\n\n // Event triggered when downloading an image ends\n xhr.onloadend = function (event) {\n // Action\n if (options.onloadend) {\n options.onloadend(event, params);\n }\n\n const eventData = {\n url,\n imageId,\n };\n\n // Event\n cornerstone.triggerEvent(\n (cornerstone as any).events,\n 'cornerstoneimageloadend',\n eventData\n );\n };\n\n // handle response data\n xhr.onreadystatechange = function (event) {\n // Action\n if (options.onreadystatechange) {\n options.onreadystatechange(event, params);\n\n return;\n }\n\n // Default action\n // TODO: consider sending out progress messages here as we receive\n // the pixel data\n if (xhr.readyState === 4) {\n // Status OK (200) and partial content (206) are both handled\n if (xhr.status === 200 \|\| xhr.status === 206) {\n options\n .beforeProcessing(xhr)\n .then(resolve)\n .catch(() => {\n errorInterceptor(xhr);\n // request failed, reject the Promise\n reject(xhr);\n });\n } else {\n errorInterceptor(xhr);\n // request failed, reject the Promise\n reject(xhr);\n }\n }\n };\n\n // Event triggered when downloading an image progresses\n xhr.onprogress = function (oProgress) {\n // console.log('progress:',oProgress)\n const loaded = oProgress.loaded; // evt.loaded the bytes browser receive\n\n let total: number;\n\n let percentComplete: number;\n\n if (oProgress.lengthComputable) {\n total = oProgress.total; // evt.total the total bytes seted by the header\n percentComplete = Math.round((loaded / total) 100);\n }\n\n // Action\n if (options.onprogress) {\n options.onprogress(oProgress, params);\n }\n };\n xhr.onerror = function () {\n errorInterceptor(xhr);\n reject(xhr);\n };\n\n xhr.onabort = function () {\n errorInterceptor(xhr);\n reject(xhr);\n };\n xhr.send();\n });\n\n promise.xhr = xhr;\n\n return promise;\n}\n\nexport default xhrRequest;\n","import { default as xhrRequest } from './xhrRequest';\nimport { setOptions, getOptions } from './options';\n\nconst internal = {\n xhrRequest,\n setOptions,\n getOptions,\n};\n\nexport { setOptions, getOptions, xhrRequest, internal };\n","import { Enums } from '@cornerstonejs/core';\nimport findIndexOfString from './findIndexOfString';\n\nconst { ImageQualityStatus } = Enums;\n/*\n Extracts multipart/related data or single part data from a response byte\n * array.\n \n @param contentType - guess of the root content type\n * @param imageFrameAsArrayBuffer - array buffer containing the image frame\n * @param options - contains already computed values from\n * earlier calls, allowing additional calls to be made to fetch\n * additional data.\n * @param isPartial - indicates the file may end partially\n * @returns a compressed image frame containing the pixel data.\n /\nexport default function extractMultipart(\n contentType: string,\n imageFrameAsArrayBuffer,\n options?\n) {\n options \|\|= {};\n // request succeeded, Parse the multi-part mime response\n const response = new Uint8Array(imageFrameAsArrayBuffer);\n const isPartial = !!options?.isPartial;\n if (contentType.indexOf('multipart') === -1) {\n return {\n contentType,\n imageQualityStatus: isPartial\n ? ImageQualityStatus.SUBRESOLUTION\n : ImageQualityStatus.FULL_RESOLUTION,\n pixelData: response,\n };\n }\n\n let { tokenIndex, responseHeaders, boundary, multipartContentType } = options;\n\n // First look for the multipart mime header\n tokenIndex \|\|= findIndexOfString(response, '\\r\\n\\r\\n');\n\n if (tokenIndex === -1) {\n throw new Error('invalid response - no multipart mime header');\n }\n\n if (!boundary) {\n const header = uint8ArrayToString(response, 0, tokenIndex);\n // Now find the boundary marker\n responseHeaders = header.split('\\r\\n');\n boundary = findBoundary(responseHeaders);\n\n if (!boundary) {\n throw new Error('invalid response - no boundary marker');\n }\n }\n const offset = tokenIndex + 4; // skip over the \\r\\n\\r\\n\n\n // find the terminal boundary marker\n const endIndex = findIndexOfString(response, boundary, offset);\n\n if (endIndex === -1 && !isPartial) {\n throw new Error('invalid response - terminating boundary not found');\n }\n\n multipartContentType \|\|= findContentType(responseHeaders);\n\n options.tokenIndex = tokenIndex;\n options.boundary = boundary;\n options.responseHeaders = responseHeaders;\n options.multipartContentType = multipartContentType;\n options.isPartial = endIndex === -1;\n\n // return the info for this pixel data\n return {\n contentType: multipartContentType,\n // done indicates if the read has finished the entire image, not if\n // the image is completely available\n extractDone: !isPartial \|\| endIndex !== -1,\n tokenIndex,\n responseHeaders,\n boundary,\n multipartContentType,\n // Exclude the \\r\\n as well as the boundary\n pixelData: imageFrameAsArrayBuffer.slice(offset, endIndex - 2),\n };\n}\n\nexport function findBoundary(header: string[]): string {\n for (let i = 0; i < header.length; i++) {\n if (header[i].substr(0, 2) === '--') {\n return header[i];\n }\n }\n}\n\nexport function findContentType(header: string[]): string {\n for (let i = 0; i < header.length; i++) {\n if (header[i].substr(0, 13) === 'Content-Type:') {\n return header[i].substr(13).trim();\n }\n }\n}\n\nexport function uint8ArrayToString(data, offset, length) {\n offset = offset \|\| 0;\n length = length \|\| data.length - offset;\n let str = '';\n\n for (let i = offset; i < offset + length; i++) {\n str += String.fromCharCode(data[i]);\n }\n\n return str;\n}\n","import { Types, Enums } from '@cornerstonejs/core';\n\nconst { ImageQualityStatus } = Enums;\n\n/* Gets the status of returned images /\nexport function getImageQualityStatus(\n retrieveOptions: Types.RetrieveOptions,\n done = true\n) {\n if (!done) {\n return ImageQualityStatus.SUBRESOLUTION;\n }\n return (\n retrieveOptions.imageQualityStatus ?? ImageQualityStatus.FULL_RESOLUTION\n );\n}\n","import { Types, utilities } from '@cornerstonejs/core';\nimport { getOptions } from './options';\nimport { LoaderXhrRequestError } from '../../types';\nimport extractMultipart from '../wadors/extractMultipart';\nimport { getImageQualityStatus } from '../wadors/getImageQualityStatus';\n\nconst { ProgressiveIterator } = utilities;\ntype RetrieveOptions = Types.RetrieveOptions;\n\n/\n This function does a streaming parse from an http request, delivering\n * combined/subsequent parts of the result as iterations on a\n * ProgressiveIterator instance.\n \n @param url - to request and parse as either multipart or singlepart.\n * @param imageId\n * @param defaultHeaders\n * @returns\n /\nexport default function streamRequest(\n url: string,\n imageId: string,\n defaultHeaders: Record<string, string> = {},\n options: CornerstoneWadoRsLoaderOptions = {}\n) {\n const globalOptions = getOptions();\n const { retrieveOptions = {}, streamingData = {} } = options;\n const minChunkSize = retrieveOptions.minChunkSize \|\| 128 1024;\n\n const errorInterceptor = (err: any) => {\n if (typeof globalOptions.errorInterceptor === 'function') {\n const error = new Error('request failed') as LoaderXhrRequestError;\n globalOptions.errorInterceptor(error);\n }\n };\n\n // Make the request for the streamable image frame (i.e. HTJ2K)\n const loadIterator = new ProgressiveIterator('streamRequest');\n loadIterator.generate(async (iterator, reject) => {\n const headers = Object.assign({}, defaultHeaders /* beforeSendHeaders /);\n\n Object.keys(headers).forEach(function (key) {\n if (headers[key] === null) {\n headers[key] = undefined;\n }\n if (key === 'Accept' && url.indexOf('accept=') !== -1) {\n headers[key] = undefined;\n }\n });\n\n try {\n const response = await fetch(url, {\n headers: defaultHeaders,\n signal: undefined,\n });\n\n // Response is expected to be a 200 status response\n if (response.status !== 200) {\n throw new Error(\n `Couldn't retrieve ${url} got status ${response.status}`\n );\n }\n const responseReader = response.body.getReader();\n const responseHeaders = response.headers;\n\n const contentType = responseHeaders.get('content-type');\n\n const totalBytes = Number(responseHeaders.get('Content-Length'));\n\n let readDone = false;\n let encodedData = streamingData.encodedData;\n let lastSize = streamingData.lastSize \|\| 0;\n streamingData.isPartial = true;\n\n while (!readDone) {\n const { done, value } = await responseReader.read();\n encodedData = appendChunk(encodedData, value);\n if (!encodedData) {\n if (readDone) {\n throw new Error(`Done but no image frame available ${imageId}`);\n }\n continue;\n }\n readDone = done \|\| encodedData.byteLength === totalBytes;\n if (!readDone && encodedData.length < lastSize + minChunkSize) {\n continue;\n }\n lastSize = encodedData.length;\n streamingData.isPartial = !done;\n const extracted = extractMultipart(\n contentType,\n encodedData,\n streamingData\n );\n const imageQualityStatus = getImageQualityStatus(\n retrieveOptions,\n readDone\n );\n const detail = {\n url,\n imageId,\n ...extracted,\n percentComplete: done\n ? 100\n : (extracted.pixelData?.length 100) / totalBytes,\n imageQualityStatus,\n done: readDone,\n };\n\n // All of the image load events will be handled by the imageLoader\n // this simply delivers the raw data as it becomes available.\n iterator.add(detail, readDone);\n }\n } catch (err) {\n errorInterceptor(err);\n console.error(err);\n reject(err);\n }\n });\n\n return loadIterator.getNextPromise();\n}\n\nfunction appendChunk(existing: Uint8Array, chunk?: Uint8Array) {\n // that imageId\n if (!existing) {\n return chunk;\n }\n if (!chunk) {\n return existing;\n }\n const newDataArray = new Uint8Array(existing.length + chunk.length);\n newDataArray.set(existing, 0);\n newDataArray.set(chunk, existing.length);\n return newDataArray;\n}\n","import { Types, Enums } from '@cornerstonejs/core';\nimport { getOptions } from './options';\nimport { LoaderXhrRequestError, LoaderXhrRequestPromise } from '../../types';\nimport metaDataManager from '../wadors/metaDataManager';\nimport extractMultipart from '../wadors/extractMultipart';\nimport { getImageQualityStatus } from '../wadors/getImageQualityStatus';\nimport { CornerstoneWadoRsLoaderOptions } from '../wadors/loadImage';\n\ntype RangeRetrieveOptions = Types.RangeRetrieveOptions;\n\n/*\n Performs a range request to fetch part of an encoded image, typically\n * so that partial resolution images can be fetched.\n * The configuration of exactly what is requested is based on the transfer\n * syntax provided.\n * Note this generates 1 response for each call, and those reponses may or may\n * not be combined with each other depending on the configuration applied.\n \n * HTJ2K Streaming TSUID -> Use actual range requests, and set it up for streaming\n * image decoding of byte range requests\n * * JLS and Non-streaming HTJ2K -> Use a sub-resolution (or thumbnail) endpoint\n * followed by normal endpoint\n \n @param url - including an fsiz parameter\n * @param imageId - to fetch for\n * @param defaultHeaders - to add to the request\n * @returns Compressed image data\n /\nexport default function rangeRequest(\n url: string,\n imageId: string,\n defaultHeaders: Record<string, string> = {},\n options: CornerstoneWadoRsLoaderOptions = {}\n): LoaderXhrRequestPromise<{\n contentType: string;\n pixelData: Uint8Array;\n imageQualityStatus: Enums.ImageQualityStatus;\n percentComplete: number;\n}> {\n const globalOptions = getOptions();\n const { retrieveOptions = {}, streamingData } = options;\n const chunkSize =\n streamingData.chunkSize \|\|\n getValue(imageId, retrieveOptions, 'chunkSize') \|\|\n 65536;\n\n const errorInterceptor = (err: any) => {\n if (typeof globalOptions.errorInterceptor === 'function') {\n const error = new Error('request failed') as LoaderXhrRequestError;\n globalOptions.errorInterceptor(error);\n } else {\n console.warn('rangeRequest:Caught', err);\n }\n };\n\n // Make the request for the streamable image frame (i.e. HTJ2K)\n const promise = new Promise<{\n contentType: string;\n pixelData: Uint8Array;\n percentComplete: number;\n imageQualityStatus: Enums.ImageQualityStatus;\n }>(async (resolve, reject) => {\n const headers = Object.assign(\n {},\n defaultHeaders\n / beforeSendHeaders /\n );\n\n Object.keys(headers).forEach(function (key) {\n if (headers[key] === null \|\| headers[key] === undefined) {\n delete headers[key];\n }\n });\n\n try {\n if (!streamingData.encodedData) {\n streamingData.chunkSize = chunkSize;\n streamingData.rangesFetched = 0;\n }\n const byteRange = getByteRange(streamingData, retrieveOptions);\n\n const { encodedData, responseHeaders } = await fetchRangeAndAppend(\n url,\n headers,\n byteRange,\n streamingData\n );\n\n // Resolve promise with the first range, so it can be passed through to\n // cornerstone via the usual image loading pathway. All subsequent\n // ranges will be passed and decoded via events.\n const contentType = responseHeaders.get('content-type');\n const { totalBytes } = streamingData;\n const doneAllBytes = totalBytes === encodedData.byteLength;\n const extract = extractMultipart(contentType, encodedData, {\n isPartial: true,\n });\n\n // Allow over-writing the done status to indicate complete on partial\n const imageQualityStatus = getImageQualityStatus(\n retrieveOptions,\n doneAllBytes \|\| extract.extractDone\n );\n resolve({\n ...extract,\n imageQualityStatus,\n percentComplete: extract.extractDone\n ? 100\n : (chunkSize 100) / totalBytes,\n });\n } catch (err: any) {\n errorInterceptor(err);\n console.error(err);\n reject(err);\n }\n });\n\n return promise;\n}\n\nasync function fetchRangeAndAppend(\n url: string,\n headers: any,\n range: [number, number \| ''],\n streamingData\n) {\n if (range) {\n headers = Object.assign(headers, {\n Range: `bytes=${range[0]}-${range[1]}`,\n });\n }\n let { encodedData } = streamingData;\n if (range[1] && encodedData?.byteLength > range[1]) {\n return streamingData;\n }\n const response = await fetch(url, {\n headers,\n signal: undefined,\n });\n\n const responseArrayBuffer = await response.arrayBuffer();\n const responseTypedArray = new Uint8Array(responseArrayBuffer);\n const { status } = response;\n\n // Append new data\n let newByteArray: Uint8Array;\n if (encodedData) {\n newByteArray = new Uint8Array(\n encodedData.length + responseTypedArray.length\n );\n newByteArray.set(encodedData, 0);\n newByteArray.set(responseTypedArray, encodedData.length);\n streamingData.rangesFetched = 1;\n } else {\n newByteArray = new Uint8Array(responseTypedArray.length);\n newByteArray.set(responseTypedArray, 0);\n streamingData.rangesFetched++;\n }\n streamingData.encodedData = encodedData = newByteArray;\n streamingData.responseHeaders = response.headers;\n\n const contentRange = response.headers.get('Content-Range');\n if (contentRange) {\n streamingData.totalBytes = Number(contentRange.split('/')[1]);\n } else if (status !== 206 \|\| !range) {\n streamingData.totalBytes = encodedData?.byteLength;\n } else if (range[1] === '' \|\| encodedData?.length < range[1]) {\n streamingData.totalBytes = encodedData.byteLength;\n } else {\n streamingData.totalBytes = Number.MAX_SAFE_INTEGER;\n }\n\n return streamingData;\n}\n\nfunction getValue(imageId: string, src, attr: string) {\n const value = src[attr];\n if (typeof value !== 'function') {\n return value;\n }\n const metaData = metaDataManager.get(imageId);\n return value(metaData, imageId);\n}\n\nfunction getByteRange(\n streamingData,\n retrieveOptions: RangeRetrieveOptions\n): [number, number \| ''] {\n const { totalBytes, encodedData, chunkSize = 65536 } = streamingData;\n const { rangeIndex = 0 } = retrieveOptions;\n if (rangeIndex === -1 && (!totalBytes \|\| !encodedData)) {\n return [0, ''];\n }\n if (rangeIndex === -1 \|\| encodedData?.byteLength > totalBytes - chunkSize) {\n return [encodedData?.byteLength \|\| 0, ''];\n }\n // Note the byte range is inclusive at both ends and zero based,\n // so the byteLength is the next index to fetch.\n return [encodedData?.byteLength \|\| 0, chunkSize * (rangeIndex + 1) - 1];\n}\n","import { xhrRequest } from '../internal/index';\n// import rangeRequest from '../internal/rangeRequest';\nimport streamRequest from '../internal/streamRequest';\nimport rangeRequest from '../internal/rangeRequest';\nimport extractMultipart from './extractMultipart';\nimport { getImageQualityStatus } from './getImageQualityStatus';\nimport { CornerstoneWadoRsLoaderOptions } from './loadImage';\nimport { RangeRetrieveOptions } from 'core/dist/types/types';\n\nfunction getPixelData(\n uri: string,\n imageId: string,\n mediaType = 'application/octet-stream',\n options?: CornerstoneWadoRsLoaderOptions\n) {\n const { streamingData, retrieveOptions = {} } = options \|\| {};\n const headers = {\n Accept: mediaType,\n };\n\n // Add urlArguments to the url for retrieving - allows accept and other\n // parameters to be added.\n let url = retrieveOptions.urlArguments\n ? `${uri}${uri.indexOf('?') === -1 ? '?' : '&'}${\n retrieveOptions.urlArguments\n }`\n : uri;\n\n // Replace the /frames/ part of the path with another path to choose\n // a different resource type.\n if (retrieveOptions.framesPath) {\n url = url.replace('/frames/', retrieveOptions.framesPath);\n }\n\n // Swap the streaming data out if a new instance starts.\n if (streamingData?.url !== url) {\n options.streamingData = { url };\n }\n\n if ((retrieveOptions as RangeRetrieveOptions).rangeIndex !== undefined) {\n return rangeRequest(url, imageId, headers, options);\n }\n\n // Use the streaming parser only when configured to do so\n if (retrieveOptions.streaming) {\n return streamRequest(url, imageId, headers, options);\n }\n\n /*\n Not progressively rendering, use regular xhr request.\n /\n const loadPromise = xhrRequest(url, imageId, headers);\n const { xhr } = loadPromise;\n\n return loadPromise.then(function (imageFrameAsArrayBuffer / , xhr/) {\n const contentType =\n xhr.getResponseHeader('Content-Type') \|\| 'application/octet-stream';\n const extracted = extractMultipart(\n contentType,\n new Uint8Array(imageFrameAsArrayBuffer)\n );\n extracted.imageQualityStatus = getImageQualityStatus(retrieveOptions, true);\n return extracted;\n });\n}\n\nexport default getPixelData;\n","import { PixelDataTypedArray } from '../types';\n\n/\n Calculate the minimum and maximum values in an Array\n \n @param {Number[]} storedPixelData\n * @return {{min: Number, max: Number}}\n /\nfunction getMinMax(storedPixelData: PixelDataTypedArray): {\n min: number;\n max: number;\n} {\n // we always calculate the min max values since they are not always\n // present in DICOM and we don't want to trust them anyway as cornerstone\n // depends on us providing reliable values for these\n let min = storedPixelData[0];\n\n let max = storedPixelData[0];\n\n let storedPixel;\n const numPixels = storedPixelData.length;\n\n for (let index = 1; index < numPixels; index++) {\n storedPixel = storedPixelData[index];\n min = Math.min(min, storedPixel);\n max = Math.max(max, storedPixel);\n }\n\n return {\n min,\n max,\n };\n}\n\nexport default getMinMax;\n","import {\n convertRGBColorByPixel,\n convertRGBColorByPlane,\n convertYBRFullByPixel,\n convertYBRFull422ByPixel,\n convertYBRFullByPlane,\n convertPALETTECOLOR,\n} from './colorSpaceConverters/index';\n\nfunction convertRGB(imageFrame, colorBuffer, useRGBA) {\n if (imageFrame.planarConfiguration === 0) {\n convertRGBColorByPixel(imageFrame.pixelData, colorBuffer, useRGBA);\n } else {\n convertRGBColorByPlane(imageFrame.pixelData, colorBuffer, useRGBA);\n }\n}\n\nfunction convertYBRFull(imageFrame, colorBuffer, useRGBA) {\n if (imageFrame.planarConfiguration === 0) {\n convertYBRFullByPixel(imageFrame.pixelData, colorBuffer, useRGBA);\n } else {\n convertYBRFullByPlane(imageFrame.pixelData, colorBuffer, useRGBA);\n }\n}\n\nexport default function convertColorSpace(imageFrame, colorBuffer, useRGBA) {\n // convert based on the photometric interpretation\n if (imageFrame.photometricInterpretation === 'RGB') {\n convertRGB(imageFrame, colorBuffer, useRGBA);\n } else if (imageFrame.photometricInterpretation === 'YBR_RCT') {\n convertRGB(imageFrame, colorBuffer, useRGBA);\n } else if (imageFrame.photometricInterpretation === 'YBR_ICT') {\n convertRGB(imageFrame, colorBuffer, useRGBA);\n } else if (imageFrame.photometricInterpretation === 'PALETTE COLOR') {\n convertPALETTECOLOR(imageFrame, colorBuffer, useRGBA);\n } else if (imageFrame.photometricInterpretation === 'YBR_FULL_422') {\n convertYBRFull422ByPixel(imageFrame.pixelData, colorBuffer, useRGBA);\n } else if (imageFrame.photometricInterpretation === 'YBR_FULL') {\n convertYBRFull(imageFrame, colorBuffer, useRGBA);\n } else {\n // TODO - handle YBR_PARTIAL and 420 colour spaces\n throw new Error(\n `No color space conversion for photometric interpretation ${imageFrame.photometricInterpretation}`\n );\n }\n}\n","import { ByteArray } from 'dicom-parser';\n\nexport default function (\n imageFrame: ByteArray,\n colorBuffer: ByteArray,\n useRGBA: boolean\n): void {\n if (imageFrame === undefined) {\n throw new Error('convertYBRFull422ByPixel: ybrBuffer must be defined');\n }\n if (imageFrame.length % 2 !== 0) {\n throw new Error(\n `convertYBRFull422ByPixel: ybrBuffer length ${imageFrame.length} must be divisible by 2`\n );\n }\n\n const numPixels = imageFrame.length / 2;\n\n let ybrIndex = 0;\n\n let bufferIndex = 0;\n\n if (useRGBA) {\n for (let i = 0; i < numPixels; i += 2) {\n const y1 = imageFrame[ybrIndex++];\n const y2 = imageFrame[ybrIndex++];\n const cb = imageFrame[ybrIndex++];\n const cr = imageFrame[ybrIndex++];\n\n colorBuffer[bufferIndex++] = y1 + 1.402 (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y1 - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y1 + 1.772 * (cb - 128); // blue\n colorBuffer[bufferIndex++] = 255; // alpha\n\n colorBuffer[bufferIndex++] = y2 + 1.402 * (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y2 - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y2 + 1.772 * (cb - 128); // blue\n colorBuffer[bufferIndex++] = 255; // alpha\n }\n\n return;\n }\n\n for (let i = 0; i < numPixels; i += 2) {\n const y1 = imageFrame[ybrIndex++];\n const y2 = imageFrame[ybrIndex++];\n const cb = imageFrame[ybrIndex++];\n const cr = imageFrame[ybrIndex++];\n\n colorBuffer[bufferIndex++] = y1 + 1.402 * (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y1 - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y1 + 1.772 * (cb - 128); // blue\n\n colorBuffer[bufferIndex++] = y2 + 1.402 * (cr - 128); // red\n colorBuffer[bufferIndex++] =\n y2 - 0.34414 * (cb - 128) - 0.71414 * (cr - 128); // green\n colorBuffer[bufferIndex++] = y2 + 1.772 * (cb - 128); // blue\n }\n}\n","import { ByteArray } from 'dicom-parser';\nimport getMinMax from '../shared/getMinMax';\nimport { ImageFrame } from '../types';\n\n/*\n Special decoder for 8 bit jpeg that leverages the browser's built in JPEG decoder for increased performance\n /\n\nfunction arrayBufferToString(buffer: ArrayBuffer) {\n return binaryToString(\n String.fromCharCode.apply(\n null,\n Array.prototype.slice.apply(new Uint8Array(buffer))\n )\n );\n}\n\nfunction binaryToString(binary: string) {\n let error;\n\n try {\n return decodeURIComponent(escape(binary));\n } catch (_error) {\n error = _error;\n if (error instanceof URIError) {\n return binary;\n }\n throw error;\n }\n}\n\nfunction decodeJPEGBaseline8BitColor(\n imageFrame: ImageFrame,\n pixelData: ByteArray,\n canvas: HTMLCanvasElement\n): Promise<ImageFrame> {\n const start = new Date().getTime();\n const imgBlob = new Blob([pixelData], { type: 'image/jpeg' });\n\n return new Promise((resolve, reject) => {\n const fileReader = new FileReader();\n\n if (fileReader.readAsBinaryString === undefined) {\n fileReader.readAsArrayBuffer(imgBlob);\n } else {\n fileReader.readAsBinaryString(imgBlob); // doesn't work on IE11\n }\n\n fileReader.onload = function () {\n const img = new Image();\n\n img.onload = function () {\n canvas.height = img.height;\n canvas.width = img.width;\n imageFrame.rows = img.height;\n imageFrame.columns = img.width;\n const context = canvas.getContext('2d');\n\n /\n @todo check this context\n /\n context.drawImage(this as any, 0, 0);\n const imageData = context.getImageData(0, 0, img.width, img.height);\n const end = new Date().getTime();\n\n imageFrame.pixelData = new Uint8Array(imageData.data.buffer);\n imageFrame.imageData = imageData;\n imageFrame.decodeTimeInMS = end - start;\n\n // calculate smallest and largest PixelValue\n const minMax = getMinMax(imageFrame.pixelData as any);\n\n imageFrame.smallestPixelValue = minMax.min;\n imageFrame.largestPixelValue = minMax.max;\n imageFrame.pixelDataLength = imageFrame.pixelData.length;\n\n resolve(imageFrame);\n };\n\n img.onerror = function (error) {\n reject(error);\n };\n\n if (fileReader.readAsBinaryString === undefined) {\n img.src = `data:image/jpeg;base64,${window.btoa(\n arrayBufferToString(fileReader.result as ArrayBuffer)\n )}`;\n } else {\n img.src = `data:image/jpeg;base64,${window.btoa(\n fileReader.result as string\n )}`; // doesn't work on IE11\n }\n };\n\n fileReader.onerror = (e) => {\n reject(e);\n };\n });\n}\n\nexport default decodeJPEGBaseline8BitColor;\n","export default function Worker_fn() {\n return new Worker(__webpack_public_path__ + \"index.worker.f4bda803c15bc6359d5f.worker.js\");\n}\n","// Not sure why but webpack isn't splitting this out unless we explicitly use worker-loader!\n// eslint-disable-next-line\n// import cornerstoneDICOMImageLoaderWebWorker from 'worker-loader!../webWorker/index.worker';\nimport cornerstoneDICOMImageLoaderWebWorker from '../webWorker/index.worker';\n\nimport {\n WebWorkerOptions,\n WorkerTaskTypes,\n WorkerTask,\n WebWorkerDecodeTaskData,\n WebWorkerResponse,\n WebWorkerDeferredObject,\n} from '../types';\n\n// This is for the Webpack 5 approch but it's currently broken\n// so we will continue relying on worker-loader for now\n// https://github.com/webpack/webpack/issues/13899\n/ const cornerstoneDICOMImageLoaderWebWorkerPath = new URL(\n '../webWorker/index',\n import.meta.url\n);/\n\nimport { getOptions } from './internal/options';\n\n// the taskId to assign to the next task added via addTask()\nlet nextTaskId = 0;\n\nconst tasks: WorkerTask[] = [];\n\n// array of web workers to dispatch decode tasks to\nconst webWorkers: {\n worker: Worker;\n status: 'ready' \| 'busy' \| 'initializing';\n task?: WorkerTask;\n}[] = [];\n\n// The options for cornerstoneDICOMImageLoader\nconst options = getOptions();\n\nconst defaultConfig: WebWorkerOptions = {\n maxWebWorkers: navigator.hardwareConcurrency \|\| 1,\n startWebWorkersOnDemand: true,\n webWorkerTaskPaths: [],\n taskConfiguration: {\n decodeTask: {\n initializeCodecsOnStartup: false,\n strict: options.strict,\n },\n },\n};\n\nlet config: WebWorkerOptions;\n\nconst statistics = {\n maxWebWorkers: 0,\n numWebWorkers: 0,\n numTasksQueued: 0,\n numTasksExecuting: 0,\n numTasksCompleted: 0,\n totalTaskTimeInMS: 0,\n totalTimeDelayedInMS: 0,\n};\n\n/\n Function to start a task on a web worker\n /\nfunction startTaskOnWebWorker() {\n // return immediately if no decode tasks to do\n if (!tasks.length) {\n return;\n }\n\n // look for a web worker that is ready\n for (let i = 0; i < webWorkers.length; i++) {\n if (webWorkers[i].status === 'ready') {\n // mark it as busy so tasks are not assigned to it\n webWorkers[i].status = 'busy';\n\n // get the highest priority task\n const task = tasks.shift();\n\n task.start = new Date().getTime();\n\n // update stats with how long this task was delayed (waiting in queue)\n const end = new Date().getTime();\n\n statistics.totalTimeDelayedInMS += end - task.added;\n\n // assign this task to this web worker and send the web worker\n // a message to execute it\n webWorkers[i].task = task;\n webWorkers[i].worker.postMessage(\n {\n taskType: task.taskType,\n workerIndex: i,\n data: task.data,\n },\n task.transferList\n );\n statistics.numTasksExecuting++;\n\n return;\n }\n }\n\n // if no available web workers and we haven't started max web workers, start a new one\n if (webWorkers.length < config.maxWebWorkers) {\n spawnWebWorker();\n }\n}\n\n/\n Function to handle a message from a web worker\n * @param msg\n /\nfunction handleMessageFromWorker(msg: MessageEvent<WebWorkerResponse>) {\n // console.log('handleMessageFromWorker', msg.data);\n if (msg.data.taskType === 'initialize') {\n webWorkers[msg.data.workerIndex].status = 'ready';\n startTaskOnWebWorker();\n } else {\n const start = webWorkers[msg.data.workerIndex].task.start;\n\n const action = msg.data.status === 'success' ? 'resolve' : 'reject';\n\n try {\n webWorkers[msg.data.workerIndex].task.deferred[action](msg.data.result);\n } catch (e) {\n // Do a catch here to ensure the web worker is available\n console.warn('Caught error delivering response', e);\n }\n\n webWorkers[msg.data.workerIndex].task = undefined;\n\n statistics.numTasksExecuting--;\n webWorkers[msg.data.workerIndex].status = 'ready';\n statistics.numTasksCompleted++;\n\n const end = new Date().getTime();\n\n statistics.totalTaskTimeInMS += end - start;\n\n startTaskOnWebWorker();\n }\n}\n\n/\n Spawns a new web worker\n /\nfunction spawnWebWorker() {\n // prevent exceeding maxWebWorkers\n if (webWorkers.length >= config.maxWebWorkers) {\n return;\n }\n\n // spawn the webworker\n const worker: Worker = new (cornerstoneDICOMImageLoaderWebWorker as any)();\n\n // This is for the Webpack 5 approach but it's currently broken\n / const worker = new Worker(cornerstoneDICOMImageLoaderWebWorkerPath, {\n name: `cornerstoneDICOMImageLoaderWebWorkerPath-${webWorkers.length + 1}`,\n type: 'module',\n });/\n\n // const worker = new Worker(\n // './cornerstoneDICOMImageLoaderWebWorker.bundle.min',\n // {\n // name: `cornerstoneDICOMImageLoaderWebWorkerPath-${webWorkers.length + 1}`,\n // }\n // );\n\n webWorkers.push({\n worker,\n status: 'initializing',\n });\n worker.addEventListener('message', handleMessageFromWorker);\n worker.postMessage({\n taskType: 'initialize',\n workerIndex: webWorkers.length - 1,\n config,\n });\n}\n\n/\n Initialization function for the web worker manager - spawns web workers\n * @param configObject\n /\nfunction initialize(configObject?: WebWorkerOptions): void {\n configObject = configObject \|\| defaultConfig;\n\n // prevent being initialized more than once\n if (config) {\n // throw new Error('WebWorkerManager already initialized');\n }\n\n config = configObject;\n\n config.maxWebWorkers =\n config.maxWebWorkers \|\| navigator.hardwareConcurrency \|\| 1;\n\n // Spawn new web workers\n if (!config.startWebWorkersOnDemand) {\n for (let i = 0; i < config.maxWebWorkers; i++) {\n spawnWebWorker();\n }\n }\n}\n\n/\n Terminate all running web workers.\n /\nfunction terminate(): void {\n for (let i = 0; i < webWorkers.length; i++) {\n webWorkers[i].worker.terminate();\n }\n webWorkers.length = 0;\n config = undefined;\n}\n\n/\n dynamically loads a web worker task\n * @param sourcePath\n * @param taskConfig\n /\nfunction loadWebWorkerTask(sourcePath: string, taskConfig): void {\n // add it to the list of web worker tasks paths so on demand web workers\n // load this properly\n config.webWorkerTaskPaths.push(sourcePath);\n\n // if a task specific configuration is provided, merge it into the config\n if (taskConfig) {\n config.taskConfiguration = Object.assign(\n config.taskConfiguration,\n taskConfig\n );\n }\n\n // tell each spawned web worker to load this task\n for (let i = 0; i < webWorkers.length; i++) {\n webWorkers[i].worker.postMessage({\n taskType: 'loadWebWorkerTask',\n workerIndex: webWorkers.length - 1,\n sourcePath,\n config,\n });\n }\n}\n\n/\n Function to add a decode task to be performed\n \n @param taskType - the taskType for this task\n * @param data - data specific to the task\n * @param priority - optional priority of the task (defaults to 0), > 0 is higher, < 0 is lower\n * @param transferList - optional array of data to transfer to web worker\n * @returns {}\n /\nfunction addTask<T = any>(\n taskType: WorkerTaskTypes,\n data: WebWorkerDecodeTaskData,\n priority = 0,\n transferList: Transferable[]\n): { taskId: number; promise: Promise<T> } {\n if (!config) {\n initialize();\n }\n\n let deferred: WebWorkerDeferredObject<T> = {\n resolve: undefined,\n reject: undefined,\n };\n const promise = new Promise<T>((resolve, reject) => {\n deferred = {\n resolve,\n reject,\n };\n });\n\n // find the right spot to insert this decode task (based on priority)\n let i: number;\n\n for (i = 0; i < tasks.length; i++) {\n if (tasks[i].priority < priority) {\n break;\n }\n }\n\n const taskId = nextTaskId++;\n\n // insert the decode task at position i\n tasks.splice(i, 0, {\n taskId,\n taskType,\n status: 'ready',\n added: new Date().getTime(),\n data,\n deferred,\n priority,\n transferList,\n });\n\n // try to start a task on the web worker since we just added a new task and a web worker may be available\n startTaskOnWebWorker();\n\n return {\n taskId,\n promise,\n };\n}\n\n/*\n Changes the priority of a queued task\n * @param taskId - the taskId to change the priority of\n * @param priority - priority of the task (defaults to 0), > 0 is higher, < 0 is lower\n * @returns boolean - true on success, false if taskId not found\n /\nfunction setTaskPriority(taskId: number, priority = 0): boolean {\n // search for this taskId\n for (let i = 0; i < tasks.length; i++) {\n if (tasks[i].taskId === taskId) {\n // taskId found, remove it\n const task = tasks.splice(i, 1)[0];\n\n // set its priority\n task.priority = priority;\n\n // find the right spot to insert this decode task (based on priority)\n for (i = 0; i < tasks.length; i++) {\n if (tasks[i].priority < priority) {\n break;\n }\n }\n\n // insert the decode task at position i\n tasks.splice(i, 0, task);\n\n return true;\n }\n }\n\n return false;\n}\n\n/\n Cancels a queued task and rejects\n * @param taskId - the taskId to cancel\n * @param reason - optional reason the task was rejected\n * @returns boolean - true on success, false if taskId not found\n /\nfunction cancelTask(taskId: number, reason: string): boolean {\n // search for this taskId\n for (let i = 0; i < tasks.length; i++) {\n if (tasks[i].taskId === taskId) {\n // taskId found, remove it\n /\n @todo Check if this is a bug. Splice returns an array but task is\n * treated as a single task object\n /\n const task = tasks.splice(i, 1);\n\n (task as any).deferred.reject(reason);\n\n return true;\n }\n }\n\n return false;\n}\n\n/\n Function to return the statistics on running web workers\n * @returns object containing statistics\n /\nfunction getStatistics(): typeof config {\n statistics.maxWebWorkers = config.maxWebWorkers;\n statistics.numWebWorkers = webWorkers.length;\n statistics.numTasksQueued = tasks.length;\n\n return statistics;\n}\n\nexport default {\n initialize,\n loadWebWorkerTask,\n addTask,\n getStatistics,\n setTaskPriority,\n cancelTask,\n webWorkers,\n terminate,\n};\n","import decodeJPEGBaseline8BitColor from './decodeJPEGBaseline8BitColor';\nimport webWorkerManager from './webWorkerManager';\n\n// dicomParser requires pako for browser-side decoding of deflate transfer syntax\n// We only need one function though, so lets import that so we don't make our bundle\n// too large.\nimport { ByteArray } from 'dicom-parser';\nimport { inflateRaw } from 'pako/lib/inflate';\nimport { ImageFrame, LoaderDecodeOptions } from '../types';\n\n(window as any).pako = { inflateRaw };\n\nfunction processDecodeTask(\n imageFrame: ImageFrame,\n transferSyntax: string,\n pixelData: ByteArray,\n srcOptions,\n decodeConfig: LoaderDecodeOptions\n): Promise<ImageFrame> {\n const options = { ...srcOptions };\n // If a loader is specified, it can't be passed through because it is a function\n // and can't be safely cloned/copied externally.\n delete options.loader;\n // Similarly, the streamData may contain larger data information and\n // although it can be passed to the decoder, it isn't needed and is slow\n delete options.streamingData;\n\n const priority = options.priority \|\| undefined;\n const transferList = options.transferPixelData\n ? [pixelData.buffer]\n : undefined;\n\n return webWorkerManager.addTask(\n 'decodeTask',\n {\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig,\n },\n priority,\n transferList\n ).promise;\n}\n\nfunction decodeImageFrame(\n imageFrame,\n transferSyntax,\n pixelData,\n canvas,\n options = {},\n decodeConfig\n) {\n switch (transferSyntax) {\n case '1.2.840.10008.1.2':\n // Implicit VR Little Endian\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.1':\n // Explicit VR Little Endian\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.2':\n // Explicit VR Big Endian (retired)\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.1.99':\n // Deflate transfer syntax (deflated by dicomParser)\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.5':\n // RLE Lossless\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.50':\n // JPEG Baseline lossy process 1 (8 bit)\n\n // Handle 8-bit JPEG Baseline color images using the browser's built-in\n // JPEG decoding\n if (\n imageFrame.bitsAllocated === 8 &&\n (imageFrame.samplesPerPixel === 3 \|\| imageFrame.samplesPerPixel === 4)\n ) {\n return decodeJPEGBaseline8BitColor(imageFrame, pixelData, canvas);\n }\n\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.51':\n // JPEG Baseline lossy process 2 & 4 (12 bit)\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.57':\n // JPEG Lossless, Nonhierarchical (Processes 14)\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.70':\n // JPEG Lossless, Nonhierarchical (Processes 14 [Selection 1])\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.80':\n // JPEG-LS Lossless Image Compression\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.81':\n // JPEG-LS Lossy (Near-Lossless) Image Compression\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.90':\n // JPEG 2000 Lossless\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n case '1.2.840.10008.1.2.4.91':\n // JPEG 2000 Lossy\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n\n case '3.2.840.10008.1.2.4.96':\n case '1.2.840.10008.1.2.4.201':\n case '1.2.840.10008.1.2.4.202':\n case '1.2.840.10008.1.2.4.203':\n // HTJ2K\n return processDecodeTask(\n imageFrame,\n transferSyntax,\n pixelData,\n options,\n decodeConfig\n );\n }\n\n / Don't know if these work...\n // JPEG 2000 Part 2 Multicomponent Image Compression (Lossless Only)\n else if(transferSyntax === \"1.2.840.10008.1.2.4.92\")\n {\n return cornerstoneDICOMImageLoader.decodeJPEG2000(dataSet, frame);\n }\n // JPEG 2000 Part 2 Multicomponent Image Compression\n else if(transferSyntax === \"1.2.840.10008.1.2.4.93\")\n {\n return cornerstoneDICOMImageLoader.decodeJPEG2000(dataSet, frame);\n }\n /\n\n return Promise.reject(\n new Error(`No decoder for transfer syntax ${transferSyntax}`)\n );\n}\n\nexport default decodeImageFrame;\n","import external from '../externalModules';\nimport { ImageFrame, MetadataImagePixelModule } from '../types';\n\nfunction getImageFrame(imageId: string): ImageFrame {\n const { cornerstone } = external;\n const imagePixelModule: MetadataImagePixelModule = cornerstone.metaData.get(\n 'imagePixelModule',\n imageId\n );\n\n return {\n samplesPerPixel: imagePixelModule.samplesPerPixel,\n photometricInterpretation: imagePixelModule.photometricInterpretation,\n planarConfiguration: imagePixelModule.planarConfiguration,\n rows: imagePixelModule.rows,\n columns: imagePixelModule.columns,\n bitsAllocated: imagePixelModule.bitsAllocated,\n bitsStored: imagePixelModule.bitsStored,\n pixelRepresentation: imagePixelModule.pixelRepresentation, // 0 = unsigned,\n smallestPixelValue: imagePixelModule.smallestPixelValue,\n largestPixelValue: imagePixelModule.largestPixelValue,\n redPaletteColorLookupTableDescriptor:\n imagePixelModule.redPaletteColorLookupTableDescriptor,\n greenPaletteColorLookupTableDescriptor:\n imagePixelModule.greenPaletteColorLookupTableDescriptor,\n bluePaletteColorLookupTableDescriptor:\n imagePixelModule.bluePaletteColorLookupTableDescriptor,\n redPaletteColorLookupTableData:\n imagePixelModule.redPaletteColorLookupTableData,\n greenPaletteColorLookupTableData:\n imagePixelModule.greenPaletteColorLookupTableData,\n bluePaletteColorLookupTableData:\n imagePixelModule.bluePaletteColorLookupTableData,\n pixelData: undefined, // populated later after decoding\n imageId,\n };\n}\n\nexport default getImageFrame;\n","export default function (photoMetricInterpretation: string): boolean {\n return (\n photoMetricInterpretation === 'RGB' \|\|\n photoMetricInterpretation === 'PALETTE COLOR' \|\|\n photoMetricInterpretation === 'YBR_FULL' \|\|\n photoMetricInterpretation === 'YBR_FULL_422' \|\|\n photoMetricInterpretation === 'YBR_PARTIAL_422' \|\|\n photoMetricInterpretation === 'YBR_PARTIAL_420' \|\|\n photoMetricInterpretation === 'YBR_RCT' \|\|\n photoMetricInterpretation === 'YBR_ICT'\n );\n}\n","import { ByteArray } from 'dicom-parser';\nimport external from '../externalModules';\nimport getMinMax from '../shared/getMinMax';\nimport getPixelDataTypeFromMinMax from '../shared/getPixelDataTypeFromMinMax';\nimport {\n DICOMLoaderImageOptions,\n MetadataImagePlaneModule,\n MetadataSopCommonModule,\n DICOMLoaderIImage,\n ImageFrame,\n PixelDataTypedArray,\n} from '../types';\nimport convertColorSpace from './convertColorSpace';\nimport isColorConversionRequired from './isColorConversionRequired';\nimport decodeImageFrame from './decodeImageFrame';\nimport getImageFrame from './getImageFrame';\nimport getScalingParameters from './getScalingParameters';\nimport { getOptions } from './internal/options';\nimport isColorImageFn from '../shared/isColorImage';\n\nlet lastImageIdDrawn = '';\n\nfunction isModalityLUTForDisplay(sopClassUid: string): boolean {\n // special case for XA and XRF\n // https://groups.google.com/forum/#!searchin/comp.protocols.dicom/Modality$20LUT$20XA/comp.protocols.dicom/UBxhOZ2anJ0/D0R_QP8V2wIJ\n return (\n sopClassUid !== '1.2.840.10008.5.1.4.1.1.12.1' && // XA\n sopClassUid !== '1.2.840.10008.5.1.4.1.1.12.2.1'\n ); // XRF\n}\n\n/\n Helper function to set pixel d2023-03-17-16-35-04.pngata to the right typed array.\n * This is needed because web workers can transfer array buffers but not typed arrays\n \n Here we are setting the pixel data to the right typed array based on the final\n * min and max values\n /\nfunction setPixelDataType(imageFrame) {\n const minValue = imageFrame.smallestPixelValue;\n const maxValue = imageFrame.largestPixelValue;\n\n const TypedArray = getPixelDataTypeFromMinMax(minValue, maxValue);\n\n if (TypedArray) {\n const typedArray = new TypedArray(imageFrame.pixelData);\n imageFrame.pixelData = typedArray;\n } else {\n throw new Error('Could not apply a typed array to the pixel data');\n }\n}\n\n/\n Removes the A from RGBA to return RGB buffer, this is used when the\n * decoding happens with browser API which results in RGBA, but if useRGBA flag\n * is set to false, we want to return RGB\n \n @param pixelData - decoded image in RGBA\n * @param targetBuffer - target buffer to write to\n /\nfunction removeAFromRGBA(\n pixelData: PixelDataTypedArray,\n targetBuffer: Uint8ClampedArray \| Uint8Array\n) {\n const numPixels = pixelData.length / 4;\n\n let rgbIndex = 0;\n\n let bufferIndex = 0;\n\n for (let i = 0; i < numPixels; i++) {\n targetBuffer[bufferIndex++] = pixelData[rgbIndex++]; // red\n targetBuffer[bufferIndex++] = pixelData[rgbIndex++]; // green\n targetBuffer[bufferIndex++] = pixelData[rgbIndex++]; // blue\n rgbIndex++; // skip alpha\n }\n\n return targetBuffer;\n}\n\nfunction createImage(\n imageId: string,\n pixelData: ByteArray,\n transferSyntax: string,\n options: DICOMLoaderImageOptions = {}\n): Promise<DICOMLoaderIImage \| ImageFrame> {\n // whether to use RGBA for color images, default true as cs-legacy uses RGBA\n // but we don't need RGBA in cs3d, and it's faster, and memory-efficient\n // in cs3d\n const useRGBA = options.useRGBA;\n\n // always preScale the pixel array unless it is asked not to\n options.preScale = {\n enabled:\n options.preScale && options.preScale.enabled !== undefined\n ? options.preScale.enabled\n : false,\n };\n\n if (!pixelData?.length) {\n return Promise.reject(new Error('The pixel data is missing'));\n }\n\n const { cornerstone } = external;\n const { MetadataModules } = cornerstone.Enums;\n const canvas = document.createElement('canvas');\n const imageFrame = getImageFrame(imageId);\n imageFrame.decodeLevel = options.decodeLevel;\n\n options.allowFloatRendering = cornerstone.canRenderFloatTextures();\n\n // Get the scaling parameters from the metadata\n if (options.preScale.enabled) {\n const scalingParameters = getScalingParameters(\n cornerstone.metaData,\n imageId\n );\n\n if (scalingParameters) {\n options.preScale = {\n ...options.preScale,\n scalingParameters,\n };\n }\n }\n\n // we need to identify if the target buffer is a SharedArrayBuffer\n // since inside the webworker we don't have access to the window\n // to say if it is a SharedArrayBuffer or not with instanceof\n options.isSharedArrayBuffer =\n options.targetBuffer?.arrayBuffer &&\n options.targetBuffer.arrayBuffer instanceof SharedArrayBuffer;\n\n const { decodeConfig } = getOptions();\n\n // check if the options to use the 16 bit data type is set\n // on the image load options, and prefer that over the global\n // options of the dicom loader\n decodeConfig.use16BitDataType =\n (options && options.targetBuffer?.type === 'Uint16Array') \|\|\n options.targetBuffer?.type === 'Int16Array'\n ? true\n : options.useNativeDataType \|\| decodeConfig.use16BitDataType;\n\n // Remove any property of the `imageFrame` that cannot be transferred to the worker,\n // such as promises and functions.\n // This is necessary because the `imageFrame` object is passed to the worker.\n Object.keys(imageFrame).forEach((key) => {\n if (\n typeof imageFrame[key] === 'function' \|\|\n imageFrame[key] instanceof Promise\n ) {\n delete imageFrame[key];\n }\n });\n\n const decodePromise = decodeImageFrame(\n imageFrame,\n transferSyntax,\n pixelData,\n canvas,\n options,\n decodeConfig\n );\n\n const { use16BitDataType } = decodeConfig;\n const isColorImage = isColorImageFn(imageFrame.photometricInterpretation);\n\n return new Promise<DICOMLoaderIImage \| ImageFrame>((resolve, reject) => {\n // eslint-disable-next-line complexity\n decodePromise.then(function (imageFrame: ImageFrame) {\n // if it is desired to skip creating image, return the imageFrame\n // after the decode. This might be useful for some applications\n // that only need the decoded pixel data and not the image object\n if (options.skipCreateImage) {\n return resolve(imageFrame);\n }\n // If we have a target buffer that was written to in the\n // Decode task, point the image to it here.\n // We can't have done it within the thread incase it was a SharedArrayBuffer.\n let alreadyTyped = false;\n // We can safely render color image in 8 bit, so no need to convert\n if (options.targetBuffer && options.targetBuffer.type && !isColorImage) {\n const {\n arrayBuffer,\n type,\n offset: rawOffset = 0,\n length: rawLength,\n } = options.targetBuffer;\n\n const imageFrameLength = imageFrame.pixelDataLength;\n\n const offset = rawOffset;\n const length =\n rawLength !== null && rawLength !== undefined\n ? rawLength\n : imageFrameLength - offset;\n\n const typedArrayConstructors = {\n Uint8Array,\n Uint16Array: use16BitDataType ? Uint16Array : undefined,\n Int16Array: use16BitDataType ? Int16Array : undefined,\n Float32Array,\n };\n\n if (length !== imageFrame.pixelDataLength) {\n throw new Error(\n `target array for image does not have the same length (${length}) as the decoded image length (${imageFrame.pixelDataLength}).`\n );\n }\n\n const TypedArrayConstructor = typedArrayConstructors[type];\n\n // TypedArray.Set is api level and ~50x faster than copying elements even for\n // Arrays of different types, which aren't simply memcpy ops.\n const typedArray = arrayBuffer\n ? new TypedArrayConstructor(arrayBuffer, offset, length)\n : new TypedArrayConstructor(imageFrame.pixelData);\n\n if (length !== imageFrame.pixelDataLength) {\n throw new Error(\n 'target array for image does not have the same length as the decoded image length.'\n );\n }\n\n imageFrame.pixelData = typedArray;\n alreadyTyped = true;\n }\n\n if (!alreadyTyped) {\n setPixelDataType(imageFrame);\n }\n\n const imagePlaneModule: MetadataImagePlaneModule =\n cornerstone.metaData.get(MetadataModules.IMAGE_PLANE, imageId) \|\| {};\n const voiLutModule =\n cornerstone.metaData.get(MetadataModules.VOI_LUT, imageId) \|\| {};\n const modalityLutModule =\n cornerstone.metaData.get(MetadataModules.MODALITY_LUT, imageId) \|\| {};\n const sopCommonModule: MetadataSopCommonModule =\n cornerstone.metaData.get(MetadataModules.SOP_COMMON, imageId) \|\| {};\n const calibrationModule =\n cornerstone.metaData.get(MetadataModules.CALIBRATION, imageId) \|\| {};\n const { rows, columns } = imageFrame;\n\n if (isColorImage) {\n if (isColorConversionRequired(imageFrame)) {\n canvas.height = imageFrame.rows;\n canvas.width = imageFrame.columns;\n const context = canvas.getContext('2d');\n let imageData = context.createImageData(\n imageFrame.columns,\n imageFrame.rows\n );\n if (!useRGBA) {\n imageData = {\n ...imageData,\n data: new Uint8ClampedArray(\n imageFrame.samplesPerPixel \n imageFrame.columns \n imageFrame.rows\n ),\n };\n }\n convertColorSpace(imageFrame, imageData.data, useRGBA);\n imageFrame.imageData = imageData;\n imageFrame.pixelData = imageData.data;\n imageFrame.pixelDataLength = imageData.data.length;\n } else if (\n !useRGBA &&\n imageFrame.pixelDataLength === 4 rows * columns\n ) {\n // This case is the case where we need RGB (that is !useRGBA), and\n // we have RGBA (that is 4 values per pixel, not 3). For this case,\n // remove the A value.\n // Note: rendering libraries like vtk expect Uint8Array for RGB images\n // otherwise they will convert them to Float32Array which might be slow\n const colorBuffer = new Uint8Array(\n (imageFrame.pixelData.length / 4) * 3\n );\n\n // remove the A from the RGBA of the imageFrame\n imageFrame.pixelData = removeAFromRGBA(\n imageFrame.pixelData,\n colorBuffer\n );\n\n imageFrame.pixelDataLength = imageFrame.pixelData.length;\n }\n // else {\n // No need to do any conversion - already RGB\n // Consider RGB to RGBA conversion?\n\n /** @todo check as any /\n // calculate smallest and largest PixelValue of the converted pixelData\n const minMax = getMinMax(imageFrame.pixelData as any);\n\n imageFrame.smallestPixelValue = minMax.min;\n imageFrame.largestPixelValue = minMax.max;\n }\n\n const image: DICOMLoaderIImage = {\n imageId,\n color: isColorImage,\n calibration: calibrationModule,\n columnPixelSpacing: imagePlaneModule.columnPixelSpacing,\n columns: imageFrame.columns,\n height: imageFrame.rows,\n preScale: imageFrame.preScale,\n intercept: modalityLutModule.rescaleIntercept\n ? modalityLutModule.rescaleIntercept\n : 0,\n slope: modalityLutModule.rescaleSlope\n ? modalityLutModule.rescaleSlope\n : 1,\n invert: imageFrame.photometricInterpretation === 'MONOCHROME1',\n minPixelValue: imageFrame.smallestPixelValue,\n maxPixelValue: imageFrame.largestPixelValue,\n rowPixelSpacing: imagePlaneModule.rowPixelSpacing,\n rows: imageFrame.rows,\n sizeInBytes: imageFrame.pixelData.byteLength,\n width: imageFrame.columns,\n // use the first value for rendering, if other values\n // are needed later, it can be grabbed again from the voiLUtModule\n windowCenter: voiLutModule.windowCenter\n ? voiLutModule.windowCenter[0]\n : undefined,\n windowWidth: voiLutModule.windowWidth\n ? voiLutModule.windowWidth[0]\n : undefined,\n voiLUTFunction: voiLutModule.voiLUTFunction\n ? voiLutModule.voiLUTFunction\n : undefined,\n decodeTimeInMS: imageFrame.decodeTimeInMS,\n floatPixelData: undefined,\n imageFrame,\n rgba: isColorImage && useRGBA,\n getPixelData: () => imageFrame.pixelData,\n getCanvas: undefined,\n numComps: undefined,\n };\n\n if (image.color) {\n image.getCanvas = function () {\n // the getCanvas function is used in the CPU rendering path\n // and it is used to use the canvas api to draw the image\n // instead of looping through the pixel data and drawing each pixel\n // to use the canvas api, we need to convert the pixel data to a\n // Uint8ClampedArray (which is what the canvas api expects)\n // and then we can use the putImageData api to draw the image\n // However, if the image already was loaded without the alpha channel\n // we need to add the alpha channel back in\n if (lastImageIdDrawn === imageId) {\n return canvas;\n }\n\n const width = image.columns;\n const height = image.rows;\n\n canvas.height = height;\n canvas.width = width;\n const ctx = canvas.getContext('2d');\n const imageData = ctx.createImageData(width, height);\n\n const arr = imageFrame.pixelData;\n\n if (arr.length === width height * 4) {\n for (let i = 0; i < arr.length; i++) {\n imageData.data[i] = arr[i];\n }\n }\n // Set pixel data for RGB array\n else if (arr.length === width * height * 3) {\n let j = 0;\n for (let i = 0; i < arr.length; i += 3) {\n imageData.data[j++] = arr[i];\n imageData.data[j++] = arr[i + 1];\n imageData.data[j++] = arr[i + 2];\n imageData.data[j++] = 255;\n }\n }\n\n imageFrame.pixelData = imageData.data;\n imageFrame.pixelDataLength = imageData.data.length;\n\n imageFrame.imageData = imageData;\n ctx.putImageData(imageFrame.imageData, 0, 0);\n lastImageIdDrawn = imageId;\n\n return canvas;\n };\n }\n\n // Modality LUT\n if (\n modalityLutModule.modalityLUTSequence &&\n modalityLutModule.modalityLUTSequence.length > 0 &&\n isModalityLUTForDisplay(sopCommonModule.sopClassUID)\n ) {\n image.modalityLUT = modalityLutModule.modalityLUTSequence[0];\n }\n\n // VOI LUT\n if (\n voiLutModule.voiLUTSequence &&\n voiLutModule.voiLUTSequence.length > 0\n ) {\n image.voiLUT = voiLutModule.voiLUTSequence[0];\n }\n\n if (image.color) {\n // Note that by the DICOM definition, the window width and center are\n // 256/128 for an identity transform.\n image.windowWidth = 256;\n image.windowCenter = 128;\n }\n\n // set the ww/wc to cover the dynamic range of the image if no values are supplied\n if (image.windowCenter === undefined \|\| image.windowWidth === undefined) {\n const minVoi = image.imageFrame.minAfterScale;\n const maxVoi = image.imageFrame.maxAfterScale;\n\n image.windowWidth = maxVoi - minVoi;\n image.windowCenter = (maxVoi + minVoi) / 2;\n }\n resolve(image);\n }, reject);\n });\n}\n\nexport default createImage;\n","import { PixelDataTypedArray } from '../types';\n\nexport default function getPixelDataTypeFromMinMax(\n min: number,\n max: number\n): PixelDataTypedArray {\n let pixelDataType;\n if (Number.isInteger(min) && Number.isInteger(max)) {\n if (min >= 0) {\n if (max <= 255) {\n pixelDataType = Uint8Array;\n } else if (max <= 65535) {\n pixelDataType = Uint16Array;\n }\n } else {\n if (min >= -128 && max <= 127) {\n pixelDataType = Int8Array;\n } else if (min >= -32768 && max <= 32767) {\n pixelDataType = Int16Array;\n }\n }\n }\n\n return pixelDataType \|\| Float32Array;\n}\n","import { MetadataGeneralSeriesModule } from '../types';\n\n/*\n It returns the scaling parameters for the image with the given imageId. This can be\n * used to get passed (as an option) to the imageLoader in order to apply scaling to the image inside\n * the imageLoader.\n * @param imageId - The imageId of the image\n * @returns ScalingParameters\n /\nexport default function getScalingParameters(metaData: any, imageId: string) {\n const modalityLutModule = metaData.get('modalityLutModule', imageId) \|\| {};\n\n const generalSeriesModule: MetadataGeneralSeriesModule =\n metaData.get('generalSeriesModule', imageId) \|\| {};\n\n const { modality } = generalSeriesModule;\n\n const scalingParameters = {\n rescaleSlope: modalityLutModule.rescaleSlope,\n rescaleIntercept: modalityLutModule.rescaleIntercept,\n modality,\n };\n\n const suvFactor = metaData.get('scalingModule', imageId) \|\| {};\n\n return {\n ...scalingParameters,\n ...(modality === 'PT' && { suvbw: suvFactor.suvbw }),\n };\n}\n","/\n This function checks color space conversion data requirements before\n * applying them. This function was created to solve problems like the one\n * discussed in here https://discourse.orthanc-server.org/t/orthanc-convert-ybr-to-rgb-but-does-not-change-metadata/3533/17\n * In this case, Orthanc server converts the pixel data from YBR to RGB, but maintain\n * the photometricInterpretation dicom tag in YBR\n * @param imageFrame\n * @param RGBA\n * @returns\n /\nexport default function isColorConversionRequired(imageFrame) {\n if (imageFrame === undefined) {\n return false;\n }\n const { rows, columns, photometricInterpretation, pixelDataLength } =\n imageFrame;\n\n // if it is rgba don't convert (typically jpeg, jpeg-xl, jpeg2000 etc)\n if (pixelDataLength === 4 columns * rows) {\n // RGBA - JPEG\n return false;\n }\n\n if (photometricInterpretation.endsWith('420')) {\n return (\n pixelDataLength ===\n (3 * Math.ceil(columns / 2) + Math.floor(columns / 2)) * rows\n );\n } else if (photometricInterpretation.endsWith('422')) {\n return (\n pixelDataLength ===\n (3 * Math.ceil(columns / 2) + Math.floor(columns / 2)) \n Math.ceil(rows / 2) +\n Math.floor(rows / 2) columns\n );\n } else {\n return photometricInterpretation !== 'RGB';\n // and it is one of the rle and lei cases then we need to convert\n }\n}\n","import { Enums, utilities, metaData } from '@cornerstonejs/core';\nimport type { Types, RetrieveOptions } from '@cornerstonejs/core';\n\nimport external from '../../externalModules';\nimport createImage from '../createImage';\nimport getPixelData from './getPixelData';\nimport { DICOMLoaderIImage, DICOMLoaderImageOptions } from '../../types';\n\nconst { ProgressiveIterator } = utilities;\nconst { ImageQualityStatus } = Enums;\nconst streamableTransferSyntaxes = new Set<string>([\n // Private HTJ2K\n '3.2.840.10008.1.2.4.96',\n // Released HTJ2K - only the RPCL one is definitely streamable.\n '1.2.840.10008.1.2.4.202',\n // HTJ2K lossy might be streamable, so try it. If it fails it is ok as it will\n // proceed and eventually work.\n '1.2.840.10008.1.2.4.203',\n]);\n\n/*\n Helper method to extract the transfer-syntax from the response of the server.\n * @param {string} contentType The value of the content-type header as returned by the WADO-RS server.\n * @return The transfer-syntax as announced by the server, or Implicit Little Endian by default.\n /\nexport function getTransferSyntaxForContentType(contentType: string): string {\n const defaultTransferSyntax = '1.2.840.10008.1.2'; // Default is Implicit Little Endian.\n if (!contentType) {\n return defaultTransferSyntax;\n }\n\n // Browse through the content type parameters\n const parameters = contentType.split(';');\n const params: Record<string, string> = {};\n\n parameters.forEach((parameter) => {\n // Look for a transfer-syntax=XXXX pair\n const parameterValues = parameter.split('=');\n\n if (parameterValues.length !== 2) {\n return;\n }\n\n const value = parameterValues[1].trim().replace(/\"/g, '');\n\n params[parameterValues[0].trim()] = value;\n });\n\n // This is useful if the PACS doesn't respond with a syntax\n // in the content type.\n // http://dicom.nema.org/medical/dicom/current/output/chtml/part18/chapter_6.html#table_6.1.1.8-3b\n const defaultTransferSyntaxByType = {\n 'image/jpeg': '1.2.840.10008.1.2.4.50',\n 'image/x-dicom-rle': '1.2.840.10008.1.2.5',\n 'image/x-jls': '1.2.840.10008.1.2.4.80',\n 'image/jls': '1.2.840.10008.1.2.4.80',\n 'image/jll': '1.2.840.10008.1.2.4.70',\n 'image/jp2': '1.2.840.10008.1.2.4.90',\n 'image/jpx': '1.2.840.10008.1.2.4.92',\n // Temporary types, until ratified by DICOM committed - TODO\n 'image/jphc': '3.2.840.10008.1.2.4.96',\n 'image/jxl': '1.2.840.10008.1.2.4.140',\n };\n\n if (params['transfer-syntax']) {\n return params['transfer-syntax'];\n } else if (\n contentType &&\n !Object.keys(params).length &&\n defaultTransferSyntaxByType[contentType]\n ) {\n // dcm4che seems to be reporting the content type as just 'image/jp2'?\n return defaultTransferSyntaxByType[contentType];\n } else if (params.type && defaultTransferSyntaxByType[params.type]) {\n return defaultTransferSyntaxByType[params.type];\n } else if (defaultTransferSyntaxByType[contentType]) {\n return defaultTransferSyntaxByType[contentType];\n }\n\n return defaultTransferSyntax;\n}\n\nfunction getImageRetrievalPool() {\n return external.cornerstone.imageRetrievalPoolManager;\n}\n\nexport interface StreamingData {\n url: string;\n encodedData?: Uint8Array;\n // Some values used by instances of streaming data for range\n totalBytes?: number;\n chunkSize?: number;\n totalRanges?: number;\n rangesFetched?: number;\n}\n\nexport interface CornerstoneWadoRsLoaderOptions\n extends DICOMLoaderImageOptions {\n requestType?: string;\n additionalDetails?: {\n imageId: string;\n };\n priority?: number;\n addToBeginning?: boolean;\n retrieveType?: string;\n transferSyntaxUID?: string;\n // Retrieve options are stored to provide sub-options for nested calls\n retrieveOptions?: RetrieveOptions;\n // Streaming data adds information about already streamed results.\n streamingData?: StreamingData;\n}\n\n// TODO: load bulk data items that we might need\n\n// Uncomment this on to test jpegls codec in OHIF\n// const mediaType = 'multipart/related; type=\"image/x-jls\"';\n// const mediaType = 'multipart/related; type=\"application/octet-stream\"; transfer-syntax=\"image/x-jls\"';\nconst mediaType =\n 'multipart/related; type=application/octet-stream; transfer-syntax=';\n\nfunction loadImage(\n imageId: string,\n options: CornerstoneWadoRsLoaderOptions = {}\n): Types.IImageLoadObject {\n const imageRetrievalPool = getImageRetrievalPool();\n\n const start = new Date().getTime();\n\n const uncompressedIterator = new ProgressiveIterator<DICOMLoaderIImage>(\n 'decompress'\n );\n async function sendXHR(imageURI: string, imageId: string, mediaType: string) {\n uncompressedIterator.generate(async (it) => {\n // get the pixel data from the server\n const compressedIt = ProgressiveIterator.as(\n getPixelData(imageURI, imageId, mediaType, options)\n );\n let lastDecodeLevel = 10;\n for await (const result of compressedIt) {\n const {\n pixelData,\n imageQualityStatus = ImageQualityStatus.FULL_RESOLUTION,\n percentComplete,\n done = true,\n extractDone = true,\n } = result;\n const transferSyntax = getTransferSyntaxForContentType(\n result.contentType\n );\n if (!extractDone && !streamableTransferSyntaxes.has(transferSyntax)) {\n continue;\n }\n const decodeLevel =\n result.decodeLevel ??\n (imageQualityStatus === ImageQualityStatus.FULL_RESOLUTION\n ? 0\n : decodeLevelFromComplete(\n percentComplete,\n options.retrieveOptions?.decodeLevel\n ));\n if (!done && lastDecodeLevel <= decodeLevel) {\n // No point trying again yet\n continue;\n }\n\n try {\n const useOptions = {\n ...options,\n decodeLevel,\n };\n const image = (await createImage(\n imageId,\n pixelData,\n transferSyntax,\n useOptions\n )) as DICOMLoaderIImage;\n\n // add the loadTimeInMS property\n const end = new Date().getTime();\n\n image.loadTimeInMS = end - start;\n image.transferSyntaxUID = transferSyntax;\n image.imageQualityStatus = imageQualityStatus;\n // The iteration is done even if the image itself isn't done yet\n it.add(image, done);\n lastDecodeLevel = decodeLevel;\n } catch (e) {\n if (extractDone) {\n console.warn(\"Couldn't decode\", e);\n throw e;\n }\n }\n }\n });\n }\n\n const requestType = options.requestType \|\| 'interaction';\n const additionalDetails = options.additionalDetails \|\| { imageId };\n const priority = options.priority === undefined ? 5 : options.priority;\n const addToBeginning = options.addToBeginning \|\| false;\n const uri = imageId.substring(7);\n\n imageRetrievalPool.addRequest(\n sendXHR.bind(this, uri, imageId, mediaType),\n requestType,\n additionalDetails,\n priority,\n addToBeginning\n );\n\n return {\n promise: uncompressedIterator.getDonePromise(),\n cancelFn: undefined,\n };\n}\n\n/** The decode level is based on how much of hte data is needed for\n * each level. It is a square function, so\n * level 4 only needs 1/25 of the data (eg (4+1)^2). Add 2% to ensure\n * there is enough space\n /\nfunction decodeLevelFromComplete(percent: number, retrieveDecodeLevel = 4) {\n const testSize = percent / 100 - 0.02;\n if (testSize > 1 / 4) {\n return Math.min(retrieveDecodeLevel, 0);\n }\n if (testSize > 1 / 16) {\n return Math.min(retrieveDecodeLevel, 1);\n }\n if (testSize > 1 / 64) {\n return Math.min(retrieveDecodeLevel, 2);\n }\n return Math.min(retrieveDecodeLevel, 3);\n}\n\nexport default loadImage;\n","import {\n getNumberString,\n getNumberValue,\n getNumberValues,\n getValue,\n metaDataProvider,\n} from './metaData/index';\n\nimport findIndexOfString from './findIndexOfString';\nimport getPixelData from './getPixelData';\nimport metaDataManager from './metaDataManager';\nimport loadImage from './loadImage';\nimport register from './register';\n\nconst metaData = {\n getNumberString,\n getNumberValue,\n getNumberValues,\n getValue,\n metaDataProvider,\n};\n\nexport default {\n metaData,\n findIndexOfString,\n getPixelData,\n loadImage,\n metaDataManager,\n register,\n};\n","import loadImage from './loadImage';\nimport { metaDataProvider } from './metaData/index';\n\nexport default function (cornerstone) {\n // register wadors scheme and metadata provider\n cornerstone.registerImageLoader('wadors', loadImage);\n cornerstone.metaData.addProvider(metaDataProvider);\n}\n","import { MetadataImagePixelModule } from '../../../types';\nimport { DataSet } from 'dicom-parser';\n\nfunction getLutDescriptor(dataSet: DataSet, tag: string) {\n if (!dataSet.elements[tag] \|\| dataSet.elements[tag].length !== 6) {\n return;\n }\n\n return [\n dataSet.uint16(tag, 0),\n dataSet.uint16(tag, 1),\n dataSet.uint16(tag, 2),\n ];\n}\n\nfunction getLutData(lutDataSet: DataSet, tag: string, lutDescriptor): number[] {\n const lut = [];\n const lutData = lutDataSet.elements[tag];\n\n for (let i = 0; i < lutDescriptor[0]; i++) {\n // Output range is always unsigned\n if (lutDescriptor[2] === 16) {\n lut[i] = lutDataSet.uint16(tag, i);\n } else {\n lut[i] = lutDataSet.byteArray[i + lutData.dataOffset];\n }\n }\n\n return lut;\n}\n\nfunction populatePaletteColorLut(\n dataSet: DataSet,\n imagePixelModule: MetadataImagePixelModule\n) {\n imagePixelModule.redPaletteColorLookupTableDescriptor = getLutDescriptor(\n dataSet,\n 'x00281101'\n );\n imagePixelModule.greenPaletteColorLookupTableDescriptor = getLutDescriptor(\n dataSet,\n 'x00281102'\n );\n imagePixelModule.bluePaletteColorLookupTableDescriptor = getLutDescriptor(\n dataSet,\n 'x00281103'\n );\n\n // The first Palette Color Lookup Table Descriptor value is the number of entries in the lookup table.\n // When the number of table entries is equal to 2ˆ16 then this value shall be 0.\n // See http://dicom.nema.org/MEDICAL/DICOM/current/output/chtml/part03/sect_C.7.6.3.html#sect_C.7.6.3.1.5\n if (imagePixelModule.redPaletteColorLookupTableDescriptor[0] === 0) {\n imagePixelModule.redPaletteColorLookupTableDescriptor[0] = 65536;\n imagePixelModule.greenPaletteColorLookupTableDescriptor[0] = 65536;\n imagePixelModule.bluePaletteColorLookupTableDescriptor[0] = 65536;\n }\n\n // The third Palette Color Lookup Table Descriptor value specifies the number of bits for each entry in the Lookup Table Data.\n // It shall take the value of 8 or 16.\n // The LUT Data shall be stored in a format equivalent to 8 bits allocated when the number of bits for each entry is 8, and 16 bits allocated when the number of bits for each entry is 16, where in both cases the high bit is equal to bits allocated-1.\n // The third value shall be identical for each of the Red, Green and Blue Palette Color Lookup Table Descriptors.\n //\n // Note: Some implementations have encoded 8 bit entries with 16 bits allocated, padding the high bits;\n // this can be detected by comparing the number of entries specified in the LUT Descriptor with the actual value length of the LUT Data entry.\n // The value length in bytes should equal the number of entries if bits allocated is 8, and be twice as long if bits allocated is 16.\n const numLutEntries =\n imagePixelModule.redPaletteColorLookupTableDescriptor[0];\n const lutData = dataSet.elements.x00281201;\n const lutBitsAllocated = lutData.length === numLutEntries ? 8 : 16;\n\n // If the descriptors do not appear to have the correct values, correct them\n if (\n imagePixelModule.redPaletteColorLookupTableDescriptor[2] !==\n lutBitsAllocated\n ) {\n imagePixelModule.redPaletteColorLookupTableDescriptor[2] = lutBitsAllocated;\n imagePixelModule.greenPaletteColorLookupTableDescriptor[2] =\n lutBitsAllocated;\n imagePixelModule.bluePaletteColorLookupTableDescriptor[2] =\n lutBitsAllocated;\n }\n\n imagePixelModule.redPaletteColorLookupTableData = getLutData(\n dataSet,\n 'x00281201',\n imagePixelModule.redPaletteColorLookupTableDescriptor\n );\n imagePixelModule.greenPaletteColorLookupTableData = getLutData(\n dataSet,\n 'x00281202',\n imagePixelModule.greenPaletteColorLookupTableDescriptor\n );\n imagePixelModule.bluePaletteColorLookupTableData = getLutData(\n dataSet,\n 'x00281203',\n imagePixelModule.bluePaletteColorLookupTableDescriptor\n );\n}\n\nfunction populateSmallestLargestPixelValues(\n dataSet: DataSet,\n imagePixelModule: MetadataImagePixelModule\n) {\n const pixelRepresentation = dataSet.uint16('x00280103');\n\n if (pixelRepresentation === 0) {\n imagePixelModule.smallestPixelValue = dataSet.uint16('x00280106');\n imagePixelModule.largestPixelValue = dataSet.uint16('x00280107');\n } else {\n imagePixelModule.smallestPixelValue = dataSet.int16('x00280106');\n imagePixelModule.largestPixelValue = dataSet.int16('x00280107');\n }\n}\n\nfunction getImagePixelModule(dataSet: DataSet): MetadataImagePixelModule {\n const imagePixelModule = {\n samplesPerPixel: dataSet.uint16('x00280002'),\n photometricInterpretation: dataSet.string('x00280004'),\n rows: dataSet.uint16('x00280010'),\n columns: dataSet.uint16('x00280011'),\n bitsAllocated: dataSet.uint16('x00280100'),\n bitsStored: dataSet.uint16('x00280101'),\n highBit: dataSet.uint16('x00280102'),\n pixelRepresentation: dataSet.uint16('x00280103'),\n planarConfiguration: dataSet.uint16('x00280006'),\n pixelAspectRatio: dataSet.string('x00280034'),\n } as MetadataImagePixelModule;\n\n populateSmallestLargestPixelValues(dataSet, imagePixelModule);\n\n if (\n imagePixelModule.photometricInterpretation === 'PALETTE COLOR' &&\n dataSet.elements.x00281101\n ) {\n populatePaletteColorLut(dataSet, imagePixelModule);\n }\n\n return imagePixelModule;\n}\n\nexport default getImagePixelModule;\n","import { DataSet, Element } from 'dicom-parser';\nimport { LutType } from '../../../types';\n\nfunction getLUT(pixelRepresentation: number, lutDataSet: DataSet): LutType {\n let numLUTEntries = lutDataSet.uint16('x00283002', 0);\n\n if (numLUTEntries === 0) {\n numLUTEntries = 65535;\n }\n let firstValueMapped = 0;\n\n if (pixelRepresentation === 0) {\n firstValueMapped = lutDataSet.uint16('x00283002', 1);\n } else {\n firstValueMapped = lutDataSet.int16('x00283002', 1);\n }\n const numBitsPerEntry = lutDataSet.uint16('x00283002', 2);\n // console.log('LUT(', numLUTEntries, ',', firstValueMapped, ',', numBitsPerEntry, ')');\n const lut = {\n id: '1',\n firstValueMapped,\n numBitsPerEntry,\n lut: [],\n };\n\n // console.log(\"minValue=\", minValue, \"; maxValue=\", maxValue);\n for (let i = 0; i < numLUTEntries; i++) {\n if (pixelRepresentation === 0) {\n lut.lut[i] = lutDataSet.uint16('x00283006', i);\n } else {\n lut.lut[i] = lutDataSet.int16('x00283006', i);\n }\n }\n\n return lut;\n}\n\nfunction getLUTs(pixelRepresentation: number, lutSequence: Element): LutType[] {\n if (!lutSequence \|\| !lutSequence.items \|\| !lutSequence.items.length) {\n return;\n }\n const luts: LutType[] = [];\n\n for (let i = 0; i < lutSequence.items.length; i++) {\n const lutDataSet = lutSequence.items[i].dataSet;\n const lut = getLUT(pixelRepresentation, lutDataSet);\n\n if (lut) {\n luts.push(lut);\n }\n }\n\n return luts;\n}\n\nexport default getLUTs;\n","/ eslint no-bitwise: 0 /\n\nimport { DataSet } from 'dicom-parser';\n\nfunction getMinStoredPixelValue(dataSet: DataSet) {\n const pixelRepresentation = dataSet.uint16('x00280103');\n const bitsStored = dataSet.uint16('x00280101');\n\n if (pixelRepresentation === 0) {\n return 0;\n }\n\n return -1 << (bitsStored - 1);\n}\n\n// 0 = unsigned / US, 1 = signed / SS\nfunction getModalityLUTOutputPixelRepresentation(dataSet: DataSet) {\n // CT SOP Classes are always signed\n const sopClassUID = dataSet.string('x00080016');\n\n if (\n sopClassUID === '1.2.840.10008.5.1.4.1.1.2' \|\|\n sopClassUID === '1.2.840.10008.5.1.4.1.1.2.1'\n ) {\n return 1;\n }\n\n // if rescale intercept and rescale slope are present, pass the minimum stored\n // pixel value through them to see if we get a signed output range\n const rescaleIntercept = dataSet.floatString('x00281052');\n const rescaleSlope = dataSet.floatString('x00281053');\n\n if (rescaleIntercept !== undefined && rescaleSlope !== undefined) {\n const minStoredPixelValue = getMinStoredPixelValue(dataSet); //\n const minModalityLutValue =\n minStoredPixelValue rescaleSlope + rescaleIntercept;\n\n if (minModalityLutValue < 0) {\n return 1;\n }\n\n return 0;\n }\n\n // Output of non linear modality lut is always unsigned\n if (dataSet.elements.x00283000 && dataSet.elements.x00283000.length > 0) {\n return 0;\n }\n\n // If no modality lut transform, output is same as pixel representation\n return dataSet.uint16('x00280103');\n}\n\nexport default getModalityLUTOutputPixelRepresentation;\n","import { DataSet } from 'dicom-parser';\n\nfunction getNumberValues(\n dataSet: DataSet,\n tag: string,\n minimumLength: number\n): number[] {\n const values = [];\n const valueAsString = dataSet.string(tag);\n\n if (!valueAsString) {\n return;\n }\n const split = valueAsString.split('\\\\');\n\n if (minimumLength && split.length < minimumLength) {\n return;\n }\n for (let i = 0; i < split.length; i++) {\n values.push(parseFloat(split[i]));\n }\n\n return values;\n}\n\nexport default getNumberValues;\n","export interface CornerstoneImageUrl {\n scheme: string;\n url: string;\n frame: number;\n pixelDataFrame: number;\n}\n\nfunction parseImageId(imageId: string): CornerstoneImageUrl {\n // build a url by parsing out the url scheme and frame index from the imageId\n const firstColonIndex = imageId.indexOf(':');\n\n let url = imageId.substring(firstColonIndex + 1);\n const frameIndex = url.indexOf('frame=');\n\n let frame;\n\n if (frameIndex !== -1) {\n const frameStr = url.substring(frameIndex + 6);\n\n frame = parseInt(frameStr, 10);\n url = url.substring(0, frameIndex - 1);\n }\n\n const scheme = imageId.substring(0, firstColonIndex);\n /*\n Why we adjust frameNumber? since in the above we are extracting the\n * frame number from the imageId (from the metadata), and the frame number\n * starts from 1, but in the loader which uses the dicomParser\n * the frame number starts from 0.\n /\n\n const adjustedFrame = frame !== undefined ? frame - 1 : undefined;\n\n return {\n scheme,\n url,\n frame,\n pixelDataFrame: adjustedFrame,\n };\n}\n\nexport default parseImageId;\n","import { DataSet } from 'dicom-parser';\nimport external from '../../externalModules';\nimport {\n LoadRequestFunction,\n DICOMLoaderDataSetWithFetchMore,\n} from '../../types';\n\nfunction fixFragments(dataSet: DataSet) {\n // The partially parsed pixelData element has incorrect fragment\n // lengths because the byte array is truncated, so we manually set\n // it to the actual length.\n const fragments = dataSet.elements.x7fe00010.fragments;\n const totalLength = dataSet.byteArray.length;\n\n for (const fragment of fragments) {\n const { position, length } = fragment;\n\n if (length > totalLength - position) {\n console.log(\n `Truncated fragment, changing fragment length from ${\n fragment.length\n } to ${totalLength - position}`\n );\n fragment.length = totalLength - position;\n }\n }\n\n return dataSet;\n}\n\nfunction parsePartialByteArray(byteArray: Uint8Array) {\n const { dicomParser } = external;\n /\n First parse just up to pixelData. This will make sure the\n * metadata header is correctly parsed (assuming no other error is\n * thrown during parsing). Then, parse again using the whole partial\n * arraybuffer. This will error, but still kick out the parsed\n * partial pixel data in the error object.\n /\n\n let dataSet = dicomParser.parseDicom(byteArray, {\n untilTag: 'x7fe00010',\n });\n\n if (!dataSet.elements.x7fe00010) {\n console.warn('Pixel data not found!');\n // Re-fetch more of the file\n }\n\n let pixelDataSet: DataSet;\n\n try {\n // This is expected to fail, since the file is incomplete, but\n // dicomParser helpfully spits out the parsed partial dataset in\n // the error object. The problem is, the dataset here is\n // incomplete, because dicomParser throws before* combining the\n // metadata header and regular datasets, so transfer syntax and\n // other metadata headers aren't included.\n pixelDataSet = dicomParser.parseDicom(byteArray);\n } catch (err: any) {\n // Todo: This is probably invalid handling - it expects the only reason to\n // fail is a partial dataset\n console.error(err);\n console.log('pixel data dataset:', err.dataSet);\n pixelDataSet = err.dataSet;\n }\n\n // Add the parsed partial pixel data element to the dataset\n // including the metadata headers.\n dataSet.elements.x7fe00010 = pixelDataSet.elements.x7fe00010;\n\n dataSet = fixFragments(dataSet);\n\n return dataSet;\n}\n\nexport default async function dataSetFromPartialContent(\n byteArray: Uint8Array,\n loadRequest: LoadRequestFunction,\n metadata: {\n uri: string;\n imageId: string;\n fileTotalLength: number \| null;\n }\n): Promise<DICOMLoaderDataSetWithFetchMore> {\n const dataSet: DICOMLoaderDataSetWithFetchMore =\n parsePartialByteArray(byteArray);\n const { uri, imageId, fileTotalLength } = metadata;\n\n // Allow re-fetching of more of the file\n dataSet.fetchMore = async function (fetchOptions) {\n // Default to fetching the rest of the file if no lengthToFetch is set. Also\n // default to fetching the same URI/imageId\n const _options = Object.assign(\n {\n uri,\n imageId,\n fetchedLength: byteArray.length, // Not sure if this would ever need to be configurable tbh\n lengthToFetch: fileTotalLength - byteArray.length,\n },\n fetchOptions\n );\n const { fetchedLength, lengthToFetch } = _options;\n\n // Use passed xhr loader to re-fetch new byte range\n\n // Todo: the following might be wrong, does it return array buffer or\n // something else?\n // @ts-ignore\n const { arrayBuffer } = await loadRequest(uri, imageId, {\n byteRange: `${fetchedLength}-${fetchedLength + lengthToFetch}`,\n });\n\n // Combine byte ranges\n const byteArrayToAppend = new Uint8Array(arrayBuffer);\n const combinedByteArray = new Uint8Array(\n dataSet.byteArray.length + byteArrayToAppend.length\n );\n\n combinedByteArray.set(dataSet.byteArray);\n combinedByteArray.set(byteArrayToAppend, dataSet.byteArray.length);\n\n // Re-parse potentially partial byte range and return\n return dataSetFromPartialContent(combinedByteArray, loadRequest, metadata);\n };\n\n return dataSet;\n}\n","function getDirectFrameInformation(dataSet, frame) {\n if (!dataSet) {\n return;\n }\n\n const {\n NumberOfFrames,\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n } = getMultiframeInformation(dataSet);\n\n if (PerFrameFunctionalGroupsSequence \|\| NumberOfFrames > 1) {\n const { shared, perFrame } = getFrameInformation(\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n frame\n );\n\n return {\n NumberOfFrames,\n PerFrameFunctionalInformation: perFrame,\n SharedFunctionalInformation: shared,\n };\n }\n\n return {\n NumberOfFrames,\n };\n}\n\nfunction getFrameInformation(\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n frameNumber\n) {\n const shared = {};\n\n (SharedFunctionalGroupsSequence\n ? Object.values(SharedFunctionalGroupsSequence.items[0].dataSet.elements)\n : []\n ).map((it: any) => (shared[it.tag] = it));\n\n const perFrame = {};\n\n (PerFrameFunctionalGroupsSequence\n ? Object.values(\n PerFrameFunctionalGroupsSequence.items[frameNumber - 1].dataSet.elements\n )\n : []\n ).map((it: any) => (perFrame[it.tag] = it));\n\n return {\n shared,\n perFrame,\n };\n}\n\nfunction getMultiframeInformation(dataSet) {\n if (!dataSet) {\n return;\n }\n const { elements, ...otherAttributtes } = dataSet;\n const {\n x52009230: PerFrameFunctionalGroupsSequence,\n x52009229: SharedFunctionalGroupsSequence,\n ...otherElements\n } = elements;\n\n const NumberOfFrames = dataSet.intString('x00280008');\n\n return {\n NumberOfFrames,\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n otherElements,\n otherAttributtes,\n };\n}\n\n// function that retrieves specific frame metadata information from multiframe\n// metadata\nfunction combineFrameInstanceDataset(frameNumber, dataSet) {\n if (!dataSet) {\n return;\n }\n\n const {\n NumberOfFrames,\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n otherElements,\n } = getMultiframeInformation(dataSet);\n\n if (PerFrameFunctionalGroupsSequence \|\| NumberOfFrames > 1) {\n const { shared, perFrame } = getFrameInformation(\n PerFrameFunctionalGroupsSequence,\n SharedFunctionalGroupsSequence,\n frameNumber\n );\n\n // creating a new copy of the dataset to remove the two multiframe dicom tags\n const newElements = {\n elements: {\n ...otherElements,\n ...shared,\n ...perFrame,\n },\n };\n\n const clonedDataset = Object.create(dataSet);\n const newDataset = Object.assign(clonedDataset, newElements);\n\n return newDataset;\n }\n\n return dataSet;\n}\n\nexport {\n combineFrameInstanceDataset,\n getMultiframeInformation,\n getFrameInformation,\n getDirectFrameInformation,\n};\n","import { loadedDataSets } from './dataSetCacheManager';\n\nfunction _get(uri) {\n if (!loadedDataSets[uri]) {\n return;\n }\n\n return loadedDataSets[uri];\n}\n\nfunction isMultiframeDataset(uri) {\n const dataSet = _get(uri);\n\n return _isMultiframeDataset(dataSet);\n}\n\nfunction _isMultiframeDataset(dataSet) {\n // Checks if dicomTag NumberOf Frames exists and it is greater than one\n if (!dataSet) {\n return false;\n }\n\n const numberOfFrames = dataSet.intString('x00280008');\n\n return numberOfFrames && numberOfFrames > 1;\n}\n\nfunction retrieveFrameParameterIndex(uri) {\n return uri.indexOf('&frame=');\n}\n\nfunction retrieveMultiframeDataset(uri) {\n const frameParameterIndex = retrieveFrameParameterIndex(uri);\n const multiframeURI =\n frameParameterIndex === -1 ? uri : uri.slice(0, frameParameterIndex);\n const frame = parseInt(uri.slice(frameParameterIndex + 7), 10) \|\| 1;\n\n let dataSet;\n\n if (loadedDataSets[multiframeURI]) {\n dataSet = loadedDataSets[multiframeURI].dataSet;\n } else {\n dataSet = undefined;\n }\n\n return {\n dataSet,\n frame,\n };\n}\n\nfunction generateMultiframeWADOURIs(uri) {\n const listWADOURIs = [];\n\n const dataSet = _get(uri);\n\n if (_isMultiframeDataset(dataSet)) {\n const numberOfFrames = (dataSet as any).intString('x00280008');\n\n for (let i = 1; i <= numberOfFrames; i++) {\n listWADOURIs.push(`${uri}&frame=${i}`);\n }\n } else {\n listWADOURIs.push(uri);\n }\n\n return listWADOURIs;\n}\n\nexport default {\n _get,\n generateMultiframeWADOURIs,\n retrieveMultiframeDataset,\n isMultiframeDataset,\n};\n","import { DataSet } from 'dicom-parser';\nimport external from '../../externalModules';\nimport { xhrRequest } from '../internal/index';\nimport dataSetFromPartialContent from './dataset-from-partial-content';\nimport {\n LoadRequestFunction,\n DICOMLoaderDataSetWithFetchMore,\n} from '../../types';\nimport { combineFrameInstanceDataset } from './combineFrameInstanceDataset';\nimport multiframeDataset from './retrieveMultiframeDataset';\n\nexport interface CornerstoneWadoLoaderCacheManagerInfoResponse {\n cacheSizeInBytes: number;\n numberOfDataSetsCached: number;\n}\n\nexport interface CornerstoneWadoLoaderCachedPromise\n extends Promise<DataSet \| DICOMLoaderDataSetWithFetchMore> {\n cacheCount?: number;\n}\n\n/*\n This object supports loading of DICOM P10 dataset from a uri and caching it so it can be accessed\n * by the caller. This allows a caller to access the datasets without having to go through cornerstone's\n * image loader mechanism. One reason a caller may need to do this is to determine the number of frames\n * in a multiframe sop instance so it can create the imageId's correctly.\n /\nlet cacheSizeInBytes = 0;\n\nlet loadedDataSets: Record<string, { dataSet: DataSet; cacheCount: number }> =\n {};\n\nlet promises: Record<string, CornerstoneWadoLoaderCachedPromise> = {};\n\n// returns true if the wadouri for the specified index has been loaded\nfunction isLoaded(uri: string): boolean {\n return loadedDataSets[uri] !== undefined;\n}\n\nfunction get(uri: string): DataSet {\n let dataSet;\n\n if (uri.includes('&frame=')) {\n const { frame, dataSet: multiframeDataSet } =\n multiframeDataset.retrieveMultiframeDataset(uri);\n\n dataSet = combineFrameInstanceDataset(frame, multiframeDataSet);\n } else if (loadedDataSets[uri]) {\n dataSet = loadedDataSets[uri].dataSet;\n }\n\n return dataSet;\n}\n\nfunction update(uri: string, dataSet: DataSet) {\n const loadedDataSet = loadedDataSets[uri];\n\n if (!loadedDataSet) {\n console.error(`No loaded dataSet for uri ${uri}`);\n\n return;\n }\n // Update dataset\n cacheSizeInBytes -= loadedDataSet.dataSet.byteArray.length;\n loadedDataSet.dataSet = dataSet;\n cacheSizeInBytes += dataSet.byteArray.length;\n\n external.cornerstone.triggerEvent(\n (external.cornerstone as any).events,\n 'datasetscachechanged',\n {\n uri,\n action: 'updated',\n cacheInfo: getInfo(),\n }\n );\n}\n\n// loads the dicom dataset from the wadouri sp\nfunction load(\n uri: string,\n loadRequest: LoadRequestFunction = xhrRequest,\n imageId: string\n): CornerstoneWadoLoaderCachedPromise {\n const { cornerstone, dicomParser } = external;\n\n // if already loaded return it right away\n if (loadedDataSets[uri]) {\n // console.log('using loaded dataset ' + uri);\n return new Promise((resolve) => {\n loadedDataSets[uri].cacheCount++;\n resolve(loadedDataSets[uri].dataSet);\n });\n }\n\n // if we are currently loading this uri, increment the cacheCount and return its promise\n if (promises[uri]) {\n // console.log('returning existing load promise for ' + uri);\n promises[uri].cacheCount++;\n\n return promises[uri];\n }\n\n // This uri is not loaded or being loaded, load it via an xhrRequest\n const loadDICOMPromise = loadRequest(uri, imageId);\n\n // handle success and failure of the XHR request load\n const promise: CornerstoneWadoLoaderCachedPromise = new Promise(\n (resolve, reject) => {\n loadDICOMPromise\n .then(async function (dicomPart10AsArrayBuffer: any / , xhr/) {\n const partialContent = {\n isPartialContent: false,\n fileTotalLength: null,\n };\n\n // Allow passing extra data with the loader promise so as not to change\n // the API\n if (!(dicomPart10AsArrayBuffer instanceof ArrayBuffer)) {\n if (!dicomPart10AsArrayBuffer.arrayBuffer) {\n return reject(\n new Error(\n 'If not returning ArrayBuffer, must return object with `arrayBuffer` parameter'\n )\n );\n }\n partialContent.isPartialContent =\n dicomPart10AsArrayBuffer.flags.isPartialContent;\n partialContent.fileTotalLength =\n dicomPart10AsArrayBuffer.flags.fileTotalLength;\n dicomPart10AsArrayBuffer = dicomPart10AsArrayBuffer.arrayBuffer;\n }\n\n const byteArray = new Uint8Array(dicomPart10AsArrayBuffer);\n\n // Reject the promise if parsing the dicom file fails\n let dataSet: DataSet \| DICOMLoaderDataSetWithFetchMore;\n\n try {\n if (partialContent.isPartialContent) {\n // This dataSet object will include a fetchMore function,\n dataSet = await dataSetFromPartialContent(\n byteArray,\n loadRequest,\n {\n uri,\n imageId,\n fileTotalLength: partialContent.fileTotalLength,\n }\n );\n } else {\n dataSet = dicomParser.parseDicom(byteArray);\n }\n } catch (error) {\n return reject(error);\n }\n\n loadedDataSets[uri] = {\n dataSet,\n cacheCount: promise.cacheCount,\n };\n cacheSizeInBytes += dataSet.byteArray.length;\n resolve(dataSet);\n\n cornerstone.triggerEvent(\n (cornerstone as any).events,\n 'datasetscachechanged',\n {\n uri,\n action: 'loaded',\n cacheInfo: getInfo(),\n }\n );\n }, reject)\n .then(\n () => {\n // Remove the promise if success\n delete promises[uri];\n },\n () => {\n // Remove the promise if failure\n delete promises[uri];\n }\n );\n }\n );\n\n promise.cacheCount = 1;\n\n promises[uri] = promise;\n\n return promise;\n}\n\n// remove the cached/loaded dicom dataset for the specified wadouri to free up memory\nfunction unload(uri: string): void {\n const { cornerstone } = external;\n\n // console.log('unload for ' + uri);\n if (loadedDataSets[uri]) {\n loadedDataSets[uri].cacheCount--;\n if (loadedDataSets[uri].cacheCount === 0) {\n // console.log('removing loaded dataset for ' + uri);\n cacheSizeInBytes -= loadedDataSets[uri].dataSet.byteArray.length;\n delete loadedDataSets[uri];\n\n cornerstone.triggerEvent(\n (cornerstone as any).events,\n 'datasetscachechanged',\n {\n uri,\n action: 'unloaded',\n cacheInfo: getInfo(),\n }\n );\n }\n }\n}\n\nexport function getInfo(): CornerstoneWadoLoaderCacheManagerInfoResponse {\n return {\n cacheSizeInBytes,\n numberOfDataSetsCached: Object.keys(loadedDataSets).length,\n };\n}\n\n// removes all cached datasets from memory\nfunction purge(): void {\n loadedDataSets = {};\n promises = {};\n cacheSizeInBytes = 0;\n}\n\nexport default {\n isLoaded,\n load,\n unload,\n getInfo,\n purge,\n get,\n update,\n};\n\nexport { loadedDataSets };\n","import getNumberValues from './getNumberValues';\nimport isNMReconstructable from '../../isNMReconstructable';\n\n/\n Get a subpart of Image Type dicom tag defined by index\n * @param {} dataSet\n @param {} index 0 based index of the subtype\n /\nfunction getImageTypeSubItemFromDataset(dataSet, index) {\n const imageType = dataSet.string('x00080008');\n\n if (imageType) {\n const subTypes = imageType.split('\\\\');\n\n if (subTypes.length > index) {\n return subTypes[index];\n }\n }\n\n return undefined;\n}\n/*\n Extracts the orientation from NM multiframe dataset, if image type\n * equal to RECON TOMO or RECON GATED TOMO\n * @param {} dataSet\n @returns\n /\nfunction extractOrientationFromNMMultiframeDataset(dataSet) {\n let imageOrientationPatient;\n const modality = dataSet.string('x00080060');\n\n if (modality?.includes('NM')) {\n const imageSubType = getImageTypeSubItemFromDataset(dataSet, 2);\n\n if (imageSubType && isNMReconstructable(imageSubType)) {\n if (dataSet.elements.x00540022) {\n imageOrientationPatient = getNumberValues(\n dataSet.elements.x00540022.items[0].dataSet,\n 'x00200037',\n 6\n );\n }\n }\n }\n\n return imageOrientationPatient;\n}\n\n/\n Extracts the position from NM multiframe dataset, if image type\n * equal to RECON TOMO or RECON GATED TOMO\n * @param {} dataSet\n @returns\n /\nfunction extractPositionFromNMMultiframeDataset(dataSet) {\n let imagePositionPatient;\n const modality = dataSet.string('x00080060');\n\n if (modality?.includes('NM')) {\n const imageSubType = getImageTypeSubItemFromDataset(dataSet, 2);\n\n if (imageSubType && isNMReconstructable(imageSubType)) {\n if (dataSet.elements.x00540022) {\n imagePositionPatient = getNumberValues(\n dataSet.elements.x00540022.items[0].dataSet,\n 'x00200032',\n 3\n );\n }\n }\n }\n\n return imagePositionPatient;\n}\n\n/\n Extract orientation information from a dataset. It tries to get the orientation\n * from the Detector Information Sequence (for NM images) if image type equal\n * to RECON TOMO or RECON GATED TOMO\n * @param {} dataSet\n @returns\n /\nfunction extractOrientationFromDataset(dataSet) {\n let imageOrientationPatient = getNumberValues(dataSet, 'x00200037', 6);\n\n // Trying to get the orientation from the Plane Orientation Sequence\n if (!imageOrientationPatient && dataSet.elements.x00209116) {\n imageOrientationPatient = getNumberValues(\n dataSet.elements.x00209116.items[0].dataSet,\n 'x00200037',\n 6\n );\n }\n\n // If orientation not valid to this point, trying to get the orientation\n // from the Detector Information Sequence (for NM images) with image type\n // equal to RECON TOMO or RECON GATED TOMO\n\n if (!imageOrientationPatient) {\n imageOrientationPatient =\n extractOrientationFromNMMultiframeDataset(dataSet);\n }\n\n return imageOrientationPatient;\n}\n\n/\n Extract position information from a dataset. It tries to get the position\n * from the Detector Information Sequence (for NM images) if image type equal\n * to RECON TOMO or RECON GATED TOMO\n * @param {} dataSet\n @returns\n /\nfunction extractPositionFromDataset(dataSet) {\n let imagePositionPatient = getNumberValues(dataSet, 'x00200032', 3);\n\n // Trying to get the position from the Plane Position Sequence\n if (!imagePositionPatient && dataSet.elements.x00209113) {\n imagePositionPatient = getNumberValues(\n dataSet.elements.x00209113.items[0].dataSet,\n 'x00200032',\n 3\n );\n }\n\n // If position not valid to this point, trying to get the position\n // from the Detector Information Sequence (for NM images)\n if (!imagePositionPatient) {\n imagePositionPatient = extractPositionFromNMMultiframeDataset(dataSet);\n }\n\n return imagePositionPatient;\n}\n\n/\n Extract the pixelSpacing information. If exists, extracts this information\n * from Pixel Measures Sequence\n * @param {} dataSet\n @returns\n /\nfunction extractSpacingFromDataset(dataSet) {\n let pixelSpacing = getNumberValues(dataSet, 'x00280030', 2);\n\n // If pixelSpacing not valid to this point, trying to get the spacing\n // from the Pixel Measures Sequence\n if (!pixelSpacing && dataSet.elements.x00289110) {\n pixelSpacing = getNumberValues(\n dataSet.elements.x00289110.items[0].dataSet,\n 'x00280030',\n 2\n );\n }\n\n return pixelSpacing;\n}\n\n/\n Extract the sliceThickness information. If exists, extracts this information\n * from Pixel Measures Sequence\n * @param {} dataSet\n @returns\n /\nfunction extractSliceThicknessFromDataset(dataSet) {\n let sliceThickness;\n\n if (dataSet.elements.x00180050) {\n sliceThickness = dataSet.floatString('x00180050');\n } else if (\n dataSet.elements.x00289110 &&\n dataSet.elements.x00289110.items.length &&\n dataSet.elements.x00289110.items[0].dataSet.elements.x00180050\n ) {\n sliceThickness =\n dataSet.elements.x00289110.items[0].dataSet.floatString('x00180050');\n }\n\n return sliceThickness;\n}\n\nexport {\n getImageTypeSubItemFromDataset,\n extractOrientationFromDataset,\n extractPositionFromDataset,\n extractSpacingFromDataset,\n extractSliceThicknessFromDataset,\n};\n","import external from '../../../externalModules';\nimport getNumberValues from './getNumberValues';\nimport parseImageId from '../parseImageId';\nimport dataSetCacheManager from '../dataSetCacheManager';\nimport getImagePixelModule from './getImagePixelModule';\nimport getOverlayPlaneModule from './getOverlayPlaneModule';\nimport getLUTs from './getLUTs';\nimport getModalityLUTOutputPixelRepresentation from './getModalityLUTOutputPixelRepresentation';\nimport { getDirectFrameInformation } from '../combineFrameInstanceDataset';\nimport multiframeDataset from '../retrieveMultiframeDataset';\nimport {\n getImageTypeSubItemFromDataset,\n extractOrientationFromDataset,\n extractPositionFromDataset,\n extractSpacingFromDataset,\n extractSliceThicknessFromDataset,\n} from './extractPositioningFromDataset';\nimport isNMReconstructable from '../../isNMReconstructable';\nimport {\n getInstanceModule,\n instanceModuleNames,\n} from '../../getInstanceModule';\n\nfunction metaDataProvider(type, imageId) {\n const { MetadataModules } = external.cornerstone.Enums;\n const { dicomParser } = external;\n\n // Several providers use array queries\n if (Array.isArray(imageId)) {\n return;\n }\n\n const parsedImageId = parseImageId(imageId);\n\n if (type === MetadataModules.MULTIFRAME) {\n const multiframeData = multiframeDataset.retrieveMultiframeDataset(\n parsedImageId.url\n );\n\n if (!multiframeData.dataSet) {\n return;\n }\n\n const multiframeInfo = getDirectFrameInformation(\n multiframeData.dataSet,\n multiframeData.frame\n );\n\n return multiframeInfo;\n }\n\n let url = parsedImageId.url;\n\n if (parsedImageId.frame) {\n url = `${url}&frame=${parsedImageId.frame}`;\n }\n\n const dataSet = dataSetCacheManager.get(url);\n\n if (!dataSet) {\n return;\n }\n\n if (type === MetadataModules.GENERAL_STUDY) {\n return {\n studyDescription: dataSet.string('x00081030'),\n studyDate: dicomParser.parseDA(dataSet.string('x00080020')),\n studyTime: dicomParser.parseTM(dataSet.string('x00080030') \|\| ''),\n accessionNumber: dataSet.string('x00080050'),\n };\n }\n\n if (type === MetadataModules.GENERAL_SERIES) {\n return {\n modality: dataSet.string('x00080060'),\n seriesInstanceUID: dataSet.string('x0020000e'),\n seriesNumber: dataSet.intString('x00200011'),\n studyInstanceUID: dataSet.string('x0020000d'),\n seriesDate: dicomParser.parseDA(dataSet.string('x00080021')),\n seriesTime: dicomParser.parseTM(dataSet.string('x00080031') \|\| ''),\n acquisitionDate: dicomParser.parseDA(dataSet.string('x00080022')),\n acquisitionTime: dicomParser.parseTM(dataSet.string('x00080032') \|\| ''),\n };\n }\n\n if (type === MetadataModules.GENERAL_IMAGE) {\n return {\n sopInstanceUID: dataSet.string('x00080018'),\n instanceNumber: dataSet.intString('x00200013'),\n lossyImageCompression: dataSet.string('x00282110'),\n lossyImageCompressionRatio: dataSet.floatString('x00282112'),\n lossyImageCompressionMethod: dataSet.string('x00282114'),\n };\n }\n\n if (type === MetadataModules.PATIENT) {\n return {\n patientID: dataSet.string('x00100020'),\n patientName: dataSet.string('x00100010'),\n };\n }\n\n if (type === MetadataModules.PATIENT_STUDY) {\n return {\n patientAge: dataSet.intString('x00101010'),\n patientSize: dataSet.floatString('x00101020'),\n patientSex: dataSet.string('x00100040'),\n patientWeight: dataSet.floatString('x00101030'),\n };\n }\n\n if (type === MetadataModules.NM_MULTIFRAME_GEOMETRY) {\n const modality = dataSet.string('x00080060');\n const imageSubType = getImageTypeSubItemFromDataset(dataSet, 2);\n\n return {\n modality,\n imageType: dataSet.string('x00080008'),\n imageSubType,\n imageOrientationPatient: extractOrientationFromDataset(dataSet),\n imagePositionPatient: extractPositionFromDataset(dataSet),\n sliceThickness: extractSliceThicknessFromDataset(dataSet),\n pixelSpacing: extractSpacingFromDataset(dataSet),\n numberOfFrames: dataSet.uint16('x00280008'),\n isNMReconstructable:\n isNMReconstructable(imageSubType) && modality.includes('NM'),\n };\n }\n\n if (type === MetadataModules.IMAGE_PLANE) {\n const imageOrientationPatient = extractOrientationFromDataset(dataSet);\n const imagePositionPatient = extractPositionFromDataset(dataSet);\n const pixelSpacing = extractSpacingFromDataset(dataSet);\n const sliceThickness = extractSliceThicknessFromDataset(dataSet);\n\n let columnPixelSpacing = null;\n\n let rowPixelSpacing = null;\n\n if (pixelSpacing) {\n rowPixelSpacing = pixelSpacing[0];\n columnPixelSpacing = pixelSpacing[1];\n }\n\n let rowCosines = null;\n\n let columnCosines = null;\n\n if (imageOrientationPatient) {\n rowCosines = [\n // @ts-expect-error\n parseFloat(imageOrientationPatient[0]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[1]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[2]),\n ];\n columnCosines = [\n // @ts-expect-error\n parseFloat(imageOrientationPatient[3]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[4]),\n // @ts-expect-error\n parseFloat(imageOrientationPatient[5]),\n ];\n }\n\n return {\n frameOfReferenceUID: dataSet.string('x00200052'),\n rows: dataSet.uint16('x00280010'),\n columns: dataSet.uint16('x00280011'),\n imageOrientationPatient,\n rowCosines,\n columnCosines,\n imagePositionPatient,\n sliceThickness,\n sliceLocation: dataSet.floatString('x00201041'),\n pixelSpacing,\n rowPixelSpacing,\n columnPixelSpacing,\n };\n }\n\n if (type === MetadataModules.CINE) {\n return {\n frameTime: dataSet.floatString('x00181063'),\n };\n }\n\n if (type === MetadataModules.IMAGE_PIXEL) {\n return getImagePixelModule(dataSet);\n }\n\n if (type === MetadataModules.VOI_LUT) {\n const modalityLUTOutputPixelRepresentation =\n getModalityLUTOutputPixelRepresentation(dataSet);\n\n return {\n windowCenter: getNumberValues(dataSet, 'x00281050', 1),\n windowWidth: getNumberValues(dataSet, 'x00281051', 1),\n voiLUTSequence: getLUTs(\n modalityLUTOutputPixelRepresentation,\n dataSet.elements.x00283010\n ),\n };\n }\n\n if (type === MetadataModules.MODALITY_LUT) {\n return {\n rescaleIntercept: dataSet.floatString('x00281052'),\n rescaleSlope: dataSet.floatString('x00281053'),\n rescaleType: dataSet.string('x00281054'),\n modalityLUTSequence: getLUTs(\n dataSet.uint16('x00280103'),\n dataSet.elements.x00283000\n ),\n };\n }\n\n if (type === MetadataModules.SOP_COMMON) {\n return {\n sopClassUID: dataSet.string('x00080016'),\n sopInstanceUID: dataSet.string('x00080018'),\n };\n }\n\n if (type === MetadataModules.PET_ISOTOPE) {\n const radiopharmaceuticalInfo = dataSet.elements.x00540016;\n\n if (radiopharmaceuticalInfo === undefined) {\n return;\n }\n\n const firstRadiopharmaceuticalInfoDataSet =\n radiopharmaceuticalInfo.items[0].dataSet;\n\n return {\n radiopharmaceuticalInfo: {\n radiopharmaceuticalStartTime: dicomParser.parseTM(\n firstRadiopharmaceuticalInfoDataSet.string('x00181072') \|\| ''\n ),\n radionuclideTotalDose:\n firstRadiopharmaceuticalInfoDataSet.floatString('x00181074'),\n radionuclideHalfLife:\n firstRadiopharmaceuticalInfoDataSet.floatString('x00181075'),\n },\n };\n }\n\n if (type === MetadataModules.OVERLAY_PLANE) {\n return getOverlayPlaneModule(dataSet);\n }\n\n // Note: this is not a DICOM module, but a useful metadata that can be\n // retrieved from the image\n if (type === 'transferSyntax') {\n let transferSyntaxUID;\n\n try {\n transferSyntaxUID = dataSet.string('x00020010');\n } catch (error) {\n // Do nothing\n }\n\n return {\n transferSyntaxUID,\n };\n }\n\n if (type === MetadataModules.PET_SERIES) {\n return {\n correctedImage: dataSet.string('x00280051'),\n units: dataSet.string('x00541001'),\n decayCorrection: dataSet.string('x00541102'),\n };\n }\n\n if (type === MetadataModules.PET_IMAGE) {\n return {\n frameReferenceTime: dataSet.floatString(\n dataSet.string('x00541300') \|\| ''\n ),\n actualFrameDuration: dataSet.intString(dataSet.string('x00181242')),\n };\n }\n\n // Note: this is not a DICOM module, but rather an aggregation on all others\n if (type === 'instance') {\n return getInstanceModule(imageId, metaDataProvider, instanceModuleNames);\n }\n}\n\nexport default metaDataProvider;\n","import { DataSet } from 'dicom-parser';\n\nexport default function getOverlayPlaneModule(dataSet: DataSet) {\n const overlays = [];\n\n for (let overlayGroup = 0x00; overlayGroup <= 0x1e; overlayGroup += 0x02) {\n let groupStr = `x60${overlayGroup.toString(16)}`;\n\n if (groupStr.length === 4) {\n groupStr = `x600${overlayGroup.toString(16)}`;\n }\n\n const data = dataSet.elements[`${groupStr}3000`];\n\n if (!data) {\n continue;\n }\n\n const pixelData = [];\n\n for (let i = 0; i < data.length; i++) {\n for (let k = 0; k < 8; k++) {\n const byte_as_int = dataSet.byteArray[data.dataOffset + i];\n\n pixelData[i 8 + k] = (byte_as_int >> k) & 0b1; // eslint-disable-line no-bitwise\n }\n }\n\n overlays.push({\n rows: dataSet.uint16(`${groupStr}0010`),\n columns: dataSet.uint16(`${groupStr}0011`),\n type: dataSet.string(`${groupStr}0040`),\n x: dataSet.int16(`${groupStr}0050`, 1) - 1,\n y: dataSet.int16(`${groupStr}0050`, 0) - 1,\n pixelData,\n description: dataSet.string(`${groupStr}0022`),\n label: dataSet.string(`${groupStr}1500`),\n roiArea: dataSet.string(`${groupStr}1301`),\n roiMean: dataSet.string(`${groupStr}1302`),\n roiStandardDeviation: dataSet.string(`${groupStr}1303`),\n });\n }\n\n return {\n overlays,\n };\n}\n","let files: Blob[] = [];\n\nfunction add(file: Blob): string {\n const fileIndex = files.push(file);\n\n return `dicomfile:${fileIndex - 1}`;\n}\n\nfunction get(index: number): Blob {\n return files[index];\n}\n\nfunction remove(index: number): void {\n files[index] = undefined;\n}\n\nfunction purge(): void {\n files = [];\n}\n\nexport default {\n add,\n get,\n remove,\n purge,\n};\n","import { ByteArray, DataSet, ByteStream, readSequenceItem } from 'dicom-parser';\nimport external from '../../externalModules';\n\n/*\n Function to deal with extracting an image frame from an encapsulated data set.\n /\n\nfunction framesAreFragmented(dataSet: DataSet) {\n const numberOfFrames = dataSet.intString('x00280008');\n const pixelDataElement = dataSet.elements.x7fe00010;\n\n return numberOfFrames !== pixelDataElement.fragments.length;\n}\n\nexport default function getEncapsulatedImageFrame(\n dataSet: DataSet,\n frameIndex: number\n): ByteArray {\n const { dicomParser } = external;\n\n if (\n dataSet.elements.x7fe00010 &&\n dataSet.elements.x7fe00010.basicOffsetTable.length\n ) {\n // Basic Offset Table is not empty\n return dicomParser.readEncapsulatedImageFrame(\n dataSet,\n dataSet.elements.x7fe00010,\n frameIndex\n );\n }\n\n // Empty basic offset table\n\n if (framesAreFragmented(dataSet)) {\n const basicOffsetTable = dicomParser.createJPEGBasicOffsetTable(\n dataSet,\n dataSet.elements.x7fe00010\n );\n\n return dicomParser.readEncapsulatedImageFrame(\n dataSet,\n dataSet.elements.x7fe00010,\n frameIndex,\n basicOffsetTable\n );\n }\n\n // the following code is pretty much a duplicate of the logic here\n // https://github.com/cornerstonejs/dicomParser/blob/master/src/readEncapsulatedPixelDataFromFragments.js\n // but it takes care of slicing the array buffer to be sent to the worker. We can't\n // get a view of the buffer because the buffer since it will still have the\n // array buffer, which can be in some cases huge to be sent to the worker.\n // Todo: a better approach would be to transfer the buffer to the worker by having the\n // transferPixelData option set to true, but for some reason it is giving an error\n // in the dicomParser library.\n const fragments = dataSet.elements.x7fe00010.fragments;\n\n // create byte stream on the data for this pixel data element\n const byteStream = new ByteStream(\n dataSet.byteArrayParser,\n dataSet.byteArray,\n dataSet.elements.x7fe00010.dataOffset\n );\n\n // seek past the basic offset table (no need to parse it again since we already have)\n const basicOffsetTable = readSequenceItem(byteStream);\n\n if (basicOffsetTable.tag !== 'xfffee000') {\n throw 'dicomParser.readEncapsulatedPixelData: missing basic offset table xfffee000';\n }\n\n byteStream.seek(basicOffsetTable.length);\n\n const fragmentZeroPosition = byteStream.position;\n\n // we should check that the number of frames + 1 is equal to the number of fragments\n // since there might be a situation where any frame before the one we are looking for\n // here is split into multiple fragments\n if (frameIndex + 1 > fragments.length) {\n throw 'dicomParser.readEncapsulatedPixelData: frame exceeds number of fragments';\n }\n\n const fragmentHeaderSize = 8;\n const byteOffset =\n fragmentZeroPosition + fragments[frameIndex].offset + fragmentHeaderSize;\n const length = fragments[frameIndex].length;\n\n // Grab ONLY the portion of the byteArray containing the frame for decoding since\n // it will be impossible to decode the entire image everytime (this return will go\n // to the decodeImageFrame function in cornerstoneWADOImageLoader which runs in a\n // web worker)\n return new Uint8Array(\n byteStream.byteArray.buffer.slice(\n byteStream.byteArray.byteOffset + byteOffset,\n byteStream.byteArray.byteOffset + byteOffset + length\n )\n );\n}\n","/ eslint no-bitwise: 0 /\n\nimport { ByteArray } from 'dicom-parser';\n\nfunction isBitSet(byte: number, bitPos: number) {\n return byte & (1 << bitPos);\n}\n\n/\n Function to deal with unpacking a binary frame\n /\nfunction unpackBinaryFrame(\n byteArray: ByteArray,\n frameOffset: number,\n pixelsPerFrame: number\n): Uint8Array {\n // Create a new pixel array given the image size\n const pixelData = new Uint8Array(pixelsPerFrame);\n\n for (let i = 0; i < pixelsPerFrame; i++) {\n // Compute byte position\n const bytePos = Math.floor(i / 8);\n\n // Get the current byte\n const byte = byteArray[bytePos + frameOffset];\n\n // Bit position (0-7) within byte\n const bitPos = i % 8;\n\n // Check whether bit at bitpos is set\n pixelData[i] = isBitSet(byte, bitPos) ? 1 : 0;\n }\n\n return pixelData;\n}\n\nexport default unpackBinaryFrame;\n","import { DataSet } from 'dicom-parser';\nimport unpackBinaryFrame from './unpackBinaryFrame';\n\n/\n Function to deal with extracting an image frame from an encapsulated data set.\n /\n\nfunction getUncompressedImageFrame(\n dataSet: DataSet,\n frameIndex: number\n): Uint8Array {\n const pixelDataElement =\n dataSet.elements.x7fe00010 \|\| dataSet.elements.x7fe00008;\n const bitsAllocated = dataSet.uint16('x00280100');\n const rows = dataSet.uint16('x00280010');\n const columns = dataSet.uint16('x00280011');\n\n let samplesPerPixel = dataSet.uint16('x00280002');\n\n /\n From: http://dicom.nema.org/medical/dicom/current/output/chtml/part03/sect_C.7.6.3.html\n \n Though the chrominance channels are downsampled, there are still nominally\n * three channels, hence Samples per Pixel (0028,0002) has a value of 3, not\n * 2. I.e., for pixel data in a Native (uncompressed) format, the Value Length\n * of Pixel Data (7FE0,0010) is not:\n \n Rows (0028,0010) * Columns (0028,0011) * Number of Frames (0028,0008) \n Samples per Pixel (0028,0002) * (⌊(Bits Allocated (0028,0100)-1)/8⌋+1)\n \n padded to an even length, as it would otherwise be, but rather is:\n \n Rows (0028,0010) * Columns (0028,0011) * Number of Frames (0028,0008) * 2 \n (⌊(Bits Allocated (0028,0100)-1)/8⌋+1)\n \n padded to an even length.\n /\n const photometricInterpretation = dataSet.string('x00280004');\n\n if (photometricInterpretation === 'YBR_FULL_422') {\n samplesPerPixel = 2;\n console.warn(\n `Using SamplesPerPixel of 2 for YBR_FULL_422 photometric interpretation.\n See http://dicom.nema.org/medical/dicom/current/output/chtml/part03/sect_C.7.6.3.html for more information.`\n );\n }\n\n const pixelDataOffset = pixelDataElement.dataOffset;\n const pixelsPerFrame = rows columns * samplesPerPixel;\n\n let frameOffset;\n\n if (bitsAllocated === 8) {\n frameOffset = pixelDataOffset + frameIndex * pixelsPerFrame;\n if (frameOffset >= dataSet.byteArray.length) {\n throw new Error('frame exceeds size of pixelData');\n }\n\n return new Uint8Array(\n dataSet.byteArray.buffer.slice(frameOffset, frameOffset + pixelsPerFrame)\n );\n } else if (bitsAllocated === 16) {\n frameOffset = pixelDataOffset + frameIndex * pixelsPerFrame * 2;\n if (frameOffset >= dataSet.byteArray.length) {\n throw new Error('frame exceeds size of pixelData');\n }\n\n return new Uint8Array(\n dataSet.byteArray.buffer.slice(\n frameOffset,\n frameOffset + pixelsPerFrame * 2\n )\n );\n } else if (bitsAllocated === 1) {\n frameOffset = pixelDataOffset + frameIndex * pixelsPerFrame * 0.125;\n if (frameOffset >= dataSet.byteArray.length) {\n throw new Error('frame exceeds size of pixelData');\n }\n\n return unpackBinaryFrame(dataSet.byteArray, frameOffset, pixelsPerFrame);\n } else if (bitsAllocated === 32) {\n frameOffset = pixelDataOffset + frameIndex * pixelsPerFrame * 4;\n if (frameOffset >= dataSet.byteArray.length) {\n throw new Error('frame exceeds size of pixelData');\n }\n\n return new Uint8Array(\n dataSet.byteArray.buffer.slice(\n frameOffset,\n frameOffset + pixelsPerFrame * 4\n )\n );\n }\n\n throw new Error('unsupported pixel format');\n}\n\nexport default getUncompressedImageFrame;\n","import parseImageId from './parseImageId';\nimport fileManager from './fileManager';\n\nfunction loadFileRequest(uri: string): Promise<ArrayBuffer> {\n const parsedImageId = parseImageId(uri);\n const fileIndex = parseInt(parsedImageId.url, 10);\n const file = fileManager.get(fileIndex);\n\n return new Promise<ArrayBuffer>((resolve, reject) => {\n const fileReader = new FileReader();\n\n fileReader.onload = (e) => {\n const dicomPart10AsArrayBuffer = e.target.result as ArrayBuffer;\n\n resolve(dicomPart10AsArrayBuffer);\n };\n\n fileReader.onerror = reject;\n\n fileReader.readAsArrayBuffer(file);\n });\n}\n\nexport default loadFileRequest;\n","import { ByteArray, DataSet } from 'dicom-parser';\nimport getEncapsulatedImageFrame from './getEncapsulatedImageFrame';\nimport getUncompressedImageFrame from './getUncompressedImageFrame';\n\nfunction getPixelData(dataSet: DataSet, frameIndex = 0): ByteArray {\n const pixelDataElement =\n dataSet.elements.x7fe00010 \|\| dataSet.elements.x7fe00008;\n\n if (!pixelDataElement) {\n return null;\n }\n\n if (pixelDataElement.encapsulatedPixelData) {\n return getEncapsulatedImageFrame(dataSet, frameIndex);\n }\n\n return getUncompressedImageFrame(dataSet, frameIndex);\n}\n\nexport default getPixelData;\n","import { DataSet } from 'dicom-parser';\nimport { Types } from '@cornerstonejs/core';\nimport createImage from '../createImage';\nimport { xhrRequest } from '../internal/index';\nimport dataSetCacheManager from './dataSetCacheManager';\nimport {\n LoadRequestFunction,\n DICOMLoaderIImage,\n DICOMLoaderImageOptions,\n ImageFrame,\n} from '../../types';\nimport getPixelData from './getPixelData';\nimport loadFileRequest from './loadFileRequest';\nimport parseImageId from './parseImageId';\n\n// add a decache callback function to clear out our dataSetCacheManager\nfunction addDecache(imageLoadObject: Types.IImageLoadObject, imageId: string) {\n imageLoadObject.decache = function () {\n // console.log('decache');\n const parsedImageId = parseImageId(imageId);\n\n dataSetCacheManager.unload(parsedImageId.url);\n };\n}\n\n/*\n Given the dataSetPromise and imageId this will return a promise to be\n * resolved with an image object containing the loaded image.\n \n @param dataSetPromise - A promise that resolves to a DataSet object.\n * @param imageId - The imageId of the image to be loaded.\n * @param frame - The frame number to be loaded in case of multiframe. it should\n * be noted that this is used to extract the pixelData from dicomParser and\n * dicomParser is 0-based index (the first pixelData is frame 0); however,\n * in metadata and imageId frame is 1-based index (the first frame is frame 1).\n * @param sharedCacheKey - A key to be used to cache the loaded image.\n * @param options - Options to be used when loading the image.\n * @param callbacks - Callbacks to be called when the image is loaded.\n * @returns An object containing a promise to be resolved with the loaded image\n /\nfunction loadImageFromPromise(\n dataSetPromise: Promise<DataSet>,\n imageId: string,\n frame = 0,\n sharedCacheKey: string,\n options: DICOMLoaderImageOptions,\n callbacks?: {\n imageDoneCallback: (image: DICOMLoaderIImage) => void;\n }\n): Types.IImageLoadObject {\n const start = new Date().getTime();\n const imageLoadObject: Types.IImageLoadObject = {\n cancelFn: undefined,\n promise: undefined,\n };\n\n imageLoadObject.promise = new Promise((resolve, reject) => {\n dataSetPromise.then(\n (dataSet / , xhr/) => {\n const pixelData = getPixelData(dataSet, frame);\n const transferSyntax = dataSet.string('x00020010');\n const loadEnd = new Date().getTime();\n const imagePromise = createImage(\n imageId,\n pixelData,\n transferSyntax,\n options\n );\n\n addDecache(imageLoadObject, imageId);\n\n imagePromise.then(\n (image) => {\n image = image as DICOMLoaderIImage;\n image.data = dataSet;\n image.sharedCacheKey = sharedCacheKey;\n const end = new Date().getTime();\n\n image.loadTimeInMS = loadEnd - start;\n image.totalTimeInMS = end - start;\n if (\n callbacks !== undefined &&\n callbacks.imageDoneCallback !== undefined\n ) {\n callbacks.imageDoneCallback(image);\n }\n resolve(image);\n },\n function (error) {\n // Reject the error, and the dataSet\n reject({\n error,\n dataSet,\n });\n }\n );\n },\n function (error) {\n // Reject the error\n reject({\n error,\n });\n }\n );\n });\n\n return imageLoadObject;\n}\n\nfunction loadImageFromDataSet(\n dataSet,\n imageId: string,\n frame = 0,\n sharedCacheKey: string,\n options\n): Types.IImageLoadObject {\n const start = new Date().getTime();\n\n const promise = new Promise<DICOMLoaderIImage \| ImageFrame>(\n (resolve, reject) => {\n const loadEnd = new Date().getTime();\n\n let imagePromise: Promise<DICOMLoaderIImage \| ImageFrame>;\n\n try {\n const pixelData = getPixelData(dataSet, frame);\n const transferSyntax = dataSet.string('x00020010');\n\n imagePromise = createImage(imageId, pixelData, transferSyntax, options);\n } catch (error) {\n // Reject the error, and the dataSet\n reject({\n error,\n dataSet,\n });\n\n return;\n }\n\n imagePromise.then((image) => {\n image = image as DICOMLoaderIImage;\n\n image.data = dataSet;\n image.sharedCacheKey = sharedCacheKey;\n const end = new Date().getTime();\n\n image.loadTimeInMS = loadEnd - start;\n image.totalTimeInMS = end - start;\n resolve(image);\n }, reject);\n }\n );\n\n return {\n promise: promise as Promise<any>,\n cancelFn: undefined,\n };\n}\n\nfunction getLoaderForScheme(scheme: string): LoadRequestFunction {\n if (scheme === 'dicomweb' \|\| scheme === 'wadouri') {\n return xhrRequest;\n } else if (scheme === 'dicomfile') {\n return loadFileRequest;\n }\n}\n\nfunction loadImage(\n imageId: string,\n options: DICOMLoaderImageOptions = {}\n): Types.IImageLoadObject {\n const parsedImageId = parseImageId(imageId);\n\n options = Object.assign({}, options);\n\n // IMPORTANT: if you have a custom loader that you want to use for a specific\n // scheme, you should create your own loader and register it with the scheme\n // in the image loader, and NOT just pass it in as an option. This is because\n // the scheme is used to determine the loader to use and is more maintainable\n\n // The loader isn't transferable, so ensure it is deleted\n delete options.loader;\n // The options might have a loader above, but it is a loader into the cache,\n // so not the scheme loader, which is separate and defined by the scheme here\n const schemeLoader = getLoaderForScheme(parsedImageId.scheme);\n\n // if the dataset for this url is already loaded, use it, in case of multiframe\n // images, we need to extract the frame pixelData from the dataset although the\n // image is loaded\n if (dataSetCacheManager.isLoaded(parsedImageId.url)) {\n /\n @todo The arguments to the dataSetCacheManager below are incorrect.\n /\n const dataSet: DataSet = (dataSetCacheManager as any).get(\n parsedImageId.url,\n schemeLoader,\n imageId\n );\n\n return loadImageFromDataSet(\n dataSet,\n imageId,\n parsedImageId.pixelDataFrame,\n parsedImageId.url,\n options\n );\n }\n\n // load the dataSet via the dataSetCacheManager\n const dataSetPromise = dataSetCacheManager.load(\n parsedImageId.url,\n schemeLoader,\n imageId\n );\n\n return loadImageFromPromise(\n dataSetPromise,\n imageId,\n parsedImageId.frame,\n parsedImageId.url,\n options\n );\n}\n\nexport { loadImageFromPromise, getLoaderForScheme, loadImage };\n","import {\n getImagePixelModule,\n getLUTs,\n getModalityLUTOutputPixelRepresentation,\n getNumberValues,\n metaDataProvider,\n} from './metaData/index';\n\nimport dataSetCacheManager from './dataSetCacheManager';\nimport fileManager from './fileManager';\nimport getEncapsulatedImageFrame from './getEncapsulatedImageFrame';\nimport getUncompressedImageFrame from './getUncompressedImageFrame';\nimport loadFileRequest from './loadFileRequest';\nimport {\n loadImageFromPromise,\n getLoaderForScheme,\n loadImage,\n} from './loadImage';\nimport parseImageId from './parseImageId';\nimport unpackBinaryFrame from './unpackBinaryFrame';\nimport register from './register';\n\nconst metaData = {\n getImagePixelModule,\n getLUTs,\n getModalityLUTOutputPixelRepresentation,\n getNumberValues,\n metaDataProvider,\n};\n\nexport default {\n metaData,\n dataSetCacheManager,\n fileManager,\n getEncapsulatedImageFrame,\n getUncompressedImageFrame,\n loadFileRequest,\n loadImageFromPromise,\n getLoaderForScheme,\n loadImage,\n parseImageId,\n unpackBinaryFrame,\n register,\n};\n","import as cornerstoneImport from '@cornerstonejs/core';\nimport { loadImage } from './loadImage';\nimport { metaDataProvider } from './metaData/index';\n\nexport default function (cornerstone: typeof cornerstoneImport): void {\n // register dicomweb and wadouri image loader prefixes\n cornerstone.registerImageLoader('dicomweb', loadImage);\n cornerstone.registerImageLoader('wadouri', loadImage);\n cornerstone.registerImageLoader('dicomfile', loadImage);\n\n // add wadouri metadata provider\n cornerstone.metaData.addProvider(metaDataProvider);\n}\n","import wadors from './wadors/index';\nimport wadouri from './wadouri/index';\n\n/*\n Register the WADO-URI and WADO-RS image loaders and metaData providers\n * with an instance of Cornerstone Core.\n \n @param cornerstone The Cornerstone Core library to register the image loaders with\n /\nfunction registerLoaders(cornerstone: any): void {\n wadors.register(cornerstone);\n wadouri.register(cornerstone);\n}\n\nexport default registerLoaders;\n","/ eslint import/extensions:0 /\nimport registerLoaders from './imageLoader/registerLoaders';\n\nlet cornerstone;\nlet dicomParser;\n\nconst external = {\n set cornerstone(cs) {\n cornerstone = cs;\n\n registerLoaders(cornerstone);\n },\n get cornerstone() {\n if (!cornerstone) {\n cornerstone = window && (window as any).cornerstone;\n\n if (!cornerstone) {\n throw new Error(\n 'cornerstoneDICOMImageLoader requires a copy of Cornerstone to work properly. Please add cornerstoneDICOMImageLoader.external.cornerstone = cornerstone; to your application.'\n );\n }\n\n registerLoaders(cornerstone);\n }\n\n return cornerstone;\n },\n set dicomParser(dp) {\n dicomParser = dp;\n },\n get dicomParser() {\n if (!dicomParser) {\n if (window && (window as any).dicomParser) {\n dicomParser = (window as any).dicomParser;\n } else {\n throw new Error(\n 'cornerstoneDICOMImageLoader requires a copy of dicomParser to work properly. Please add cornerstoneDICOMImageLoader.external.dicomParser = dicomParser; to your application.'\n );\n }\n }\n\n return dicomParser;\n },\n};\n\nexport default external;\n","import { ByteArray } from 'dicom-parser';\nimport { ImageFrame } from '../../types';\nimport external from '../../externalModules';\n\nfunction convertLUTto8Bit(lut: number[], shift: number) {\n const numEntries = lut.length;\n const cleanedLUT = new Uint8ClampedArray(numEntries);\n\n for (let i = 0; i < numEntries; ++i) {\n cleanedLUT[i] = lut[i] >> shift;\n }\n\n return cleanedLUT;\n}\n\nfunction fetchPaletteData(imageFrame, color, fallback) {\n const data = imageFrame[`${color}PaletteColorLookupTableData`];\n if (data) {\n return Promise.resolve(data);\n }\n\n const result = external.cornerstone.metaData.get(\n 'imagePixelModule',\n imageFrame.imageId\n );\n\n if (result && typeof result.then === 'function') {\n return result.then((module) =>\n module ? module[`${color}PaletteColorLookupTableData`] : fallback\n );\n } else {\n return Promise.resolve(\n result ? result[`${color}PaletteColorLookupTableData`] : fallback\n );\n }\n}\n\n/\n Convert pixel data with PALETTE COLOR Photometric Interpretation to RGBA\n \n @param imageFrame - The ImageFrame to convert\n * @param colorBuffer - The buffer to write the converted pixel data to\n * @returns\n /\nexport default function (\n imageFrame: ImageFrame,\n colorBuffer: ByteArray,\n useRGBA: boolean\n): void {\n const numPixels = imageFrame.columns imageFrame.rows;\n const pixelData = imageFrame.pixelData;\n\n Promise.all([\n fetchPaletteData(imageFrame, 'red', null),\n fetchPaletteData(imageFrame, 'green', null),\n fetchPaletteData(imageFrame, 'blue', null),\n ]).then(([rData, gData, bData]) => {\n if (!rData \|\| !gData \|\| !bData) {\n throw new Error(\n 'The image does not have a complete color palette. R, G, and B palette data are required.'\n );\n }\n\n const len = rData.length;\n let palIndex = 0;\n let bufferIndex = 0;\n\n const start = imageFrame.redPaletteColorLookupTableDescriptor[1];\n const shift =\n imageFrame.redPaletteColorLookupTableDescriptor[2] === 8 ? 0 : 8;\n\n const rDataCleaned = convertLUTto8Bit(rData, shift);\n const gDataCleaned = convertLUTto8Bit(gData, shift);\n const bDataCleaned = convertLUTto8Bit(bData, shift);\n\n if (useRGBA) {\n for (let i = 0; i < numPixels; ++i) {\n let value = pixelData[palIndex++];\n\n if (value < start) {\n value = 0;\n } else if (value > start + len - 1) {\n value = len - 1;\n } else {\n value -= start;\n }\n\n colorBuffer[bufferIndex++] = rDataCleaned[value];\n colorBuffer[bufferIndex++] = gDataCleaned[value];\n colorBuffer[bufferIndex++] = bDataCleaned[value];\n colorBuffer[bufferIndex++] = 255;\n }\n\n return;\n }\n\n for (let i = 0; i < numPixels; ++i) {\n let value = pixelData[palIndex++];\n\n if (value < start) {\n value = 0;\n } else if (value > start + len - 1) {\n value = len - 1;\n } else {\n value -= start;\n }\n\n colorBuffer[bufferIndex++] = rDataCleaned[value];\n colorBuffer[bufferIndex++] = gDataCleaned[value];\n colorBuffer[bufferIndex++] = bDataCleaned[value];\n }\n });\n}\n","import { setOptions } from './internal/index';\nimport { LoaderOptions } from '../types';\n\nfunction configure(options: LoaderOptions): void {\n setOptions(options);\n}\n\nexport default configure;\n","import { ImageFrame } from '../types';\n\nfunction isJPEGBaseline8BitColor(\n imageFrame: ImageFrame,\n transferSyntax: string\n): boolean {\n /** @todo check as any */\n transferSyntax = transferSyntax \|\| (imageFrame as any).transferSyntax;\n\n if (\n imageFrame.bitsAllocated === 8 &&\n transferSyntax === '1.2.840.10008.1.2.4.50' &&\n (imageFrame.samplesPerPixel === 3 \|\| imageFrame.samplesPerPixel === 4)\n ) {\n return true;\n }\n}\n\nexport default isJPEGBaseline8BitColor;\n","import {\n convertRGBColorByPixel,\n convertRGBColorByPlane,\n convertYBRFullByPixel,\n convertYBRFullByPlane,\n convertPALETTECOLOR,\n} from './colorSpaceConverters/index';\n\nimport { default as wadouri } from './wadouri/index';\nimport { default as wadors } from './wadors/index';\nimport { default as configure } from './configure';\nimport { default as convertColorSpace } from './convertColorSpace';\nimport { default as createImage } from './createImage';\nimport { default as decodeImageFrame } from './decodeImageFrame';\nimport { default as decodeJPEGBaseline8BitColor } from './decodeJPEGBaseline8BitColor';\nimport { default as getImageFrame } from './getImageFrame';\nimport { default as getMinMax } from '../shared/getMinMax';\nimport { default as isColorImage } from '../shared/isColorImage';\nimport { default as isJPEGBaseline8BitColor } from './isJPEGBaseline8BitColor';\nimport { default as webWorkerManager } from './webWorkerManager';\nimport { default as getPixelData } from './wadors/getPixelData';\nimport { internal } from './internal/index';\nimport { default as external } from '../externalModules';\n\nconst cornerstoneDICOMImageLoader = {\n convertRGBColorByPixel,\n convertRGBColorByPlane,\n convertYBRFullByPixel,\n convertYBRFullByPlane,\n convertPALETTECOLOR,\n wadouri,\n wadors,\n configure,\n convertColorSpace,\n createImage,\n decodeImageFrame,\n decodeJPEGBaseline8BitColor,\n getImageFrame,\n getPixelData,\n getMinMax,\n isColorImage,\n isJPEGBaseline8BitColor,\n webWorkerManager,\n internal,\n external,\n};\n\nexport {\n convertRGBColorByPixel,\n convertRGBColorByPlane,\n convertYBRFullByPixel,\n convertYBRFullByPlane,\n convertPALETTECOLOR,\n wadouri,\n wadors,\n configure,\n convertColorSpace,\n createImage,\n decodeImageFrame,\n decodeJPEGBaseline8BitColor,\n getImageFrame,\n getPixelData,\n getMinMax,\n isColorImage,\n isJPEGBaseline8BitColor,\n webWorkerManager,\n internal,\n external,\n};\n\nexport default cornerstoneDICOMImageLoader;\n"],"names":["root","factory","exports","module","require","define","amd","this","__WEBPACK_EXTERNAL_MODULE__464__","__WEBPACK_EXTERNAL_MODULE__713__","zlib_inflate","utils","strings","msg","ZStream","GZheader","toString","Object","prototype","Z_NO_FLUSH","Z_FINISH","Z_OK","Z_STREAM_END","Z_NEED_DICT","Z_STREAM_ERROR","Z_DATA_ERROR","Z_MEM_ERROR","Inflate","options","assign","chunkSize","windowBits","to","opt","raw","err","ended","chunks","strm","avail_out","status","inflateInit2","Error","header","inflateGetHeader","dictionary","string2buf","call","Uint8Array","inflateSetDictionary","inflate","input","inflator","push","result","data","flush_mode","_flush_mode","last_avail_out","next_in","avail_in","length","output","next_out","state","wrap","inflateReset","onEnd","next_out_utf8","utf8border","tail","utf8str","buf2string","set","subarray","onData","inflateEnd","chunk","join","flattenChunks","_has","obj","key","hasOwnProperty","sources","Array","slice","arguments","source","shift","TypeError","p","len","i","l","pos","STR_APPLY_UIA_OK","String","fromCharCode","apply","__","_utf8len","q","str","TextEncoder","encode","buf","c","c2","m_pos","str_len","buf_len","charCodeAt","max","TextDecoder","decode","out","utf16buf","c_len","buf2binstring","adler","s1","s2","n","Z_PARTIAL_FLUSH","Z_SYNC_FLUSH","Z_FULL_FLUSH","Z_BLOCK","Z_TREES","Z_ERRNO","Z_BUF_ERROR","Z_NO_COMPRESSION","Z_BEST_SPEED","Z_BEST_COMPRESSION","Z_DEFAULT_COMPRESSION","Z_FILTERED","Z_HUFFMAN_ONLY","Z_RLE","Z_FIXED","Z_DEFAULT_STRATEGY","Z_BINARY","Z_TEXT","Z_UNKNOWN","Z_DEFLATED","crcTable","Uint32Array","table","k","makeTable","crc","t","end","text","time","xflags","os","extra","extra_len","name","comment","hcrc","done","BAD","start","_in","last","_out","beg","dmax","wsize","whave","wnext","s_window","hold","bits","lcode","dcode","lmask","dmask","here","op","dist","from","from_source","window","lencode","distcode","lenbits","distbits","top","dolen","mode","dodist","sane","adler32","crc32","inflate_fast","inflate_table","HEAD","DICT","TYPE","TYPEDO","COPY_","LEN_","LEN","CHECK","MEM","zswap32","InflateState","havedict","flags","check","total","head","wbits","offset","ncode","nlen","ndist","have","next","lens","Uint16Array","work","lendyn","distdyn","back","was","inflateStateCheck","inflateResetKeep","total_in","total_out","Int32Array","inflateReset2","ret","lenfix","distfix","virgin","fixedtables","sym","updatewindow","src","copy","inflateInit","flush","put","left","here_bits","here_op","here_val","last_bits","last_op","last_val","hbuf","opts","order","inf_leave","data_type","dictLength","dictid","inflateInfo","MAXBITS","lbase","lext","dbase","dext","type","lens_index","codes","table_index","incr","fill","low","mask","match","min","curr","drop","used","huff","base","count","offs","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","__webpack_modules__","d","definition","o","defineProperty","enumerable","get","g","globalThis","Function","e","prop","r","Symbol","toStringTag","value","scriptUrl","importScripts","location","document","currentScript","scripts","getElementsByTagName","replace","imageFrame","colorBuffer","useRGBA","numPixels","rgbIndex","bufferIndex","rIndex","gIndex","bIndex","ybrIndex","y","cb","cr","yIndex","cbIndex","crIndex","element","index","defaultValue","Value","getValue","parseFloat","minimumLength","isArray","values","imageIdToURI","imageId","colonIndex","indexOf","substring","getTagValue","tag","justElement","getFrameInformation","PerFrameFunctionalGroupsSequence","SharedFunctionalGroupsSequence","frameNumber","shared","map","it","filter","perFrame","getMultiframeInformation","metaData","NumberOfFrames","rest","_retrieveMultiframeMetadata","imageURI","lastSlashIdx","imageIdFrameless","frame","parseInt","metadata","metadataByImageURI","retrieveMultiframeMetadata","isMultiframe","numberOfFrames","multiframeMetadataByImageURI","add","multiframeMetadata","cachedMetadata","retrievedMetadata","firstFrameMetadata","combined","instance","newInstance","forEach","item","entries","combineFrameInstance","remove","purge","isNMReconstructable","imageSubType","isNMModality","includes","getImageTypeSubItemFromMetadata","imageType","extractOrientationFromMetadata","imageOrientationPatient","getNumberValues","detectorInformationSequence","extractOrientationFromNMMultiframeMetadata","extractPositionFromMetadata","imagePositionPatient","extractPositionFromNMMultiframeMetadata","getInstanceModule","metaDataProvider","types","capitalizedData","capitalizeTag","error","console","charAt","toUpperCase","instanceModuleNames","getFirstNumberValue","sequence","warn","getUSEnhancedRegions","sequenceOfUltrasoundRegions","getSequenceItems","physicalDeltaX","physicalDeltaY","physicalUnitsXDirection","physicalUnitsYDirection","regionLocationMinY0","regionLocationMaxY1","regionLocationMinX0","regionLocationMaxX1","referencePixelX0","referencePixelY0","referencePhysicalPixelValueY","referencePhysicalPixelValueX","regionSpatialFormat","regionDataType","regionFlags","transducerFrequency","getTransferSyntax","transferSyntaxUID","MetadataModules","external","dicomParser","MULTIFRAME","PerFrameFunctionalInformation","SharedFunctionalInformation","metaDataManager","GENERAL_STUDY","studyDescription","studyDate","parseDA","studyTime","parseTM","accessionNumber","GENERAL_SERIES","modality","seriesInstanceUID","seriesNumber","getNumberValue","studyInstanceUID","seriesDate","seriesTime","acquisitionDate","acquisitionTime","GENERAL_IMAGE","sopInstanceUID","instanceNumber","lossyImageCompression","lossyImageCompressionRatio","lossyImageCompressionMethod","PATIENT","patientID","patientName","PATIENT_STUDY","patientAge","patientSize","patientSex","patientWeight","NM_MULTIFRAME_GEOMETRY","sliceThickness","spacingBetweenSlices","pixelSpacing","IMAGE_PLANE","columnPixelSpacing","rowPixelSpacing","rowCosines","columnCosines","frameOfReferenceUID","rows","columns","sliceLocation","ULTRASOUND_ENHANCED_REGION","CALIBRATION","IMAGE_URL","isVideo","imageUrl","thumbnail","rendered","getImageUrlModule","CINE","cineRate","getCineModule","IMAGE_PIXEL","samplesPerPixel","photometricInterpretation","bitsAllocated","bitsStored","highBit","pixelRepresentation","planarConfiguration","pixelAspectRatio","smallestPixelValue","largestPixelValue","redPaletteColorLookupTableDescriptor","greenPaletteColorLookupTableDescriptor","bluePaletteColorLookupTableDescriptor","redPaletteColorLookupTableData","greenPaletteColorLookupTableData","bluePaletteColorLookupTableData","VOI_LUT","windowCenter","windowWidth","MODALITY_LUT","rescaleIntercept","rescaleSlope","rescaleType","SOP_COMMON","sopClassUID","PET_ISOTOPE","radiopharmaceuticalInfo","radiopharmaceuticalStartTime","radiopharmaceuticalStartDateTime","radionuclideTotalDose","radionuclideHalfLife","OVERLAY_PLANE","overlays","overlayGroup","groupStr","pixelData","byte_as_int","dataOffset","x","description","label","roiArea","roiMean","roiStandardDeviation","getOverlayPlaneModule","PET_SERIES","correctedImage","units","decayCorrection","PET_IMAGE","frameReferenceTime","actualFrameDuration","checkToken","token","endIndex","uint","j","stringToUint8Array","open","xhr","url","beforeSend","beforeProcessing","Promise","resolve","response","imageCreated","strict","decodeConfig","convertFloatPixelDataToInt","use16BitDataType","setOptions","newOptions","getOptions","defaultHeaders","params","cornerstone","errorInterceptor","request","XMLHttpRequest","promise","reject","beforeSendHeaders","responseType","headers","keys","setRequestHeader","deferred","onloadstart","event","eventData","triggerEvent","events","onloadend","onreadystatechange","readyState","then","catch","onprogress","oProgress","loaded","percentComplete","lengthComputable","Math","round","onerror","onabort","send","internal","xhrRequest","ImageQualityStatus","Enums","extractMultipart","contentType","imageFrameAsArrayBuffer","isPartial","imageQualityStatus","SUBRESOLUTION","FULL_RESOLUTION","tokenIndex","responseHeaders","boundary","multipartContentType","findIndexOfString","uint8ArrayToString","split","substr","findBoundary","trim","findContentType","extractDone","getImageQualityStatus","retrieveOptions","ProgressiveIterator","utilities","streamRequest","globalOptions","streamingData","minChunkSize","loadIterator","generate","async","iterator","fetch","signal","responseReader","body","getReader","totalBytes","Number","readDone","encodedData","lastSize","read","appendChunk","byteLength","extracted","detail","getNextPromise","existing","newDataArray","rangeRequest","attr","rangesFetched","byteRange","rangeIndex","getByteRange","range","Range","responseArrayBuffer","arrayBuffer","responseTypedArray","newByteArray","contentRange","MAX_SAFE_INTEGER","fetchRangeAndAppend","doneAllBytes","extract","uri","mediaType","Accept","urlArguments","framesPath","streaming","loadPromise","getResponseHeader","storedPixelData","storedPixel","convertRGB","convertRGBColorByPixel","convertRGBColorByPlane","convertColorSpace","convertPALETTECOLOR","y1","y2","convertYBRFull422ByPixel","convertYBRFullByPixel","convertYBRFullByPlane","convertYBRFull","arrayBufferToString","buffer","binary","decodeURIComponent","escape","_error","URIError","binaryToString","canvas","Date","getTime","imgBlob","Blob","fileReader","FileReader","readAsBinaryString","readAsArrayBuffer","onload","img","Image","height","width","context","getContext","drawImage","imageData","getImageData","decodeTimeInMS","minMax","getMinMax","pixelDataLength","btoa","Worker_fn","Worker","nextTaskId","tasks","webWorkers","defaultConfig","maxWebWorkers","navigator","hardwareConcurrency","startWebWorkersOnDemand","webWorkerTaskPaths","taskConfiguration","decodeTask","initializeCodecsOnStartup","config","statistics","numWebWorkers","numTasksQueued","numTasksExecuting","numTasksCompleted","totalTaskTimeInMS","totalTimeDelayedInMS","startTaskOnWebWorker","task","added","worker","postMessage","taskType","workerIndex","transferList","spawnWebWorker","handleMessageFromWorker","action","cornerstoneDICOMImageLoaderWebWorker","addEventListener","initialize","configObject","loadWebWorkerTask","sourcePath","taskConfig","addTask","priority","taskId","splice","getStatistics","setTaskPriority","cancelTask","reason","terminate","processDecodeTask","transferSyntax","srcOptions","loader","transferPixelData","webWorkerManager","pako","inflateRaw","decodeJPEGBaseline8BitColor","imagePixelModule","photoMetricInterpretation","lastImageIdDrawn","setPixelDataType","TypedArray","pixelDataType","isInteger","Int8Array","Int16Array","Float32Array","getPixelDataTypeFromMinMax","typedArray","preScale","enabled","createElement","getImageFrame","decodeLevel","allowFloatRendering","canRenderFloatTextures","scalingParameters","modalityLutModule","generalSeriesModule","suvFactor","suvbw","getScalingParameters","isSharedArrayBuffer","targetBuffer","SharedArrayBuffer","useNativeDataType","decodePromise","decodeImageFrame","isColorImage","isColorImageFn","skipCreateImage","alreadyTyped","rawOffset","rawLength","imageFrameLength","typedArrayConstructors","TypedArrayConstructor","imagePlaneModule","voiLutModule","sopCommonModule","calibrationModule","endsWith","ceil","floor","isColorConversionRequired","createImageData","Uint8ClampedArray","removeAFromRGBA","image","color","calibration","intercept","slope","invert","minPixelValue","maxPixelValue","sizeInBytes","voiLUTFunction","floatPixelData","rgba","getPixelData","getCanvas","numComps","sopClassUid","ctx","arr","putImageData","modalityLUTSequence","modalityLUT","voiLUTSequence","voiLUT","minVoi","minAfterScale","maxVoi","maxAfterScale","streamableTransferSyntaxes","Set","getTransferSyntaxForContentType","defaultTransferSyntax","parameters","parameter","parameterValues","defaultTransferSyntaxByType","decodeLevelFromComplete","percent","retrieveDecodeLevel","testSize","imageRetrievalPool","uncompressedIterator","requestType","additionalDetails","addToBeginning","addRequest","compressedIt","as","lastDecodeLevel","has","useOptions","createImage","loadTimeInMS","bind","getDonePromise","cancelFn","getNumberString","loadImage","register","registerImageLoader","addProvider","getLutDescriptor","dataSet","elements","uint16","getLutData","lutDataSet","lutDescriptor","lut","lutData","byteArray","string","int16","populateSmallestLargestPixelValues","x00281101","numLutEntries","lutBitsAllocated","x00281201","populatePaletteColorLut","getLUT","numLUTEntries","firstValueMapped","id","numBitsPerEntry","lutSequence","items","luts","floatString","minStoredPixelValue","getMinStoredPixelValue","x00283000","valueAsString","firstColonIndex","frameIndex","frameStr","scheme","pixelDataFrame","parsePartialByteArray","pixelDataSet","parseDicom","untilTag","x7fe00010","log","fragments","totalLength","fragment","position","fixFragments","dataSetFromPartialContent","loadRequest","fileTotalLength","fetchMore","fetchOptions","_options","fetchedLength","lengthToFetch","byteArrayToAppend","combinedByteArray","otherAttributtes","x52009230","x52009229","otherElements","intString","_get","loadedDataSets","_isMultiframeDataset","generateMultiframeWADOURIs","listWADOURIs","retrieveMultiframeDataset","frameParameterIndex","retrieveFrameParameterIndex","multiframeURI","isMultiframeDataset","cacheSizeInBytes","promises","getInfo","numberOfDataSetsCached","isLoaded","load","cacheCount","loadDICOMPromise","dicomPart10AsArrayBuffer","partialContent","isPartialContent","ArrayBuffer","cacheInfo","unload","multiframeDataSet","multiframeDataset","newElements","clonedDataset","create","combineFrameInstanceDataset","update","loadedDataSet","getImageTypeSubItemFromDataset","subTypes","extractOrientationFromDataset","x00209116","x00540022","extractOrientationFromNMMultiframeDataset","extractPositionFromDataset","x00209113","extractPositionFromNMMultiframeDataset","extractSpacingFromDataset","x00289110","extractSliceThicknessFromDataset","x00180050","parsedImageId","parseImageId","multiframeData","multiframeInfo","getDirectFrameInformation","dataSetCacheManager","frameTime","getImagePixelModule","modalityLUTOutputPixelRepresentation","getModalityLUTOutputPixelRepresentation","getLUTs","x00283010","x00540016","firstRadiopharmaceuticalInfoDataSet","files","file","getEncapsulatedImageFrame","basicOffsetTable","readEncapsulatedImageFrame","framesAreFragmented","createJPEGBasicOffsetTable","byteStream","ByteStream","byteArrayParser","readSequenceItem","seek","fragmentZeroPosition","byteOffset","isBitSet","byte","bitPos","frameOffset","pixelsPerFrame","pixelDataElement","x7fe00008","pixelDataOffset","unpackBinaryFrame","fileIndex","fileManager","target","encapsulatedPixelData","getUncompressedImageFrame","loadImageFromPromise","dataSetPromise","sharedCacheKey","callbacks","imageLoadObject","loadEnd","imagePromise","decache","addDecache","totalTimeInMS","imageDoneCallback","getLoaderForScheme","loadFileRequest","schemeLoader","loadImageFromDataSet","wadors","wadouri","cs","registerLoaders","dp","convertLUTto8Bit","numEntries","cleanedLUT","fetchPaletteData","fallback","all","rData","gData","bData","palIndex","rDataCleaned","gDataCleaned","bDataCleaned","configure","isJPEGBaseline8BitColor"],"sourceRoot":""}