{"version":3,"sources":["jsdelivr-header.js","/npm/jdataview@2.5.0/dist/node/jdataview.js"],"names":[],"mappings":"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","file":"/npm/jdataview@2.5.0/dist/node/jdataview.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/jdataview@2.5.0/dist/node/jdataview.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","!function(factory) {\n    var global = this;\n    module.exports = factory(global);\n}(function(global) {\n    \"use strict\";\n    function is(obj, Ctor) {\n        return \"object\" != typeof obj || null === obj ? !1 : obj.constructor === Ctor || Object.prototype.toString.call(obj) === \"[object \" + Ctor.name + \"]\";\n    }\n    function arrayFrom(arrayLike, forceCopy) {\n        return !forceCopy && is(arrayLike, Array) ? arrayLike : Array.prototype.slice.call(arrayLike);\n    }\n    function defined(value, defaultValue) {\n        return void 0 !== value ? value : defaultValue;\n    }\n    function jDataView(buffer, byteOffset, byteLength, littleEndian) {\n        if (jDataView.is(buffer)) {\n            var result = buffer.slice(byteOffset, byteOffset + byteLength);\n            return result._littleEndian = defined(littleEndian, result._littleEndian), result;\n        }\n        if (!jDataView.is(this)) return new jDataView(buffer, byteOffset, byteLength, littleEndian);\n        if (this.buffer = buffer = jDataView.wrapBuffer(buffer), this._isArrayBuffer = compatibility.ArrayBuffer && is(buffer, ArrayBuffer), \n        this._isPixelData = !1, this._isDataView = compatibility.DataView && this._isArrayBuffer, \n        this._isNodeBuffer = !0 && compatibility.NodeBuffer && is(buffer, Buffer), !this._isNodeBuffer && !this._isArrayBuffer && !is(buffer, Array)) throw new TypeError(\"jDataView buffer has an incompatible type\");\n        this._littleEndian = !!littleEndian;\n        var bufferLength = \"byteLength\" in buffer ? buffer.byteLength : buffer.length;\n        this.byteOffset = byteOffset = defined(byteOffset, 0), this.byteLength = byteLength = defined(byteLength, bufferLength - byteOffset), \n        this._offset = this._bitOffset = 0, this._isDataView ? this._view = new DataView(buffer, byteOffset, byteLength) : this._checkBounds(byteOffset, byteLength, bufferLength), \n        this._engineAction = this._isDataView ? this._dataViewAction : this._isNodeBuffer ? this._nodeBufferAction : this._isArrayBuffer ? this._arrayBufferAction : this._arrayAction;\n    }\n    function getCharCodes(string) {\n        if (compatibility.NodeBuffer) return new Buffer(string, \"binary\");\n        for (var Type = compatibility.ArrayBuffer ? Uint8Array : Array, codes = new Type(string.length), i = 0, length = string.length; length > i; i++) codes[i] = 255 & string.charCodeAt(i);\n        return codes;\n    }\n    function pow2(n) {\n        return n >= 0 && 31 > n ? 1 << n : pow2[n] || (pow2[n] = Math.pow(2, n));\n    }\n    function Uint64(lo, hi) {\n        this.lo = lo, this.hi = hi;\n    }\n    function Int64() {\n        Uint64.apply(this, arguments);\n    }\n    var compatibility = {\n        NodeBuffer: !0 && \"Buffer\" in global,\n        DataView: \"DataView\" in global,\n        ArrayBuffer: \"ArrayBuffer\" in global,\n        PixelData: !1\n    }, TextEncoder = global.TextEncoder, TextDecoder = global.TextDecoder;\n    compatibility.NodeBuffer && !function(buffer) {\n        try {\n            buffer.writeFloatLE(1/0, 0);\n        } catch (e) {\n            compatibility.NodeBuffer = !1;\n        }\n    }(new Buffer(4));\n    var dataTypes = {\n        Int8: 1,\n        Int16: 2,\n        Int32: 4,\n        Uint8: 1,\n        Uint16: 2,\n        Uint32: 4,\n        Float32: 4,\n        Float64: 8\n    };\n    jDataView.wrapBuffer = function(buffer) {\n        switch (typeof buffer) {\n          case \"number\":\n            if (compatibility.NodeBuffer) buffer = new Buffer(buffer), buffer.fill(0); else if (compatibility.ArrayBuffer) buffer = new Uint8Array(buffer).buffer; else {\n                buffer = new Array(buffer);\n                for (var i = 0; i < buffer.length; i++) buffer[i] = 0;\n            }\n            return buffer;\n\n          case \"string\":\n            buffer = getCharCodes(buffer);\n\n          default:\n            return \"length\" in buffer && !(compatibility.NodeBuffer && is(buffer, Buffer) || compatibility.ArrayBuffer && is(buffer, ArrayBuffer)) && (compatibility.NodeBuffer ? buffer = new Buffer(buffer) : compatibility.ArrayBuffer ? is(buffer, ArrayBuffer) || (buffer = new Uint8Array(buffer).buffer, \n            is(buffer, ArrayBuffer) || (buffer = new Uint8Array(arrayFrom(buffer, !0)).buffer)) : buffer = arrayFrom(buffer)), \n            buffer;\n        }\n    }, jDataView.is = function(view) {\n        return view && view.jDataView;\n    }, jDataView.from = function() {\n        return new jDataView(arguments);\n    }, jDataView.Uint64 = Uint64, Uint64.prototype = {\n        valueOf: function() {\n            return this.lo + pow2(32) * this.hi;\n        },\n        toString: function() {\n            return Number.prototype.toString.apply(this.valueOf(), arguments);\n        }\n    }, Uint64.fromNumber = function(number) {\n        var hi = Math.floor(number / pow2(32)), lo = number - hi * pow2(32);\n        return new Uint64(lo, hi);\n    }, jDataView.Int64 = Int64, Int64.prototype = \"create\" in Object ? Object.create(Uint64.prototype) : new Uint64(), \n    Int64.prototype.valueOf = function() {\n        return this.hi < pow2(31) ? Uint64.prototype.valueOf.apply(this, arguments) : -(pow2(32) - this.lo + pow2(32) * (pow2(32) - 1 - this.hi));\n    }, Int64.fromNumber = function(number) {\n        var lo, hi;\n        if (number >= 0) {\n            var unsigned = Uint64.fromNumber(number);\n            lo = unsigned.lo, hi = unsigned.hi;\n        } else hi = Math.floor(number / pow2(32)), lo = number - hi * pow2(32), hi += pow2(32);\n        return new Int64(lo, hi);\n    };\n    var proto = jDataView.prototype = {\n        compatibility: compatibility,\n        jDataView: !0,\n        _checkBounds: function(byteOffset, byteLength, maxLength) {\n            if (\"number\" != typeof byteOffset) throw new TypeError(\"Offset is not a number.\");\n            if (\"number\" != typeof byteLength) throw new TypeError(\"Size is not a number.\");\n            if (0 > byteLength) throw new RangeError(\"Length is negative.\");\n            if (0 > byteOffset || byteOffset + byteLength > defined(maxLength, this.byteLength)) throw new RangeError(\"Offsets are out of bounds.\");\n        },\n        _action: function(type, isReadAction, byteOffset, littleEndian, value) {\n            return this._engineAction(type, isReadAction, defined(byteOffset, this._offset), defined(littleEndian, this._littleEndian), value);\n        },\n        _dataViewAction: function(type, isReadAction, byteOffset, littleEndian, value) {\n            return this._offset = byteOffset + dataTypes[type], isReadAction ? this._view[\"get\" + type](byteOffset, littleEndian) : this._view[\"set\" + type](byteOffset, value, littleEndian);\n        },\n        _arrayBufferAction: function(type, isReadAction, byteOffset, littleEndian, value) {\n            var typedArray, size = dataTypes[type], TypedArray = global[type + \"Array\"];\n            if (littleEndian = defined(littleEndian, this._littleEndian), 1 === size || (this.byteOffset + byteOffset) % size === 0 && littleEndian) return typedArray = new TypedArray(this.buffer, this.byteOffset + byteOffset, 1), \n            this._offset = byteOffset + size, isReadAction ? typedArray[0] : typedArray[0] = value;\n            var bytes = new Uint8Array(isReadAction ? this.getBytes(size, byteOffset, littleEndian, !0) : size);\n            return typedArray = new TypedArray(bytes.buffer, 0, 1), isReadAction ? typedArray[0] : (typedArray[0] = value, \n            void this._setBytes(byteOffset, bytes, littleEndian));\n        },\n        _arrayAction: function(type, isReadAction, byteOffset, littleEndian, value) {\n            return isReadAction ? this[\"_get\" + type](byteOffset, littleEndian) : this[\"_set\" + type](byteOffset, value, littleEndian);\n        },\n        _getBytes: function(length, byteOffset, littleEndian) {\n            littleEndian = defined(littleEndian, this._littleEndian), byteOffset = defined(byteOffset, this._offset), \n            length = defined(length, this.byteLength - byteOffset), this._checkBounds(byteOffset, length), \n            byteOffset += this.byteOffset, this._offset = byteOffset - this.byteOffset + length;\n            var result = this._isArrayBuffer ? new Uint8Array(this.buffer, byteOffset, length) : (this.buffer.slice || Array.prototype.slice).call(this.buffer, byteOffset, byteOffset + length);\n            return littleEndian || 1 >= length ? result : arrayFrom(result).reverse();\n        },\n        getBytes: function(length, byteOffset, littleEndian, toArray) {\n            var result = this._getBytes(length, byteOffset, defined(littleEndian, !0));\n            return toArray ? arrayFrom(result) : result;\n        },\n        _setBytes: function(byteOffset, bytes, littleEndian) {\n            var length = bytes.length;\n            if (0 !== length) {\n                if (littleEndian = defined(littleEndian, this._littleEndian), byteOffset = defined(byteOffset, this._offset), \n                this._checkBounds(byteOffset, length), !littleEndian && length > 1 && (bytes = arrayFrom(bytes, !0).reverse()), \n                byteOffset += this.byteOffset, this._isArrayBuffer) new Uint8Array(this.buffer, byteOffset, length).set(bytes); else if (this._isNodeBuffer) new Buffer(bytes).copy(this.buffer, byteOffset); else for (var i = 0; length > i; i++) this.buffer[byteOffset + i] = bytes[i];\n                this._offset = byteOffset - this.byteOffset + length;\n            }\n        },\n        setBytes: function(byteOffset, bytes, littleEndian) {\n            this._setBytes(byteOffset, bytes, defined(littleEndian, !0));\n        },\n        getString: function(byteLength, byteOffset, encoding) {\n            if (this._isNodeBuffer) return byteOffset = defined(byteOffset, this._offset), byteLength = defined(byteLength, this.byteLength - byteOffset), \n            this._checkBounds(byteOffset, byteLength), this._offset = byteOffset + byteLength, \n            this.buffer.toString(encoding || \"binary\", this.byteOffset + byteOffset, this.byteOffset + this._offset);\n            var bytes = this._getBytes(byteLength, byteOffset, !0);\n            if (encoding = \"utf8\" === encoding ? \"utf-8\" : encoding || \"binary\", TextDecoder && \"binary\" !== encoding) return new TextDecoder(encoding).decode(this._isArrayBuffer ? bytes : new Uint8Array(bytes));\n            var string = \"\";\n            byteLength = bytes.length;\n            for (var i = 0; byteLength > i; i++) string += String.fromCharCode(bytes[i]);\n            return \"utf-8\" === encoding && (string = decodeURIComponent(escape(string))), string;\n        },\n        setString: function(byteOffset, subString, encoding) {\n            if (this._isNodeBuffer) return byteOffset = defined(byteOffset, this._offset), this._checkBounds(byteOffset, subString.length), \n            void (this._offset = byteOffset + this.buffer.write(subString, this.byteOffset + byteOffset, encoding || \"binary\"));\n            encoding = \"utf8\" === encoding ? \"utf-8\" : encoding || \"binary\";\n            var bytes;\n            TextEncoder && \"binary\" !== encoding ? bytes = new TextEncoder(encoding).encode(subString) : (\"utf-8\" === encoding && (subString = unescape(encodeURIComponent(subString))), \n            bytes = getCharCodes(subString)), this._setBytes(byteOffset, bytes, !0);\n        },\n        getChar: function(byteOffset) {\n            return this.getString(1, byteOffset);\n        },\n        setChar: function(byteOffset, character) {\n            this.setString(byteOffset, character);\n        },\n        tell: function() {\n            return this._offset;\n        },\n        seek: function(byteOffset) {\n            return this._checkBounds(byteOffset, 0), this._offset = byteOffset;\n        },\n        skip: function(byteLength) {\n            return this.seek(this._offset + byteLength);\n        },\n        slice: function(start, end, forceCopy) {\n            function normalizeOffset(offset, byteLength) {\n                return 0 > offset ? offset + byteLength : offset;\n            }\n            return start = normalizeOffset(start, this.byteLength), end = normalizeOffset(defined(end, this.byteLength), this.byteLength), \n            forceCopy ? new jDataView(this.getBytes(end - start, start, !0, !0), void 0, void 0, this._littleEndian) : new jDataView(this.buffer, this.byteOffset + start, end - start, this._littleEndian);\n        },\n        alignBy: function(byteCount) {\n            return this._bitOffset = 0, 1 !== defined(byteCount, 1) ? this.skip(byteCount - (this._offset % byteCount || byteCount)) : this._offset;\n        },\n        _getFloat64: function(byteOffset, littleEndian) {\n            var b = this._getBytes(8, byteOffset, littleEndian), sign = 1 - 2 * (b[7] >> 7), exponent = ((b[7] << 1 & 255) << 3 | b[6] >> 4) - 1023, mantissa = (15 & b[6]) * pow2(48) + b[5] * pow2(40) + b[4] * pow2(32) + b[3] * pow2(24) + b[2] * pow2(16) + b[1] * pow2(8) + b[0];\n            return 1024 === exponent ? 0 !== mantissa ? 0/0 : 1/0 * sign : -1023 === exponent ? sign * mantissa * pow2(-1074) : sign * (1 + mantissa * pow2(-52)) * pow2(exponent);\n        },\n        _getFloat32: function(byteOffset, littleEndian) {\n            var b = this._getBytes(4, byteOffset, littleEndian), sign = 1 - 2 * (b[3] >> 7), exponent = (b[3] << 1 & 255 | b[2] >> 7) - 127, mantissa = (127 & b[2]) << 16 | b[1] << 8 | b[0];\n            return 128 === exponent ? 0 !== mantissa ? 0/0 : 1/0 * sign : -127 === exponent ? sign * mantissa * pow2(-149) : sign * (1 + mantissa * pow2(-23)) * pow2(exponent);\n        },\n        _get64: function(Type, byteOffset, littleEndian) {\n            littleEndian = defined(littleEndian, this._littleEndian), byteOffset = defined(byteOffset, this._offset);\n            for (var parts = littleEndian ? [ 0, 4 ] : [ 4, 0 ], i = 0; 2 > i; i++) parts[i] = this.getUint32(byteOffset + parts[i], littleEndian);\n            return this._offset = byteOffset + 8, new Type(parts[0], parts[1]);\n        },\n        getInt64: function(byteOffset, littleEndian) {\n            return this._get64(Int64, byteOffset, littleEndian);\n        },\n        getUint64: function(byteOffset, littleEndian) {\n            return this._get64(Uint64, byteOffset, littleEndian);\n        },\n        _getInt32: function(byteOffset, littleEndian) {\n            var b = this._getBytes(4, byteOffset, littleEndian);\n            return b[3] << 24 | b[2] << 16 | b[1] << 8 | b[0];\n        },\n        _getUint32: function(byteOffset, littleEndian) {\n            return this._getInt32(byteOffset, littleEndian) >>> 0;\n        },\n        _getInt16: function(byteOffset, littleEndian) {\n            return this._getUint16(byteOffset, littleEndian) << 16 >> 16;\n        },\n        _getUint16: function(byteOffset, littleEndian) {\n            var b = this._getBytes(2, byteOffset, littleEndian);\n            return b[1] << 8 | b[0];\n        },\n        _getInt8: function(byteOffset) {\n            return this._getUint8(byteOffset) << 24 >> 24;\n        },\n        _getUint8: function(byteOffset) {\n            return this._getBytes(1, byteOffset)[0];\n        },\n        _getBitRangeData: function(bitLength, byteOffset) {\n            var startBit = (defined(byteOffset, this._offset) << 3) + this._bitOffset, endBit = startBit + bitLength, start = startBit >>> 3, end = endBit + 7 >>> 3, b = this._getBytes(end - start, start, !0), wideValue = 0;\n            (this._bitOffset = 7 & endBit) && (this._bitOffset -= 8);\n            for (var i = 0, length = b.length; length > i; i++) wideValue = wideValue << 8 | b[i];\n            return {\n                start: start,\n                bytes: b,\n                wideValue: wideValue\n            };\n        },\n        getSigned: function(bitLength, byteOffset) {\n            var shift = 32 - bitLength;\n            return this.getUnsigned(bitLength, byteOffset) << shift >> shift;\n        },\n        getUnsigned: function(bitLength, byteOffset) {\n            var value = this._getBitRangeData(bitLength, byteOffset).wideValue >>> -this._bitOffset;\n            return 32 > bitLength ? value & ~(-1 << bitLength) : value;\n        },\n        _setBinaryFloat: function(byteOffset, value, mantSize, expSize, littleEndian) {\n            var exponent, mantissa, signBit = 0 > value ? 1 : 0, eMax = ~(-1 << expSize - 1), eMin = 1 - eMax;\n            0 > value && (value = -value), 0 === value ? (exponent = 0, mantissa = 0) : isNaN(value) ? (exponent = 2 * eMax + 1, \n            mantissa = 1) : 1/0 === value ? (exponent = 2 * eMax + 1, mantissa = 0) : (exponent = Math.floor(Math.log(value) / Math.LN2), \n            exponent >= eMin && eMax >= exponent ? (mantissa = Math.floor((value * pow2(-exponent) - 1) * pow2(mantSize)), \n            exponent += eMax) : (mantissa = Math.floor(value / pow2(eMin - mantSize)), exponent = 0));\n            for (var b = []; mantSize >= 8; ) b.push(mantissa % 256), mantissa = Math.floor(mantissa / 256), \n            mantSize -= 8;\n            for (exponent = exponent << mantSize | mantissa, expSize += mantSize; expSize >= 8; ) b.push(255 & exponent), \n            exponent >>>= 8, expSize -= 8;\n            b.push(signBit << expSize | exponent), this._setBytes(byteOffset, b, littleEndian);\n        },\n        _setFloat32: function(byteOffset, value, littleEndian) {\n            this._setBinaryFloat(byteOffset, value, 23, 8, littleEndian);\n        },\n        _setFloat64: function(byteOffset, value, littleEndian) {\n            this._setBinaryFloat(byteOffset, value, 52, 11, littleEndian);\n        },\n        _set64: function(Type, byteOffset, value, littleEndian) {\n            \"object\" != typeof value && (value = Type.fromNumber(value)), littleEndian = defined(littleEndian, this._littleEndian), \n            byteOffset = defined(byteOffset, this._offset);\n            var parts = littleEndian ? {\n                lo: 0,\n                hi: 4\n            } : {\n                lo: 4,\n                hi: 0\n            };\n            for (var partName in parts) this.setUint32(byteOffset + parts[partName], value[partName], littleEndian);\n            this._offset = byteOffset + 8;\n        },\n        setInt64: function(byteOffset, value, littleEndian) {\n            this._set64(Int64, byteOffset, value, littleEndian);\n        },\n        setUint64: function(byteOffset, value, littleEndian) {\n            this._set64(Uint64, byteOffset, value, littleEndian);\n        },\n        _setUint32: function(byteOffset, value, littleEndian) {\n            this._setBytes(byteOffset, [ 255 & value, value >>> 8 & 255, value >>> 16 & 255, value >>> 24 ], littleEndian);\n        },\n        _setUint16: function(byteOffset, value, littleEndian) {\n            this._setBytes(byteOffset, [ 255 & value, value >>> 8 & 255 ], littleEndian);\n        },\n        _setUint8: function(byteOffset, value) {\n            this._setBytes(byteOffset, [ 255 & value ]);\n        },\n        setUnsigned: function(byteOffset, value, bitLength) {\n            var data = this._getBitRangeData(bitLength, byteOffset), wideValue = data.wideValue, b = data.bytes;\n            wideValue &= ~(~(-1 << bitLength) << -this._bitOffset), wideValue |= (32 > bitLength ? value & ~(-1 << bitLength) : value) << -this._bitOffset;\n            for (var i = b.length - 1; i >= 0; i--) b[i] = 255 & wideValue, wideValue >>>= 8;\n            this._setBytes(data.start, b, !0);\n        }\n    }, nodeNaming = {\n        Int8: \"Int8\",\n        Int16: \"Int16\",\n        Int32: \"Int32\",\n        Uint8: \"UInt8\",\n        Uint16: \"UInt16\",\n        Uint32: \"UInt32\",\n        Float32: \"Float\",\n        Float64: \"Double\"\n    };\n    proto._nodeBufferAction = function(type, isReadAction, byteOffset, littleEndian, value) {\n        this._offset = byteOffset + dataTypes[type];\n        var nodeName = nodeNaming[type] + (\"Int8\" === type || \"Uint8\" === type ? \"\" : littleEndian ? \"LE\" : \"BE\");\n        return byteOffset += this.byteOffset, isReadAction ? this.buffer[\"read\" + nodeName](byteOffset) : this.buffer[\"write\" + nodeName](value, byteOffset);\n    };\n    for (var type in dataTypes) !function(type) {\n        proto[\"get\" + type] = function(byteOffset, littleEndian) {\n            return this._action(type, !0, byteOffset, littleEndian);\n        }, proto[\"set\" + type] = function(byteOffset, value, littleEndian) {\n            this._action(type, !1, byteOffset, littleEndian, value);\n        };\n    }(type);\n    proto._setInt32 = proto._setUint32, proto._setInt16 = proto._setUint16, proto._setInt8 = proto._setUint8, \n    proto.setSigned = proto.setUnsigned;\n    for (var method in proto) \"set\" === method.slice(0, 3) && !function(type) {\n        proto[\"write\" + type] = function() {\n            Array.prototype.unshift.call(arguments, void 0), this[\"set\" + type].apply(this, arguments);\n        };\n    }(method.slice(3));\n    return jDataView;\n});"]}