@luffysolution/pi-scholar 0.1.1 → 0.2.0

package/node_modules/jose/dist/webapi/key/generate_secret.js

@@ -1,36 +0,0 @@
-import { unsupportedAlg, algArgument } from "../lib/key_algorithm.js";
-import { validateExtractableOption } from "../lib/key_options.js";
-async function generateSecret(alg, options) {
-  const extractable = validateExtractableOption(options?.extractable);
-  let length, algorithm, keyUsages;
-  switch (alg) {
-    case "HS256":
-    case "HS384":
-    case "HS512":
-      length = +alg.slice(-3), algorithm = { name: "HMAC", hash: `SHA-${length}`, length }, keyUsages = ["sign", "verify"];
-      break;
-    case "A128CBC-HS256":
-    case "A192CBC-HS384":
-    case "A256CBC-HS512":
-      return crypto.getRandomValues(new Uint8Array(+alg.slice(-3) >> 3));
-    case "A128KW":
-    case "A192KW":
-    case "A256KW":
-      length = +alg.slice(1, 4), algorithm = { name: "AES-KW", length }, keyUsages = ["wrapKey", "unwrapKey"];
-      break;
-    case "A128GCMKW":
-    case "A192GCMKW":
-    case "A256GCMKW":
-    case "A128GCM":
-    case "A192GCM":
-    case "A256GCM":
-      length = +alg.slice(1, 4), algorithm = { name: "AES-GCM", length }, keyUsages = ["encrypt", "decrypt"];
-      break;
-    default:
-      unsupportedAlg(algArgument);
-  }
-  return crypto.subtle.generateKey(algorithm, extractable ?? !1, keyUsages);
-}
-export {
-  generateSecret
-};

package/node_modules/jose/dist/webapi/key/import.js

@@ -1,57 +0,0 @@
-import { decode as decodeBase64URL } from "../util/base64url.js";
-import { fromSPKI, fromPKCS8, fromX509 } from "../lib/asn1.js";
-import { jwkToKey } from "../lib/jwk_to_key.js";
-import { keyAlgorithm } from "../lib/key_algorithm.js";
-import { JOSENotSupported } from "../util/errors.js";
-import { isObject } from "../lib/type_checks.js";
-import { validateExtractableOption } from "../lib/key_options.js";
-import { normalizeJwk } from "../lib/jwk_metadata.js";
-async function importSPKI(spki, alg, options) {
-  if (typeof spki != "string" || spki.indexOf("-----BEGIN PUBLIC KEY-----") !== 0)
-    throw new TypeError('"spki" must be SPKI formatted string');
-  return fromSPKI(spki, alg, options);
-}
-async function importX509(x509, alg, options) {
-  if (typeof x509 != "string" || x509.indexOf("-----BEGIN CERTIFICATE-----") !== 0)
-    throw new TypeError('"x509" must be X.509 formatted string');
-  return fromX509(x509, alg, options);
-}
-async function importPKCS8(pkcs8, alg, options) {
-  if (typeof pkcs8 != "string" || pkcs8.indexOf("-----BEGIN PRIVATE KEY-----") !== 0)
-    throw new TypeError('"pkcs8" must be PKCS#8 formatted string');
-  return fromPKCS8(pkcs8, alg, options);
-}
-async function importJWK(jwk, alg, options) {
-  if (!isObject(jwk))
-    throw new TypeError("JWK must be an object");
-  const normalized = normalizeJwk(jwk), extractable = validateExtractableOption(options?.extractable), { alg: jwkAlg } = normalized;
-  alg ??= jwkAlg;
-  const ext = extractable ?? normalized.ext;
-  if (normalized.kty !== "oct" && !alg)
-    throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
-  switch (normalized.kty) {
-    case "oct":
-      if (typeof normalized.k != "string")
-        throw new TypeError('missing "k" (Key Value) Parameter value');
-      return decodeBase64URL(normalized.k);
-    case "AKP": {
-      if (typeof jwkAlg != "string" || !jwkAlg)
-        throw new TypeError('missing "alg" (Algorithm) Parameter value');
-      if (alg !== jwkAlg)
-        throw new TypeError("JWK alg and alg option value mismatch");
-      return jwkToKey(keyAlgorithm(alg), { ...normalized, ext });
-    }
-    case "RSA":
-    case "EC":
-    case "OKP":
-      return jwkToKey(keyAlgorithm(alg), { ...normalized, alg, ext });
-    default:
-      throw new JOSENotSupported('Unsupported "kty" (Key Type) Parameter value');
-  }
-}
-export {
-  importJWK,
-  importPKCS8,
-  importSPKI,
-  importX509
-};

