unjwt 0.6.1 → 0.7.0

package/dist/_chunks/libs/rou3.mjs

@@ -0,0 +1,5 @@
+const NullProtoObj = /* @__PURE__ */ (() => {
+	const e = function() {};
+	return e.prototype = Object.create(null), Object.freeze(e.prototype), e;
+})();
+export { NullProtoObj as t };

package/dist/_chunks/libs/unsecure.d.mts

@@ -0,0 +1,94 @@
+/**
+* Generate a Uint8Array of cryptographically secure random bytes.
+*
+* @param length Number of random bytes to generate.
+* @returns A Uint8Array filled with random bytes.
+*
+* @example
+* const key = secureRandomBytes(32); // 256-bit key material
+*/
+declare function secureRandomBytes(length: number): Uint8Array<ArrayBuffer>;
+/**
+* Shuffles an array in-place using the Fisher-Yates algorithm with a
+* cryptographically secure random number generator.
+* @template T
+* @param {Array<T>} array The array to shuffle.
+* @param {SecureRandomGenerator} [generator] - An optional random number generator to reuse.
+*
+* @description If you require to shuffle multiple times it is adviced to pass the `generator` parameter to avoid creating a new generator for each shuffle. (refer to `createSecureRandomGenerator()` factory)
+*
+* @returns {Array<T>} The shuffled array.
+*/
+/**
+* Parse JSON while stripping prototype-pollution vectors during parsing.
+*
+* Uses a reviver to drop own properties named `__proto__`, `prototype`, or
+* `constructor` before they can be assigned. For nested payloads this is
+* cheaper than parsing first and sanitizing after, and it guarantees no
+* unsanitized object ever exists.
+*
+* @param json The JSON text to parse.
+* @returns The parsed value with dangerous keys stripped.
+* @throws {SyntaxError} If `json` is not valid JSON.
+*
+* @example
+* const payload = safeJsonParse<{ user: { name: string } }>(untrustedInput);
+*/
+declare function safeJsonParse<T = any>(json: string): T;
+/**
+* Remove prototype-pollution vectors from a plain record in-place.
+*
+* Strips own properties named `__proto__`, `prototype`, and `constructor`
+* recursively through nested objects and arrays. Cycle-safe.
+*
+* Returns the same reference for convenience. Use {@link sanitizeObjectCopy}
+* if you need a deep copy with the original preserved.
+*/
+declare function sanitizeObject<T extends Record<string, unknown> | undefined>(obj: T): T;
+/**
+* Return a sanitized deep copy of `obj`. The input is never mutated.
+*
+* Dangerous keys (`__proto__`, `prototype`, `constructor`) are stripped
+* recursively. The returned structure consists of plain objects (rooted on
+* `Object.prototype`) and arrays. Cycle-safe: circular references in the
+* input are preserved in the output (pointing at the copied node, not the
+* original reference).
+*
+* Non-object / undefined inputs are returned unchanged.
+*/
+declare function sanitizeObjectCopy<T extends Record<string, unknown> | undefined>(obj: T): T;
+/**
+* Base64 encoding. Accepts `string` or raw bytes; throws `TypeError` on
+* `null`/`undefined`. Empty strings and empty `Uint8Array` return `""`.
+*/
+declare function base64Encode(data: Uint8Array<ArrayBuffer> | string): string;
+/**
+* Base64 URL-safe encoding (no padding). Accepts `string` or raw bytes;
+* throws `TypeError` on `null`/`undefined`. Empty inputs return `""`.
+*/
+declare function base64UrlEncode(data: Uint8Array<ArrayBuffer> | string): string;
+declare function base64Decode<T extends DecodeReturnAs>(data: string | Uint8Array<ArrayBuffer>, options: {
+  returnAs: T;
+}): T extends "string" ? string : Uint8Array<ArrayBuffer>;
+declare function base64Decode(data: string): string;
+declare function base64Decode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function base64UrlDecode<T extends DecodeReturnAs>(data: string | Uint8Array<ArrayBuffer>, options: {
+  returnAs: T;
+}): T extends "string" ? string : Uint8Array<ArrayBuffer>;
+declare function base64UrlDecode(data: string): string;
+declare function base64UrlDecode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+/**
+* Hex encoding. Accepts `string` or raw bytes; throws `TypeError` on
+* `null`/`undefined`. Empty strings and empty `Uint8Array` return `""`.
+*/
+/**
+* Output-shape option shared by `hexDecode`, `base64Decode`, `base64UrlDecode`,
+* and `base32Decode`. Decoders mirror their input type when this is omitted:
+* `string` input decodes to `string`, `Uint8Array` input decodes to `Uint8Array`.
+*
+* `"bytes"` is an alias for `"uint8array"`.
+*/
+type DecodeReturnAs = "string" | "uint8array" | "bytes";
+declare const textEncoder: TextEncoder;
+declare const textDecoder: TextDecoder;
+export { textDecoder as a, sanitizeObject as c, base64UrlEncode as i, sanitizeObjectCopy as l, base64Encode as n, textEncoder as o, base64UrlDecode as r, safeJsonParse as s, base64Decode as t, secureRandomBytes as u };

