lib0 0.2.61 → 0.2.62

package/README.md

@@ -245,6 +245,30 @@ Using getAsync & setIfUndefined ensures that the init function is only calle
 <b><code>conditions.undefinedToNull</code></b><br>
 </dl>
 </details>
+<details><summary><b>[lib0/crypto]</b> </summary>
+<pre>import * as crypto from 'lib0/crypto'</pre>
+<dl>
+<b><code>y(data: string | Uint8Array): Uint8Array</code></b><br>
+<b><code>ymmetricKey(secret: string | Uint8Array, salt: string | Uint8Array, opts: Object, opts.extractable: boolean, opts.usages: Array&lt;'sign'|'verify'|'encrypt'|'decrypt'&gt;): PromiseLike&lt;CryptoKey&gt;</code></b><br>
+<b><code>ymmetricKey()</code></b><br>
+<b><code>eAsymmetricKey(opts: Object, opts.extractable: boolean, opts.usages: Array&lt;'sign'|'verify'|'encrypt'|'decrypt'&gt;)</code></b><br>
+<b><code>eAsymmetricKey()</code></b><br>
+<b><code>ey(key: CryptoKey)</code></b><br>
+<b><code>ey()</code></b><br>
+<b><code>ymmetricKey(jwk: any, opts: Object, opts.extractable: boolean, opts.usages: Array&lt;'sign'|'verify'|'encrypt'|'decrypt'&gt;)</code></b><br>
+<b><code>ymmetricKey()</code></b><br>
+<b><code>symmetricKey(jwk: any, opts: Object, opts.extractable: boolean, opts.usages: Array&lt;'sign'|'verify'|'encrypt'|'decrypt'&gt;)</code></b><br>
+<b><code>symmetricKey()</code></b><br>
+<b><code>(data: Uint8Array, key: CryptoKey): PromiseLike&lt;Uint8Array&gt;</code></b><br>
+<b><code>()</code></b><br>
+<b><code>(data: Uint8Array, key: CryptoKey): PromiseLike&lt;Uint8Array&gt;</code></b><br>
+<b><code>()</code></b><br>
+<b><code>(data: Uint8Array, privateKey: CryptoKey): PromiseLike&lt;Uint8Array&gt;</code></b><br>
+<b><code>()</code></b><br>
+<b><code>(signature: Uint8Array, data: Uint8Array, publicKey: CryptoKey): PromiseLike&lt;boolean&gt;</code></b><br>
+<b><code>()</code></b><br>
+</dl>
+</details>
 <details><summary><b>[lib0/decoding]</b> Efficient schema-less binary decoding with support for variable length encoding.</summary>
 <pre>import * as decoding from 'lib0/decoding'</pre>
 
@@ -1329,6 +1353,25 @@ export const testMyFirstTest = tc => {
 <b><code>url.encodeQueryParams(params: Object&lt;string,string&gt;): string</code></b><br>
 </dl>
 </details>
+<details><summary><b>[lib0/webcrypto.browser]</b> </summary>
+<pre>import * as webcrypto.browser from 'lib0/webcrypto.browser'</pre>
+<dl>
+<b><code></code></b><br>
+<b><code>()</code></b><br>
+<b><code>omValues</code></b><br>
+<b><code>omValues()</code></b><br>
+</dl>
+</details>
+<details><summary><b>[lib0/webcrypto.node]</b> </summary>
+<pre>import * as webcrypto.node from 'lib0/webcrypto.node'</pre>
+<dl>
+<b><code></code></b><br>
+<b><code>()</code></b><br>
+<b><code>to.subtle: any</code></b><br>
+<b><code>omValues</code></b><br>
+<b><code>omValues()</code></b><br>
+</dl>
+</details>
 <details><summary><b>[lib0/websocket]</b> Tiny websocket connection handler.</summary>
 <pre>import * as websocket from 'lib0/websocket'</pre>
 

package/crypto.d.ts

@@ -0,0 +1,22 @@
+export function deriveSymmetricKey(secret: string | Uint8Array, salt: string | Uint8Array, { extractable, usages }?: {
+    extractable?: boolean | undefined;
+    usages?: ("decrypt" | "encrypt" | "sign" | "verify")[] | undefined;
+}): PromiseLike<CryptoKey>;
+export function generateAsymmetricKey({ extractable, usages }?: {
+    extractable?: boolean | undefined;
+    usages?: ("decrypt" | "encrypt" | "sign" | "verify")[] | undefined;
+}): Promise<CryptoKeyPair>;
+export function exportKey(key: CryptoKey): Promise<JsonWebKey>;
+export function importSymmetricKey(jwk: any, { extractable, usages }?: {
+    extractable?: boolean | undefined;
+    usages?: ("decrypt" | "encrypt" | "sign" | "verify")[] | undefined;
+}): Promise<CryptoKey>;
+export function importAsymmetricKey(jwk: any, { extractable, usages }?: {
+    extractable?: boolean | undefined;
+    usages?: ("decrypt" | "encrypt" | "sign" | "verify")[] | undefined;
+}): Promise<CryptoKey>;
+export function encrypt(data: Uint8Array, key: CryptoKey): PromiseLike<Uint8Array>;
+export function decrypt(data: Uint8Array, key: CryptoKey): PromiseLike<Uint8Array>;
+export function sign(data: Uint8Array, privateKey: CryptoKey): PromiseLike<Uint8Array>;
+export function verify(signature: Uint8Array, data: Uint8Array, publicKey: CryptoKey): PromiseLike<boolean>;
+//# sourceMappingURL=crypto.d.ts.map

package/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["crypto.js"],"names":[],"mappings":"AA0BO,2CAPI,MAAM,GAAG,UAAU,QACnB,MAAM,GAAG,UAAU;IAEJ,WAAW;IACwB,MAAM;IACvD,YAAY,SAAS,CAAC,CA4BjC;AAQM;IAHmB,WAAW;IACwB,MAAM;2BAUhE;AAMI,+BAFI,SAAS,uBAEkD;AAS/D,wCALI,GAAG;IAEY,WAAW;IACwB,MAAM;uBAGI;AAShE,yCALI,GAAG;IAEY,WAAW;IACwB,MAAM;uBAGkC;AAW9F,8BAJI,UAAU,OACV,SAAS,GACR,YAAY,UAAU,CAAC,CAkBlC;AAWM,8BAJI,UAAU,OACV,SAAS,GACR,YAAY,UAAU,CAAC,CAclC;AAWM,2BAJI,UAAU,cACV,SAAS,GACR,YAAY,UAAU,CAAC,CAUa;AAYzC,kCALI,UAAU,QACV,UAAU,aACV,SAAS,GACR,YAAY,OAAO,CAAC,CAW7B"}

