@poppinss/utils 7.0.0-next.3 → 7.0.0-next.5

package/build/main-aO4h7ygK.js

@@ -0,0 +1,514 @@
+import { n as __toESM, t as __commonJSMin } from "./chunk-BNZ4_A-W.js";
+var import_secure_json_parse = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const hasBuffer = typeof Buffer !== "undefined";
+	const suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+	const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+	function _parse(text, reviver, options) {
+		if (options == null) {
+			if (reviver !== null && typeof reviver === "object") {
+				options = reviver;
+				reviver = void 0;
+			}
+		}
+		if (hasBuffer && Buffer.isBuffer(text)) text = text.toString();
+		if (text && text.charCodeAt(0) === 65279) text = text.slice(1);
+		const obj = JSON.parse(text, reviver);
+		if (obj === null || typeof obj !== "object") return obj;
+		const protoAction = options && options.protoAction || "error";
+		const constructorAction = options && options.constructorAction || "error";
+		if (protoAction === "ignore" && constructorAction === "ignore") return obj;
+		if (protoAction !== "ignore" && constructorAction !== "ignore") {
+			if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) return obj;
+		} else if (protoAction !== "ignore" && constructorAction === "ignore") {
+			if (suspectProtoRx.test(text) === false) return obj;
+		} else if (suspectConstructorRx.test(text) === false) return obj;
+		return filter(obj, {
+			protoAction,
+			constructorAction,
+			safe: options && options.safe
+		});
+	}
+	function filter(obj, { protoAction = "error", constructorAction = "error", safe } = {}) {
+		let next = [obj];
+		while (next.length) {
+			const nodes = next;
+			next = [];
+			for (const node of nodes) {
+				if (protoAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+					if (safe === true) return null;
+					else if (protoAction === "error") throw new SyntaxError("Object contains forbidden prototype property");
+					delete node.__proto__;
+				}
+				if (constructorAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor === "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+					if (safe === true) return null;
+					else if (constructorAction === "error") throw new SyntaxError("Object contains forbidden prototype property");
+					delete node.constructor;
+				}
+				for (const key in node) {
+					const value = node[key];
+					if (value && typeof value === "object") next.push(value);
+				}
+			}
+		}
+		return obj;
+	}
+	function parse(text, reviver, options) {
+		const { stackTraceLimit } = Error;
+		Error.stackTraceLimit = 0;
+		try {
+			return _parse(text, reviver, options);
+		} finally {
+			Error.stackTraceLimit = stackTraceLimit;
+		}
+	}
+	function safeParse(text, reviver) {
+		const { stackTraceLimit } = Error;
+		Error.stackTraceLimit = 0;
+		try {
+			return _parse(text, reviver, { safe: true });
+		} catch {
+			return;
+		} finally {
+			Error.stackTraceLimit = stackTraceLimit;
+		}
+	}
+	module.exports = parse;
+	module.exports.default = parse;
+	module.exports.parse = parse;
+	module.exports.safeParse = safeParse;
+	module.exports.scan = filter;
+})))();
+function safeParse(jsonString, reviver) {
+	return (0, import_secure_json_parse.parse)(jsonString, reviver, {
+		protoAction: "remove",
+		constructorAction: "remove"
+	});
+}
+var import_safe_stable_stringify = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { hasOwnProperty } = Object.prototype;
+	const stringify = configure();
+	stringify.configure = configure;
+	stringify.stringify = stringify;
+	stringify.default = stringify;
+	exports.stringify = stringify;
+	exports.configure = configure;
+	module.exports = stringify;
+	const strEscapeSequencesRegExp = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
+	function strEscape(str) {
+		if (str.length < 5e3 && !strEscapeSequencesRegExp.test(str)) return `"${str}"`;
+		return JSON.stringify(str);
+	}
+	function sort(array, comparator) {
+		if (array.length > 200 || comparator) return array.sort(comparator);
+		for (let i = 1; i < array.length; i++) {
+			const currentValue = array[i];
+			let position = i;
+			while (position !== 0 && array[position - 1] > currentValue) {
+				array[position] = array[position - 1];
+				position--;
+			}
+			array[position] = currentValue;
+		}
+		return array;
+	}
+	const typedArrayPrototypeGetSymbolToStringTag = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Object.getPrototypeOf(new Int8Array())), Symbol.toStringTag).get;
+	function isTypedArrayWithEntries(value) {
+		return typedArrayPrototypeGetSymbolToStringTag.call(value) !== void 0 && value.length !== 0;
+	}
+	function stringifyTypedArray(array, separator, maximumBreadth) {
+		if (array.length < maximumBreadth) maximumBreadth = array.length;
+		const whitespace = separator === "," ? "" : " ";
+		let res = `"0":${whitespace}${array[0]}`;
+		for (let i = 1; i < maximumBreadth; i++) res += `${separator}"${i}":${whitespace}${array[i]}`;
+		return res;
+	}
+	function getCircularValueOption(options) {
+		if (hasOwnProperty.call(options, "circularValue")) {
+			const circularValue = options.circularValue;
+			if (typeof circularValue === "string") return `"${circularValue}"`;
+			if (circularValue == null) return circularValue;
+			if (circularValue === Error || circularValue === TypeError) return { toString() {
+				throw new TypeError("Converting circular structure to JSON");
+			} };
+			throw new TypeError("The \"circularValue\" argument must be of type string or the value null or undefined");
+		}
+		return "\"[Circular]\"";
+	}
+	function getDeterministicOption(options) {
+		let value;
+		if (hasOwnProperty.call(options, "deterministic")) {
+			value = options.deterministic;
+			if (typeof value !== "boolean" && typeof value !== "function") throw new TypeError("The \"deterministic\" argument must be of type boolean or comparator function");
+		}
+		return value === void 0 ? true : value;
+	}
+	function getBooleanOption(options, key) {
+		let value;
+		if (hasOwnProperty.call(options, key)) {
+			value = options[key];
+			if (typeof value !== "boolean") throw new TypeError(`The "${key}" argument must be of type boolean`);
+		}
+		return value === void 0 ? true : value;
+	}
+	function getPositiveIntegerOption(options, key) {
+		let value;
+		if (hasOwnProperty.call(options, key)) {
+			value = options[key];
+			if (typeof value !== "number") throw new TypeError(`The "${key}" argument must be of type number`);
+			if (!Number.isInteger(value)) throw new TypeError(`The "${key}" argument must be an integer`);
+			if (value < 1) throw new RangeError(`The "${key}" argument must be >= 1`);
+		}
+		return value === void 0 ? Infinity : value;
+	}
+	function getItemCount(number) {
+		if (number === 1) return "1 item";
+		return `${number} items`;
+	}
+	function getUniqueReplacerSet(replacerArray) {
+		const replacerSet = /* @__PURE__ */ new Set();
+		for (const value of replacerArray) if (typeof value === "string" || typeof value === "number") replacerSet.add(String(value));
+		return replacerSet;
+	}
+	function getStrictOption(options) {
+		if (hasOwnProperty.call(options, "strict")) {
+			const value = options.strict;
+			if (typeof value !== "boolean") throw new TypeError("The \"strict\" argument must be of type boolean");
+			if (value) return (value$1) => {
+				let message = `Object can not safely be stringified. Received type ${typeof value$1}`;
+				if (typeof value$1 !== "function") message += ` (${value$1.toString()})`;
+				throw new Error(message);
+			};
+		}
+	}
+	function configure(options) {
+		options = { ...options };
+		const fail = getStrictOption(options);
+		if (fail) {
+			if (options.bigint === void 0) options.bigint = false;
+			if (!("circularValue" in options)) options.circularValue = Error;
+		}
+		const circularValue = getCircularValueOption(options);
+		const bigint = getBooleanOption(options, "bigint");
+		const deterministic = getDeterministicOption(options);
+		const comparator = typeof deterministic === "function" ? deterministic : void 0;
+		const maximumDepth = getPositiveIntegerOption(options, "maximumDepth");
+		const maximumBreadth = getPositiveIntegerOption(options, "maximumBreadth");
+		function stringifyFnReplacer(key, parent, stack, replacer, spacer, indentation) {
+			let value = parent[key];
+			if (typeof value === "object" && value !== null && typeof value.toJSON === "function") value = value.toJSON(key);
+			value = replacer.call(parent, key, value);
+			switch (typeof value) {
+				case "string": return strEscape(value);
+				case "object": {
+					if (value === null) return "null";
+					if (stack.indexOf(value) !== -1) return circularValue;
+					let res = "";
+					let join = ",";
+					const originalIndentation = indentation;
+					if (Array.isArray(value)) {
+						if (value.length === 0) return "[]";
+						if (maximumDepth < stack.length + 1) return "\"[Array]\"";
+						stack.push(value);
+						if (spacer !== "") {
+							indentation += spacer;
+							res += `\n${indentation}`;
+							join = `,\n${indentation}`;
+						}
+						const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+						let i = 0;
+						for (; i < maximumValuesToStringify - 1; i++) {
+							const tmp$1 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+							res += tmp$1 !== void 0 ? tmp$1 : "null";
+							res += join;
+						}
+						const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+						res += tmp !== void 0 ? tmp : "null";
+						if (value.length - 1 > maximumBreadth) {
+							const removedKeys = value.length - maximumBreadth - 1;
+							res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+						}
+						if (spacer !== "") res += `\n${originalIndentation}`;
+						stack.pop();
+						return `[${res}]`;
+					}
+					let keys = Object.keys(value);
+					const keyLength = keys.length;
+					if (keyLength === 0) return "{}";
+					if (maximumDepth < stack.length + 1) return "\"[Object]\"";
+					let whitespace = "";
+					let separator = "";
+					if (spacer !== "") {
+						indentation += spacer;
+						join = `,\n${indentation}`;
+						whitespace = " ";
+					}
+					const maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+					if (deterministic && !isTypedArrayWithEntries(value)) keys = sort(keys, comparator);
+					stack.push(value);
+					for (let i = 0; i < maximumPropertiesToStringify; i++) {
+						const key$1 = keys[i];
+						const tmp = stringifyFnReplacer(key$1, value, stack, replacer, spacer, indentation);
+						if (tmp !== void 0) {
+							res += `${separator}${strEscape(key$1)}:${whitespace}${tmp}`;
+							separator = join;
+						}
+					}
+					if (keyLength > maximumBreadth) {
+						const removedKeys = keyLength - maximumBreadth;
+						res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
+						separator = join;
+					}
+					if (spacer !== "" && separator.length > 1) res = `\n${indentation}${res}\n${originalIndentation}`;
+					stack.pop();
+					return `{${res}}`;
+				}
+				case "number": return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+				case "boolean": return value === true ? "true" : "false";
+				case "undefined": return;
+				case "bigint": if (bigint) return String(value);
+				default: return fail ? fail(value) : void 0;
+			}
+		}
+		function stringifyArrayReplacer(key, value, stack, replacer, spacer, indentation) {
+			if (typeof value === "object" && value !== null && typeof value.toJSON === "function") value = value.toJSON(key);
+			switch (typeof value) {
+				case "string": return strEscape(value);
+				case "object": {
+					if (value === null) return "null";
+					if (stack.indexOf(value) !== -1) return circularValue;
+					const originalIndentation = indentation;
+					let res = "";
+					let join = ",";
+					if (Array.isArray(value)) {
+						if (value.length === 0) return "[]";
+						if (maximumDepth < stack.length + 1) return "\"[Array]\"";
+						stack.push(value);
+						if (spacer !== "") {
+							indentation += spacer;
+							res += `\n${indentation}`;
+							join = `,\n${indentation}`;
+						}
+						const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+						let i = 0;
+						for (; i < maximumValuesToStringify - 1; i++) {
+							const tmp$1 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+							res += tmp$1 !== void 0 ? tmp$1 : "null";
+							res += join;
+						}
+						const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+						res += tmp !== void 0 ? tmp : "null";
+						if (value.length - 1 > maximumBreadth) {
+							const removedKeys = value.length - maximumBreadth - 1;
+							res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+						}
+						if (spacer !== "") res += `\n${originalIndentation}`;
+						stack.pop();
+						return `[${res}]`;
+					}
+					stack.push(value);
+					let whitespace = "";
+					if (spacer !== "") {
+						indentation += spacer;
+						join = `,\n${indentation}`;
+						whitespace = " ";
+					}
+					let separator = "";
+					for (const key$1 of replacer) {
+						const tmp = stringifyArrayReplacer(key$1, value[key$1], stack, replacer, spacer, indentation);
+						if (tmp !== void 0) {
+							res += `${separator}${strEscape(key$1)}:${whitespace}${tmp}`;
+							separator = join;
+						}
+					}
+					if (spacer !== "" && separator.length > 1) res = `\n${indentation}${res}\n${originalIndentation}`;
+					stack.pop();
+					return `{${res}}`;
+				}
+				case "number": return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+				case "boolean": return value === true ? "true" : "false";
+				case "undefined": return;
+				case "bigint": if (bigint) return String(value);
+				default: return fail ? fail(value) : void 0;
+			}
+		}
+		function stringifyIndent(key, value, stack, spacer, indentation) {
+			switch (typeof value) {
+				case "string": return strEscape(value);
+				case "object": {
+					if (value === null) return "null";
+					if (typeof value.toJSON === "function") {
+						value = value.toJSON(key);
+						if (typeof value !== "object") return stringifyIndent(key, value, stack, spacer, indentation);
+						if (value === null) return "null";
+					}
+					if (stack.indexOf(value) !== -1) return circularValue;
+					const originalIndentation = indentation;
+					if (Array.isArray(value)) {
+						if (value.length === 0) return "[]";
+						if (maximumDepth < stack.length + 1) return "\"[Array]\"";
+						stack.push(value);
+						indentation += spacer;
+						let res$1 = `\n${indentation}`;
+						const join$1 = `,\n${indentation}`;
+						const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+						let i = 0;
+						for (; i < maximumValuesToStringify - 1; i++) {
+							const tmp$1 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+							res$1 += tmp$1 !== void 0 ? tmp$1 : "null";
+							res$1 += join$1;
+						}
+						const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+						res$1 += tmp !== void 0 ? tmp : "null";
+						if (value.length - 1 > maximumBreadth) {
+							const removedKeys = value.length - maximumBreadth - 1;
+							res$1 += `${join$1}"... ${getItemCount(removedKeys)} not stringified"`;
+						}
+						res$1 += `\n${originalIndentation}`;
+						stack.pop();
+						return `[${res$1}]`;
+					}
+					let keys = Object.keys(value);
+					const keyLength = keys.length;
+					if (keyLength === 0) return "{}";
+					if (maximumDepth < stack.length + 1) return "\"[Object]\"";
+					indentation += spacer;
+					const join = `,\n${indentation}`;
+					let res = "";
+					let separator = "";
+					let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+					if (isTypedArrayWithEntries(value)) {
+						res += stringifyTypedArray(value, join, maximumBreadth);
+						keys = keys.slice(value.length);
+						maximumPropertiesToStringify -= value.length;
+						separator = join;
+					}
+					if (deterministic) keys = sort(keys, comparator);
+					stack.push(value);
+					for (let i = 0; i < maximumPropertiesToStringify; i++) {
+						const key$1 = keys[i];
+						const tmp = stringifyIndent(key$1, value[key$1], stack, spacer, indentation);
+						if (tmp !== void 0) {
+							res += `${separator}${strEscape(key$1)}: ${tmp}`;
+							separator = join;
+						}
+					}
+					if (keyLength > maximumBreadth) {
+						const removedKeys = keyLength - maximumBreadth;
+						res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
+						separator = join;
+					}
+					if (separator !== "") res = `\n${indentation}${res}\n${originalIndentation}`;
+					stack.pop();
+					return `{${res}}`;
+				}
+				case "number": return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+				case "boolean": return value === true ? "true" : "false";
+				case "undefined": return;
+				case "bigint": if (bigint) return String(value);
+				default: return fail ? fail(value) : void 0;
+			}
+		}
+		function stringifySimple(key, value, stack) {
+			switch (typeof value) {
+				case "string": return strEscape(value);
+				case "object": {
+					if (value === null) return "null";
+					if (typeof value.toJSON === "function") {
+						value = value.toJSON(key);
+						if (typeof value !== "object") return stringifySimple(key, value, stack);
+						if (value === null) return "null";
+					}
+					if (stack.indexOf(value) !== -1) return circularValue;
+					let res = "";
+					const hasLength = value.length !== void 0;
+					if (hasLength && Array.isArray(value)) {
+						if (value.length === 0) return "[]";
+						if (maximumDepth < stack.length + 1) return "\"[Array]\"";
+						stack.push(value);
+						const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+						let i = 0;
+						for (; i < maximumValuesToStringify - 1; i++) {
+							const tmp$1 = stringifySimple(String(i), value[i], stack);
+							res += tmp$1 !== void 0 ? tmp$1 : "null";
+							res += ",";
+						}
+						const tmp = stringifySimple(String(i), value[i], stack);
+						res += tmp !== void 0 ? tmp : "null";
+						if (value.length - 1 > maximumBreadth) {
+							const removedKeys = value.length - maximumBreadth - 1;
+							res += `,"... ${getItemCount(removedKeys)} not stringified"`;
+						}
+						stack.pop();
+						return `[${res}]`;
+					}
+					let keys = Object.keys(value);
+					const keyLength = keys.length;
+					if (keyLength === 0) return "{}";
+					if (maximumDepth < stack.length + 1) return "\"[Object]\"";
+					let separator = "";
+					let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+					if (hasLength && isTypedArrayWithEntries(value)) {
+						res += stringifyTypedArray(value, ",", maximumBreadth);
+						keys = keys.slice(value.length);
+						maximumPropertiesToStringify -= value.length;
+						separator = ",";
+					}
+					if (deterministic) keys = sort(keys, comparator);
+					stack.push(value);
+					for (let i = 0; i < maximumPropertiesToStringify; i++) {
+						const key$1 = keys[i];
+						const tmp = stringifySimple(key$1, value[key$1], stack);
+						if (tmp !== void 0) {
+							res += `${separator}${strEscape(key$1)}:${tmp}`;
+							separator = ",";
+						}
+					}
+					if (keyLength > maximumBreadth) {
+						const removedKeys = keyLength - maximumBreadth;
+						res += `${separator}"...":"${getItemCount(removedKeys)} not stringified"`;
+					}
+					stack.pop();
+					return `{${res}}`;
+				}
+				case "number": return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+				case "boolean": return value === true ? "true" : "false";
+				case "undefined": return;
+				case "bigint": if (bigint) return String(value);
+				default: return fail ? fail(value) : void 0;
+			}
+		}
+		function stringify$2(value, replacer, space) {
+			if (arguments.length > 1) {
+				let spacer = "";
+				if (typeof space === "number") spacer = " ".repeat(Math.min(space, 10));
+				else if (typeof space === "string") spacer = space.slice(0, 10);
+				if (replacer != null) {
+					if (typeof replacer === "function") return stringifyFnReplacer("", { "": value }, [], replacer, spacer, "");
+					if (Array.isArray(replacer)) return stringifyArrayReplacer("", value, [], getUniqueReplacerSet(replacer), spacer, "");
+				}
+				if (spacer.length !== 0) return stringifyIndent("", value, [], spacer, "");
+			}
+			return stringifySimple("", value, []);
+		}
+		return stringify$2;
+	}
+})))(), 1);
+const configure = import_safe_stable_stringify.configure;
+import_safe_stable_stringify.default;
+import_safe_stable_stringify.default;
+const stringify = configure({
+	bigint: false,
+	circularValue: void 0,
+	deterministic: false
+});
+function jsonStringifyReplacer(replacer) {
+	return function(key, value) {
+		const val = replacer ? replacer.call(this, key, value) : value;
+		if (typeof val === "bigint") return val.toString();
+		return val;
+	};
+}
+function safeStringify(value, replacer, space) {
+	return stringify(value, jsonStringifyReplacer(replacer), space);
+}
+export { safeParse as n, safeStringify as t };