package/node_modules/jose/dist/webapi/lib/asn1.js

@@ -1,140 +0,0 @@
-import { invalidKeyInput } from "./invalid_key_input.js";
-import { encodeBase64, decodeBase64 } from "../lib/base64.js";
-import { JOSENotSupported } from "../util/errors.js";
-import { keyAlgorithm, unsupportedAlg, algArgument } from "./key_algorithm.js";
-import { isCryptoKey, isKeyObject } from "./is_key_like.js";
-import { validateExtractableOption } from "./key_options.js";
-const formatPEM = (b64, descriptor) => {
-  const newlined = (b64.match(/.{1,64}/g) || []).join(`
-`);
-  return `-----BEGIN ${descriptor}-----
-${newlined}
------END ${descriptor}-----`;
-}, genericExport = async (keyType, keyFormat, key) => {
-  if (isKeyObject(key)) {
-    if (key.type !== keyType)
-      throw new TypeError(`key is not a ${keyType} key`);
-    return key.export({ format: "pem", type: keyFormat });
-  }
-  if (!isCryptoKey(key))
-    throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject"));
-  if (!key.extractable)
-    throw new TypeError("CryptoKey is not extractable");
-  if (key.type !== keyType)
-    throw new TypeError(`key is not a ${keyType} key`);
-  return formatPEM(encodeBase64(new Uint8Array(await crypto.subtle.exportKey(keyFormat, key))), `${keyType.toUpperCase()} KEY`);
-}, toSPKI = (key) => genericExport("public", "spki", key), toPKCS8 = (key) => genericExport("private", "pkcs8", key), bytesEqual = (a, b) => {
-  if (a.byteLength !== b.length)
-    return !1;
-  for (let i = 0; i < a.byteLength; i++)
-    if (a[i] !== b[i])
-      return !1;
-  return !0;
-}, createASN1State = (data) => ({ data, pos: 0 }), readByte = (state) => {
-  const byte = state.data[state.pos++];
-  if (byte === void 0)
-    throw new Error("Unexpected end of ASN.1 input");
-  return byte;
-}, parseLength = (state) => {
-  const first = readByte(state);
-  if (first & 128) {
-    const lengthOfLen = first & 127;
-    let length = 0;
-    for (let i = 0; i < lengthOfLen; i++)
-      length = length << 8 | readByte(state);
-    return length;
-  }
-  return first;
-}, skipElement = (state, count = 1) => {
-  for (; count-- > 0; ) {
-    state.pos++;
-    const length = parseLength(state);
-    state.pos += length;
-  }
-}, expectTag = (state, expectedTag, errorMessage) => {
-  if (readByte(state) !== expectedTag)
-    throw new Error(errorMessage);
-}, getSubarray = (state, length) => {
-  if (length < 0 || state.pos + length > state.data.length)
-    throw new Error("Unexpected end of ASN.1 input");
-  const result = state.data.subarray(state.pos, state.pos + length);
-  return state.pos += length, result;
-}, parseAlgorithmOID = (state) => {
-  expectTag(state, 6, "Expected algorithm OID");
-  const oidLen = parseLength(state);
-  return getSubarray(state, oidLen);
-};
-function parseKeyHeader(state, keyFormat) {
-  if (expectTag(state, 48, `Invalid ${keyFormat === "spki" ? "SPKI" : "PKCS#8"} structure`), parseLength(state), keyFormat === "pkcs8") {
-    expectTag(state, 2, "Expected version field");
-    const length = parseLength(state);
-    state.pos += length;
-  }
-  expectTag(state, 48, "Expected algorithm identifier"), parseLength(state);
-}
-const parseECAlgorithmIdentifier = (state) => {
-  const algOid = parseAlgorithmOID(state);
-  if (bytesEqual(algOid, [43, 101, 110]))
-    return "X25519";
-  if (!bytesEqual(algOid, [42, 134, 72, 206, 61, 2, 1]))
-    throw new Error("Unsupported key algorithm");
-  expectTag(state, 6, "Expected curve OID");
-  const curveOidLen = parseLength(state), curveOid = getSubarray(state, curveOidLen);
-  if (bytesEqual(curveOid, [42, 134, 72, 206, 61, 3, 1, 7]))
-    return "P-256";
-  if (bytesEqual(curveOid, [43, 129, 4, 0, 34]))
-    return "P-384";
-  if (bytesEqual(curveOid, [43, 129, 4, 0, 35]))
-    return "P-521";
-  throw new Error("Unsupported named curve");
-}, genericImport = async (keyFormat, keyData, alg, options) => {
-  const extractable = validateExtractableOption(options?.extractable), entry = keyAlgorithm(alg, algArgument);
-  entry.secret && unsupportedAlg(algArgument);
-  const isPublic = keyFormat === "spki";
-  let algorithm;
-  if (entry.resolve)
-    try {
-      const state = createASN1State(keyData);
-      parseKeyHeader(state, keyFormat), algorithm = entry.resolve({ crv: parseECAlgorithmIdentifier(state) });
-    } catch {
-      throw new JOSENotSupported("Invalid or unsupported key format");
-    }
-  else
-    algorithm = entry.subtle;
-  return crypto.subtle.importKey(keyFormat, keyData, algorithm, extractable ?? isPublic, entry.usages[isPublic ? 0 : 1]);
-}, processPEMData = (pem, pattern) => decodeBase64(pem.replace(pattern, "")), fromPKCS8 = (pem, alg, options) => {
-  const keyData = processPEMData(pem, /(?:-----(?:BEGIN|END) PRIVATE KEY-----|\s)/g);
-  return genericImport("pkcs8", keyData, alg, options);
-}, fromSPKI = (pem, alg, options) => {
-  const keyData = processPEMData(pem, /(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g);
-  return genericImport("spki", keyData, alg, options);
-};
-function spkiFromX509(buf) {
-  const state = createASN1State(buf);
-  expectTag(state, 48, "Invalid certificate structure");
-  const certificateLength = parseLength(state);
-  if (certificateLength < 0 || state.pos + certificateLength > state.data.length)
-    throw new Error("Unexpected end of ASN.1 input");
-  expectTag(state, 48, "Invalid tbsCertificate structure"), parseLength(state), buf[state.pos] === 160 ? skipElement(state, 6) : skipElement(state, 5);
-  const spkiStart = state.pos;
-  expectTag(state, 48, "Invalid SPKI structure");
-  const spkiContentLen = parseLength(state);
-  return buf.subarray(spkiStart, spkiStart + spkiContentLen + (state.pos - spkiStart));
-}
-const fromX509 = (pem, alg, options) => {
-  let spki;
-  try {
-    const certificate = processPEMData(pem, /(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g);
-    spki = spkiFromX509(certificate);
-  } catch (cause) {
-    throw new TypeError("Failed to parse the X.509 certificate", { cause });
-  }
-  return genericImport("spki", spki, alg, options);
-};
-export {
-  fromPKCS8,
-  fromSPKI,
-  fromX509,
-  toPKCS8,
-  toSPKI
-};

package/node_modules/jose/dist/webapi/lib/base64.js

@@ -1,20 +0,0 @@
-function encodeBase64(input) {
-  if (Uint8Array.prototype.toBase64)
-    return input.toBase64();
-  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)));
-  return btoa(arr.join(""));
-}
-function decodeBase64(encoded) {
-  if (Uint8Array.fromBase64)
-    return Uint8Array.fromBase64(encoded);
-  const binary = atob(encoded), bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++)
-    bytes[i] = binary.charCodeAt(i);
-  return bytes;
-}
-export {
-  decodeBase64,
-  encodeBase64
-};

