@golocalinteractive/golocal-cloud-wrapper 1.0.54 → 1.0.56

package/dist/golocal-cloud-wrapper.es265.js

@@ -0,0 +1,102 @@
+import crypto from "./golocal-cloud-wrapper.es294.js";
+import { JOSENotSupported } from "./golocal-cloud-wrapper.es240.js";
+const findOid = (keyData, oid, from = 0) => {
+  if (from === 0) {
+    oid.unshift(oid.length);
+    oid.unshift(6);
+  }
+  const i = keyData.indexOf(oid[0], from);
+  if (i === -1)
+    return false;
+  const sub = keyData.subarray(i, i + oid.length);
+  if (sub.length !== oid.length)
+    return false;
+  return sub.every((value, index) => value === oid[index]) || findOid(keyData, oid, i + 1);
+};
+const getNamedCurve = (keyData) => {
+  switch (true) {
+    case findOid(keyData, [42, 134, 72, 206, 61, 3, 1, 7]):
+      return "P-256";
+    case findOid(keyData, [43, 129, 4, 0, 34]):
+      return "P-384";
+    case findOid(keyData, [43, 129, 4, 0, 35]):
+      return "P-521";
+    case findOid(keyData, [43, 101, 110]):
+      return "X25519";
+    case findOid(keyData, [43, 101, 111]):
+      return "X448";
+    case findOid(keyData, [43, 101, 112]):
+      return "Ed25519";
+    case findOid(keyData, [43, 101, 113]):
+      return "Ed448";
+    default:
+      throw new JOSENotSupported("Invalid or unsupported EC Key Curve or OKP Key Sub Type");
+  }
+};
+const genericImport = async (replace, keyFormat, pem, alg, options) => {
+  let algorithm;
+  let keyUsages;
+  const keyData = new Uint8Array(atob(pem.replace(replace, "")).split("").map((c) => c.charCodeAt(0)));
+  switch (alg) {
+    case "PS256":
+    case "PS384":
+    case "PS512":
+      algorithm = { name: "RSA-PSS", hash: `SHA-${alg.slice(-3)}` };
+      keyUsages = ["sign"];
+      break;
+    case "RS256":
+    case "RS384":
+    case "RS512":
+      algorithm = { name: "RSASSA-PKCS1-v1_5", hash: `SHA-${alg.slice(-3)}` };
+      keyUsages = ["sign"];
+      break;
+    case "RSA-OAEP":
+    case "RSA-OAEP-256":
+    case "RSA-OAEP-384":
+    case "RSA-OAEP-512":
+      algorithm = {
+        name: "RSA-OAEP",
+        hash: `SHA-${parseInt(alg.slice(-3), 10) || 1}`
+      };
+      keyUsages = ["decrypt", "unwrapKey"];
+      break;
+    case "ES256":
+      algorithm = { name: "ECDSA", namedCurve: "P-256" };
+      keyUsages = ["sign"];
+      break;
+    case "ES384":
+      algorithm = { name: "ECDSA", namedCurve: "P-384" };
+      keyUsages = ["sign"];
+      break;
+    case "ES512":
+      algorithm = { name: "ECDSA", namedCurve: "P-521" };
+      keyUsages = ["sign"];
+      break;
+    case "ECDH-ES":
+    case "ECDH-ES+A128KW":
+    case "ECDH-ES+A192KW":
+    case "ECDH-ES+A256KW": {
+      const namedCurve = getNamedCurve(keyData);
+      algorithm = namedCurve.startsWith("P-") ? { name: "ECDH", namedCurve } : { name: namedCurve };
+      keyUsages = ["deriveBits"];
+      break;
+    }
+    case "Ed25519":
+      algorithm = { name: "Ed25519" };
+      keyUsages = ["sign"];
+      break;
+    case "EdDSA":
+      algorithm = { name: getNamedCurve(keyData) };
+      keyUsages = ["sign"];
+      break;
+    default:
+      throw new JOSENotSupported('Invalid or unsupported "alg" (Algorithm) value');
+  }
+  return crypto.subtle.importKey(keyFormat, keyData, algorithm, false, keyUsages);
+};
+const fromPKCS8 = (pem, alg, options) => {
+  return genericImport(/(?:-----(?:BEGIN|END) PRIVATE KEY-----|\s)/g, "pkcs8", pem, alg);
+};
+export {
+  fromPKCS8
+};