package/build/modules/assert.js

@@ -1,31 +1,18 @@
-// modules/assert.ts
-import { inspect } from "util";
-import { AssertionError } from "assert";
+import { inspect } from "node:util";
+import { AssertionError } from "node:assert";
 function assert(value, message) {
-  return assertExists(value, message);
+	return assertExists(value, message);
 }
 function assertExists(value, message) {
-  if (!value) {
-    throw new AssertionError({ message: message ?? "value is falsy" });
-  }
+	if (!value) throw new AssertionError({ message: message ?? "value is falsy" });
 }
 function assertUnreachable(x) {
-  throw new AssertionError({ message: `unreachable code executed: ${inspect(x)}` });
+	throw new AssertionError({ message: `unreachable code executed: ${inspect(x)}` });
 }
 function assertNotNull(value, message) {
-  if (value === null) {
-    throw new AssertionError({ message: message ?? "unexpected null value" });
-  }
+	if (value === null) throw new AssertionError({ message: message ?? "unexpected null value" });
 }
 function assertIsDefined(value, message) {
-  if (value === void 0) {
-    throw new AssertionError({ message: message ?? "unexpected undefined value" });
-  }
+	if (value === void 0) throw new AssertionError({ message: message ?? "unexpected undefined value" });
 }
-export {
-  assert,
-  assertExists,
-  assertIsDefined,
-  assertNotNull,
-  assertUnreachable
-};
+export { assert, assertExists, assertIsDefined, assertNotNull, assertUnreachable };

