@nsshunt/stsfhirpg 1.2.22 → 1.2.24

package/dist/index.mjs

@@ -13,27 +13,7 @@ import cluster from "cluster";
 import { Pool } from "pg";
 import { TinyEmitter } from "tiny-emitter";
 //#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-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];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
 //#endregion
 //#region src/fhir-utils/fhirDateUtils.ts
 var FHIRDateUtils = class {
@@ -92,1309 +72,3218 @@ 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;
+//#region node_modules/xxhash-wasm/esm/xxhash-wasm.js
+var t = new Uint8Array([
+	0,
+	97,
+	115,
+	109,
+	1,
+	0,
+	0,
+	0,
+	1,
+	48,
+	8,
+	96,
+	3,
+	127,
+	127,
+	127,
+	1,
+	127,
+	96,
+	3,
+	127,
+	127,
+	127,
+	0,
+	96,
+	2,
+	127,
+	127,
+	0,
+	96,
+	1,
+	127,
+	1,
+	127,
+	96,
+	3,
+	127,
+	127,
+	126,
+	1,
+	126,
+	96,
+	3,
+	126,
+	127,
+	127,
+	1,
+	126,
+	96,
+	2,
+	127,
+	126,
+	0,
+	96,
+	1,
+	127,
+	1,
+	126,
+	3,
+	11,
+	10,
+	0,
+	0,
+	2,
+	1,
+	3,
+	4,
+	5,
+	6,
+	1,
+	7,
+	5,
+	3,
+	1,
+	0,
+	1,
+	7,
+	85,
+	9,
+	3,
+	109,
+	101,
+	109,
+	2,
+	0,
+	5,
+	120,
+	120,
+	104,
+	51,
+	50,
+	0,
+	0,
+	6,
+	105,
+	110,
+	105,
+	116,
+	51,
+	50,
+	0,
+	2,
+	8,
+	117,
+	112,
+	100,
+	97,
+	116,
+	101,
+	51,
+	50,
+	0,
+	3,
+	8,
+	100,
+	105,
+	103,
+	101,
+	115,
+	116,
+	51,
+	50,
+	0,
+	4,
+	5,
+	120,
+	120,
+	104,
+	54,
+	52,
+	0,
+	5,
+	6,
+	105,
+	110,
+	105,
+	116,
+	54,
+	52,
+	0,
+	7,
+	8,
+	117,
+	112,
+	100,
+	97,
+	116,
+	101,
+	54,
+	52,
+	0,
+	8,
+	8,
+	100,
+	105,
+	103,
+	101,
+	115,
+	116,
+	54,
+	52,
+	0,
+	9,
+	10,
+	251,
+	22,
+	10,
+	242,
+	1,
+	1,
+	4,
+	127,
+	32,
+	0,
+	32,
+	1,
+	106,
+	33,
+	3,
+	32,
+	1,
+	65,
+	16,
+	79,
+	4,
+	127,
+	32,
+	3,
+	65,
+	16,
+	107,
+	33,
+	6,
+	32,
+	2,
+	65,
+	168,
+	136,
+	141,
+	161,
+	2,
+	106,
+	33,
+	3,
+	32,
+	2,
+	65,
+	137,
+	235,
+	208,
+	208,
+	7,
+	107,
+	33,
+	4,
+	32,
+	2,
+	65,
+	207,
+	140,
+	162,
+	142,
+	6,
+	106,
+	33,
+	5,
+	3,
+	64,
+	32,
+	3,
+	32,
+	0,
+	40,
+	2,
+	0,
+	65,
+	247,
+	148,
+	175,
+	175,
+	120,
+	108,
+	106,
+	65,
+	13,
+	119,
+	65,
+	177,
+	243,
+	221,
+	241,
+	121,
+	108,
+	33,
+	3,
+	32,
+	4,
+	32,
+	0,
+	65,
+	4,
+	106,
+	34,
+	0,
+	40,
+	2,
+	0,
+	65,
+	247,
+	148,
+	175,
+	175,
+	120,
+	108,
+	106,
+	65,
+	13,
+	119,
+	65,
+	177,
+	243,
+	221,
+	241,
+	121,
+	108,
+	33,
+	4,
+	32,
+	2,
+	32,
+	0,
+	65,
+	4,
+	106,
+	34,
+	0,
+	40,
+	2,
+	0,
+	65,
+	247,
+	148,
+	175,
+	175,
+	120,
+	108,
+	106,
+	65,
+	13,
+	119,
+	65,
+	177,
+	243,
+	221,
+	241,
+	121,
+	108,
+	33,
+	2,
+	32,
+	5,
+	32,
+	0,
+	65,
+	4,
+	106,
+	34,
+	0,
+	40,
+	2,
+	0,
+	65,
+	247,
+	148,
+	175,
+	175,
+	120,
+	108,
+	106,
+	65,
+	13,
+	119,
+	65,
+	177,
+	243,
+	221,
+	241,
+	121,
+	108,
+	33,
+	5,
+	32,
+	6,
+	32,
+	0,
+	65,
+	4,
+	106,
+	34,
+	0,
+	79,
+	13,
+	0,
+	11,
+	32,
+	2,
+	65,
+	12,
+	119,
+	32,
+	5,
+	65,
+	18,
+	119,
+	106,
+	32,
+	4,
+	65,
+	7,
+	119,
+	106,
+	32,
+	3,
+	65,
+	1,
+	119,
+	106,
+	5,
+	32,
+	2,
+	65,
+	177,
+	207,
+	217,
+	178,
+	1,
+	106,
+	11,
+	32,
+	1,
+	106,
+	32,
+	0,
+	32,
+	1,
+	65,
+	15,
+	113,
+	16,
+	1,
+	11,
+	146,
+	1,
+	0,
+	32,
+	1,
+	32,
+	2,
+	106,
+	33,
+	2,
+	3,
+	64,
+	32,
+	1,
+	65,
+	4,
+	106,
+	32,
+	2,
+	75,
+	69,
+	4,
+	64,
+	32,
+	0,
+	32,
+	1,
+	40,
+	2,
+	0,
+	65,
+	189,
+	220,
+	202,
+	149,
+	124,
+	108,
+	106,
+	65,
+	17,
+	119,
+	65,
+	175,
+	214,
+	211,
+	190,
+	2,
+	108,
+	33,
+	0,
+	32,
+	1,
+	65,
+	4,
+	106,
+	33,
+	1,
+	12,
+	1,
+	11,
+	11,
+	3,
+	64,
+	32,
+	1,
+	32,
+	2,
+	79,
+	69,
+	4,
+	64,
+	32,
+	0,
+	32,
+	1,
+	45,
+	0,
+	0,
+	65,
+	177,
+	207,
+	217,
+	178,
+	1,
+	108,
+	106,
+	65,
+	11,
+	119,
+	65,
+	177,
+	243,
+	221,
+	241,
+	121,
+	108,
+	33,
+	0,
+	32,
+	1,
+	65,
+	1,
+	106,
+	33,
+	1,
+	12,
+	1,
+	11,
+	11,
+	32,
+	0,
+	32,
+	0,
+	65,
+	15,
+	118,
+	115,
+	65,
+	247,
+	148,
+	175,
+	175,
+	120,
+	108,
+	34,
+	0,
+	65,
+	13,
+	118,
+	32,
+	0,
+	115,
+	65,
+	189,
+	220,
+	202,
+	149,
+	124,
+	108,
+	34,
+	0,
+	65,
+	16,
+	118,
+	32,
+	0,
+	115,
+	11,
+	63,
+	0,
+	32,
+	0,
+	65,
+	8,
+	106,
+	32,
+	1,
+	65,
+	168,
+	136,
+	141,
+	161,
+	2,
+	106,
+	54,
+	2,
+	0,
+	32,
+	0,
+	65,
+	12,
+	106,
+	32,
+	1,
+	65,
+	137,
+	235,
+	208,
+	208,
+	7,
+	107,
+	54,
+	2,
+	0,
+	32,
+	0,
+	65,
+	16,
+	106,
+	32,
+	1,
+	54,
+	2,
+	0,
+	32,
+	0,
+	65,
+	20,
+	106,
+	32,
+	1,
+	65,
+	207,
+	140,
+	162,
+	142,
+	6,
+	106,
+	54,
+	2,
+	0,
+	11,
+	195,
+	4,
+	1,
+	6,
+	127,
+	32,
+	1,
+	32,
+	2,
+	106,
+	33,
+	6,
+	32,
+	0,
+	65,
+	24,
+	106,
+	33,
+	4,
+	32,
+	0,
+	65,
+	40,
+	106,
+	40,
+	2,
+	0,
+	33,
+	3,
+	32,
+	0,
+	32,
+	0,
+	40,
+	2,
+	0,
+	32,
+	2,
+	106,
+	54,
+	2,
+	0,
+	32,
+	0,
+	65,
+	4,
+	106,
+	34,
+	5,
+	32,
+	5,
+	40,
+	2,
+	0,
+	32,
+	2,
+	65,
+	16,
+	79,
+	32,
+	0,
+	40,
+	2,
+	0,
+	65,
+	16,
+	79,
+	114,
+	114,
+	54,
+	2,
+	0,
+	32,
+	2,
+	32,
+	3,
+	106,
+	65,
+	16,
+	73,
+	4,
+	64,
+	32,
+	3,
+	32,
+	4,
+	106,
+	32,
+	1,
+	32,
+	2,
+	252,
+	10,
+	0,
+	0,
+	32,
+	0,
+	65,
+	40,
+	106,
+	32,
+	2,
+	32,
+	3,
+	106,
+	54,
+	2,
+	0,
+	15,
+	11,
+	32,
+	3,
+	4,
+	64,
+	32,
+	3,
+	32,
+	4,
+	106,
+	32,
+	1,
+	65,
+	16,
+	32,
+	3,
+	107,
+	34,
+	2,
+	252,
+	10,
+	0,
+	0,
+	32,
+	0,
+	65,
+	8,
+	106,
+	34,
+	3,
+	32,
+	3,
+	40,
+	2,
+	0,
+	32,
+	4,
+	40,
+	2,
+	0,
+	65,
+	247,
+	148,
+	175,
+	175,
+	120,
+	108,
+	106,
+	65,
+	13,
+	119,
+	65,
+	177,
+	243,
+	221,
+	241,
+	121,
+	108,
+	54,
+	2,
+	0,
+	32,
+	0,
+	65,
+	12,
+	106,
+	34,
+	3,
+	32,
+	3,
+	40,
+	2,
+	0,
+	32,
+	4,
+	65,
+	4,
+	106,
+	40,
+	2,
+	0,
+	65,
+	247,
+	148,
+	175,
+	175,
+	120,
+	108,
+	106,
+	65,
+	13,
+	119,
+	65,
+	177,
+	243,
+	221,
+	241,
+	121,
+	108,
+	54,
+	2,
+	0,
+	32,
+	0,
+	65,
+	16,
+	106,
+	34,
+	3,
+	32,
+	3,
+	40,
+	2,
+	0,
+	32,
+	4,
+	65,
+	8,
+	106,
+	40,
+	2,
+	0,
+	65,
+	247,
+	148,
+	175,
+	175,
+	120,
+	108,
+	106,
+	65,
+	13,
+	119,
+	65,
+	177,
+	243,
+	221,
+	241,
+	121,
+	108,
+	54,
+	2,
+	0,
+	32,
+	0,
+	65,
+	20,
+	106,
+	34,
+	3,
+	32,
+	3,
+	40,
+	2,
+	0,
+	32,
+	4,
+	65,
+	12,
+	106,
+	40,
+	2,
+	0,
+	65,
+	247,
+	148,
+	175,
+	175,
+	120,
+	108,
+	106,
+	65,
+	13,
+	119,
+	65,
+	177,
+	243,
+	221,
+	241,
+	121,
+	108,
+	54,
+	2,
+	0,
+	32,
+	0,
+	65,
+	40,
+	106,
+	65,
+	0,
+	54,
+	2,
+	0,
+	32,
+	1,
+	32,
+	2,
+	106,
+	33,
+	1,
+	11,
+	32,
+	1,
+	32,
+	6,
+	65,
+	16,
+	107,
+	77,
+	4,
+	64,
+	32,
+	6,
+	65,
+	16,
+	107,
+	33,
+	8,
+	32,
+	0,
+	65,
+	8,
+	106,
+	40,
+	2,
+	0,
+	33,
+	2,
+	32,
+	0,
+	65,
+	12,
+	106,
+	40,
+	2,
+	0,
+	33,
+	3,
+	32,
+	0,
+	65,
+	16,
+	106,
+	40,
+	2,
+	0,
+	33,
+	5,
+	32,
+	0,
+	65,
+	20,
+	106,
+	40,
+	2,
+	0,
+	33,
+	7,
+	3,
+	64,
+	32,
+	2,
+	32,
+	1,
+	40,
+	2,
+	0,
+	65,
+	247,
+	148,
+	175,
+	175,
+	120,
+	108,
+	106,
+	65,
+	13,
+	119,
+	65,
+	177,
+	243,
+	221,
+	241,
+	121,
+	108,
+	33,
+	2,
+	32,
+	3,
+	32,
+	1,
+	65,
+	4,
+	106,
+	34,
+	1,
+	40,
+	2,
+	0,
+	65,
+	247,
+	148,
+	175,
+	175,
+	120,
+	108,
+	106,
+	65,
+	13,
+	119,
+	65,
+	177,
+	243,
+	221,
+	241,
+	121,
+	108,
+	33,
+	3,
+	32,
+	5,
+	32,
+	1,
+	65,
+	4,
+	106,
+	34,
+	1,
+	40,
+	2,
+	0,
+	65,
+	247,
+	148,
+	175,
+	175,
+	120,
+	108,
+	106,
+	65,
+	13,
+	119,
+	65,
+	177,
+	243,
+	221,
+	241,
+	121,
+	108,
+	33,
+	5,
+	32,
+	7,
+	32,
+	1,
+	65,
+	4,
+	106,
+	34,
+	1,
+	40,
+	2,
+	0,
+	65,
+	247,
+	148,
+	175,
+	175,
+	120,
+	108,
+	106,
+	65,
+	13,
+	119,
+	65,
+	177,
+	243,
+	221,
+	241,
+	121,
+	108,
+	33,
+	7,
+	32,
+	8,
+	32,
+	1,
+	65,
+	4,
+	106,
+	34,
+	1,
+	79,
+	13,
+	0,
+	11,
+	32,
+	0,
+	65,
+	8,
+	106,
+	32,
+	2,
+	54,
+	2,
+	0,
+	32,
+	0,
+	65,
+	12,
+	106,
+	32,
+	3,
+	54,
+	2,
+	0,
+	32,
+	0,
+	65,
+	16,
+	106,
+	32,
+	5,
+	54,
+	2,
+	0,
+	32,
+	0,
+	65,
+	20,
+	106,
+	32,
+	7,
+	54,
+	2,
+	0,
+	11,
+	32,
+	1,
+	32,
+	6,
+	73,
+	4,
+	64,
+	32,
+	4,
+	32,
+	1,
+	32,
+	6,
+	32,
+	1,
+	107,
+	34,
+	1,
+	252,
+	10,
+	0,
+	0,
+	32,
+	0,
+	65,
+	40,
+	106,
+	32,
+	1,
+	54,
+	2,
+	0,
+	11,
+	11,
+	97,
+	1,
+	1,
+	127,
+	32,
+	0,
+	65,
+	16,
+	106,
+	40,
+	2,
+	0,
+	33,
+	1,
+	32,
+	0,
+	65,
+	4,
+	106,
+	40,
+	2,
+	0,
+	4,
+	127,
+	32,
+	1,
+	65,
+	12,
+	119,
+	32,
+	0,
+	65,
+	20,
+	106,
+	40,
+	2,
+	0,
+	65,
+	18,
+	119,
+	106,
+	32,
+	0,
+	65,
+	12,
+	106,
+	40,
+	2,
+	0,
+	65,
+	7,
+	119,
+	106,
+	32,
+	0,
+	65,
+	8,
+	106,
+	40,
+	2,
+	0,
+	65,
+	1,
+	119,
+	106,
+	5,
+	32,
+	1,
+	65,
+	177,
+	207,
+	217,
+	178,
+	1,
+	106,
+	11,
+	32,
+	0,
+	40,
+	2,
+	0,
+	106,
+	32,
+	0,
+	65,
+	24,
+	106,
+	32,
+	0,
+	65,
+	40,
+	106,
+	40,
+	2,
+	0,
+	16,
+	1,
+	11,
+	255,
+	3,
+	2,
+	3,
+	126,
+	1,
+	127,
+	32,
+	0,
+	32,
+	1,
+	106,
+	33,
+	6,
+	32,
+	1,
+	65,
+	32,
+	79,
+	4,
+	126,
+	32,
+	6,
+	65,
+	32,
+	107,
+	33,
+	6,
+	32,
+	2,
+	66,
+	214,
+	235,
+	130,
+	238,
+	234,
+	253,
+	137,
+	245,
+	224,
+	0,
+	124,
+	33,
+	3,
+	32,
+	2,
+	66,
+	177,
+	169,
+	172,
+	193,
+	173,
+	184,
+	212,
+	166,
+	61,
+	125,
+	33,
+	4,
+	32,
+	2,
+	66,
+	249,
+	234,
+	208,
+	208,
+	231,
+	201,
+	161,
+	228,
+	225,
+	0,
+	124,
+	33,
+	5,
+	3,
+	64,
+	32,
+	3,
+	32,
+	0,
+	41,
+	3,
+	0,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	124,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	33,
+	3,
+	32,
+	4,
+	32,
+	0,
+	65,
+	8,
+	106,
+	34,
+	0,
+	41,
+	3,
+	0,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	124,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	33,
+	4,
+	32,
+	2,
+	32,
+	0,
+	65,
+	8,
+	106,
+	34,
+	0,
+	41,
+	3,
+	0,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	124,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	33,
+	2,
+	32,
+	5,
+	32,
+	0,
+	65,
+	8,
+	106,
+	34,
+	0,
+	41,
+	3,
+	0,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	124,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	33,
+	5,
+	32,
+	6,
+	32,
+	0,
+	65,
+	8,
+	106,
+	34,
+	0,
+	79,
+	13,
+	0,
+	11,
+	32,
+	2,
+	66,
+	12,
+	137,
+	32,
+	5,
+	66,
+	18,
+	137,
+	124,
+	32,
+	4,
+	66,
+	7,
+	137,
+	124,
+	32,
+	3,
+	66,
+	1,
+	137,
+	124,
+	32,
+	3,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	133,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	66,
+	157,
+	163,
+	181,
+	234,
+	131,
+	177,
+	141,
+	138,
+	250,
+	0,
+	125,
+	32,
+	4,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	133,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	66,
+	157,
+	163,
+	181,
+	234,
+	131,
+	177,
+	141,
+	138,
+	250,
+	0,
+	125,
+	32,
+	2,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	133,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	66,
+	157,
+	163,
+	181,
+	234,
+	131,
+	177,
+	141,
+	138,
+	250,
+	0,
+	125,
+	32,
+	5,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	133,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	66,
+	157,
+	163,
+	181,
+	234,
+	131,
+	177,
+	141,
+	138,
+	250,
+	0,
+	125,
+	5,
+	32,
+	2,
+	66,
+	197,
+	207,
+	217,
+	178,
+	241,
+	229,
+	186,
+	234,
+	39,
+	124,
+	11,
+	32,
+	1,
+	173,
+	124,
+	32,
+	0,
+	32,
+	1,
+	65,
+	31,
+	113,
+	16,
+	6,
+	11,
+	134,
+	2,
+	0,
+	32,
+	1,
+	32,
+	2,
+	106,
+	33,
+	2,
+	3,
+	64,
+	32,
+	2,
+	32,
+	1,
+	65,
+	8,
+	106,
+	79,
+	4,
+	64,
+	32,
+	1,
+	41,
+	3,
+	0,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	32,
+	0,
+	133,
+	66,
+	27,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	66,
+	157,
+	163,
+	181,
+	234,
+	131,
+	177,
+	141,
+	138,
+	250,
+	0,
+	125,
+	33,
+	0,
+	32,
+	1,
+	65,
+	8,
+	106,
+	33,
+	1,
+	12,
+	1,
+	11,
+	11,
+	32,
+	1,
+	65,
+	4,
+	106,
+	32,
+	2,
+	77,
+	4,
+	64,
+	32,
+	0,
+	32,
+	1,
+	53,
+	2,
+	0,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	133,
+	66,
+	23,
+	137,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	66,
+	249,
+	243,
+	221,
+	241,
+	153,
+	246,
+	153,
+	171,
+	22,
+	124,
+	33,
+	0,
+	32,
+	1,
+	65,
+	4,
+	106,
+	33,
+	1,
+	11,
+	3,
+	64,
+	32,
+	1,
+	32,
+	2,
+	73,
+	4,
+	64,
+	32,
+	0,
+	32,
+	1,
+	49,
+	0,
+	0,
+	66,
+	197,
+	207,
+	217,
+	178,
+	241,
+	229,
+	186,
+	234,
+	39,
+	126,
+	133,
+	66,
+	11,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	33,
+	0,
+	32,
+	1,
+	65,
+	1,
+	106,
+	33,
+	1,
+	12,
+	1,
+	11,
+	11,
+	32,
+	0,
+	32,
+	0,
+	66,
+	33,
+	136,
+	133,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	34,
+	0,
+	32,
+	0,
+	66,
+	29,
+	136,
+	133,
+	66,
+	249,
+	243,
+	221,
+	241,
+	153,
+	246,
+	153,
+	171,
+	22,
+	126,
+	34,
+	0,
+	32,
+	0,
+	66,
+	32,
+	136,
+	133,
+	11,
+	77,
+	0,
+	32,
+	0,
+	65,
+	8,
+	106,
+	32,
+	1,
+	66,
+	214,
+	235,
+	130,
+	238,
+	234,
+	253,
+	137,
+	245,
+	224,
+	0,
+	124,
+	55,
+	3,
+	0,
+	32,
+	0,
+	65,
+	16,
+	106,
+	32,
+	1,
+	66,
+	177,
+	169,
+	172,
+	193,
+	173,
+	184,
+	212,
+	166,
+	61,
+	125,
+	55,
+	3,
+	0,
+	32,
+	0,
+	65,
+	24,
+	106,
+	32,
+	1,
+	55,
+	3,
+	0,
+	32,
+	0,
+	65,
+	32,
+	106,
+	32,
+	1,
+	66,
+	249,
+	234,
+	208,
+	208,
+	231,
+	201,
+	161,
+	228,
+	225,
+	0,
+	124,
+	55,
+	3,
+	0,
+	11,
+	244,
+	4,
+	2,
+	3,
+	127,
+	4,
+	126,
+	32,
+	1,
+	32,
+	2,
+	106,
+	33,
+	5,
+	32,
+	0,
+	65,
+	40,
+	106,
+	33,
+	4,
+	32,
+	0,
+	65,
+	200,
+	0,
+	106,
+	40,
+	2,
+	0,
+	33,
+	3,
+	32,
+	0,
+	32,
+	0,
+	41,
+	3,
+	0,
+	32,
+	2,
+	173,
+	124,
+	55,
+	3,
+	0,
+	32,
+	2,
+	32,
+	3,
+	106,
+	65,
+	32,
+	73,
+	4,
+	64,
+	32,
+	3,
+	32,
+	4,
+	106,
+	32,
+	1,
+	32,
+	2,
+	252,
+	10,
+	0,
+	0,
+	32,
+	0,
+	65,
+	200,
+	0,
+	106,
+	32,
+	2,
+	32,
+	3,
+	106,
+	54,
+	2,
+	0,
+	15,
+	11,
+	32,
+	3,
+	4,
+	64,
+	32,
+	3,
+	32,
+	4,
+	106,
+	32,
+	1,
+	65,
+	32,
+	32,
+	3,
+	107,
+	34,
+	2,
+	252,
+	10,
+	0,
+	0,
+	32,
+	0,
+	65,
+	8,
+	106,
+	34,
+	3,
+	32,
+	3,
+	41,
+	3,
+	0,
+	32,
+	4,
+	41,
+	3,
+	0,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	124,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	55,
+	3,
+	0,
+	32,
+	0,
+	65,
+	16,
+	106,
+	34,
+	3,
+	32,
+	3,
+	41,
+	3,
+	0,
+	32,
+	4,
+	65,
+	8,
+	106,
+	41,
+	3,
+	0,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	124,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	55,
+	3,
+	0,
+	32,
+	0,
+	65,
+	24,
+	106,
+	34,
+	3,
+	32,
+	3,
+	41,
+	3,
+	0,
+	32,
+	4,
+	65,
+	16,
+	106,
+	41,
+	3,
+	0,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	124,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	55,
+	3,
+	0,
+	32,
+	0,
+	65,
+	32,
+	106,
+	34,
+	3,
+	32,
+	3,
+	41,
+	3,
+	0,
+	32,
+	4,
+	65,
+	24,
+	106,
+	41,
+	3,
+	0,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	124,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	55,
+	3,
+	0,
+	32,
+	0,
+	65,
+	200,
+	0,
+	106,
+	65,
+	0,
+	54,
+	2,
+	0,
+	32,
+	1,
+	32,
+	2,
+	106,
+	33,
+	1,
+	11,
+	32,
+	1,
+	65,
+	32,
+	106,
+	32,
+	5,
+	77,
+	4,
+	64,
+	32,
+	5,
+	65,
+	32,
+	107,
+	33,
+	2,
+	32,
+	0,
+	65,
+	8,
+	106,
+	41,
+	3,
+	0,
+	33,
+	6,
+	32,
+	0,
+	65,
+	16,
+	106,
+	41,
+	3,
+	0,
+	33,
+	7,
+	32,
+	0,
+	65,
+	24,
+	106,
+	41,
+	3,
+	0,
+	33,
+	8,
+	32,
+	0,
+	65,
+	32,
+	106,
+	41,
+	3,
+	0,
+	33,
+	9,
+	3,
+	64,
+	32,
+	6,
+	32,
+	1,
+	41,
+	3,
+	0,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	124,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	33,
+	6,
+	32,
+	7,
+	32,
+	1,
+	65,
+	8,
+	106,
+	34,
+	1,
+	41,
+	3,
+	0,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	124,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	33,
+	7,
+	32,
+	8,
+	32,
+	1,
+	65,
+	8,
+	106,
+	34,
+	1,
+	41,
+	3,
+	0,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	124,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	33,
+	8,
+	32,
+	9,
+	32,
+	1,
+	65,
+	8,
+	106,
+	34,
+	1,
+	41,
+	3,
+	0,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	124,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	33,
+	9,
+	32,
+	2,
+	32,
+	1,
+	65,
+	8,
+	106,
+	34,
+	1,
+	79,
+	13,
+	0,
+	11,
+	32,
+	0,
+	65,
+	8,
+	106,
+	32,
+	6,
+	55,
+	3,
+	0,
+	32,
+	0,
+	65,
+	16,
+	106,
+	32,
+	7,
+	55,
+	3,
+	0,
+	32,
+	0,
+	65,
+	24,
+	106,
+	32,
+	8,
+	55,
+	3,
+	0,
+	32,
+	0,
+	65,
+	32,
+	106,
+	32,
+	9,
+	55,
+	3,
+	0,
+	11,
+	32,
+	1,
+	32,
+	5,
+	73,
+	4,
+	64,
+	32,
+	4,
+	32,
+	1,
+	32,
+	5,
+	32,
+	1,
+	107,
+	34,
+	1,
+	252,
+	10,
+	0,
+	0,
+	32,
+	0,
+	65,
+	200,
+	0,
+	106,
+	32,
+	1,
+	54,
+	2,
+	0,
+	11,
+	11,
+	188,
+	2,
+	1,
+	5,
+	126,
+	32,
+	0,
+	65,
+	24,
+	106,
+	41,
+	3,
+	0,
+	33,
+	1,
+	32,
+	0,
+	41,
+	3,
+	0,
+	34,
+	2,
+	66,
+	32,
+	90,
+	4,
+	126,
+	32,
+	0,
+	65,
+	8,
+	106,
+	41,
+	3,
+	0,
+	34,
+	3,
+	66,
+	1,
+	137,
+	32,
+	0,
+	65,
+	16,
+	106,
+	41,
+	3,
+	0,
+	34,
+	4,
+	66,
+	7,
+	137,
+	124,
+	32,
+	1,
+	66,
+	12,
+	137,
+	32,
+	0,
+	65,
+	32,
+	106,
+	41,
+	3,
+	0,
+	34,
+	5,
+	66,
+	18,
+	137,
+	124,
+	124,
+	32,
+	3,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	133,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	66,
+	157,
+	163,
+	181,
+	234,
+	131,
+	177,
+	141,
+	138,
+	250,
+	0,
+	125,
+	32,
+	4,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	133,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	66,
+	157,
+	163,
+	181,
+	234,
+	131,
+	177,
+	141,
+	138,
+	250,
+	0,
+	125,
+	32,
+	1,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	133,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	66,
+	157,
+	163,
+	181,
+	234,
+	131,
+	177,
+	141,
+	138,
+	250,
+	0,
+	125,
+	32,
+	5,
+	66,
+	207,
+	214,
+	211,
+	190,
+	210,
+	199,
+	171,
+	217,
+	66,
+	126,
+	66,
+	31,
+	137,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	133,
+	66,
+	135,
+	149,
+	175,
+	175,
+	152,
+	182,
+	222,
+	155,
+	158,
+	127,
+	126,
+	66,
+	157,
+	163,
+	181,
+	234,
+	131,
+	177,
+	141,
+	138,
+	250,
+	0,
+	125,
+	5,
+	32,
+	1,
+	66,
+	197,
+	207,
+	217,
+	178,
+	241,
+	229,
+	186,
+	234,
+	39,
+	124,
+	11,
+	32,
+	2,
+	124,
+	32,
+	0,
+	65,
+	40,
+	106,
+	32,
+	2,
+	66,
+	31,
+	131,
+	167,
+	16,
+	6,
+	11
+]);
+async function e() {
+	return function(t) {
+		const { exports: { mem: e, xxh32: n, xxh64: r, init32: i, update32: a, digest32: o, init64: s, update64: u, digest64: c } } = t;
+		let h = new Uint8Array(e.buffer);
+		function g(t, n) {
+			if (e.buffer.byteLength < t + n) {
+				const r = Math.ceil((t + n - e.buffer.byteLength) / 65536);
+				e.grow(r), h = new Uint8Array(e.buffer);
 			}
-			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 = "";
+		function f(t, e, n, r, i, a) {
+			g(t);
+			const o = new Uint8Array(t);
+			return h.set(o), n(0, e), o.set(h.subarray(0, t)), {
+				update(e) {
+					let n;
+					return h.set(o), "string" == typeof e ? (g(3 * e.length, t), n = w.encodeInto(e, h.subarray(t)).written) : (g(e.byteLength, t), h.set(e, t), n = e.byteLength), r(0, t, n), o.set(h.subarray(0, t)), this;
+				},
+				digest: () => (h.set(o), a(i(0)))
+			};
 		}
-		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);
+		function y(t) {
+			return t >>> 0;
 		}
-		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;
+		const b = 2n ** 64n - 1n;
+		function d(t) {
+			return t & b;
 		}
-		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;
+		const w = new TextEncoder(), l = 0, p = 0n;
+		function x(t, e = l) {
+			return g(3 * t.length, 0), y(n(0, w.encodeInto(t, h).written, e));
 		}
-		while (p < bEnd) {
-			u.fromBits(isString ? input.charCodeAt(p++) : input[p++], 0);
-			h32.add(u.multiply(PRIME32_5)).rotl(11).multiply(PRIME32_1);
+		function L(t, e = p) {
+			return g(3 * t.length, 0), d(r(0, w.encodeInto(t, h).written, e));
 		}
-		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;
-}));
+		return {
+			h32: x,
+			h32ToString: (t, e = l) => x(t, e).toString(16).padStart(8, "0"),
+			h32Raw: (t, e = l) => (g(t.byteLength, 0), h.set(t), y(n(0, t.byteLength, e))),
+			create32: (t = l) => f(48, t, i, a, o, y),
+			h64: L,
+			h64ToString: (t, e = p) => L(t, e).toString(16).padStart(16, "0"),
+			h64Raw: (t, e = p) => (g(t.byteLength, 0), h.set(t), d(r(0, t.byteLength, e))),
+			create64: (t = p) => f(88, t, s, u, c, d)
+		};
+	}((await WebAssembly.instantiate(t)).instance);
+}
 //#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;
