@arbidocs/react 0.5.111 → 0.5.112

package/dist/chunk-LSU4UPS5.js

@@ -1,1011 +0,0 @@
-import { useDocumentTools, SIGNED_LOCKED_REASON, fetchMarkupPdf, fetchDocumentFile, fetchDocumentPdf } from './chunk-QMY2JKBI.js';
-import { mergeLayers, AnnotationStoreOfflineError } from './chunk-T4CLW3DN.js';
-import { parseLayer, emptyLayer, LAYER_SCHEMA_VERSION } from './chunk-T3USOSVN.js';
-import { documentBytesKey, arbiQueryKeys, useArbiHost } from './chunk-ZM6N7YZH.js';
-import { parseVersionRef } from './chunk-UW2SGTI5.js';
-import { useMemo, useState, useCallback, useEffect, useSyncExternalStore } from 'react';
-import { onlineManager, useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
-import { unlockIdentityWithPassword, signMessage, getUserEncryptionKeypair, sealedBoxDecrypt, sealedBoxEncrypt, initSodium } from '@arbidocs/client';
-import { workspaces } from '@arbidocs/sdk/browser';
-
-// src/document-tools/markup-store.ts
-var MAX_MERGE_ATTEMPTS = 5;
-var KEEPALIVE_LIMIT = 6e4;
-var MarkupStoreError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-    this.name = "MarkupStoreError";
-  }
-  status;
-};
-var detailOf = (error, fallback) => {
-  const detail3 = error?.detail;
-  return typeof detail3 === "string" ? detail3 : fallback;
-};
-async function call(request) {
-  try {
-    return await request();
-  } catch (e) {
-    if (e instanceof TypeError || typeof navigator !== "undefined" && !navigator.onLine) {
-      throw new AnnotationStoreOfflineError();
-    }
-    throw e;
-  }
-}
-function createMarkupStore({ version, client, onSaved }) {
-  let revision = 0;
-  let count = 0;
-  let canEdit = false;
-  let base = null;
-  const seen = /* @__PURE__ */ new Set();
-  const remember = (layer) => {
-    for (const a of layer.annotations) seen.add(a.id);
-  };
-  const query = version ? { version } : {};
-  async function read(documentId, ifNoneMatch) {
-    const { data, error, response } = await call(
-      () => client.GET("/v1/document/{document_ext_id}/markup", {
-        params: { path: { document_ext_id: documentId }, query },
-        headers: ifNoneMatch === void 0 ? void 0 : { "If-None-Match": `"${ifNoneMatch}"` }
-      })
-    );
-    if (response.status === 304) return null;
-    if (error || !data) {
-      throw new MarkupStoreError(
-        detailOf(error, `The markup could not be loaded (${response.status})`),
-        response.status
-      );
-    }
-    const layer = parseLayer({
-      schema: LAYER_SCHEMA_VERSION,
-      documentId,
-      annotations: data.annotations ?? [],
-      updatedAt: data.updated_at ?? (/* @__PURE__ */ new Date()).toISOString()
-    });
-    return { revision: data.revision ?? 0, layer, canEdit: !!data.can_edit };
-  }
-  function adopt(server) {
-    revision = server.revision;
-    canEdit = server.canEdit;
-    base = server.layer;
-    count = server.layer.annotations.length;
-    remember(server.layer);
-  }
-  async function put(layer, from) {
-    return call(
-      () => client.PUT("/v1/document/{document_ext_id}/markup", {
-        params: { path: { document_ext_id: layer.documentId }, query },
-        headers: { "If-Match": `"${from}"` },
-        body: { annotations: layer.annotations, base_revision: from },
-        // A save started as the page closes must outlive it; browsers cap such bodies at 64 KB.
-        keepalive: JSON.stringify(layer.annotations).length < KEEPALIVE_LIMIT
-      })
-    );
-  }
-  return {
-    snapshot: () => ({ revision, count, canEdit }),
-    canEdit: () => canEdit,
-    async load(documentId) {
-      const server = await read(documentId);
-      if (!server) throw new MarkupStoreError("The markup could not be loaded");
-      adopt(server);
-      return server.layer;
-    },
-    async save(layer) {
-      remember(layer);
-      let mine = layer;
-      for (let attempt = 0; attempt < MAX_MERGE_ATTEMPTS; attempt++) {
-        const { data, error, response } = await put(mine, revision);
-        if (response.ok && data) {
-          revision = data.revision;
-          count = data.count;
-          base = mine;
-          remember(mine);
-          onSaved?.({ revision, count, canEdit });
-          return mine;
-        }
-        if (response.status === 409) {
-          const latest = await read(layer.documentId);
-          if (!latest) throw new MarkupStoreError("The markup could not be re-read");
-          const deleted = new Set(
-            [...seen].filter((id) => !mine.annotations.some((a) => a.id === id))
-          );
-          const merged = mergeLayers({ base, mine, theirs: latest.layer, deleted });
-          revision = latest.revision;
-          canEdit = latest.canEdit;
-          base = latest.layer;
-          remember(latest.layer);
-          mine = merged;
-          continue;
-        }
-        if (response.status === 403) canEdit = false;
-        throw new MarkupStoreError(
-          detailOf(error, `The markup could not be saved (${response.status})`),
-          response.status
-        );
-      }
-      throw new MarkupStoreError("The markup keeps changing; it will be saved on the next edit");
-    },
-    async pull(documentId) {
-      const server = await read(documentId, revision);
-      if (!server || server.revision === revision) return null;
-      adopt(server);
-      return server.layer;
-    }
-  };
-}
-
-// src/document-tools/markup-transfer.ts
-var LEGACY_LAYER_PREFIX = "arbi:annotations:";
-function storage() {
-  try {
-    return typeof localStorage === "undefined" ? void 0 : localStorage;
-  } catch {
-    return void 0;
-  }
-}
-function readLegacyLayer(documentId) {
-  try {
-    const raw = storage()?.getItem(LEGACY_LAYER_PREFIX + documentId);
-    if (!raw) return null;
-    return parseLayer(JSON.parse(raw));
-  } catch {
-    return null;
-  }
-}
-function forgetLegacyLayer(documentId) {
-  try {
-    storage()?.removeItem(LEGACY_LAYER_PREFIX + documentId);
-  } catch {
-  }
-}
-function marksByVersion(layer, versions) {
-  const sorted = [...versions].sort((a, b) => a.n - b.n);
-  const out = /* @__PURE__ */ new Map();
-  for (const mark of layer.annotations) {
-    const at = Date.parse(mark.createdAt);
-    let target = sorted[0]?.n ?? 1;
-    for (const v of sorted) {
-      const created = v.created_at ? Date.parse(v.created_at) : Number.NaN;
-      if (!Number.isNaN(created) && !Number.isNaN(at) && created <= at) target = v.n;
-    }
-    out.set(target, [...out.get(target) ?? [], mark]);
-  }
-  return out;
-}
-async function addToMarkup(documentId, version, marks, client) {
-  const store = createMarkupStore({ version, client });
-  const current = await store.load(documentId);
-  const incoming = {
-    ...emptyLayer(documentId, (/* @__PURE__ */ new Date()).toISOString()),
-    annotations: marks
-  };
-  const merged = mergeLayers({ base: null, mine: current, theirs: incoming });
-  const added = merged.annotations.length - current.annotations.length;
-  if (added > 0) await store.save(parseLayer({ ...merged, schema: LAYER_SCHEMA_VERSION }));
-  return added;
-}
-async function migrateLegacyLayer(documentId, layer, versions, currentVersion, client) {
-  let added = 0;
-  for (const [n, marks] of marksByVersion(layer, versions.length ? versions : [{ n: 1 }])) {
-    added += await addToMarkup(documentId, n === currentVersion ? void 0 : n, marks, client);
-  }
-  forgetLegacyLayer(documentId);
-  return added;
-}
-async function openThreadsOf(documentId, version, client) {
-  const layer = await createMarkupStore({ version, client }).load(documentId);
-  return layer.annotations.filter((a) => a.kind === "comment" && !a.resolved);
-}
-async function copyOpenThreads(documentId, fromVersion, client) {
-  const threads = await openThreadsOf(documentId, fromVersion, client);
-  if (!threads.length) return 0;
-  return addToMarkup(documentId, void 0, threads, client);
-}
-function versionsWithMarkup(versions) {
-  return (versions ?? []).filter((v) => (v.markup_count ?? 0) > 0);
-}
-var SIGNED_UNCHANGED = "The signed PDF is unchanged: the comments are kept beside it as markup.";
-function useDocumentMarkup(documentData, snapshotVersion, currentSigned = false) {
-  const { client, notify, saveFile, onDocumentsChanged } = useDocumentTools();
-  const documentId = documentData?.external_id;
-  const currentVersion = documentData?.current_version ?? 1;
-  const shownVersion = snapshotVersion ?? currentVersion;
-  const versions = useMemo(() => documentData?.versions ?? [], [documentData?.versions]);
-  const [localCounts, setLocalCounts] = useState({});
-  const countOf = useCallback(
-    (n) => localCounts[`${documentId}@${n}`] ?? versions.find((v) => v.n === n)?.markup_count ?? 0,
-    [localCounts, documentId, versions]
-  );
-  const hasMarkup = countOf(shownVersion) > 0;
-  const [showOriginal, setShowOriginal] = useState(false);
-  useEffect(() => setShowOriginal(false), [documentId, snapshotVersion]);
-  const refresh = useCallback(() => {
-    if (!documentId || !onDocumentsChanged) return;
-    Promise.resolve(onDocumentsChanged([documentId], "markup")).catch(
-      (e) => console.warn("Could not refresh the document after a markup change", e)
-    );
-  }, [documentId, onDocumentsChanged]);
-  const onMarkupChange = useCallback(
-    (snapshot) => {
-      if (!documentId) return;
-      const key = `${documentId}@${shownVersion}`;
-      if (countOf(shownVersion) > 0 !== snapshot.count > 0) refresh();
-      setLocalCounts((counts) => ({ ...counts, [key]: snapshot.count }));
-    },
-    [documentId, shownVersion, countOf, refresh]
-  );
-  const downloadMarkup = useCallback(async () => {
-    if (!documentId) return;
-    if (currentSigned) {
-      notify(SIGNED_LOCKED_REASON, "info");
-      return;
-    }
-    try {
-      const { blob, fileName } = await fetchMarkupPdf(
-        client,
-        documentId,
-        snapshotVersion ? snapshotVersion : void 0
-      );
-      saveFile(blob, fileName);
-    } catch (e) {
-      notify(e instanceof Error ? e.message : "The markup could not be downloaded", "error");
-    }
-  }, [client, documentId, snapshotVersion, saveFile, notify, currentSigned]);
-  const [legacyCount, setLegacyCount] = useState(0);
-  const [migrating, setMigrating] = useState(false);
-  const shared = documentData?.shared;
-  const loaded = !!documentData;
-  const migrate = useCallback(async () => {
-    if (!documentId) return;
-    const layer = readLegacyLayer(documentId);
-    if (!layer) return;
-    setMigrating(true);
-    try {
-      const added = await migrateLegacyLayer(documentId, layer, versions, currentVersion, client);
-      setLegacyCount(0);
-      setLocalCounts({});
-      refresh();
-      if (added > 0) {
-        notify(
-          `${added} annotation${added === 1 ? "" : "s"} from this browser saved to the document`,
-          "success",
-          {
-            description: shared ? "They are now part of the shared markup." : "They are saved with the document, visible only to you."
-          }
-        );
-      }
-    } catch (e) {
-      notify(
-        e instanceof Error ? e.message : "The annotations from this browser could not be saved",
-        "error",
-        { description: "They are still kept in this browser; open the document again to retry." }
-      );
-    } finally {
-      setMigrating(false);
-    }
-  }, [client, documentId, versions, currentVersion, refresh, shared, notify]);
-  useEffect(() => {
-    if (!documentId || !loaded) return;
-    const layer = readLegacyLayer(documentId);
-    if (!layer) {
-      setLegacyCount(0);
-      return;
-    }
-    if (layer.annotations.length === 0) {
-      forgetLegacyLayer(documentId);
-      setLegacyCount(0);
-      return;
-    }
-    if (shared) setLegacyCount(layer.annotations.length);
-    else void migrate();
-  }, [documentId, loaded, shared]);
-  const legacyPrompt = legacyCount > 0 && !snapshotVersion ? {
-    count: legacyCount,
-    busy: migrating,
-    add: () => void migrate(),
-    discard: () => {
-      if (documentId) forgetLegacyLayer(documentId);
-      setLegacyCount(0);
-    }
-  } : null;
-  const [copying, setCopying] = useState(false);
-  const olderWithMarkup = versionsWithMarkup(versions).filter((v) => v.n !== currentVersion).sort((a, b) => b.n - a.n)[0];
-  const olderNote = !snapshotVersion && !hasMarkup && olderWithMarkup ? {
-    version: olderWithMarkup.n,
-    busy: copying,
-    signed: currentSigned,
-    copy: () => {
-      if (!documentId) return;
-      setCopying(true);
-      copyOpenThreads(documentId, olderWithMarkup.n, client).then((n) => {
-        if (n > 0) {
-          setLocalCounts((c) => ({ ...c, [`${documentId}@${currentVersion}`]: n }));
-          refresh();
-        }
-        notify(
-          n > 0 ? `${n} open comment thread${n === 1 ? "" : "s"} copied to version ${currentVersion}` : `Version ${olderWithMarkup.n} has no open comments`,
-          n > 0 ? "success" : "info",
-          // The markup is stored beside the version, so the sealed bytes do not change.
-          n > 0 && currentSigned ? { description: SIGNED_UNCHANGED } : void 0
-        );
-      }).catch(
-        (e) => notify(e instanceof Error ? e.message : "The comments could not be copied", "error")
-      ).finally(() => setCopying(false));
-    }
-  } : null;
-  return {
-    hasMarkup,
-    showOriginal,
-    setShowOriginal,
-    onMarkupChange,
-    downloadMarkup,
-    legacyPrompt,
-    olderNote
-  };
-}
-
-// src/document-tools/frozen-copy.ts
-var baseName = (fileName) => (fileName || "document").replace(/\.pdf$/i, "");
-function frozenCopyName(fileName, redacted) {
-  return `${baseName(fileName)} (${redacted ? "redacted" : "annotated"}).pdf`;
-}
-function redactionLogName(fileName) {
-  return `${baseName(fileName)} (redaction log).csv`;
-}
-async function uploadFrozenCopy(upload, bytes, source, redacted) {
-  const file = new File([bytes], frozenCopyName(source.fileName, redacted), {
-    type: "application/pdf"
-  });
-  const query = {
-    derived_from: [source.documentId],
-    derived_role: redacted ? "redaction" : "annotated",
-    shared: source.shared
-  };
-  if (source.folder) query.folder = source.folder;
-  if (source.workspaceId) query.workspace_ext_id = source.workspaceId;
-  const response = await upload({ file, query });
-  return response?.doc_ext_ids?.[0];
-}
-
-// src/document-tools/can-annotate.ts
-function canAnnotate(s) {
-  return s.activeTab === "pdf" && s.hasPdf && !s.isImage && !s.isVideo && !s.isAudio && !s.isDownloadOnly && !s.isDraft && !s.isStreaming && !s.isSnapshot && !s.isComparing;
-}
-function useIsOnline() {
-  return useSyncExternalStore(
-    (onChange) => onlineManager.subscribe(onChange),
-    () => onlineManager.isOnline(),
-    () => true
-  );
-}
-function useDocumentBytes(documentRef, options) {
-  const { client } = useDocumentTools();
-  const { version, kind, enabled = true, fallback } = options;
-  return useQuery({
-    queryKey: documentBytesKey(documentRef, version ?? null, kind),
-    queryFn: async ({ signal }) => {
-      if (fallback && typeof navigator !== "undefined" && navigator.onLine === false) {
-        const offline = await fallback();
-        if (offline) return offline;
-      }
-      try {
-        return await (kind === "original" ? fetchDocumentFile : fetchDocumentPdf)(
-          client,
-          documentRef,
-          { signal }
-        );
-      } catch (error) {
-        const offline = await fallback?.();
-        if (offline) return offline;
-        throw error;
-      }
-    },
-    enabled: enabled && !!documentRef,
-    // 'always' so it still runs offline: the fallback serves a copy kept on this device.
-    networkMode: "always",
-    staleTime: Infinity
-  });
-}
-function intentText(signer) {
-  return `I, ${signer.name.trim()}, sign this document electronically. I intend this electronic signature to have the same effect as my handwritten signature.`;
-}
-async function sha256Hex(blob) {
-  const digest = await crypto.subtle.digest("SHA-256", new Uint8Array(await blob.arrayBuffer()));
-  return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
-}
-function toAppearance(box) {
-  return { page: box.page - 1, x: box.rect.x, y: box.rect.y, width: box.rect.w, height: box.rect.h };
-}
-var MIN_SIGNATURE_BOX = { width: 0.3, height: 0.07 };
-function isLegibleSignatureBox(rect) {
-  return rect.w >= MIN_SIGNATURE_BOX.width && rect.h >= MIN_SIGNATURE_BOX.height;
-}
-var SIGNATURES_PATH = "/v1/document/{document_ext_id}/signatures";
-function errorDetail(error, fallback) {
-  const detail3 = error?.detail;
-  return typeof detail3 === "string" ? detail3 : fallback;
-}
-async function fetchDocumentSignatures(client, documentRef) {
-  const { docId, version } = parseVersionRef(documentRef);
-  const { data, error } = await client.GET(SIGNATURES_PATH, {
-    params: { path: { document_ext_id: docId }, ...version ? { query: { version } } : {} }
-  });
-  if (!data) throw new Error(errorDetail(error, "The signatures could not be read"));
-  return data;
-}
-function useDocumentSignatures(documentId, enabled = true) {
-  const { client } = useDocumentTools();
-  const { docId, version } = parseVersionRef(documentId);
-  return useQuery({
-    queryKey: arbiQueryKeys.documentSignatures(docId ?? "", version),
-    queryFn: () => fetchDocumentSignatures(client, documentId),
-    enabled: enabled && !!docId,
-    staleTime: 6e4
-  });
-}
-var SigningError = class extends Error {
-  reason;
-  constructor(message, reason) {
-    super(message);
-    this.name = "SigningError";
-    this.reason = reason;
-  }
-};
-function signingErrorReason(detail3) {
-  if (/still being prepared/i.test(detail3)) return "preparing";
-  if (/no longer the current version/i.test(detail3)) return "stale";
-  return "failed";
-}
-function signingError(error, fallback) {
-  const detail3 = errorDetail(error, fallback);
-  return new SigningError(detail3, signingErrorReason(detail3));
-}
-var PREPARE_RETRIES = 3;
-var PREPARE_RETRY_DELAY_MS = 1500;
-var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function signDocument(client, deploymentDomain, {
-  documentId,
-  pdfBlob,
-  email,
-  password,
-  signer,
-  appearance,
-  includeDate = false,
-  version
-}) {
-  const path = { document_ext_id: documentId };
-  const body = {
-    signer: { name: signer.name },
-    ...appearance ? { appearance } : {},
-    include_date: includeDate,
-    ...version ? { version } : {}
-  };
-  const prepare = () => client.POST("/v1/document/{document_ext_id}/sign/prepare", { params: { path }, body });
-  let prepared = await prepare();
-  for (let attempt = 0; !prepared.data && attempt < PREPARE_RETRIES; attempt++) {
-    if (signingError(prepared.error, "").reason !== "preparing") break;
-    await wait(PREPARE_RETRY_DELAY_MS);
-    prepared = await prepare();
-  }
-  if (!prepared.data) throw signingError(prepared.error, "Could not prepare signing");
-  const { statement, intent, source_sha256, timestamp } = prepared.data;
-  if (await sha256Hex(pdfBlob) !== source_sha256) {
-    throw new Error("The document changed since it was opened. Reopen it and sign again.");
-  }
-  if (intent !== intentText(signer)) throw new Error("Signing statement mismatch; not signed.");
-  const identity = await unlockIdentityWithPassword(email, password, deploymentDomain);
-  const signed = await client.POST("/v1/document/{document_ext_id}/sign", {
-    params: { path },
-    body: { ...body, timestamp, signature: signMessage(statement, identity) }
-  });
-  if (!signed.data) throw signingError(signed.error, "Signing failed");
-  return signed.data;
-}
-function useSignDocument() {
-  const env = useDocumentTools();
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (vars) => {
-      if (!env.deploymentDomain) throw new Error("Signing is not set up: no deployment domain");
-      return signDocument(env.client, env.deploymentDomain, vars);
-    },
-    onSuccess: async (result) => {
-      await env.onDocumentsChanged?.([result.doc_ext_id], "signed");
-      await queryClient.invalidateQueries({ queryKey: arbiQueryKeys.documentSignatures() });
-    }
-  });
-}
-var VERIFY_PATH = "/v1/sign/verify/{reference}";
-var REFERENCE = /^sig-[0-9a-f]{32}$/;
-function isSignatureReference(reference) {
-  return !!reference && REFERENCE.test(reference);
-}
-var SignatureVerificationError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-    this.name = "SignatureVerificationError";
-  }
-  status;
-};
-var VERIFY_ERRORS = {
-  404: "No signature has this reference.",
-  429: "Too many checks, try again in a minute."
-};
-async function fetchSignatureVerification(client, reference) {
-  if (!isSignatureReference(reference)) {
-    throw new SignatureVerificationError("This is not a signature reference.");
-  }
-  const { data, response } = await client.GET(VERIFY_PATH, {
-    params: { path: { reference } }
-  });
-  if (!response.ok || !data) {
-    throw new SignatureVerificationError(
-      VERIFY_ERRORS[response.status] ?? "The signature could not be checked right now.",
-      response.status
-    );
-  }
-  return data;
-}
-function useSignatureVerification(reference) {
-  const { client } = useDocumentTools();
-  return useQuery({
-    queryKey: arbiQueryKeys.signatureVerification(reference ?? ""),
-    queryFn: () => fetchSignatureVerification(client, reference),
-    enabled: !!reference,
-    retry: false
-  });
-}
-async function matchSignedCopy(file, verification) {
-  const hash = await sha256Hex(file);
-  if (hash === verification.document_sha256.toLowerCase()) return { kind: "current" };
-  const signature = verification.signatures.find((s) => s.sha256.toLowerCase() === hash);
-  return signature ? { kind: "earlier", signature } : { kind: "none" };
-}
-function useOpenWorkspaceRead() {
-  const arbi = useArbiHost().arbi;
-  const workspaceId = arbi?.hasWorkspace ? arbi.getWorkspaceId() : void 0;
-  const read = (run) => arbi && workspaceId ? arbi.readInWorkspace(workspaceId, run) : run();
-  return { workspaceId, read };
-}
-var SIGNATURE_FIELD_TYPES = [
-  "signature",
-  "initials",
-  "date",
-  "name"
-];
-var FIELD_TYPE_LABELS = {
-  signature: "Signature",
-  initials: "Initials",
-  date: "Date signed",
-  name: "Name"
-};
-var DEFAULT_FIELD_SIZE = {
-  signature: { width: 0.28, height: 0.05 },
-  initials: { width: 0.1, height: 0.04 },
-  date: { width: 0.22, height: 0.028 },
-  name: { width: 0.28, height: 0.028 }
-};
-var SIGNER_PROGRESS_LABELS = {
-  invited: "Invited",
-  registered: "Not opened yet",
-  viewed: "Viewed",
-  signed: "Signed",
-  declined: "Declined"
-};
-var EMAIL = /^[^@\s<>,;]{1,64}@[^@\s<>,;]{1,255}\.[^@\s<>,;]{1,63}$/;
-var isEmailSigner = (signer) => EMAIL.test(signer.trim());
-var MARK_FIELD_TYPES = ["signature", "initials"];
-function detail(error, fallback) {
-  const d = error?.detail;
-  if (typeof d === "string") return d;
-  if (Array.isArray(d) && d[0] && typeof d[0] === "object" && "msg" in d[0]) {
-    return String(d[0].msg);
-  }
-  return fallback;
-}
-function newFieldId() {
-  return `f${Math.random().toString(36).slice(2, 10)}`;
-}
-function initialsOf(name) {
-  return name.split(/\s+/).filter(Boolean).map((part) => part[0].toUpperCase()).join("").slice(0, 4);
-}
-function fieldsInSigningOrder(fields, signer) {
-  return fields.filter((f) => f.signer === signer).sort((a, b) => a.page - b.page || a.y - b.y || a.x - b.x);
-}
-function sendBlocker(fields) {
-  if (fields.length === 0) return "Place at least one field.";
-  const signers = [...new Set(fields.map((f) => f.signer))];
-  for (const signer of signers) {
-    if (!fields.some((f) => f.signer === signer && MARK_FIELD_TYPES.includes(f.type))) {
-      return "Every signer needs a signature or initials field.";
-    }
-  }
-  return null;
-}
-function fieldsFromSuggestions(suggestions, assign, members = /* @__PURE__ */ new Map()) {
-  return suggestions.flatMap((s) => {
-    const email = s.signer_email?.toLowerCase();
-    const signer = email ? members.get(email) ?? email : assign[s.group];
-    if (!signer) return [];
-    return [
-      {
-        id: newFieldId(),
-        type: s.type,
-        page: s.page,
-        x: s.x,
-        y: s.y,
-        width: s.width,
-        height: s.height,
-        signer,
-        required: s.required ?? true
-      }
-    ];
-  });
-}
-function splitSuggestions(suggestions) {
-  return {
-    placed: suggestions.filter((s) => s.source === "anchor"),
-    extras: suggestions.filter((s) => s.source !== "anchor")
-  };
-}
-async function fetchDocumentSignatureRequests(client, documentId) {
-  const { data, error } = await client.GET("/v1/document/{document_ext_id}/signature-requests", {
-    params: { path: { document_ext_id: documentId } }
-  });
-  if (!data) throw new Error(detail(error, "The signature requests could not be read"));
-  return data;
-}
-function useDocumentSignatureRequests(documentId, enabled = true) {
-  const { client } = useDocumentTools();
-  return useQuery({
-    queryKey: arbiQueryKeys.signatureRequestsForDocument(documentId ?? ""),
-    queryFn: () => fetchDocumentSignatureRequests(client, documentId),
-    enabled: enabled && !!documentId,
-    staleTime: 15e3
-  });
-}
-async function signatureFieldSuggestions(client, documentId, version) {
-  const { data, error } = await client.GET(
-    "/v1/document/{document_ext_id}/signature-fields/suggest",
-    {
-      params: { path: { document_ext_id: documentId }, ...version ? { query: { version } } : {} }
-    }
-  );
-  if (!data) throw new Error(detail(error, "Signature blocks could not be read"));
-  return { fields: data.fields, signers: data.signers ?? [] };
-}
-async function suggestSignatureFields(client, documentId, version) {
-  return (await signatureFieldSuggestions(client, documentId, version)).fields;
-}
-async function saveSignatureRequest(client, { documentId, version, fields, message, requestId, send }) {
-  if (!requestId) {
-    const { data, error } = await client.POST("/v1/document/{document_ext_id}/signature-requests", {
-      params: { path: { document_ext_id: documentId } },
-      body: { fields, message: message || null, send, ...version ? { version } : {} }
-    });
-    if (!data) throw new Error(detail(error, "The signature request could not be saved"));
-    return data;
-  }
-  const path = { request_ext_id: requestId };
-  const updated = await client.PATCH("/v1/signature-requests/{request_ext_id}", {
-    params: { path },
-    body: { fields, message: message ?? null }
-  });
-  if (!updated.data) throw new Error(detail(updated.error, "The draft could not be saved"));
-  if (!send) return updated.data;
-  const sent = await client.POST("/v1/signature-requests/{request_ext_id}/send", {
-    params: { path }
-  });
-  if (!sent.data) throw new Error(detail(sent.error, "The request could not be sent"));
-  return sent.data;
-}
-function useInvalidateRequests() {
-  const queryClient = useQueryClient();
-  return () => queryClient.invalidateQueries({ queryKey: arbiQueryKeys.signatureRequests() });
-}
-function useSaveSignatureRequest() {
-  const { client } = useDocumentTools();
-  const invalidate = useInvalidateRequests();
-  return useMutation({
-    mutationFn: (vars) => saveSignatureRequest(client, vars),
-    onSuccess: invalidate
-  });
-}
-function useVoidSignatureRequest() {
-  const { client } = useDocumentTools();
-  const invalidate = useInvalidateRequests();
-  return useMutation({
-    mutationFn: async (requestId) => {
-      const { data, error } = await client.POST("/v1/signature-requests/{request_ext_id}/void", {
-        params: { path: { request_ext_id: requestId } }
-      });
-      if (!data) throw new Error(detail(error, "The request could not be voided"));
-      return data;
-    },
-    onSuccess: invalidate
-  });
-}
-function useDeclineSignatureRequest() {
-  const { client } = useDocumentTools();
-  const invalidate = useInvalidateRequests();
-  return useMutation({
-    mutationFn: async ({ requestId, reason }) => {
-      const { data, error } = await client.POST("/v1/signature-requests/{request_ext_id}/decline", {
-        params: { path: { request_ext_id: requestId } },
-        body: { reason: reason || null }
-      });
-      if (!data) throw new Error(detail(error, "Could not decline"));
-      return data;
-    },
-    onSuccess: invalidate
-  });
-}
-async function signSignatureRequest(client, deploymentDomain, { request, pdfBlob, email, password, adopted, fields }) {
-  const path = { request_ext_id: request.external_id };
-  const body = { adopted, fields };
-  const prepared = await client.POST("/v1/signature-requests/{request_ext_id}/sign/prepare", {
-    params: { path },
-    body
-  });
-  if (!prepared.data) {
-    throw new SigningError(detail(prepared.error, "Could not prepare signing"), "failed");
-  }
-  const { statement, intent, source_sha256, timestamp } = prepared.data;
-  if (source_sha256 !== request.source_sha256 || await sha256Hex(pdfBlob) !== source_sha256) {
-    throw new SigningError("The document changed since it was sent. Ask for it again.", "stale");
-  }
-  if (intent !== intentText({ name: adopted.name })) {
-    throw new Error("Signing statement mismatch; not signed.");
-  }
-  const identity = await unlockIdentityWithPassword(email, password, deploymentDomain);
-  const signed = await client.POST("/v1/signature-requests/{request_ext_id}/sign", {
-    params: { path },
-    body: { ...body, timestamp, signature: signMessage(statement, identity) }
-  });
-  if (!signed.data) throw new SigningError(detail(signed.error, "Signing failed"), "failed");
-  return signed.data;
-}
-function useSignSignatureRequest() {
-  const env = useDocumentTools();
-  const invalidate = useInvalidateRequests();
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (vars) => {
-      if (!env.deploymentDomain) throw new Error("Signing is not set up: no deployment domain");
-      return signSignatureRequest(env.client, env.deploymentDomain, vars);
-    },
-    onSuccess: async (result) => {
-      await invalidate();
-      if (result.completed && result.request.doc_ext_id) {
-        await env.onDocumentsChanged?.([result.request.doc_ext_id], "signed");
-        await queryClient.invalidateQueries({ queryKey: arbiQueryKeys.documentSignatures() });
-      }
-    }
-  });
-}
-function useSignerCandidates(enabled = true) {
-  const { client, user } = useDocumentTools();
-  const { workspaceId, read } = useOpenWorkspaceRead();
-  return useQuery({
-    queryKey: arbiQueryKeys.signatureCandidates(workspaceId ?? ""),
-    queryFn: async () => {
-      const { data, error } = await read(() => client.GET("/v1/workspace/users"));
-      if (!data) throw new Error(detail(error, "The workspace members could not be read"));
-      const people = data.filter((m) => m.user.external_id.startsWith("usr-")).map((m) => ({
-        externalId: m.user.external_id,
-        name: [m.user.given_name, m.user.family_name].filter(Boolean).join(" ") || m.user.email,
-        email: m.user.email,
-        role: String(m.role)
-      }));
-      const me = user?.email?.toLowerCase();
-      return [...people].sort(
-        (a, b) => Number(b.email.toLowerCase() === me) - Number(a.email.toLowerCase() === me)
-      );
-    },
-    enabled,
-    staleTime: 6e4
-  });
-}
-async function inviteSigners(client, documentId, emails) {
-  if (!emails.length) return;
-  const { error, response } = await client.POST("/v1/workspace/users", {
-    body: workspaces.addWorkspaceMembersBody({
-      emails,
-      role: "guest",
-      confirm_invite: true,
-      resource_type: "document",
-      resource_ext_id: documentId
-    })
-  });
-  if (response.status === 409) {
-    throw new Error("Share the document with the workspace before asking others to sign it.");
-  }
-  if (error && response.status !== 404) {
-    throw new Error(detail(error, "The signers could not be invited"));
-  }
-}
-function useInviteSigners() {
-  const { client } = useDocumentTools();
-  const invalidate = useInvalidateRequests();
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: ({ documentId, emails }) => inviteSigners(client, documentId, emails),
-    onSuccess: async () => {
-      await invalidate();
-      await queryClient.invalidateQueries({ queryKey: arbiQueryKeys.signatureCandidates() });
-    }
-  });
-}
-var INFORMAL_SIGNATURE_NOTE = "Your saved signature or initials are placed as an image on the document.";
-async function keypair(source = getUserEncryptionKeypair) {
-  await initSodium();
-  const pair = await source();
-  if (!pair) throw new Error("Sign in again to use your saved signature.");
-  return pair;
-}
-function detail2(error, fallback) {
-  const d = error?.detail;
-  return typeof d === "string" ? d : fallback;
-}
-async function fetchSavedSignature(client, source) {
-  const { data, error } = await client.GET("/v1/user/signature");
-  if (!data) throw new Error(detail2(error, "Your saved signature could not be read"));
-  if (!data.sealed) return null;
-  const pair = await keypair(source);
-  const json = new TextDecoder().decode(sealedBoxDecrypt(data.sealed, pair.secretKey));
-  return JSON.parse(json);
-}
-async function storeSavedSignature(client, signature, source) {
-  const pair = await keypair(source);
-  const sealed = sealedBoxEncrypt(
-    Uint8Array.from(new TextEncoder().encode(JSON.stringify(signature))),
-    pair.publicKey
-  );
-  const { error, response } = await client.PUT("/v1/user/signature", { body: { sealed } });
-  if (!response.ok) throw new Error(detail2(error, "Your signature could not be saved"));
-}
-async function deleteSavedSignature(client) {
-  const { error, response } = await client.DELETE("/v1/user/signature");
-  if (!response.ok) throw new Error(detail2(error, "Your saved signature could not be deleted"));
-}
-function useSavedSignature(enabled = true) {
-  const { client } = useDocumentTools();
-  return useQuery({
-    queryKey: arbiQueryKeys.savedSignature(),
-    queryFn: () => fetchSavedSignature(client),
-    enabled,
-    staleTime: 6e4,
-    retry: false
-  });
-}
-function useStoreSavedSignature() {
-  const { client } = useDocumentTools();
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (signature) => storeSavedSignature(client, signature),
-    onSuccess: (_, signature) => queryClient.setQueryData(arbiQueryKeys.savedSignature(), signature)
-  });
-}
-function useDeleteSavedSignature() {
-  const { client } = useDocumentTools();
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: () => deleteSavedSignature(client),
-    onSuccess: () => queryClient.setQueryData(arbiQueryKeys.savedSignature(), null)
-  });
-}
-function pngBytes(base64) {
-  const raw = atob(base64);
-  const out = new Uint8Array(raw.length);
-  for (let i = 0; i < raw.length; i++) out[i] = raw.charCodeAt(i);
-  return out;
-}
-function pngSize(base64) {
-  const bytes = pngBytes(base64.slice(0, 64));
-  const view = new DataView(bytes.buffer);
-  return { width: view.getUint32(16), height: view.getUint32(20) };
-}
-function failure(error) {
-  const detail3 = error?.detail;
-  return new Error(typeof detail3 === "string" ? detail3 : "The shared file request failed");
-}
-async function createFileShare(client, documentId, body) {
-  const result = await client.POST("/v1/document/{document_ext_id}/file-shares", {
-    params: { path: { document_ext_id: documentId } },
-    body
-  });
-  if (!result.data) throw failure(result.error);
-  return result.data;
-}
-async function getFileShare(client, id) {
-  const result = await client.GET("/v1/file-shares/{share_id}", {
-    params: { path: { share_id: id } }
-  });
-  if (!result.data) throw failure(result.error);
-  return result.data;
-}
-async function fileShareBytes(client, id, kind) {
-  const result = await client.GET("/v1/file-shares/{share_id}/file", {
-    params: { path: { share_id: id }, query: { kind } },
-    parseAs: "blob"
-  });
-  if (!result.data) throw failure(result.error);
-  return result.data;
-}
-function fileShareSigningRequest(share) {
-  return {
-    external_id: share.external_id,
-    doc_ext_id: share.document_ext_id,
-    version: share.version,
-    source_sha256: share.source_sha256,
-    fields: share.fields,
-    message: share.message,
-    status: share.status === "signing" ? "sent" : share.status === "completed" ? "completed" : "voided",
-    signers: share.recipients.filter((r) => r.permission === "sign").map((r) => ({
-      external_id: r.email,
-      email: r.email,
-      name: r.email,
-      status: r.status === "signed" ? "signed" : "pending",
-      progress: r.status === "signed" ? "signed" : "registered",
-      fields: share.fields.filter((f) => f.signer === r.email).length
-    })),
-    created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
-    stale: false
-  };
-}
-async function signFileShare(client, domain, vars) {
-  const path = { share_id: vars.request.external_id };
-  const body = { adopted: vars.adopted, fields: vars.fields };
-  const prepared = await client.POST("/v1/file-shares/{share_id}/sign/prepare", {
-    params: { path },
-    body
-  });
-  if (!prepared.data) throw failure(prepared.error);
-  const { statement, timestamp, source_sha256, intent } = prepared.data;
-  if (source_sha256 !== vars.request.source_sha256 || await sha256Hex(vars.pdfBlob) !== source_sha256)
-    throw new Error("The shared file changed. Ask the sender for a new request.");
-  if (intent !== intentText({ name: vars.adopted.name }))
-    throw new Error("Signing statement mismatch");
-  const identity = await unlockIdentityWithPassword(vars.email, vars.password, domain);
-  const result = await client.POST("/v1/file-shares/{share_id}/sign", {
-    params: { path },
-    body: { ...body, timestamp, signature: signMessage(statement, identity) }
-  });
-  if (!result.data) throw failure(result.error);
-  return {
-    request: fileShareSigningRequest(result.data),
-    completed: result.data.status === "completed"
-  };
-}
-function useFileShare(client, shareId, signing) {
-  return useQuery({
-    queryKey: arbiQueryKeys.fileShare(shareId),
-    queryFn: () => getFileShare(client, shareId),
-    refetchInterval: signing ? false : 5e3
-  });
-}
-function useFileSharePdf(client, shareId, share) {
-  return useQuery({
-    queryKey: arbiQueryKeys.fileSharePdf(shareId, share?.status),
-    queryFn: () => fileShareBytes(client, shareId, share?.status === "completed" ? "signed" : "view"),
-    enabled: !!share?.can_preview,
-    staleTime: Infinity
-  });
-}
-function useFileShares(client) {
-  return useQuery({
-    queryKey: arbiQueryKeys.fileShares(),
-    queryFn: async () => {
-      const result = await client.GET("/v1/file-shares");
-      if (!result.data) throw new Error("Could not load shared files");
-      return result.data;
-    }
-  });
-}
-
-export { DEFAULT_FIELD_SIZE, FIELD_TYPE_LABELS, INFORMAL_SIGNATURE_NOTE, LEGACY_LAYER_PREFIX, MARK_FIELD_TYPES, MAX_MERGE_ATTEMPTS, MarkupStoreError, SIGNATURE_FIELD_TYPES, SIGNED_UNCHANGED, SIGNER_PROGRESS_LABELS, SignatureVerificationError, SigningError, VERIFY_PATH, addToMarkup, canAnnotate, copyOpenThreads, createFileShare, createMarkupStore, deleteSavedSignature, fetchDocumentSignatureRequests, fetchDocumentSignatures, fetchSavedSignature, fetchSignatureVerification, fieldsFromSuggestions, fieldsInSigningOrder, fileShareBytes, fileShareSigningRequest, forgetLegacyLayer, frozenCopyName, getFileShare, initialsOf, intentText, inviteSigners, isEmailSigner, isLegibleSignatureBox, isSignatureReference, marksByVersion, matchSignedCopy, migrateLegacyLayer, newFieldId, openThreadsOf, pngBytes, pngSize, readLegacyLayer, redactionLogName, saveSignatureRequest, sendBlocker, sha256Hex, signDocument, signFileShare, signSignatureRequest, signatureFieldSuggestions, splitSuggestions, storeSavedSignature, suggestSignatureFields, toAppearance, uploadFrozenCopy, useDeclineSignatureRequest, useDeleteSavedSignature, useDocumentBytes, useDocumentMarkup, useDocumentSignatureRequests, useDocumentSignatures, useFileShare, useFileSharePdf, useFileShares, useInviteSigners, useIsOnline, useSaveSignatureRequest, useSavedSignature, useSignDocument, useSignSignatureRequest, useSignatureVerification, useSignerCandidates, useStoreSavedSignature, useVoidSignatureRequest, versionsWithMarkup };
-//# sourceMappingURL=chunk-LSU4UPS5.js.map
-//# sourceMappingURL=chunk-LSU4UPS5.js.map