package/dist/_chunks/libs/unsecure.mjs

@@ -0,0 +1,144 @@
+function safeJsonParse(json) {
+	return JSON.parse(json, _jsonReviver);
+}
+function sanitizeObject(obj) {
+	if (!obj || typeof obj !== "object") return obj;
+	const seen = /* @__PURE__ */ new WeakSet();
+	seen.add(obj);
+	_sanitizeInPlace(obj, seen);
+	return obj;
+}
+function sanitizeObjectCopy(obj) {
+	if (!obj || typeof obj !== "object") return obj;
+	return _sanitizeCopy(obj, /* @__PURE__ */ new WeakMap());
+}
+const _jsonReviver = (key, value) => _isDangerousKey(key) ? void 0 : value;
+function _isDangerousKey(key) {
+	return key === "__proto__" || key === "prototype" || key === "constructor";
+}
+function _sanitizeInPlace(current, seen) {
+	if (Array.isArray(current)) {
+		for (let i = 0; i < current.length; i++) {
+			const v = current[i];
+			if (v !== null && typeof v === "object" && !seen.has(v)) {
+				seen.add(v);
+				_sanitizeInPlace(v, seen);
+			}
+		}
+		return;
+	}
+	const keys = Object.keys(current);
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		if (_isDangerousKey(key)) {
+			delete current[key];
+			continue;
+		}
+		const v = current[key];
+		if (v !== null && typeof v === "object" && !seen.has(v)) {
+			seen.add(v);
+			_sanitizeInPlace(v, seen);
+		}
+	}
+}
+function _sanitizeCopy(current, seen) {
+	const existing = seen.get(current);
+	if (existing !== void 0) return existing;
+	if (Array.isArray(current)) {
+		const out = [];
+		seen.set(current, out);
+		for (let i = 0; i < current.length; i++) {
+			const v = current[i];
+			out.push(v !== null && typeof v === "object" ? _sanitizeCopy(v, seen) : v);
+		}
+		return out;
+	}
+	const out = {};
+	seen.set(current, out);
+	const keys = Object.keys(current);
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		if (_isDangerousKey(key)) continue;
+		const v = current[key];
+		out[key] = v !== null && typeof v === "object" ? _sanitizeCopy(v, seen) : v;
+	}
+	return out;
+}
+const _Buffer = /* @__PURE__ */ (() => {
+	try {
+		return globalThis.Buffer;
+	} catch {
+		return;
+	}
+})();
+const _hasBuffer = typeof _Buffer?.from === "function";
+function _toBuffer(data) {
+	return data instanceof Uint8Array ? _Buffer.from(data.buffer, data.byteOffset, data.byteLength) : _Buffer.from(data);
+}
+const _hasToBase64 = !_hasBuffer && typeof Uint8Array.prototype.toBase64 === "function";
+const _hasFromBase64 = !_hasBuffer && typeof Uint8Array.fromBase64 === "function";
+const _b64UrlEncOpts = /* @__PURE__ */ Object.freeze({
+	alphabet: "base64url",
+	omitPadding: true
+});
+const _b64UrlDecOpts = /* @__PURE__ */ Object.freeze({ alphabet: "base64url" });
+function base64Encode(data) {
+	if (data == null) throw new TypeError("base64Encode: data must be a string or Uint8Array.");
+	if (_hasBuffer) return _toBuffer(data).toString("base64");
+	const encodedData = data instanceof Uint8Array ? data : textEncoder.encode(data);
+	if (_hasToBase64) return encodedData.toBase64();
+	return btoa(String.fromCodePoint(...encodedData));
+}
+function base64UrlEncode(data) {
+	if (data == null) throw new TypeError("base64UrlEncode: data must be a string or Uint8Array.");
+	if (_hasBuffer) return _toBuffer(data).toString("base64url");
+	const encodedData = data instanceof Uint8Array ? data : textEncoder.encode(data);
+	if (_hasToBase64) return encodedData.toBase64(_b64UrlEncOpts);
+	return btoa(String.fromCodePoint(...encodedData)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64Decode(data, options) {
+	if (data == null) throw new TypeError("base64Decode: data must be a string or Uint8Array.");
+	const isBufferInput = data instanceof Uint8Array;
+	const str = isBufferInput ? textDecoder.decode(data) : data;
+	const decodeToString = (options?.returnAs ?? (isBufferInput ? "uint8array" : "string")) === "string";
+	if (!str) return decodeToString ? "" : new Uint8Array(0);
+	if (_hasBuffer) {
+		const buf = _Buffer.from(str, "base64");
+		return decodeToString ? buf.toString("utf8") : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+	}
+	const decoded = _hasFromBase64 ? Uint8Array.fromBase64(str) : Uint8Array.from(atob(str), (b) => b.codePointAt(0));
+	return decodeToString ? textDecoder.decode(decoded) : decoded;
+}
+function base64UrlDecode(data, options) {
+	if (data == null) throw new TypeError("base64UrlDecode: data must be a string or Uint8Array.");
+	const isBufferInput = data instanceof Uint8Array;
+	let str = isBufferInput ? textDecoder.decode(data) : data;
+	const decodeToString = (options?.returnAs ?? (isBufferInput ? "uint8array" : "string")) === "string";
+	if (!str) return decodeToString ? "" : new Uint8Array(0);
+	if (_hasBuffer) {
+		const buf = _Buffer.from(str, "base64url");
+		return decodeToString ? buf.toString("utf8") : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+	}
+	let decoded;
+	if (_hasFromBase64) decoded = Uint8Array.fromBase64(str, _b64UrlDecOpts);
+	else {
+		str = str.replace(/-/g, "+").replace(/_/g, "/");
+		while (str.length % 4) str += "=";
+		decoded = Uint8Array.from(atob(str), (b) => b.codePointAt(0));
+	}
+	return decodeToString ? textDecoder.decode(decoded) : decoded;
+}
+!_hasBuffer && Uint8Array.prototype.toHex;
+!_hasBuffer && Uint8Array.fromHex;
+const textEncoder = /* @__PURE__ */ new TextEncoder();
+const textDecoder = /* @__PURE__ */ new TextDecoder();
+function secureRandomBytes(length) {
+	if (!Number.isInteger(length) || length < 0) throw new RangeError("length must be a non-negative integer.");
+	const bytes = new Uint8Array(length);
+	if (length > 0) for (let offset = 0; offset < length; offset += 65536) {
+		const chunk = bytes.subarray(offset, Math.min(offset + 65536, length));
+		crypto.getRandomValues(chunk);
+	}
+	return bytes;
+}
+export { base64UrlEncode as a, safeJsonParse as c, base64UrlDecode as i, sanitizeObject as l, base64Decode as n, textDecoder as o, base64Encode as r, textEncoder as s, secureRandomBytes as t, sanitizeObjectCopy as u };