package/crypto.js

@@ -0,0 +1,185 @@
+/* eslint-env browser */
+
+import * as encoding from './encoding.js'
+import * as decoding from './decoding.js'
+import * as string from './string.js'
+import * as webcrypto from 'lib0/webcrypto'
+
+/* istanbul ignore next */
+/**
+ * @param {string | Uint8Array} data
+ * @return {Uint8Array}
+ */
+const toBinary = data => typeof data === 'string' ? string.encodeUtf8(data) : data
+
+/**
+ * @experimental The API is not final!
+ *
+ * Derive an symmetric key using the Password-Based-Key-Derivation-Function-2.
+ *
+ * @param {string | Uint8Array} secret
+ * @param {string | Uint8Array} salt
+ * @param {Object} opts
+ * @param {boolean} [opts.extractable]
+ * @param {Array<'sign'|'verify'|'encrypt'|'decrypt'>} [opts.usages]
+ * @return {PromiseLike<CryptoKey>}
+ */
+export const deriveSymmetricKey = (secret, salt, { extractable = false, usages = ['encrypt', 'decrypt'] } = {}) => {
+  const binSecret = toBinary(secret)
+  const binSalt = toBinary(salt)
+  return webcrypto.subtle.importKey(
+    'raw',
+    binSecret,
+    'PBKDF2',
+    false,
+    ['deriveKey']
+  ).then(keyMaterial =>
+    webcrypto.subtle.deriveKey(
+      {
+        name: 'PBKDF2',
+        salt: binSalt, // NIST recommends at least 64 bits
+        iterations: 600000, // OWASP recommends 600k iterations
+        hash: 'SHA-256'
+      },
+      keyMaterial,
+      {
+        name: 'AES-GCM',
+        length: 256
+      },
+      extractable,
+      usages
+    )
+  )
+}
+
+/* istanbul ignore next */
+/**
+ * @param {Object} opts
+ * @param {boolean} [opts.extractable]
+ * @param {Array<'sign'|'verify'|'encrypt'|'decrypt'>} [opts.usages]
+ */
+export const generateAsymmetricKey = ({ extractable = false, usages = ['sign', 'verify'] } = {}) =>
+  webcrypto.subtle.generateKey(
+    {
+      name: 'ECDSA',
+      namedCurve: 'P-384'
+    },
+    extractable,
+    usages
+  )
+
+/* istanbul ignore next */
+/**
+ * @param {CryptoKey} key - Symmetric or Asymmetric key
+ */
+export const exportKey = key => webcrypto.subtle.exportKey('jwk', key)
+
+/* istanbul ignore next */
+/**
+ * @param {any} jwk
+ * @param {Object} opts
+ * @param {boolean} [opts.extractable]
+ * @param {Array<'sign'|'verify'|'encrypt'|'decrypt'>} [opts.usages]
+ */
+export const importSymmetricKey = (jwk, { extractable = false, usages = ['encrypt', 'decrypt'] } = {}) =>
+  webcrypto.subtle.importKey('jwk', jwk, 'PBKDF2', extractable, usages)
+
+/* istanbul ignore next */
+/**
+ * @param {any} jwk
+ * @param {Object} opts
+ * @param {boolean} [opts.extractable]
+ * @param {Array<'sign'|'verify'|'encrypt'|'decrypt'>} [opts.usages]
+ */
+export const importAsymmetricKey = (jwk, { extractable = false, usages = ['encrypt', 'decrypt'] } = {}) =>
+  webcrypto.subtle.importKey('jwk', jwk, { name: 'ECDSA', namedCurve: 'P-384' }, extractable, usages)
+
+/**
+ * @experimental The API is not final!
+ *
+ * Encrypt some data using AES-GCM method.
+ *
+ * @param {Uint8Array} data data to be encrypted
+ * @param {CryptoKey} key
+ * @return {PromiseLike<Uint8Array>} encrypted, base64 encoded message
+ */
+export const encrypt = (data, key) => {
+  const iv = webcrypto.getRandomValues(new Uint8Array(16)) // 92bit is enough. 128bit is recommended if space is not an issue.
+  return webcrypto.subtle.encrypt(
+    {
+      name: 'AES-GCM',
+      iv
+    },
+    key,
+    data
+  ).then(cipher => {
+    const encryptedDataEncoder = encoding.createEncoder()
+    // iv may be sent in the clear to the other peers
+    encoding.writeUint8Array(encryptedDataEncoder, iv)
+    encoding.writeVarUint8Array(encryptedDataEncoder, new Uint8Array(cipher))
+    return encoding.toUint8Array(encryptedDataEncoder)
+  })
+}
+
+/**
+ * @experimental The API is not final!
+ *
+ * Decrypt some data using AES-GCM method.
+ *
+ * @param {Uint8Array} data
+ * @param {CryptoKey} key
+ * @return {PromiseLike<Uint8Array>} decrypted buffer
+ */
+export const decrypt = (data, key) => {
+  const dataDecoder = decoding.createDecoder(data)
+  const iv = decoding.readUint8Array(dataDecoder, 16)
+  const cipher = decoding.readVarUint8Array(dataDecoder)
+  return webcrypto.subtle.decrypt(
+    {
+      name: 'AES-GCM',
+      iv
+    },
+    key,
+    cipher
+  ).then(data => new Uint8Array(data))
+}
+
+/**
+ * @experimental The API is not final!
+ *
+ * Sign a message
+ *
+ * @param {Uint8Array} data
+ * @param {CryptoKey} privateKey
+ * @return {PromiseLike<Uint8Array>} signature
+ */
+export const sign = (data, privateKey) =>
+  webcrypto.subtle.sign(
+    {
+      name: 'ECDSA',
+      hash: { name: 'SHA-384' }
+    },
+    privateKey,
+    data
+  ).then(signature => new Uint8Array(signature))
+
+/**
+ * @experimental The API is not final!
+ *
+ * Sign a message
+ *
+ * @param {Uint8Array} signature
+ * @param {Uint8Array} data
+ * @param {CryptoKey} publicKey
+ * @return {PromiseLike<boolean>} signature
+ */
+export const verify = (signature, data, publicKey) =>
+  webcrypto.subtle.verify(
+    {
+      name: 'ECDSA',
+      hash: { name: 'SHA-384' }
+    },
+    publicKey,
+    signature,
+    data
+  )

