every-plugin 0.4.13 → 0.4.15

package/dist/standard-v75BC6Z5.cjs

@@ -0,0 +1,685 @@
+let __orpc_contract = require("@orpc/contract");
+
+//#region ../../node_modules/.bun/@orpc+shared@1.10.4+460773ef8ff1e07c/node_modules/@orpc/shared/dist/index.mjs
+function resolveMaybeOptionalOptions(rest) {
+	return rest[0] ?? {};
+}
+function toArray(value$1) {
+	return Array.isArray(value$1) ? value$1 : value$1 === void 0 || value$1 === null ? [] : [value$1];
+}
+const ORPC_SHARED_PACKAGE_NAME = "@orpc/shared";
+const ORPC_SHARED_PACKAGE_VERSION = "1.10.4";
+function once(fn) {
+	let cached;
+	return () => {
+		if (cached) return cached.result;
+		const result = fn();
+		cached = { result };
+		return result;
+	};
+}
+function sequential(fn) {
+	let lastOperationPromise = Promise.resolve();
+	return (...args) => {
+		return lastOperationPromise = lastOperationPromise.catch(() => {}).then(() => {
+			return fn(...args);
+		});
+	};
+}
+const GLOBAL_OTEL_CONFIG_KEY = `__${ORPC_SHARED_PACKAGE_NAME}@${ORPC_SHARED_PACKAGE_VERSION}/otel/config__`;
+function isAsyncIteratorObject(maybe) {
+	if (!maybe || typeof maybe !== "object") return false;
+	return "next" in maybe && typeof maybe.next === "function" && Symbol.asyncIterator in maybe && typeof maybe[Symbol.asyncIterator] === "function";
+}
+const fallbackAsyncDisposeSymbol = Symbol.for("asyncDispose");
+const asyncDisposeSymbol = Symbol.asyncDispose ?? fallbackAsyncDisposeSymbol;
+var AsyncIteratorClass = class {
+	#isDone = false;
+	#isExecuteComplete = false;
+	#cleanup;
+	#next;
+	constructor(next, cleanup) {
+		this.#cleanup = cleanup;
+		this.#next = sequential(async () => {
+			if (this.#isDone) return {
+				done: true,
+				value: void 0
+			};
+			try {
+				const result = await next();
+				if (result.done) this.#isDone = true;
+				return result;
+			} catch (err) {
+				this.#isDone = true;
+				throw err;
+			} finally {
+				if (this.#isDone && !this.#isExecuteComplete) {
+					this.#isExecuteComplete = true;
+					await this.#cleanup("next");
+				}
+			}
+		});
+	}
+	next() {
+		return this.#next();
+	}
+	async return(value$1) {
+		this.#isDone = true;
+		if (!this.#isExecuteComplete) {
+			this.#isExecuteComplete = true;
+			await this.#cleanup("return");
+		}
+		return {
+			done: true,
+			value: value$1
+		};
+	}
+	async throw(err) {
+		this.#isDone = true;
+		if (!this.#isExecuteComplete) {
+			this.#isExecuteComplete = true;
+			await this.#cleanup("throw");
+		}
+		throw err;
+	}
+	/**
+	* asyncDispose symbol only available in esnext, we should fallback to Symbol.for('asyncDispose')
+	*/
+	async [asyncDisposeSymbol]() {
+		this.#isDone = true;
+		if (!this.#isExecuteComplete) {
+			this.#isExecuteComplete = true;
+			await this.#cleanup("dispose");
+		}
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+};
+function stringifyJSON(value$1) {
+	return JSON.stringify(value$1);
+}
+function findDeepMatches(check, payload, segments = [], maps = [], values = []) {
+	if (check(payload)) {
+		maps.push(segments);
+		values.push(payload);
+	} else if (Array.isArray(payload)) payload.forEach((v, i) => {
+		findDeepMatches(check, v, [...segments, i], maps, values);
+	});
+	else if (isObject(payload)) for (const key in payload) findDeepMatches(check, payload[key], [...segments, key], maps, values);
+	return {
+		maps,
+		values
+	};
+}
+function getConstructor(value$1) {
+	if (!isTypescriptObject(value$1)) return null;
+	return Object.getPrototypeOf(value$1)?.constructor;
+}
+function isObject(value$1) {
+	if (!value$1 || typeof value$1 !== "object") return false;
+	const proto = Object.getPrototypeOf(value$1);
+	return proto === Object.prototype || !proto || !proto.constructor;
+}
+function isTypescriptObject(value$1) {
+	return !!value$1 && (typeof value$1 === "object" || typeof value$1 === "function");
+}
+function clone(value$1) {
+	if (Array.isArray(value$1)) return value$1.map(clone);
+	if (isObject(value$1)) {
+		const result = {};
+		for (const key in value$1) result[key] = clone(value$1[key]);
+		return result;
+	}
+	return value$1;
+}
+const NullProtoObj = /* @__PURE__ */ (() => {
+	const e = function() {};
+	e.prototype = /* @__PURE__ */ Object.create(null);
+	Object.freeze(e.prototype);
+	return e;
+})();
+function value(value2, ...args) {
+	if (typeof value2 === "function") return value2(...args);
+	return value2;
+}
+function tryDecodeURIComponent(value$1) {
+	try {
+		return decodeURIComponent(value$1);
+	} catch {
+		return value$1;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@orpc+standard-server@1.10.4+460773ef8ff1e07c/node_modules/@orpc/standard-server/dist/index.mjs
+var EventEncoderError = class extends TypeError {};
+var ErrorEvent = class extends Error {
+	data;
+	constructor(options) {
+		super(options?.message ?? "An error event was received", options);
+		this.data = options?.data;
+	}
+};
+function assertEventId(id) {
+	if (id.includes("\n")) throw new EventEncoderError("Event's id must not contain a newline character");
+}
+function assertEventRetry(retry) {
+	if (!Number.isInteger(retry) || retry < 0) throw new EventEncoderError("Event's retry must be a integer and >= 0");
+}
+function assertEventComment(comment) {
+	if (comment.includes("\n")) throw new EventEncoderError("Event's comment must not contain a newline character");
+}
+const EVENT_SOURCE_META_SYMBOL = Symbol("ORPC_EVENT_SOURCE_META");
+function withEventMeta(container, meta) {
+	if (meta.id === void 0 && meta.retry === void 0 && !meta.comments?.length) return container;
+	if (meta.id !== void 0) assertEventId(meta.id);
+	if (meta.retry !== void 0) assertEventRetry(meta.retry);
+	if (meta.comments !== void 0) for (const comment of meta.comments) assertEventComment(comment);
+	return new Proxy(container, { get(target, prop, receiver) {
+		if (prop === EVENT_SOURCE_META_SYMBOL) return meta;
+		return Reflect.get(target, prop, receiver);
+	} });
+}
+function getEventMeta(container) {
+	return isTypescriptObject(container) ? Reflect.get(container, EVENT_SOURCE_META_SYMBOL) : void 0;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@orpc+client@1.10.4+460773ef8ff1e07c/node_modules/@orpc/client/dist/shared/client.DmkMd_GB.mjs
+const ORPC_CLIENT_PACKAGE_NAME = "@orpc/client";
+const ORPC_CLIENT_PACKAGE_VERSION = "1.10.4";
+const COMMON_ORPC_ERROR_DEFS = {
+	BAD_REQUEST: {
+		status: 400,
+		message: "Bad Request"
+	},
+	UNAUTHORIZED: {
+		status: 401,
+		message: "Unauthorized"
+	},
+	FORBIDDEN: {
+		status: 403,
+		message: "Forbidden"
+	},
+	NOT_FOUND: {
+		status: 404,
+		message: "Not Found"
+	},
+	METHOD_NOT_SUPPORTED: {
+		status: 405,
+		message: "Method Not Supported"
+	},
+	NOT_ACCEPTABLE: {
+		status: 406,
+		message: "Not Acceptable"
+	},
+	TIMEOUT: {
+		status: 408,
+		message: "Request Timeout"
+	},
+	CONFLICT: {
+		status: 409,
+		message: "Conflict"
+	},
+	PRECONDITION_FAILED: {
+		status: 412,
+		message: "Precondition Failed"
+	},
+	PAYLOAD_TOO_LARGE: {
+		status: 413,
+		message: "Payload Too Large"
+	},
+	UNSUPPORTED_MEDIA_TYPE: {
+		status: 415,
+		message: "Unsupported Media Type"
+	},
+	UNPROCESSABLE_CONTENT: {
+		status: 422,
+		message: "Unprocessable Content"
+	},
+	TOO_MANY_REQUESTS: {
+		status: 429,
+		message: "Too Many Requests"
+	},
+	CLIENT_CLOSED_REQUEST: {
+		status: 499,
+		message: "Client Closed Request"
+	},
+	INTERNAL_SERVER_ERROR: {
+		status: 500,
+		message: "Internal Server Error"
+	},
+	NOT_IMPLEMENTED: {
+		status: 501,
+		message: "Not Implemented"
+	},
+	BAD_GATEWAY: {
+		status: 502,
+		message: "Bad Gateway"
+	},
+	SERVICE_UNAVAILABLE: {
+		status: 503,
+		message: "Service Unavailable"
+	},
+	GATEWAY_TIMEOUT: {
+		status: 504,
+		message: "Gateway Timeout"
+	}
+};
+function fallbackORPCErrorStatus(code, status) {
+	return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
+}
+function fallbackORPCErrorMessage(code, message) {
+	return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
+}
+const GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL = Symbol.for(`__${ORPC_CLIENT_PACKAGE_NAME}@${ORPC_CLIENT_PACKAGE_VERSION}/error/ORPC_ERROR_CONSTRUCTORS__`);
+globalThis[GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL] ??= /* @__PURE__ */ new WeakSet();
+const globalORPCErrorConstructors = globalThis[GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL];
+var ORPCError$1 = class extends Error {
+	defined;
+	code;
+	status;
+	data;
+	constructor(code, ...rest) {
+		const options = resolveMaybeOptionalOptions(rest);
+		if (options.status !== void 0 && !isORPCErrorStatus(options.status)) throw new Error("[ORPCError] Invalid error status code.");
+		const message = fallbackORPCErrorMessage(code, options.message);
+		super(message, options);
+		this.code = code;
+		this.status = fallbackORPCErrorStatus(code, options.status);
+		this.defined = options.defined ?? false;
+		this.data = options.data;
+	}
+	toJSON() {
+		return {
+			defined: this.defined,
+			code: this.code,
+			status: this.status,
+			message: this.message,
+			data: this.data
+		};
+	}
+	/**
+	* Workaround for Next.js where different contexts use separate
+	* dependency graphs, causing multiple ORPCError constructors existing and breaking
+	* `instanceof` checks across contexts.
+	*
+	* This is particularly problematic with "Optimized SSR", where orpc-client
+	* executes in one context but is invoked from another. When an error is thrown
+	* in the execution context, `instanceof ORPCError` checks fail in the
+	* invocation context due to separate class constructors.
+	*
+	* @todo Remove this and related code if Next.js resolves the multiple dependency graph issue.
+	*/
+	static [Symbol.hasInstance](instance) {
+		if (globalORPCErrorConstructors.has(this)) {
+			const constructor = getConstructor(instance);
+			if (constructor && globalORPCErrorConstructors.has(constructor)) return true;
+		}
+		return super[Symbol.hasInstance](instance);
+	}
+};
+globalORPCErrorConstructors.add(ORPCError$1);
+function toORPCError(error) {
+	return error instanceof ORPCError$1 ? error : new ORPCError$1("INTERNAL_SERVER_ERROR", {
+		message: "Internal server error",
+		cause: error
+	});
+}
+function isORPCErrorStatus(status) {
+	return status < 200 || status >= 400;
+}
+function isORPCErrorJson(json) {
+	if (!isObject(json)) return false;
+	const validKeys = [
+		"defined",
+		"code",
+		"status",
+		"message",
+		"data"
+	];
+	if (Object.keys(json).some((k) => !validKeys.includes(k))) return false;
+	return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && isORPCErrorStatus(json.status) && "message" in json && typeof json.message === "string";
+}
+function createORPCErrorFromJson(json, options = {}) {
+	return new ORPCError$1(json.code, {
+		...options,
+		...json
+	});
+}
+function mapEventIterator(iterator, maps) {
+	const mapError = async (error) => {
+		let mappedError = await maps.error(error);
+		if (mappedError !== error) {
+			const meta = getEventMeta(error);
+			if (meta && isTypescriptObject(mappedError)) mappedError = withEventMeta(mappedError, meta);
+		}
+		return mappedError;
+	};
+	return new AsyncIteratorClass(async () => {
+		const { done, value: value$1 } = await (async () => {
+			try {
+				return await iterator.next();
+			} catch (error) {
+				throw await mapError(error);
+			}
+		})();
+		let mappedValue = await maps.value(value$1, done);
+		if (mappedValue !== value$1) {
+			const meta = getEventMeta(value$1);
+			if (meta && isTypescriptObject(mappedValue)) mappedValue = withEventMeta(mappedValue, meta);
+		}
+		return {
+			done,
+			value: mappedValue
+		};
+	}, async () => {
+		try {
+			await iterator.return?.();
+		} catch (error) {
+			throw await mapError(error);
+		}
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@orpc+openapi-client@1.10.4+460773ef8ff1e07c/node_modules/@orpc/openapi-client/dist/shared/openapi-client.t9fCAe3x.mjs
+var StandardBracketNotationSerializer = class {
+	maxArrayIndex;
+	constructor(options = {}) {
+		this.maxArrayIndex = options.maxBracketNotationArrayIndex ?? 9999;
+	}
+	serialize(data, segments = [], result = []) {
+		if (Array.isArray(data)) data.forEach((item, i) => {
+			this.serialize(item, [...segments, i], result);
+		});
+		else if (isObject(data)) for (const key in data) this.serialize(data[key], [...segments, key], result);
+		else result.push([this.stringifyPath(segments), data]);
+		return result;
+	}
+	deserialize(serialized) {
+		if (serialized.length === 0) return {};
+		const arrayPushStyles = /* @__PURE__ */ new WeakSet();
+		const ref = { value: [] };
+		for (const [path, value$1] of serialized) {
+			const segments = this.parsePath(path);
+			let currentRef = ref;
+			let nextSegment = "value";
+			segments.forEach((segment, i) => {
+				if (!Array.isArray(currentRef[nextSegment]) && !isObject(currentRef[nextSegment])) currentRef[nextSegment] = [];
+				if (i !== segments.length - 1) {
+					if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment, this.maxArrayIndex)) if (arrayPushStyles.has(currentRef[nextSegment])) {
+						arrayPushStyles.delete(currentRef[nextSegment]);
+						currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
+					} else currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+				} else if (Array.isArray(currentRef[nextSegment])) {
+					if (segment === "") {
+						if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+					} else if (arrayPushStyles.has(currentRef[nextSegment])) {
+						arrayPushStyles.delete(currentRef[nextSegment]);
+						currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
+					} else if (!isValidArrayIndex(segment, this.maxArrayIndex)) currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+				}
+				currentRef = currentRef[nextSegment];
+				nextSegment = segment;
+			});
+			if (Array.isArray(currentRef) && nextSegment === "") {
+				arrayPushStyles.add(currentRef);
+				currentRef.push(value$1);
+			} else if (nextSegment in currentRef) if (Array.isArray(currentRef[nextSegment])) currentRef[nextSegment].push(value$1);
+			else currentRef[nextSegment] = [currentRef[nextSegment], value$1];
+			else currentRef[nextSegment] = value$1;
+		}
+		return ref.value;
+	}
+	stringifyPath(segments) {
+		return segments.map((segment) => {
+			return segment.toString().replace(/[\\[\]]/g, (match) => {
+				switch (match) {
+					case "\\": return "\\\\";
+					case "[": return "\\[";
+					case "]": return "\\]";
+					default: return match;
+				}
+			});
+		}).reduce((result, segment, i) => {
+			if (i === 0) return segment;
+			return `${result}[${segment}]`;
+		}, "");
+	}
+	parsePath(path) {
+		const segments = [];
+		let inBrackets = false;
+		let currentSegment = "";
+		let backslashCount = 0;
+		for (let i = 0; i < path.length; i++) {
+			const char = path[i];
+			const nextChar = path[i + 1];
+			if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
+				if (nextChar === void 0) inBrackets = false;
+				segments.push(currentSegment);
+				currentSegment = "";
+				i++;
+			} else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
+				inBrackets = true;
+				segments.push(currentSegment);
+				currentSegment = "";
+			} else if (char === "\\") backslashCount++;
+			else {
+				currentSegment += "\\".repeat(backslashCount / 2) + char;
+				backslashCount = 0;
+			}
+		}
+		return inBrackets || segments.length === 0 ? [path] : segments;
+	}
+};
+function isValidArrayIndex(value$1, maxIndex) {
+	return /^0$|^[1-9]\d*$/.test(value$1) && Number(value$1) <= maxIndex;
+}
+function arrayToObject(array) {
+	const obj = new NullProtoObj();
+	array.forEach((item, i) => {
+		obj[i] = item;
+	});
+	return obj;
+}
+function pushStyleArrayToObject(array) {
+	const obj = new NullProtoObj();
+	obj[""] = array.length === 1 ? array[0] : array;
+	return obj;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@orpc+client@1.10.4+460773ef8ff1e07c/node_modules/@orpc/client/dist/shared/client.Di65MWxv.mjs
+function toHttpPath(path) {
+	return `/${path.map(encodeURIComponent).join("/")}`;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@orpc+openapi-client@1.10.4+460773ef8ff1e07c/node_modules/@orpc/openapi-client/dist/shared/openapi-client.B2Q9qU5m.mjs
+var StandardOpenAPIJsonSerializer = class {
+	customSerializers;
+	constructor(options = {}) {
+		this.customSerializers = options.customJsonSerializers ?? [];
+	}
+	serialize(data, hasBlobRef = { value: false }) {
+		for (const custom of this.customSerializers) if (custom.condition(data)) return this.serialize(custom.serialize(data), hasBlobRef);
+		if (data instanceof Blob) {
+			hasBlobRef.value = true;
+			return [data, hasBlobRef.value];
+		}
+		if (data instanceof Set) return this.serialize(Array.from(data), hasBlobRef);
+		if (data instanceof Map) return this.serialize(Array.from(data.entries()), hasBlobRef);
+		if (Array.isArray(data)) return [data.map((v) => v === void 0 ? null : this.serialize(v, hasBlobRef)[0]), hasBlobRef.value];
+		if (isObject(data)) {
+			const json = {};
+			for (const k in data) {
+				if (k === "toJSON" && typeof data[k] === "function") continue;
+				json[k] = this.serialize(data[k], hasBlobRef)[0];
+			}
+			return [json, hasBlobRef.value];
+		}
+		if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) return [data.toString(), hasBlobRef.value];
+		if (data instanceof Date) return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
+		if (Number.isNaN(data)) return [null, hasBlobRef.value];
+		return [data, hasBlobRef.value];
+	}
+};
+function standardizeHTTPPath(path) {
+	return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function getDynamicParams(path) {
+	return path ? standardizeHTTPPath(path).match(/\/\{[^}]+\}/g)?.map((v) => ({
+		raw: v,
+		name: v.match(/\{\+?([^}]+)\}/)[1]
+	})) : void 0;
+}
+var StandardOpenAPISerializer = class {
+	constructor(jsonSerializer, bracketNotation) {
+		this.jsonSerializer = jsonSerializer;
+		this.bracketNotation = bracketNotation;
+	}
+	serialize(data, options = {}) {
+		if (isAsyncIteratorObject(data) && !options.outputFormat) return mapEventIterator(data, {
+			value: async (value$1) => this.#serialize(value$1, { outputFormat: "plain" }),
+			error: async (e) => {
+				return new ErrorEvent({
+					data: this.#serialize(toORPCError(e).toJSON(), { outputFormat: "plain" }),
+					cause: e
+				});
+			}
+		});
+		return this.#serialize(data, options);
+	}
+	#serialize(data, options) {
+		const [json, hasBlob] = this.jsonSerializer.serialize(data);
+		if (options.outputFormat === "plain") return json;
+		if (options.outputFormat === "URLSearchParams") {
+			const params = new URLSearchParams();
+			for (const [path, value$1] of this.bracketNotation.serialize(json)) if (typeof value$1 === "string" || typeof value$1 === "number" || typeof value$1 === "boolean") params.append(path, value$1.toString());
+			return params;
+		}
+		if (json instanceof Blob || json === void 0 || !hasBlob) return json;
+		const form = new FormData();
+		for (const [path, value$1] of this.bracketNotation.serialize(json)) if (typeof value$1 === "string" || typeof value$1 === "number" || typeof value$1 === "boolean") form.append(path, value$1.toString());
+		else if (value$1 instanceof Blob) form.append(path, value$1);
+		return form;
+	}
+	deserialize(data) {
+		if (data instanceof URLSearchParams || data instanceof FormData) return this.bracketNotation.deserialize(Array.from(data.entries()));
+		if (isAsyncIteratorObject(data)) return mapEventIterator(data, {
+			value: async (value$1) => value$1,
+			error: async (e) => {
+				if (e instanceof ErrorEvent && isORPCErrorJson(e.data)) return createORPCErrorFromJson(e.data, { cause: e });
+				return e;
+			}
+		});
+		return data;
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'StandardBracketNotationSerializer', {
+  enumerable: true,
+  get: function () {
+    return StandardBracketNotationSerializer;
+  }
+});
+Object.defineProperty(exports, 'StandardOpenAPIJsonSerializer', {
+  enumerable: true,
+  get: function () {
+    return StandardOpenAPIJsonSerializer;
+  }
+});
+Object.defineProperty(exports, 'StandardOpenAPISerializer', {
+  enumerable: true,
+  get: function () {
+    return StandardOpenAPISerializer;
+  }
+});
+Object.defineProperty(exports, 'clone', {
+  enumerable: true,
+  get: function () {
+    return clone;
+  }
+});
+Object.defineProperty(exports, 'fallbackORPCErrorMessage', {
+  enumerable: true,
+  get: function () {
+    return fallbackORPCErrorMessage;
+  }
+});
+Object.defineProperty(exports, 'fallbackORPCErrorStatus', {
+  enumerable: true,
+  get: function () {
+    return fallbackORPCErrorStatus;
+  }
+});
+Object.defineProperty(exports, 'findDeepMatches', {
+  enumerable: true,
+  get: function () {
+    return findDeepMatches;
+  }
+});
+Object.defineProperty(exports, 'getDynamicParams', {
+  enumerable: true,
+  get: function () {
+    return getDynamicParams;
+  }
+});
+Object.defineProperty(exports, 'isORPCErrorStatus', {
+  enumerable: true,
+  get: function () {
+    return isORPCErrorStatus;
+  }
+});
+Object.defineProperty(exports, 'isObject', {
+  enumerable: true,
+  get: function () {
+    return isObject;
+  }
+});
+Object.defineProperty(exports, 'once', {
+  enumerable: true,
+  get: function () {
+    return once;
+  }
+});
+Object.defineProperty(exports, 'standardizeHTTPPath', {
+  enumerable: true,
+  get: function () {
+    return standardizeHTTPPath;
+  }
+});
+Object.defineProperty(exports, 'stringifyJSON', {
+  enumerable: true,
+  get: function () {
+    return stringifyJSON;
+  }
+});
+Object.defineProperty(exports, 'toArray', {
+  enumerable: true,
+  get: function () {
+    return toArray;
+  }
+});
+Object.defineProperty(exports, 'toHttpPath', {
+  enumerable: true,
+  get: function () {
+    return toHttpPath;
+  }
+});
+Object.defineProperty(exports, 'tryDecodeURIComponent', {
+  enumerable: true,
+  get: function () {
+    return tryDecodeURIComponent;
+  }
+});
+Object.defineProperty(exports, 'value', {
+  enumerable: true,
+  get: function () {
+    return value;
+  }
+});
+//# sourceMappingURL=standard-v75BC6Z5.cjs.map