@powerhousedao/reactor-attachments 6.2.2-dev.9 → 6.2.2

package/dist/client.d.ts

@@ -1,6 +1,157 @@
-import { A as ReserveAttachmentOptions, B as SizeMismatch, C as AttachmentMetadata, D as AttachmentUploadResult, E as AttachmentTransportConfig, F as AttachmentNotFound, I as AttachmentPending, L as HashMismatch, M as TransportResponse, N as UploadFirstReserveAttachmentOptions, O as HashFirstReserveAttachmentOptions, P as AttachmentAlreadyExists, R as InvalidAttachmentRef, S as AttachmentHeader, T as AttachmentStatus, V as UploadTooLarge, _ as IAttachmentTransport, a as RemoteAttachmentUpload, b as IAttachmentUploadFactory, c as SwitchboardAttachmentTransport, d as createRef, f as parseRef, g as IAttachmentStore, h as IAttachmentService, i as RemoteAttachmentUploadFactory, j as TransportFetchResult, k as Reservation, l as SwitchboardTransportConfig, m as IAttachmentReader, n as createRemoteAttachmentService, o as RemoteReservationStore, p as AttachmentService, r as RemoteAttachmentStore, s as SwitchboardClientConfig, t as NullAttachmentTransport, u as ParsedRef, v as IAttachmentTransportFactory, w as AttachmentResponse, x as IReservationStore, y as IAttachmentUpload, z as ReservationNotFound } from "./null-attachment-transport-BBhQIk5A.js";
+import { $ as AttachmentPending, A as IReservationStore, B as AttachmentStatus, C as IAttachmentReader, D as IAttachmentTransportFactory, E as IAttachmentTransport, F as AttachmentDownloadTargetOptions, G as HashFirstReserveAttachmentOptions, H as AttachmentTransportConfig, I as AttachmentHeader, J as TransportFetchResult, K as Reservation, L as AttachmentMetadata, N as AttachmentDownloadOptions, O as IAttachmentUpload, P as AttachmentDownloadTarget, Q as AttachmentNotFound, R as AttachmentResponse, T as IAttachmentStore, U as AttachmentUploadResult, V as AttachmentTargetHeaders, W as AttachmentUploadTarget, X as UploadFirstReserveAttachmentOptions, Y as TransportResponse, Z as AttachmentAlreadyExists, _ as createRef, a as RemoteAttachmentUpload, at as SizeMismatch, b as parseAttachmentDownloadTarget, c as XhrUploadTransportOptions, d as AttachmentUploadResponse, et as AttachmentTransferError, f as AttachmentUploadTransport, g as ParsedRef, h as SwitchboardTransportConfig, i as RemoteAttachmentUploadFactory, it as ReservationNotFound, k as IAttachmentUploadFactory, l as createXhrUploadTransport, m as SwitchboardAttachmentTransport, n as createRemoteAttachmentService, nt as HashMismatch, o as RemoteReservationStore, ot as UploadTooLarge, p as createFetchUploadTransport, q as ReserveAttachmentOptions, r as RemoteAttachmentStore, rt as InvalidAttachmentRef, s as SwitchboardClientConfig, t as NullAttachmentTransport, tt as AttachmentTransferStage, u as AttachmentUploadRequest, v as parseRef, w as IAttachmentService, x as parseAttachmentUploadTarget, y as AttachmentService, z as AttachmentSendOptions } from "./null-attachment-transport-CMrO_ZKA.js";
 import { AttachmentHash, AttachmentRef } from "@powerhousedao/reactor";
 