package/crypto.test.d.ts

@@ -0,0 +1,6 @@
+export function testReapeatEncryption(tc: t.TestCase): Promise<void>;
+export function testEncryptionPerformance(tc: t.TestCase): Promise<void>;
+export function testConsistentKeyGeneration(_tc: t.TestCase): Promise<void>;
+export function testSigning(tc: t.TestCase): Promise<void>;
+import * as t from "./testing.js";
+//# sourceMappingURL=crypto.test.d.ts.map

package/crypto.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.test.d.ts","sourceRoot":"","sources":["crypto.test.js"],"names":[],"mappings":"AAQO,0CAFI,EAAE,QAAQ,iBA+BpB;AAKM,8CAFI,EAAE,QAAQ,iBAsCpB;AAKM,iDAFI,EAAE,QAAQ,iBA0CpB;AAKM,gCAFI,EAAE,QAAQ,iBAapB"}

package/dist/crypto.cjs

@@ -0,0 +1,231 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var encoding = require('./buffer-22bb9fae.cjs');
+var string = require('./string-ad04f734.cjs');
+var webcrypto = require('lib0/webcrypto');
+require('./environment-f6386808.cjs');
+require('./map-28a001c9.cjs');
+require('./conditions-fb475c70.cjs');
+require('./storage.cjs');
+require('./function-40d38a5b.cjs');
+require('./array-42d0736b.cjs');
+require('./set-b596ef38.cjs');
+require('./object-fe9c0021.cjs');
+require('./binary-ac8e39e2.cjs');
+require('./math-08e068f9.cjs');
+require('./number-e62129bc.cjs');
+require('./error-873c9cbf.cjs');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var webcrypto__namespace = /*#__PURE__*/_interopNamespace(webcrypto);
+
+/* eslint-env browser */
+
+/* istanbul ignore next */
+/**
+ * @param {string | Uint8Array} data
+ * @return {Uint8Array}
+ */
+const toBinary = data => typeof data === 'string' ? string.encodeUtf8(data) : data;
+
+/**
+ * @experimental The API is not final!
+ *
+ * Derive an symmetric key using the Password-Based-Key-Derivation-Function-2.
+ *
+ * @param {string | Uint8Array} secret
+ * @param {string | Uint8Array} salt
+ * @param {Object} opts
+ * @param {boolean} [opts.extractable]
+ * @param {Array<'sign'|'verify'|'encrypt'|'decrypt'>} [opts.usages]
+ * @return {PromiseLike<CryptoKey>}
+ */
+const deriveSymmetricKey = (secret, salt, { extractable = false, usages = ['encrypt', 'decrypt'] } = {}) => {
+  const binSecret = toBinary(secret);
+  const binSalt = toBinary(salt);
+  return webcrypto__namespace.subtle.importKey(
+    'raw',
+    binSecret,
+    'PBKDF2',
+    false,
+    ['deriveKey']
+  ).then(keyMaterial =>
+    webcrypto__namespace.subtle.deriveKey(
+      {
+        name: 'PBKDF2',
+        salt: binSalt, // NIST recommends at least 64 bits
+        iterations: 600000, // OWASP recommends 600k iterations
+        hash: 'SHA-256'
+      },
+      keyMaterial,
+      {
+        name: 'AES-GCM',
+        length: 256
+      },
+      extractable,
+      usages
+    )
+  )
+};
+
+/* istanbul ignore next */
+/**
+ * @param {Object} opts
+ * @param {boolean} [opts.extractable]
+ * @param {Array<'sign'|'verify'|'encrypt'|'decrypt'>} [opts.usages]
+ */
+const generateAsymmetricKey = ({ extractable = false, usages = ['sign', 'verify'] } = {}) =>
+  webcrypto__namespace.subtle.generateKey(
+    {
+      name: 'ECDSA',
+      namedCurve: 'P-384'
+    },
+    extractable,
+    usages
+  );
+
+/* istanbul ignore next */
+/**
+ * @param {CryptoKey} key - Symmetric or Asymmetric key
+ */
+const exportKey = key => webcrypto__namespace.subtle.exportKey('jwk', key);
+
+/* istanbul ignore next */
+/**
+ * @param {any} jwk
+ * @param {Object} opts
+ * @param {boolean} [opts.extractable]
+ * @param {Array<'sign'|'verify'|'encrypt'|'decrypt'>} [opts.usages]
+ */
+const importSymmetricKey = (jwk, { extractable = false, usages = ['encrypt', 'decrypt'] } = {}) =>
+  webcrypto__namespace.subtle.importKey('jwk', jwk, 'PBKDF2', extractable, usages);
+
+/* istanbul ignore next */
+/**
+ * @param {any} jwk
+ * @param {Object} opts
+ * @param {boolean} [opts.extractable]
+ * @param {Array<'sign'|'verify'|'encrypt'|'decrypt'>} [opts.usages]
+ */
+const importAsymmetricKey = (jwk, { extractable = false, usages = ['encrypt', 'decrypt'] } = {}) =>
+  webcrypto__namespace.subtle.importKey('jwk', jwk, { name: 'ECDSA', namedCurve: 'P-384' }, extractable, usages);
+
+/**
+ * @experimental The API is not final!
+ *
+ * Encrypt some data using AES-GCM method.
+ *
+ * @param {Uint8Array} data data to be encrypted
+ * @param {CryptoKey} key
+ * @return {PromiseLike<Uint8Array>} encrypted, base64 encoded message
+ */
+const encrypt = (data, key) => {
+  const iv = webcrypto__namespace.getRandomValues(new Uint8Array(16)); // 92bit is enough. 128bit is recommended if space is not an issue.
+  return webcrypto__namespace.subtle.encrypt(
+    {
+      name: 'AES-GCM',
+      iv
+    },
+    key,
+    data
+  ).then(cipher => {
+    const encryptedDataEncoder = encoding.createEncoder();
+    // iv may be sent in the clear to the other peers
+    encoding.writeUint8Array(encryptedDataEncoder, iv);
+    encoding.writeVarUint8Array(encryptedDataEncoder, new Uint8Array(cipher));
+    return encoding.toUint8Array(encryptedDataEncoder)
+  })
+};
+
+/**
+ * @experimental The API is not final!
+ *
+ * Decrypt some data using AES-GCM method.
+ *
+ * @param {Uint8Array} data
+ * @param {CryptoKey} key
+ * @return {PromiseLike<Uint8Array>} decrypted buffer
+ */
+const decrypt = (data, key) => {
+  const dataDecoder = encoding.createDecoder(data);
+  const iv = encoding.readUint8Array(dataDecoder, 16);
+  const cipher = encoding.readVarUint8Array(dataDecoder);
+  return webcrypto__namespace.subtle.decrypt(
+    {
+      name: 'AES-GCM',
+      iv
+    },
+    key,
+    cipher
+  ).then(data => new Uint8Array(data))
+};
+
+/**
+ * @experimental The API is not final!
+ *
+ * Sign a message
+ *
+ * @param {Uint8Array} data
+ * @param {CryptoKey} privateKey
+ * @return {PromiseLike<Uint8Array>} signature
+ */
+const sign = (data, privateKey) =>
+  webcrypto__namespace.subtle.sign(
+    {
+      name: 'ECDSA',
+      hash: { name: 'SHA-384' }
+    },
+    privateKey,
+    data
+  ).then(signature => new Uint8Array(signature));
+
+/**
+ * @experimental The API is not final!
+ *
+ * Sign a message
+ *
+ * @param {Uint8Array} signature
+ * @param {Uint8Array} data
+ * @param {CryptoKey} publicKey
+ * @return {PromiseLike<boolean>} signature
+ */
+const verify = (signature, data, publicKey) =>
+  webcrypto__namespace.subtle.verify(
+    {
+      name: 'ECDSA',
+      hash: { name: 'SHA-384' }
+    },
+    publicKey,
+    signature,
+    data
+  );
+
+exports.decrypt = decrypt;
+exports.deriveSymmetricKey = deriveSymmetricKey;
+exports.encrypt = encrypt;
+exports.exportKey = exportKey;
+exports.generateAsymmetricKey = generateAsymmetricKey;
+exports.importAsymmetricKey = importAsymmetricKey;
+exports.importSymmetricKey = importSymmetricKey;
+exports.sign = sign;
+exports.verify = verify;
+//# sourceMappingURL=crypto.cjs.map

