@flickfyi/flkr 0.0.153 → 0.0.156

package/node_modules/@flickfyi/http-message-sig/dist/index.js

@@ -20,11 +20,11 @@ function isType(value, typeConstructor, typeStringified) {
 	if (value.constructor === typeConstructor) return true;
 	return objectToString.call(value) === typeStringified;
 }
-function isUint8Array(value) {
+function isUint8Array$1(value) {
 	return isType(value, Uint8Array, uint8ArrayStringified);
 }
 function assertUint8Array(value) {
-	if (!isUint8Array(value)) throw new TypeError(`Expected \`Uint8Array\`, got \`${typeof value}\``);
+	if (!isUint8Array$1(value)) throw new TypeError(`Expected \`Uint8Array\`, got \`${typeof value}\``);
 }
 new globalThis.TextDecoder("utf8");
 function assertString(value) {
@@ -74,6 +74,686 @@ function decode(b) {
 	return base64ToUint8Array(b);
 }
 //#endregion
+//#region ../../node_modules/.bun/@sindresorhus+is@8.1.0/node_modules/@sindresorhus/is/distribution/utilities.js
+function keysOf(value) {
+	return Object.keys(value);
+}
+//#endregion
+//#region ../../node_modules/.bun/@sindresorhus+is@8.1.0/node_modules/@sindresorhus/is/distribution/index.js
+var typedArrayTypeNames = [
+	"Int8Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array"
+];
+function isTypedArrayName(name) {
+	return typedArrayTypeNames.includes(name);
+}
+var objectTypeNames = [
+	"Function",
+	"Generator",
+	"AsyncGenerator",
+	"GeneratorFunction",
+	"AsyncGeneratorFunction",
+	"AsyncFunction",
+	"Observable",
+	"Array",
+	"Buffer",
+	"Blob",
+	"Object",
+	"RegExp",
+	"Date",
+	"Error",
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"WeakRef",
+	"ArrayBuffer",
+	"SharedArrayBuffer",
+	"DataView",
+	"Promise",
+	"URL",
+	"FormData",
+	"URLSearchParams",
+	"HTMLElement",
+	"NaN",
+	...typedArrayTypeNames
+];
+function isObjectTypeName(name) {
+	return objectTypeNames.includes(name);
+}
+var primitiveTypeNames = [
+	"null",
+	"undefined",
+	"string",
+	"number",
+	"bigint",
+	"boolean",
+	"symbol"
+];
+function isPrimitiveTypeName(name) {
+	return primitiveTypeNames.includes(name);
+}
+[...objectTypeNames, ...primitiveTypeNames];
+var getObjectType = (value) => {
+	const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
+	if (/HTML\w+Element/v.test(objectTypeName) && isHtmlElement(value)) return "HTMLElement";
+	if (isObjectTypeName(objectTypeName)) return objectTypeName;
+};
+function detect(value) {
+	if (value === null) return "null";
+	switch (typeof value) {
+		case "undefined": return "undefined";
+		case "string": return "string";
+		case "number": return Number.isNaN(value) ? "NaN" : "number";
+		case "boolean": return "boolean";
+		case "function": return "Function";
+		case "bigint": return "bigint";
+		case "symbol": return "symbol";
+	}
+	if (isObservable(value)) return "Observable";
+	if (isArray(value)) return "Array";
+	if (isBuffer(value)) return "Buffer";
+	const tagType = getObjectType(value);
+	if (tagType !== void 0 && tagType !== "Object") return tagType;
+	if (hasPromiseApi(value)) return "Promise";
+	if (isBoxedPrimitiveObject(value)) throw new TypeError("Please don't use object wrappers for primitive types");
+	return "Object";
+}
+function hasPromiseApi(value) {
+	return isFunction(value?.then) && isFunction(value?.catch);
+}
+function hasBoxedPrimitiveBrand(value, valueOf) {
+	try {
+		Reflect.apply(valueOf, value, []);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isBoxedPrimitiveObject(value) {
+	return hasBoxedPrimitiveBrand(value, String.prototype.valueOf) || hasBoxedPrimitiveBrand(value, Boolean.prototype.valueOf) || hasBoxedPrimitiveBrand(value, Number.prototype.valueOf);
+}
+Object.assign(detect, {
+	all: isAll,
+	any: isAny,
+	array: isArray,
+	arrayBuffer: isArrayBuffer,
+	arrayLike: isArrayLike,
+	arrayOf: isArrayOf,
+	asyncFunction: isAsyncFunction,
+	asyncGenerator: isAsyncGenerator,
+	asyncGeneratorFunction: isAsyncGeneratorFunction,
+	asyncIterable: isAsyncIterable,
+	bigint: isBigint,
+	bigInt64Array: isBigInt64Array,
+	bigUint64Array: isBigUint64Array,
+	blob: isBlob,
+	boolean: isBoolean,
+	boundFunction: isBoundFunction,
+	buffer: isBuffer,
+	class: isClass,
+	dataView: isDataView,
+	date: isDate,
+	detect,
+	directInstanceOf: isDirectInstanceOf,
+	emptyArray: isEmptyArray,
+	emptyMap: isEmptyMap,
+	emptyObject: isEmptyObject,
+	emptySet: isEmptySet,
+	emptyString: isEmptyString,
+	emptyStringOrWhitespace: isEmptyStringOrWhitespace,
+	enumCase: isEnumCase,
+	error: isError,
+	evenInteger: isEvenInteger,
+	falsy: isFalsy,
+	finiteNumber: isFiniteNumber,
+	float32Array: isFloat32Array,
+	float64Array: isFloat64Array,
+	formData: isFormData,
+	function: isFunction,
+	generator: isGenerator,
+	generatorFunction: isGeneratorFunction,
+	htmlElement: isHtmlElement,
+	infinite: isInfinite,
+	inRange: isInRange,
+	int16Array: isInt16Array,
+	int32Array: isInt32Array,
+	int8Array: isInt8Array,
+	integer: isInteger,
+	iterable: isIterable,
+	map: isMap,
+	nan: isNan,
+	nativePromise: isNativePromise,
+	negativeInteger: isNegativeInteger,
+	negativeNumber: isNegativeNumber,
+	nodeStream: isNodeStream,
+	nonEmptyArray: isNonEmptyArray,
+	nonEmptyMap: isNonEmptyMap,
+	nonEmptyObject: isNonEmptyObject,
+	nonEmptySet: isNonEmptySet,
+	nonEmptyString: isNonEmptyString,
+	nonEmptyStringAndNotWhitespace: isNonEmptyStringAndNotWhitespace,
+	nonNegativeInteger: isNonNegativeInteger,
+	nonNegativeNumber: isNonNegativeNumber,
+	null: isNull,
+	nullOrUndefined: isNullOrUndefined,
+	number: isNumber,
+	numericString: isNumericString,
+	object: isObject,
+	observable: isObservable,
+	oddInteger: isOddInteger,
+	oneOf: isOneOf,
+	plainObject: isPlainObject,
+	positiveInteger: isPositiveInteger,
+	positiveNumber: isPositiveNumber,
+	primitive: isPrimitive,
+	promise: isPromise,
+	propertyKey: isPropertyKey,
+	regExp: isRegExp,
+	safeInteger: isSafeInteger,
+	set: isSet,
+	sharedArrayBuffer: isSharedArrayBuffer,
+	string: isString,
+	symbol: isSymbol,
+	truthy: isTruthy,
+	tupleLike: isTupleLike,
+	typedArray: isTypedArray,
+	uint16Array: isUint16Array,
+	uint32Array: isUint32Array,
+	uint8Array: isUint8Array,
+	uint8ClampedArray: isUint8ClampedArray,
+	undefined: isUndefined,
+	urlInstance: isUrlInstance,
+	urlSearchParams: isUrlSearchParams,
+	urlString: isUrlString,
+	optional: isOptional,
+	validDate: isValidDate,
+	validLength: isValidLength,
+	weakMap: isWeakMap,
+	weakRef: isWeakRef,
+	weakSet: isWeakSet,
+	whitespaceString: isWhitespaceString
+});
+function isAbsoluteModule2(remainder) {
+	return (value) => isInteger(value) && Math.abs(value % 2) === remainder;
+}
+function validatePredicateArray(predicateArray, allowEmpty) {
+	if (predicateArray.length === 0) {
+		if (allowEmpty) {} else throw new TypeError("Invalid predicate array");
+		return;
+	}
+	for (const predicate of predicateArray) validatePredicate(predicate);
+}
+function validatePredicate(predicate) {
+	if (!isFunction(predicate)) throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`);
+}
+function isAll(predicate, ...values) {
+	if (Array.isArray(predicate)) {
+		const predicateArray = predicate;
+		validatePredicateArray(predicateArray, values.length === 0);
+		const combinedPredicate = (value) => predicateArray.every((singlePredicate) => singlePredicate(value));
+		if (values.length === 0) return combinedPredicate;
+		return predicateOnArray(Array.prototype.every, combinedPredicate, values);
+	}
+	return predicateOnArray(Array.prototype.every, predicate, values);
+}
+function isAny(predicate, ...values) {
+	if (Array.isArray(predicate)) {
+		const predicateArray = predicate;
+		validatePredicateArray(predicateArray, values.length === 0);
+		const combinedPredicate = (value) => predicateArray.some((singlePredicate) => singlePredicate(value));
+		if (values.length === 0) return combinedPredicate;
+		return predicateOnArray(Array.prototype.some, combinedPredicate, values);
+	}
+	return predicateOnArray(Array.prototype.some, predicate, values);
+}
+function isOptional(value, predicate) {
+	return isUndefined(value) || predicate(value);
+}
+function isArray(value, assertion) {
+	if (!Array.isArray(value)) return false;
+	if (!isFunction(assertion)) return true;
+	return value.every((element) => assertion(element));
+}
+function isArrayBuffer(value) {
+	return getObjectType(value) === "ArrayBuffer";
+}
+function isArrayLike(value) {
+	return !isNullOrUndefined(value) && !isFunction(value) && isValidLength(value.length);
+}
+function isArrayOf(predicate) {
+	return (value) => isArray(value) && value.every((element) => predicate(element));
+}
+function isAsyncFunction(value) {
+	return getObjectType(value) === "AsyncFunction";
+}
+function isAsyncGenerator(value) {
+	return isAsyncIterable(value) && isFunction(value.next) && isFunction(value.throw);
+}
+function isAsyncGeneratorFunction(value) {
+	return getObjectType(value) === "AsyncGeneratorFunction";
+}
+function isAsyncIterable(value) {
+	return isFunction(value?.[Symbol.asyncIterator]);
+}
+function isBigint(value) {
+	return typeof value === "bigint";
+}
+function isBigInt64Array(value) {
+	return getObjectType(value) === "BigInt64Array";
+}
+function isBigUint64Array(value) {
+	return getObjectType(value) === "BigUint64Array";
+}
+function isBlob(value) {
+	return getObjectType(value) === "Blob";
+}
+function isBoolean(value) {
+	return value === true || value === false;
+}
+function isBoundFunction(value) {
+	return isFunction(value) && !Object.hasOwn(value, "prototype");
+}
+/**
+Note: [Prefer using `Uint8Array` instead of `Buffer`.](https://sindresorhus.com/blog/goodbye-nodejs-buffer)
+*/
+function isBuffer(value) {
+	return value?.constructor?.isBuffer?.(value) ?? false;
+}
+function isClass(value) {
+	return isFunction(value) && /^class(?:\s+|\{)/v.test(value.toString());
+}
+function isDataView(value) {
+	return getObjectType(value) === "DataView";
+}
+function isDate(value) {
+	return getObjectType(value) === "Date";
+}
+function isDirectInstanceOf(instance, class_) {
+	if (instance === void 0 || instance === null) return false;
+	return Object.getPrototypeOf(instance) === class_.prototype;
+}
+function isEmptyArray(value) {
+	return isArray(value) && value.length === 0;
+}
+function isEmptyMap(value) {
+	return isMap(value) && value.size === 0;
+}
+function isEmptyObject(value) {
+	return isObject(value) && !isFunction(value) && !isArray(value) && !isMap(value) && !isSet(value) && Object.keys(value).length === 0;
+}
+function isEmptySet(value) {
+	return isSet(value) && value.size === 0;
+}
+function isEmptyString(value) {
+	return isString(value) && value.length === 0;
+}
+function isEmptyStringOrWhitespace(value) {
+	return isEmptyString(value) || isWhitespaceString(value);
+}
+function isEnumCase(value, targetEnum) {
+	const enumObject = targetEnum;
+	return Object.entries(enumObject).some(([key, enumValue]) => {
+		if (!isString(enumValue)) return enumValue === value;
+		const numericKey = Number(key);
+		if (Number.isNaN(numericKey) || String(numericKey) !== key) return enumValue === value;
+		return enumValue === value && !(Object.hasOwn(enumObject, enumValue) && enumObject[enumValue] === numericKey);
+	});
+}
+function isError(value) {
+	return getObjectType(value) === "Error";
+}
+function isEvenInteger(value) {
+	return isAbsoluteModule2(0)(value);
+}
+function isFalsy(value) {
+	return !value;
+}
+function isFiniteNumber(value) {
+	return Number.isFinite(value);
+}
+function isFloat32Array(value) {
+	return getObjectType(value) === "Float32Array";
+}
+function isFloat64Array(value) {
+	return getObjectType(value) === "Float64Array";
+}
+function isFormData(value) {
+	return getObjectType(value) === "FormData";
+}
+function isFunction(value) {
+	return typeof value === "function";
+}
+function isGenerator(value) {
+	return isIterable(value) && isFunction(value?.next) && isFunction(value?.throw);
+}
+function isGeneratorFunction(value) {
+	return getObjectType(value) === "GeneratorFunction";
+}
+var NODE_TYPE_ELEMENT = 1;
+var DOM_PROPERTIES_TO_CHECK = [
+	"innerHTML",
+	"ownerDocument",
+	"style",
+	"attributes",
+	"nodeValue"
+];
+function isHtmlElement(value) {
+	return isObject(value) && value.nodeType === NODE_TYPE_ELEMENT && isString(value.nodeName) && !isPlainObject(value) && DOM_PROPERTIES_TO_CHECK.every((property) => property in value);
+}
+function isInfinite(value) {
+	return value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY;
+}
+function isInRange(value, range) {
+	if (isNumber(range)) return value >= Math.min(0, range) && value <= Math.max(range, 0);
+	if (isArray(range) && range.length === 2) {
+		if (Number.isNaN(range[0]) || Number.isNaN(range[1])) throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
+		return value >= Math.min(...range) && value <= Math.max(...range);
+	}
+	throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
+}
+function isInt16Array(value) {
+	return getObjectType(value) === "Int16Array";
+}
+function isInt32Array(value) {
+	return getObjectType(value) === "Int32Array";
+}
+function isInt8Array(value) {
+	return getObjectType(value) === "Int8Array";
+}
+function isInteger(value) {
+	return Number.isInteger(value);
+}
+function isIterable(value) {
+	return isFunction(value?.[Symbol.iterator]);
+}
+function isMap(value) {
+	return getObjectType(value) === "Map";
+}
+function isNan(value) {
+	return Number.isNaN(value);
+}
+function isNativePromise(value) {
+	return getObjectType(value) === "Promise";
+}
+function isNegativeInteger(value) {
+	return isInteger(value) && value < 0;
+}
+function isNegativeNumber(value) {
+	return isNumber(value) && value < 0;
+}
+function isNodeStream(value) {
+	return isObject(value) && isFunction(value.pipe) && !isObservable(value);
+}
+function isNonEmptyArray(value) {
+	return isArray(value) && value.length > 0;
+}
+function isNonEmptyMap(value) {
+	return isMap(value) && value.size > 0;
+}
+function isNonEmptyObject(value) {
+	return isObject(value) && !isFunction(value) && !isArray(value) && !isMap(value) && !isSet(value) && Object.keys(value).length > 0;
+}
+function isNonEmptySet(value) {
+	return isSet(value) && value.size > 0;
+}
+function isNonEmptyString(value) {
+	return isString(value) && value.length > 0;
+}
+function isNonEmptyStringAndNotWhitespace(value) {
+	return isString(value) && !isEmptyStringOrWhitespace(value);
+}
+function isNonNegativeInteger(value) {
+	return isInteger(value) && value >= 0;
+}
+function isNonNegativeNumber(value) {
+	return isNumber(value) && value >= 0;
+}
+function isNull(value) {
+	return value === null;
+}
+function isNullOrUndefined(value) {
+	return isNull(value) || isUndefined(value);
+}
+function isNumber(value) {
+	return typeof value === "number" && !Number.isNaN(value);
+}
+function isNumericString(value) {
+	return isString(value) && !isEmptyStringOrWhitespace(value) && value === value.trim() && !Number.isNaN(Number(value));
+}
+function isObject(value) {
+	return !isNull(value) && (typeof value === "object" || isFunction(value));
+}
+function isObservable(value) {
+	if (!value) return false;
+	if (Symbol.observable !== void 0 && value === value[Symbol.observable]?.()) return true;
+	if (value === value["@@observable"]?.()) return true;
+	return false;
+}
+function isOddInteger(value) {
+	return isAbsoluteModule2(1)(value);
+}
+function isOneOf(values) {
+	return (value) => values.includes(value);
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+function isPositiveInteger(value) {
+	return isInteger(value) && value > 0;
+}
+function isPositiveNumber(value) {
+	return isNumber(value) && value > 0;
+}
+function isPrimitive(value) {
+	return isNull(value) || isPrimitiveTypeName(typeof value);
+}
+function isPromise(value) {
+	return isNativePromise(value) || hasPromiseApi(value);
+}
+function isPropertyKey(value) {
+	return isAny([
+		isString,
+		isNumber,
+		isSymbol
+	], value);
+}
+function isRegExp(value) {
+	return getObjectType(value) === "RegExp";
+}
+function isSafeInteger(value) {
+	return Number.isSafeInteger(value);
+}
+function isSet(value) {
+	return getObjectType(value) === "Set";
+}
+function isSharedArrayBuffer(value) {
+	return getObjectType(value) === "SharedArrayBuffer";
+}
+function isString(value) {
+	return typeof value === "string";
+}
+function isSymbol(value) {
+	return typeof value === "symbol";
+}
+function isTruthy(value) {
+	return Boolean(value);
+}
+function isTupleLike(value, guards) {
+	if (isArray(guards) && isArray(value) && guards.length === value.length) return guards.every((guard, index) => guard(value[index]));
+	return false;
+}
+function isTypedArray(value) {
+	return isTypedArrayName(getObjectType(value));
+}
+function isUint16Array(value) {
+	return getObjectType(value) === "Uint16Array";
+}
+function isUint32Array(value) {
+	return getObjectType(value) === "Uint32Array";
+}
+function isUint8Array(value) {
+	return getObjectType(value) === "Uint8Array";
+}
+function isUint8ClampedArray(value) {
+	return getObjectType(value) === "Uint8ClampedArray";
+}
+function isUndefined(value) {
+	return value === void 0;
+}
+function isUrlInstance(value) {
+	return getObjectType(value) === "URL";
+}
+function isUrlSearchParams(value) {
+	return getObjectType(value) === "URLSearchParams";
+}
+function isUrlString(value) {
+	if (!isString(value)) return false;
+	try {
+		new URL(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isValidDate(value) {
+	return isDate(value) && !isNan(Number(value));
+}
+function isValidLength(value) {
+	return isSafeInteger(value) && value >= 0;
+}
+function isWeakMap(value) {
+	return getObjectType(value) === "WeakMap";
+}
+function isWeakRef(value) {
+	return getObjectType(value) === "WeakRef";
+}
+function isWeakSet(value) {
+	return getObjectType(value) === "WeakSet";
+}
+function isWhitespaceString(value) {
+	return isString(value) && /^\s+$/v.test(value);
+}
+function predicateOnArray(method, predicate, values) {
+	validatePredicate(predicate);
+	if (values.length === 0) throw new TypeError("Invalid number of values");
+	return method.call(values, predicate);
+}
+new Intl.ListFormat("en", {
+	style: "long",
+	type: "conjunction"
+});
+new Intl.ListFormat("en", {
+	style: "long",
+	type: "disjunction"
+});
+keysOf({
+	isArray: "Array",
+	isArrayBuffer: "ArrayBuffer",
+	isArrayLike: "array-like",
+	isAsyncFunction: "AsyncFunction",
+	isAsyncGenerator: "AsyncGenerator",
+	isAsyncGeneratorFunction: "AsyncGeneratorFunction",
+	isAsyncIterable: "AsyncIterable",
+	isBigint: "bigint",
+	isBigInt64Array: "BigInt64Array",
+	isBigUint64Array: "BigUint64Array",
+	isBlob: "Blob",
+	isBoolean: "boolean",
+	isBoundFunction: "bound Function",
+	isBuffer: "Buffer",
+	isClass: "Class",
+	isDataView: "DataView",
+	isDate: "Date",
+	isDirectInstanceOf: "T",
+	isEmptyArray: "empty array",
+	isEmptyMap: "empty map",
+	isEmptyObject: "empty object",
+	isEmptySet: "empty set",
+	isEmptyString: "empty string",
+	isEmptyStringOrWhitespace: "empty string or whitespace",
+	isEnumCase: "EnumCase",
+	isError: "Error",
+	isEvenInteger: "even integer",
+	isFalsy: "falsy",
+	isFiniteNumber: "finite number",
+	isFloat32Array: "Float32Array",
+	isFloat64Array: "Float64Array",
+	isFormData: "FormData",
+	isFunction: "Function",
+	isGenerator: "Generator",
+	isGeneratorFunction: "GeneratorFunction",
+	isHtmlElement: "HTMLElement",
+	isInfinite: "infinite number",
+	isInRange: "in range",
+	isInt16Array: "Int16Array",
+	isInt32Array: "Int32Array",
+	isInt8Array: "Int8Array",
+	isInteger: "integer",
+	isIterable: "Iterable",
+	isMap: "Map",
+	isNan: "NaN",
+	isNativePromise: "native Promise",
+	isNegativeInteger: "negative integer",
+	isNegativeNumber: "negative number",
+	isNodeStream: "Node.js Stream",
+	isNonEmptyArray: "non-empty array",
+	isNonEmptyMap: "non-empty map",
+	isNonEmptyObject: "non-empty object",
+	isNonEmptySet: "non-empty set",
+	isNonEmptyString: "non-empty string",
+	isNonEmptyStringAndNotWhitespace: "non-empty string and not whitespace",
+	isNonNegativeInteger: "non-negative integer",
+	isNonNegativeNumber: "non-negative number",
+	isNull: "null",
+	isNullOrUndefined: "null or undefined",
+	isNumber: "number",
+	isNumericString: "string with a number",
+	isObject: "Object",
+	isObservable: "Observable",
+	isOddInteger: "odd integer",
+	isPlainObject: "plain object",
+	isPositiveInteger: "positive integer",
+	isPositiveNumber: "positive number",
+	isPrimitive: "primitive",
+	isPromise: "Promise",
+	isPropertyKey: "PropertyKey",
+	isRegExp: "RegExp",
+	isSafeInteger: "safe integer",
+	isSet: "Set",
+	isSharedArrayBuffer: "SharedArrayBuffer",
+	isString: "string",
+	isSymbol: "symbol",
+	isTruthy: "truthy",
+	isTupleLike: "tuple-like",
+	isTypedArray: "TypedArray",
+	isUint16Array: "Uint16Array",
+	isUint32Array: "Uint32Array",
+	isUint8Array: "Uint8Array",
+	isUint8ClampedArray: "Uint8ClampedArray",
+	isUndefined: "undefined",
+	isUrlInstance: "URL",
+	isUrlSearchParams: "URLSearchParams",
+	isUrlString: "string with a URL",
+	isValidDate: "valid Date",
+	isValidLength: "valid length",
+	isWeakMap: "WeakMap",
+	isWeakRef: "WeakRef",
+	isWeakSet: "WeakSet",
+	isWhitespaceString: "whitespace string"
+});
+//#endregion
 //#region src/build.ts
 /**
 * Extracts one member from a Dictionary Structured Field and serializes that
@@ -420,7 +1100,7 @@ function orderedParameterEntries(parameters) {
 */
 function toStructuredParameterValue(value) {
 	if (value instanceof Date) return Math.floor(value.getTime() / 1e3);
-	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || isArrayBuffer(value)) return value;
 	return value.toString();
 }
 /**