@nsshunt/stsfhirpg 1.2.20 → 1.2.21

package/dist/index.cjs

@@ -6,6 +6,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
@@ -22,7 +23,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 let luxon = require("luxon");
-let murmurhash3js = require("murmurhash3js");
 let node_fs = require("node:fs");
 node_fs = __toESM(node_fs);
 let crypto = require("crypto");
@@ -99,45 +99,1338 @@ var FHIRDateUtils = class {
 	}
 };
 //#endregion
+//#region node_modules/cuint/lib/uint32.js
+var require_uint32 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root) {
+		UINT32(Math.pow(36, 5)), UINT32(Math.pow(16, 7)), UINT32(Math.pow(10, 9)), UINT32(Math.pow(2, 30));
+		UINT32(36), UINT32(16), UINT32(10), UINT32(2);
+		/**
+		*	Represents an unsigned 32 bits integer
+		* @constructor
+		* @param {Number|String|Number} low bits     | integer as a string 		 | integer as a number
+		* @param {Number|Number|Undefined} high bits | radix (optional, default=10)
+		* @return 
+		*/
+		function UINT32(l, h) {
+			if (!(this instanceof UINT32)) return new UINT32(l, h);
+			this._low = 0;
+			this._high = 0;
+			this.remainder = null;
+			if (typeof h == "undefined") return fromNumber.call(this, l);
+			if (typeof l == "string") return fromString.call(this, l, h);
+			fromBits.call(this, l, h);
+		}
+		/**
+		* Set the current _UINT32_ object with its low and high bits
+		* @method fromBits
+		* @param {Number} low bits
+		* @param {Number} high bits
+		* @return ThisExpression
+		*/
+		function fromBits(l, h) {
+			this._low = l | 0;
+			this._high = h | 0;
+			return this;
+		}
+		UINT32.prototype.fromBits = fromBits;
+		/**
+		* Set the current _UINT32_ object from a number
+		* @method fromNumber
+		* @param {Number} number
+		* @return ThisExpression
+		*/
+		function fromNumber(value) {
+			this._low = value & 65535;
+			this._high = value >>> 16;
+			return this;
+		}
+		UINT32.prototype.fromNumber = fromNumber;
+		/**
+		* Set the current _UINT32_ object from a string
+		* @method fromString
+		* @param {String} integer as a string
+		* @param {Number} radix (optional, default=10)
+		* @return ThisExpression
+		*/
+		function fromString(s, radix) {
+			var value = parseInt(s, radix || 10);
+			this._low = value & 65535;
+			this._high = value >>> 16;
+			return this;
+		}
+		UINT32.prototype.fromString = fromString;
+		/**
+		* Convert this _UINT32_ to a number
+		* @method toNumber
+		* @return {Number} the converted UINT32
+		*/
+		UINT32.prototype.toNumber = function() {
+			return this._high * 65536 + this._low;
+		};
+		/**
+		* Convert this _UINT32_ to a string
+		* @method toString
+		* @param {Number} radix (optional, default=10)
+		* @return {String} the converted UINT32
+		*/
+		UINT32.prototype.toString = function(radix) {
+			return this.toNumber().toString(radix || 10);
+		};
+		/**
+		* Add two _UINT32_. The current _UINT32_ stores the result
+		* @method add
+		* @param {Object} other UINT32
+		* @return ThisExpression
+		*/
+		UINT32.prototype.add = function(other) {
+			var a00 = this._low + other._low;
+			var a16 = a00 >>> 16;
+			a16 += this._high + other._high;
+			this._low = a00 & 65535;
+			this._high = a16 & 65535;
+			return this;
+		};
+		/**
+		* Subtract two _UINT32_. The current _UINT32_ stores the result
+		* @method subtract
+		* @param {Object} other UINT32
+		* @return ThisExpression
+		*/
+		UINT32.prototype.subtract = function(other) {
+			return this.add(other.clone().negate());
+		};
+		/**
+		* Multiply two _UINT32_. The current _UINT32_ stores the result
+		* @method multiply
+		* @param {Object} other UINT32
+		* @return ThisExpression
+		*/
+		UINT32.prototype.multiply = function(other) {
+			var a16 = this._high;
+			var a00 = this._low;
+			var b16 = other._high;
+			var b00 = other._low;
+			var c16, c00 = a00 * b00;
+			c16 = c00 >>> 16;
+			c16 += a16 * b00;
+			c16 &= 65535;
+			c16 += a00 * b16;
+			this._low = c00 & 65535;
+			this._high = c16 & 65535;
+			return this;
+		};
+		/**
+		* Divide two _UINT32_. The current _UINT32_ stores the result.
+		* The remainder is made available as the _remainder_ property on
+		* the _UINT32_ object. It can be null, meaning there are no remainder.
+		* @method div
+		* @param {Object} other UINT32
+		* @return ThisExpression
+		*/
+		UINT32.prototype.div = function(other) {
+			if (other._low == 0 && other._high == 0) throw Error("division by zero");
+			if (other._high == 0 && other._low == 1) {
+				this.remainder = new UINT32(0);
+				return this;
+			}
+			if (other.gt(this)) {
+				this.remainder = this.clone();
+				this._low = 0;
+				this._high = 0;
+				return this;
+			}
+			if (this.eq(other)) {
+				this.remainder = new UINT32(0);
+				this._low = 1;
+				this._high = 0;
+				return this;
+			}
+			var _other = other.clone();
+			var i = -1;
+			while (!this.lt(_other)) {
+				_other.shiftLeft(1, true);
+				i++;
+			}
+			this.remainder = this.clone();
+			this._low = 0;
+			this._high = 0;
+			for (; i >= 0; i--) {
+				_other.shiftRight(1);
+				if (!this.remainder.lt(_other)) {
+					this.remainder.subtract(_other);
+					if (i >= 16) this._high |= 1 << i - 16;
+					else this._low |= 1 << i;
+				}
+			}
+			return this;
+		};
+		/**
+		* Negate the current _UINT32_
+		* @method negate
+		* @return ThisExpression
+		*/
+		UINT32.prototype.negate = function() {
+			var v = (~this._low & 65535) + 1;
+			this._low = v & 65535;
+			this._high = ~this._high + (v >>> 16) & 65535;
+			return this;
+		};
+		/**
+		* Equals
+		* @method eq
+		* @param {Object} other UINT32
+		* @return {Boolean}
+		*/
+		UINT32.prototype.equals = UINT32.prototype.eq = function(other) {
+			return this._low == other._low && this._high == other._high;
+		};
+		/**
+		* Greater than (strict)
+		* @method gt
+		* @param {Object} other UINT32
+		* @return {Boolean}
+		*/
+		UINT32.prototype.greaterThan = UINT32.prototype.gt = function(other) {
+			if (this._high > other._high) return true;
+			if (this._high < other._high) return false;
+			return this._low > other._low;
+		};
+		/**
+		* Less than (strict)
+		* @method lt
+		* @param {Object} other UINT32
+		* @return {Boolean}
+		*/
+		UINT32.prototype.lessThan = UINT32.prototype.lt = function(other) {
+			if (this._high < other._high) return true;
+			if (this._high > other._high) return false;
+			return this._low < other._low;
+		};
+		/**
+		* Bitwise OR
+		* @method or
+		* @param {Object} other UINT32
+		* @return ThisExpression
+		*/
+		UINT32.prototype.or = function(other) {
+			this._low |= other._low;
+			this._high |= other._high;
+			return this;
+		};
+		/**
+		* Bitwise AND
+		* @method and
+		* @param {Object} other UINT32
+		* @return ThisExpression
+		*/
+		UINT32.prototype.and = function(other) {
+			this._low &= other._low;
+			this._high &= other._high;
+			return this;
+		};
+		/**
+		* Bitwise NOT
+		* @method not
+		* @return ThisExpression
+		*/
+		UINT32.prototype.not = function() {
+			this._low = ~this._low & 65535;
+			this._high = ~this._high & 65535;
+			return this;
+		};
+		/**
+		* Bitwise XOR
+		* @method xor
+		* @param {Object} other UINT32
+		* @return ThisExpression
+		*/
+		UINT32.prototype.xor = function(other) {
+			this._low ^= other._low;
+			this._high ^= other._high;
+			return this;
+		};
+		/**
+		* Bitwise shift right
+		* @method shiftRight
+		* @param {Number} number of bits to shift
+		* @return ThisExpression
+		*/
+		UINT32.prototype.shiftRight = UINT32.prototype.shiftr = function(n) {
+			if (n > 16) {
+				this._low = this._high >> n - 16;
+				this._high = 0;
+			} else if (n == 16) {
+				this._low = this._high;
+				this._high = 0;
+			} else {
+				this._low = this._low >> n | this._high << 16 - n & 65535;
+				this._high >>= n;
+			}
+			return this;
+		};
+		/**
+		* Bitwise shift left
+		* @method shiftLeft
+		* @param {Number} number of bits to shift
+		* @param {Boolean} allow overflow
+		* @return ThisExpression
+		*/
+		UINT32.prototype.shiftLeft = UINT32.prototype.shiftl = function(n, allowOverflow) {
+			if (n > 16) {
+				this._high = this._low << n - 16;
+				this._low = 0;
+				if (!allowOverflow) this._high &= 65535;
+			} else if (n == 16) {
+				this._high = this._low;
+				this._low = 0;
+			} else {
+				this._high = this._high << n | this._low >> 16 - n;
+				this._low = this._low << n & 65535;
+				if (!allowOverflow) this._high &= 65535;
+			}
+			return this;
+		};
+		/**
+		* Bitwise rotate left
+		* @method rotl
+		* @param {Number} number of bits to rotate
+		* @return ThisExpression
+		*/
+		UINT32.prototype.rotateLeft = UINT32.prototype.rotl = function(n) {
+			var v = this._high << 16 | this._low;
+			v = v << n | v >>> 32 - n;
+			this._low = v & 65535;
+			this._high = v >>> 16;
+			return this;
+		};
+		/**
+		* Bitwise rotate right
+		* @method rotr
+		* @param {Number} number of bits to rotate
+		* @return ThisExpression
+		*/
+		UINT32.prototype.rotateRight = UINT32.prototype.rotr = function(n) {
+			var v = this._high << 16 | this._low;
+			v = v >>> n | v << 32 - n;
+			this._low = v & 65535;
+			this._high = v >>> 16;
+			return this;
+		};
+		/**
+		* Clone the current _UINT32_
+		* @method clone
+		* @return {Object} cloned UINT32
+		*/
+		UINT32.prototype.clone = function() {
+			return new UINT32(this._low, this._high);
+		};
+		if (typeof define != "undefined" && define.amd) define([], function() {
+			return UINT32;
+		});
+		else if (typeof module != "undefined" && module.exports) module.exports = UINT32;
+		else root["UINT32"] = UINT32;
+	})(exports);
+}));
+//#endregion
+//#region node_modules/cuint/lib/uint64.js
+var require_uint64 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root) {
+		var radixPowerCache = {
+			16: UINT64(Math.pow(16, 5)),
+			10: UINT64(Math.pow(10, 5)),
+			2: UINT64(Math.pow(2, 5))
+		};
+		var radixCache = {
+			16: UINT64(16),
+			10: UINT64(10),
+			2: UINT64(2)
+		};
+		/**
+		*	Represents an unsigned 64 bits integer
+		* @constructor
+		* @param {Number} first low bits (8)
+		* @param {Number} second low bits (8)
+		* @param {Number} first high bits (8)
+		* @param {Number} second high bits (8)
+		* or
+		* @param {Number} low bits (32)
+		* @param {Number} high bits (32)
+		* or
+		* @param {String|Number} integer as a string 		 | integer as a number
+		* @param {Number|Undefined} radix (optional, default=10)
+		* @return 
+		*/
+		function UINT64(a00, a16, a32, a48) {
+			if (!(this instanceof UINT64)) return new UINT64(a00, a16, a32, a48);
+			this.remainder = null;
+			if (typeof a00 == "string") return fromString.call(this, a00, a16);
+			if (typeof a16 == "undefined") return fromNumber.call(this, a00);
+			fromBits.apply(this, arguments);
+		}
+		/**
+		* Set the current _UINT64_ object with its low and high bits
+		* @method fromBits
+		* @param {Number} first low bits (8)
+		* @param {Number} second low bits (8)
+		* @param {Number} first high bits (8)
+		* @param {Number} second high bits (8)
+		* or
+		* @param {Number} low bits (32)
+		* @param {Number} high bits (32)
+		* @return ThisExpression
+		*/
+		function fromBits(a00, a16, a32, a48) {
+			if (typeof a32 == "undefined") {
+				this._a00 = a00 & 65535;
+				this._a16 = a00 >>> 16;
+				this._a32 = a16 & 65535;
+				this._a48 = a16 >>> 16;
+				return this;
+			}
+			this._a00 = a00 | 0;
+			this._a16 = a16 | 0;
+			this._a32 = a32 | 0;
+			this._a48 = a48 | 0;
+			return this;
+		}
+		UINT64.prototype.fromBits = fromBits;
+		/**
+		* Set the current _UINT64_ object from a number
+		* @method fromNumber
+		* @param {Number} number
+		* @return ThisExpression
+		*/
+		function fromNumber(value) {
+			this._a00 = value & 65535;
+			this._a16 = value >>> 16;
+			this._a32 = 0;
+			this._a48 = 0;
+			return this;
+		}
+		UINT64.prototype.fromNumber = fromNumber;
+		/**
+		* Set the current _UINT64_ object from a string
+		* @method fromString
+		* @param {String} integer as a string
+		* @param {Number} radix (optional, default=10)
+		* @return ThisExpression
+		*/
+		function fromString(s, radix) {
+			radix = radix || 10;
+			this._a00 = 0;
+			this._a16 = 0;
+			this._a32 = 0;
+			this._a48 = 0;
+			var radixUint = radixPowerCache[radix] || new UINT64(Math.pow(radix, 5));
+			for (var i = 0, len = s.length; i < len; i += 5) {
+				var size = Math.min(5, len - i);
+				var value = parseInt(s.slice(i, i + size), radix);
+				this.multiply(size < 5 ? new UINT64(Math.pow(radix, size)) : radixUint).add(new UINT64(value));
+			}
+			return this;
+		}
+		UINT64.prototype.fromString = fromString;
+		/**
+		* Convert this _UINT64_ to a number (last 32 bits are dropped)
+		* @method toNumber
+		* @return {Number} the converted UINT64
+		*/
+		UINT64.prototype.toNumber = function() {
+			return this._a16 * 65536 + this._a00;
+		};
+		/**
+		* Convert this _UINT64_ to a string
+		* @method toString
+		* @param {Number} radix (optional, default=10)
+		* @return {String} the converted UINT64
+		*/
+		UINT64.prototype.toString = function(radix) {
+			radix = radix || 10;
+			var radixUint = radixCache[radix] || new UINT64(radix);
+			if (!this.gt(radixUint)) return this.toNumber().toString(radix);
+			var self = this.clone();
+			var res = new Array(64);
+			for (var i = 63; i >= 0; i--) {
+				self.div(radixUint);
+				res[i] = self.remainder.toNumber().toString(radix);
+				if (!self.gt(radixUint)) break;
+			}
+			res[i - 1] = self.toNumber().toString(radix);
+			return res.join("");
+		};
+		/**
+		* Add two _UINT64_. The current _UINT64_ stores the result
+		* @method add
+		* @param {Object} other UINT64
+		* @return ThisExpression
+		*/
+		UINT64.prototype.add = function(other) {
+			var a00 = this._a00 + other._a00;
+			var a16 = a00 >>> 16;
+			a16 += this._a16 + other._a16;
+			var a32 = a16 >>> 16;
+			a32 += this._a32 + other._a32;
+			var a48 = a32 >>> 16;
+			a48 += this._a48 + other._a48;
+			this._a00 = a00 & 65535;
+			this._a16 = a16 & 65535;
+			this._a32 = a32 & 65535;
+			this._a48 = a48 & 65535;
+			return this;
+		};
+		/**
+		* Subtract two _UINT64_. The current _UINT64_ stores the result
+		* @method subtract
+		* @param {Object} other UINT64
+		* @return ThisExpression
+		*/
+		UINT64.prototype.subtract = function(other) {
+			return this.add(other.clone().negate());
+		};
+		/**
+		* Multiply two _UINT64_. The current _UINT64_ stores the result
+		* @method multiply
+		* @param {Object} other UINT64
+		* @return ThisExpression
+		*/
+		UINT64.prototype.multiply = function(other) {
+			var a00 = this._a00;
+			var a16 = this._a16;
+			var a32 = this._a32;
+			var a48 = this._a48;
+			var b00 = other._a00;
+			var b16 = other._a16;
+			var b32 = other._a32;
+			var b48 = other._a48;
+			var c00 = a00 * b00;
+			var c16 = c00 >>> 16;
+			c16 += a00 * b16;
+			var c32 = c16 >>> 16;
+			c16 &= 65535;
+			c16 += a16 * b00;
+			c32 += c16 >>> 16;
+			c32 += a00 * b32;
+			var c48 = c32 >>> 16;
+			c32 &= 65535;
+			c32 += a16 * b16;
+			c48 += c32 >>> 16;
+			c32 &= 65535;
+			c32 += a32 * b00;
+			c48 += c32 >>> 16;
+			c48 += a00 * b48;
+			c48 &= 65535;
+			c48 += a16 * b32;
+			c48 &= 65535;
+			c48 += a32 * b16;
+			c48 &= 65535;
+			c48 += a48 * b00;
+			this._a00 = c00 & 65535;
+			this._a16 = c16 & 65535;
+			this._a32 = c32 & 65535;
+			this._a48 = c48 & 65535;
+			return this;
+		};
+		/**
+		* Divide two _UINT64_. The current _UINT64_ stores the result.
+		* The remainder is made available as the _remainder_ property on
+		* the _UINT64_ object. It can be null, meaning there are no remainder.
+		* @method div
+		* @param {Object} other UINT64
+		* @return ThisExpression
+		*/
+		UINT64.prototype.div = function(other) {
+			if (other._a16 == 0 && other._a32 == 0 && other._a48 == 0) {
+				if (other._a00 == 0) throw Error("division by zero");
+				if (other._a00 == 1) {
+					this.remainder = new UINT64(0);
+					return this;
+				}
+			}
+			if (other.gt(this)) {
+				this.remainder = this.clone();
+				this._a00 = 0;
+				this._a16 = 0;
+				this._a32 = 0;
+				this._a48 = 0;
+				return this;
+			}
+			if (this.eq(other)) {
+				this.remainder = new UINT64(0);
+				this._a00 = 1;
+				this._a16 = 0;
+				this._a32 = 0;
+				this._a48 = 0;
+				return this;
+			}
+			var _other = other.clone();
+			var i = -1;
+			while (!this.lt(_other)) {
+				_other.shiftLeft(1, true);
+				i++;
+			}
+			this.remainder = this.clone();
+			this._a00 = 0;
+			this._a16 = 0;
+			this._a32 = 0;
+			this._a48 = 0;
+			for (; i >= 0; i--) {
+				_other.shiftRight(1);
+				if (!this.remainder.lt(_other)) {
+					this.remainder.subtract(_other);
+					if (i >= 48) this._a48 |= 1 << i - 48;
+					else if (i >= 32) this._a32 |= 1 << i - 32;
+					else if (i >= 16) this._a16 |= 1 << i - 16;
+					else this._a00 |= 1 << i;
+				}
+			}
+			return this;
+		};
+		/**
+		* Negate the current _UINT64_
+		* @method negate
+		* @return ThisExpression
+		*/
+		UINT64.prototype.negate = function() {
+			var v = (~this._a00 & 65535) + 1;
+			this._a00 = v & 65535;
+			v = (~this._a16 & 65535) + (v >>> 16);
+			this._a16 = v & 65535;
+			v = (~this._a32 & 65535) + (v >>> 16);
+			this._a32 = v & 65535;
+			this._a48 = ~this._a48 + (v >>> 16) & 65535;
+			return this;
+		};
+		/**
+		
+		* @method eq
+		* @param {Object} other UINT64
+		* @return {Boolean}
+		*/
+		UINT64.prototype.equals = UINT64.prototype.eq = function(other) {
+			return this._a48 == other._a48 && this._a00 == other._a00 && this._a32 == other._a32 && this._a16 == other._a16;
+		};
+		/**
+		* Greater than (strict)
+		* @method gt
+		* @param {Object} other UINT64
+		* @return {Boolean}
+		*/
+		UINT64.prototype.greaterThan = UINT64.prototype.gt = function(other) {
+			if (this._a48 > other._a48) return true;
+			if (this._a48 < other._a48) return false;
+			if (this._a32 > other._a32) return true;
+			if (this._a32 < other._a32) return false;
+			if (this._a16 > other._a16) return true;
+			if (this._a16 < other._a16) return false;
+			return this._a00 > other._a00;
+		};
+		/**
+		* Less than (strict)
+		* @method lt
+		* @param {Object} other UINT64
+		* @return {Boolean}
+		*/
+		UINT64.prototype.lessThan = UINT64.prototype.lt = function(other) {
+			if (this._a48 < other._a48) return true;
+			if (this._a48 > other._a48) return false;
+			if (this._a32 < other._a32) return true;
+			if (this._a32 > other._a32) return false;
+			if (this._a16 < other._a16) return true;
+			if (this._a16 > other._a16) return false;
+			return this._a00 < other._a00;
+		};
+		/**
+		* Bitwise OR
+		* @method or
+		* @param {Object} other UINT64
+		* @return ThisExpression
+		*/
+		UINT64.prototype.or = function(other) {
+			this._a00 |= other._a00;
+			this._a16 |= other._a16;
+			this._a32 |= other._a32;
+			this._a48 |= other._a48;
+			return this;
+		};
+		/**
+		* Bitwise AND
+		* @method and
+		* @param {Object} other UINT64
+		* @return ThisExpression
+		*/
+		UINT64.prototype.and = function(other) {
+			this._a00 &= other._a00;
+			this._a16 &= other._a16;
+			this._a32 &= other._a32;
+			this._a48 &= other._a48;
+			return this;
+		};
+		/**
+		* Bitwise XOR
+		* @method xor
+		* @param {Object} other UINT64
+		* @return ThisExpression
+		*/
+		UINT64.prototype.xor = function(other) {
+			this._a00 ^= other._a00;
+			this._a16 ^= other._a16;
+			this._a32 ^= other._a32;
+			this._a48 ^= other._a48;
+			return this;
+		};
+		/**
+		* Bitwise NOT
+		* @method not
+		* @return ThisExpression
+		*/
+		UINT64.prototype.not = function() {
+			this._a00 = ~this._a00 & 65535;
+			this._a16 = ~this._a16 & 65535;
+			this._a32 = ~this._a32 & 65535;
+			this._a48 = ~this._a48 & 65535;
+			return this;
+		};
+		/**
+		* Bitwise shift right
+		* @method shiftRight
+		* @param {Number} number of bits to shift
+		* @return ThisExpression
+		*/
+		UINT64.prototype.shiftRight = UINT64.prototype.shiftr = function(n) {
+			n %= 64;
+			if (n >= 48) {
+				this._a00 = this._a48 >> n - 48;
+				this._a16 = 0;
+				this._a32 = 0;
+				this._a48 = 0;
+			} else if (n >= 32) {
+				n -= 32;
+				this._a00 = (this._a32 >> n | this._a48 << 16 - n) & 65535;
+				this._a16 = this._a48 >> n & 65535;
+				this._a32 = 0;
+				this._a48 = 0;
+			} else if (n >= 16) {
+				n -= 16;
+				this._a00 = (this._a16 >> n | this._a32 << 16 - n) & 65535;
+				this._a16 = (this._a32 >> n | this._a48 << 16 - n) & 65535;
+				this._a32 = this._a48 >> n & 65535;
+				this._a48 = 0;
+			} else {
+				this._a00 = (this._a00 >> n | this._a16 << 16 - n) & 65535;
+				this._a16 = (this._a16 >> n | this._a32 << 16 - n) & 65535;
+				this._a32 = (this._a32 >> n | this._a48 << 16 - n) & 65535;
+				this._a48 = this._a48 >> n & 65535;
+			}
+			return this;
+		};
+		/**
+		* Bitwise shift left
+		* @method shiftLeft
+		* @param {Number} number of bits to shift
+		* @param {Boolean} allow overflow
+		* @return ThisExpression
+		*/
+		UINT64.prototype.shiftLeft = UINT64.prototype.shiftl = function(n, allowOverflow) {
+			n %= 64;
+			if (n >= 48) {
+				this._a48 = this._a00 << n - 48;
+				this._a32 = 0;
+				this._a16 = 0;
+				this._a00 = 0;
+			} else if (n >= 32) {
+				n -= 32;
+				this._a48 = this._a16 << n | this._a00 >> 16 - n;
+				this._a32 = this._a00 << n & 65535;
+				this._a16 = 0;
+				this._a00 = 0;
+			} else if (n >= 16) {
+				n -= 16;
+				this._a48 = this._a32 << n | this._a16 >> 16 - n;
+				this._a32 = (this._a16 << n | this._a00 >> 16 - n) & 65535;
+				this._a16 = this._a00 << n & 65535;
+				this._a00 = 0;
+			} else {
+				this._a48 = this._a48 << n | this._a32 >> 16 - n;
+				this._a32 = (this._a32 << n | this._a16 >> 16 - n) & 65535;
+				this._a16 = (this._a16 << n | this._a00 >> 16 - n) & 65535;
+				this._a00 = this._a00 << n & 65535;
+			}
+			if (!allowOverflow) this._a48 &= 65535;
+			return this;
+		};
+		/**
+		* Bitwise rotate left
+		* @method rotl
+		* @param {Number} number of bits to rotate
+		* @return ThisExpression
+		*/
+		UINT64.prototype.rotateLeft = UINT64.prototype.rotl = function(n) {
+			n %= 64;
+			if (n == 0) return this;
+			if (n >= 32) {
+				var v = this._a00;
+				this._a00 = this._a32;
+				this._a32 = v;
+				v = this._a48;
+				this._a48 = this._a16;
+				this._a16 = v;
+				if (n == 32) return this;
+				n -= 32;
+			}
+			var high = this._a48 << 16 | this._a32;
+			var low = this._a16 << 16 | this._a00;
+			var _high = high << n | low >>> 32 - n;
+			var _low = low << n | high >>> 32 - n;
+			this._a00 = _low & 65535;
+			this._a16 = _low >>> 16;
+			this._a32 = _high & 65535;
+			this._a48 = _high >>> 16;
+			return this;
+		};
+		/**
+		* Bitwise rotate right
+		* @method rotr
+		* @param {Number} number of bits to rotate
+		* @return ThisExpression
+		*/
+		UINT64.prototype.rotateRight = UINT64.prototype.rotr = function(n) {
+			n %= 64;
+			if (n == 0) return this;
+			if (n >= 32) {
+				var v = this._a00;
+				this._a00 = this._a32;
+				this._a32 = v;
+				v = this._a48;
+				this._a48 = this._a16;
+				this._a16 = v;
+				if (n == 32) return this;
+				n -= 32;
+			}
+			var high = this._a48 << 16 | this._a32;
+			var low = this._a16 << 16 | this._a00;
+			var _high = high >>> n | low << 32 - n;
+			var _low = low >>> n | high << 32 - n;
+			this._a00 = _low & 65535;
+			this._a16 = _low >>> 16;
+			this._a32 = _high & 65535;
+			this._a48 = _high >>> 16;
+			return this;
+		};
+		/**
+		* Clone the current _UINT64_
+		* @method clone
+		* @return {Object} cloned UINT64
+		*/
+		UINT64.prototype.clone = function() {
+			return new UINT64(this._a00, this._a16, this._a32, this._a48);
+		};
+		if (typeof define != "undefined" && define.amd) define([], function() {
+			return UINT64;
+		});
+		else if (typeof module != "undefined" && module.exports) module.exports = UINT64;
+		else root["UINT64"] = UINT64;
+	})(exports);
+}));
+//#endregion
+//#region node_modules/cuint/index.js
+var require_cuint = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.UINT32 = require_uint32();
+	exports.UINT64 = require_uint64();
+}));
+//#endregion
+//#region node_modules/xxhashjs/lib/xxhash.js
+var require_xxhash = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	xxHash implementation in pure Javascript
+	
+	Copyright (C) 2013, Pierre Curto
+	MIT license
+	*/
+	var UINT32 = require_cuint().UINT32;
+	UINT32.prototype.xxh_update = function(low, high) {
+		var b00 = PRIME32_2._low;
+		var b16 = PRIME32_2._high;
+		var c16, c00 = low * b00;
+		c16 = c00 >>> 16;
+		c16 += high * b00;
+		c16 &= 65535;
+		c16 += low * b16;
+		var a00 = this._low + (c00 & 65535);
+		var a16 = a00 >>> 16;
+		a16 += this._high + (c16 & 65535);
+		var v = a16 << 16 | a00 & 65535;
+		v = v << 13 | v >>> 19;
+		a00 = v & 65535;
+		a16 = v >>> 16;
+		b00 = PRIME32_1._low;
+		b16 = PRIME32_1._high;
+		c00 = a00 * b00;
+		c16 = c00 >>> 16;
+		c16 += a16 * b00;
+		c16 &= 65535;
+		c16 += a00 * b16;
+		this._low = c00 & 65535;
+		this._high = c16 & 65535;
+	};
+	var PRIME32_1 = UINT32("2654435761");
+	var PRIME32_2 = UINT32("2246822519");
+	var PRIME32_3 = UINT32("3266489917");
+	var PRIME32_4 = UINT32("668265263");
+	var PRIME32_5 = UINT32("374761393");
+	/**
+	* Convert string to proper UTF-8 array
+	* @param str Input string
+	* @returns {Uint8Array} UTF8 array is returned as uint8 array
+	*/
+	function toUTF8Array(str) {
+		var utf8 = [];
+		for (var i = 0, n = str.length; i < n; i++) {
+			var charcode = str.charCodeAt(i);
+			if (charcode < 128) utf8.push(charcode);
+			else if (charcode < 2048) utf8.push(192 | charcode >> 6, 128 | charcode & 63);
+			else if (charcode < 55296 || charcode >= 57344) utf8.push(224 | charcode >> 12, 128 | charcode >> 6 & 63, 128 | charcode & 63);
+			else {
+				i++;
+				charcode = 65536 + ((charcode & 1023) << 10 | str.charCodeAt(i) & 1023);
+				utf8.push(240 | charcode >> 18, 128 | charcode >> 12 & 63, 128 | charcode >> 6 & 63, 128 | charcode & 63);
+			}
+		}
+		return new Uint8Array(utf8);
+	}
+	/**
+	* XXH object used as a constructor or a function
+	* @constructor
+	* or
+	* @param {Object|String} input data
+	* @param {Number|UINT32} seed
+	* @return ThisExpression
+	* or
+	* @return {UINT32} xxHash
+	*/
+	function XXH() {
+		if (arguments.length == 2) return new XXH(arguments[1]).update(arguments[0]).digest();
+		if (!(this instanceof XXH)) return new XXH(arguments[0]);
+		init.call(this, arguments[0]);
+	}
+	/**
+	* Initialize the XXH instance with the given seed
+	* @method init
+	* @param {Number|Object} seed as a number or an unsigned 32 bits integer
+	* @return ThisExpression
+	*/
+	function init(seed) {
+		this.seed = seed instanceof UINT32 ? seed.clone() : UINT32(seed);
+		this.v1 = this.seed.clone().add(PRIME32_1).add(PRIME32_2);
+		this.v2 = this.seed.clone().add(PRIME32_2);
+		this.v3 = this.seed.clone();
+		this.v4 = this.seed.clone().subtract(PRIME32_1);
+		this.total_len = 0;
+		this.memsize = 0;
+		this.memory = null;
+		return this;
+	}
+	XXH.prototype.init = init;
+	/**
+	* Add data to be computed for the XXH hash
+	* @method update
+	* @param {String|Buffer|ArrayBuffer} input as a string or nodejs Buffer or ArrayBuffer
+	* @return ThisExpression
+	*/
+	XXH.prototype.update = function(input) {
+		var isString = typeof input == "string";
+		var isArrayBuffer;
+		if (isString) {
+			input = toUTF8Array(input);
+			isString = false;
+			isArrayBuffer = true;
+		}
+		if (typeof ArrayBuffer !== "undefined" && input instanceof ArrayBuffer) {
+			isArrayBuffer = true;
+			input = new Uint8Array(input);
+		}
+		var p = 0;
+		var len = input.length;
+		var bEnd = p + len;
+		if (len == 0) return this;
+		this.total_len += len;
+		if (this.memsize == 0) if (isString) this.memory = "";
+		else if (isArrayBuffer) this.memory = new Uint8Array(16);
+		else this.memory = new Buffer(16);
+		if (this.memsize + len < 16) {
+			if (isString) this.memory += input;
+			else if (isArrayBuffer) this.memory.set(input.subarray(0, len), this.memsize);
+			else input.copy(this.memory, this.memsize, 0, len);
+			this.memsize += len;
+			return this;
+		}
+		if (this.memsize > 0) {
+			if (isString) this.memory += input.slice(0, 16 - this.memsize);
+			else if (isArrayBuffer) this.memory.set(input.subarray(0, 16 - this.memsize), this.memsize);
+			else input.copy(this.memory, this.memsize, 0, 16 - this.memsize);
+			var p32 = 0;
+			if (isString) {
+				this.v1.xxh_update(this.memory.charCodeAt(p32 + 1) << 8 | this.memory.charCodeAt(p32), this.memory.charCodeAt(p32 + 3) << 8 | this.memory.charCodeAt(p32 + 2));
+				p32 += 4;
+				this.v2.xxh_update(this.memory.charCodeAt(p32 + 1) << 8 | this.memory.charCodeAt(p32), this.memory.charCodeAt(p32 + 3) << 8 | this.memory.charCodeAt(p32 + 2));
+				p32 += 4;
+				this.v3.xxh_update(this.memory.charCodeAt(p32 + 1) << 8 | this.memory.charCodeAt(p32), this.memory.charCodeAt(p32 + 3) << 8 | this.memory.charCodeAt(p32 + 2));
+				p32 += 4;
+				this.v4.xxh_update(this.memory.charCodeAt(p32 + 1) << 8 | this.memory.charCodeAt(p32), this.memory.charCodeAt(p32 + 3) << 8 | this.memory.charCodeAt(p32 + 2));
+			} else {
+				this.v1.xxh_update(this.memory[p32 + 1] << 8 | this.memory[p32], this.memory[p32 + 3] << 8 | this.memory[p32 + 2]);
+				p32 += 4;
+				this.v2.xxh_update(this.memory[p32 + 1] << 8 | this.memory[p32], this.memory[p32 + 3] << 8 | this.memory[p32 + 2]);
+				p32 += 4;
+				this.v3.xxh_update(this.memory[p32 + 1] << 8 | this.memory[p32], this.memory[p32 + 3] << 8 | this.memory[p32 + 2]);
+				p32 += 4;
+				this.v4.xxh_update(this.memory[p32 + 1] << 8 | this.memory[p32], this.memory[p32 + 3] << 8 | this.memory[p32 + 2]);
+			}
+			p += 16 - this.memsize;
+			this.memsize = 0;
+			if (isString) this.memory = "";
+		}
+		if (p <= bEnd - 16) {
+			var limit = bEnd - 16;
+			do {
+				if (isString) {
+					this.v1.xxh_update(input.charCodeAt(p + 1) << 8 | input.charCodeAt(p), input.charCodeAt(p + 3) << 8 | input.charCodeAt(p + 2));
+					p += 4;
+					this.v2.xxh_update(input.charCodeAt(p + 1) << 8 | input.charCodeAt(p), input.charCodeAt(p + 3) << 8 | input.charCodeAt(p + 2));
+					p += 4;
+					this.v3.xxh_update(input.charCodeAt(p + 1) << 8 | input.charCodeAt(p), input.charCodeAt(p + 3) << 8 | input.charCodeAt(p + 2));
+					p += 4;
+					this.v4.xxh_update(input.charCodeAt(p + 1) << 8 | input.charCodeAt(p), input.charCodeAt(p + 3) << 8 | input.charCodeAt(p + 2));
+				} else {
+					this.v1.xxh_update(input[p + 1] << 8 | input[p], input[p + 3] << 8 | input[p + 2]);
+					p += 4;
+					this.v2.xxh_update(input[p + 1] << 8 | input[p], input[p + 3] << 8 | input[p + 2]);
+					p += 4;
+					this.v3.xxh_update(input[p + 1] << 8 | input[p], input[p + 3] << 8 | input[p + 2]);
+					p += 4;
+					this.v4.xxh_update(input[p + 1] << 8 | input[p], input[p + 3] << 8 | input[p + 2]);
+				}
+				p += 4;
+			} while (p <= limit);
+		}
+		if (p < bEnd) {
+			if (isString) this.memory += input.slice(p);
+			else if (isArrayBuffer) this.memory.set(input.subarray(p, bEnd), this.memsize);
+			else input.copy(this.memory, this.memsize, p, bEnd);
+			this.memsize = bEnd - p;
+		}
+		return this;
+	};
+	/**
+	* Finalize the XXH computation. The XXH instance is ready for reuse for the given seed
+	* @method digest
+	* @return {UINT32} xxHash
+	*/
+	XXH.prototype.digest = function() {
+		var input = this.memory;
+		var isString = typeof input == "string";
+		var p = 0;
+		var bEnd = this.memsize;
+		var h32, h;
+		var u = new UINT32();
+		if (this.total_len >= 16) h32 = this.v1.rotl(1).add(this.v2.rotl(7).add(this.v3.rotl(12).add(this.v4.rotl(18))));
+		else h32 = this.seed.clone().add(PRIME32_5);
+		h32.add(u.fromNumber(this.total_len));
+		while (p <= bEnd - 4) {
+			if (isString) u.fromBits(input.charCodeAt(p + 1) << 8 | input.charCodeAt(p), input.charCodeAt(p + 3) << 8 | input.charCodeAt(p + 2));
+			else u.fromBits(input[p + 1] << 8 | input[p], input[p + 3] << 8 | input[p + 2]);
+			h32.add(u.multiply(PRIME32_3)).rotl(17).multiply(PRIME32_4);
+			p += 4;
+		}
+		while (p < bEnd) {
+			u.fromBits(isString ? input.charCodeAt(p++) : input[p++], 0);
+			h32.add(u.multiply(PRIME32_5)).rotl(11).multiply(PRIME32_1);
+		}
+		h = h32.clone().shiftRight(15);
+		h32.xor(h).multiply(PRIME32_2);
+		h = h32.clone().shiftRight(13);
+		h32.xor(h).multiply(PRIME32_3);
+		h = h32.clone().shiftRight(16);
+		h32.xor(h);
+		this.init(this.seed);
+		return h32;
+	};
+	module.exports = XXH;
+}));
+//#endregion
+//#region node_modules/xxhashjs/lib/xxhash64.js
+var require_xxhash64 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	xxHash64 implementation in pure Javascript
+	
+	Copyright (C) 2016, Pierre Curto
+	MIT license
+	*/
+	var UINT64 = require_cuint().UINT64;
+	var PRIME64_1 = UINT64("11400714785074694791");
+	var PRIME64_2 = UINT64("14029467366897019727");
+	var PRIME64_3 = UINT64("1609587929392839161");
+	var PRIME64_4 = UINT64("9650029242287828579");
+	var PRIME64_5 = UINT64("2870177450012600261");
+	/**
+	* Convert string to proper UTF-8 array
+	* @param str Input string
+	* @returns {Uint8Array} UTF8 array is returned as uint8 array
+	*/
+	function toUTF8Array(str) {
+		var utf8 = [];
+		for (var i = 0, n = str.length; i < n; i++) {
+			var charcode = str.charCodeAt(i);
+			if (charcode < 128) utf8.push(charcode);
+			else if (charcode < 2048) utf8.push(192 | charcode >> 6, 128 | charcode & 63);
+			else if (charcode < 55296 || charcode >= 57344) utf8.push(224 | charcode >> 12, 128 | charcode >> 6 & 63, 128 | charcode & 63);
+			else {
+				i++;
+				charcode = 65536 + ((charcode & 1023) << 10 | str.charCodeAt(i) & 1023);
+				utf8.push(240 | charcode >> 18, 128 | charcode >> 12 & 63, 128 | charcode >> 6 & 63, 128 | charcode & 63);
+			}
+		}
+		return new Uint8Array(utf8);
+	}
+	/**
+	* XXH64 object used as a constructor or a function
+	* @constructor
+	* or
+	* @param {Object|String} input data
+	* @param {Number|UINT64} seed
+	* @return ThisExpression
+	* or
+	* @return {UINT64} xxHash
+	*/
+	function XXH64() {
+		if (arguments.length == 2) return new XXH64(arguments[1]).update(arguments[0]).digest();
+		if (!(this instanceof XXH64)) return new XXH64(arguments[0]);
+		init.call(this, arguments[0]);
+	}
+	/**
+	* Initialize the XXH64 instance with the given seed
+	* @method init
+	* @param {Number|Object} seed as a number or an unsigned 32 bits integer
+	* @return ThisExpression
+	*/
+	function init(seed) {
+		this.seed = seed instanceof UINT64 ? seed.clone() : UINT64(seed);
+		this.v1 = this.seed.clone().add(PRIME64_1).add(PRIME64_2);
+		this.v2 = this.seed.clone().add(PRIME64_2);
+		this.v3 = this.seed.clone();
+		this.v4 = this.seed.clone().subtract(PRIME64_1);
+		this.total_len = 0;
+		this.memsize = 0;
+		this.memory = null;
+		return this;
+	}
+	XXH64.prototype.init = init;
+	/**
+	* Add data to be computed for the XXH64 hash
+	* @method update
+	* @param {String|Buffer|ArrayBuffer} input as a string or nodejs Buffer or ArrayBuffer
+	* @return ThisExpression
+	*/
+	XXH64.prototype.update = function(input) {
+		var isString = typeof input == "string";
+		var isArrayBuffer;
+		if (isString) {
+			input = toUTF8Array(input);
+			isString = false;
+			isArrayBuffer = true;
+		}
+		if (typeof ArrayBuffer !== "undefined" && input instanceof ArrayBuffer) {
+			isArrayBuffer = true;
+			input = new Uint8Array(input);
+		}
+		var p = 0;
+		var len = input.length;
+		var bEnd = p + len;
+		if (len == 0) return this;
+		this.total_len += len;
+		if (this.memsize == 0) if (isString) this.memory = "";
+		else if (isArrayBuffer) this.memory = new Uint8Array(32);
+		else this.memory = new Buffer(32);
+		if (this.memsize + len < 32) {
+			if (isString) this.memory += input;
+			else if (isArrayBuffer) this.memory.set(input.subarray(0, len), this.memsize);
+			else input.copy(this.memory, this.memsize, 0, len);
+			this.memsize += len;
+			return this;
+		}
+		if (this.memsize > 0) {
+			if (isString) this.memory += input.slice(0, 32 - this.memsize);
+			else if (isArrayBuffer) this.memory.set(input.subarray(0, 32 - this.memsize), this.memsize);
+			else input.copy(this.memory, this.memsize, 0, 32 - this.memsize);
+			var p64 = 0;
+			if (isString) {
+				var other = UINT64(this.memory.charCodeAt(p64 + 1) << 8 | this.memory.charCodeAt(p64), this.memory.charCodeAt(p64 + 3) << 8 | this.memory.charCodeAt(p64 + 2), this.memory.charCodeAt(p64 + 5) << 8 | this.memory.charCodeAt(p64 + 4), this.memory.charCodeAt(p64 + 7) << 8 | this.memory.charCodeAt(p64 + 6));
+				this.v1.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+				p64 += 8;
+				other = UINT64(this.memory.charCodeAt(p64 + 1) << 8 | this.memory.charCodeAt(p64), this.memory.charCodeAt(p64 + 3) << 8 | this.memory.charCodeAt(p64 + 2), this.memory.charCodeAt(p64 + 5) << 8 | this.memory.charCodeAt(p64 + 4), this.memory.charCodeAt(p64 + 7) << 8 | this.memory.charCodeAt(p64 + 6));
+				this.v2.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+				p64 += 8;
+				other = UINT64(this.memory.charCodeAt(p64 + 1) << 8 | this.memory.charCodeAt(p64), this.memory.charCodeAt(p64 + 3) << 8 | this.memory.charCodeAt(p64 + 2), this.memory.charCodeAt(p64 + 5) << 8 | this.memory.charCodeAt(p64 + 4), this.memory.charCodeAt(p64 + 7) << 8 | this.memory.charCodeAt(p64 + 6));
+				this.v3.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+				p64 += 8;
+				other = UINT64(this.memory.charCodeAt(p64 + 1) << 8 | this.memory.charCodeAt(p64), this.memory.charCodeAt(p64 + 3) << 8 | this.memory.charCodeAt(p64 + 2), this.memory.charCodeAt(p64 + 5) << 8 | this.memory.charCodeAt(p64 + 4), this.memory.charCodeAt(p64 + 7) << 8 | this.memory.charCodeAt(p64 + 6));
+				this.v4.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+			} else {
+				var other = UINT64(this.memory[p64 + 1] << 8 | this.memory[p64], this.memory[p64 + 3] << 8 | this.memory[p64 + 2], this.memory[p64 + 5] << 8 | this.memory[p64 + 4], this.memory[p64 + 7] << 8 | this.memory[p64 + 6]);
+				this.v1.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+				p64 += 8;
+				other = UINT64(this.memory[p64 + 1] << 8 | this.memory[p64], this.memory[p64 + 3] << 8 | this.memory[p64 + 2], this.memory[p64 + 5] << 8 | this.memory[p64 + 4], this.memory[p64 + 7] << 8 | this.memory[p64 + 6]);
+				this.v2.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+				p64 += 8;
+				other = UINT64(this.memory[p64 + 1] << 8 | this.memory[p64], this.memory[p64 + 3] << 8 | this.memory[p64 + 2], this.memory[p64 + 5] << 8 | this.memory[p64 + 4], this.memory[p64 + 7] << 8 | this.memory[p64 + 6]);
+				this.v3.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+				p64 += 8;
+				other = UINT64(this.memory[p64 + 1] << 8 | this.memory[p64], this.memory[p64 + 3] << 8 | this.memory[p64 + 2], this.memory[p64 + 5] << 8 | this.memory[p64 + 4], this.memory[p64 + 7] << 8 | this.memory[p64 + 6]);
+				this.v4.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+			}
+			p += 32 - this.memsize;
+			this.memsize = 0;
+			if (isString) this.memory = "";
+		}
+		if (p <= bEnd - 32) {
+			var limit = bEnd - 32;
+			do {
+				if (isString) {
+					var other = UINT64(input.charCodeAt(p + 1) << 8 | input.charCodeAt(p), input.charCodeAt(p + 3) << 8 | input.charCodeAt(p + 2), input.charCodeAt(p + 5) << 8 | input.charCodeAt(p + 4), input.charCodeAt(p + 7) << 8 | input.charCodeAt(p + 6));
+					this.v1.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+					p += 8;
+					other = UINT64(input.charCodeAt(p + 1) << 8 | input.charCodeAt(p), input.charCodeAt(p + 3) << 8 | input.charCodeAt(p + 2), input.charCodeAt(p + 5) << 8 | input.charCodeAt(p + 4), input.charCodeAt(p + 7) << 8 | input.charCodeAt(p + 6));
+					this.v2.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+					p += 8;
+					other = UINT64(input.charCodeAt(p + 1) << 8 | input.charCodeAt(p), input.charCodeAt(p + 3) << 8 | input.charCodeAt(p + 2), input.charCodeAt(p + 5) << 8 | input.charCodeAt(p + 4), input.charCodeAt(p + 7) << 8 | input.charCodeAt(p + 6));
+					this.v3.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+					p += 8;
+					other = UINT64(input.charCodeAt(p + 1) << 8 | input.charCodeAt(p), input.charCodeAt(p + 3) << 8 | input.charCodeAt(p + 2), input.charCodeAt(p + 5) << 8 | input.charCodeAt(p + 4), input.charCodeAt(p + 7) << 8 | input.charCodeAt(p + 6));
+					this.v4.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+				} else {
+					var other = UINT64(input[p + 1] << 8 | input[p], input[p + 3] << 8 | input[p + 2], input[p + 5] << 8 | input[p + 4], input[p + 7] << 8 | input[p + 6]);
+					this.v1.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+					p += 8;
+					other = UINT64(input[p + 1] << 8 | input[p], input[p + 3] << 8 | input[p + 2], input[p + 5] << 8 | input[p + 4], input[p + 7] << 8 | input[p + 6]);
+					this.v2.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+					p += 8;
+					other = UINT64(input[p + 1] << 8 | input[p], input[p + 3] << 8 | input[p + 2], input[p + 5] << 8 | input[p + 4], input[p + 7] << 8 | input[p + 6]);
+					this.v3.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+					p += 8;
+					other = UINT64(input[p + 1] << 8 | input[p], input[p + 3] << 8 | input[p + 2], input[p + 5] << 8 | input[p + 4], input[p + 7] << 8 | input[p + 6]);
+					this.v4.add(other.multiply(PRIME64_2)).rotl(31).multiply(PRIME64_1);
+				}
+				p += 8;
+			} while (p <= limit);
+		}
+		if (p < bEnd) {
+			if (isString) this.memory += input.slice(p);
+			else if (isArrayBuffer) this.memory.set(input.subarray(p, bEnd), this.memsize);
+			else input.copy(this.memory, this.memsize, p, bEnd);
+			this.memsize = bEnd - p;
+		}
+		return this;
+	};
+	/**
+	* Finalize the XXH64 computation. The XXH64 instance is ready for reuse for the given seed
+	* @method digest
+	* @return {UINT64} xxHash
+	*/
+	XXH64.prototype.digest = function() {
+		var input = this.memory;
+		var isString = typeof input == "string";
+		var p = 0;
+		var bEnd = this.memsize;
+		var h64, h;
+		var u = new UINT64();
+		if (this.total_len >= 32) {
+			h64 = this.v1.clone().rotl(1);
+			h64.add(this.v2.clone().rotl(7));
+			h64.add(this.v3.clone().rotl(12));
+			h64.add(this.v4.clone().rotl(18));
+			h64.xor(this.v1.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1));
+			h64.multiply(PRIME64_1).add(PRIME64_4);
+			h64.xor(this.v2.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1));
+			h64.multiply(PRIME64_1).add(PRIME64_4);
+			h64.xor(this.v3.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1));
+			h64.multiply(PRIME64_1).add(PRIME64_4);
+			h64.xor(this.v4.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1));
+			h64.multiply(PRIME64_1).add(PRIME64_4);
+		} else h64 = this.seed.clone().add(PRIME64_5);
+		h64.add(u.fromNumber(this.total_len));
+		while (p <= bEnd - 8) {
+			if (isString) u.fromBits(input.charCodeAt(p + 1) << 8 | input.charCodeAt(p), input.charCodeAt(p + 3) << 8 | input.charCodeAt(p + 2), input.charCodeAt(p + 5) << 8 | input.charCodeAt(p + 4), input.charCodeAt(p + 7) << 8 | input.charCodeAt(p + 6));
+			else u.fromBits(input[p + 1] << 8 | input[p], input[p + 3] << 8 | input[p + 2], input[p + 5] << 8 | input[p + 4], input[p + 7] << 8 | input[p + 6]);
+			u.multiply(PRIME64_2).rotl(31).multiply(PRIME64_1);
+			h64.xor(u).rotl(27).multiply(PRIME64_1).add(PRIME64_4);
+			p += 8;
+		}
+		if (p + 4 <= bEnd) {
+			if (isString) u.fromBits(input.charCodeAt(p + 1) << 8 | input.charCodeAt(p), input.charCodeAt(p + 3) << 8 | input.charCodeAt(p + 2), 0, 0);
+			else u.fromBits(input[p + 1] << 8 | input[p], input[p + 3] << 8 | input[p + 2], 0, 0);
+			h64.xor(u.multiply(PRIME64_1)).rotl(23).multiply(PRIME64_2).add(PRIME64_3);
+			p += 4;
+		}
+		while (p < bEnd) {
+			u.fromBits(isString ? input.charCodeAt(p++) : input[p++], 0, 0, 0);
+			h64.xor(u.multiply(PRIME64_5)).rotl(11).multiply(PRIME64_1);
+		}
+		h = h64.clone().shiftRight(33);
+		h64.xor(h).multiply(PRIME64_2);
+		h = h64.clone().shiftRight(29);
+		h64.xor(h).multiply(PRIME64_3);
+		h = h64.clone().shiftRight(32);
+		h64.xor(h);
+		this.init(this.seed);
+		return h64;
+	};
+	module.exports = XXH64;
+}));
+//#endregion
 //#region src/fhir-utils/fhirHashUtils.ts