package/dist/crypto.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.cjs","sources":["../crypto.js"],"sourcesContent":["/* eslint-env browser */\n\nimport * as encoding from './encoding.js'\nimport * as decoding from './decoding.js'\nimport * as string from './string.js'\nimport * as webcrypto from 'lib0/webcrypto'\n\n/* istanbul ignore next */\n/**\n * @param {string | Uint8Array} data\n * @return {Uint8Array}\n */\nconst toBinary = data => typeof data === 'string' ? string.encodeUtf8(data) : data\n\n/**\n * @experimental The API is not final!\n *\n * Derive an symmetric key using the Password-Based-Key-Derivation-Function-2.\n *\n * @param {string | Uint8Array} secret\n * @param {string | Uint8Array} salt\n * @param {Object} opts\n * @param {boolean} [opts.extractable]\n * @param {Array<'sign'|'verify'|'encrypt'|'decrypt'>} [opts.usages]\n * @return {PromiseLike<CryptoKey>}\n */\nexport const deriveSymmetricKey = (secret, salt, { extractable = false, usages = ['encrypt', 'decrypt'] } = {}) => {\n  const binSecret = toBinary(secret)\n  const binSalt = toBinary(salt)\n  return webcrypto.subtle.importKey(\n    'raw',\n    binSecret,\n    'PBKDF2',\n    false,\n    ['deriveKey']\n  ).then(keyMaterial =>\n    webcrypto.subtle.deriveKey(\n      {\n        name: 'PBKDF2',\n        salt: binSalt, // NIST recommends at least 64 bits\n        iterations: 600000, // OWASP recommends 600k iterations\n        hash: 'SHA-256'\n      },\n      keyMaterial,\n      {\n        name: 'AES-GCM',\n        length: 256\n      },\n      extractable,\n      usages\n    )\n  )\n}\n\n/* istanbul ignore next */\n/**\n * @param {Object} opts\n * @param {boolean} [opts.extractable]\n * @param {Array<'sign'|'verify'|'encrypt'|'decrypt'>} [opts.usages]\n */\nexport const generateAsymmetricKey = ({ extractable = false, usages = ['sign', 'verify'] } = {}) =>\n  webcrypto.subtle.generateKey(\n    {\n      name: 'ECDSA',\n      namedCurve: 'P-384'\n    },\n    extractable,\n    usages\n  )\n\n/* istanbul ignore next */\n/**\n * @param {CryptoKey} key - Symmetric or Asymmetric key\n */\nexport const exportKey = key => webcrypto.subtle.exportKey('jwk', key)\n\n/* istanbul ignore next */\n/**\n * @param {any} jwk\n * @param {Object} opts\n * @param {boolean} [opts.extractable]\n * @param {Array<'sign'|'verify'|'encrypt'|'decrypt'>} [opts.usages]\n */\nexport const importSymmetricKey = (jwk, { extractable = false, usages = ['encrypt', 'decrypt'] } = {}) =>\n  webcrypto.subtle.importKey('jwk', jwk, 'PBKDF2', extractable, usages)\n\n/* istanbul ignore next */\n/**\n * @param {any} jwk\n * @param {Object} opts\n * @param {boolean} [opts.extractable]\n * @param {Array<'sign'|'verify'|'encrypt'|'decrypt'>} [opts.usages]\n */\nexport const importAsymmetricKey = (jwk, { extractable = false, usages = ['encrypt', 'decrypt'] } = {}) =>\n  webcrypto.subtle.importKey('jwk', jwk, { name: 'ECDSA', namedCurve: 'P-384' }, extractable, usages)\n\n/**\n * @experimental The API is not final!\n *\n * Encrypt some data using AES-GCM method.\n *\n * @param {Uint8Array} data data to be encrypted\n * @param {CryptoKey} key\n * @return {PromiseLike<Uint8Array>} encrypted, base64 encoded message\n */\nexport const encrypt = (data, key) => {\n  const iv = webcrypto.getRandomValues(new Uint8Array(16)) // 92bit is enough. 128bit is recommended if space is not an issue.\n  return webcrypto.subtle.encrypt(\n    {\n      name: 'AES-GCM',\n      iv\n    },\n    key,\n    data\n  ).then(cipher => {\n    const encryptedDataEncoder = encoding.createEncoder()\n    // iv may be sent in the clear to the other peers\n    encoding.writeUint8Array(encryptedDataEncoder, iv)\n    encoding.writeVarUint8Array(encryptedDataEncoder, new Uint8Array(cipher))\n    return encoding.toUint8Array(encryptedDataEncoder)\n  })\n}\n\n/**\n * @experimental The API is not final!\n *\n * Decrypt some data using AES-GCM method.\n *\n * @param {Uint8Array} data\n * @param {CryptoKey} key\n * @return {PromiseLike<Uint8Array>} decrypted buffer\n */\nexport const decrypt = (data, key) => {\n  const dataDecoder = decoding.createDecoder(data)\n  const iv = decoding.readUint8Array(dataDecoder, 16)\n  const cipher = decoding.readVarUint8Array(dataDecoder)\n  return webcrypto.subtle.decrypt(\n    {\n      name: 'AES-GCM',\n      iv\n    },\n    key,\n    cipher\n  ).then(data => new Uint8Array(data))\n}\n\n/**\n * @experimental The API is not final!\n *\n * Sign a message\n *\n * @param {Uint8Array} data\n * @param {CryptoKey} privateKey\n * @return {PromiseLike<Uint8Array>} signature\n */\nexport const sign = (data, privateKey) =>\n  webcrypto.subtle.sign(\n    {\n      name: 'ECDSA',\n      hash: { name: 'SHA-384' }\n    },\n    privateKey,\n    data\n  ).then(signature => new Uint8Array(signature))\n\n/**\n * @experimental The API is not final!\n *\n * Sign a message\n *\n * @param {Uint8Array} signature\n * @param {Uint8Array} data\n * @param {CryptoKey} publicKey\n * @return {PromiseLike<boolean>} signature\n */\nexport const verify = (signature, data, publicKey) =>\n  webcrypto.subtle.verify(\n    {\n      name: 'ECDSA',\n      hash: { name: 'SHA-384' }\n    },\n    publicKey,\n    signature,\n    data\n  )\n"],"names":["string.encodeUtf8","webcrypto","encoding.createEncoder","encoding.writeUint8Array","encoding.writeVarUint8Array","encoding.toUint8Array","decoding.createDecoder","decoding.readUint8Array","decoding.readVarUint8Array"],"mappings":"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"}

package/dist/crypto.d.ts

@@ -0,0 +1,22 @@
+export function deriveSymmetricKey(secret: string | Uint8Array, salt: string | Uint8Array, { extractable, usages }?: {
+    extractable?: boolean | undefined;
+    usages?: ("decrypt" | "encrypt" | "sign" | "verify")[] | undefined;
+}): PromiseLike<CryptoKey>;
+export function generateAsymmetricKey({ extractable, usages }?: {
+    extractable?: boolean | undefined;
+    usages?: ("decrypt" | "encrypt" | "sign" | "verify")[] | undefined;
+}): Promise<CryptoKeyPair>;
+export function exportKey(key: CryptoKey): Promise<JsonWebKey>;
+export function importSymmetricKey(jwk: any, { extractable, usages }?: {
+    extractable?: boolean | undefined;
+    usages?: ("decrypt" | "encrypt" | "sign" | "verify")[] | undefined;
+}): Promise<CryptoKey>;
+export function importAsymmetricKey(jwk: any, { extractable, usages }?: {
+    extractable?: boolean | undefined;
+    usages?: ("decrypt" | "encrypt" | "sign" | "verify")[] | undefined;
+}): Promise<CryptoKey>;
+export function encrypt(data: Uint8Array, key: CryptoKey): PromiseLike<Uint8Array>;
+export function decrypt(data: Uint8Array, key: CryptoKey): PromiseLike<Uint8Array>;
+export function sign(data: Uint8Array, privateKey: CryptoKey): PromiseLike<Uint8Array>;
+export function verify(signature: Uint8Array, data: Uint8Array, publicKey: CryptoKey): PromiseLike<boolean>;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../crypto.js"],"names":[],"mappings":"AA0BO,2CAPI,MAAM,GAAG,UAAU,QACnB,MAAM,GAAG,UAAU;IAEJ,WAAW;IACwB,MAAM;IACvD,YAAY,SAAS,CAAC,CA4BjC;AAQM;IAHmB,WAAW;IACwB,MAAM;2BAUhE;AAMI,+BAFI,SAAS,uBAEkD;AAS/D,wCALI,GAAG;IAEY,WAAW;IACwB,MAAM;uBAGI;AAShE,yCALI,GAAG;IAEY,WAAW;IACwB,MAAM;uBAGkC;AAW9F,8BAJI,UAAU,OACV,SAAS,GACR,YAAY,UAAU,CAAC,CAkBlC;AAWM,8BAJI,UAAU,OACV,SAAS,GACR,YAAY,UAAU,CAAC,CAclC;AAWM,2BAJI,UAAU,cACV,SAAS,GACR,YAAY,UAAU,CAAC,CAUa;AAYzC,kCALI,UAAU,QACV,UAAU,aACV,SAAS,GACR,YAAY,OAAO,CAAC,CAW7B"}

package/dist/crypto.test.d.ts

@@ -0,0 +1,6 @@
+export function testReapeatEncryption(tc: t.TestCase): Promise<void>;
+export function testEncryptionPerformance(tc: t.TestCase): Promise<void>;
+export function testConsistentKeyGeneration(_tc: t.TestCase): Promise<void>;
+export function testSigning(tc: t.TestCase): Promise<void>;
+import * as t from "./testing.js";
+//# sourceMappingURL=crypto.test.d.ts.map

package/dist/crypto.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.test.d.ts","sourceRoot":"","sources":["../crypto.test.js"],"names":[],"mappings":"AAQO,0CAFI,EAAE,QAAQ,iBA+BpB;AAKM,8CAFI,EAAE,QAAQ,iBAsCpB;AAKM,iDAFI,EAAE,QAAQ,iBA0CpB;AAKM,gCAFI,EAAE,QAAQ,iBAapB"}

package/dist/rollup.config.d.ts

@@ -33,7 +33,7 @@ declare var _default: ({
         file?: undefined;
     };
     external: string[];
-    plugins?: undefined;
+    plugins: import("rollup").Plugin[];
 })[];
 export default _default;
 //# sourceMappingURL=rollup.config.d.ts.map

package/dist/webcrypto.browser.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* eslint-env browser */
+
+const subtle = crypto.subtle;
+const getRandomValues = crypto.getRandomValues.bind(crypto);
+
+exports.getRandomValues = getRandomValues;
+exports.subtle = subtle;
+//# sourceMappingURL=webcrypto.browser.cjs.map

package/dist/webcrypto.browser.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto.browser.cjs","sources":["../webcrypto.browser.js"],"sourcesContent":["/* eslint-env browser */\n\nexport const subtle = crypto.subtle\nexport const getRandomValues = crypto.getRandomValues.bind(crypto)\n"],"names":[],"mappings":";;;;AAAA;AACA;AACY,MAAC,MAAM,GAAG,MAAM,CAAC,OAAM;AACvB,MAAC,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM;;;;;"}

package/dist/webcrypto.browser.d.ts

@@ -0,0 +1,3 @@
+export const subtle: SubtleCrypto;
+export const getRandomValues: <T extends ArrayBufferView | null>(array: T) => T;
+//# sourceMappingURL=webcrypto.browser.d.ts.map

package/dist/webcrypto.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto.browser.d.ts","sourceRoot":"","sources":["../webcrypto.browser.js"],"names":[],"mappings":"AAEA,kCAAmC;AACnC,gFAAkE"}

package/dist/webcrypto.node.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var node_crypto = require('node:crypto');
+
+const subtle = /** @type {any} */ (node_crypto.webcrypto).subtle;
+const getRandomValues = /** @type {any} */ (node_crypto.webcrypto).getRandomValues.bind(node_crypto.webcrypto);
+
+exports.getRandomValues = getRandomValues;
+exports.subtle = subtle;
+//# sourceMappingURL=webcrypto.node.cjs.map

package/dist/webcrypto.node.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto.node.cjs","sources":["../webcrypto.node.js"],"sourcesContent":["\nimport { webcrypto } from 'node:crypto'\n\nexport const subtle = /** @type {any} */ (webcrypto).subtle\nexport const getRandomValues = /** @type {any} */ (webcrypto).getRandomValues.bind(webcrypto)\n"],"names":["webcrypto"],"mappings":";;;;;;AAGY,MAAC,MAAM,sBAAsB,CAACA,qBAAS,EAAE,OAAM;AAC/C,MAAC,eAAe,sBAAsB,CAACA,qBAAS,EAAE,eAAe,CAAC,IAAI,CAACA,qBAAS;;;;;"}

package/dist/webcrypto.node.d.ts

@@ -0,0 +1,3 @@
+export const subtle: any;
+export const getRandomValues: any;
+//# sourceMappingURL=webcrypto.node.d.ts.map

package/dist/webcrypto.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto.node.d.ts","sourceRoot":"","sources":["../webcrypto.node.js"],"names":[],"mappings":"AAGA,yBAA2D;AAC3D,kCAA6F"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lib0",
-  "version": "0.2.61",
+  "version": "0.2.62",
   "description": "",
   "sideEffects": false,
   "type": "module",
@@ -75,6 +75,12 @@
       "import": "./condititons.js",
       "require": "./dist/conditions.cjs"
     },
+    "./crypto": {
+      "types": "./crypto.d.ts",
+      "module": "./crypto.js",
+      "import": "./crypto.js",
+      "require": "./dist/crypto.cjs"
+    },
     "./decoding.js": "./decoding.js",
     "./dist/decoding.cjs": "./dist/decoding.cjs",
     "./decoding": {
@@ -370,6 +376,18 @@
       "module": "./websocket.js",
       "import": "./websocket.js",
       "require": "./dist/websocket.cjs"
+    },
+    "./webcrypto": {
+      "types": "./webcrypto.browser.d.ts",
+      "node": {
+        "import": "./webcrypto.node.js",
+        "require": "./dist/webcrypto.node.cjs"
+      },
+      "browser": {
+        "import": "./webcrypto.browser.js",
+        "require": "./dist/webcrypto.browser.cjs"
+      },
+      "module": "./webcrypto.browser.js"
     }
   },
   "dependencies": {

package/rollup.config.d.ts

@@ -33,7 +33,7 @@ declare var _default: ({
         file?: undefined;
     };
     external: string[];
-    plugins?: undefined;
+    plugins: import("rollup").Plugin[];
 })[];
 export default _default;
 //# sourceMappingURL=rollup.config.d.ts.map

package/test.js

@@ -1,6 +1,7 @@
 import { runTests } from './testing.js'
 import * as array from './array.test.js'
 import * as broadcastchannel from './broadcastchannel.test.js'
+import * as crypto from './crypto.test.js'
 import * as logging from './logging.test.js'
 import * as string from './string.test.js'
 import * as encoding from './encoding.test.js'
@@ -41,6 +42,7 @@ if (isBrowser) {
 runTests({
   array,
   broadcastchannel,
+  crypto,
   logging,
   string,
   encoding,

package/webcrypto.browser.d.ts

@@ -0,0 +1,3 @@
+export const subtle: SubtleCrypto;
+export const getRandomValues: <T extends ArrayBufferView | null>(array: T) => T;
+//# sourceMappingURL=webcrypto.browser.d.ts.map

package/webcrypto.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto.browser.d.ts","sourceRoot":"","sources":["webcrypto.browser.js"],"names":[],"mappings":"AAEA,kCAAmC;AACnC,gFAAkE"}

package/webcrypto.browser.js

@@ -0,0 +1,4 @@
+/* eslint-env browser */
+
+export const subtle = crypto.subtle
+export const getRandomValues = crypto.getRandomValues.bind(crypto)

package/webcrypto.node.d.ts

@@ -0,0 +1,3 @@
+export const subtle: any;
+export const getRandomValues: any;
+//# sourceMappingURL=webcrypto.node.d.ts.map

package/webcrypto.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto.node.d.ts","sourceRoot":"","sources":["webcrypto.node.js"],"names":[],"mappings":"AAGA,yBAA2D;AAC3D,kCAA6F"}

package/webcrypto.node.js

@@ -0,0 +1,5 @@
+
+import { webcrypto } from 'node:crypto'
+
+export const subtle = /** @type {any} */ (webcrypto).subtle
+export const getRandomValues = /** @type {any} */ (webcrypto).getRandomValues.bind(webcrypto)