package/node_modules/jose/dist/webapi/lib/buffer_utils.js

@@ -1,40 +0,0 @@
-const encoder = new TextEncoder(), decoder = new TextDecoder(), strictDecoder = new TextDecoder("utf-8", { fatal: !0 }), MAX_INT32 = 2 ** 32;
-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;
-}
-function writeUInt32BE(buf, value, offset) {
-  if (value < 0 || value >= MAX_INT32)
-    throw new RangeError(`value must be >= 0 and <= ${MAX_INT32 - 1}. Received ${value}`);
-  buf.set([value >>> 24, value >>> 16, value >>> 8, value & 255], offset);
-}
-function uint64be(value) {
-  const high = Math.floor(value / MAX_INT32), low = value % MAX_INT32, buf = new Uint8Array(8);
-  return writeUInt32BE(buf, high, 0), writeUInt32BE(buf, low, 4), buf;
-}
-function uint32be(value) {
-  const buf = new Uint8Array(4);
-  return writeUInt32BE(buf, value), buf;
-}
-function 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;
-}
-export {
-  concat,
-  decoder,
-  encode,
-  encoder,
-  strictDecoder,
-  uint32be,
-  uint64be
-};

package/node_modules/jose/dist/webapi/lib/content_encryption.js

@@ -1,98 +0,0 @@
-import { concat, uint64be } from "./buffer_utils.js";
-import { checkCryptoKey } from "./crypto_key.js";
-import { invalidKeyInput } from "./invalid_key_input.js";
-import { JWEDecryptionFailed, JWEInvalid } from "../util/errors.js";
-import { isCryptoKey } from "./is_key_like.js";
-const generateCek = (enc) => crypto.getRandomValues(new Uint8Array(enc.cekBits >> 3));
-function checkCekLength(cek, expected) {
-  const actual = cek.byteLength << 3;
-  if (actual !== expected)
-    throw new JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
-}
-const generateIv = (enc) => crypto.getRandomValues(new Uint8Array(enc.ivBits >> 3));
-function checkIvLength(enc, iv) {
-  if (iv.length << 3 !== enc.ivBits)
-    throw new JWEInvalid("Invalid Initialization Vector length");
-}
-async function cbcKeySetup(enc, cek, usage) {
-  if (!(cek instanceof Uint8Array))
-    throw new TypeError(invalidKeyInput(cek, "Uint8Array"));
-  const keySize = enc.cekBits >> 1, encKey = await crypto.subtle.importKey("raw", cek.subarray(keySize >> 3), "AES-CBC", !1, [usage]), macKey = await crypto.subtle.importKey("raw", cek.subarray(0, keySize >> 3), {
-    hash: `SHA-${keySize << 1}`,
-    name: "HMAC"
-  }, !1, ["sign"]);
-  return [encKey, macKey, keySize];
-}
-async function cbcHmacTag(macKey, macData, keySize) {
-  return new Uint8Array((await crypto.subtle.sign("HMAC", macKey, macData)).slice(0, keySize >> 3));
-}
-async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
-  const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, "encrypt"), ciphertext = new Uint8Array(await crypto.subtle.encrypt({
-    iv,
-    name: "AES-CBC"
-  }, encKey, plaintext)), macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8)), tag = await cbcHmacTag(macKey, macData, keySize);
-  return { ciphertext, tag, iv };
-}
-async function timingSafeEqual(a, b) {
-  const algorithm = { name: "HMAC", hash: "SHA-256" }, key = await crypto.subtle.generateKey(algorithm, !1, ["sign", "verify"]), aHmac = await crypto.subtle.sign(algorithm, key, a);
-  return crypto.subtle.verify(algorithm, key, aHmac, b);
-}
-async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
-  const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, "decrypt"), macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8)), expectedTag = await cbcHmacTag(macKey, macData, keySize);
-  try {
-    if (await timingSafeEqual(tag, expectedTag))
-      return new Uint8Array(await crypto.subtle.decrypt({ iv, name: "AES-CBC" }, encKey, ciphertext));
-  } catch {
-  }
-  throw new JWEDecryptionFailed();
-}
-async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
-  const encKey = cek instanceof Uint8Array ? await crypto.subtle.importKey("raw", cek, "AES-GCM", !1, [
-    "encrypt"
-  ]) : (checkCryptoKey(cek, enc.subtle, "encrypt"), cek), encrypted = new Uint8Array(await crypto.subtle.encrypt({
-    additionalData: aad,
-    iv,
-    name: "AES-GCM",
-    tagLength: 128
-  }, encKey, plaintext)), tag = encrypted.slice(-16);
-  return { ciphertext: encrypted.slice(0, -16), tag, iv };
-}
-async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
-  const encKey = cek instanceof Uint8Array ? await crypto.subtle.importKey("raw", cek, "AES-GCM", !1, [
-    "decrypt"
-  ]) : (checkCryptoKey(cek, enc.subtle, "decrypt"), cek);
-  try {
-    return new Uint8Array(await crypto.subtle.decrypt({
-      additionalData: aad,
-      iv,
-      name: "AES-GCM",
-      tagLength: 128
-    }, encKey, concat(ciphertext, tag)));
-  } catch {
-    throw new JWEDecryptionFailed();
-  }
-}
-async function encrypt(enc, plaintext, cek, iv, aad) {
-  if (!isCryptoKey(cek) && !(cek instanceof Uint8Array))
-    throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key"));
-  return iv ? checkIvLength(enc, iv) : iv = generateIv(enc), cek instanceof Uint8Array && checkCekLength(cek, enc.cekBits), enc.cbc ? cbcEncrypt(enc, plaintext, cek, iv, aad) : gcmEncrypt(enc, plaintext, cek, iv, aad);
-}
-async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
-  if (!isCryptoKey(cek) && !(cek instanceof Uint8Array))
-    throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key"));
-  if (!iv)
-    throw new JWEInvalid("JWE Initialization Vector missing");
-  if (!tag)
-    throw new JWEInvalid("JWE Authentication Tag missing");
-  if (!enc.cbc && tag.length !== 16)
-    throw new JWEInvalid("Invalid Authentication Tag length");
-  return checkIvLength(enc, iv), cek instanceof Uint8Array && checkCekLength(cek, enc.cekBits), enc.cbc ? cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) : gcmDecrypt(enc, cek, ciphertext, iv, tag, aad);
-}
-export {
-  checkCekLength,
-  checkIvLength,
-  decrypt,
-  encrypt,
-  generateCek,
-  generateIv
-};

