@volter/tabnode 0.5.21 → 0.5.22

package/dist/assets/{runtime-worker-XRE6n_4W.js → runtime-worker-Bw5ePWPu.js}

@@ -23705,6 +23705,83 @@ function createCryptoModule(require2) {
     const keyInfo = extractKeyInfo(key);
     return new KeyObject2("private", keyInfo.keyData, keyInfo.algorithm);
   }
+  const NAMED_CURVES = {
+    "prime256v1": "P-256",
+    "p-256": "P-256",
+    "secp256r1": "P-256",
+    "secp384r1": "P-384",
+    "p-384": "P-384",
+    "secp521r1": "P-521",
+    "p-521": "P-521"
+  };
+  function keyPairAlgorithm(type2, options) {
+    const exponent = (value) => {
+      let rest = value ?? 65537;
+      const bytes2 = [];
+      while (rest > 0) {
+        bytes2.unshift(rest & 255);
+        rest = Math.floor(rest / 256);
+      }
+      return new Uint8Array(bytes2);
+    };
+    switch (type2) {
+      case "rsa":
+      case "rsa-pss": {
+        if (!Number.isInteger(options.modulusLength)) throw Object.assign(new TypeError('The "options.modulusLength" property must be of type number.'), { code: "ERR_INVALID_ARG_TYPE" });
+        const name = type2 === "rsa" ? "RSASSA-PKCS1-v1_5" : "RSA-PSS";
+        return { generate: { name, modulusLength: options.modulusLength, publicExponent: exponent(options.publicExponent), hash: "SHA-256" }, usages: ["sign", "verify"], name: type2 === "rsa" ? "RSA-SHA256" : "RSA-PSS" };
+      }
+      case "ec": {
+        const curve = NAMED_CURVES[String(options.namedCurve ?? "").toLowerCase()];
+        if (!curve) throw Object.assign(new TypeError(`Invalid EC curve name ${String(options.namedCurve)}`), { code: "ERR_CRYPTO_INVALID_CURVE" });
+        return { generate: { name: "ECDSA", namedCurve: curve }, usages: ["sign", "verify"], name: curve === "P-256" ? "ES256" : curve === "P-384" ? "ES384" : "ES512" };
+      }
+      case "ed25519":
+        return { generate: { name: "Ed25519" }, usages: ["sign", "verify"], name: "Ed25519" };
+      case "x25519":
+        return { generate: { name: "X25519" }, usages: ["deriveBits"], name: "X25519" };
+      default:
+        throw Object.assign(new TypeError(`The argument 'type' must be a supported key type. Received '${type2}'`), { code: "ERR_INVALID_ARG_VALUE" });
+    }
+  }
+  function encodedKey(der, encoding, kind) {
+    const expected = kind === "public" ? "spki" : "pkcs8";
+    if (encoding.type !== void 0 && encoding.type !== expected) {
+      unsupported2(`Encoding a ${kind} key as ${encoding.type}`);
+    }
+    const bytes2 = Buffer2.from(der);
+    if (encoding.format === "der") return bytes2;
+    if (encoding.format !== "pem") unsupported2(`Encoding a key in the ${String(encoding.format)} format`);
+    const label = kind === "public" ? "PUBLIC KEY" : "PRIVATE KEY";
+    const body = bytes2.toString("base64").match(/.{1,64}/g).join("\n");
+    return `-----BEGIN ${label}-----
+${body}
+-----END ${label}-----
+`;
+  }
+  async function generateKeyPairAsync(type2, options) {
+    const algorithm = keyPairAlgorithm(type2, options);
+    const pair = await crypto.subtle.generateKey(algorithm.generate, true, algorithm.usages);
+    const publicKey = options.publicKeyEncoding ? encodedKey(await crypto.subtle.exportKey("spki", pair.publicKey), options.publicKeyEncoding, "public") : new KeyObject2("public", pair.publicKey, algorithm.name);
+    const privateKey = options.privateKeyEncoding ? encodedKey(await crypto.subtle.exportKey("pkcs8", pair.privateKey), options.privateKeyEncoding, "private") : new KeyObject2("private", pair.privateKey, algorithm.name);
+    return { publicKey, privateKey };
+  }
+  function generateKeyPair2(type2, options, callback) {
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    }
+    if (typeof callback !== "function") throw Object.assign(new TypeError('The "callback" argument must be of type function.'), { code: "ERR_INVALID_ARG_TYPE" });
+    const done = callback;
+    keyPairAlgorithm(type2, options ?? {});
+    generateKeyPairAsync(type2, options ?? {}).then(
+      ({ publicKey, privateKey }) => done(null, publicKey, privateKey),
+      (error) => done(error instanceof Error ? error : new Error(String(error)))
+    );
+  }
+  Object.defineProperty(generateKeyPair2, Symbol.for("nodejs.util.promisify.custom"), {
+    value: (type2, options) => generateKeyPairAsync(type2, options ?? {})
+  });
   function timingSafeEqual2(a, b) {
     if (a.length !== b.length) {
       return false;
@@ -23861,11 +23938,12 @@ function createCryptoModule(require2) {
     KeyObject: KeyObject2,
     createSecretKey: createSecretKey2,
     createPublicKey: createPublicKey2,
-    createPrivateKey: createPrivateKey2
+    createPrivateKey: createPrivateKey2,
+    generateKeyPair: generateKeyPair2
   };
 }
 const cryptoModule = createCryptoModule();
-const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
+const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, generateKeyPair, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
 var cryptoShim = /* @__PURE__ */ Object.freeze({
   __proto__: null,
   KeyObject,
@@ -23879,6 +23957,7 @@ var cryptoShim = /* @__PURE__ */ Object.freeze({
   createSign,
   createVerify,
   default: cryptoModule,
+  generateKeyPair,
   getCiphers,
   getHashes,
   getRandomValues,

package/dist/index.mjs

@@ -21322,10 +21322,17 @@ var implementation$1 = function bind2(that) {
 var implementation = implementation$1;
 var functionBind = Function.prototype.bind || implementation;
 var functionCall = Function.prototype.call;
-var functionApply = Function.prototype.apply;
+var functionApply;
+var hasRequiredFunctionApply;
+function requireFunctionApply() {
+  if (hasRequiredFunctionApply) return functionApply;
+  hasRequiredFunctionApply = 1;
+  functionApply = Function.prototype.apply;
+  return functionApply;
+}
 var reflectApply = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
 var bind$2 = functionBind;
-var $apply$1 = functionApply;
+var $apply$1 = requireFunctionApply();
 var $call$2 = functionCall;
 var $reflectApply = reflectApply;
 var actualApply = $reflectApply || bind$2.call($call$2, $apply$1);
@@ -21445,7 +21452,7 @@ var hasSymbols = requireHasSymbols()();
 var getProto = requireGetProto();
 var $ObjectGPO = requireObject_getPrototypeOf();
 var $ReflectGPO = requireReflect_getPrototypeOf();
-var $apply = functionApply;
+var $apply = requireFunctionApply();
 var $call = functionCall;
 var needsEval = {};
 var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined$1 : getProto(Uint8Array);
@@ -22086,7 +22093,7 @@ function requireApplyBind() {
   if (hasRequiredApplyBind) return applyBind;
   hasRequiredApplyBind = 1;
   var bind3 = functionBind;
-  var $apply2 = functionApply;
+  var $apply2 = requireFunctionApply();
   var actualApply$1 = actualApply;
   applyBind = function applyBind2() {
     return actualApply$1(bind3, $apply2, arguments);
@@ -23874,6 +23881,83 @@ function createCryptoModule(require2) {
     const keyInfo = extractKeyInfo(key);
     return new KeyObject2("private", keyInfo.keyData, keyInfo.algorithm);
   }
+  const NAMED_CURVES = {
+    "prime256v1": "P-256",
+    "p-256": "P-256",
+    "secp256r1": "P-256",
+    "secp384r1": "P-384",
+    "p-384": "P-384",
+    "secp521r1": "P-521",
+    "p-521": "P-521"
+  };
+  function keyPairAlgorithm(type2, options) {
+    const exponent = (value) => {
+      let rest = value ?? 65537;
+      const bytes2 = [];
+      while (rest > 0) {
+        bytes2.unshift(rest & 255);
+        rest = Math.floor(rest / 256);
+      }
+      return new Uint8Array(bytes2);
+    };
+    switch (type2) {
+      case "rsa":
+      case "rsa-pss": {
+        if (!Number.isInteger(options.modulusLength)) throw Object.assign(new TypeError('The "options.modulusLength" property must be of type number.'), { code: "ERR_INVALID_ARG_TYPE" });
+        const name = type2 === "rsa" ? "RSASSA-PKCS1-v1_5" : "RSA-PSS";
+        return { generate: { name, modulusLength: options.modulusLength, publicExponent: exponent(options.publicExponent), hash: "SHA-256" }, usages: ["sign", "verify"], name: type2 === "rsa" ? "RSA-SHA256" : "RSA-PSS" };
+      }
+      case "ec": {
+        const curve = NAMED_CURVES[String(options.namedCurve ?? "").toLowerCase()];
+        if (!curve) throw Object.assign(new TypeError(`Invalid EC curve name ${String(options.namedCurve)}`), { code: "ERR_CRYPTO_INVALID_CURVE" });
+        return { generate: { name: "ECDSA", namedCurve: curve }, usages: ["sign", "verify"], name: curve === "P-256" ? "ES256" : curve === "P-384" ? "ES384" : "ES512" };
+      }
+      case "ed25519":
+        return { generate: { name: "Ed25519" }, usages: ["sign", "verify"], name: "Ed25519" };
+      case "x25519":
+        return { generate: { name: "X25519" }, usages: ["deriveBits"], name: "X25519" };
+      default:
+        throw Object.assign(new TypeError(`The argument 'type' must be a supported key type. Received '${type2}'`), { code: "ERR_INVALID_ARG_VALUE" });
+    }
+  }
+  function encodedKey(der, encoding, kind) {
+    const expected = kind === "public" ? "spki" : "pkcs8";
+    if (encoding.type !== void 0 && encoding.type !== expected) {
+      unsupported2(`Encoding a ${kind} key as ${encoding.type}`);
+    }
+    const bytes2 = Buffer2.from(der);
+    if (encoding.format === "der") return bytes2;
+    if (encoding.format !== "pem") unsupported2(`Encoding a key in the ${String(encoding.format)} format`);
+    const label = kind === "public" ? "PUBLIC KEY" : "PRIVATE KEY";
+    const body = bytes2.toString("base64").match(/.{1,64}/g).join("\n");
+    return `-----BEGIN ${label}-----
+${body}
+-----END ${label}-----
+`;
+  }
+  async function generateKeyPairAsync(type2, options) {
+    const algorithm = keyPairAlgorithm(type2, options);
+    const pair = await crypto.subtle.generateKey(algorithm.generate, true, algorithm.usages);
+    const publicKey = options.publicKeyEncoding ? encodedKey(await crypto.subtle.exportKey("spki", pair.publicKey), options.publicKeyEncoding, "public") : new KeyObject2("public", pair.publicKey, algorithm.name);
+    const privateKey = options.privateKeyEncoding ? encodedKey(await crypto.subtle.exportKey("pkcs8", pair.privateKey), options.privateKeyEncoding, "private") : new KeyObject2("private", pair.privateKey, algorithm.name);
+    return { publicKey, privateKey };
+  }
+  function generateKeyPair2(type2, options, callback) {
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    }
+    if (typeof callback !== "function") throw Object.assign(new TypeError('The "callback" argument must be of type function.'), { code: "ERR_INVALID_ARG_TYPE" });
+    const done = callback;
+    keyPairAlgorithm(type2, options ?? {});
+    generateKeyPairAsync(type2, options ?? {}).then(
+      ({ publicKey, privateKey }) => done(null, publicKey, privateKey),
+      (error) => done(error instanceof Error ? error : new Error(String(error)))
+    );
+  }
+  Object.defineProperty(generateKeyPair2, Symbol.for("nodejs.util.promisify.custom"), {
+    value: (type2, options) => generateKeyPairAsync(type2, options ?? {})
+  });
   function timingSafeEqual2(a, b) {
     if (a.length !== b.length) {
       return false;
@@ -24030,11 +24114,12 @@ function createCryptoModule(require2) {
     KeyObject: KeyObject2,
     createSecretKey: createSecretKey2,
     createPublicKey: createPublicKey2,
-    createPrivateKey: createPrivateKey2
+    createPrivateKey: createPrivateKey2,
+    generateKeyPair: generateKeyPair2
   };
 }
 const cryptoModule = createCryptoModule();
-const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported: unsupported$1, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
+const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported: unsupported$1, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, generateKeyPair, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
 const cryptoShim = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   KeyObject,
@@ -24048,6 +24133,7 @@ const cryptoShim = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   createSign,
   createVerify,
   default: cryptoModule,
+  generateKeyPair,
   getCiphers,
   getHashes,
   getRandomValues,
@@ -39839,7 +39925,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-XRE6n_4W.js",
+        "/assets/runtime-worker-Bw5ePWPu.js",
         import.meta.url
       ),
       { type: "module" }

package/dist/shims/crypto.d.ts

@@ -245,6 +245,19 @@ export declare function createCryptoModule(require?: (name: string) => any): {
             format?: string;
         }): Buffer | string;
     };
+    generateKeyPair: (type: string, options: {
+        modulusLength?: number;
+        publicExponent?: number;
+        namedCurve?: string;
+        publicKeyEncoding?: {
+            type?: string;
+            format?: string;
+        };
+        privateKeyEncoding?: {
+            type?: string;
+            format?: string;
+        };
+    } | ((error: Error | null, publicKey?: unknown, privateKey?: unknown) => void), callback?: (error: Error | null, publicKey?: unknown, privateKey?: unknown) => void) => void;
 };
 declare const cryptoModule: {
     unsupported: (operation: string) => never;
@@ -477,6 +490,19 @@ declare const cryptoModule: {
             format?: string;
         }): Buffer | string;
     };
+    generateKeyPair: (type: string, options: {
+        modulusLength?: number;
+        publicExponent?: number;
+        namedCurve?: string;
+        publicKeyEncoding?: {
+            type?: string;
+            format?: string;
+        };
+        privateKeyEncoding?: {
+            type?: string;
+            format?: string;
+        };
+    } | ((error: Error | null, publicKey?: unknown, privateKey?: unknown) => void), callback?: (error: Error | null, publicKey?: unknown, privateKey?: unknown) => void) => void;
 };
 export declare const randomBytes: {
     (size: number): Buffer;
@@ -679,6 +705,18 @@ export declare const randomBytes: {
         type?: string;
         format?: string;
     }): Buffer | string;
-}, timingSafeEqual: (a: Buffer | Uint8Array, b: Buffer | Uint8Array) => boolean, getCiphers: () => string[], getHashes: () => string[];
+}, generateKeyPair: (type: string, options: {
+    modulusLength?: number;
+    publicExponent?: number;
+    namedCurve?: string;
+    publicKeyEncoding?: {
+        type?: string;
+        format?: string;
+    };
+    privateKeyEncoding?: {
+        type?: string;
+        format?: string;
+    };
+} | ((error: Error | null, publicKey?: unknown, privateKey?: unknown) => void), callback?: (error: Error | null, publicKey?: unknown, privateKey?: unknown) => void) => void, timingSafeEqual: (a: Buffer | Uint8Array, b: Buffer | Uint8Array) => boolean, getCiphers: () => string[], getHashes: () => string[];
 export type KeyObject = InstanceType<typeof KeyObject>;
 export default cryptoModule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/tabnode",