package/dist/golocal-cloud-wrapper.es266.js

@@ -0,0 +1,106 @@
+import crypto from "./golocal-cloud-wrapper.es294.js";
+import { JOSENotSupported } from "./golocal-cloud-wrapper.es240.js";
+function subtleMapping(jwk) {
+  let algorithm;
+  let keyUsages;
+  switch (jwk.kty) {
+    case "RSA": {
+      switch (jwk.alg) {
+        case "PS256":
+        case "PS384":
+        case "PS512":
+          algorithm = { name: "RSA-PSS", hash: `SHA-${jwk.alg.slice(-3)}` };
+          keyUsages = jwk.d ? ["sign"] : ["verify"];
+          break;
+        case "RS256":
+        case "RS384":
+        case "RS512":
+          algorithm = { name: "RSASSA-PKCS1-v1_5", hash: `SHA-${jwk.alg.slice(-3)}` };
+          keyUsages = jwk.d ? ["sign"] : ["verify"];
+          break;
+        case "RSA-OAEP":
+        case "RSA-OAEP-256":
+        case "RSA-OAEP-384":
+        case "RSA-OAEP-512":
+          algorithm = {
+            name: "RSA-OAEP",
+            hash: `SHA-${parseInt(jwk.alg.slice(-3), 10) || 1}`
+          };
+          keyUsages = jwk.d ? ["decrypt", "unwrapKey"] : ["encrypt", "wrapKey"];
+          break;
+        default:
+          throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+      }
+      break;
+    }
+    case "EC": {
+      switch (jwk.alg) {
+        case "ES256":
+          algorithm = { name: "ECDSA", namedCurve: "P-256" };
+          keyUsages = jwk.d ? ["sign"] : ["verify"];
+          break;
+        case "ES384":
+          algorithm = { name: "ECDSA", namedCurve: "P-384" };
+          keyUsages = jwk.d ? ["sign"] : ["verify"];
+          break;
+        case "ES512":
+          algorithm = { name: "ECDSA", namedCurve: "P-521" };
+          keyUsages = jwk.d ? ["sign"] : ["verify"];
+          break;
+        case "ECDH-ES":
+        case "ECDH-ES+A128KW":
+        case "ECDH-ES+A192KW":
+        case "ECDH-ES+A256KW":
+          algorithm = { name: "ECDH", namedCurve: jwk.crv };
+          keyUsages = jwk.d ? ["deriveBits"] : [];
+          break;
+        default:
+          throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+      }
+      break;
+    }
+    case "OKP": {
+      switch (jwk.alg) {
+        case "Ed25519":
+          algorithm = { name: "Ed25519" };
+          keyUsages = jwk.d ? ["sign"] : ["verify"];
+          break;
+        case "EdDSA":
+          algorithm = { name: jwk.crv };
+          keyUsages = jwk.d ? ["sign"] : ["verify"];
+          break;
+        case "ECDH-ES":
+        case "ECDH-ES+A128KW":
+        case "ECDH-ES+A192KW":
+        case "ECDH-ES+A256KW":
+          algorithm = { name: jwk.crv };
+          keyUsages = jwk.d ? ["deriveBits"] : [];
+          break;
+        default:
+          throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+      }
+      break;
+    }
+    default:
+      throw new JOSENotSupported('Invalid or unsupported JWK "kty" (Key Type) Parameter value');
+  }
+  return { algorithm, keyUsages };
+}
+const parse = async (jwk) => {
+  if (!jwk.alg) {
+    throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
+  }
+  const { algorithm, keyUsages } = subtleMapping(jwk);
+  const rest = [
+    algorithm,
+    jwk.ext ?? false,
+    jwk.key_ops ?? keyUsages
+  ];
+  const keyData = { ...jwk };
+  delete keyData.alg;
+  delete keyData.use;
+  return crypto.subtle.importKey("jwk", keyData, ...rest);
+};
+export {
+  parse as default
+};

package/dist/golocal-cloud-wrapper.es267.js

@@ -0,0 +1,4 @@
+var removeTrailingSlash = {};
+export {
+  removeTrailingSlash as __exports
+};

package/dist/golocal-cloud-wrapper.es268.js