package/node_modules/jose/dist/webapi/lib/crypto_key.js

@@ -1,27 +0,0 @@
-const unusable = (name, prop = "algorithm.name") => new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
-function checkUsage(key, usage) {
-  if (usage && !key.usages.includes(usage))
-    throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
-}
-function checkModulusLength(alg, key) {
-  const { modulusLength } = key.algorithm;
-  if (typeof modulusLength != "number" || modulusLength < 2048)
-    throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
-}
-function checkCryptoKey(key, expected, usage) {
-  const algorithm = key.algorithm;
-  if (algorithm.name !== expected.name)
-    throw unusable(expected.name);
-  if (expected.hash && algorithm.hash?.name !== expected.hash)
-    throw unusable(expected.hash, "algorithm.hash");
-  if (expected.namedCurve && algorithm.namedCurve !== expected.namedCurve)
-    throw unusable(expected.namedCurve, "algorithm.namedCurve");
-  if (expected.length !== void 0 && algorithm.length !== expected.length)
-    throw unusable(expected.length, "algorithm.length");
-  checkUsage(key, usage);
-}
-export {
-  checkCryptoKey,
-  checkModulusLength,
-  checkUsage
-};

package/node_modules/jose/dist/webapi/lib/deflate.js

@@ -1,50 +0,0 @@
-import { JOSENotSupported, JWEInvalid } from "../util/errors.js";
-import { concat } from "./buffer_utils.js";
-function validateZip(joseHeader, protectedHeader) {
-  if (joseHeader.zip !== void 0 && joseHeader.zip !== "DEF")
-    throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
-  if (joseHeader.zip !== void 0 && !protectedHeader?.zip)
-    throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
-}
-function supported(name) {
-  if (typeof globalThis[name] > "u")
-    throw new JOSENotSupported(`JWE "zip" (Compression Algorithm) Header Parameter requires the ${name} API.`);
-}
-async function compress(input) {
-  supported("CompressionStream");
-  const cs = new CompressionStream("deflate-raw"), writer = cs.writable.getWriter();
-  writer.write(input).catch(() => {
-  }), writer.close().catch(() => {
-  });
-  const chunks = [], reader = cs.readable.getReader();
-  for (; ; ) {
-    const { value, done } = await reader.read();
-    if (done)
-      break;
-    chunks.push(value);
-  }
-  return concat(...chunks);
-}
-async function decompress(input, maxLength) {
-  supported("DecompressionStream");
-  const ds = new DecompressionStream("deflate-raw"), writer = ds.writable.getWriter();
-  writer.write(input).catch(() => {
-  }), writer.close().catch(() => {
-  });
-  const chunks = [];
-  let length = 0;
-  const reader = ds.readable.getReader();
-  for (; ; ) {
-    const { value, done } = await reader.read();
-    if (done)
-      break;
-    if (chunks.push(value), length += value.byteLength, maxLength !== 1 / 0 && length > maxLength)
-      throw new JWEInvalid("Decompressed plaintext exceeded the configured limit");
-  }
-  return concat(...chunks);
-}
-export {
-  compress,
-  decompress,
-  validateZip
-};

