@fairfox/polly 0.85.1 → 0.85.2

package/dist/src/mesh.js

@@ -19,12 +19,14 @@ var __toESM = (mod, isNodeMode, target) => {
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
   if (canCache)
     cache.set(mod, to);
   return to;
@@ -167,18 +169,18 @@ var init_idb_helpers = __esm(() => {
 // src/shared/lib/encryption.ts
 var exports_encryption = {};
 __export(exports_encryption, {
-  sealEnvelope: () => sealEnvelope,
-  openEnvelope: () => openEnvelope,
-  generateDocumentKey: () => generateDocumentKey,
-  encrypt: () => encrypt,
-  encodeEncryptedEnvelope: () => encodeEncryptedEnvelope,
-  decryptOrThrow: () => decryptOrThrow,
-  decrypt: () => decrypt,
-  decodeEncryptedEnvelope: () => decodeEncryptedEnvelope,
-  TAG_BYTES: () => TAG_BYTES,
-  NONCE_BYTES: () => NONCE_BYTES,
+  EncryptionError: () => EncryptionError,
   KEY_BYTES: () => KEY_BYTES,
-  EncryptionError: () => EncryptionError
+  NONCE_BYTES: () => NONCE_BYTES,
+  TAG_BYTES: () => TAG_BYTES,
+  decodeEncryptedEnvelope: () => decodeEncryptedEnvelope,
+  decrypt: () => decrypt,
+  decryptOrThrow: () => decryptOrThrow,
+  encodeEncryptedEnvelope: () => encodeEncryptedEnvelope,
+  encrypt: () => encrypt,
+  generateDocumentKey: () => generateDocumentKey,
+  openEnvelope: () => openEnvelope,
+  sealEnvelope: () => sealEnvelope
 });
 import nacl from "tweetnacl";
 function generateDocumentKey() {
@@ -4276,79 +4278,79 @@ function randomBytes(n) {
   return out;
 }
 export {
-  wasMeshStateResolved,
-  verify,
-  signingKeyPairFromSecret,
-  sign,
-  serialisePairingToken,
-  serialiseKeyring,
-  revokePeerLocally,
-  resolveDocumentId,
-  resetMeshState,
-  registerRedirectDetector,
-  registerDocIdResolver,
-  parsePairingToken,
-  memoryKeyringStorage,
-  isPairingTokenExpired,
-  isMeshStateConfigured,
-  isBlobRef,
-  getStorageOpenError,
-  getRedirectDetector,
-  getMeshStateModuleId,
-  getLazyWrappers,
-  getLazyReachedRepo,
-  getLazyInvocations,
-  getLastLoadedRejection,
-  getLastConfiguredRepoPeerId,
-  getDocIdResolver,
-  generateSigningKeyPair,
-  generateDocumentKey,
-  encrypt,
-  encodeRevocation,
-  encodePairingToken,
-  deserialiseKeyring,
-  deriveDocumentId,
-  decryptOrThrow,
-  decrypt,
-  decodeRevocation,
-  decodePairingToken,
-  createRevocation,
-  createPairingTokenWithFreshIdentity,
-  createPairingToken,
-  createMeshClient,
-  createBlobStore,
-  createBlobRef,
-  configureMeshState,
-  computeBlobHash,
-  applyRevocation,
-  applyPairingToken,
-  SigningError,
-  SIGNATURE_BYTES as SIGNING_SIGNATURE_BYTES,
-  SECRET_KEY_BYTES as SIGNING_SECRET_KEY_BYTES,
-  PUBLIC_KEY_BYTES as SIGNING_PUBLIC_KEY_BYTES,
-  RevocationError,
-  REVOCATION_RECORD_VERSION,
-  REVOCATION_MAGIC,
-  PairingError,
-  PAIRING_TOKEN_VERSION,
-  PAIRING_NONCE_BYTES,
-  MeshWebRTCAdapter,
-  MeshSignalingClient,
-  MeshNetworkAdapter,
-  MemoryBlobCache,
-  MESH_STATE_MODULE_ID,
-  IndexedDBBlobCache,
-  EncryptionError,
-  TAG_BYTES as ENCRYPTION_TAG_BYTES,
-  NONCE_BYTES as ENCRYPTION_NONCE_BYTES,
-  KEY_BYTES as ENCRYPTION_KEY_BYTES,
-  DEFAULT_PAIRING_TTL_MS,
-  DEFAULT_MESH_KEY_ID,
-  DEFAULT_ICE_SERVERS,
-  $meshText,
-  $meshState,
+  $meshCounter,
   $meshList,
-  $meshCounter
+  $meshState,
+  $meshText,
+  DEFAULT_ICE_SERVERS,
+  DEFAULT_MESH_KEY_ID,
+  DEFAULT_PAIRING_TTL_MS,
+  KEY_BYTES as ENCRYPTION_KEY_BYTES,
+  NONCE_BYTES as ENCRYPTION_NONCE_BYTES,
+  TAG_BYTES as ENCRYPTION_TAG_BYTES,
+  EncryptionError,
+  IndexedDBBlobCache,
+  MESH_STATE_MODULE_ID,
+  MemoryBlobCache,
+  MeshNetworkAdapter,
+  MeshSignalingClient,
+  MeshWebRTCAdapter,
+  PAIRING_NONCE_BYTES,
+  PAIRING_TOKEN_VERSION,
+  PairingError,
+  REVOCATION_MAGIC,
+  REVOCATION_RECORD_VERSION,
+  RevocationError,
+  PUBLIC_KEY_BYTES as SIGNING_PUBLIC_KEY_BYTES,
+  SECRET_KEY_BYTES as SIGNING_SECRET_KEY_BYTES,
+  SIGNATURE_BYTES as SIGNING_SIGNATURE_BYTES,
+  SigningError,
+  applyPairingToken,
+  applyRevocation,
+  computeBlobHash,
+  configureMeshState,
+  createBlobRef,
+  createBlobStore,
+  createMeshClient,
+  createPairingToken,
+  createPairingTokenWithFreshIdentity,
+  createRevocation,
+  decodePairingToken,
+  decodeRevocation,
+  decrypt,
+  decryptOrThrow,
+  deriveDocumentId,
+  deserialiseKeyring,
+  encodePairingToken,
+  encodeRevocation,
+  encrypt,
+  generateDocumentKey,
+  generateSigningKeyPair,
+  getDocIdResolver,
+  getLastConfiguredRepoPeerId,
+  getLastLoadedRejection,
+  getLazyInvocations,
+  getLazyReachedRepo,
+  getLazyWrappers,
+  getMeshStateModuleId,
+  getRedirectDetector,
+  getStorageOpenError,
+  isBlobRef,
+  isMeshStateConfigured,
+  isPairingTokenExpired,
+  memoryKeyringStorage,
+  parsePairingToken,
+  registerDocIdResolver,
+  registerRedirectDetector,
+  resetMeshState,
+  resolveDocumentId,
+  revokePeerLocally,
+  serialiseKeyring,
+  serialisePairingToken,
+  sign,
+  signingKeyPairFromSecret,
+  verify,
+  wasMeshStateResolved
 };
 
-//# debugId=7FA8CE30CEE539D264756E2164756E21
+//# debugId=B7E4A5DD6C20ECAA64756E2164756E21