@@ -0,0 +1,4 @@
+var addPathPrefix = {};
+export {
+  addPathPrefix as __exports
+};

package/dist/golocal-cloud-wrapper.es269.js

@@ -0,0 +1,38 @@
+import { __exports as parsePath } from "./golocal-cloud-wrapper.es282.js";
+var hasRequiredParsePath;
+function requireParsePath() {
+  if (hasRequiredParsePath) return parsePath;
+  hasRequiredParsePath = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "parsePath", {
+      enumerable: true,
+      get: function() {
+        return parsePath2;
+      }
+    });
+    function parsePath2(path) {
+      const hashIndex = path.indexOf("#");
+      const queryIndex = path.indexOf("?");
+      const hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
+      if (hasQuery || hashIndex > -1) {
+        return {
+          pathname: path.substring(0, hasQuery ? queryIndex : hashIndex),
+          query: hasQuery ? path.substring(queryIndex, hashIndex > -1 ? hashIndex : void 0) : "",
+          hash: hashIndex > -1 ? path.slice(hashIndex) : ""
+        };
+      }
+      return {
+        pathname: path,
+        query: "",
+        hash: ""
+      };
+    }
+  })(parsePath);
+  return parsePath;
+}
+export {
+  requireParsePath as __require
+};

package/dist/golocal-cloud-wrapper.es27.js

