@astralbeam/sdk 0.17.0 → 0.19.0

package/dist/validate-BOw-BAyv.js

@@ -0,0 +1,140 @@
+//#region ../node_modules/.bun/jose@6.2.12/node_modules/jose/dist/webapi/lib/buffer_utils.js
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const strictDecoder = new TextDecoder("utf-8", { fatal: !0 });
+function concat(...buffers) {
+	const size = buffers.reduce((acc, { length }) => acc + length, 0), buf = new Uint8Array(size);
+	let i = 0;
+	for (const buffer of buffers) buf.set(buffer, i), i += buffer.length;
+	return buf;
+}
+const NON_ASCII = /[^\x00-\x7f]/;
+function encode$1(string) {
+	if (typeof string == "string" && string.length >= 128) {
+		if (NON_ASCII.test(string)) throw new TypeError("non-ASCII string encountered in encode()");
+		return encoder.encode(string);
+	}
+	const bytes = new Uint8Array(string.length);
+	for (let i = 0; i < string.length; i++) {
+		const code = string.charCodeAt(i);
+		if (code > 127) throw new TypeError("non-ASCII string encountered in encode()");
+		bytes[i] = code;
+	}
+	return bytes;
+}
+function encodeBase64(input, url = !1) {
+	if (Uint8Array.prototype.toBase64) return input.toBase64({
+		alphabet: url ? "base64url" : "base64",
+		omitPadding: url
+	});
+	const CHUNK_SIZE = 32768, arr = [];
+	for (let i = 0; i < input.length; i += CHUNK_SIZE) arr.push(String.fromCharCode.apply(null, input.subarray(i, i + CHUNK_SIZE)));
+	const encoded = btoa(arr.join(""));
+	return url ? encoded.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_") : encoded;
+}
+function decodeBase64(encoded, url = !1) {
+	if (Uint8Array.fromBase64) return Uint8Array.fromBase64(encoded, { alphabet: url ? "base64url" : "base64" });
+	if (url) {
+		if (encoded.includes("+") || encoded.includes("/")) throw new TypeError("Invalid base64url");
+		encoded = encoded.replace(/-/g, "+").replace(/_/g, "/");
+	}
+	const binary = atob(encoded), bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+//#endregion
+//#region ../node_modules/.bun/jose@6.2.12/node_modules/jose/dist/webapi/util/errors.js
+var JOSEError = class extends Error {
+	static code = "ERR_JOSE_GENERIC";
+	code = "ERR_JOSE_GENERIC";
+	constructor(message, options) {
+		super(message, options), this.name = this.constructor.name, Error.captureStackTrace?.(this, this.constructor);
+	}
+};
+var JOSENotSupported = class extends JOSEError {
+	static code = "ERR_JOSE_NOT_SUPPORTED";
+	code = "ERR_JOSE_NOT_SUPPORTED";
+};
+var JWSInvalid = class extends JOSEError {
+	static code = "ERR_JWS_INVALID";
+	code = "ERR_JWS_INVALID";
+};
+var JWTInvalid = class extends JOSEError {
+	static code = "ERR_JWT_INVALID";
+	code = "ERR_JWT_INVALID";
+};
+//#endregion
+//#region ../node_modules/.bun/jose@6.2.12/node_modules/jose/dist/webapi/util/base64url.js
+const invalid = "The input to be decoded is not correctly encoded.";
+function decode(input) {
+	try {
+		return decodeBase64(typeof input == "string" ? input : decoder.decode(input), !0);
+	} catch (cause) {
+		throw new TypeError(invalid, { cause });
+	}
+}
+function encode(input) {
+	return encodeBase64(typeof input == "string" ? encoder.encode(input) : input, !0);
+}
+//#endregion
+//#region ../node_modules/.bun/jose@6.2.12/node_modules/jose/dist/webapi/lib/validate.js
+function isObject(input) {
+	if (typeof input != "object" || input === null || Object.prototype.toString.call(input) !== "[object Object]") return !1;
+	const prototype = Object.getPrototypeOf(input);
+	return prototype === null || Object.getPrototypeOf(prototype) === null;
+}
+function isDisjoint(...headers) {
+	const parameters = /* @__PURE__ */ new Set();
+	for (const header of headers) if (header) for (const parameter of Object.keys(header)) {
+		if (parameters.has(parameter)) return !1;
+		parameters.add(parameter);
+	}
+	return !0;
+}
+function assertNotSet(value, name) {
+	if (value !== void 0) throw new TypeError(`${name} can only be called once`);
+}
+const JWS_RECOGNIZED = {
+	__proto__: null,
+	b64: !0
+};
+function validateCritDuplicates(Err, protectedHeader) {
+	const { crit } = protectedHeader ?? {};
+	if (Array.isArray(crit) && new Set(crit).size !== crit.length) throw new Err("\"crit\" (Critical) Header Parameter MUST NOT contain duplicate values");
+}
+function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) {
+	if (joseHeader.crit !== void 0 && protectedHeader?.crit === void 0) throw new Err("\"crit\" (Critical) Header Parameter MUST be integrity protected");
+	if (!protectedHeader || protectedHeader.crit === void 0) return [];
+	if (!Array.isArray(protectedHeader.crit) || protectedHeader.crit.length === 0 || protectedHeader.crit.some((input) => typeof input != "string" || input.length === 0)) throw new Err("\"crit\" (Critical) Header Parameter MUST be an array of non-empty strings when present");
+	const recognized = recognizedOption === void 0 ? recognizedDefault : {
+		__proto__: null,
+		...recognizedOption,
+		...recognizedDefault
+	};
+	for (const parameter of protectedHeader.crit) {
+		if (!(parameter in recognized)) throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
+		if (!Object.hasOwn(joseHeader, parameter) || joseHeader[parameter] === void 0) throw new Err(`Extension Header Parameter "${parameter}" is missing`);
+		if (recognized[parameter] && (!Object.hasOwn(protectedHeader, parameter) || protectedHeader[parameter] === void 0)) throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
+	}
+	return protectedHeader.crit;
+}
+function validateB64(protectedHeader, extensions) {
+	if (extensions.includes("b64")) {
+		const b64 = protectedHeader.b64;
+		if (typeof b64 != "boolean") throw new JWSInvalid("The \"b64\" (base64url-encode payload) Header Parameter must be a boolean");
+		return b64;
+	}
+	return !0;
+}
+function serializeJoseHeader(Err, header) {
+	let serialized, parsed;
+	try {
+		serialized = JSON.stringify(header), parsed = JSON.parse(serialized);
+	} catch (cause) {
+		throw new Err("JOSE Header is not valid JSON", { cause });
+	}
+	if (!isObject(parsed)) throw new Err("JOSE Header is not a JSON object");
+	return [parsed, serialized];
+}
+//#endregion
+export { strictDecoder as _, serializeJoseHeader as a, validateCritDuplicates as c, JOSENotSupported as d, JWSInvalid as f, encoder as g, encode$1 as h, isObject as i, decode as l, concat as m, assertNotSet as n, validateB64 as o, JWTInvalid as p, isDisjoint as r, validateCrit as s, JWS_RECOGNIZED as t, encode as u };