package/build/modules/base64.js

@@ -1,43 +1,26 @@
-// modules/base64.ts
 var Base64 = class {
-  encode(data, encoding) {
-    if (typeof data === "string") {
-      return Buffer.from(data, encoding).toString("base64");
-    }
-    if (Buffer.isBuffer(data)) {
-      return data.toString("base64");
-    }
-    return Buffer.from(data).toString("base64");
-  }
-  decode(encoded, encoding = "utf-8", strict = false) {
-    if (Buffer.isBuffer(encoded)) {
-      return encoded.toString(encoding);
-    }
-    const decoded = Buffer.from(encoded, "base64").toString(encoding);
-    const isInvalid = this.encode(decoded, encoding) !== encoded;
-    if (strict && isInvalid) {
-      throw new Error("Cannot decode malformed value");
-    }
-    return isInvalid ? null : decoded;
-  }
-  urlEncode(data, encoding) {
-    const encoded = typeof data === "string" ? this.encode(data, encoding) : this.encode(data);
-    return encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, "");
-  }
-  urlDecode(encoded, encoding = "utf-8", strict = false) {
-    if (Buffer.isBuffer(encoded)) {
-      return encoded.toString(encoding);
-    }
-    const decoded = Buffer.from(encoded, "base64").toString(encoding);
-    const isInvalid = this.urlEncode(decoded, encoding) !== encoded;
-    if (strict && isInvalid) {
-      throw new Error("Cannot urlDecode malformed value");
-    }
-    return isInvalid ? null : decoded;
-  }
-};
-var base64 = new Base64();
-var base64_default = base64;
-export {
-  base64_default as default
+	encode(data, encoding) {
+		if (typeof data === "string") return Buffer.from(data, encoding).toString("base64");
+		if (Buffer.isBuffer(data)) return data.toString("base64");
+		return Buffer.from(data).toString("base64");
+	}
+	decode(encoded, encoding = "utf-8", strict = false) {
+		if (Buffer.isBuffer(encoded)) return encoded.toString(encoding);
+		const decoded = Buffer.from(encoded, "base64").toString(encoding);
+		const isInvalid = this.encode(decoded, encoding) !== encoded;
+		if (strict && isInvalid) throw new Error("Cannot decode malformed value");
+		return isInvalid ? null : decoded;
+	}
+	urlEncode(data, encoding) {
+		return (typeof data === "string" ? this.encode(data, encoding) : this.encode(data)).replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, "");
+	}
+	urlDecode(encoded, encoding = "utf-8", strict = false) {
+		if (Buffer.isBuffer(encoded)) return encoded.toString(encoding);
+		const decoded = Buffer.from(encoded, "base64").toString(encoding);
+		const isInvalid = this.urlEncode(decoded, encoding) !== encoded;
+		if (strict && isInvalid) throw new Error("Cannot urlDecode malformed value");
+		return isInvalid ? null : decoded;
+	}
 };
+var base64_default = new Base64();
+export { base64_default as default };

package/build/modules/exception.js

@@ -1,12 +1,2 @@
-import {
-  Exception,
-  InvalidArgumentsException,
-  RuntimeException,
-  createError
-} from "../chunk-SKNTF5Q5.js";
-export {
-  Exception,
-  InvalidArgumentsException,
-  RuntimeException,
-  createError
-};
+import { i as createError, n as InvalidArgumentsException, r as RuntimeException, t as Exception } from "../exception-L7vjh-Gv.js";
+export { Exception, InvalidArgumentsException, RuntimeException, createError };