@@ -0,0 +1,45 @@
+import { clsx } from "./golocal-cloud-wrapper.es57.js";
+const falsyToString = (value) => typeof value === "boolean" ? `${value}` : value === 0 ? "0" : value;
+const cx = clsx;
+const cva = (base, config) => (props) => {
+  var _config_compoundVariants;
+  if ((config === null || config === void 0 ? void 0 : config.variants) == null) return cx(base, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
+  const { variants, defaultVariants } = config;
+  const getVariantClassNames = Object.keys(variants).map((variant) => {
+    const variantProp = props === null || props === void 0 ? void 0 : props[variant];
+    const defaultVariantProp = defaultVariants === null || defaultVariants === void 0 ? void 0 : defaultVariants[variant];
+    if (variantProp === null) return null;
+    const variantKey = falsyToString(variantProp) || falsyToString(defaultVariantProp);
+    return variants[variant][variantKey];
+  });
+  const propsWithoutUndefined = props && Object.entries(props).reduce((acc, param) => {
+    let [key, value] = param;
+    if (value === void 0) {
+      return acc;
+    }
+    acc[key] = value;
+    return acc;
+  }, {});
+  const getCompoundVariantClassNames = config === null || config === void 0 ? void 0 : (_config_compoundVariants = config.compoundVariants) === null || _config_compoundVariants === void 0 ? void 0 : _config_compoundVariants.reduce((acc, param) => {
+    let { class: cvClass, className: cvClassName, ...compoundVariantOptions } = param;
+    return Object.entries(compoundVariantOptions).every((param2) => {
+      let [key, value] = param2;
+      return Array.isArray(value) ? value.includes({
+        ...defaultVariants,
+        ...propsWithoutUndefined
+      }[key]) : {
+        ...defaultVariants,
+        ...propsWithoutUndefined
+      }[key] === value;
+    }) ? [
+      ...acc,
+      cvClass,
+      cvClassName
+    ] : acc;
+  }, []);
+  return cx(base, getVariantClassNames, getCompoundVariantClassNames, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
+};
+export {
+  cva,
+  cx
+};

package/dist/golocal-cloud-wrapper.es270.js

@@ -0,0 +1,4 @@
+var addPathSuffix = {};
+export {
+  addPathSuffix as __exports
+};

package/dist/golocal-cloud-wrapper.es271.js

@@ -0,0 +1,4 @@
+var addLocale = {};
+export {
+  addLocale as __exports
+};

package/dist/golocal-cloud-wrapper.es272.js

@@ -0,0 +1,4 @@
+var normalizeLocalePath = {};
+export {
+  normalizeLocalePath as __exports
+};

package/dist/golocal-cloud-wrapper.es273.js

@@ -0,0 +1,4 @@
+var removePathPrefix = {};
+export {
+  removePathPrefix as __exports
+};

package/dist/golocal-cloud-wrapper.es274.js

@@ -0,0 +1,4 @@
+var pathHasPrefix = {};
+export {
+  pathHasPrefix as __exports
+};

package/dist/golocal-cloud-wrapper.es275.js

@@ -0,0 +1,4 @@
+var asyncLocalStorage = {};
+export {
+  asyncLocalStorage as __exports
+};

package/dist/golocal-cloud-wrapper.es276.js

@@ -0,0 +1,4 @@
+var afterTaskAsyncStorageInstance = {};
+export {
+  afterTaskAsyncStorageInstance as __exports
+};

package/dist/golocal-cloud-wrapper.es277.js

@@ -0,0 +1,11 @@
+function assignRef(ref, value) {
+  if (typeof ref === "function") {
+    ref(value);
+  } else if (ref) {
+    ref.current = value;
+  }
+  return ref;
+}
+export {
+  assignRef
+};

package/dist/golocal-cloud-wrapper.es278.js

@@ -0,0 +1,29 @@
+import { useState } from "react";
+function useCallbackRef(initialValue, callback) {
+  var ref = useState(function() {
+    return {
+      // value
+      value: initialValue,
+      // last callback
+      callback,
+      // "memoized" public interface
+      facade: {
+        get current() {
+          return ref.value;
+        },
+        set current(value) {
+          var last = ref.value;
+          if (last !== value) {
+            ref.value = value;
+            ref.callback(value, last);
+          }
+        }
+      }
+    };
+  })[0];
+  ref.callback = callback;
+  return ref.facade;
+}
+export {
+  useCallbackRef
+};

package/dist/golocal-cloud-wrapper.es279.js

@@ -0,0 +1,4 @@
+var headers = {};
+export {
+  headers as __exports
+};

package/dist/golocal-cloud-wrapper.es28.js

@@ -0,0 +1,8 @@
+import { clsx } from "./golocal-cloud-wrapper.es57.js";
+import { twMerge } from "./golocal-cloud-wrapper.es58.js";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+export {
+  cn
+};

package/dist/golocal-cloud-wrapper.es280.js

@@ -0,0 +1,4 @@
+var createDedupedByCallsiteServerErrorLogger = {};
+export {
+  createDedupedByCallsiteServerErrorLogger as __exports
+};

package/dist/golocal-cloud-wrapper.es281.js

@@ -0,0 +1,4 @@
+var requestCookies = {};
+export {
+  requestCookies as __exports
+};

package/dist/golocal-cloud-wrapper.es282.js

@@ -0,0 +1,4 @@
+var parsePath = {};
+export {
+  parsePath as __exports
+};

package/dist/golocal-cloud-wrapper.es283.js

@@ -0,0 +1,5 @@
+import crypto from "./golocal-cloud-wrapper.es294.js";
+const random = crypto.getRandomValues.bind(crypto);
+export {
+  random as default
+};

package/dist/golocal-cloud-wrapper.es284.js

@@ -0,0 +1,36 @@
+import bogusWebCrypto from "./golocal-cloud-wrapper.es308.js";
+import crypto, { isCryptoKey } from "./golocal-cloud-wrapper.es294.js";
+import { checkEncCryptoKey } from "./golocal-cloud-wrapper.es301.js";
+import invalidKeyInput from "./golocal-cloud-wrapper.es297.js";
+import { types } from "./golocal-cloud-wrapper.es298.js";
+function checkKeySize(key, alg) {
+  if (key.algorithm.length !== parseInt(alg.slice(1, 4), 10)) {
+    throw new TypeError(`Invalid key size for alg: ${alg}`);
+  }
+}
+function getCryptoKey(key, alg, usage) {
+  if (isCryptoKey(key)) {
+    checkEncCryptoKey(key, alg, usage);
+    return key;
+  }
+  if (key instanceof Uint8Array) {
+    return crypto.subtle.importKey("raw", key, "AES-KW", true, [usage]);
+  }
+  throw new TypeError(invalidKeyInput(key, ...types, "Uint8Array"));
+}
+const wrap = async (alg, key, cek) => {
+  const cryptoKey = await getCryptoKey(key, alg, "wrapKey");
+  checkKeySize(cryptoKey, alg);
+  const cryptoKeyCek = await crypto.subtle.importKey("raw", cek, ...bogusWebCrypto);
+  return new Uint8Array(await crypto.subtle.wrapKey("raw", cryptoKeyCek, cryptoKey, "AES-KW"));
+};
+const unwrap = async (alg, key, encryptedKey) => {
+  const cryptoKey = await getCryptoKey(key, alg, "unwrapKey");
+  checkKeySize(cryptoKey, alg);
+  const cryptoKeyCek = await crypto.subtle.unwrapKey("raw", encryptedKey, cryptoKey, "AES-KW", ...bogusWebCrypto);
+  return new Uint8Array(await crypto.subtle.exportKey("raw", cryptoKeyCek));
+};
+export {
+  unwrap,
+  wrap
+};

package/dist/golocal-cloud-wrapper.es285.js

@@ -0,0 +1,46 @@
+import { concat, uint32be, lengthAndInput, encoder, concatKdf } from "./golocal-cloud-wrapper.es241.js";
+import crypto, { isCryptoKey } from "./golocal-cloud-wrapper.es294.js";
+import { checkEncCryptoKey } from "./golocal-cloud-wrapper.es301.js";
+import invalidKeyInput from "./golocal-cloud-wrapper.es297.js";
+import { types } from "./golocal-cloud-wrapper.es298.js";
+async function deriveKey(publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) {
+  if (!isCryptoKey(publicKey)) {
+    throw new TypeError(invalidKeyInput(publicKey, ...types));
+  }
+  checkEncCryptoKey(publicKey, "ECDH");
+  if (!isCryptoKey(privateKey)) {
+    throw new TypeError(invalidKeyInput(privateKey, ...types));
+  }
+  checkEncCryptoKey(privateKey, "ECDH", "deriveBits");
+  const value = concat(lengthAndInput(encoder.encode(algorithm)), lengthAndInput(apu), lengthAndInput(apv), uint32be(keyLength));
+  let length;
+  if (publicKey.algorithm.name === "X25519") {
+    length = 256;
+  } else if (publicKey.algorithm.name === "X448") {
+    length = 448;
+  } else {
+    length = Math.ceil(parseInt(publicKey.algorithm.namedCurve.substr(-3), 10) / 8) << 3;
+  }
+  const sharedSecret = new Uint8Array(await crypto.subtle.deriveBits({
+    name: publicKey.algorithm.name,
+    public: publicKey
+  }, privateKey, length));
+  return concatKdf(sharedSecret, keyLength, value);
+}
+async function generateEpk(key) {
+  if (!isCryptoKey(key)) {
+    throw new TypeError(invalidKeyInput(key, ...types));
+  }
+  return crypto.subtle.generateKey(key.algorithm, true, ["deriveBits"]);
+}
+function ecdhAllowed(key) {
+  if (!isCryptoKey(key)) {
+    throw new TypeError(invalidKeyInput(key, ...types));
+  }
+  return ["P-256", "P-384", "P-521"].includes(key.algorithm.namedCurve) || key.algorithm.name === "X25519" || key.algorithm.name === "X448";
+}
+export {
+  deriveKey,
+  ecdhAllowed,
+  generateEpk
+};

package/dist/golocal-cloud-wrapper.es286.js

@@ -0,0 +1,55 @@
+import random from "./golocal-cloud-wrapper.es283.js";
+import { p2s } from "./golocal-cloud-wrapper.es241.js";
+import { encode } from "./golocal-cloud-wrapper.es242.js";
+import { wrap, unwrap } from "./golocal-cloud-wrapper.es284.js";
+import checkP2s from "./golocal-cloud-wrapper.es309.js";
+import crypto, { isCryptoKey } from "./golocal-cloud-wrapper.es294.js";
+import { checkEncCryptoKey } from "./golocal-cloud-wrapper.es301.js";
+import invalidKeyInput from "./golocal-cloud-wrapper.es297.js";
+import { types } from "./golocal-cloud-wrapper.es298.js";
+function getCryptoKey(key, alg) {
+  if (key instanceof Uint8Array) {
+    return crypto.subtle.importKey("raw", key, "PBKDF2", false, ["deriveBits"]);
+  }
+  if (isCryptoKey(key)) {
+    checkEncCryptoKey(key, alg, "deriveBits", "deriveKey");
+    return key;
+  }
+  throw new TypeError(invalidKeyInput(key, ...types, "Uint8Array"));
+}
+async function deriveKey(p2s$1, alg, p2c, key) {
+  checkP2s(p2s$1);
+  const salt = p2s(alg, p2s$1);
+  const keylen = parseInt(alg.slice(13, 16), 10);
+  const subtleAlg = {
+    hash: `SHA-${alg.slice(8, 11)}`,
+    iterations: p2c,
+    name: "PBKDF2",
+    salt
+  };
+  const wrapAlg = {
+    length: keylen,
+    name: "AES-KW"
+  };
+  const cryptoKey = await getCryptoKey(key, alg);
+  if (cryptoKey.usages.includes("deriveBits")) {
+    return new Uint8Array(await crypto.subtle.deriveBits(subtleAlg, cryptoKey, keylen));
+  }
+  if (cryptoKey.usages.includes("deriveKey")) {
+    return crypto.subtle.deriveKey(subtleAlg, cryptoKey, wrapAlg, false, ["wrapKey", "unwrapKey"]);
+  }
+  throw new TypeError('PBKDF2 key "usages" must include "deriveBits" or "deriveKey"');
+}
+const encrypt = async (alg, key, cek, p2c = 2048, p2s2 = random(new Uint8Array(16))) => {
+  const derived = await deriveKey(p2s2, alg, p2c, key);
+  const encryptedKey = await wrap(alg.slice(-6), derived, cek);
+  return { encryptedKey, p2c, p2s: encode(p2s2) };
+};
+const decrypt = async (alg, key, encryptedKey, p2c, p2s2) => {
+  const derived = await deriveKey(p2s2, alg, p2c, key);
+  return unwrap(alg.slice(-6), derived, encryptedKey);
+};
+export {
+  decrypt,
+  encrypt
+};

package/dist/golocal-cloud-wrapper.es287.js

@@ -0,0 +1,41 @@
+import subtleRsaEs from "./golocal-cloud-wrapper.es310.js";
+import bogusWebCrypto from "./golocal-cloud-wrapper.es308.js";
+import crypto, { isCryptoKey } from "./golocal-cloud-wrapper.es294.js";
+import { checkEncCryptoKey } from "./golocal-cloud-wrapper.es301.js";
+import checkKeyLength from "./golocal-cloud-wrapper.es295.js";
+import invalidKeyInput from "./golocal-cloud-wrapper.es297.js";
+import { types } from "./golocal-cloud-wrapper.es298.js";
+const encrypt = async (alg, key, cek) => {
+  if (!isCryptoKey(key)) {
+    throw new TypeError(invalidKeyInput(key, ...types));
+  }
+  checkEncCryptoKey(key, alg, "encrypt", "wrapKey");
+  checkKeyLength(alg, key);
+  if (key.usages.includes("encrypt")) {
+    return new Uint8Array(await crypto.subtle.encrypt(subtleRsaEs(alg), key, cek));
+  }
+  if (key.usages.includes("wrapKey")) {
+    const cryptoKeyCek = await crypto.subtle.importKey("raw", cek, ...bogusWebCrypto);
+    return new Uint8Array(await crypto.subtle.wrapKey("raw", cryptoKeyCek, key, subtleRsaEs(alg)));
+  }
+  throw new TypeError('RSA-OAEP key "usages" must include "encrypt" or "wrapKey" for this operation');
+};
+const decrypt = async (alg, key, encryptedKey) => {
+  if (!isCryptoKey(key)) {
+    throw new TypeError(invalidKeyInput(key, ...types));
+  }
+  checkEncCryptoKey(key, alg, "decrypt", "unwrapKey");
+  checkKeyLength(alg, key);
+  if (key.usages.includes("decrypt")) {
+    return new Uint8Array(await crypto.subtle.decrypt(subtleRsaEs(alg), key, encryptedKey));
+  }
+  if (key.usages.includes("unwrapKey")) {
+    const cryptoKeyCek = await crypto.subtle.unwrapKey("raw", encryptedKey, key, subtleRsaEs(alg), ...bogusWebCrypto);
+    return new Uint8Array(await crypto.subtle.exportKey("raw", cryptoKeyCek));
+  }
+  throw new TypeError('RSA-OAEP key "usages" must include "decrypt" or "unwrapKey" for this operation');
+};
+export {
+  decrypt,
+  encrypt
+};