+//#region src/fhir-utils/hashUtils.ts
+var import___vite_browser_external = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {};
+})))();
+var HashUtils = class HashUtils {
+	static instance;
+	HASH_SEED = 43981n;
+	h64;
+	static getInstance() {
+		if (!HashUtils.instance) HashUtils.instance = new HashUtils();
+		return HashUtils.instance;
+	}
+	constructor() {}
+	normalizeStringParam = (input) => {
+		return input.trim().replace(/\s+/g, " ").toLowerCase();
 	};
-	/**
-	* 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;
+	InitHash = async () => {
+		this.h64 = (await e()).h64;
 	};
-	module.exports = XXH64;
-}));
+	xxhash64Signed(input) {
+		if (this.h64) return BigInt.asIntN(64, this.h64(input, this.HASH_SEED));
+		throw (0, import___vite_browser_external.error)(`h64 not initialized`);
+	}
+	hashStringParam(input, normalize) {
+		if (normalize === true) {
+			const normalized = this.normalizeStringParam(input);
+			return this.xxhash64Signed(normalized);
+		} else return this.xxhash64Signed(input);
+	}
+	hashTokenParam({ system, code }) {
+		const combined = (system ?? "") + "|" + code;
+		return this.xxhash64Signed(combined);
+	}
+	hashReferenceParam(reference) {
+		return this.xxhash64Signed(reference);
+	}
+	hashUriParam(uri, lowercase = false) {
+		return this.xxhash64Signed(lowercase ? uri.toLowerCase() : uri);
+	}
+};
 //#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);
+HashUtils.getInstance().InitHash();
+var HASH_SEED = 43981n;
 /**
 * Normalize string values similar to HAPI FHIR (trim, collapse whitespace, lowercase)
 */
 function normalizeStringParam(input) {
 	return input.trim().replace(/\s+/g, " ").toLowerCase();
 }
+var h64;
+async function initHash() {
+	h64 = (await e()).h64;
+}
 function xxhash64Signed(input) {
-	const hashHex = import_lib.default.h64(input, 43981).toString(16).padStart(16, "0");
-	return Buffer.from(hashHex, "hex").readBigInt64BE(0);
+	return BigInt.asIntN(64, h64(input, HASH_SEED));
 }
 /**
 * Converts first 64 bits of MurmurHash3_x64_128 result into signed BigInt
@@ -1403,8 +3292,7 @@ function xxhash64Signed(input) {
 * Compute hash for a normalized string search parameter
 */
 function hashStringParam(input, normalize) {
-	if (normalize === true) return xxhash64Signed(normalizeStringParam(input));
-	else return xxhash64Signed(input);
+	return HashUtils.getInstance().hashStringParam(input, normalize);
 }
 /**
 * Compute hash for a token search parameter (system|code)
@@ -4529,6 +6417,6 @@ var PGFhirAccessLayer = class extends TinyEmitter {
 	};
 };
 //#endregion
-export { DBSearchIndex, FHIRDateUtils, PGFhirAccessLayer, ResourceHelper, hashReferenceParam, hashStringParam, hashTokenParam, hashUriParam, normalizeStringParam, xxhash64Signed };
+export { DBSearchIndex, FHIRDateUtils, PGFhirAccessLayer, ResourceHelper, hashReferenceParam, hashStringParam, hashTokenParam, hashUriParam, initHash, normalizeStringParam, xxhash64Signed };
 
 //# sourceMappingURL=index.mjs.map