package/node_modules/jose/dist/webapi/lib/helpers.js

@@ -1,45 +0,0 @@
-import { decode } from "../util/base64url.js";
-import { encode, strictDecoder } from "./buffer_utils.js";
-import { isObject } from "./type_checks.js";
-const unprotected = /* @__PURE__ */ Symbol();
-function assertNotSet(value, name) {
-  if (value !== void 0)
-    throw new TypeError(`${name} can only be called once`);
-}
-function decodeBase64url(value, label, ErrorClass) {
-  try {
-    return decode(value);
-  } catch {
-    throw new ErrorClass(`Failed to base64url decode the ${label}`);
-  }
-}
-function encodeBase64url(value, label, ErrorClass) {
-  try {
-    return encode(value);
-  } catch {
-    throw new ErrorClass(`The ${label} is not a valid base64url string`);
-  }
-}
-async function digest(algorithm, data) {
-  const subtleDigest = `SHA-${algorithm.slice(-3)}`;
-  return new Uint8Array(await crypto.subtle.digest(subtleDigest, data));
-}
-function parseJoseHeader(b64, ErrorClass, message) {
-  let parsed;
-  try {
-    parsed = JSON.parse(strictDecoder.decode(decode(b64)));
-  } catch {
-    throw new ErrorClass(message);
-  }
-  if (!isObject(parsed))
-    throw new ErrorClass(message);
-  return parsed;
-}
-export {
-  assertNotSet,
-  decodeBase64url,
-  digest,
-  encodeBase64url,
-  parseJoseHeader,
-  unprotected
-};