+//#region src/concurrency.d.ts
+/**
+ * Ordered result of one batch item. `index` always mirrors the input
+ * position, so callers can correlate results with inputs regardless of
+ * completion order, and successes are retained when siblings fail.
+ */
+type BatchItemResult<R> = {
+  index: number;
+  status: "fulfilled";
+  value: R;
+} | {
+  index: number;
+  status: "rejected";
+  error: unknown;
+};
+type RunWithConcurrencyOptions<R = unknown> = {
+  /** Maximum simultaneously running workers. Must be a positive integer. */concurrency: number;
+  /**
+   * Whole-batch cancellation: unstarted items are rejected with the signal's
+   * reason without ever starting, while already-started items keep running —
+   * per-item signals are the mechanism for interrupting active work.
+   */
+  signal?: AbortSignal;
+  /**
+   * Called once per item as it settles, in completion order, including items
+   * the signal skipped before they ever started. That completeness is the
+   * point: a caller counting settlements must still reach `items.length`
+   * after a whole-batch abort.
+   */
+  onSettled?: (result: BatchItemResult<R>) => void;
+};
+/**
+ * Runs `worker` over `items` with a hard upper bound on simultaneous
+ * executions. Bounding starts (not just transfers) is what keeps memory flat:
+ * an item's preprocessing (hashing/buffering) only begins when a slot frees.
+ */
+declare function runWithConcurrency<T, R>(items: readonly T[], worker: (item: T, index: number) => Promise<R>, options: RunWithConcurrencyOptions<R>): Promise<BatchItemResult<R>[]>;
+//#endregion
+//#region src/progress.d.ts
+/**
+ * Byte-level progress for attachment transfers.
+ *
+ * `loaded`/`total` are per-stage, never per-operation. A per-operation
+ * denominator would have to weight hashing against transfer, and a confirmed
+ * dedup would shrink it mid-flight from 2N to N — the bar would run backwards.
+ * Choosing that weighting is a UI decision the client cannot make.
+ */
+type AttachmentStage = "hashing" | "reserving" | "uploading" | "requesting-download-target" | "downloading" | "done" | "error";
+type AttachmentProgress = {
+  stage: AttachmentStage; /** Bytes moved so far within `stage`. */
+  loaded: number; /** Denominator for `stage`: file.size for uploads, header.sizeBytes for downloads. */
+  total: number | undefined; /** True when the stage is running but bytes cannot (yet) be observed. */
+  indeterminate: boolean; /** Only on a terminal `done` where dedup skipped the transfer entirely. */
+  deduped?: true;
+};
+type AttachmentProgressListener = (progress: AttachmentProgress) => void;
+type AttachmentProgressOptions = {
+  onProgress?: AttachmentProgressListener; /** Min ms between byte events within a stage. Default 100. 0 emits every observation. */
+  throttleMs?: number;
+};
+declare const DEFAULT_PROGRESS_THROTTLE_MS = 100;
+/**
+ * Fraction in 0..1 for a progress event. Indeterminate and unknown-total
+ * events read as 0 — a bar cannot honestly show a position it does not know.
+ * A zero total is complete by definition (the dedup case moves no bytes).
+ */
+declare function progressFraction(progress: AttachmentProgress): number;
+type ProgressEmitterOptions = AttachmentProgressOptions & {
+  /** Injected clock so throttle tests stay synchronous. */now?: () => number;
+};
+/**
+ * Emits `AttachmentProgress` for one single-item operation, upholding:
+ *
+ * - **I1** exactly one terminal event (`done` or `error`) — never both, never twice.
+ * - **I2** on `done`: `indeterminate === false`, `total` is a number, `loaded === total`.
+ * - **I3** `loaded` is non-decreasing within a stage and resets to 0 on stage change.
+ * - **I4** the terminal event bypasses the throttle unconditionally.
+ * - **I5** `error` carries the last known `loaded`/`total`.
+ *
+ * Leading edge: the first `bytes()` after a `stage()` always emits, so a bar
+ * leaves 0 immediately. There is deliberately no trailing-edge timer — it
+ * would leak on throw, could fire after the terminal event and violate I1's
+ * ordering, and is unnecessary because `finish()` always emits
+ * `loaded === total`, making a dropped last intra-stage tick invisible.
+ */
+declare class ProgressEmitter {
+  private readonly listener;
+  private readonly throttleMs;
+  private readonly now;
+  private currentStage;
+  private loaded;
+  private total;
+  private emittedBytesInStage;
+  private lastEmitAt;
+  private settled;
+  constructor(options?: ProgressEmitterOptions);
+  /** True when a listener is attached; lets callers skip instrumentation entirely. */
+  get active(): boolean;
+  /**
+   * Enter a stage. Always emits and resets `loaded` to 0. Entry is always
+   * indeterminate: no bytes have moved yet, and whether they can be observed
+   * at all is only proven by a transport actually calling back.
+   */
+  stage(stage: AttachmentStage, options?: {
+    total?: number;
+  }): void;
+  /**
+   * Report observed bytes within the current stage. Throttled by time, with
+   * the first observation after a stage change always emitted.
+   */
+  bytes(loaded: number, total?: number): void;
+  /**
+   * Terminal success. `total` defaults to the bytes actually seen so a stage
+   * with no known denominator still satisfies I2.
+   */
+  finish(override?: {
+    loaded?: number;
+    total?: number;
+    deduped?: true;
+  }): void;
+  /** Terminal success for a confirmed dedup: no bytes moved, and none needed to. */
+  finishDeduped(): void;
+  /** Terminal failure, carrying the last known byte counts. */
+  fail(): void;
+  private emit;
+}
+type ByteProgressHooks = {
+  /** Cumulative bytes handed to the consumer. */onBytes?: (loaded: number) => void; /** The source ended and every byte reached the consumer. */
+  onDone?: () => void;
+  onError?: (error: unknown) => void;
+};
+/**
+ * Count bytes as a consumer reads them.
+ *
+ * Uses the manual-reader form rather than `pipeThrough`, whose internal queue
+ * reads far ahead of the consumer and would make `loaded` overstate what was
+ * actually received. `highWaterMark: 0` is load-bearing for the same reason:
+ * at the default of 1 the wrapper pulls one chunk the instant it is
+ * constructed, so a caller who never reads still sees bytes counted.
+ *
+ * `cancel` propagates to the source, which is what keeps reader refcounts
+ * (e.g. `KyselyAttachmentStore`'s) correct. Cancelling is an abandonment, not
+ * a completion, so it reports `onError` — never `onDone` — carrying the
+ * cancel reason the way an `AbortSignal` carries its own, with the DOM's
+ * default `AbortError` when the canceller gave none.
+ *
+ * Returns `source` unchanged when no hook is supplied, so a caller with no
+ * listener pays nothing.
+ */
+declare function withByteProgress(source: ReadableStream<Uint8Array>, hooks: ByteProgressHooks): ReadableStream<Uint8Array>;
+//#endregion
 //#region src/client.d.ts
 type PreprocessResult = {
   ref: AttachmentRef;
@@ -10,14 +161,149 @@ type PreprocessResult = {
   data: ReadableStream<Uint8Array>;
   stream: () => ReadableStream<Uint8Array>;
 };
+type AttachmentUploadInput = {
+  file: Blob;
+  fileName?: string;
+  mimeType?: string; /** Per-item cancellation, checked between stages. */
+  signal?: AbortSignal;
+};
+/**
+ * Upload bytes that were already hashed by a separate `preprocess()` call.
+ *
+ * This is the canonical two-call flow: the ref must reach the document before
+ * the bytes are committed, so callers preprocess, dispatch the operation, then
+ * upload. Passing the result back in skips the hashing stage rather than
+ * faking a zero-millisecond one.
+ */
+type AttachmentPreprocessedUploadInput = {
+  preprocessed: PreprocessResult;
+  signal?: AbortSignal;
+};
+/**
+ * Every remote download names the document that authorizes its ref; batches
+ * may freely mix documents because the anchor travels with each item.
+ */
+type AttachmentDownloadInput = {
+  documentId: string;
+  ref: AttachmentRef;
+  signal?: AbortSignal;
+};
+/**
+ * The document keeps its own name and type for an attachment (the same
+ * bytes may appear under different names in different documents), so the
+ * blob-producing conveniences let callers override what the server header
+ * reports from upload time.
+ */
+type AttachmentBlobOptions = {
+  mimeType?: string;
+};
+type AttachmentSaveOptions = {
+  fileName?: string;
+  mimeType?: string;
+};
+type AttachmentBlobResult = {
+  blob: Blob;
+  header: AttachmentHeader;
+};
+type AttachmentObjectUrl = {
+  /** Ready for img/iframe/video src. Pins memory until revoke() is called. */url: string;
+  header: AttachmentHeader;
+  revoke: () => void;
+};
+type AttachmentShareLinkInput = {
+  documentId: string;
+  ref: AttachmentRef; /** Requested link lifetime in seconds; the server clamps to its maximum. */
+  expiresIn?: number;
+  signal?: AbortSignal;
+};
+/**
+ * A self-contained public URL: anyone holding it can fetch the bytes until
+ * expiresAtUtc, with no login and no document access. Minting one requires
+ * document read access; once minted it cannot be revoked before expiry.
+ */
+type AttachmentShareLink = {
+  url: string;
+  expiresAtUtc: string;
+};
+/**
+ * Batch progress is per item, carrying the item's `index`. There is
+ * deliberately no batch-wide byte total: weighting items against each other is
+ * a presentation decision the client cannot make, and a confirmed dedup would
+ * shrink the denominator mid-flight.
+ */
+type AttachmentBatchOptions = {
+  /** Bounds preprocessing and transfer together. Defaults to 4. */concurrency?: number; /** Whole-batch cancellation: stops unstarted items. */
+  signal?: AbortSignal;
+  onProgress?: (progress: AttachmentProgress & {
+    index: number;
+  }) => void;
+  /**
+   * Fired as each item settles, including items the signal skipped before they
+   * started, so `settled` always reaches `total`.
+   */
+  onItemSettled?: (counts: AttachmentBatchCounts) => void; /** Min ms between byte events, applied per item rather than batch-wide. */
+  throttleMs?: number;
+};
+type AttachmentBatchCounts = {
+  settled: number;
+  completed: number;
+  failed: number;
+  total: number;
+};
+declare const DEFAULT_ATTACHMENT_BATCH_CONCURRENCY = 4;
 interface IAttachmentClient {
   preprocess(file: Blob, opts?: {
     fileName?: string;
     mimeType?: string;
   }): Promise<PreprocessResult>;
   reserve(options: HashFirstReserveAttachmentOptions, send: (handle: IAttachmentUpload) => Promise<AttachmentUploadResult>): Promise<AttachmentUploadResult>;
+  /**
+   * Hash, reserve, and transfer one file; a confirmed dedup skips the transfer
+   * and reports a terminal `done` carrying `deduped: true` and zero bytes.
+   *
+   * Also accepts an already-preprocessed payload, so the canonical
+   * preprocess -> dispatch -> upload flow reports progress too.
+   */
+  upload(input: AttachmentUploadInput | AttachmentPreprocessedUploadInput, options?: AttachmentProgressOptions): Promise<AttachmentUploadResult>;
+  /**
+   * Document-authorized download of one ref.
+   *
+   * Resolves as soon as the byte stream is available, with `downloading` as
+   * the last event emitted and `loaded: 0`. Byte events and the terminal
+   * `done` arrive as the caller reads the stream — and never arrive at all if
+   * the caller abandons it.
+   */
+  download(input: AttachmentDownloadInput, options?: AttachmentProgressOptions): Promise<AttachmentResponse>;
+  /**
+   * Document-authorized download materialized as a typed Blob. The Blob's
+   * type comes from the server header unless overridden — that's what makes
+   * browsers render PDFs inline and images correctly.
+   */
+  downloadBlob(input: AttachmentDownloadInput, options?: AttachmentBlobOptions & AttachmentProgressOptions): Promise<AttachmentBlobResult>;
+  /**
+   * Download and hand the bytes to the browser's save-file flow. Browser
+   * only. fileName defaults to the server header's; pass the document's own
+   * name for per-document naming.
+   */
+  saveAttachment(input: AttachmentDownloadInput, options?: AttachmentSaveOptions & AttachmentProgressOptions): Promise<void>;
+  /**
+   * Download and expose the bytes as an object URL for inline rendering
+   * (img/iframe/video src). Callers MUST call revoke() when done — the URL
+   * pins the blob in memory until then.
+   */
+  downloadObjectUrl(input: AttachmentDownloadInput, options?: AttachmentBlobOptions & AttachmentProgressOptions): Promise<AttachmentObjectUrl>;
+  /**
+   * Mint a public share link: a presigned URL anyone can fetch until it
+   * expires, with no login. Authorized exactly like a download (document
+   * read access + the reference index). Requires a presigned-capable
+   * storage backend (S3); rejects when the server answers with an
+   * authenticated switchboard target, which would not be public.
+   */
+  getShareLink(input: AttachmentShareLinkInput): Promise<AttachmentShareLink>;
+  uploadMany(inputs: readonly AttachmentUploadInput[], options?: AttachmentBatchOptions): Promise<BatchItemResult<AttachmentUploadResult>[]>;
+  downloadMany(inputs: readonly AttachmentDownloadInput[], options?: AttachmentBatchOptions): Promise<BatchItemResult<AttachmentResponse>[]>;
 }
 declare function createAttachmentClient(service: IAttachmentService): IAttachmentClient;
 //#endregion
-export { AttachmentAlreadyExists, type AttachmentHeader, type AttachmentMetadata, AttachmentNotFound, AttachmentPending, type AttachmentResponse, AttachmentService, type AttachmentStatus, type AttachmentTransportConfig, type AttachmentUploadResult, type HashFirstReserveAttachmentOptions, HashMismatch, IAttachmentClient, type IAttachmentReader, type IAttachmentService, type IAttachmentStore, type IAttachmentTransport, type IAttachmentTransportFactory, type IAttachmentUpload, type IAttachmentUploadFactory, type IReservationStore, InvalidAttachmentRef, NullAttachmentTransport, type ParsedRef, PreprocessResult, RemoteAttachmentStore, RemoteAttachmentUpload, RemoteAttachmentUploadFactory, RemoteReservationStore, type Reservation, ReservationNotFound, type ReserveAttachmentOptions, SizeMismatch, SwitchboardAttachmentTransport, type SwitchboardClientConfig, type SwitchboardTransportConfig, type TransportFetchResult, type TransportResponse, type UploadFirstReserveAttachmentOptions, UploadTooLarge, createAttachmentClient, createRef, createRemoteAttachmentService, parseRef };
+export { AttachmentAlreadyExists, AttachmentBatchCounts, AttachmentBatchOptions, AttachmentBlobOptions, AttachmentBlobResult, AttachmentDownloadInput, type AttachmentDownloadOptions, type AttachmentDownloadTarget, type AttachmentDownloadTargetOptions, type AttachmentHeader, type AttachmentMetadata, AttachmentNotFound, AttachmentObjectUrl, AttachmentPending, AttachmentPreprocessedUploadInput, type AttachmentProgress, type AttachmentProgressListener, type AttachmentProgressOptions, type AttachmentResponse, AttachmentSaveOptions, type AttachmentSendOptions, AttachmentService, AttachmentShareLink, AttachmentShareLinkInput, type AttachmentStage, type AttachmentStatus, type AttachmentTargetHeaders, AttachmentTransferError, type AttachmentTransferStage, type AttachmentTransportConfig, AttachmentUploadInput, type AttachmentUploadRequest, type AttachmentUploadResponse, type AttachmentUploadResult, type AttachmentUploadTarget, type AttachmentUploadTransport, type BatchItemResult, type ByteProgressHooks, DEFAULT_ATTACHMENT_BATCH_CONCURRENCY, DEFAULT_PROGRESS_THROTTLE_MS, type HashFirstReserveAttachmentOptions, HashMismatch, IAttachmentClient, type IAttachmentReader, type IAttachmentService, type IAttachmentStore, type IAttachmentTransport, type IAttachmentTransportFactory, type IAttachmentUpload, type IAttachmentUploadFactory, type IReservationStore, InvalidAttachmentRef, NullAttachmentTransport, type ParsedRef, PreprocessResult, ProgressEmitter, type ProgressEmitterOptions, RemoteAttachmentStore, RemoteAttachmentUpload, RemoteAttachmentUploadFactory, RemoteReservationStore, type Reservation, ReservationNotFound, type ReserveAttachmentOptions, type RunWithConcurrencyOptions, SizeMismatch, SwitchboardAttachmentTransport, type SwitchboardClientConfig, type SwitchboardTransportConfig, type TransportFetchResult, type TransportResponse, type UploadFirstReserveAttachmentOptions, UploadTooLarge, type XhrUploadTransportOptions, createAttachmentClient, createFetchUploadTransport, createRef, createRemoteAttachmentService, createXhrUploadTransport, parseAttachmentDownloadTarget, parseAttachmentUploadTarget, parseRef, progressFraction, runWithConcurrency, withByteProgress };
 //# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","names":[],"sources":["../src/client.ts"],"mappings":";;;;KA0DY,gBAAA;EACV,GAAA,EAAK,aAAA;EACL,IAAA,EAAM,cAAA;EACN,SAAA;EACA,OAAA,EAAS,iCAAA;EACT,IAAA,EAAM,cAAA,CAAe,UAAA;EACrB,MAAA,QAAc,cAAA,CAAe,UAAA;AAAA;AAAA,UAGd,iBAAA;EACf,UAAA,CACE,IAAA,EAAM,IAAA,EACN,IAAA;IAAS,QAAA;IAAmB,QAAA;EAAA,IAC3B,OAAA,CAAQ,gBAAA;EACX,OAAA,CACE,OAAA,EAAS,iCAAA,EACT,IAAA,GAAO,MAAA,EAAQ,iBAAA,KAAsB,OAAA,CAAQ,sBAAA,IAC5C,OAAA,CAAQ,sBAAA;AAAA;AAAA,iBA2DG,sBAAA,CACd,OAAA,EAAS,kBAAA,GACR,iBAAA"}
+{"version":3,"file":"client.d.ts","names":[],"sources":["../src/concurrency.ts","../src/progress.ts","../src/client.ts"],"mappings":";;;;;;;;AAKA;KAAY,eAAA;EACN,KAAA;EAAe,MAAA;EAAqB,KAAA,EAAO,CAAA;AAAA;EAC3C,KAAA;EAAe,MAAA;EAAoB,KAAA;AAAA;AAAA,KAE7B,yBAAA;EAF6B,0EAIvC,WAAA;EAJ4C;AAE9C;;;;EAQE,MAAA,GAAS,WAAA;EAOY;;;;;;EAArB,SAAA,IAAa,MAAA,EAAQ,eAAA,CAAgB,CAAA;AAAA;;;;;;iBAQjB,kBAAA,MAAA,CACpB,KAAA,WAAgB,CAAA,IAChB,MAAA,GAAS,IAAA,EAAM,CAAA,EAAG,KAAA,aAAkB,OAAA,CAAQ,CAAA,GAC5C,OAAA,EAAS,yBAAA,CAA0B,CAAA,IAClC,OAAA,CAAQ,eAAA,CAAgB,CAAA;;;;;;;AA/B3B;;;;KCIY,eAAA;AAAA,KASA,kBAAA;EACV,KAAA,EAAO,eAAA,EDbiC;ECexC,MAAA,UDdI;ECgBJ,KAAA,sBDhBuC;ECkBvC,aAAA,WDlB4C;ECoB5C,OAAA;AAAA;AAAA,KAGU,0BAAA,IAA8B,QAAA,EAAU,kBAAA;AAAA,KAExC,yBAAA;EACV,UAAA,GAAa,0BAAA,EDTQ;ECWrB,UAAA;AAAA;AAAA,cAGW,4BAAA;;;;;;iBAOG,gBAAA,CAAiB,QAAA,EAAU,kBAAA;AAAA,KAS/B,sBAAA,GAAyB,yBAAA;ED9BI,yDCgCvC,GAAA;AAAA;;;;;;;;;;;;;;;;cAkBW,eAAA;EAAA,iBACM,QAAA;EAAA,iBACA,UAAA;EAAA,iBACA,GAAA;EAAA,QAET,YAAA;EAAA,QACA,MAAA;EAAA,QACA,KAAA;EAAA,QACA,mBAAA;EAAA,QACA,UAAA;EAAA,QACA,OAAA;cAEI,OAAA,GAAU,sBAAA;EDlDrB;EAAA,ICyDG,MAAA,CAAA;EDzDqB;;;;;ECkEzB,KAAA,CAAM,KAAA,EAAO,eAAA,EAAiB,OAAA;IAAY,KAAA;EAAA;;;;AApF5C;EAsGE,KAAA,CAAM,MAAA,UAAgB,KAAA;;;;;EAoBtB,MAAA,CAAO,QAAA;IAAa,MAAA;IAAiB,KAAA;IAAgB,OAAA;EAAA;EAjH9C;EAgIP,aAAA,CAAA;EA7HoC;EAkIpC,IAAA,CAAA;EAAA,QAWQ,IAAA;AAAA;AAAA,KAME,iBAAA;EAjJyB,+CAmJnC,OAAA,IAAW,MAAA,mBAlJ4B;EAoJvC,MAAA;EACA,OAAA,IAAW,KAAA;AAAA;;;AAhJb;;;;;AAOA;;;;;AASA;;;;;AAoBA;iBAiIgB,gBAAA,CACd,MAAA,EAAQ,cAAA,CAAe,UAAA,GACvB,KAAA,EAAO,iBAAA,GACN,cAAA,CAAe,UAAA;;;KCnGN,gBAAA;EACV,GAAA,EAAK,aAAA;EACL,IAAA,EAAM,cAAA;EACN,SAAA;EACA,OAAA,EAAS,iCAAA;EACT,IAAA,EAAM,cAAA,CAAe,UAAA;EACrB,MAAA,QAAc,cAAA,CAAe,UAAA;AAAA;AAAA,KAGnB,qBAAA;EACV,IAAA,EAAM,IAAA;EACN,QAAA;EACA,QAAA,WFtGS;EEwGT,MAAA,GAAS,WAAA;AAAA;;;;;AFzFX;;;;KEoGY,iCAAA;EACV,YAAA,EAAc,gBAAA;EACd,MAAA,GAAS,WAAA;AAAA;;;;;KAOC,uBAAA;EACV,UAAA;EACA,GAAA,EAAK,aAAA;EACL,MAAA,GAAS,WAAA;AAAA;;;;;;;KASC,qBAAA;EACV,QAAA;AAAA;AAAA,KAGU,qBAAA;EACV,QAAA;EACA,QAAA;AAAA;AAAA,KAGU,oBAAA;EACV,IAAA,EAAM,IAAA;EACN,MAAA,EAAQ,gBAAA;AAAA;AAAA,KAGE,mBAAA;ED9JA,4ECgKV,GAAA;EACA,MAAA,EAAQ,gBAAA;EACR,MAAA;AAAA;AAAA,KAGU,wBAAA;EACV,UAAA;EACA,GAAA,EAAK,aAAA,ED7JiB;EC+JtB,SAAA;EACA,MAAA,GAAS,WAAA;AAAA;;;;;;KAQC,mBAAA;EACV,GAAA;EACA,YAAA;AAAA;;AD7JF;;;;;KCsKY,sBAAA;EDnKV,iECqKA,WAAA,WDrKU;ECuKV,MAAA,GAAS,WAAA;EACT,UAAA,IAAc,QAAA,EAAU,kBAAA;IAAuB,KAAA;EAAA;EDrKR;AAOzC;;;ECmKE,aAAA,IAAiB,MAAA,EAAQ,qBAAA,WDnKkC;ECqK3D,UAAA;AAAA;AAAA,KAGU,qBAAA;EACV,OAAA;EACA,SAAA;EACA,MAAA;EACA,KAAA;AAAA;AAAA,cAGW,oCAAA;AAAA,UAEI,iBAAA;EACf,UAAA,CACE,IAAA,EAAM,IAAA,EACN,IAAA;IAAS,QAAA;IAAmB,QAAA;EAAA,IAC3B,OAAA,CAAQ,gBAAA;EACX,OAAA,CACE,OAAA,EAAS,iCAAA,EACT,IAAA,GAAO,MAAA,EAAQ,iBAAA,KAAsB,OAAA,CAAQ,sBAAA,IAC5C,OAAA,CAAQ,sBAAA;EDpJH;;;;;;;EC4JR,MAAA,CACE,KAAA,EAAO,qBAAA,GAAwB,iCAAA,EAC/B,OAAA,GAAU,yBAAA,GACT,OAAA,CAAQ,sBAAA;ED3IE;;;;;;;;ECoJb,QAAA,CACE,KAAA,EAAO,uBAAA,EACP,OAAA,GAAU,yBAAA,GACT,OAAA,CAAQ,kBAAA;EDjH0B;;;;;ECuHrC,YAAA,CACE,KAAA,EAAO,uBAAA,EACP,OAAA,GAAU,qBAAA,GAAwB,yBAAA,GACjC,OAAA,CAAQ,oBAAA;ED3FC;;AAMd;;;EC2FE,cAAA,CACE,KAAA,EAAO,uBAAA,EACP,OAAA,GAAU,qBAAA,GAAwB,yBAAA,GACjC,OAAA;ED5FH;;;;;ECkGA,iBAAA,CACE,KAAA,EAAO,uBAAA,EACP,OAAA,GAAU,qBAAA,GAAwB,yBAAA,GACjC,OAAA,CAAQ,mBAAA;EDlGc;AAqB3B;;;;;;ECqFE,YAAA,CAAa,KAAA,EAAO,wBAAA,GAA2B,OAAA,CAAQ,mBAAA;EACvD,UAAA,CACE,MAAA,WAAiB,qBAAA,IACjB,OAAA,GAAU,sBAAA,GACT,OAAA,CAAQ,eAAA,CAAgB,sBAAA;EAC3B,YAAA,CACE,MAAA,WAAiB,uBAAA,IACjB,OAAA,GAAU,sBAAA,GACT,OAAA,CAAQ,eAAA,CAAgB,kBAAA;AAAA;AAAA,iBAyWb,sBAAA,CACd,OAAA,EAAS,kBAAA,GACR,iBAAA"}