+var import_lib = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		h32: require_xxhash(),
+		h64: require_xxhash64()
+	};
+})))(), 1);
 /**
 * Normalize string values similar to HAPI FHIR (trim, collapse whitespace, lowercase)
 */
 function normalizeStringParam(input) {
 	return input.trim().replace(/\s+/g, " ").toLowerCase();
 }
+function xxhash64Signed(input) {
+	const hashHex = import_lib.default.h64(input, 43981).toString(16).padStart(16, "0");
+	return Buffer.from(hashHex, "hex").readBigInt64BE(0);
+}
 /**
 * Converts first 64 bits of MurmurHash3_x64_128 result into signed BigInt
 */
-function murmur64Signed(input) {
-	const hex128 = murmurhash3js.x64.hash128(input);
-	return Buffer.from(hex128.slice(0, 16), "hex").readBigInt64LE(0);
-}
 /**
 * Compute hash for a normalized string search parameter
 */
 function hashStringParam(input, normalize) {
-	if (normalize === true) return murmur64Signed(normalizeStringParam(input));
-	else return murmur64Signed(input);
+	if (normalize === true) return xxhash64Signed(normalizeStringParam(input));
+	else return xxhash64Signed(input);
 }
 /**
 * Compute hash for a token search parameter (system|code)
 */
 function hashTokenParam({ system, code }) {
-	return murmur64Signed((system ?? "") + "|" + code);
+	return xxhash64Signed((system ?? "") + "|" + code);
 }
 /**
 * Compute hash for a reference search parameter
 * Case-sensitive and used as-is
 */
 function hashReferenceParam(reference) {
-	return murmur64Signed(reference);
+	return xxhash64Signed(reference);
 }
 /**
 * Compute hash for a URI parameter (optionally lowercased)
 */
 function hashUriParam(uri, lowercase = false) {
-	return murmur64Signed(lowercase ? uri.toLowerCase() : uri);
+	return xxhash64Signed(lowercase ? uri.toLowerCase() : uri);
 }
 //#endregion
 //#region src/redisDistributedLock.ts
@@ -3251,7 +4544,7 @@ exports.hashReferenceParam = hashReferenceParam;
 exports.hashStringParam = hashStringParam;
 exports.hashTokenParam = hashTokenParam;
 exports.hashUriParam = hashUriParam;
-exports.murmur64Signed = murmur64Signed;
 exports.normalizeStringParam = normalizeStringParam;
+exports.xxhash64Signed = xxhash64Signed;
 
 //# sourceMappingURL=index.cjs.map