package/node_modules/jose/dist/webapi/lib/invalid_key_input.js

@@ -1,12 +0,0 @@
-function message(msg, actual, ...types) {
-  if (types.length > 2) {
-    const last = types.pop();
-    msg += `one of type ${types.join(", ")}, or ${last}.`;
-  } else types.length === 2 ? msg += `one of type ${types[0]} or ${types[1]}.` : msg += `of type ${types[0]}.`;
-  return actual == null ? msg += ` Received ${actual}` : typeof actual == "function" && actual.name ? msg += ` Received function ${actual.name}` : typeof actual == "object" && actual != null && actual.constructor?.name && (msg += ` Received an instance of ${actual.constructor.name}`), msg;
-}
-const invalidKeyInput = (actual, ...types) => message("Key must be ", actual, ...types), withAlg = (alg, actual, ...types) => message(`Key for the ${alg} algorithm must be `, actual, ...types);
-export {
-  invalidKeyInput,
-  withAlg
-};

package/node_modules/jose/dist/webapi/lib/is_key_like.js

@@ -1,19 +0,0 @@
-function assertCryptoKey(key) {
-  if (!isCryptoKey(key))
-    throw new Error("CryptoKey instance expected");
-}
-const isCryptoKey = (key) => {
-  if (key?.[Symbol.toStringTag] === "CryptoKey")
-    return !0;
-  try {
-    return key instanceof CryptoKey;
-  } catch {
-    return !1;
-  }
-}, isKeyObject = (key) => key?.[Symbol.toStringTag] === "KeyObject", isKeyLike = (key) => isCryptoKey(key) || isKeyObject(key);
-export {
-  assertCryptoKey,
-  isCryptoKey,
-  isKeyLike,
-  isKeyObject
-};

package/node_modules/jose/dist/webapi/lib/jwe_algorithms.js

