x402-proxy 0.10.6 → 0.10.9

package/dist/Credential-COZQnr1-.js

@@ -0,0 +1,2055 @@
+#!/usr/bin/env node
+import { t as keccak_256 } from "./sha3-CYkWM8Xa.js";
+import { t as hmac } from "./hmac-59IlS_by.js";
+import { t as sha256 } from "./sha256-FAs0qeni.js";
+import { B as _number, Cn as safeParseAsync, Dn as clone, Fn as normalizeParams, Gt as $ZodObject, H as _refine, Jt as $ZodPipe, K as _string, Lt as $ZodLiteral, On as defineLazy, Q as _unknown, Qt as $ZodString, Sn as safeParse, Tt as $ZodEnum, U as _regex, Un as $constructor, Ut as $ZodNumber, Zt as $ZodRecord, a as _boolean, an as $ZodUnion, bn as parse, d as _custom, en as $ZodTransform, on as $ZodUnknown, pt as $ZodBoolean, qt as $ZodOptional, tn as $ZodType, ut as $ZodArray, xn as parseAsync, xt as $ZodDiscriminatedUnion, yt as $ZodCustom } from "./api-CUzmQvTQ.js";
+//#region node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/mini/schemas.js
+const ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
+	if (!inst._zod) throw new Error("Uninitialized schema in ZodMiniType.");
+	$ZodType.init(inst, def);
+	inst.def = def;
+	inst.type = def.type;
+	inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse });
+	inst.safeParse = (data, params) => safeParse(inst, data, params);
+	inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
+	inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
+	inst.check = (...checks) => {
+		return inst.clone({
+			...def,
+			checks: [...def.checks ?? [], ...checks.map((ch) => typeof ch === "function" ? { _zod: {
+				check: ch,
+				def: { check: "custom" },
+				onattach: []
+			} } : ch)]
+		}, { parent: true });
+	};
+	inst.with = inst.check;
+	inst.clone = (_def, params) => clone(inst, _def, params);
+	inst.brand = () => inst;
+	inst.register = ((reg, meta) => {
+		reg.add(inst, meta);
+		return inst;
+	});
+	inst.apply = (fn) => fn(inst);
+});
+const ZodMiniString = /* @__PURE__ */ $constructor("ZodMiniString", (inst, def) => {
+	$ZodString.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function string(params) {
+	return _string(ZodMiniString, params);
+}
+const ZodMiniNumber = /* @__PURE__ */ $constructor("ZodMiniNumber", (inst, def) => {
+	$ZodNumber.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function number(params) {
+	return _number(ZodMiniNumber, params);
+}
+const ZodMiniBoolean = /* @__PURE__ */ $constructor("ZodMiniBoolean", (inst, def) => {
+	$ZodBoolean.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function boolean(params) {
+	return _boolean(ZodMiniBoolean, params);
+}
+const ZodMiniUnknown = /* @__PURE__ */ $constructor("ZodMiniUnknown", (inst, def) => {
+	$ZodUnknown.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function unknown() {
+	return _unknown(ZodMiniUnknown);
+}
+const ZodMiniArray = /* @__PURE__ */ $constructor("ZodMiniArray", (inst, def) => {
+	$ZodArray.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function array(element, params) {
+	return new ZodMiniArray({
+		type: "array",
+		element,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
+	$ZodObject.init(inst, def);
+	ZodMiniType.init(inst, def);
+	defineLazy(inst, "shape", () => def.shape);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function object(shape, params) {
+	return new ZodMiniObject({
+		type: "object",
+		shape: shape ?? {},
+		...normalizeParams(params)
+	});
+}
+const ZodMiniUnion = /* @__PURE__ */ $constructor("ZodMiniUnion", (inst, def) => {
+	$ZodUnion.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function union(options, params) {
+	return new ZodMiniUnion({
+		type: "union",
+		options,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodMiniDiscriminatedUnion", (inst, def) => {
+	$ZodDiscriminatedUnion.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function discriminatedUnion(discriminator, options, params) {
+	return new ZodMiniDiscriminatedUnion({
+		type: "union",
+		options,
+		discriminator,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniRecord = /* @__PURE__ */ $constructor("ZodMiniRecord", (inst, def) => {
+	$ZodRecord.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function record(keyType, valueType, params) {
+	return new ZodMiniRecord({
+		type: "record",
+		keyType,
+		valueType,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniEnum = /* @__PURE__ */ $constructor("ZodMiniEnum", (inst, def) => {
+	$ZodEnum.init(inst, def);
+	ZodMiniType.init(inst, def);
+	inst.options = Object.values(def.entries);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function _enum(values, params) {
+	return new ZodMiniEnum({
+		type: "enum",
+		entries: Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values,
+		...normalizeParams(params)
+	});
+}
+const ZodMiniLiteral = /* @__PURE__ */ $constructor("ZodMiniLiteral", (inst, def) => {
+	$ZodLiteral.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function literal(value, params) {
+	return new ZodMiniLiteral({
+		type: "literal",
+		values: Array.isArray(value) ? value : [value],
+		...normalizeParams(params)
+	});
+}
+const ZodMiniTransform = /* @__PURE__ */ $constructor("ZodMiniTransform", (inst, def) => {
+	$ZodTransform.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function transform(fn) {
+	return new ZodMiniTransform({
+		type: "transform",
+		transform: fn
+	});
+}
+const ZodMiniOptional = /* @__PURE__ */ $constructor("ZodMiniOptional", (inst, def) => {
+	$ZodOptional.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function optional(innerType) {
+	return new ZodMiniOptional({
+		type: "optional",
+		innerType
+	});
+}
+const ZodMiniPipe = /* @__PURE__ */ $constructor("ZodMiniPipe", (inst, def) => {
+	$ZodPipe.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function pipe(in_, out) {
+	return new ZodMiniPipe({
+		type: "pipe",
+		in: in_,
+		out
+	});
+}
+const ZodMiniCustom = /* @__PURE__ */ $constructor("ZodMiniCustom", (inst, def) => {
+	$ZodCustom.init(inst, def);
+	ZodMiniType.init(inst, def);
+});
+/* @__NO_SIDE_EFFECTS__ */
+function custom(fn, _params) {
+	return _custom(ZodMiniCustom, fn ?? (() => true), _params);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function refine(fn, _params = {}) {
+	return _refine(ZodMiniCustom, fn, _params);
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.10_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/version.js
+/** @internal */
+const version = "0.1.1";
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.10_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/internal/errors.js
+/** @internal */
+function getVersion() {
+	return version;
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.10_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Errors.js
+/**
+* Base error class inherited by all errors thrown by ox.
+*
+* @example
+* ```ts
+* import { Errors } from 'ox'
+* throw new Errors.BaseError('An error occurred')
+* ```
+*/
+var BaseError = class BaseError extends Error {
+	static setStaticOptions(options) {
+		BaseError.prototype.docsOrigin = options.docsOrigin;
+		BaseError.prototype.showVersion = options.showVersion;
+		BaseError.prototype.version = options.version;
+	}
+	constructor(shortMessage, options = {}) {
+		const details = (() => {
+			if (options.cause instanceof BaseError) {
+				if (options.cause.details) return options.cause.details;
+				if (options.cause.shortMessage) return options.cause.shortMessage;
+			}
+			if (options.cause && "details" in options.cause && typeof options.cause.details === "string") return options.cause.details;
+			if (options.cause?.message) return options.cause.message;
+			return options.details;
+		})();
+		const docsPath = (() => {
+			if (options.cause instanceof BaseError) return options.cause.docsPath || options.docsPath;
+			return options.docsPath;
+		})();
+		const docsBaseUrl = options.docsOrigin ?? BaseError.prototype.docsOrigin;
+		const docs = `${docsBaseUrl}${docsPath ?? ""}`;
+		const showVersion = Boolean(options.version ?? BaseError.prototype.showVersion);
+		const version = options.version ?? BaseError.prototype.version;
+		const message = [
+			shortMessage || "An error occurred.",
+			...options.metaMessages ? ["", ...options.metaMessages] : [],
+			...details || docsPath || showVersion ? [
+				"",
+				details ? `Details: ${details}` : void 0,
+				docsPath ? `See: ${docs}` : void 0,
+				showVersion ? `Version: ${version}` : void 0
+			] : []
+		].filter((x) => typeof x === "string").join("\n");
+		super(message, options.cause ? { cause: options.cause } : void 0);
+		Object.defineProperty(this, "details", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "docs", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "docsOrigin", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "docsPath", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "shortMessage", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "showVersion", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "version", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "cause", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "BaseError"
+		});
+		this.cause = options.cause;
+		this.details = details;
+		this.docs = docs;
+		this.docsOrigin = docsBaseUrl;
+		this.docsPath = docsPath;
+		this.shortMessage = shortMessage;
+		this.showVersion = showVersion;
+		this.version = version;
+	}
+	walk(fn) {
+		return walk(this, fn);
+	}
+};
+Object.defineProperty(BaseError, "defaultStaticOptions", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: {
+		docsOrigin: "https://oxlib.sh",
+		showVersion: false,
+		version: `ox@${getVersion()}`
+	}
+});
+BaseError.setStaticOptions(BaseError.defaultStaticOptions);
+/** @internal */
+function walk(err, fn) {
+	if (fn?.(err)) return err;
+	if (err && typeof err === "object" && "cause" in err && err.cause) return walk(err.cause, fn);
+	return fn ? null : err;
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.10_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/internal/bytes.js
+/** @internal */
+function assertSize$1(bytes, size_) {
+	if (size(bytes) > size_) throw new SizeOverflowError({
+		givenSize: size(bytes),
+		maxSize: size_
+	});
+}
+/** @internal */
+const charCodeMap = {
+	zero: 48,
+	nine: 57,
+	A: 65,
+	F: 70,
+	a: 97,
+	f: 102
+};
+/** @internal */
+function charCodeToBase16(char) {
+	if (char >= charCodeMap.zero && char <= charCodeMap.nine) return char - charCodeMap.zero;
+	if (char >= charCodeMap.A && char <= charCodeMap.F) return char - (charCodeMap.A - 10);
+	if (char >= charCodeMap.a && char <= charCodeMap.f) return char - (charCodeMap.a - 10);
+}
+/** @internal */
+function pad$1(bytes, options = {}) {
+	const { dir, size = 32 } = options;
+	if (size === 0) return bytes;
+	if (bytes.length > size) throw new SizeExceedsPaddingSizeError({
+		size: bytes.length,
+		targetSize: size,
+		type: "Bytes"
+	});
+	const paddedBytes = new Uint8Array(size);
+	for (let i = 0; i < size; i++) {
+		const padEnd = dir === "right";
+		paddedBytes[padEnd ? i : size - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+	}
+	return paddedBytes;
+}
+/** @internal */
+function trim(value, options = {}) {
+	const { dir = "left" } = options;
+	let data = value;
+	let sliceLength = 0;
+	for (let i = 0; i < data.length - 1; i++) if (data[dir === "left" ? i : data.length - i - 1].toString() === "0") sliceLength++;
+	else break;
+	data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
+	return data;
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.10_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/internal/hex.js
+/** @internal */
+function assertSize(hex, size_) {
+	if (size$1(hex) > size_) throw new SizeOverflowError$1({
+		givenSize: size$1(hex),
+		maxSize: size_
+	});
+}
+/** @internal */
+function assertStartOffset(value, start) {
+	if (typeof start === "number" && start > 0 && start > size$1(value) - 1) throw new SliceOffsetOutOfBoundsError({
+		offset: start,
+		position: "start",
+		size: size$1(value)
+	});
+}
+/** @internal */
+function assertEndOffset(value, start, end) {
+	if (typeof start === "number" && typeof end === "number" && size$1(value) !== end - start) throw new SliceOffsetOutOfBoundsError({
+		offset: end,
+		position: "end",
+		size: size$1(value)
+	});
+}
+/** @internal */
+function pad(hex_, options = {}) {
+	const { dir, size = 32 } = options;
+	if (size === 0) return hex_;
+	const hex = hex_.replace("0x", "");
+	if (hex.length > size * 2) throw new SizeExceedsPaddingSizeError$1({
+		size: Math.ceil(hex.length / 2),
+		targetSize: size,
+		type: "Hex"
+	});
+	return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size * 2, "0")}`;
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.10_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Json.js
+const bigIntSuffix = "#__bigint";
+/**
+* Serializes a value to a canonical JSON string as defined by
+* [RFC 8785 (JSON Canonicalization Scheme)](https://www.rfc-editor.org/rfc/rfc8785).
+*
+* - Object keys are sorted recursively by UTF-16 code unit comparison.
+* - Primitives are serialized per ECMAScript rules (no trailing zeros on numbers, etc.).
+* - No whitespace is inserted.
+*
+* @example
+* ```ts twoslash
+* import { Json } from 'ox'
+*
+* const json = Json.canonicalize({ b: 2, a: 1 })
+* // @log: '{"a":1,"b":2}'
+* ```
+*
+* @example
+* ```ts twoslash
+* import { Json } from 'ox'
+*
+* const json = Json.canonicalize({ z: [3, { y: 1, x: 2 }], a: 'hello' })
+* // @log: '{"a":"hello","z":[3,{"x":2,"y":1}]}'
+* ```
+*
+* @param value - The value to canonicalize.
+* @returns The canonical JSON string.
+*/
+function canonicalize(value) {
+	if (value === null || typeof value === "boolean" || typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new TypeError("Cannot canonicalize non-finite number");
+		return Object.is(value, -0) ? "0" : JSON.stringify(value);
+	}
+	if (typeof value === "bigint") throw new TypeError("Cannot canonicalize bigint");
+	if (Array.isArray(value)) return `[${value.map((item) => canonicalize(item)).join(",")}]`;
+	if (typeof value === "object") return `{${Object.keys(value).sort().reduce((acc, key) => {
+		const v = value[key];
+		if (v !== void 0) acc.push(`${JSON.stringify(key)}:${canonicalize(v)}`);
+		return acc;
+	}, []).join(",")}}`;
+}
+/**
+* Stringifies a value to its JSON representation, with support for `bigint`.
+*
+* @example
+* ```ts twoslash
+* import { Json } from 'ox'
+*
+* const json = Json.stringify({
+*   foo: 'bar',
+*   baz: 69420694206942069420694206942069420694206942069420n,
+* })
+* // @log: '{"foo":"bar","baz":"69420694206942069420694206942069420694206942069420#__bigint"}'
+* ```
+*
+* @param value - The value to stringify.
+* @param replacer - A function that transforms the results. It is passed the key and value of the property, and must return the value to be used in the JSON string. If this function returns `undefined`, the property is not included in the resulting JSON string.
+* @param space - A string or number that determines the indentation of the JSON string. If it is a number, it indicates the number of spaces to use as indentation; if it is a string (e.g. `'\t'`), it uses the string as the indentation character.
+* @returns The JSON string.
+*/
+function stringify(value, replacer, space) {
+	return JSON.stringify(value, (key, value) => {
+		if (typeof replacer === "function") return replacer(key, value);
+		if (typeof value === "bigint") return value.toString() + bigIntSuffix;
+		return value;
+	}, space);
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.10_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Hex.js
+const encoder$2 = /* @__PURE__ */ new TextEncoder();
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+/**
+* Asserts if the given value is {@link ox#Hex.Hex}.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.assert('abc')
+* // @error: InvalidHexValueTypeError:
+* // @error: Value `"abc"` of type `string` is an invalid hex type.
+* // @error: Hex types must be represented as `"0x\${string}"`.
+* ```
+*
+* @param value - The value to assert.
+* @param options - Options.
+*/
+function assert$1(value, options = {}) {
+	const { strict = false } = options;
+	if (!value) throw new InvalidHexTypeError(value);
+	if (typeof value !== "string") throw new InvalidHexTypeError(value);
+	if (strict) {
+		if (!/^0x[0-9a-fA-F]*$/.test(value)) throw new InvalidHexValueError(value);
+	}
+	if (!value.startsWith("0x")) throw new InvalidHexValueError(value);
+}
+/**
+* Concatenates two or more {@link ox#Hex.Hex}.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.concat('0x123', '0x456')
+* // @log: '0x123456'
+* ```
+*
+* @param values - The {@link ox#Hex.Hex} values to concatenate.
+* @returns The concatenated {@link ox#Hex.Hex} value.
+*/
+function concat(...values) {
+	return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
+}
+/**
+* Instantiates a {@link ox#Hex.Hex} value from a hex string or {@link ox#Bytes.Bytes} value.
+*
+* :::tip
+*
+* To instantiate from a **Boolean**, **String**, or **Number**, use one of the following:
+*
+* - `Hex.fromBoolean`
+*
+* - `Hex.fromString`
+*
+* - `Hex.fromNumber`
+*
+* :::
+*
+* @example
+* ```ts twoslash
+* import { Bytes, Hex } from 'ox'
+*
+* Hex.from('0x48656c6c6f20576f726c6421')
+* // @log: '0x48656c6c6f20576f726c6421'
+*
+* Hex.from(Bytes.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))
+* // @log: '0x48656c6c6f20576f726c6421'
+* ```
+*
+* @param value - The {@link ox#Bytes.Bytes} value to encode.
+* @returns The encoded {@link ox#Hex.Hex} value.
+*/
+function from$2(value) {
+	if (value instanceof Uint8Array) return fromBytes$1(value);
+	if (Array.isArray(value)) return fromBytes$1(new Uint8Array(value));
+	return value;
+}
+/**
+* Encodes a boolean into a {@link ox#Hex.Hex} value.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.fromBoolean(true)
+* // @log: '0x1'
+*
+* Hex.fromBoolean(false)
+* // @log: '0x0'
+*
+* Hex.fromBoolean(true, { size: 32 })
+* // @log: '0x0000000000000000000000000000000000000000000000000000000000000001'
+* ```
+*
+* @param value - The boolean value to encode.
+* @param options - Options.
+* @returns The encoded {@link ox#Hex.Hex} value.
+*/
+function fromBoolean(value, options = {}) {
+	const hex = `0x${Number(value)}`;
+	if (typeof options.size === "number") {
+		assertSize(hex, options.size);
+		return padLeft(hex, options.size);
+	}
+	return hex;
+}
+/**
+* Encodes a {@link ox#Bytes.Bytes} value into a {@link ox#Hex.Hex} value.
+*
+* @example
+* ```ts twoslash
+* import { Bytes, Hex } from 'ox'
+*
+* Hex.fromBytes(Bytes.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))
+* // @log: '0x48656c6c6f20576f726c6421'
+* ```
+*
+* @param value - The {@link ox#Bytes.Bytes} value to encode.
+* @param options - Options.
+* @returns The encoded {@link ox#Hex.Hex} value.
+*/
+function fromBytes$1(value, options = {}) {
+	let string = "";
+	for (let i = 0; i < value.length; i++) string += hexes[value[i]];
+	const hex = `0x${string}`;
+	if (typeof options.size === "number") {
+		assertSize(hex, options.size);
+		return padRight$1(hex, options.size);
+	}
+	return hex;
+}
+/**
+* Encodes a number or bigint into a {@link ox#Hex.Hex} value.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.fromNumber(420)
+* // @log: '0x1a4'
+*
+* Hex.fromNumber(420, { size: 32 })
+* // @log: '0x00000000000000000000000000000000000000000000000000000000000001a4'
+* ```
+*
+* @param value - The number or bigint value to encode.
+* @param options - Options.
+* @returns The encoded {@link ox#Hex.Hex} value.
+*/
+function fromNumber(value, options = {}) {
+	const { signed, size } = options;
+	const value_ = BigInt(value);
+	let maxValue;
+	if (size) if (signed) maxValue = (1n << BigInt(size) * 8n - 1n) - 1n;
+	else maxValue = 2n ** (BigInt(size) * 8n) - 1n;
+	else if (typeof value === "number") maxValue = BigInt(Number.MAX_SAFE_INTEGER);
+	const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
+	if (maxValue && value_ > maxValue || value_ < minValue) {
+		const suffix = typeof value === "bigint" ? "n" : "";
+		throw new IntegerOutOfRangeError({
+			max: maxValue ? `${maxValue}${suffix}` : void 0,
+			min: `${minValue}${suffix}`,
+			signed,
+			size,
+			value: `${value}${suffix}`
+		});
+	}
+	const hex = `0x${(signed && value_ < 0 ? BigInt.asUintN(size * 8, BigInt(value_)) : value_).toString(16)}`;
+	if (size) return padLeft(hex, size);
+	return hex;
+}
+/**
+* Encodes a string into a {@link ox#Hex.Hex} value.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+* Hex.fromString('Hello World!')
+* // '0x48656c6c6f20576f726c6421'
+*
+* Hex.fromString('Hello World!', { size: 32 })
+* // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
+* ```
+*
+* @param value - The string value to encode.
+* @param options - Options.
+* @returns The encoded {@link ox#Hex.Hex} value.
+*/
+function fromString$2(value, options = {}) {
+	return fromBytes$1(encoder$2.encode(value), options);
+}
+/**
+* Pads a {@link ox#Hex.Hex} value to the left with zero bytes until it reaches the given `size` (default: 32 bytes).
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.padLeft('0x1234', 4)
+* // @log: '0x00001234'
+* ```
+*
+* @param value - The {@link ox#Hex.Hex} value to pad.
+* @param size - The size (in bytes) of the output hex value.
+* @returns The padded {@link ox#Hex.Hex} value.
+*/
+function padLeft(value, size) {
+	return pad(value, {
+		dir: "left",
+		size
+	});
+}
+/**
+* Pads a {@link ox#Hex.Hex} value to the right with zero bytes until it reaches the given `size` (default: 32 bytes).
+*
+* @example
+* ```ts
+* import { Hex } from 'ox'
+*
+* Hex.padRight('0x1234', 4)
+* // @log: '0x12340000'
+* ```
+*
+* @param value - The {@link ox#Hex.Hex} value to pad.
+* @param size - The size (in bytes) of the output hex value.
+* @returns The padded {@link ox#Hex.Hex} value.
+*/
+function padRight$1(value, size) {
+	return pad(value, {
+		dir: "right",
+		size
+	});
+}
+/**
+* Generates a random {@link ox#Hex.Hex} value of the specified length.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* const hex = Hex.random(32)
+* // @log: '0x...'
+* ```
+*
+* @returns Random {@link ox#Hex.Hex} value.
+*/
+function random$1(length) {
+	return fromBytes$1(random(length));
+}
+/**
+* Returns a section of a {@link ox#Bytes.Bytes} value given a start/end bytes offset.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.slice('0x0123456789', 1, 4)
+* // @log: '0x234567'
+* ```
+*
+* @param value - The {@link ox#Hex.Hex} value to slice.
+* @param start - The start offset (in bytes).
+* @param end - The end offset (in bytes).
+* @param options - Options.
+* @returns The sliced {@link ox#Hex.Hex} value.
+*/
+function slice(value, start, end, options = {}) {
+	const { strict } = options;
+	assertStartOffset(value, start);
+	const value_ = `0x${value.replace("0x", "").slice((start ?? 0) * 2, (end ?? value.length) * 2)}`;
+	if (strict) assertEndOffset(value_, start, end);
+	return value_;
+}
+/**
+* Retrieves the size of a {@link ox#Hex.Hex} value (in bytes).
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.size('0xdeadbeef')
+* // @log: 4
+* ```
+*
+* @param value - The {@link ox#Hex.Hex} value to get the size of.
+* @returns The size of the {@link ox#Hex.Hex} value (in bytes).
+*/
+function size$1(value) {
+	return Math.ceil((value.length - 2) / 2);
+}
+/**
+* Decodes a {@link ox#Hex.Hex} value into a BigInt.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.toBigInt('0x1a4')
+* // @log: 420n
+*
+* Hex.toBigInt('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })
+* // @log: 420n
+* ```
+*
+* @param hex - The {@link ox#Hex.Hex} value to decode.
+* @param options - Options.
+* @returns The decoded BigInt.
+*/
+function toBigInt(hex, options = {}) {
+	const { signed } = options;
+	if (options.size) assertSize(hex, options.size);
+	const value = BigInt(hex);
+	if (!signed) return value;
+	const size = (hex.length - 2) / 2;
+	const max_unsigned = (1n << BigInt(size) * 8n) - 1n;
+	if (value <= max_unsigned >> 1n) return value;
+	return value - max_unsigned - 1n;
+}
+/**
+* Decodes a {@link ox#Hex.Hex} value into a {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* const data = Hex.toBytes('0x48656c6c6f20776f726c6421')
+* // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+* ```
+*
+* @param hex - The {@link ox#Hex.Hex} value to decode.
+* @param options - Options.
+* @returns The decoded {@link ox#Bytes.Bytes}.
+*/
+function toBytes$1(hex, options = {}) {
+	return fromHex(hex, options);
+}
+/**
+* Decodes a {@link ox#Hex.Hex} value into a number.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.toNumber('0x1a4')
+* // @log: 420
+*
+* Hex.toNumber('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })
+* // @log: 420
+* ```
+*
+* @param hex - The {@link ox#Hex.Hex} value to decode.
+* @param options - Options.
+* @returns The decoded number.
+*/
+function toNumber(hex, options = {}) {
+	const { signed, size } = options;
+	if (!signed && !size) return Number(hex);
+	return Number(toBigInt(hex, options));
+}
+/**
+* Decodes a {@link ox#Hex.Hex} value into a string.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.toString('0x48656c6c6f20576f726c6421')
+* // @log: 'Hello world!'
+*
+* Hex.toString('0x48656c6c6f20576f726c64210000000000000000000000000000000000000000', {
+*  size: 32,
+* })
+* // @log: 'Hello world'
+* ```
+*
+* @param hex - The {@link ox#Hex.Hex} value to decode.
+* @param options - Options.
+* @returns The decoded string.
+*/
+function toString$2(hex, options = {}) {
+	const { size } = options;
+	let bytes = fromHex(hex);
+	if (size) {
+		assertSize$1(bytes, size);
+		bytes = trimRight(bytes);
+	}
+	return new TextDecoder().decode(bytes);
+}
+/**
+* Checks if the given value is {@link ox#Hex.Hex}.
+*
+* @example
+* ```ts twoslash
+* import { Bytes, Hex } from 'ox'
+*
+* Hex.validate('0xdeadbeef')
+* // @log: true
+*
+* Hex.validate(Bytes.from([1, 2, 3]))
+* // @log: false
+* ```
+*
+* @param value - The value to check.
+* @param options - Options.
+* @returns `true` if the value is a {@link ox#Hex.Hex}, `false` otherwise.
+*/
+function validate$1(value, options = {}) {
+	const { strict = false } = options;
+	try {
+		assert$1(value, { strict });
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Thrown when the provided integer is out of range, and cannot be represented as a hex value.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.fromNumber(420182738912731283712937129)
+* // @error: Hex.IntegerOutOfRangeError: Number \`4.2018273891273126e+26\` is not in safe unsigned integer range (`0` to `9007199254740991`)
+* ```
+*/
+var IntegerOutOfRangeError = class extends BaseError {
+	constructor({ max, min, signed, size, value }) {
+		super(`Number \`${value}\` is not in safe${size ? ` ${size * 8}-bit` : ""}${signed ? " signed" : " unsigned"} integer range ${max ? `(\`${min}\` to \`${max}\`)` : `(above \`${min}\`)`}`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Hex.IntegerOutOfRangeError"
+		});
+	}
+};
+/**
+* Thrown when the provided value is not a valid hex type.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.assert(1)
+* // @error: Hex.InvalidHexTypeError: Value `1` of type `number` is an invalid hex type.
+* ```
+*/
+var InvalidHexTypeError = class extends BaseError {
+	constructor(value) {
+		super(`Value \`${typeof value === "object" ? stringify(value) : value}\` of type \`${typeof value}\` is an invalid hex type.`, { metaMessages: ["Hex types must be represented as `\"0x${string}\"`."] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Hex.InvalidHexTypeError"
+		});
+	}
+};
+/**
+* Thrown when the provided hex value is invalid.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.assert('0x0123456789abcdefg')
+* // @error: Hex.InvalidHexValueError: Value `0x0123456789abcdefg` is an invalid hex value.
+* // @error: Hex values must start with `"0x"` and contain only hexadecimal characters (0-9, a-f, A-F).
+* ```
+*/
+var InvalidHexValueError = class extends BaseError {
+	constructor(value) {
+		super(`Value \`${value}\` is an invalid hex value.`, { metaMessages: ["Hex values must start with `\"0x\"` and contain only hexadecimal characters (0-9, a-f, A-F)."] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Hex.InvalidHexValueError"
+		});
+	}
+};
+/**
+* Thrown when the size of the value exceeds the expected max size.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.fromString('Hello World!', { size: 8 })
+* // @error: Hex.SizeOverflowError: Size cannot exceed `8` bytes. Given size: `12` bytes.
+* ```
+*/
+var SizeOverflowError$1 = class extends BaseError {
+	constructor({ givenSize, maxSize }) {
+		super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Hex.SizeOverflowError"
+		});
+	}
+};
+/**
+* Thrown when the slice offset exceeds the bounds of the value.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.slice('0x0123456789', 6)
+* // @error: Hex.SliceOffsetOutOfBoundsError: Slice starting at offset `6` is out-of-bounds (size: `5`).
+* ```
+*/
+var SliceOffsetOutOfBoundsError = class extends BaseError {
+	constructor({ offset, position, size }) {
+		super(`Slice ${position === "start" ? "starting" : "ending"} at offset \`${offset}\` is out-of-bounds (size: \`${size}\`).`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Hex.SliceOffsetOutOfBoundsError"
+		});
+	}
+};
+/**
+* Thrown when the size of the value exceeds the pad size.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.padLeft('0x1a4e12a45a21323123aaa87a897a897a898a6567a578a867a98778a667a85a875a87a6a787a65a675a6a9', 32)
+* // @error: Hex.SizeExceedsPaddingSizeError: Hex size (`43`) exceeds padding size (`32`).
+* ```
+*/
+var SizeExceedsPaddingSizeError$1 = class extends BaseError {
+	constructor({ size, targetSize, type }) {
+		super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size}\`) exceeds padding size (\`${targetSize}\`).`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Hex.SizeExceedsPaddingSizeError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.10_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Bytes.js
+const decoder$1 = /* @__PURE__ */ new TextDecoder();
+const encoder$1 = /* @__PURE__ */ new TextEncoder();
+/**
+* Asserts if the given value is {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.assert('abc')
+* // @error: Bytes.InvalidBytesTypeError:
+* // @error: Value `"abc"` of type `string` is an invalid Bytes value.
+* // @error: Bytes values must be of type `Uint8Array`.
+* ```
+*
+* @param value - Value to assert.
+*/
+function assert(value) {
+	if (value instanceof Uint8Array) return;
+	if (!value) throw new InvalidBytesTypeError(value);
+	if (typeof value !== "object") throw new InvalidBytesTypeError(value);
+	if (!("BYTES_PER_ELEMENT" in value)) throw new InvalidBytesTypeError(value);
+	if (value.BYTES_PER_ELEMENT !== 1 || value.constructor.name !== "Uint8Array") throw new InvalidBytesTypeError(value);
+}
+/**
+* Instantiates a {@link ox#Bytes.Bytes} value from a `Uint8Array`, a hex string, or an array of unsigned 8-bit integers.
+*
+* :::tip
+*
+* To instantiate from a **Boolean**, **String**, or **Number**, use one of the following:
+*
+* - `Bytes.fromBoolean`
+*
+* - `Bytes.fromString`
+*
+* - `Bytes.fromNumber`
+*
+* :::
+*
+* @example
+* ```ts twoslash
+* // @noErrors
+* import { Bytes } from 'ox'
+*
+* const data = Bytes.from([255, 124, 5, 4])
+* // @log: Uint8Array([255, 124, 5, 4])
+*
+* const data = Bytes.from('0xdeadbeef')
+* // @log: Uint8Array([222, 173, 190, 239])
+* ```
+*
+* @param value - Value to convert.
+* @returns A {@link ox#Bytes.Bytes} instance.
+*/
+function from$1(value) {
+	if (value instanceof Uint8Array) return value;
+	if (typeof value === "string") return fromHex(value);
+	return fromArray(value);
+}
+/**
+* Converts an array of unsigned 8-bit integers into {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const data = Bytes.fromArray([255, 124, 5, 4])
+* // @log: Uint8Array([255, 124, 5, 4])
+* ```
+*
+* @param value - Value to convert.
+* @returns A {@link ox#Bytes.Bytes} instance.
+*/
+function fromArray(value) {
+	return value instanceof Uint8Array ? value : new Uint8Array(value);
+}
+/**
+* Encodes a {@link ox#Hex.Hex} value into {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const data = Bytes.fromHex('0x48656c6c6f20776f726c6421')
+* // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+* ```
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const data = Bytes.fromHex('0x48656c6c6f20776f726c6421', { size: 32 })
+* // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+* ```
+*
+* @param value - {@link ox#Hex.Hex} value to encode.
+* @param options - Encoding options.
+* @returns Encoded {@link ox#Bytes.Bytes}.
+*/
+function fromHex(value, options = {}) {
+	const { size } = options;
+	let hex = value;
+	if (size) {
+		assertSize(value, size);
+		hex = padRight$1(value, size);
+	}
+	let hexString = hex.slice(2);
+	if (hexString.length % 2) hexString = `0${hexString}`;
+	const length = hexString.length / 2;
+	const bytes = new Uint8Array(length);
+	for (let index = 0, j = 0; index < length; index++) {
+		const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
+		const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
+		if (nibbleLeft === void 0 || nibbleRight === void 0) throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+		bytes[index] = nibbleLeft << 4 | nibbleRight;
+	}
+	return bytes;
+}
+/**
+* Encodes a string into {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const data = Bytes.fromString('Hello world!')
+* // @log: Uint8Array([72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33])
+* ```
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const data = Bytes.fromString('Hello world!', { size: 32 })
+* // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+* ```
+*
+* @param value - String to encode.
+* @param options - Encoding options.
+* @returns Encoded {@link ox#Bytes.Bytes}.
+*/
+function fromString$1(value, options = {}) {
+	const { size } = options;
+	const bytes = encoder$1.encode(value);
+	if (typeof size === "number") {
+		assertSize$1(bytes, size);
+		return padRight(bytes, size);
+	}
+	return bytes;
+}
+/**
+* Pads a {@link ox#Bytes.Bytes} value to the right with zero bytes until it reaches the given `size` (default: 32 bytes).
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.padRight(Bytes.from([1]), 4)
+* // @log: Uint8Array([1, 0, 0, 0])
+* ```
+*
+* @param value - {@link ox#Bytes.Bytes} value to pad.
+* @param size - Size to pad the {@link ox#Bytes.Bytes} value to.
+* @returns Padded {@link ox#Bytes.Bytes} value.
+*/
+function padRight(value, size) {
+	return pad$1(value, {
+		dir: "right",
+		size
+	});
+}
+/**
+* Generates random {@link ox#Bytes.Bytes} of the specified length.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const bytes = Bytes.random(32)
+* // @log: Uint8Array([... x32])
+* ```
+*
+* @param length - Length of the random {@link ox#Bytes.Bytes} to generate.
+* @returns Random {@link ox#Bytes.Bytes} of the specified length.
+*/
+function random(length) {
+	return crypto.getRandomValues(new Uint8Array(length));
+}
+/**
+* Retrieves the size of a {@link ox#Bytes.Bytes} value.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.size(Bytes.from([1, 2, 3, 4]))
+* // @log: 4
+* ```
+*
+* @param value - {@link ox#Bytes.Bytes} value.
+* @returns Size of the {@link ox#Bytes.Bytes} value.
+*/
+function size(value) {
+	return value.length;
+}
+/**
+* Decodes a {@link ox#Bytes.Bytes} into a string.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const data = Bytes.toString(Bytes.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))
+* // @log: 'Hello world'
+* ```
+*
+* @param bytes - The {@link ox#Bytes.Bytes} to decode.
+* @param options - Options.
+* @returns Decoded string.
+*/
+function toString$1(bytes, options = {}) {
+	const { size } = options;
+	let bytes_ = bytes;
+	if (typeof size !== "undefined") {
+		assertSize$1(bytes_, size);
+		bytes_ = trimRight(bytes_);
+	}
+	return decoder$1.decode(bytes_);
+}
+/**
+* Trims trailing zeros from a {@link ox#Bytes.Bytes} value.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.trimRight(Bytes.from([1, 2, 3, 0, 0, 0, 0]))
+* // @log: Uint8Array([1, 2, 3])
+* ```
+*
+* @param value - {@link ox#Bytes.Bytes} value.
+* @returns Trimmed {@link ox#Bytes.Bytes} value.
+*/
+function trimRight(value) {
+	return trim(value, { dir: "right" });
+}
+/**
+* Checks if the given value is {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.validate('0x')
+* // @log: false
+*
+* Bytes.validate(Bytes.from([1, 2, 3]))
+* // @log: true
+* ```
+*
+* @param value - Value to check.
+* @returns `true` if the value is {@link ox#Bytes.Bytes}, otherwise `false`.
+*/
+function validate(value) {
+	try {
+		assert(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Thrown when a value cannot be converted to bytes.
+*
+* @example
+* ```ts twoslash
+* // @noErrors
+* import { Bytes } from 'ox'
+*
+* Bytes.from('foo')
+* // @error: Bytes.InvalidBytesTypeError: Value `foo` of type `string` is an invalid Bytes value.
+* ```
+*/
+var InvalidBytesTypeError = class extends BaseError {
+	constructor(value) {
+		super(`Value \`${typeof value === "object" ? stringify(value) : value}\` of type \`${typeof value}\` is an invalid Bytes value.`, { metaMessages: ["Bytes values must be of type `Bytes`."] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Bytes.InvalidBytesTypeError"
+		});
+	}
+};
+/**
+* Thrown when a size exceeds the maximum allowed size.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.fromString('Hello World!', { size: 8 })
+* // @error: Bytes.SizeOverflowError: Size cannot exceed `8` bytes. Given size: `12` bytes.
+* ```
+*/
+var SizeOverflowError = class extends BaseError {
+	constructor({ givenSize, maxSize }) {
+		super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Bytes.SizeOverflowError"
+		});
+	}
+};
+/**
+* Thrown when a the padding size exceeds the maximum allowed size.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.padLeft(Bytes.fromString('Hello World!'), 8)
+* // @error: [Bytes.SizeExceedsPaddingSizeError: Bytes size (`12`) exceeds padding size (`8`).
+* ```
+*/
+var SizeExceedsPaddingSizeError = class extends BaseError {
+	constructor({ size, targetSize, type }) {
+		super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size}\`) exceeds padding size (\`${targetSize}\`).`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Bytes.SizeExceedsPaddingSizeError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.10_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Hash.js
+/**
+* Calculates the [Keccak256](https://en.wikipedia.org/wiki/SHA-3) hash of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.
+*
+* This function is a re-export of `keccak_256` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.
+*
+* @example
+* ```ts twoslash
+* import { Hash } from 'ox'
+*
+* Hash.keccak256('0xdeadbeef')
+* // @log: '0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1'
+* ```
+*
+* @example
+* ### Calculate Hash of a String
+*
+* ```ts twoslash
+* import { Hash, Hex } from 'ox'
+*
+* Hash.keccak256(Hex.fromString('hello world'))
+* // @log: '0x3ea2f1d0abf3fc66cf29eebb70cbd4e7fe762ef8a09bcc06c8edf641230afec0'
+* ```
+*
+* @example
+* ### Configure Return Type
+*
+* ```ts twoslash
+* import { Hash } from 'ox'
+*
+* Hash.keccak256('0xdeadbeef', { as: 'Bytes' })
+* // @log: Uint8Array [...]
+* ```
+*
+* @param value - {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.
+* @param options - Options.
+* @returns Keccak256 hash.
+*/
+function keccak256(value, options = {}) {
+	const { as = typeof value === "string" ? "Hex" : "Bytes" } = options;
+	const bytes = keccak_256(from$1(value));
+	if (as === "Bytes") return bytes;
+	return fromBytes$1(bytes);
+}
+/**
+* Calculates the [HMAC-SHA256](https://en.wikipedia.org/wiki/HMAC) of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.
+*
+* This function is a re-export of `hmac` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.
+*
+* @example
+* ```ts twoslash
+* import { Hash, Hex } from 'ox'
+*
+* Hash.hmac256(Hex.fromString('key'), '0xdeadbeef')
+* // @log: '0x...'
+* ```
+*
+* @example
+* ### Configure Return Type
+*
+* ```ts twoslash
+* import { Hash, Hex } from 'ox'
+*
+* Hash.hmac256(Hex.fromString('key'), '0xdeadbeef', { as: 'Bytes' })
+* // @log: Uint8Array [...]
+* ```
+*
+* @param key - {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} key.
+* @param value - {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.
+* @param options - Options.
+* @returns HMAC-SHA256 hash.
+*/
+function hmac256(key, value, options = {}) {
+	const { as = typeof value === "string" ? "Hex" : "Bytes" } = options;
+	const bytes = hmac(sha256, from$1(key), from$1(value));
+	if (as === "Bytes") return bytes;
+	return fromBytes$1(bytes);
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.10_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Base64.js
+const encoder = /* @__PURE__ */ new TextEncoder();
+const decoder = /* @__PURE__ */ new TextDecoder();
+const integerToCharacter = /* @__PURE__ */ Object.fromEntries(Array.from("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").map((a, i) => [i, a.charCodeAt(0)]));
+const characterToInteger = {
+	...Object.fromEntries(Array.from("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").map((a, i) => [a.charCodeAt(0), i])),
+	["=".charCodeAt(0)]: 0,
+	["-".charCodeAt(0)]: 62,
+	["_".charCodeAt(0)]: 63
+};
+/**
+* Encodes a {@link ox#Bytes.Bytes} to a Base64-encoded string (with optional padding and/or URL-safe characters).
+*
+* @example
+* ```ts twoslash
+* import { Base64, Bytes } from 'ox'
+*
+* const value = Base64.fromBytes(Bytes.fromString('hello world'))
+* // @log: 'aGVsbG8gd29ybGQ='
+* ```
+*
+* @example
+* ### No Padding
+*
+* Turn off [padding of encoded data](https://datatracker.ietf.org/doc/html/rfc4648#section-3.2) with the `pad` option:
+*
+* ```ts twoslash
+* import { Base64, Bytes } from 'ox'
+*
+* const value = Base64.fromBytes(Bytes.fromString('hello world'), { pad: false })
+* // @log: 'aGVsbG8gd29ybGQ'
+* ```
+*
+* ### URL-safe Encoding
+*
+* Turn on [URL-safe encoding](https://datatracker.ietf.org/doc/html/rfc4648#section-5) (Base64 URL) with the `url` option:
+*
+* ```ts twoslash
+* import { Base64, Bytes } from 'ox'
+*
+* const value = Base64.fromBytes(Bytes.fromString('hello wod'), { url: true })
+* // @log: 'aGVsbG8gd29_77-9ZA=='
+* ```
+*
+* @param value - The byte array to encode.
+* @param options - Encoding options.
+* @returns The Base64 encoded string.
+*/
+function fromBytes(value, options = {}) {
+	const { pad = true, url = false } = options;
+	const encoded = new Uint8Array(Math.ceil(value.length / 3) * 4);
+	for (let i = 0, j = 0; j < value.length; i += 4, j += 3) {
+		const y = (value[j] << 16) + (value[j + 1] << 8) + (value[j + 2] | 0);
+		encoded[i] = integerToCharacter[y >> 18];
+		encoded[i + 1] = integerToCharacter[y >> 12 & 63];
+		encoded[i + 2] = integerToCharacter[y >> 6 & 63];
+		encoded[i + 3] = integerToCharacter[y & 63];
+	}
+	const k = value.length % 3;
+	const end = Math.floor(value.length / 3) * 4 + (k && k + 1);
+	let base64 = decoder.decode(new Uint8Array(encoded.buffer, 0, end));
+	if (pad && k === 1) base64 += "==";
+	if (pad && k === 2) base64 += "=";
+	if (url) base64 = base64.replaceAll("+", "-").replaceAll("/", "_");
+	return base64;
+}
+/**
+* Encodes a string to a Base64-encoded string (with optional padding and/or URL-safe characters).
+*
+* @example
+* ```ts twoslash
+* import { Base64 } from 'ox'
+*
+* const value = Base64.fromString('hello world')
+* // @log: 'aGVsbG8gd29ybGQ='
+* ```
+*
+* @example
+* ### No Padding
+*
+* Turn off [padding of encoded data](https://datatracker.ietf.org/doc/html/rfc4648#section-3.2) with the `pad` option:
+*
+* ```ts twoslash
+* import { Base64 } from 'ox'
+*
+* const value = Base64.fromString('hello world', { pad: false })
+* // @log: 'aGVsbG8gd29ybGQ'
+* ```
+*
+* ### URL-safe Encoding
+*
+* Turn on [URL-safe encoding](https://datatracker.ietf.org/doc/html/rfc4648#section-5) (Base64 URL) with the `url` option:
+*
+* ```ts twoslash
+* import { Base64 } from 'ox'
+*
+* const value = Base64.fromString('hello wod', { url: true })
+* // @log: 'aGVsbG8gd29_77-9ZA=='
+* ```
+*
+* @param value - The string to encode.
+* @param options - Encoding options.
+* @returns The Base64 encoded string.
+*/
+function fromString(value, options = {}) {
+	return fromBytes(fromString$1(value), options);
+}
+/**
+* Decodes a Base64-encoded string (with optional padding and/or URL-safe characters) to {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { Base64, Bytes } from 'ox'
+*
+* const value = Base64.toBytes('aGVsbG8gd29ybGQ=')
+* // @log: Uint8Array([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100])
+* ```
+*
+* @param value - The string, hex value, or byte array to encode.
+* @returns The Base64 decoded {@link ox#Bytes.Bytes}.
+*/
+function toBytes(value) {
+	const base64 = value.replace(/=+$/, "");
+	const size = base64.length;
+	const decoded = new Uint8Array(size + 3);
+	encoder.encodeInto(base64 + "===", decoded);
+	for (let i = 0, j = 0; i < base64.length; i += 4, j += 3) {
+		const x = (characterToInteger[decoded[i]] << 18) + (characterToInteger[decoded[i + 1]] << 12) + (characterToInteger[decoded[i + 2]] << 6) + characterToInteger[decoded[i + 3]];
+		decoded[j] = x >> 16;
+		decoded[j + 1] = x >> 8 & 255;
+		decoded[j + 2] = x & 255;
+	}
+	const decodedSize = (size >> 2) * 3 + (size % 4 && size % 4 - 1);
+	return new Uint8Array(decoded.buffer, 0, decodedSize);
+}
+/**
+* Decodes a Base64-encoded string (with optional padding and/or URL-safe characters) to a string.
+*
+* @example
+* ```ts twoslash
+* import { Base64 } from 'ox'
+*
+* const value = Base64.toString('aGVsbG8gd29ybGQ=')
+* // @log: 'hello world'
+* ```
+*
+* @param value - The string, hex value, or byte array to encode.
+* @returns The Base64 decoded string.
+*/
+function toString(value) {
+	return toString$1(toBytes(value));
+}
+//#endregion
+//#region node_modules/.pnpm/mppx@0.5.1_@modelcontextprotocol+sdk@1.28.0_zod@4.3.6__express@5.2.1_hono@4.12.9_openap_d8babfcabcc768186151f117bc0e35e5/node_modules/mppx/dist/PaymentRequest.js
+/**
+* Deserializes a base64url string to a request.
+*
+* @param encoded - The base64url-encoded string.
+* @returns The deserialized request.
+*
+* @example
+* ```ts
+* import { Request } from 'mppx'
+*
+* const request = Request.deserialize(serialized)
+* ```
+*/
+function deserialize$2(encoded) {
+	const json = toString(encoded);
+	return JSON.parse(json);
+}
+/**
+* Serializes a request to a base64url string.
+*
+* @param request - The request to serialize.
+* @returns A base64url-encoded string (no padding).
+*
+* @example
+* ```ts
+* import { Request } from 'mppx'
+*
+* const serialized = Request.serialize(request)
+* // => "eyJhbW91bnQiOiIxMDAwMDAwIiwiY3VycmVuY3kiOiIweC4uLiJ9"
+* ```
+*/
+function serialize$1(request) {
+	return fromString(canonicalize(request), {
+		pad: false,
+		url: true
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/mppx@0.5.1_@modelcontextprotocol+sdk@1.28.0_zod@4.3.6__express@5.2.1_hono@4.12.9_openap_d8babfcabcc768186151f117bc0e35e5/node_modules/mppx/dist/zod.js
+/** Numeric string amount (e.g., "1", "1.5", "1000000"). */
+function amount() {
+	return (/* @__PURE__ */ string()).check(_regex(/^\d+(\.\d+)?$/, "Invalid amount"));
+}
+/** ISO 8601 datetime string (e.g., "2025-01-06T12:00:00Z"). */
+function datetime() {
+	return (/* @__PURE__ */ string()).check(_regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/, "Invalid ISO 8601 datetime"));
+}
+/** Hex-encoded hash string (0x-prefixed, 64 hex chars). */
+function hash() {
+	return (/* @__PURE__ */ string()).check(_regex(/^0x[0-9a-fA-F]{64}$/, "Invalid hash"));
+}
+/** Hex-encoded signature string (0x-prefixed). */
+function signature() {
+	return (/* @__PURE__ */ string()).check(_regex(/^0x[0-9a-fA-F]+$/, "Invalid signature"));
+}
+//#endregion
+//#region node_modules/.pnpm/mppx@0.5.1_@modelcontextprotocol+sdk@1.28.0_zod@4.3.6__express@5.2.1_hono@4.12.9_openap_d8babfcabcc768186151f117bc0e35e5/node_modules/mppx/dist/Challenge.js
+/**
+* Schema for a payment challenge.
+*
+* @example
+* ```ts
+* import { Challenge } from 'mppx'
+*
+* const challenge = Challenge.Schema.parse(data)
+* ```
+*/
+const Schema = /* @__PURE__ */ object({
+	description: /* @__PURE__ */ optional(/* @__PURE__ */ string()),
+	digest: /* @__PURE__ */ optional((/* @__PURE__ */ string()).check(_regex(/^sha-256=/, "Invalid digest format"))),
+	expires: /* @__PURE__ */ optional(datetime()),
+	id: /* @__PURE__ */ string(),
+	intent: /* @__PURE__ */ string(),
+	method: /* @__PURE__ */ string(),
+	opaque: /* @__PURE__ */ optional(/* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ string())),
+	realm: /* @__PURE__ */ string(),
+	request: /* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ unknown())
+});
+/**
+* Creates a challenge from the given parameters.
+*
+* If `secretKey` option is provided, the challenge ID is computed as HMAC-SHA256
+* over the challenge parameters (realm|method|intent|request|expires|digest),
+* cryptographically binding the ID to its contents.
+*
+* @param parameters - Challenge parameters.
+* @param options - Optional settings including secretKey for HMAC-bound ID.
+* @returns A challenge.
+*
+* @example
+* ```ts
+* import { Challenge } from 'mppx'
+*
+* // With HMAC-bound ID (recommended for servers)
+* const challenge = Challenge.from(
+*   {
+*     realm: 'api.example.com',
+*     method: 'tempo',
+*     intent: 'charge',
+*     request: { amount: '1000000', currency: '0x...', recipient: '0x...' },
+*   },
+*   { secretKey: 'my-secret' },
+* )
+*
+* // With explicit ID
+* const challenge = Challenge.from({
+*   id: 'abc123',
+*   realm: 'api.example.com',
+*   method: 'tempo',
+*   intent: 'charge',
+*   request: { amount: '1000000', currency: '0x...', recipient: '0x...' },
+* })
+* ```
+*/
+function from(parameters, options) {
+	const { description, digest, meta, method: methodName, intent, realm, request, secretKey } = parameters;
+	const expires = parameters.expires;
+	const id = secretKey ? computeId({
+		...parameters,
+		expires,
+		...meta && { opaque: meta }
+	}, { secretKey }) : parameters.id;
+	return Schema.parse({
+		id,
+		realm,
+		method: methodName,
+		intent,
+		request,
+		...description && { description },
+		...digest && { digest },
+		...expires && { expires },
+		...meta && { opaque: meta }
+	});
+}
+/**
+* Deserializes a WWW-Authenticate header value to a challenge.
+*
+* @example
+* ```ts
+* import { Challenge } from 'mppx'
+*
+* const challenge = Challenge.deserialize(header)
+*
+* // With methods for type narrowing
+* const challenge = Challenge.deserialize(header, { methods })
+* ```
+*
+* @param header - The WWW-Authenticate header value.
+* @param options - Optional settings to narrow the challenge type.
+* @returns The deserialized challenge.
+*/
+function deserialize$1(value, options) {
+	const params = extractPaymentAuthParams(value);
+	if (!params) throw new Error("Missing Payment scheme.");
+	const { request, opaque, ...rest } = parseAuthParams(params);
+	if (!request) throw new Error("Missing request parameter.");
+	if (rest.method && !/^[a-z][a-z0-9:_-]*$/.test(rest.method)) throw new Error(`Invalid method: "${rest.method}". Must be lowercase per spec.`);
+	return from({
+		...rest,
+		request: deserialize$2(request),
+		...opaque && { meta: deserialize$2(opaque) }
+	}, options);
+}
+/** @internal Extracts the `Payment` scheme from a WWW-Authenticate value that may contain multiple schemes. */
+function extractPaymentAuthParams(header) {
+	const token = "Payment";
+	let inQuotes = false;
+	let escaped = false;
+	for (let i = 0; i < header.length; i++) {
+		const char = header[i];
+		if (inQuotes) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === "\"") inQuotes = false;
+			continue;
+		}
+		if (char === "\"") {
+			inQuotes = true;
+			continue;
+		}
+		if (!startsWithSchemeToken(header, i, token)) continue;
+		const prefix = header.slice(0, i);
+		if (prefix.trim() && !prefix.trimEnd().endsWith(",")) continue;
+		let paramsStart = i + 7;
+		while (paramsStart < header.length && /\s/.test(header[paramsStart] ?? "")) paramsStart++;
+		return header.slice(paramsStart);
+	}
+	return null;
+}
+/** @internal Parses auth-params with support for escaped quoted-string values. */
+function parseAuthParams(input) {
+	const result = {};
+	let i = 0;
+	while (i < input.length) {
+		while (i < input.length && /[\s,]/.test(input[i] ?? "")) i++;
+		if (i >= input.length) break;
+		const keyStart = i;
+		while (i < input.length && /[A-Za-z0-9_-]/.test(input[i] ?? "")) i++;
+		const key = input.slice(keyStart, i);
+		if (!key) throw new Error("Malformed auth-param.");
+		while (i < input.length && /\s/.test(input[i] ?? "")) i++;
+		if (input[i] !== "=") break;
+		i++;
+		while (i < input.length && /\s/.test(input[i] ?? "")) i++;
+		const [value, nextIndex] = readAuthParamValue(input, i);
+		i = nextIndex;
+		if (key in result) throw new Error(`Duplicate parameter: ${key}`);
+		result[key] = value;
+	}
+	return result;
+}
+/** @internal */
+function readAuthParamValue(input, start) {
+	if (input[start] === "\"") return readQuotedAuthParamValue(input, start + 1);
+	let i = start;
+	while (i < input.length && input[i] !== ",") i++;
+	return [input.slice(start, i).trim(), i];
+}
+/** @internal */
+function readQuotedAuthParamValue(input, start) {
+	let i = start;
+	let value = "";
+	let escaped = false;
+	while (i < input.length) {
+		const char = input[i];
+		i++;
+		if (escaped) {
+			value += char;
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (char === "\"") return [value, i];
+		value += char;
+	}
+	throw new Error("Unterminated quoted-string.");
+}
+/** @internal */
+function startsWithSchemeToken(value, index, token) {
+	if (!value.slice(index).toLowerCase().startsWith(token.toLowerCase())) return false;
+	const next = value[index + token.length];
+	return Boolean(next && /\s/.test(next));
+}
+/**
+* Extracts the challenge from a Headers object.
+*
+* @param headers - The HTTP headers.
+* @param options - Optional settings to narrow the challenge type.
+* @returns The deserialized challenge.
+*
+* @example
+* ```ts
+* import { Challenge } from 'mppx'
+*
+* const challenge = Challenge.fromHeaders(response.headers)
+*
+* // With methods for type narrowing
+* const challenge = Challenge.fromHeaders(response.headers, { methods })
+* ```
+*/
+function fromHeaders(headers, options) {
+	const header = headers.get("WWW-Authenticate");
+	if (!header) throw new Error("Missing WWW-Authenticate header.");
+	return deserialize$1(header, options);
+}
+/**
+* Extracts the challenge from a Response's WWW-Authenticate header.
+*
+* @param response - The HTTP response (must be 402 status).
+* @param options - Optional settings to narrow the challenge type.
+* @returns The deserialized challenge.
+*
+* @example
+* ```ts
+* import { Challenge } from 'mppx'
+*
+* const response = await fetch('/resource')
+* if (response.status === 402)
+*   const challenge = Challenge.fromResponse(response)
+*
+* // With methods for type narrowing
+* const challenge = Challenge.fromResponse(response, { methods })
+* ```
+*/
+function fromResponse(response, options) {
+	if (response.status !== 402) throw new Error("Response status is not 402.");
+	return fromHeaders(response.headers, options);
+}
+/**
+* Extracts all Payment challenges from a Response with potentially merged
+* `WWW-Authenticate` headers (multiple challenges in a single header value).
+*
+* @param response - The HTTP response (must be 402 status).
+* @param options - Optional settings to narrow the challenge type.
+* @returns An array of deserialized challenges.
+*
+* @example
+* ```ts
+* import { Challenge } from 'mppx'
+*
+* const response = await fetch('/resource')
+* if (response.status === 402) {
+*   const challenges = Challenge.fromResponseList(response)
+*   // challenges[0] => tempo/charge, challenges[1] => stripe/charge
+* }
+* ```
+*/
+function fromResponseList(response, options) {
+	if (response.status !== 402) throw new Error("Response status is not 402.");
+	return fromHeadersList(response.headers, options);
+}
+/**
+* Extracts all Payment challenges from a Headers object with potentially
+* merged `WWW-Authenticate` values.
+*
+* @param headers - The HTTP headers.
+* @param options - Optional settings to narrow the challenge type.
+* @returns An array of deserialized challenges.
+*/
+function fromHeadersList(headers, options) {
+	const header = headers.get("WWW-Authenticate");
+	if (!header) throw new Error("Missing WWW-Authenticate header.");
+	return deserializeList(header, options);
+}
+/**
+* Deserializes a `WWW-Authenticate` header value that may contain multiple
+* Payment challenges (comma-separated per RFC 9110 §11.6.1).
+*
+* @param value - The raw WWW-Authenticate header value.
+* @param options - Optional settings to narrow the challenge type.
+* @returns An array of deserialized challenges.
+*/
+function deserializeList(value, options) {
+	const starts = [];
+	for (const match of value.matchAll(/Payment\s+/gi)) starts.push(match.index);
+	if (starts.length === 0) throw new Error("No Payment schemes found.");
+	return starts.map((start, i) => {
+		const end = i + 1 < starts.length ? starts[i + 1] : value.length;
+		return deserialize$1(value.slice(start, end).replace(/,\s*$/, ""), options);
+	});
+}
+/** @internal Computes HMAC-SHA256 challenge ID from parameters. */
+function computeId(challenge, options) {
+	const input = [
+		challenge.realm,
+		challenge.method,
+		challenge.intent,
+		serialize$1(challenge.request),
+		challenge.expires ?? "",
+		challenge.digest ?? "",
+		challenge.opaque ? serialize$1(challenge.opaque) : ""
+	].join("|");
+	return fromBytes(hmac256(fromString$1(options.secretKey), fromString$1(input), { as: "Bytes" }), {
+		url: true,
+		pad: false
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/mppx@0.5.1_@modelcontextprotocol+sdk@1.28.0_zod@4.3.6__express@5.2.1_hono@4.12.9_openap_d8babfcabcc768186151f117bc0e35e5/node_modules/mppx/dist/Credential.js
+/**
+* Deserializes an Authorization header value to a credential.
+*
+* @param header - The Authorization header value.
+* @returns The deserialized credential.
+*
+* @example
+* ```ts
+* import { Credential } from 'mppx'
+*
+* const credential = Credential.deserialize(header)
+* ```
+*/
+function deserialize(value) {
+	const prefixMatch = value.match(/^Payment\s+(.+)$/i);
+	if (!prefixMatch?.[1]) throw new Error("Missing Payment scheme.");
+	try {
+		const json = toString(prefixMatch[1]);
+		const parsed = JSON.parse(json);
+		return {
+			challenge: Schema.parse({
+				...parsed.challenge,
+				request: deserialize$2(parsed.challenge.request)
+			}),
+			payload: parsed.payload,
+			...parsed.source && { source: parsed.source }
+		};
+	} catch {
+		throw new Error("Invalid base64url or JSON.");
+	}
+}
+/**
+* Serializes a credential to the Authorization header format.
+*
+* @param credential - The credential to serialize.
+* @returns A string suitable for the Authorization header value.
+*
+* @example
+* ```ts
+* import { Credential } from 'mppx'
+*
+* const header = Credential.serialize(credential)
+* // => 'Payment eyJjaGFsbGVuZ2UiOnsi...'
+* ```
+*/
+function serialize(credential) {
+	const wire = {
+		challenge: {
+			...credential.challenge,
+			request: serialize$1(credential.challenge.request)
+		},
+		payload: credential.payload,
+		...credential.source && { source: credential.source }
+	};
+	return `Payment ${fromString(JSON.stringify(wire), {
+		pad: false,
+		url: true
+	})}`;
+}
+/**
+* Extracts the `Payment` scheme from an Authorization header value
+* that may contain multiple schemes (comma-separated per RFC 9110).
+*
+* @param header - The raw Authorization header value.
+* @returns The `Payment ...` scheme string, or `null` if not found.
+*/
+function extractPaymentScheme(header) {
+	return header.split(",").map((s) => s.trim()).find((s) => /^Payment\s+/i.test(s)) ?? null;
+}
+//#endregion
+export { validate$1 as A, object as B, random$1 as C, toBytes$1 as D, toBigInt as E, boolean as F, transform as G, pipe as H, custom as I, union as K, discriminatedUnion as L, BaseError as M, _enum as N, toNumber as O, array as P, literal as R, padRight$1 as S, slice as T, refine as U, optional as V, string as W, fromBoolean as _, fromResponseList as a, fromString$2 as b, signature as c, keccak256 as d, fromString$1 as f, from$2 as g, concat as h, fromResponse as i, stringify as j, toString$2 as k, fromString as l, IntegerOutOfRangeError as m, extractPaymentScheme as n, amount as o, validate as p, serialize as r, hash as s, deserialize as t, toString as u, fromBytes$1 as v, size$1 as w, padLeft as x, fromNumber as y, number as z };