-  "version": "0.5.21",
+  "version": "0.5.22",
   "description": "Node's own library, in a browser tab.",
   "type": "module",
   "license": "MIT",

package/src/shims/crypto.ts

@@ -800,6 +800,92 @@ function createPrivateKey(key: KeyLike): KeyObject {
   return new KeyObject('private', keyInfo.keyData as Uint8Array, keyInfo.algorithm);
 }
 
+// ============================================================================
+// generateKeyPair: Node's asynchronous key generation, done by WebCrypto.
+// A browser has no synchronous key generation, so generateKeyPairSync stays
+// absent; the callback form and its promisified form (which resolves
+// { publicKey, privateKey }, as Node's custom promisify does) are complete for
+// the types WebCrypto generates. jose's Node build promisifies this function
+// when it loads, so its absence failed any module that imported jose.
+// ============================================================================
+
+type KeyEncoding = { type?: string; format?: string };
+type KeyPairOptions = { modulusLength?: number; publicExponent?: number; namedCurve?: string; publicKeyEncoding?: KeyEncoding; privateKeyEncoding?: KeyEncoding };
+
+const NAMED_CURVES: Record<string, string> = {
+  'prime256v1': 'P-256', 'p-256': 'P-256', 'secp256r1': 'P-256',
+  'secp384r1': 'P-384', 'p-384': 'P-384',
+  'secp521r1': 'P-521', 'p-521': 'P-521',
+};
+
+function keyPairAlgorithm(type: string, options: KeyPairOptions): { generate: AlgorithmIdentifier & Record<string, unknown>; usages: KeyUsage[]; name: string } {
+  const exponent = (value: number | undefined): Uint8Array => {
+    let rest = value ?? 0x10001;
+    const bytes: number[] = [];
+    while (rest > 0) { bytes.unshift(rest & 0xff); rest = Math.floor(rest / 256); }
+    return new Uint8Array(bytes);
+  };
+  switch (type) {
+    case 'rsa':
+    case 'rsa-pss': {
+      if (!Number.isInteger(options.modulusLength)) throw Object.assign(new TypeError('The "options.modulusLength" property must be of type number.'), { code: 'ERR_INVALID_ARG_TYPE' });
+      const name = type === 'rsa' ? 'RSASSA-PKCS1-v1_5' : 'RSA-PSS';
+      return { generate: { name, modulusLength: options.modulusLength, publicExponent: exponent(options.publicExponent), hash: 'SHA-256' }, usages: ['sign', 'verify'], name: type === 'rsa' ? 'RSA-SHA256' : 'RSA-PSS' };
+    }
+    case 'ec': {
+      const curve = NAMED_CURVES[String(options.namedCurve ?? '').toLowerCase()];
+      if (!curve) throw Object.assign(new TypeError(`Invalid EC curve name ${String(options.namedCurve)}`), { code: 'ERR_CRYPTO_INVALID_CURVE' });
+      return { generate: { name: 'ECDSA', namedCurve: curve }, usages: ['sign', 'verify'], name: curve === 'P-256' ? 'ES256' : curve === 'P-384' ? 'ES384' : 'ES512' };
+    }
+    case 'ed25519':
+      return { generate: { name: 'Ed25519' }, usages: ['sign', 'verify'], name: 'Ed25519' };
+    case 'x25519':
+      return { generate: { name: 'X25519' }, usages: ['deriveBits'], name: 'X25519' };
+    default:
+      throw Object.assign(new TypeError(`The argument 'type' must be a supported key type. Received '${type}'`), { code: 'ERR_INVALID_ARG_VALUE' });
+  }
+}
+
+function encodedKey(der: ArrayBuffer, encoding: KeyEncoding, kind: 'public' | 'private'): string | Buffer {
+  const expected = kind === 'public' ? 'spki' : 'pkcs8';
+  if (encoding.type !== undefined && encoding.type !== expected) {
+    unsupported(`Encoding a ${kind} key as ${encoding.type}`);
+  }
+  const bytes = Buffer.from(der);
+  if (encoding.format === 'der') return bytes;
+  if (encoding.format !== 'pem') unsupported(`Encoding a key in the ${String(encoding.format)} format`);
+  const label = kind === 'public' ? 'PUBLIC KEY' : 'PRIVATE KEY';
+  const body = bytes.toString('base64').match(/.{1,64}/g)!.join('\n');
+  return `-----BEGIN ${label}-----\n${body}\n-----END ${label}-----\n`;
+}
+
+async function generateKeyPairAsync(type: string, options: KeyPairOptions): Promise<{ publicKey: KeyObject | string | Buffer; privateKey: KeyObject | string | Buffer }> {
+  const algorithm = keyPairAlgorithm(type, options);
+  const pair = await crypto.subtle.generateKey(algorithm.generate as AlgorithmIdentifier, true, algorithm.usages) as CryptoKeyPair;
+  const publicKey = options.publicKeyEncoding
+    ? encodedKey(await crypto.subtle.exportKey('spki', pair.publicKey), options.publicKeyEncoding, 'public')
+    : new KeyObject('public', pair.publicKey, algorithm.name);
+  const privateKey = options.privateKeyEncoding
+    ? encodedKey(await crypto.subtle.exportKey('pkcs8', pair.privateKey), options.privateKeyEncoding, 'private')
+    : new KeyObject('private', pair.privateKey, algorithm.name);
+  return { publicKey, privateKey };
+}
+
+function generateKeyPair(type: string, options: KeyPairOptions | ((error: Error | null, publicKey?: unknown, privateKey?: unknown) => void), callback?: (error: Error | null, publicKey?: unknown, privateKey?: unknown) => void): void {
+  if (typeof options === 'function') { callback = options; options = {}; }
+  if (typeof callback !== 'function') throw Object.assign(new TypeError('The "callback" argument must be of type function.'), { code: 'ERR_INVALID_ARG_TYPE' });
+  const done = callback;
+  // Argument errors throw synchronously, as Node's do.
+  keyPairAlgorithm(type, options ?? {});
+  generateKeyPairAsync(type, options ?? {}).then(
+    ({ publicKey, privateKey }) => done(null, publicKey, privateKey),
+    (error) => done(error instanceof Error ? error : new Error(String(error))),
+  );
+}
+Object.defineProperty(generateKeyPair, Symbol.for('nodejs.util.promisify.custom'), {
+  value: (type: string, options?: KeyPairOptions) => generateKeyPairAsync(type, options ?? {}),
+});
+
 // ============================================================================
 // Utility functions
 // ============================================================================
@@ -1067,10 +1153,11 @@ return {
   createSecretKey,
   createPublicKey,
   createPrivateKey,
+  generateKeyPair,
 };
 
 }
 const cryptoModule = createCryptoModule();
-export const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
+export const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, generateKeyPair, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
 export type KeyObject = InstanceType<typeof KeyObject>;
 export default cryptoModule;