@@ -1,120 +0,0 @@
-import { JOSENotSupported } from "../util/errors.js";
-import { table } from "./key_descriptor.js";
-const wrap = [
-  ["encrypt", "wrapKey"],
-  ["decrypt", "unwrapKey"]
-], derive = [[], ["deriveBits"]], none = [[], []];
-function rsaes(bits) {
-  return {
-    kty: ["RSA"],
-    mode: "key-encryption",
-    subtle: { name: "RSA-OAEP", hash: `SHA-${bits}` },
-    usages: wrap,
-    ops: ["wrapKey", "unwrapKey"]
-  };
-}
-function ecdh(mode) {
-  return {
-    kty: ["EC", "OKP"],
-    mode,
-    subtle: { name: "ECDH" },
-    resolve: ({ kty, crv, asymmetricKeyType }) => {
-      if (crv === "X25519" || asymmetricKeyType === "x25519")
-        return { name: "X25519" };
-      if (kty === "OKP")
-        throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-      return { name: "ECDH", namedCurve: crv };
-    },
-    usages: derive,
-    ops: [void 0, "deriveBits"]
-  };
-}
-function aeskw(bits, gcm = !1) {
-  return {
-    kty: ["oct"],
-    mode: "key-wrapping",
-    secret: !0,
-    subtle: { name: gcm ? "AES-GCM" : "AES-KW", length: bits },
-    usages: none,
-    ops: gcm ? ["encrypt", "decrypt"] : ["wrapKey", "unwrapKey"]
-  };
-}
-function pbes2() {
-  return {
-    kty: ["oct"],
-    mode: "key-wrapping",
-    secret: !0,
-    subtle: { name: "PBKDF2" },
-    usages: none,
-    ops: ["deriveBits", "deriveBits"]
-  };
-}
-const JWE = table({
-  dir: {
-    kty: ["oct"],
-    mode: "direct-encryption",
-    secret: !0,
-    subtle: { name: "AES-GCM" },
-    usages: none,
-    ops: ["encrypt", "decrypt"]
-  },
-  "RSA-OAEP": rsaes(1),
-  "RSA-OAEP-256": rsaes(256),
-  "RSA-OAEP-384": rsaes(384),
-  "RSA-OAEP-512": rsaes(512),
-  "ECDH-ES": ecdh("direct-key-agreement"),
-  "ECDH-ES+A128KW": ecdh("key-agreement-with-key-wrapping"),
-  "ECDH-ES+A192KW": ecdh("key-agreement-with-key-wrapping"),
-  "ECDH-ES+A256KW": ecdh("key-agreement-with-key-wrapping"),
-  A128KW: aeskw(128),
-  A192KW: aeskw(192),
-  A256KW: aeskw(256),
-  A128GCMKW: aeskw(128, !0),
-  A192GCMKW: aeskw(192, !0),
-  A256GCMKW: aeskw(256, !0),
-  "PBES2-HS256+A128KW": pbes2(),
-  "PBES2-HS384+A192KW": pbes2(),
-  "PBES2-HS512+A256KW": pbes2()
-}), contentOps = ["encrypt", "decrypt"];
-function contentEncryption(bits, cbc = !1) {
-  return {
-    kty: ["oct"],
-    secret: !0,
-    subtle: { name: cbc ? "AES-CBC" : "AES-GCM", length: bits },
-    usages: none,
-    ops: contentOps,
-    cekBits: bits,
-    ivBits: cbc ? 128 : 96,
-    cbc
-  };
-}
-const ENC = table({
-  A128GCM: contentEncryption(128),
-  A192GCM: contentEncryption(192),
-  A256GCM: contentEncryption(256),
-  "A128CBC-HS256": contentEncryption(256, !0),
-  "A192CBC-HS384": contentEncryption(384, !0),
-  "A256CBC-HS512": contentEncryption(512, !0)
-});
-function unsupported(parameter, name) {
-  throw new JOSENotSupported(`Invalid or unsupported "${parameter}" (JWE ${name}) header value`);
-}
-function jweAlgorithm(alg) {
-  return (typeof alg == "string" ? JWE[alg] : void 0) ?? unsupported("alg", "Algorithm");
-}
-function isJWECEKTransport(algorithm) {
-  return algorithm.mode === "key-wrapping" || algorithm.mode === "key-encryption" || algorithm.mode === "key-agreement-with-key-wrapping";
-}
-function invalidJWEKeyManagementMode(_mode) {
-  throw new TypeError("Invalid JWE key management mode");
-}
-function jweEncryption(enc) {
-  return (typeof enc == "string" ? ENC[enc] : void 0) ?? unsupported("enc", "Encryption Algorithm");
-}
-export {
-  JWE,
-  invalidJWEKeyManagementMode,
-  isJWECEKTransport,
-  jweAlgorithm,
-  jweEncryption
-};