@dereekb/dbx-web 13.33.0 → 13.35.0

package/fesm2022/dereekb-dbx-web.mjs

@@ -1,8 +1,8 @@
 import * as i0 from '@angular/core';
 import { Injectable, input, inject, effect, Directive, NgModule, ChangeDetectionStrategy, Component, output, computed, HostListener, forwardRef, model, InjectionToken, viewChild, ElementRef, makeEnvironmentProviders, untracked, ApplicationRef, Injector, EnvironmentInjector, createComponent, DestroyRef, signal, TemplateRef, SecurityContext, ViewContainerRef, booleanAttribute, Renderer2 } from '@angular/core';
-import { asPromise, DASH_CHARACTER_PREFIX_INSTANCE, hashStringToNumber, cssTokenVar, useIterableOrValue, isDefinedAndNotFalse, spaceSeparatedCssClasses, cssClassesSet, objectHasNoKeys, getValueFromGetter, firstValue, filterUndefinedValues, separateValues, splitFront, asDecisionFunction, SLASH_PATH_FILE_TYPE_SEPARATOR, filterMaybeArrayValues, mapIterable, toReadableError, isDefaultReadableError, MS_IN_SECOND, mergeObjects, build, ServerErrorResponse, UnauthorizedServerErrorResponse, makeTimer, MS_IN_MINUTE, toggleTimerRunning, unixDateTimeSecondsNumberForNow, ModelRelationUtility, encodeModelKeyTypePair, safeCompareEquality, addMilliseconds, isPast, asArray, slashPathDetails, mimeTypeForFileExtension, slashPathDirectoryTree, nameToInitials, isMaybeNot, isNotFalse, modifier, combineMaps, addModifiers, removeModifiers, applyBestFit, findNext, maybeModifierMapToFunction, makeValuesGroupMap, compareWithMappedValuesFunction, invertMaybeBoolean, splitCommaSeparatedStringToSet, ZIP_FILE_MIME_TYPE, cachedGetter, sortByNumberFunction, JPEG_MIME_TYPES, JPEG_MIME_TYPE, PNG_MIME_TYPE, PDF_MIME_TYPE, sequentialIncrementingNumberStringModelIdFactory, PDF_HEADER, PDF_EOF_MARKER, PDF_ENCRYPT_MARKER } from '@dereekb/util';
+import { asPromise, DASH_CHARACTER_PREFIX_INSTANCE, hashStringToNumber, cssTokenVar, useIterableOrValue, isDefinedAndNotFalse, spaceSeparatedCssClasses, cssClassesSet, objectHasNoKeys, getValueFromGetter, firstValue, filterUndefinedValues, separateValues, splitFront, asDecisionFunction, SLASH_PATH_FILE_TYPE_SEPARATOR, filterMaybeArrayValues, mapIterable, toReadableError, isDefaultReadableError, MS_IN_SECOND, mergeObjects, build, ServerErrorResponse, UnauthorizedServerErrorResponse, makeTimer, MS_IN_MINUTE, toggleTimerRunning, unixDateTimeSecondsNumberForNow, ModelRelationUtility, encodeModelKeyTypePair, safeCompareEquality, addMilliseconds, isPast, asArray, slashPathDetails, mimeTypeForFileExtension, slashPathDirectoryTree, nameToInitials, isMaybeNot, isNotFalse, modifier, combineMaps, addModifiers, removeModifiers, applyBestFit, findNext, maybeModifierMapToFunction, makeValuesGroupMap, compareWithMappedValuesFunction, invertMaybeBoolean, splitCommaSeparatedStringToSet, ZIP_FILE_MIME_TYPE, cachedGetter, sortByNumberFunction, JPEG_MIME_TYPES, JPEG_MIME_TYPE, PNG_MIME_TYPE, PDF_MIME_TYPE, JSON_MIME_TYPE, sequentialIncrementingNumberStringModelIdFactory, PDF_HEADER, PDF_EOF_MARKER, PDF_ENCRYPT_MARKER } from '@dereekb/util';
 import * as i1$2 from '@dereekb/dbx-core';
-import { completeOnDestroy, clean, AbstractTransitionWatcherDirective, DbxInjectionComponent, dbxActionWorkProgress, AbstractDbxButtonDirective, hasNonTrivialChildNodes, provideDbxButton, DbxCoreButtonModule, createInjectorForInjectionComponentConfig, initInjectionComponent, AbstractDbxActionValueGetterDirective, cleanSubscription, AbstractDbxActionHandlerDirective, FilterSourceDirective, provideActionStoreSource, isClickableFilterPreset, AbstractDbxAnchorDirective, expandClickableAnchorLinkTrees, DbxCoreFilterModule, DbxButton, DbxActionWorkable, provideDbxActionWorkable, DbxActionContextStoreSourceInstance, cleanSubscriptionWithLockSet, DBX_INJECTION_COMPONENT_DATA, checkNgContentWrapperHasContent, cleanLoadingContext, DbxActionSourceDirective, DbxActionSuccessHandlerDirective, DbxActionDirective, transformEmptyStringInputToUndefined, isIdleActionState, canTriggerAction, DbxCoreActionModule, DbxActionButtonDirective, onDbxAppAuth, SimpleStorageAccessorFactory, mergeStaticProviders, asSegueRef, AbstractTransitionDirective, DbxRouterService, AbstractIfDirective, isSegueRefActive, anchorTypeForAnchor } from '@dereekb/dbx-core';
+import { completeOnDestroy, clean, AbstractTransitionWatcherDirective, DbxInjectionComponent, dbxActionWorkProgress, AbstractDbxButtonDirective, hasNonTrivialChildNodes, provideDbxButton, DbxCoreButtonModule, createInjectorForInjectionComponentConfig, initInjectionComponent, AbstractDbxActionValueGetterDirective, cleanSubscription, AbstractDbxActionHandlerDirective, FilterSourceDirective, provideActionStoreSource, isClickableFilterPreset, AbstractDbxAnchorDirective, expandClickableAnchorLinkTrees, DbxCoreFilterModule, DbxButton, DbxActionWorkable, provideDbxActionWorkable, DbxActionContextStoreSourceInstance, cleanSubscriptionWithLockSet, DBX_INJECTION_COMPONENT_DATA, checkNgContentWrapperHasContent, cleanLoadingContext, DbxActionSourceDirective, DbxActionSuccessHandlerDirective, DbxActionDirective, transformEmptyStringInputToUndefined, isIdleActionState, canTriggerAction, DbxCoreActionModule, DbxActionButtonDirective, onDbxAppAuth, SimpleStorageAccessorFactory, mergeStaticProviders, asSegueRef, AbstractTransitionDirective, DbxRouterService, AbstractIfDirective, isSegueRefActive, anchorTypeForAnchor, DbxActionDisabledDirective, DbxActionHandlerDirective } from '@dereekb/dbx-core';
 import { NgPopoverRef, NgOverlayContainerService } from 'ng-overlay-container';
 import { of, map, BehaviorSubject, distinctUntilChanged, shareReplay, delay, Subject, first, startWith, filter, throttleTime, skip, defaultIfEmpty, combineLatest, switchMap, delayWhen, timer, asyncScheduler, from, firstValueFrom, mergeMap, race, tap, catchError, distinct, merge, exhaustMap, NEVER } from 'rxjs';
 import { LockSet, distinctUntilItemsHaveDifferentValues, filterMaybe, skipAllInitialMaybe, maybeValueFromObservableOrValue, switchMapMaybeLoadingContextStream, LoadingStateType, loadingStateType, successResult, valueFromFinishedLoadingState, loadingStateContext, initialize, asObservable, isNot, mapForEach, switchMapMaybe, listLoadingStateContext, isLoadingStateFinishedLoading, startWithBeginLoading, loadingStateFromObs, errorResult, beginLoading, distinctUntilHasDifferentValues } from '@dereekb/rxjs';
@@ -52,7 +52,7 @@ import * as i1$8 from '@angular/material/chips';
 import { MatChipsModule } from '@angular/material/chips';
 import * as i2$1 from '@angular/material/tooltip';
 import { MatTooltipModule } from '@angular/material/tooltip';
-import { PDFDocument } from '@cantoo/pdf-lib';
+import { PDFName, PDFString, PDFHexString, PDFDocument, degrees } from '@cantoo/pdf-lib';
 import { moveItemInArray, CdkDrag, CdkDragHandle, CdkDragPlaceholder, CdkDropList } from '@angular/cdk/drag-drop';
 
 /**
@@ -18151,6 +18151,22 @@ const DEFAULT_DBX_PDF_MERGE_ENCRYPTED_HANDLING = 'focus';
  * Error message used when an encrypted entry is projected to the `error` status under {@link DbxPdfMergeEncryptedHandling} `'error'` mode.
  */
 const DBX_PDF_MERGE_ENCRYPTED_ERROR_MESSAGE = 'Password-protected PDFs cannot be merged.';
+/**
+ * Default value for {@link DbxPdfMergeEditorConfig.pageEditing}. Off, so the editor's default behavior is unchanged.
+ */
+const DEFAULT_DBX_PDF_MERGE_PAGE_EDITING = false;
+/**
+ * Default value for {@link DbxPdfMergeEditorConfig.sidecar}. Off, so merged output bytes are unchanged.
+ */
+const DEFAULT_DBX_PDF_MERGE_SIDECAR = false;
+/**
+ * Default value for {@link DbxPdfMergeEditorConfig.restoreImportOnClear}. On, so an editor the app populated programmatically is reset to that document by Clear rather than left empty.
+ */
+const DEFAULT_DBX_PDF_MERGE_RESTORE_IMPORT_ON_CLEAR = true;
+/**
+ * Message shown on an encrypted entry's row while page editing is enabled. Encrypted documents cannot be opened by `pdf-lib`, so their pages cannot be listed or edited — the entry stays a single opaque row.
+ */
+const DBX_PDF_MERGE_ENCRYPTED_NOT_EDITABLE_MESSAGE = 'Encrypted — pages cannot be edited.';
 /**
  * MIME types accepted by the PDF merge editor by default: PDF documents and PNG/JPEG images.
  */
@@ -18159,6 +18175,45 @@ const DEFAULT_PDF_MERGE_ACCEPT = [PDF_MIME_TYPE, PNG_MIME_TYPE, JPEG_MIME_TYPE];
  * MIME type emitted by the merged result blob.
  */
 const PDF_MERGE_RESULT_MIME_TYPE = PDF_MIME_TYPE;
+/**
+ * Group key used for pages whose source entry has no slot id.
+ */
+const DEFAULT_PDF_MERGE_PAGE_GROUP_KEY = '_';
+/**
+ * Returns the group key a page reorders within — its entry's slot id, or {@link DEFAULT_PDF_MERGE_PAGE_GROUP_KEY} when the entry is unslotted.
+ *
+ * @param slotId - Slot id of the owning entry, if any.
+ * @returns The group key.
+ * @__NO_SIDE_EFFECTS__
+ */
+function pdfMergePageGroupKeyForSlotId(slotId) {
+    return slotId ?? DEFAULT_PDF_MERGE_PAGE_GROUP_KEY;
+}
+/**
+ * Separator between the entry id and the page index inside a page id.
+ */
+const PDF_MERGE_PAGE_ID_SEPARATOR = ':';
+/**
+ * Builds the stable identifier for a page within the editor.
+ *
+ * @param entryId - Id of the owning {@link PdfMergeEntry}.
+ * @param sourceIndex - Zero-based page index within that entry's source document.
+ * @returns The page id.
+ * @__NO_SIDE_EFFECTS__
+ */
+function makePdfMergePageId(entryId, sourceIndex) {
+    return `${entryId}${PDF_MERGE_PAGE_ID_SEPARATOR}${sourceIndex}`;
+}
+/**
+ * Returns the id of the entry a page id belongs to. Used to prune page state when an entry leaves the list.
+ *
+ * @param pageId - Page id produced by {@link makePdfMergePageId}.
+ * @returns The owning entry's id.
+ * @__NO_SIDE_EFFECTS__
+ */
+function entryIdForPdfMergePageId(pageId) {
+    return pageId.slice(0, pageId.indexOf(PDF_MERGE_PAGE_ID_SEPARATOR));
+}
 /**
  * Injection token for a workspace-wide default {@link DbxPdfMergeEditorConfig}. Use {@link provideDbxPdfMergeEditorConfig} to register a value.
  */
@@ -18186,6 +18241,233 @@ function provideDbxPdfMergeEditorPreserveEntriesOnSlotDestroy(preserve = true) {
     return { provide: DBX_PDF_MERGE_EDITOR_PRESERVE_ENTRIES_ON_SLOT_DESTROY, useValue: preserve };
 }
 
+/**
+ * Name of the JSON manifest attached to a merged PDF that records which pages came from which slot.
+ */
+const PDF_MERGE_SIDECAR_FILE_NAME = 'dbx-pdf-merge.json';
+/**
+ * Key set on each output page's dictionary holding that page's {@link PdfMergeSidecarPage.tag}.
+ *
+ * Custom page-dictionary keys travel with the page: they survive `copyPages` (including subsetting and reordering), a save/load round trip, and further edits. That is what makes tags — rather than the manifest's recorded indices — the authoritative record of which document a page belongs to.
+ */
+const PDF_MERGE_PAGE_TAG_KEY = 'DbxPageTag';
+/**
+ * Schema version of the emitted {@link PdfMergeSidecar}.
+ */
+const PDF_MERGE_SIDECAR_VERSION = 1;
+/**
+ * Description recorded on the attached manifest.
+ */
+const PDF_MERGE_SIDECAR_DESCRIPTION = 'dbx-pdf-merge page manifest';
+/**
+ * Builds the tag written onto an output page.
+ *
+ * @param slotId - Slot the page's source entry belongs to, or `null` when unslotted.
+ * @param ordinal - Zero-based position of the page within its own slot's pages.
+ * @returns A tag unique within the output document.
+ * @__NO_SIDE_EFFECTS__
+ */
+function makePdfMergeSidecarPageTag(slotId, ordinal) {
+    return `${slotId ?? '_'}-${ordinal}`;
+}
+/**
+ * Writes a page's tag onto its page dictionary so the association survives later reordering.
+ *
+ * @param page - Page in the output document.
+ * @param tag - Tag to record.
+ */
+function writePdfMergePageTag(page, tag) {
+    page.node.set(PDFName.of(PDF_MERGE_PAGE_TAG_KEY), PDFString.of(tag));
+}
+/**
+ * Reads the tag previously written onto a page, if any.
+ *
+ * Uses `get` plus an instance check rather than a typed `lookup`, because `PDFDict.lookup(key, PDFString)` throws when the key is absent — which is the normal case for any PDF that did not come out of this editor.
+ *
+ * @param page - Page to inspect.
+ * @returns The tag, or `null` when the page carries none.
+ */
+function readPdfMergePageTag(page) {
+    const value = page.node.get(PDFName.of(PDF_MERGE_PAGE_TAG_KEY));
+    let tag;
+    if (value instanceof PDFString || value instanceof PDFHexString) {
+        tag = value.decodeText();
+    }
+    else {
+        tag = null;
+    }
+    return tag;
+}
+/**
+ * Attaches a manifest to the output document as an embedded JSON file.
+ *
+ * @param document - Output document being saved.
+ * @param sidecar - Manifest to embed.
+ */
+async function attachPdfMergeSidecar(document, sidecar) {
+    // Re-wrap with this module's Uint8Array: pdf-lib validates its input with `instanceof`, and a
+    // TextEncoder supplied by another realm (Node's, under jsdom) produces an array that fails that
+    // check even though it is a genuine Uint8Array.
+    const bytes = new Uint8Array(new TextEncoder().encode(JSON.stringify(sidecar)));
+    await document.attach(bytes, PDF_MERGE_SIDECAR_FILE_NAME, {
+        mimeType: JSON_MIME_TYPE,
+        description: PDF_MERGE_SIDECAR_DESCRIPTION
+    });
+}
+/**
+ * Builds a {@link PdfMergeSidecar} from the pages written to an output document.
+ *
+ * @param pages - Page records in output order.
+ * @returns The manifest, with one document per distinct slot in first-appearance order.
+ * @__NO_SIDE_EFFECTS__
+ */
+function makePdfMergeSidecar(pages) {
+    const tagsBySlot = new Map();
+    pages.forEach((page) => {
+        const existing = tagsBySlot.get(page.slotId);
+        if (existing == null) {
+            tagsBySlot.set(page.slotId, [page.tag]);
+        }
+        else {
+            existing.push(page.tag);
+        }
+    });
+    const documents = Array.from(tagsBySlot.entries()).map(([slotId, pageTags]) => ({ slotId, pageTags }));
+    return {
+        version: PDF_MERGE_SIDECAR_VERSION,
+        createdAt: new Date().toISOString(),
+        documents,
+        pages
+    };
+}
+async function bytesForSidecarReadInput(input) {
+    return input instanceof Blob ? input.arrayBuffer() : input;
+}
+function parseSidecarBytes(data) {
+    let sidecar;
+    try {
+        const parsed = JSON.parse(new TextDecoder().decode(data));
+        sidecar = Array.isArray(parsed?.documents) && Array.isArray(parsed?.pages) ? parsed : null;
+    }
+    catch {
+        sidecar = null;
+    }
+    return sidecar;
+}
+/**
+ * Reads the manifest embedded in a merged PDF and resolves each recorded page to its current position in that file.
+ *
+ * Resolution prefers each page's own tag, which follows the page through reordering. The manifest's {@link PdfMergeSidecarPage.outputIndex} is used only as a fallback for pages whose tag has been stripped, and any index that no longer exists is reported through {@link PdfMergeSidecarReadResult.missingTags} instead.
+ *
+ * @param input - The merged PDF's bytes.
+ * @returns The manifest and its resolved documents, or `null` when the file carries no manifest, is unreadable, or is encrypted.
+ */
+async function readPdfMergeSidecar(input) {
+    let result;
+    try {
+        const bytes = await bytesForSidecarReadInput(input);
+        const document = await PDFDocument.load(bytes);
+        result = resolvePdfMergeSidecar(document);
+    }
+    catch {
+        result = null;
+    }
+    return result;
+}
+/**
+ * Resolves the manifest of an already-loaded document. Split out from {@link readPdfMergeSidecar} so {@link splitPdfMergeSidecarDocuments} can reuse the resolution without parsing the same bytes twice.
+ *
+ * @param document - Loaded merged document.
+ * @returns The resolved manifest, or `null` when the document carries none.
+ */
+function resolvePdfMergeSidecar(document) {
+    let result;
+    {
+        const attachment = document.getAttachments().find((x) => x.name === PDF_MERGE_SIDECAR_FILE_NAME);
+        const sidecar = attachment == null ? null : parseSidecarBytes(attachment.data);
+        if (sidecar == null) {
+            result = null;
+        }
+        else {
+            const pageCount = document.getPageCount();
+            const indexByTag = new Map();
+            let untaggedPageCount = 0;
+            document.getPages().forEach((page, index) => {
+                const tag = readPdfMergePageTag(page);
+                if (tag == null) {
+                    untaggedPageCount += 1;
+                }
+                else {
+                    indexByTag.set(tag, index);
+                }
+            });
+            const recordByTag = new Map(sidecar.pages.map((page) => [page.tag, page]));
+            const missingTags = [];
+            const documents = sidecar.documents.map((sidecarDocument) => {
+                const pages = [];
+                sidecarDocument.pageTags.forEach((tag) => {
+                    const record = recordByTag.get(tag);
+                    const taggedIndex = indexByTag.get(tag);
+                    if (record == null) {
+                        missingTags.push(tag);
+                    }
+                    else if (taggedIndex != null) {
+                        pages.push({ ...record, pageIndex: taggedIndex, resolvedByTag: true });
+                    }
+                    else if (record.outputIndex >= 0 && record.outputIndex < pageCount) {
+                        pages.push({ ...record, pageIndex: record.outputIndex, resolvedByTag: false });
+                    }
+                    else {
+                        missingTags.push(tag);
+                    }
+                });
+                return { slotId: sidecarDocument.slotId, pages };
+            });
+            result = { sidecar, documents, missingTags, untaggedPageCount };
+        }
+    }
+    return result;
+}
+/**
+ * Splits a previously-merged PDF back into one file per document, using the embedded manifest to decide which pages belong to which slot.
+ *
+ * This is the inverse of a merge with `sidecar: true`, and is what lets a completed document be re-imported into the editor with its slots repopulated instead of arriving as one opaque file. Page order and any rotation baked in at merge time are preserved, and each document's pages are resolved by tag so a document that was reordered after export still splits correctly.
+ *
+ * @param input - Bytes of a merged PDF.
+ * @returns One file per document plus the manifest, or `null` when the input carries no manifest, is unreadable, or is encrypted.
+ */
+async function splitPdfMergeSidecarDocuments(input) {
+    let result;
+    try {
+        const bytes = await bytesForSidecarReadInput(input);
+        const source = await PDFDocument.load(bytes);
+        const read = resolvePdfMergeSidecar(source);
+        if (read == null) {
+            result = null;
+        }
+        else {
+            const documents = [];
+            for (const document of read.documents) {
+                if (document.pages.length > 0) {
+                    const target = await PDFDocument.create();
+                    const copied = await target.copyPages(source, document.pages.map((page) => page.pageIndex));
+                    copied.forEach((page) => target.addPage(page));
+                    const outputBytes = await target.save();
+                    const name = document.pages[0].sourceName || `${document.slotId ?? 'document'}.pdf`;
+                    const file = new File([outputBytes], name, { type: PDF_MIME_TYPE });
+                    documents.push({ slotId: document.slotId, file, pageCount: document.pages.length });
+                }
+            }
+            result = { sidecar: read.sidecar, documents, missingTags: read.missingTags, untaggedPageCount: read.untaggedPageCount };
+        }
+    }
+    catch {
+        result = null;
+    }
+    return result;
+}
+
+const FULL_ROTATION_DEGREES = 360;
 const TEXT_DECODER = new TextDecoder('latin1');
 const FORMAT_KILOBYTE = 1024;
 const FORMAT_MEGABYTE = FORMAT_KILOBYTE * 1024;
@@ -18209,6 +18491,33 @@ function formatPdfMergeEntrySize(size) {
     }
     return result;
 }
+const DEFAULT_BLOB_FILE_NAMES = {
+    [PDF_MIME_TYPE]: 'document.pdf',
+    [PNG_MIME_TYPE]: 'image.png',
+    [JPEG_MIME_TYPE]: 'image.jpg'
+};
+const DEFAULT_BLOB_FILE_NAME = DEFAULT_BLOB_FILE_NAMES[PDF_MIME_TYPE];
+/**
+ * Normalizes a {@link Blob} into a {@link File} so it can become a {@link PdfMergeEntry}, which needs a name to display.
+ *
+ * A {@link File} passes through untouched unless an explicit `fileName` overrides it. A bare {@link Blob} is named from `fileName`, else from its MIME type (`document.pdf` / `image.png` / `image.jpg`), else `document.pdf` — the name only has to be plausible and correctly suffixed, since {@link classifyPdfMergeFile} falls back to the extension when a blob carries no type.
+ *
+ * @param input - Blob or File to normalize.
+ * @param fileName - Optional name, overriding a File's own name and naming a bare Blob.
+ * @returns A File carrying the resolved name.
+ */
+function asPdfMergeFile(input, fileName) {
+    const mimeType = (input.type ?? '').toLowerCase();
+    let file;
+    if (input instanceof File && fileName == null) {
+        file = input;
+    }
+    else {
+        const name = fileName ?? DEFAULT_BLOB_FILE_NAMES[mimeType] ?? DEFAULT_BLOB_FILE_NAME;
+        file = new File([input], name, { type: input.type || mimeTypeForFileExtension(slashPathDetails(name.toLowerCase()).typedFileExtension) || PDF_MIME_TYPE });
+    }
+    return file;
+}
 /**
  * Returns the {@link PdfMergeEntryKind} for a file based on its MIME type, with a small fallback to file-extension matching when the browser provided no MIME type.
  *
@@ -18363,30 +18672,305 @@ async function validatePdfMergeEntry(entry) {
     }
     return result;
 }
-async function appendPdfPages(target, entry) {
-    const bytes = await entry.file.arrayBuffer();
-    const source = await PDFDocument.load(bytes);
-    const pages = await target.copyPages(source, source.getPageIndices());
-    pages.forEach((page) => target.addPage(page));
+/**
+ * Normalizes an arbitrary degree value into the `[0, 360)` range.
+ *
+ * @param angle - Angle in degrees, possibly negative or over a full turn.
+ * @returns The equivalent angle in `[0, 360)`.
+ * @__NO_SIDE_EFFECTS__
+ */
+function normalizeRotationDegrees(angle) {
+    return ((angle % FULL_ROTATION_DEGREES) + FULL_ROTATION_DEGREES) % FULL_ROTATION_DEGREES;
+}
+/**
+ * Reads per-page metadata from an entry's source document so the editor can list its pages individually.
+ *
+ * Only called while page editing is enabled — the normal upload path never parses the document, it only scans for the PDF header and markers (see {@link validatePdfMergeEntry}).
+ *
+ * @param entry - Entry to inspect.
+ * @returns One {@link PdfMergePageMeta} per source page, or `null` when the entry is encrypted or cannot be parsed. Image entries report a single synthetic page.
+ */
+async function readPdfMergeEntryPageMetas(entry) {
+    let metas;
+    if (entry.encrypted) {
+        // pdf-lib cannot open an encrypted document at all, so its pages can never be listed or edited.
+        metas = null;
+    }
+    else if (entry.kind === 'image') {
+        const dimensions = entry.original.dimensions;
+        metas = [{ sourceIndex: 0, width: dimensions?.width ?? 0, height: dimensions?.height ?? 0, sourceRotation: 0 }];
+    }
+    else {
+        try {
+            const bytes = await entry.file.arrayBuffer();
+            const source = await PDFDocument.load(bytes);
+            metas = source.getPages().map((page, sourceIndex) => {
+                const { width, height } = page.getSize();
+                return { sourceIndex, width, height, sourceRotation: normalizeRotationDegrees(page.getRotation().angle) };
+            });
+        }
+        catch {
+            metas = null;
+        }
+    }
+    return metas;
+}
+/**
+ * Reconstructs editor entries from a PDF previously exported with an embedded manifest.
+ *
+ * Each document recorded in the manifest becomes one entry carrying its original slot id, so dropping the result into the store repopulates the same slots the file was built from. This is the re-import half of the sidecar: without it a completed document can only come back as a single opaque file.
+ *
+ * @param input - Bytes of a merged PDF, typically the file the user just chose.
+ * @param config - Optional entry-building config (id factory override, and the sidecar-less fallback).
+ * @returns The reconstructed entries and manifest, or a reason when the file cannot be imported.
+ */
+async function buildPdfMergeEntriesFromSidecar(input, config) {
+    const split = await splitPdfMergeSidecarDocuments(input);
+    let result;
+    if (split == null) {
+        // A readable PDF without a manifest and an unreadable one are distinguished so the UI can
+        // explain the difference — "not exported from here" reads very differently from "corrupt".
+        const readable = await isReadablePdf(input);
+        if (!readable) {
+            result = { error: 'unreadable' };
+        }
+        else if (config?.allowWithoutSidecar) {
+            // No manifest to attribute pages with, so the whole file becomes one unslotted entry. An
+            // `unreadable` file never reaches here — the fallback widens which readable PDFs are
+            // accepted, it does not accept broken ones.
+            const entry = buildPdfMergeEntrySync(asPdfMergeFile(input, config?.fileName), { ...config, slotId: null });
+            result = entry == null ? { error: 'unreadable' } : { entries: [entry], sidecar: null, fromSidecar: false, slotIds: [null], missingTags: [], untaggedPageCount: 0 };
+        }
+        else {
+            result = { error: 'no_sidecar' };
+        }
+    }
+    else if (split.documents.length === 0) {
+        result = { error: 'no_documents' };
+    }
+    else {
+        const entries = split.documents.map((document) => buildPdfMergeEntrySync(document.file, { ...config, slotId: document.slotId })).filter((entry) => entry != null);
+        result = {
+            entries,
+            sidecar: split.sidecar,
+            fromSidecar: true,
+            slotIds: split.documents.map((document) => document.slotId),
+            missingTags: split.missingTags,
+            untaggedPageCount: split.untaggedPageCount
+        };
+    }
+    return result;
+}
+async function isReadablePdf(input) {
+    let readable;
+    try {
+        await PDFDocument.load(await input.arrayBuffer());
+        readable = true;
+    }
+    catch {
+        readable = false;
+    }
+    return readable;
+}
+function applyPdfMergePageGroupOrder(natural, orderedIds) {
+    let ordered;
+    if (orderedIds == null || orderedIds.length === 0) {
+        ordered = [...natural];
+    }
+    else {
+        const byId = new Map(natural.map((page) => [page.id, page]));
+        const taken = new Set();
+        const result = [];
+        // Stored ids that still resolve keep their stored order; anything else is ignored.
+        orderedIds.forEach((id) => {
+            const page = byId.get(id);
+            if (page != null && !taken.has(id)) {
+                result.push(page);
+                taken.add(id);
+            }
+        });
+        // Pages the stored order does not mention are new since it was written — append them in natural order.
+        natural.forEach((page) => {
+            if (!taken.has(page.id)) {
+                result.push(page);
+            }
+        });
+        ordered = result;
+    }
+    return ordered;
+}
+/**
+ * Builds the editor's page plan from the current entries plus the user's sparse edits.
+ *
+ * The result is self-healing: stored ordering ids that no longer resolve are dropped, pages the stored ordering does not mention are appended in natural order, and overrides for departed pages are ignored. That means entries can be added and removed without any page-level bookkeeping.
+ *
+ * Entries whose metadata is `null` contribute no pages — they are encrypted (which `pdf-lib` cannot open) or unparseable. Callers should surface those separately rather than letting them disappear silently.
+ *
+ * @param input - Entries, hydrated metadata, and the stored edits.
+ * @returns The ordered page plan across every group.
+ * @__NO_SIDE_EFFECTS__
+ */
+function buildPdfMergePagePlan(input) {
+    const { entries, pageMetas, pageOverrides, pageOrder } = input;
+    const eligible = entries.filter((entry) => entry.status === 'ready' && !entry.ignored && pageMetas[entry.id] != null);
+    const groups = makeValuesGroupMap(eligible, (entry) => pdfMergePageGroupKeyForSlotId(entry.slotId));
+    const plan = [];
+    groups.forEach((groupEntries, groupKey) => {
+        const natural = [];
+        groupEntries.forEach((entry) => {
+            const metas = pageMetas[entry.id];
+            metas.forEach((meta) => {
+                const id = makePdfMergePageId(entry.id, meta.sourceIndex);
+                const override = pageOverrides[id];
+                natural.push({
+                    id,
+                    entryId: entry.id,
+                    slotId: entry.slotId ?? null,
+                    groupKey: groupKey,
+                    sourceName: entry.name,
+                    kind: entry.kind,
+                    sourceIndex: meta.sourceIndex,
+                    sourcePageCount: metas.length,
+                    meta,
+                    rotation: override?.rotation ?? 0,
+                    removed: override?.removed ?? false
+                });
+            });
+        });
+        applyPdfMergePageGroupOrder(natural, pageOrder[groupKey]).forEach((page) => plan.push(page));
+    });
+    return plan;
+}
+/**
+ * Returns a loader that parses each entry's source document at most once per merge. A page plan routinely pulls several non-adjacent pages from the same file, so without this the same bytes would be parsed repeatedly.
+ *
+ * @returns Loader that resolves an entry to its parsed source document.
+ */
+function makePdfSourceDocumentLoader() {
+    const cache = new Map();
+    return (entry) => {
+        let loaded = cache.get(entry.id);
+        if (loaded == null) {
+            loaded = entry.file.arrayBuffer().then((bytes) => PDFDocument.load(bytes));
+            cache.set(entry.id, loaded);
+        }
+        return loaded;
+    };
 }
-async function appendImagePage(target, entry) {
+async function appendImagePage(target, entry, rotation) {
     const bytes = await entry.file.arrayBuffer();
     const isPng = entry.mimeType === PNG_MIME_TYPE || entry.name.toLowerCase().endsWith('.png');
     const image = isPng ? await target.embedPng(bytes) : await target.embedJpg(bytes);
     const page = target.addPage([image.width, image.height]);
     page.drawImage(image, { x: 0, y: 0, width: image.width, height: image.height });
+    if (rotation !== 0) {
+        page.setRotation(degrees(rotation));
+    }
+    return { entry, sourceIndex: 0, rotation };
+}
+/**
+ * Appends every page of every entry, in entry order — the behavior used when no page plan is supplied.
+ *
+ * @param input - Target document, entries, and source loader.
+ * @returns One record per appended page, aligned with the target's pages.
+ */
+async function appendAllEntryPages(input) {
+    const { target, entries, loadSource } = input;
+    const records = [];
+    for (const entry of entries) {
+        if (entry.kind === 'pdf') {
+            const source = await loadSource(entry);
+            const indices = source.getPageIndices();
+            const copied = await target.copyPages(source, indices);
+            copied.forEach((page, index) => {
+                target.addPage(page);
+                records.push({ entry, sourceIndex: indices[index], rotation: normalizeRotationDegrees(page.getRotation().angle) });
+            });
+        }
+        else {
+            records.push(await appendImagePage(target, entry, 0));
+        }
+    }
+    return records;
+}
+/**
+ * Appends pages according to an explicit plan — honoring subsetting, reordering, and per-page rotation.
+ *
+ * Consecutive pages from the same entry are batched into a single `copyPages` call. `copyPages` returns pages in the order of the indices it is given, which is what lets subsetting and reordering happen in one operation.
+ *
+ * @param input - Target document, entries, page plan, and source loader.
+ * @returns One record per appended page, aligned with the target's pages.
+ */
+async function appendPlannedPages(input) {
+    const { target, entries, plan, loadSource } = input;
+    const entriesById = new Map(entries.map((entry) => [entry.id, entry]));
+    const visible = plan.filter((page) => !page.removed && entriesById.has(page.entryId));
+    const records = [];
+    let index = 0;
+    while (index < visible.length) {
+        const first = visible[index];
+        const entry = entriesById.get(first.entryId);
+        let end = index + 1;
+        while (end < visible.length && visible[end].entryId === first.entryId) {
+            end += 1;
+        }
+        const run = visible.slice(index, end);
+        if (entry.kind === 'image') {
+            for (const planned of run) {
+                records.push(await appendImagePage(target, entry, normalizeRotationDegrees(planned.rotation)));
+            }
+        }
+        else {
+            const source = await loadSource(entry);
+            const copied = await target.copyPages(source, run.map((planned) => planned.sourceIndex));
+            copied.forEach((page, runIndex) => {
+                const planned = run[runIndex];
+                // Compose rather than replace: a scan already stored at 90° that the user rotates by 90° must land at 180°.
+                const rotation = normalizeRotationDegrees(planned.meta.sourceRotation + planned.rotation);
+                target.addPage(page);
+                page.setRotation(degrees(rotation));
+                records.push({ entry, sourceIndex: planned.sourceIndex, rotation });
+            });
+        }
+        index = end;
+    }
+    return records;
+}
+/**
+ * Tags each output page and attaches the manifest describing which pages belong to which slot.
+ *
+ * @param target - Document being assembled, whose pages align with `records`.
+ * @param records - One record per appended page, in output order.
+ */
+async function writePdfMergeSidecarForRecords(target, records) {
+    const ordinalBySlotKey = new Map();
+    const outputPages = target.getPages();
+    const sidecarPages = records.map((record, outputIndex) => {
+        // Normalize to null so the value survives JSON.stringify, which drops undefined.
+        const slotId = record.entry.slotId ?? null;
+        const slotKey = slotId ?? '';
+        const ordinal = ordinalBySlotKey.get(slotKey) ?? 0;
+        const tag = makePdfMergeSidecarPageTag(slotId, ordinal);
+        ordinalBySlotKey.set(slotKey, ordinal + 1);
+        writePdfMergePageTag(outputPages[outputIndex], tag);
+        return { tag, slotId, sourceName: record.entry.name, sourceIndex: record.sourceIndex, rotation: record.rotation, outputIndex };
+    });
+    await attachPdfMergeSidecar(target, makePdfMergeSidecar(sidecarPages));
 }
 /**
  * Merges every `ready` entry in the provided array order into a single PDF and returns it as a `Blob`. PDF entries contribute their full set of pages in order; image entries contribute one page sized to the image.
  *
- * Special case: when the only `ready` entry is a single encrypted PDF, returns a passthrough `Blob` of its original bytes — `pdf-lib` cannot read encrypted PDFs even with `ignoreEncryption: true`, and downstream upload flows still need a usable blob.
+ * Supplying {@link MergePdfMergeEntriesOptions.pages} replaces that default with an explicit page plan, so pages can be subsetted, reordered, and rotated. Supplying {@link MergePdfMergeEntriesOptions.sidecar} additionally embeds a manifest of which pages came from which slot.
  *
- * Throws if no `ready` entries are provided, or if multiple encrypted entries are passed in (the editor only routes here under focus mode where it has narrowed to one).
+ * Special case: when the only `ready` entry is a single encrypted PDF, returns a passthrough `Blob` of its original bytes — `pdf-lib` cannot read encrypted PDFs even with `ignoreEncryption: true`, and downstream upload flows still need a usable blob. Neither the page plan nor the sidecar applies on that path, since the document cannot be opened.
+ *
+ * Throws if no `ready` entries are provided, if multiple encrypted entries are passed in (the editor only routes here under focus mode where it has narrowed to one), or if the page plan leaves no pages to emit.
  *
  * @param entries - Ordered entries to merge.
+ * @param options - Optional page plan and sidecar switch.
  * @returns A Blob with `application/pdf` MIME type.
  */
-async function mergePdfMergeEntries(entries) {
+async function mergePdfMergeEntries(entries, options) {
     const ready = entries.filter((entry) => entry.status === 'ready');
     let result;
     if (ready.length === 0) {
@@ -18401,13 +18985,14 @@ async function mergePdfMergeEntries(entries) {
     }
     else {
         const target = await PDFDocument.create();
-        for (const entry of ready) {
-            if (entry.kind === 'pdf') {
-                await appendPdfPages(target, entry);
-            }
-            else {
-                await appendImagePage(target, entry);
-            }
+        const loadSource = makePdfSourceDocumentLoader();
+        const plan = options?.pages;
+        const records = plan == null ? await appendAllEntryPages({ target, entries: ready, loadSource }) : await appendPlannedPages({ target, entries: ready, plan, loadSource });
+        if (records.length === 0) {
+            throw new Error('No pages to merge.');
+        }
+        if (options?.sidecar) {
+            await writePdfMergeSidecarForRecords(target, records);
         }
         const bytes = await target.save();
         result = new Blob([bytes], { type: PDF_MERGE_RESULT_MIME_TYPE });
@@ -18416,11 +19001,39 @@ async function mergePdfMergeEntries(entries) {
 }
 
 /**
- * Initial state used by {@link DbxPdfMergeEditorStore} — no entries.
+ * Initial state used by {@link DbxPdfMergeEditorStore} — no entries and no page edits.
  */
 const DBX_PDF_MERGE_EDITOR_INITIAL_STATE = {
-    rawEntries: []
+    rawEntries: [],
+    pageOverrides: {},
+    pageOrder: {}
 };
+/**
+ * Drops page overrides and stored orderings that belong to entries no longer in the list.
+ *
+ * The derived plan already ignores stale ids, so this is hygiene rather than correctness — it keeps the two records from growing without bound as the user adds and removes files.
+ *
+ * @param state - Current state.
+ * @param liveEntryIds - Ids of the entries that remain.
+ * @returns The pruned page-state slice.
+ * @__NO_SIDE_EFFECTS__
+ */
+function prunePdfMergePageState(state, liveEntryIds) {
+    const pageOverrides = {};
+    const pageOrder = {};
+    Object.entries(state.pageOverrides).forEach(([pageId, override]) => {
+        if (liveEntryIds.has(entryIdForPdfMergePageId(pageId))) {
+            pageOverrides[pageId] = override;
+        }
+    });
+    Object.entries(state.pageOrder).forEach(([groupKey, pageIds]) => {
+        const kept = pageIds.filter((pageId) => liveEntryIds.has(entryIdForPdfMergePageId(pageId)));
+        if (kept.length > 0) {
+            pageOrder[groupKey] = kept;
+        }
+    });
+    return { pageOverrides, pageOrder };
+}
 /**
  * Component-scoped {@link ComponentStore} that owns the list of files staged for merging in the PDF merge editor. Each {@link PdfMergeEntry} carries its own validation promise from the moment it is built; {@link entries$} composes those promises into a live stream — emitting the entry first in `validating` state and then again as each promise resolves to `ready` or `error`. {@link mergeOutput$} emits the merged PDF blob once every entry has finished validating, at least one is `ready`, and the registered validator delegate (if any) reports `true`.
  */
@@ -18429,6 +19042,22 @@ class DbxPdfMergeEditorStore extends ComponentStore {
     _outputSizeLimit$ = new BehaviorSubject(undefined);
     _imageCompression$ = new BehaviorSubject(undefined);
     _encryptedHandling$ = new BehaviorSubject(undefined);
+    _pageEditing$ = new BehaviorSubject(undefined);
+    _sidecar$ = new BehaviorSubject(undefined);
+    /**
+     * Per-entry page metadata, parsed at most once per entry. Keyed by entry id; a resolved `null` means the entry could not be expanded. Only populated while page editing is enabled.
+     */
+    _pageMetaCache = new Map();
+    /**
+     * Mount count per registered slot id. See {@link registerSlotId} for why this is a count rather than a set.
+     */
+    _slotIdCounts = new Map();
+    _registeredSlotIds$ = new BehaviorSubject([]);
+    _importState$ = new BehaviorSubject(undefined);
+    /**
+     * Input of the most recent successful `programmatic` import, replayed by {@link clearEntries} to reset the editor to the document the app supplied. `null` until one succeeds; a user's pick never overwrites it.
+     */
+    _restorableImport;
     constructor() {
         super(DBX_PDF_MERGE_EDITOR_INITIAL_STATE);
     }
@@ -18496,28 +19125,123 @@ class DbxPdfMergeEditorStore extends ComponentStore {
      */
     encryptedEntries$ = this.entries$.pipe(map((entries) => entries.filter((entry) => entry.encrypted && entry.status === 'ready')), shareReplay(1));
     hasReadyEntries$ = this.displayEntries$.pipe(map((entries) => entries.some((entry) => entry.status === 'ready' && !entry.ignored)), distinctUntilChanged(), shareReplay(1));
+    // MARK: Page editing
     /**
-     * Emits `true` while any entry's validation promise has not yet resolved (i.e. one or more entries are still in `validating` status). Reads from {@link entries$} (not {@link displayEntries$}) so validation gating ignores the `ignored`/`error` projection done by encryption handling.
+     * Raw {@link DbxPdfMergeEditorConfig.pageEditing} value pushed onto the store, before defaulting. Consumed by the editor as the middle tier of its resolution chain (own `[config]` input → store → {@link DBX_PDF_MERGE_EDITOR_CONFIG} token), so a store-level default does not shadow the token.
      */
-    isValidating$ = this.entries$.pipe(map((entries) => entries.some((entry) => entry.status === 'validating')), distinctUntilChanged(), shareReplay(1));
+    pageEditingSetting$ = this._pageEditing$.asObservable();
     /**
-     * Emits the boolean output of the registered {@link DbxPdfMergeEditorValidator} delegate, or a constant `true` when no delegate is registered. Composed with {@link sizeLimitValid$} into {@link isValid$} to gate {@link currentMergeOutput$}.
+     * Whether page editing is active, defaulted to {@link DEFAULT_DBX_PDF_MERGE_PAGE_EDITING}. Every page-related stream is inert while this is `false`.
      */
-    validatorValid$ = this._validator$.pipe(switchMap((validator) => (validator ? validator(this.entries$) : of(true))), distinctUntilChanged(), shareReplay(1));
+    pageEditing$ = this.pageEditingSetting$.pipe(map((pageEditing) => pageEditing ?? DEFAULT_DBX_PDF_MERGE_PAGE_EDITING), distinctUntilChanged(), shareReplay(1));
     /**
-     * Internal pre-validity merge stream produced without consulting {@link isValid$}. Drives both {@link outputSize$} and the eventual {@link currentMergeOutput$} so size-based gating can observe the would-be blob without creating a cycle. Consumes {@link displayEntries$} so the merge respects the active {@link DbxPdfMergeEncryptedHandling} (encrypted-focused entries pass through, ignored entries are dropped, `error` mode demotions are honored).
+     * Raw {@link DbxPdfMergeEditorConfig.sidecar} value pushed onto the store, before defaulting.
      */
-    _candidateMergeOutput$ = combineLatest([this.displayEntries$, this.isValidating$, this.validatorValid$]).pipe(switchMap(([entries, isValidating, validatorValid]) => {
-        const mergeable = entries.filter((entry) => !entry.ignored);
-        const hasReady = mergeable.some((entry) => entry.status === 'ready');
+    sidecarSetting$ = this._sidecar$.asObservable();
+    /**
+     * Whether the merged output should carry an embedded manifest, defaulted to {@link DEFAULT_DBX_PDF_MERGE_SIDECAR}. Independent of {@link pageEditing$}.
+     */
+    sidecar$ = this.sidecarSetting$.pipe(map((sidecar) => sidecar ?? DEFAULT_DBX_PDF_MERGE_SIDECAR), distinctUntilChanged(), shareReplay(1));
+    /**
+     * Hydrated page metadata keyed by entry id.
+     *
+     * Short-circuits to an empty record while page editing is off, so the default configuration never parses a source document — the upload path's cheap header scan stays the only inspection performed. Each entry is parsed at most once thanks to {@link _pageMetaCache}, and metadata for departed entries is pruned on each pass.
+     */
+    pageMetas$ = combineLatest([this.entries$, this.pageEditing$]).pipe(switchMap(([entries, pageEditing]) => {
+        const ready = pageEditing ? entries.filter((entry) => entry.status === 'ready') : [];
         let next$;
-        if (isValidating || !hasReady || !validatorValid) {
-            next$ = of(undefined);
+        if (ready.length === 0) {
+            next$ = of({});
         }
         else {
-            next$ = from(mergePdfMergeEntries(mergeable)).pipe(catchError(() => of(undefined)));
-        }
-        return next$;
+            const readyIds = new Set(ready.map((entry) => entry.id));
+            Array.from(this._pageMetaCache.keys()).forEach((entryId) => {
+                if (!readyIds.has(entryId)) {
+                    this._pageMetaCache.delete(entryId);
+                }
+            });
+            const loaded = ready.map(async (entry) => {
+                let metas = this._pageMetaCache.get(entry.id);
+                if (metas == null) {
+                    metas = readPdfMergeEntryPageMetas(entry);
+                    this._pageMetaCache.set(entry.id, metas);
+                }
+                return [entry.id, await metas];
+            });
+            next$ = from(Promise.all(loaded)).pipe(map((pairs) => Object.fromEntries(pairs)));
+        }
+        return next$;
+    }), shareReplay(1));
+    /**
+     * The editor's ordered page plan, or `null` while page editing is disabled. Passing `null` through to the merge is what makes the default path emit every page of every entry exactly as it did before page editing existed.
+     */
+    pages$ = combineLatest([this.displayEntries$, this.pageEditing$, this.pageMetas$, this.select((state) => state.pageOverrides), this.select((state) => state.pageOrder)]).pipe(map(([entries, pageEditing, pageMetas, pageOverrides, pageOrder]) => {
+        let pages;
+        if (pageEditing) {
+            pages = buildPdfMergePagePlan({ entries, pageMetas, pageOverrides, pageOrder });
+        }
+        else {
+            pages = null;
+        }
+        return pages;
+    }), shareReplay(1));
+    /**
+     * The page plan split into the groups the UI renders, one per slot plus one for unslotted entries. Empty while page editing is disabled.
+     */
+    pageGroups$ = this.pages$.pipe(map((pages) => {
+        const grouped = makeValuesGroupMap(pages ?? [], (page) => page.groupKey);
+        const groups = [];
+        grouped.forEach((groupPages, groupKey) => {
+            groups.push({ groupKey: groupKey, slotId: groupPages[0]?.slotId ?? null, pages: groupPages });
+        });
+        return groups;
+    }), shareReplay(1));
+    /**
+     * Entries that are ready to merge but whose pages could not be listed — encrypted documents (which `pdf-lib` cannot open) and anything unparseable. Surfaced so the UI can explain why those rows are not expandable instead of letting them silently vanish from the page list. Always empty while page editing is disabled.
+     */
+    unexpandableEntries$ = combineLatest([this.displayEntries$, this.pageEditing$, this.pageMetas$]).pipe(map(([entries, pageEditing, pageMetas]) => (pageEditing ? entries.filter((entry) => entry.status === 'ready' && !entry.ignored && pageMetas[entry.id] === null) : [])), shareReplay(1));
+    /**
+     * Number of pages that will reach the merged output — the plan minus anything marked for removal. Zero while page editing is disabled, where the count is not meaningful.
+     */
+    mergeablePageCount$ = this.pages$.pipe(map((pages) => (pages ?? []).filter((page) => !page.removed).length), distinctUntilChanged(), shareReplay(1));
+    /**
+     * Whether at least one page survives the user's edits. Emits `true` while page editing is disabled so it never gates the default path.
+     */
+    hasMergeablePages$ = this.pages$.pipe(map((pages) => pages == null || pages.some((page) => !page.removed)), distinctUntilChanged(), shareReplay(1));
+    /**
+     * Returns the pages belonging to one group, for a slot rendering its own pages inline.
+     *
+     * @param slotId - Slot identifier, or `null` for the unslotted group.
+     * @returns Observable of that group's ordered pages.
+     */
+    pagesForSlotId$(slotId) {
+        const groupKey = pdfMergePageGroupKeyForSlotId(slotId);
+        return this.pages$.pipe(map((pages) => (pages ?? []).filter((page) => page.groupKey === groupKey)), shareReplay(1));
+    }
+    /**
+     * Emits `true` while any entry's validation promise has not yet resolved (i.e. one or more entries are still in `validating` status). Reads from {@link entries$} (not {@link displayEntries$}) so validation gating ignores the `ignored`/`error` projection done by encryption handling.
+     */
+    isValidating$ = this.entries$.pipe(map((entries) => entries.some((entry) => entry.status === 'validating')), distinctUntilChanged(), shareReplay(1));
+    /**
+     * Emits the boolean output of the registered {@link DbxPdfMergeEditorValidator} delegate, or a constant `true` when no delegate is registered. Composed with {@link sizeLimitValid$} into {@link isValid$} to gate {@link currentMergeOutput$}.
+     */
+    validatorValid$ = this._validator$.pipe(switchMap((validator) => (validator ? validator(this.entries$) : of(true))), distinctUntilChanged(), shareReplay(1));
+    /**
+     * Internal pre-validity merge stream produced without consulting {@link isValid$}. Drives both {@link outputSize$} and the eventual {@link currentMergeOutput$} so size-based gating can observe the would-be blob without creating a cycle. Consumes {@link displayEntries$} so the merge respects the active {@link DbxPdfMergeEncryptedHandling} (encrypted-focused entries pass through, ignored entries are dropped, `error` mode demotions are honored).
+     */
+    _candidateMergeOutput$ = combineLatest([this.displayEntries$, this.isValidating$, this.validatorValid$, this.pages$, this.sidecar$]).pipe(switchMap(([entries, isValidating, validatorValid, pages, sidecar]) => {
+        const mergeable = entries.filter((entry) => !entry.ignored);
+        const hasReady = mergeable.some((entry) => entry.status === 'ready');
+        // A `null` plan means page editing is off, in which case the merge takes its original every-page path.
+        const hasPages = pages == null || pages.some((page) => !page.removed);
+        let next$;
+        if (isValidating || !hasReady || !validatorValid || !hasPages) {
+            next$ = of(undefined);
+        }
+        else {
+            next$ = from(mergePdfMergeEntries(mergeable, { pages, sidecar })).pipe(catchError(() => of(undefined)));
+        }
+        return next$;
     }), shareReplay(1));
     /**
      * Emits the byte size of the most recent candidate merge output, or `undefined` while there is none.
@@ -18537,9 +19261,11 @@ class DbxPdfMergeEditorStore extends ComponentStore {
         return valid;
     }), distinctUntilChanged(), shareReplay(1));
     /**
-     * Emits `true` while both the registered {@link DbxPdfMergeEditorValidator} delegate (if any) and the optional output-size limit are satisfied. {@link currentMergeOutput$} gates merge emissions on this stream.
+     * Emits `true` while the registered {@link DbxPdfMergeEditorValidator} delegate (if any), the optional output-size limit, and the page plan are all satisfied. {@link currentMergeOutput$} gates merge emissions on this stream.
+     *
+     * The page-plan term is `true` whenever page editing is disabled, so this stream is unchanged on the default path. With page editing on it blocks the merge once the user has marked every page for deletion.
      */
-    isValid$ = combineLatest([this.validatorValid$, this.sizeLimitValid$]).pipe(map(([validatorValid, sizeLimitValid]) => validatorValid && sizeLimitValid), distinctUntilChanged(), shareReplay(1));
+    isValid$ = combineLatest([this.validatorValid$, this.sizeLimitValid$, this.hasMergeablePages$]).pipe(map(([validatorValid, sizeLimitValid, hasMergeablePages]) => validatorValid && sizeLimitValid && hasMergeablePages), distinctUntilChanged(), shareReplay(1));
     /**
      * Emits the merged PDF blob whenever every entry has finished validating (see {@link isValidating$}), at least one is `ready`, and {@link isValid$} reports `true`. Emits `undefined` while validation is in flight, when the list is empty, when the delegate or size limit reports invalid, or when the most recent merge failed.
      */
@@ -18558,6 +19284,176 @@ class DbxPdfMergeEditorStore extends ComponentStore {
     entriesForSlotId$(slotId) {
         return this.displayEntries$.pipe(map((entries) => entries.filter((entry) => entry.slotId === slotId)), shareReplay(1));
     }
+    // MARK: Slot registry
+    /**
+     * Slot ids currently mounted against this store, i.e. the sections this editor declares.
+     *
+     * This is what makes `<dbx-pdf-merge-import>` a zero-configuration drop-in: it derives the set of sections a re-imported file is allowed to name (and whether it renders at all) from the slots actually on screen, rather than from a hand-maintained list duplicating them.
+     *
+     * Emitted **sorted ascending**, which is deterministic but is NOT declaration order. Sorting is what lets the guard below collapse slot churn: a set cycling through `@if` (`['a','b']` → `['b']` → `['b','a']`) ends up equal to the array it started with, where registration order would emit a spuriously different array for an identical set.
+     *
+     * Registered by {@link DbxPdfMergeEditorFileUploadComponent} from its own lifecycle. Kept here rather than on the optional {@link DbxPdfMergeEditorFileUploadValidatorDirective} because it must be available whether or not a validator is present — and because a separately-provided registry could be provided at a different level than the store, letting slots register with one instance while a reader sees another.
+     */
+    registeredSlotIds$ = this._registeredSlotIds$.pipe(distinctUntilChanged((a, b) => a.length === b.length && a.every((slotId, i) => slotId === b[i])), shareReplay(1));
+    /**
+     * Registers a slot id as mounted, adding it to {@link registeredSlotIds$}.
+     *
+     * Reference-counted rather than a set: the same `slotId` can legitimately be mounted twice at once — the PDF merge upload dialog hosts its slots against an ancestor store while inline slots may still exist under {@link DBX_PDF_MERGE_EDITOR_PRESERVE_ENTRIES_ON_SLOT_DESTROY} — and one unmount must not deregister a still-mounted id.
+     *
+     * @param slotId - Slot identifier being mounted.
+     */
+    registerSlotId(slotId) {
+        this._slotIdCounts.set(slotId, (this._slotIdCounts.get(slotId) ?? 0) + 1);
+        this._emitRegisteredSlotIds();
+    }
+    /**
+     * Deregisters one mount of a slot id, removing it from {@link registeredSlotIds$} once the last mount is gone. Unknown ids are ignored.
+     *
+     * Callers must pair this with their own {@link registerSlotId} exactly once. The store frequently outlives its slots (a dialog-hosted slot is destroyed on every close while the page-level store lives on), so a missed call leaves the editor permanently claiming a section that is not on screen.
+     *
+     * @param slotId - Slot identifier being unmounted.
+     */
+    unregisterSlotId(slotId) {
+        const count = this._slotIdCounts.get(slotId);
+        if (count != null) {
+            if (count > 1) {
+                this._slotIdCounts.set(slotId, count - 1);
+            }
+            else {
+                this._slotIdCounts.delete(slotId);
+            }
+            this._emitRegisteredSlotIds();
+        }
+    }
+    _emitRegisteredSlotIds() {
+        const next = Array.from(this._slotIdCounts.keys()).sort();
+        const current = this._registeredSlotIds$.value;
+        if (next.length !== current.length || next.some((slotId, i) => slotId !== current[i])) {
+            this._registeredSlotIds$.next(next);
+        }
+    }
+    // MARK: Import
+    /**
+     * Lifecycle of the most recent {@link importMergedPdf} call, or `undefined` before the first. Lets a consumer that triggered a programmatic import observe its outcome — the picker component is not the only entry point.
+     */
+    importState$ = this._importState$.asObservable();
+    /**
+     * The most recent successful import, or `null` while none has succeeded.
+     */
+    importResult$ = this.importState$.pipe(map((state) => (state?.status === 'imported' ? state.result : null)), distinctUntilChanged(), shareReplay(1));
+    /**
+     * Why the most recent import failed, or `null` when it did not.
+     */
+    importError$ = this.importState$.pipe(map((state) => (state?.status === 'failed' ? state.error : null)), distinctUntilChanged(), shareReplay(1));
+    /**
+     * Emits `true` while an import is in flight.
+     */
+    isImporting$ = this.importState$.pipe(map((state) => state?.status === 'importing'), distinctUntilChanged(), shareReplay(1));
+    /**
+     * Whether a programmatic baseline exists for {@link clearEntries} to restore. Lets a consumer word its own confirmation honestly — "reset to the imported document" rather than "remove everything".
+     *
+     * @returns `true` once a programmatic import has succeeded.
+     */
+    hasRestorableImport() {
+        return this._restorableImport != null;
+    }
+    /**
+     * Imports a previously-exported merged PDF, replacing every entry currently in the store with the per-slot documents recorded in its manifest.
+     *
+     * This is the programmatic equivalent of what {@link DbxPdfMergeImportComponent} does with a picked file, and that component delegates here — so a stored document loaded by an app and a file chosen by a user go through one implementation with one set of error semantics. Progress and outcome are published on {@link importState$} as well as returned.
+     *
+     * @param input - The source blob plus the optional slot check and sidecar-less fallback.
+     * @returns The terminal state of this import.
+     */
+    async importMergedPdf(input) {
+        const { source, expectedSlotIds, allowWithoutSidecar, fileName } = input;
+        const origin = input.origin ?? 'programmatic';
+        const config = { allowWithoutSidecar, fileName };
+        this._importState$.next({ status: 'importing', origin });
+        const outcome = await buildPdfMergeEntriesFromSidecar(source, config);
+        let state;
+        if ('error' in outcome) {
+            state = { status: 'failed', origin, error: outcome.error };
+        }
+        else {
+            // An unsectioned document counts as unexpected too: in a slots-only editor it would render
+            // nowhere, so rejecting it beats importing pages the user can never see again.
+            const unexpected = expectedSlotIds == null ? [] : outcome.slotIds.filter((slotId) => slotId == null || !expectedSlotIds.includes(slotId));
+            if (unexpected.length > 0) {
+                state = { status: 'failed', origin, error: 'unexpected_slots', unexpectedSlotIds: unexpected };
+            }
+            else {
+                const missingSlotIds = expectedSlotIds == null ? [] : expectedSlotIds.filter((slotId) => !outcome.slotIds.includes(slotId));
+                this.replaceEntries(outcome.entries);
+                state = { status: 'imported', origin, result: { ...outcome, missingSlotIds } };
+                // A programmatic import is the app telling the editor what it should be showing, so it
+                // becomes the restore point. A user's pick deliberately does NOT overwrite it: the person
+                // replaced what is on screen, not what the app configured.
+                if (origin === 'programmatic') {
+                    this._restorableImport = input;
+                }
+            }
+        }
+        this._importState$.next(state);
+        return state;
+    }
+    /**
+     * Discards the current import lifecycle, so consumers rendering its notices (the picker's "Imported N section(s)" success line, its missing-section warning, its error) fall back to showing nothing.
+     *
+     * Separate from the entry list — this clears the *record* of an import, not its contents.
+     */
+    clearImportState() {
+        this._importState$.next(undefined);
+    }
+    /**
+     * Empties the editor, or resets it to its programmatic baseline when one exists.
+     *
+     * This is the "Clear" affordance's operation, and it deliberately is not a plain {@link clearAll}. When the surrounding app supplied the document (a programmatic {@link importMergedPdf}, or `[source]` on {@link DbxPdfMergeEditorStoreDirective}), emptying the editor would strand it in a state the app never asked for and has no obvious way to notice. Instead the original import is re-run, landing the view exactly where it was when the document first arrived — page edits, section removals, and any user-picked file on top of it all discarded.
+     *
+     * With no baseline — the ordinary case, including an editor whose only import came from {@link DbxPdfMergeImportComponent} — the entries and the import state both go, so no stale success/warning notice outlives the content it described.
+     *
+     * @param input - Optional override for the restore behavior.
+     * @returns Whether the baseline was restored, plus the re-import's terminal state when one ran.
+     */
+    async clearEntries(input) {
+        const restorable = this._restorableImport;
+        const shouldRestore = (input?.restoreImport ?? true) && restorable != null;
+        let result;
+        if (shouldRestore) {
+            const importState = await this.importMergedPdf(restorable);
+            // A baseline that no longer imports (unreadable retained blob) must not leave the old
+            // entries sitting there — the user asked for a clear and got neither.
+            if (importState.status === 'imported') {
+                result = { restored: true, importState };
+            }
+            else {
+                this.clearAll();
+                result = { restored: false, importState };
+            }
+        }
+        else {
+            this.clearAll();
+            this.clearImportState();
+            result = { restored: false };
+        }
+        return result;
+    }
+    /**
+     * Adds a single document to a slot, without any sidecar involvement — the programmatic equivalent of a user dropping one file onto a slot uploader. Existing entries are left alone.
+     *
+     * Unlike {@link importMergedPdf} this neither reads nor requires a manifest; it is the plain "put this file in that slot" primitive, for e.g. an admin appending one document to an existing set. The entry can be added before its slot mounts — {@link entriesForSlotId$} picks it up when the slot renders.
+     *
+     * @param input - The blob or file, its target slot, and an optional name for a bare blob.
+     * @returns The entry that was added, or `null` when the file is not a supported PDF/PNG/JPEG (in which case nothing was added).
+     */
+    async addFileToSlot(input) {
+        const { file, slotId, fileName, imageCompression } = input;
+        const entry = await buildPdfMergeEntry(asPdfMergeFile(file, fileName), { slotId, imageCompression: imageCompression ?? this._imageCompression$.value });
+        if (entry != null) {
+            this.addFiles({ entries: [entry] });
+        }
+        return entry;
+    }
     // MARK: Validator
     /**
      * Registers a {@link DbxPdfMergeEditorValidator} delegate that gates merge emissions. Only one delegate is active at a time — calling this replaces any previously registered delegate.
@@ -18597,6 +19493,22 @@ class DbxPdfMergeEditorStore extends ComponentStore {
     setEncryptedHandling(handling) {
         this._encryptedHandling$.next(handling ?? undefined);
     }
+    /**
+     * Enables or disables page editing, exposed via {@link pageEditing$}. Turning it on expands each ready entry into its individual pages; turning it off returns the editor to its file-granular behavior while preserving any page edits in state, so toggling back on restores them.
+     *
+     * @param pageEditing - Whether page editing is active, or a falsy value to clear and fall back to {@link DEFAULT_DBX_PDF_MERGE_PAGE_EDITING}.
+     */
+    setPageEditing(pageEditing) {
+        this._pageEditing$.next(pageEditing ?? undefined);
+    }
+    /**
+     * Enables or disables the embedded manifest, exposed via {@link sidecar$}.
+     *
+     * @param sidecar - Whether to embed the manifest, or a falsy value to clear and fall back to {@link DEFAULT_DBX_PDF_MERGE_SIDECAR}.
+     */
+    setSidecar(sidecar) {
+        this._sidecar$.next(sidecar ?? undefined);
+    }
     // MARK: Updaters
     /**
      * Appends entries (already constructed) or builds them from raw files and appends them to state. Each entry's validation promise starts when the entry is built; {@link entries$} reflects each result as it resolves. When `input` is an object with `files` and `slotId`, the resulting entries are tagged with that slot id. When `input` is `{ entries }`, the entries are appended as-is — use this shape for entries that went through async client-side compression upstream.
@@ -18619,11 +19531,17 @@ class DbxPdfMergeEditorStore extends ComponentStore {
         }
         return newEntries.length > 0 ? { ...state, rawEntries: [...state.rawEntries, ...newEntries] } : state;
     });
-    removeEntry = this.updater((state, id) => ({ ...state, rawEntries: state.rawEntries.filter((entry) => entry.id !== id) }));
+    removeEntry = this.updater((state, id) => {
+        const rawEntries = state.rawEntries.filter((entry) => entry.id !== id);
+        return { ...state, rawEntries, ...prunePdfMergePageState(state, new Set(rawEntries.map((entry) => entry.id))) };
+    });
     /**
      * Removes every entry whose `slotId` matches the given id. Used by {@link DbxPdfMergeEditorFileUploadComponent} on destroy so a slot's entries leave with it.
      */
-    removeEntriesBySlotId = this.updater((state, slotId) => ({ ...state, rawEntries: state.rawEntries.filter((entry) => entry.slotId !== slotId) }));
+    removeEntriesBySlotId = this.updater((state, slotId) => {
+        const rawEntries = state.rawEntries.filter((entry) => entry.slotId !== slotId);
+        return { ...state, rawEntries, ...prunePdfMergePageState(state, new Set(rawEntries.map((entry) => entry.id))) };
+    });
     moveEntry = this.updater((state, move) => {
         let nextState;
         if (move.previousIndex === move.currentIndex) {
@@ -18663,7 +19581,49 @@ class DbxPdfMergeEditorStore extends ComponentStore {
         }
         return nextState;
     });
-    clearAll = this.updater((state) => ({ ...state, rawEntries: [] }));
+    clearAll = this.updater((state) => ({ ...state, rawEntries: [], pageOverrides: {}, pageOrder: {} }));
+    /**
+     * Replaces the entire entry list, discarding any page edits.
+     *
+     * Used by the sidecar import path, which reconstructs a fresh set of slot-tagged entries from a previously-exported file. Done as a single state change so subscribers never observe an intermediate empty list.
+     */
+    replaceEntries = this.updater((state, entries) => ({ ...state, rawEntries: [...entries], pageOverrides: {}, pageOrder: {} }));
+    // MARK: Page updaters
+    /**
+     * Reorders a page inside its own group. Groups never exchange pages — the page list renders one CDK drop list per group, so a cross-group drag is impossible to express.
+     *
+     * The move rewrites the id array the caller rendered rather than recomputing it from state, keeping the stored order aligned with what the user saw.
+     */
+    movePageWithinGroup = this.updater((state, move) => {
+        let nextState;
+        if (move.previousIndex === move.currentIndex || move.previousIndex < 0 || move.currentIndex < 0 || move.previousIndex >= move.pageIds.length || move.currentIndex >= move.pageIds.length) {
+            nextState = state;
+        }
+        else {
+            const pageIds = [...move.pageIds];
+            moveItemInArray(pageIds, move.previousIndex, move.currentIndex);
+            nextState = { ...state, pageOrder: { ...state.pageOrder, [move.groupKey]: pageIds } };
+        }
+        return nextState;
+    });
+    /**
+     * Sets a page's rotation. The value is composed onto the page's own source rotation at merge time, so this is the rotation the user applied rather than the page's absolute orientation.
+     */
+    setPageRotation = this.updater((state, change) => {
+        const current = state.pageOverrides[change.pageId];
+        return { ...state, pageOverrides: { ...state.pageOverrides, [change.pageId]: { rotation: change.rotation, removed: current?.removed ?? false } } };
+    });
+    /**
+     * Marks a page for deletion or restores it. Marked pages stay in the list so the choice can be undone, but are excluded from the merged output.
+     */
+    setPageRemoved = this.updater((state, change) => {
+        const current = state.pageOverrides[change.pageId];
+        return { ...state, pageOverrides: { ...state.pageOverrides, [change.pageId]: { rotation: current?.rotation ?? 0, removed: change.removed } } };
+    });
+    /**
+     * Discards every page edit, returning the plan to natural order with no rotations or deletions. Leaves the entries themselves untouched.
+     */
+    clearPageEdits = this.updater((state) => ({ ...state, pageOverrides: {}, pageOrder: {} }));
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeEditorStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeEditorStore });
 }
@@ -18688,6 +19648,19 @@ class DbxPdfMergeEditorStoreDirective {
     _injectedConfig = inject(DBX_PDF_MERGE_EDITOR_CONFIG, { optional: true });
     config = input(...(ngDevMode ? [undefined, { debugName: "config" }] : /* istanbul ignore next */ []));
     outputSizeLimit = input(...(ngDevMode ? [undefined, { debugName: "outputSizeLimit" }] : /* istanbul ignore next */ []));
+    /**
+     * A previously-exported merged PDF to load into the store, for an app that fetches a stored document itself and wants the editor to open already populated — no picker involved.
+     *
+     * Imported once per distinct blob instance: re-emitting the same object does nothing, so a template re-render or an unrelated input change cannot re-import. Emitting a *different* blob imports again and replaces the entries, even if the bytes are identical.
+     *
+     * Watch {@link DbxPdfMergeEditorStore.importState$} for the outcome — a failure surfaces there rather than throwing.
+     */
+    source = input(...(ngDevMode ? [undefined, { debugName: "source" }] : /* istanbul ignore next */ []));
+    sourceConfig = input(...(ngDevMode ? [undefined, { debugName: "sourceConfig" }] : /* istanbul ignore next */ []));
+    /**
+     * The blob instance most recently handed to the store, so the same one is never imported twice.
+     */
+    _importedSource;
     effectiveErrorBytesSignal = computed(() => {
         const direct = this.outputSizeLimit();
         if (direct != null) {
@@ -18719,9 +19692,30 @@ class DbxPdfMergeEditorStoreDirective {
         effect(() => {
             this.store.setEncryptedHandling(this.config()?.encryptedHandling);
         });
+        // Same channel for pageEditing, so a dialog-hosted editor opens straight into page
+        // editing mode when the host directive asked for it.
+        effect(() => {
+            this.store.setPageEditing(this.config()?.pageEditing);
+        });
+        // Same channel for the embedded manifest. Gated separately from pageEditing — a plain
+        // slot merge benefits from recording which pages came from which slot too.
+        effect(() => {
+            this.store.setSidecar(this.config()?.sidecar);
+        });
+        // Loading a source is not idempotent the way the setters above are — it REPLACES the store's
+        // entries — so this tracks only `source` and guards on instance identity. `sourceConfig` is
+        // read untracked so changing it never re-imports; it is read at the moment a new blob arrives.
+        effect(() => {
+            const source = this.source();
+            if (source != null && source !== this._importedSource) {
+                this._importedSource = source;
+                const sourceConfig = untracked(() => this.sourceConfig());
+                void this.store.importMergedPdf({ source, expectedSlotIds: sourceConfig?.expectedSlotIds, allowWithoutSidecar: sourceConfig?.allowWithoutSidecar, fileName: sourceConfig?.fileName });
+            }
+        });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeEditorStoreDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.11", type: DbxPdfMergeEditorStoreDirective, isStandalone: true, selector: "[dbxPdfMergeEditorStore]", inputs: { config: { classPropertyName: "config", publicName: "config", isSignal: true, isRequired: false, transformFunction: null }, outputSizeLimit: { classPropertyName: "outputSizeLimit", publicName: "outputSizeLimit", isSignal: true, isRequired: false, transformFunction: null } }, providers: [DbxPdfMergeEditorStore], exportAs: ["dbxPdfMergeEditorStore"], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.11", type: DbxPdfMergeEditorStoreDirective, isStandalone: true, selector: "[dbxPdfMergeEditorStore]", inputs: { config: { classPropertyName: "config", publicName: "config", isSignal: true, isRequired: false, transformFunction: null }, outputSizeLimit: { classPropertyName: "outputSizeLimit", publicName: "outputSizeLimit", isSignal: true, isRequired: false, transformFunction: null }, source: { classPropertyName: "source", publicName: "source", isSignal: true, isRequired: false, transformFunction: null }, sourceConfig: { classPropertyName: "sourceConfig", publicName: "sourceConfig", isSignal: true, isRequired: false, transformFunction: null } }, providers: [DbxPdfMergeEditorStore], exportAs: ["dbxPdfMergeEditorStore"], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeEditorStoreDirective, decorators: [{
             type: Directive,
@@ -18731,10 +19725,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
                     providers: [DbxPdfMergeEditorStore],
                     exportAs: 'dbxPdfMergeEditorStore'
                 }]
-        }], ctorParameters: () => [], propDecorators: { config: [{ type: i0.Input, args: [{ isSignal: true, alias: "config", required: false }] }], outputSizeLimit: [{ type: i0.Input, args: [{ isSignal: true, alias: "outputSizeLimit", required: false }] }] } });
+        }], ctorParameters: () => [], propDecorators: { config: [{ type: i0.Input, args: [{ isSignal: true, alias: "config", required: false }] }], outputSizeLimit: [{ type: i0.Input, args: [{ isSignal: true, alias: "outputSizeLimit", required: false }] }], source: [{ type: i0.Input, args: [{ isSignal: true, alias: "source", required: false }] }], sourceConfig: [{ type: i0.Input, args: [{ isSignal: true, alias: "sourceConfig", required: false }] }] } });
 
-const PDF_ICON = 'picture_as_pdf';
-const IMAGE_ICON = 'image';
+const PDF_ICON$1 = 'picture_as_pdf';
+const IMAGE_ICON$1 = 'image';
 const ERROR_ICON = 'error';
 /**
  * Single row inside the {@link DbxPdfMergeListComponent}: shows the file's icon, name, formatted size, status, drag handle, and a remove button. The component's template is itself a `cdkDrag` element so each row can be reordered inside the parent's `cdkDropList`.
@@ -18751,10 +19745,10 @@ class DbxPdfMergeEntryComponent {
             icon = ERROR_ICON;
         }
         else if (entry.kind === 'pdf') {
-            icon = PDF_ICON;
+            icon = PDF_ICON$1;
         }
         else {
-            icon = IMAGE_ICON;
+            icon = IMAGE_ICON$1;
         }
         return icon;
     }, ...(ngDevMode ? [{ debugName: "iconSignal" }] : /* istanbul ignore next */ []));
@@ -18829,116 +19823,385 @@ class DbxPdfMergeEntryComponent {
           }
         </div>
       </div>
-      @if (isValidatingSignal()) {
-        <mat-progress-spinner mode="indeterminate" diameter="20"></mat-progress-spinner>
-      }
-      <button mat-icon-button type="button" class="dbx-pdf-merge-entry-remove" (click)="onRemove()" aria-label="Remove file">
-        <mat-icon>close</mat-icon>
+      @if (isValidatingSignal()) {
+        <mat-progress-spinner mode="indeterminate" diameter="20"></mat-progress-spinner>
+      }
+      <button mat-icon-button type="button" class="dbx-pdf-merge-entry-remove" (click)="onRemove()" aria-label="Remove file">
+        <mat-icon>close</mat-icon>
+      </button>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "directive", type: CdkDrag, selector: "[cdkDrag]", inputs: ["cdkDragData", "cdkDragLockAxis", "cdkDragRootElement", "cdkDragBoundary", "cdkDragStartDelay", "cdkDragFreeDragPosition", "cdkDragDisabled", "cdkDragConstrainPosition", "cdkDragPreviewClass", "cdkDragPreviewContainer", "cdkDragScale"], outputs: ["cdkDragStarted", "cdkDragReleased", "cdkDragEnded", "cdkDragEntered", "cdkDragExited", "cdkDragDropped", "cdkDragMoved"], exportAs: ["cdkDrag"] }, { kind: "directive", type: CdkDragHandle, selector: "[cdkDragHandle]", inputs: ["cdkDragHandleDisabled"] }, { kind: "directive", type: CdkDragPlaceholder, selector: "ng-template[cdkDragPlaceholder]", inputs: ["data"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i1$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i1.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatProgressSpinnerModule }, { kind: "component", type: i3.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "mode", "value", "diameter", "strokeWidth"], exportAs: ["matProgressSpinner"] }, { kind: "directive", type: DbxChipDirective, selector: "dbx-chip", inputs: ["small", "block", "color", "display", "tone"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeEntryComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-pdf-merge-entry',
+                    template: `
+    <div class="dbx-pdf-merge-entry-row" cdkDrag cdkDragLockAxis="y">
+      <ng-template cdkDragPlaceholder>
+        <div class="dbx-pdf-merge-entry-placeholder"></div>
+      </ng-template>
+      <button mat-icon-button type="button" cdkDragHandle class="dbx-pdf-merge-entry-handle" aria-label="Drag to reorder">
+        <mat-icon>drag_indicator</mat-icon>
+      </button>
+      <mat-icon class="dbx-pdf-merge-entry-icon" [class.dbx-warn]="isErrorSignal()">{{ iconSignal() }}</mat-icon>
+      <div class="dbx-pdf-merge-entry-info dbx-flex-fill-0">
+        <div class="dbx-pdf-merge-entry-name dbx-text-truncate" [title]="entry().name">{{ entry().name }}</div>
+        <div class="dbx-pdf-merge-entry-meta dbx-hint dbx-small">
+          <span>{{ sizeSignal() }}</span>
+          @if (isEncryptedSignal()) {
+            <dbx-chip class="dbx-pdf-merge-entry-encrypted-chip" color="warn" [small]="true">
+              <mat-icon class="dbx-pdf-merge-entry-encrypted-icon">lock</mat-icon>
+              <span>Encrypted</span>
+            </dbx-chip>
+          }
+          @if (compressionLabelSignal(); as compressionLabel) {
+            <span class="dbx-pdf-merge-entry-compression">{{ compressionLabel }}</span>
+          }
+          @if (statusLabelSignal(); as label) {
+            <span class="dbx-pdf-merge-entry-status" [class.dbx-warn]="isErrorSignal()">{{ label }}</span>
+          }
+        </div>
+      </div>
+      @if (isValidatingSignal()) {
+        <mat-progress-spinner mode="indeterminate" diameter="20"></mat-progress-spinner>
+      }
+      <button mat-icon-button type="button" class="dbx-pdf-merge-entry-remove" (click)="onRemove()" aria-label="Remove file">
+        <mat-icon>close</mat-icon>
+      </button>
+    </div>
+  `,
+                    host: {
+                        class: 'dbx-pdf-merge-entry d-block',
+                        '[class.dbx-pdf-merge-entry--error]': 'isErrorSignal()',
+                        '[class.dbx-pdf-merge-entry--validating]': 'isValidatingSignal()',
+                        '[class.dbx-pdf-merge-entry--ignored]': 'isIgnoredSignal()',
+                        '[class.dbx-pdf-merge-entry--encrypted]': 'isEncryptedSignal()'
+                    },
+                    imports: [CdkDrag, CdkDragHandle, CdkDragPlaceholder, MatIconModule, MatButtonModule, MatProgressSpinnerModule, DbxChipDirective],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true
+                }]
+        }], propDecorators: { entry: [{ type: i0.Input, args: [{ isSignal: true, alias: "entry", required: true }] }] } });
+
+/**
+ * Renders the staged entries inside a CDK drop list. Each row is a {@link DbxPdfMergeEntryComponent} that hosts its own `cdkDrag`, so reordering events bubble up here as `cdkDropListDropped` and forward to the store's `moveEntry` updater.
+ */
+class DbxPdfMergeListComponent {
+    store = inject(DbxPdfMergeEditorStore);
+    entries$ = this.store.displayEntries$;
+    onDrop(event) {
+        this.store.moveEntry({ previousIndex: event.previousIndex, currentIndex: event.currentIndex });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxPdfMergeListComponent, isStandalone: true, selector: "dbx-pdf-merge-list", host: { classAttribute: "dbx-pdf-merge-list" }, ngImport: i0, template: `
+    @if (entries$ | async; as entries) {
+      @if (entries.length === 0) {
+        <div class="dbx-list-empty-content dbx-hint dbx-p4">No files added yet.</div>
+      } @else {
+        <div class="dbx-pdf-merge-list-items" cdkDropList (cdkDropListDropped)="onDrop($event)">
+          @for (entry of entries; track entry.id) {
+            <dbx-pdf-merge-entry [entry]="entry"></dbx-pdf-merge-entry>
+          }
+        </div>
+      }
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: CdkDropList, selector: "[cdkDropList], cdk-drop-list", inputs: ["cdkDropListConnectedTo", "cdkDropListData", "cdkDropListOrientation", "id", "cdkDropListLockAxis", "cdkDropListDisabled", "cdkDropListSortingDisabled", "cdkDropListEnterPredicate", "cdkDropListSortPredicate", "cdkDropListAutoScrollDisabled", "cdkDropListAutoScrollStep", "cdkDropListElementContainer", "cdkDropListHasAnchor"], outputs: ["cdkDropListDropped", "cdkDropListEntered", "cdkDropListExited", "cdkDropListSorted"], exportAs: ["cdkDropList"] }, { kind: "component", type: DbxPdfMergeEntryComponent, selector: "dbx-pdf-merge-entry", inputs: ["entry"] }, { kind: "pipe", type: AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeListComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-pdf-merge-list',
+                    template: `
+    @if (entries$ | async; as entries) {
+      @if (entries.length === 0) {
+        <div class="dbx-list-empty-content dbx-hint dbx-p4">No files added yet.</div>
+      } @else {
+        <div class="dbx-pdf-merge-list-items" cdkDropList (cdkDropListDropped)="onDrop($event)">
+          @for (entry of entries; track entry.id) {
+            <dbx-pdf-merge-entry [entry]="entry"></dbx-pdf-merge-entry>
+          }
+        </div>
+      }
+    }
+  `,
+                    host: {
+                        class: 'dbx-pdf-merge-list'
+                    },
+                    imports: [AsyncPipe, CdkDropList, DbxPdfMergeEntryComponent],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true
+                }]
+        }] });
+
+const PDF_ICON = 'picture_as_pdf';
+const IMAGE_ICON = 'image';
+/**
+ * Degrees added by one press of the rotate control.
+ */
+const ROTATION_STEP_DEGREES = 90;
+/**
+ * PDF points per inch. PDF page dimensions are expressed in points; inches read better on a scanned document.
+ */
+const POINTS_PER_INCH = 72;
+const ROTATION_VALUES = [0, 90, 180, 270];
+/**
+ * Single page row inside a {@link DbxPdfMergePageListComponent} group: shows which source file and page it came from, its dimensions and rotation, and controls to rotate it, mark it for removal, and drag it to a new position.
+ *
+ * The template's root element is itself a `cdkDrag`, matching {@link DbxPdfMergeEntryComponent}, so rows reorder inside their group's drop list.
+ */
+class DbxPdfMergePageComponent {
+    store = inject(DbxPdfMergeEditorStore);
+    page = input.required(...(ngDevMode ? [{ debugName: "page" }] : /* istanbul ignore next */ []));
+    removedSignal = computed(() => this.page().removed, ...(ngDevMode ? [{ debugName: "removedSignal" }] : /* istanbul ignore next */ []));
+    iconSignal = computed(() => (this.page().kind === 'pdf' ? PDF_ICON : IMAGE_ICON), ...(ngDevMode ? [{ debugName: "iconSignal" }] : /* istanbul ignore next */ []));
+    removeLabelSignal = computed(() => (this.removedSignal() ? 'Restore page' : 'Mark page for removal'), ...(ngDevMode ? [{ debugName: "removeLabelSignal" }] : /* istanbul ignore next */ []));
+    positionLabelSignal = computed(() => {
+        const page = this.page();
+        let label;
+        if (page.kind === 'image') {
+            label = 'Image';
+        }
+        else {
+            label = `Page ${page.sourceIndex + 1} of ${page.sourcePageCount}`;
+        }
+        return label;
+    }, ...(ngDevMode ? [{ debugName: "positionLabelSignal" }] : /* istanbul ignore next */ []));
+    dimensionsLabelSignal = computed(() => {
+        const { kind, meta } = this.page();
+        let label;
+        if (meta.width <= 0 || meta.height <= 0) {
+            label = null;
+        }
+        else if (kind === 'image') {
+            label = `${Math.round(meta.width)} × ${Math.round(meta.height)} px`;
+        }
+        else {
+            label = `${(meta.width / POINTS_PER_INCH).toFixed(1)} × ${(meta.height / POINTS_PER_INCH).toFixed(1)} in`;
+        }
+        return label;
+    }, ...(ngDevMode ? [{ debugName: "dimensionsLabelSignal" }] : /* istanbul ignore next */ []));
+    rotationLabelSignal = computed(() => {
+        const rotation = this.page().rotation;
+        return rotation === 0 ? null : `${rotation}°`;
+    }, ...(ngDevMode ? [{ debugName: "rotationLabelSignal" }] : /* istanbul ignore next */ []));
+    onRotate() {
+        const page = this.page();
+        const next = ROTATION_VALUES[((page.rotation + ROTATION_STEP_DEGREES) / ROTATION_STEP_DEGREES) % ROTATION_VALUES.length];
+        this.store.setPageRotation({ pageId: page.id, rotation: next });
+    }
+    onToggleRemoved() {
+        const page = this.page();
+        this.store.setPageRemoved({ pageId: page.id, removed: !page.removed });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergePageComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxPdfMergePageComponent, isStandalone: true, selector: "dbx-pdf-merge-page", inputs: { page: { classPropertyName: "page", publicName: "page", isSignal: true, isRequired: true, transformFunction: null } }, host: { properties: { "class.dbx-pdf-merge-page--removed": "removedSignal()" }, classAttribute: "dbx-pdf-merge-page d-block" }, ngImport: i0, template: `
+    <div class="dbx-pdf-merge-page-row" cdkDrag cdkDragLockAxis="y">
+      <ng-template cdkDragPlaceholder>
+        <div class="dbx-pdf-merge-page-placeholder"></div>
+      </ng-template>
+      <button mat-icon-button type="button" cdkDragHandle class="dbx-pdf-merge-page-handle" aria-label="Drag to reorder page">
+        <mat-icon>drag_indicator</mat-icon>
+      </button>
+      <mat-icon class="dbx-pdf-merge-page-icon">{{ iconSignal() }}</mat-icon>
+      <div class="dbx-pdf-merge-page-info dbx-flex-fill-0">
+        <div class="dbx-pdf-merge-page-name dbx-text-truncate" [title]="page().sourceName">{{ page().sourceName }}</div>
+        <div class="dbx-pdf-merge-page-meta dbx-hint dbx-small">
+          <span class="dbx-pdf-merge-page-position">{{ positionLabelSignal() }}</span>
+          @if (dimensionsLabelSignal(); as dimensions) {
+            <span class="dbx-pdf-merge-page-dimensions">{{ dimensions }}</span>
+          }
+          @if (rotationLabelSignal(); as rotation) {
+            <dbx-chip class="dbx-pdf-merge-page-rotation-chip" [small]="true">
+              <mat-icon class="dbx-pdf-merge-page-rotation-icon">rotate_right</mat-icon>
+              <span>{{ rotation }}</span>
+            </dbx-chip>
+          }
+          @if (removedSignal()) {
+            <span class="dbx-pdf-merge-page-removed-label dbx-warn">Will be removed</span>
+          }
+        </div>
+      </div>
+      <button mat-icon-button type="button" class="dbx-pdf-merge-page-rotate" [disabled]="removedSignal()" (click)="onRotate()" aria-label="Rotate page 90 degrees">
+        <mat-icon>rotate_right</mat-icon>
+      </button>
+      <button mat-icon-button type="button" class="dbx-pdf-merge-page-remove" (click)="onToggleRemoved()" [attr.aria-label]="removeLabelSignal()">
+        <mat-icon>{{ removedSignal() ? 'undo' : 'close' }}</mat-icon>
       </button>
     </div>
-  `, isInline: true, dependencies: [{ kind: "directive", type: CdkDrag, selector: "[cdkDrag]", inputs: ["cdkDragData", "cdkDragLockAxis", "cdkDragRootElement", "cdkDragBoundary", "cdkDragStartDelay", "cdkDragFreeDragPosition", "cdkDragDisabled", "cdkDragConstrainPosition", "cdkDragPreviewClass", "cdkDragPreviewContainer", "cdkDragScale"], outputs: ["cdkDragStarted", "cdkDragReleased", "cdkDragEnded", "cdkDragEntered", "cdkDragExited", "cdkDragDropped", "cdkDragMoved"], exportAs: ["cdkDrag"] }, { kind: "directive", type: CdkDragHandle, selector: "[cdkDragHandle]", inputs: ["cdkDragHandleDisabled"] }, { kind: "directive", type: CdkDragPlaceholder, selector: "ng-template[cdkDragPlaceholder]", inputs: ["data"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i1$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i1.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatProgressSpinnerModule }, { kind: "component", type: i3.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "mode", "value", "diameter", "strokeWidth"], exportAs: ["matProgressSpinner"] }, { kind: "directive", type: DbxChipDirective, selector: "dbx-chip", inputs: ["small", "block", "color", "display", "tone"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, dependencies: [{ kind: "directive", type: CdkDrag, selector: "[cdkDrag]", inputs: ["cdkDragData", "cdkDragLockAxis", "cdkDragRootElement", "cdkDragBoundary", "cdkDragStartDelay", "cdkDragFreeDragPosition", "cdkDragDisabled", "cdkDragConstrainPosition", "cdkDragPreviewClass", "cdkDragPreviewContainer", "cdkDragScale"], outputs: ["cdkDragStarted", "cdkDragReleased", "cdkDragEnded", "cdkDragEntered", "cdkDragExited", "cdkDragDropped", "cdkDragMoved"], exportAs: ["cdkDrag"] }, { kind: "directive", type: CdkDragHandle, selector: "[cdkDragHandle]", inputs: ["cdkDragHandleDisabled"] }, { kind: "directive", type: CdkDragPlaceholder, selector: "ng-template[cdkDragPlaceholder]", inputs: ["data"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i1$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i1.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "directive", type: DbxChipDirective, selector: "dbx-chip", inputs: ["small", "block", "color", "display", "tone"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeEntryComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergePageComponent, decorators: [{
             type: Component,
             args: [{
-                    selector: 'dbx-pdf-merge-entry',
+                    selector: 'dbx-pdf-merge-page',
                     template: `
-    <div class="dbx-pdf-merge-entry-row" cdkDrag cdkDragLockAxis="y">
+    <div class="dbx-pdf-merge-page-row" cdkDrag cdkDragLockAxis="y">
       <ng-template cdkDragPlaceholder>
-        <div class="dbx-pdf-merge-entry-placeholder"></div>
+        <div class="dbx-pdf-merge-page-placeholder"></div>
       </ng-template>
-      <button mat-icon-button type="button" cdkDragHandle class="dbx-pdf-merge-entry-handle" aria-label="Drag to reorder">
+      <button mat-icon-button type="button" cdkDragHandle class="dbx-pdf-merge-page-handle" aria-label="Drag to reorder page">
         <mat-icon>drag_indicator</mat-icon>
       </button>
-      <mat-icon class="dbx-pdf-merge-entry-icon" [class.dbx-warn]="isErrorSignal()">{{ iconSignal() }}</mat-icon>
-      <div class="dbx-pdf-merge-entry-info dbx-flex-fill-0">
-        <div class="dbx-pdf-merge-entry-name dbx-text-truncate" [title]="entry().name">{{ entry().name }}</div>
-        <div class="dbx-pdf-merge-entry-meta dbx-hint dbx-small">
-          <span>{{ sizeSignal() }}</span>
-          @if (isEncryptedSignal()) {
-            <dbx-chip class="dbx-pdf-merge-entry-encrypted-chip" color="warn" [small]="true">
-              <mat-icon class="dbx-pdf-merge-entry-encrypted-icon">lock</mat-icon>
-              <span>Encrypted</span>
-            </dbx-chip>
+      <mat-icon class="dbx-pdf-merge-page-icon">{{ iconSignal() }}</mat-icon>
+      <div class="dbx-pdf-merge-page-info dbx-flex-fill-0">
+        <div class="dbx-pdf-merge-page-name dbx-text-truncate" [title]="page().sourceName">{{ page().sourceName }}</div>
+        <div class="dbx-pdf-merge-page-meta dbx-hint dbx-small">
+          <span class="dbx-pdf-merge-page-position">{{ positionLabelSignal() }}</span>
+          @if (dimensionsLabelSignal(); as dimensions) {
+            <span class="dbx-pdf-merge-page-dimensions">{{ dimensions }}</span>
           }
-          @if (compressionLabelSignal(); as compressionLabel) {
-            <span class="dbx-pdf-merge-entry-compression">{{ compressionLabel }}</span>
+          @if (rotationLabelSignal(); as rotation) {
+            <dbx-chip class="dbx-pdf-merge-page-rotation-chip" [small]="true">
+              <mat-icon class="dbx-pdf-merge-page-rotation-icon">rotate_right</mat-icon>
+              <span>{{ rotation }}</span>
+            </dbx-chip>
           }
-          @if (statusLabelSignal(); as label) {
-            <span class="dbx-pdf-merge-entry-status" [class.dbx-warn]="isErrorSignal()">{{ label }}</span>
+          @if (removedSignal()) {
+            <span class="dbx-pdf-merge-page-removed-label dbx-warn">Will be removed</span>
           }
         </div>
       </div>
-      @if (isValidatingSignal()) {
-        <mat-progress-spinner mode="indeterminate" diameter="20"></mat-progress-spinner>
-      }
-      <button mat-icon-button type="button" class="dbx-pdf-merge-entry-remove" (click)="onRemove()" aria-label="Remove file">
-        <mat-icon>close</mat-icon>
+      <button mat-icon-button type="button" class="dbx-pdf-merge-page-rotate" [disabled]="removedSignal()" (click)="onRotate()" aria-label="Rotate page 90 degrees">
+        <mat-icon>rotate_right</mat-icon>
+      </button>
+      <button mat-icon-button type="button" class="dbx-pdf-merge-page-remove" (click)="onToggleRemoved()" [attr.aria-label]="removeLabelSignal()">
+        <mat-icon>{{ removedSignal() ? 'undo' : 'close' }}</mat-icon>
       </button>
     </div>
   `,
                     host: {
-                        class: 'dbx-pdf-merge-entry d-block',
-                        '[class.dbx-pdf-merge-entry--error]': 'isErrorSignal()',
-                        '[class.dbx-pdf-merge-entry--validating]': 'isValidatingSignal()',
-                        '[class.dbx-pdf-merge-entry--ignored]': 'isIgnoredSignal()',
-                        '[class.dbx-pdf-merge-entry--encrypted]': 'isEncryptedSignal()'
+                        class: 'dbx-pdf-merge-page d-block',
+                        '[class.dbx-pdf-merge-page--removed]': 'removedSignal()'
                     },
-                    imports: [CdkDrag, CdkDragHandle, CdkDragPlaceholder, MatIconModule, MatButtonModule, MatProgressSpinnerModule, DbxChipDirective],
+                    imports: [CdkDrag, CdkDragHandle, CdkDragPlaceholder, MatIconModule, MatButtonModule, DbxChipDirective],
                     changeDetection: ChangeDetectionStrategy.OnPush,
                     standalone: true
                 }]
-        }], propDecorators: { entry: [{ type: i0.Input, args: [{ isSignal: true, alias: "entry", required: true }] }] } });
+        }], propDecorators: { page: [{ type: i0.Input, args: [{ isSignal: true, alias: "page", required: true }] }] } });
 
 /**
- * Renders the staged entries inside a CDK drop list. Each row is a {@link DbxPdfMergeEntryComponent} that hosts its own `cdkDrag`, so reordering events bubble up here as `cdkDropListDropped` and forward to the store's `moveEntry` updater.
+ * Message shown for an entry that is not encrypted but still could not be parsed into pages.
  */
-class DbxPdfMergeListComponent {
+const UNREADABLE_PAGES_MESSAGE = 'Pages could not be read.';
+/**
+ * Renders the editor's page plan while page editing is enabled, one CDK drop list per group.
+ *
+ * Separate, unconnected drop lists are what confine reordering to a single slot: CDK will not let a drag cross into a list it is not connected to, so the rule needs no guard code. Bind {@link slotId} to render only that slot's group — used by {@link DbxPdfMergeEditorFileUploadComponent} to show its own pages inline. Leave it unbound to render every group.
+ *
+ * Entries that could not be expanded into pages (encrypted, or unparseable) are listed separately below the groups rather than silently omitted.
+ */
+class DbxPdfMergePageListComponent {
     store = inject(DbxPdfMergeEditorStore);
-    entries$ = this.store.displayEntries$;
-    onDrop(event) {
-        this.store.moveEntry({ previousIndex: event.previousIndex, currentIndex: event.currentIndex });
+    /**
+     * Renders only this slot's group when bound. Leave unbound to render every group.
+     */
+    slotId = input(...(ngDevMode ? [undefined, { debugName: "slotId" }] : /* istanbul ignore next */ []));
+    /**
+     * Whether to show each group's slot name above its pages. Defaults to `true` when rendering every group and `false` when scoped to one slot, where the slot already has its own heading.
+     */
+    showGroupLabels = input(...(ngDevMode ? [undefined, { debugName: "showGroupLabels" }] : /* istanbul ignore next */ []));
+    _slotId$ = toObservable(this.slotId);
+    groups$ = this._slotId$.pipe(switchMap((slotId) => {
+        let groups$;
+        if (slotId == null) {
+            groups$ = this.store.pageGroups$;
+        }
+        else {
+            const groupKey = pdfMergePageGroupKeyForSlotId(slotId);
+            groups$ = this.store.pagesForSlotId$(slotId).pipe(map((pages) => (pages.length === 0 ? [] : [{ groupKey, slotId, pages }])));
+        }
+        return groups$;
+    }), shareReplay(1));
+    unexpandable$ = combineLatest([this.store.unexpandableEntries$, this._slotId$]).pipe(map(([entries, slotId]) => (slotId == null ? entries : entries.filter((entry) => entry.slotId === slotId))), shareReplay(1));
+    groupsSignal = toSignal(this.groups$, { initialValue: [] });
+    unexpandableSignal = toSignal(this.unexpandable$, { initialValue: [] });
+    showGroupLabelsSignal = computed(() => {
+        const slotId = this.slotId();
+        return this.showGroupLabels() ?? slotId == null;
+    }, ...(ngDevMode ? [{ debugName: "showGroupLabelsSignal" }] : /* istanbul ignore next */ []));
+    labelForGroup(group) {
+        return this.showGroupLabelsSignal() ? group.slotId : null;
+    }
+    messageForUnexpandable(entry) {
+        return entry.encrypted ? DBX_PDF_MERGE_ENCRYPTED_NOT_EDITABLE_MESSAGE : UNREADABLE_PAGES_MESSAGE;
+    }
+    onDrop(group, event) {
+        this.store.movePageWithinGroup({
+            groupKey: group.groupKey,
+            pageIds: group.pages.map((page) => page.id),
+            previousIndex: event.previousIndex,
+            currentIndex: event.currentIndex
+        });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxPdfMergeListComponent, isStandalone: true, selector: "dbx-pdf-merge-list", host: { classAttribute: "dbx-pdf-merge-list" }, ngImport: i0, template: `
-    @if (entries$ | async; as entries) {
-      @if (entries.length === 0) {
-        <div class="dbx-list-empty-content dbx-hint dbx-p4">No files added yet.</div>
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergePageListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxPdfMergePageListComponent, isStandalone: true, selector: "dbx-pdf-merge-page-list", inputs: { slotId: { classPropertyName: "slotId", publicName: "slotId", isSignal: true, isRequired: false, transformFunction: null }, showGroupLabels: { classPropertyName: "showGroupLabels", publicName: "showGroupLabels", isSignal: true, isRequired: false, transformFunction: null } }, host: { classAttribute: "dbx-pdf-merge-page-list d-block" }, ngImport: i0, template: `
+    @if (groupsSignal(); as groups) {
+      @if (groups.length === 0 && unexpandableSignal().length === 0) {
+        <div class="dbx-list-empty-content dbx-hint dbx-p4">No pages yet.</div>
       } @else {
-        <div class="dbx-pdf-merge-list-items" cdkDropList (cdkDropListDropped)="onDrop($event)">
-          @for (entry of entries; track entry.id) {
-            <dbx-pdf-merge-entry [entry]="entry"></dbx-pdf-merge-entry>
-          }
-        </div>
+        @for (group of groups; track group.groupKey) {
+          <div class="dbx-pdf-merge-page-group">
+            @if (labelForGroup(group); as label) {
+              <div class="dbx-pdf-merge-page-group-label dbx-hint dbx-small">{{ label }}</div>
+            }
+            <div class="dbx-pdf-merge-page-group-items" cdkDropList (cdkDropListDropped)="onDrop(group, $event)">
+              @for (page of group.pages; track page.id) {
+                <dbx-pdf-merge-page [page]="page"></dbx-pdf-merge-page>
+              }
+            </div>
+          </div>
+        }
       }
     }
-  `, isInline: true, dependencies: [{ kind: "directive", type: CdkDropList, selector: "[cdkDropList], cdk-drop-list", inputs: ["cdkDropListConnectedTo", "cdkDropListData", "cdkDropListOrientation", "id", "cdkDropListLockAxis", "cdkDropListDisabled", "cdkDropListSortingDisabled", "cdkDropListEnterPredicate", "cdkDropListSortPredicate", "cdkDropListAutoScrollDisabled", "cdkDropListAutoScrollStep", "cdkDropListElementContainer", "cdkDropListHasAnchor"], outputs: ["cdkDropListDropped", "cdkDropListEntered", "cdkDropListExited", "cdkDropListSorted"], exportAs: ["cdkDropList"] }, { kind: "component", type: DbxPdfMergeEntryComponent, selector: "dbx-pdf-merge-entry", inputs: ["entry"] }, { kind: "pipe", type: AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+    @for (entry of unexpandableSignal(); track entry.id) {
+      <div class="dbx-pdf-merge-page-unexpandable">
+        <mat-icon class="dbx-pdf-merge-page-unexpandable-icon">lock</mat-icon>
+        <span class="dbx-pdf-merge-page-unexpandable-name dbx-text-truncate" [title]="entry.name">{{ entry.name }}</span>
+        <span class="dbx-hint dbx-small">{{ messageForUnexpandable(entry) }}</span>
+      </div>
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: CdkDropList, selector: "[cdkDropList], cdk-drop-list", inputs: ["cdkDropListConnectedTo", "cdkDropListData", "cdkDropListOrientation", "id", "cdkDropListLockAxis", "cdkDropListDisabled", "cdkDropListSortingDisabled", "cdkDropListEnterPredicate", "cdkDropListSortPredicate", "cdkDropListAutoScrollDisabled", "cdkDropListAutoScrollStep", "cdkDropListElementContainer", "cdkDropListHasAnchor"], outputs: ["cdkDropListDropped", "cdkDropListEntered", "cdkDropListExited", "cdkDropListSorted"], exportAs: ["cdkDropList"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i1$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: DbxPdfMergePageComponent, selector: "dbx-pdf-merge-page", inputs: ["page"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeListComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergePageListComponent, decorators: [{
             type: Component,
             args: [{
-                    selector: 'dbx-pdf-merge-list',
+                    selector: 'dbx-pdf-merge-page-list',
                     template: `
-    @if (entries$ | async; as entries) {
-      @if (entries.length === 0) {
-        <div class="dbx-list-empty-content dbx-hint dbx-p4">No files added yet.</div>
+    @if (groupsSignal(); as groups) {
+      @if (groups.length === 0 && unexpandableSignal().length === 0) {
+        <div class="dbx-list-empty-content dbx-hint dbx-p4">No pages yet.</div>
       } @else {
-        <div class="dbx-pdf-merge-list-items" cdkDropList (cdkDropListDropped)="onDrop($event)">
-          @for (entry of entries; track entry.id) {
-            <dbx-pdf-merge-entry [entry]="entry"></dbx-pdf-merge-entry>
-          }
-        </div>
+        @for (group of groups; track group.groupKey) {
+          <div class="dbx-pdf-merge-page-group">
+            @if (labelForGroup(group); as label) {
+              <div class="dbx-pdf-merge-page-group-label dbx-hint dbx-small">{{ label }}</div>
+            }
+            <div class="dbx-pdf-merge-page-group-items" cdkDropList (cdkDropListDropped)="onDrop(group, $event)">
+              @for (page of group.pages; track page.id) {
+                <dbx-pdf-merge-page [page]="page"></dbx-pdf-merge-page>
+              }
+            </div>
+          </div>
+        }
       }
     }
+    @for (entry of unexpandableSignal(); track entry.id) {
+      <div class="dbx-pdf-merge-page-unexpandable">
+        <mat-icon class="dbx-pdf-merge-page-unexpandable-icon">lock</mat-icon>
+        <span class="dbx-pdf-merge-page-unexpandable-name dbx-text-truncate" [title]="entry.name">{{ entry.name }}</span>
+        <span class="dbx-hint dbx-small">{{ messageForUnexpandable(entry) }}</span>
+      </div>
+    }
   `,
                     host: {
-                        class: 'dbx-pdf-merge-list'
+                        class: 'dbx-pdf-merge-page-list d-block'
                     },
-                    imports: [AsyncPipe, CdkDropList, DbxPdfMergeEntryComponent],
+                    imports: [CdkDropList, MatIconModule, DbxPdfMergePageComponent],
                     changeDetection: ChangeDetectionStrategy.OnPush,
                     standalone: true
                 }]
-        }] });
+        }], propDecorators: { slotId: [{ type: i0.Input, args: [{ isSignal: true, alias: "slotId", required: false }] }], showGroupLabels: [{ type: i0.Input, args: [{ isSignal: true, alias: "showGroupLabels", required: false }] }] } });
 
 /**
  * Renders a PDF in a fixed-height embed container. Accepts either a URL or a `Blob` source.
@@ -19007,6 +20270,21 @@ const DEFAULT_DOWNLOAD_BUTTON = {
     display: { icon: 'download', text: 'Download' },
     style: { type: 'stroked' }
 };
+const DEFAULT_CLEAR_CONFIRM = {
+    title: 'Clear all files?',
+    prompt: 'Every file added to this editor will be removed, along with any page edits made to them.',
+    confirmText: 'Clear',
+    cancelText: 'Cancel'
+};
+/**
+ * Shown in place of {@link DEFAULT_CLEAR_CONFIRM} when the editor has a programmatic baseline, since Clear resets to that document rather than emptying.
+ */
+const DEFAULT_RESTORE_CONFIRM = {
+    title: 'Reset to the imported document?',
+    prompt: 'Every change made here — added files, page edits, removed sections — will be discarded and the imported document reloaded as it first arrived.',
+    confirmText: 'Reset',
+    cancelText: 'Cancel'
+};
 class DbxPdfMergeEditorComponent {
     store = inject(DbxPdfMergeEditorStore);
     _matDialog = inject(MatDialog);
@@ -19026,6 +20304,8 @@ class DbxPdfMergeEditorComponent {
     downloadButton = input(...(ngDevMode ? [undefined, { debugName: "downloadButton" }] : /* istanbul ignore next */ []));
     showAddFiles = input(...(ngDevMode ? [undefined, { debugName: "showAddFiles" }] : /* istanbul ignore next */ []));
     showFileList = input(...(ngDevMode ? [undefined, { debugName: "showFileList" }] : /* istanbul ignore next */ []));
+    pageEditing = input(...(ngDevMode ? [undefined, { debugName: "pageEditing" }] : /* istanbul ignore next */ []));
+    sidecar = input(...(ngDevMode ? [undefined, { debugName: "sidecar" }] : /* istanbul ignore next */ []));
     /**
      * Bundles every editor option into one object (see {@link DbxPdfMergeEditorConfig}). Individual inputs override the matching field here, which in turn overrides the workspace-wide {@link DBX_PDF_MERGE_EDITOR_CONFIG} token.
      */
@@ -19039,6 +20319,11 @@ class DbxPdfMergeEditorComponent {
      * Store-level encryption handling default pushed by {@link DbxPdfMergeEditorStoreDirective}. Resolved between the editor's own `config` input and the workspace-wide token in {@link effectiveConfigSignal}.
      */
     storeEncryptedHandlingSignal = toSignal(this.store.encryptedHandling$, { initialValue: undefined });
+    /**
+     * Store-level page-editing and sidecar defaults pushed by {@link DbxPdfMergeEditorStoreDirective}. These read the store's raw (undefaulted) settings so an unset store value still falls through to the workspace-wide token in {@link effectiveConfigSignal}.
+     */
+    storePageEditingSignal = toSignal(this.store.pageEditingSetting$, { initialValue: undefined });
+    storeSidecarSignal = toSignal(this.store.sidecarSetting$, { initialValue: undefined });
     /**
      * Merged config — the editor's own `config` input wins over the store-level default (for `imageCompression`), which in turn wins over the workspace-wide token. The individual inputs are resolved on top of this object in the per-field `*Signal` computeds below.
      */
@@ -19047,6 +20332,8 @@ class DbxPdfMergeEditorComponent {
         const fromToken = this._injectedConfig;
         const storeImageCompression = this.storeImageCompressionSignal();
         const storeEncryptedHandling = this.storeEncryptedHandlingSignal();
+        const storePageEditing = this.storePageEditingSignal();
+        const storeSidecar = this.storeSidecarSignal();
         return {
             imageCompression: fromInput?.imageCompression ?? storeImageCompression ?? fromToken?.imageCompression ?? null,
             outputSizeLimits: fromInput?.outputSizeLimits ?? fromToken?.outputSizeLimits ?? null,
@@ -19058,10 +20345,44 @@ class DbxPdfMergeEditorComponent {
             downloadButton: fromInput?.downloadButton ?? fromToken?.downloadButton,
             showAddFiles: fromInput?.showAddFiles ?? fromToken?.showAddFiles,
             showFileList: fromInput?.showFileList ?? fromToken?.showFileList,
-            encryptedHandling: fromInput?.encryptedHandling ?? storeEncryptedHandling ?? fromToken?.encryptedHandling ?? DEFAULT_DBX_PDF_MERGE_ENCRYPTED_HANDLING
+            encryptedHandling: fromInput?.encryptedHandling ?? storeEncryptedHandling ?? fromToken?.encryptedHandling ?? DEFAULT_DBX_PDF_MERGE_ENCRYPTED_HANDLING,
+            pageEditing: fromInput?.pageEditing ?? storePageEditing ?? fromToken?.pageEditing ?? DEFAULT_DBX_PDF_MERGE_PAGE_EDITING,
+            sidecar: fromInput?.sidecar ?? storeSidecar ?? fromToken?.sidecar ?? DEFAULT_DBX_PDF_MERGE_SIDECAR,
+            clearConfirm: fromInput?.clearConfirm ?? fromToken?.clearConfirm,
+            restoreImportOnClear: fromInput?.restoreImportOnClear ?? fromToken?.restoreImportOnClear ?? DEFAULT_DBX_PDF_MERGE_RESTORE_IMPORT_ON_CLEAR
         };
     }, ...(ngDevMode ? [{ debugName: "effectiveConfigSignal" }] : /* istanbul ignore next */ []));
+    restoreImportOnClearSignal = computed(() => this.effectiveConfigSignal().restoreImportOnClear ?? DEFAULT_DBX_PDF_MERGE_RESTORE_IMPORT_ON_CLEAR, ...(ngDevMode ? [{ debugName: "restoreImportOnClearSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * Whether Clear will reset to a programmatic baseline instead of emptying. Only affects the confirmation's wording — {@link DbxPdfMergeEditorStore.clearEntries} makes the actual decision, and re-reads the store at the moment it runs.
+     */
+    clearRestoresImportSignal = computed(() => {
+        // Tracks the entry count so the wording is re-evaluated as the editor's contents change; the
+        // store's restore point is a plain field rather than a stream (nothing else needs to observe it).
+        this.entryCountSignal();
+        return this.restoreImportOnClearSignal() && this.store.hasRestorableImport();
+    }, ...(ngDevMode ? [{ debugName: "clearRestoresImportSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * Config for the confirmation shown before the footer Clear button empties the editor. `clearConfirm` overrides any field of the default; `autoConfirm: true` restores the pre-confirmation one-click behavior.
+     *
+     * The default copy tells the truth about which of the two things Clear is about to do — reset to the app-supplied document, or remove everything.
+     */
+    clearConfirmSignal = computed(() => {
+        const base = this.clearRestoresImportSignal() ? DEFAULT_RESTORE_CONFIRM : DEFAULT_CLEAR_CONFIRM;
+        return { ...base, ...this.effectiveConfigSignal().clearConfirm };
+    }, ...(ngDevMode ? [{ debugName: "clearConfirmSignal" }] : /* istanbul ignore next */ []));
     encryptedHandlingSignal = computed(() => this.effectiveConfigSignal().encryptedHandling ?? DEFAULT_DBX_PDF_MERGE_ENCRYPTED_HANDLING, ...(ngDevMode ? [{ debugName: "encryptedHandlingSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * Whether page editing is active. When `false` the editor renders its original file list and no page machinery is instantiated at all.
+     */
+    pageEditingSignal = computed(() => {
+        const config = this.effectiveConfigSignal();
+        return this.pageEditing() ?? config.pageEditing ?? DEFAULT_DBX_PDF_MERGE_PAGE_EDITING;
+    }, ...(ngDevMode ? [{ debugName: "pageEditingSignal" }] : /* istanbul ignore next */ []));
+    sidecarSignal = computed(() => {
+        const config = this.effectiveConfigSignal();
+        return this.sidecar() ?? config.sidecar ?? DEFAULT_DBX_PDF_MERGE_SIDECAR;
+    }, ...(ngDevMode ? [{ debugName: "sidecarSignal" }] : /* istanbul ignore next */ []));
     imageCompressionConfigSignal = computed(() => this.effectiveConfigSignal().imageCompression, ...(ngDevMode ? [{ debugName: "imageCompressionConfigSignal" }] : /* istanbul ignore next */ []));
     outputSizeLimitsSignal = computed(() => this.effectiveConfigSignal().outputSizeLimits, ...(ngDevMode ? [{ debugName: "outputSizeLimitsSignal" }] : /* istanbul ignore next */ []));
     // Per-field resolution: dedicated input → config (input/token) → default. The config signal is
@@ -19102,6 +20423,10 @@ class DbxPdfMergeEditorComponent {
     errorBytesSignal = computed(() => this.outputSizeLimitsSignal()?.errorBytes, ...(ngDevMode ? [{ debugName: "errorBytesSignal" }] : /* istanbul ignore next */ []));
     hasReadyEntriesSignal = toSignal(this.store.hasReadyEntries$, { initialValue: false });
     entryCountSignal = toSignal(this.store.entryCount$, { initialValue: 0 });
+    /**
+     * Number of pages that will actually reach the output — the page plan minus anything marked for removal. Only surfaced while page editing is enabled.
+     */
+    mergeablePageCountSignal = toSignal(this.store.mergeablePageCount$, { initialValue: 0 });
     /**
      * Mirrors {@link DbxPdfMergeEditorStore.focusActive$} — `true` while `encryptedHandling === 'focus'` and at least one ready encrypted entry exists. Drives the encrypted-PDF focus banner.
      */
@@ -19171,6 +20496,14 @@ class DbxPdfMergeEditorComponent {
             const handling = this.encryptedHandlingSignal();
             this.store.setEncryptedHandling(handling);
         });
+        effect(() => {
+            const pageEditing = this.pageEditingSignal();
+            this.store.setPageEditing(pageEditing);
+        });
+        effect(() => {
+            const sidecar = this.sidecarSignal();
+            this.store.setSidecar(sidecar);
+        });
     }
     async onFiles(event) {
         const accepted = event.matchResult.accepted;
@@ -19184,9 +20517,20 @@ class DbxPdfMergeEditorComponent {
             this.store.addFiles({ entries: filtered });
         }
     }
+    /**
+     * Clears the editor, resetting to a programmatic baseline when there is one. See {@link DbxPdfMergeEditorStore.clearEntries}.
+     *
+     * @returns The clear outcome, so a programmatic caller can tell a reset from an empty.
+     */
     onClear() {
-        this.store.clearAll();
+        return this.store.clearEntries({ restoreImport: this.restoreImportOnClearSignal() });
     }
+    /**
+     * Runs as the handler of the footer Clear button's own `dbxAction`, so the `dbxActionConfirm` on that action is what stands between a misclick and the whole entry list. Delegates to {@link onClear} so a programmatic clear and the button share one path.
+     *
+     * @returns An observable the action completes on — a restore re-parses the document, so this is not instantaneous.
+     */
+    handleClear = () => from(this.onClear()).pipe(map(() => undefined));
     onPreview() {
         if (!this.canMergeSignal()) {
             return;
@@ -19213,18 +20557,20 @@ class DbxPdfMergeEditorComponent {
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxPdfMergeEditorComponent, isStandalone: true, selector: "dbx-pdf-merge-editor", inputs: { accept: { classPropertyName: "accept", publicName: "accept", isSignal: true, isRequired: false, transformFunction: null }, multiple: { classPropertyName: "multiple", publicName: "multiple", isSignal: true, isRequired: false, transformFunction: null }, fileName: { classPropertyName: "fileName", publicName: "fileName", isSignal: true, isRequired: false, transformFunction: null }, showDownloadButton: { classPropertyName: "showDownloadButton", publicName: "showDownloadButton", isSignal: true, isRequired: false, transformFunction: null }, showPreviewButton: { classPropertyName: "showPreviewButton", publicName: "showPreviewButton", isSignal: true, isRequired: false, transformFunction: null }, downloadButton: { classPropertyName: "downloadButton", publicName: "downloadButton", isSignal: true, isRequired: false, transformFunction: null }, showAddFiles: { classPropertyName: "showAddFiles", publicName: "showAddFiles", isSignal: true, isRequired: false, transformFunction: null }, showFileList: { classPropertyName: "showFileList", publicName: "showFileList", isSignal: true, isRequired: false, transformFunction: null }, config: { classPropertyName: "config", publicName: "config", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { entriesChanged: "entriesChanged" }, host: { classAttribute: "dbx-pdf-merge-editor d-block" }, ngImport: i0, template: "@if (showAddFilesSignal()) {\n  <div class=\"dbx-pdf-merge-editor-upload d-block dbx-mb3\">\n    <dbx-file-upload [accept]=\"acceptSignal()\" [multiple]=\"multipleSignal()\" (filesChanged)=\"onFiles($event)\" [hint]=\"'Drop PDFs or images here, or click to browse'\" [text]=\"'Add files'\" icon=\"upload_file\"></dbx-file-upload>\n  </div>\n}\n<ng-content></ng-content>\n@if (showFileListSignal()) {\n  <dbx-pdf-merge-list></dbx-pdf-merge-list>\n}\n@if (focusActiveSignal()) {\n  <div class=\"dbx-pdf-merge-editor-encrypted-banner\">\n    <mat-icon>lock</mat-icon>\n    <span>Encrypted PDF detected \u2014 only the encrypted file will be used; other files are ignored.</span>\n  </div>\n}\n@switch (outputSizeStateSignal()) {\n  @case ('warn') {\n    <div class=\"dbx-pdf-merge-editor-size-warning\">\n      <mat-icon>warning</mat-icon>\n      <span>Merged file is {{ formattedOutputSizeSignal() }} \u2014 above the recommended {{ formattedWarnLimitSignal() }} limit.</span>\n    </div>\n  }\n  @case ('error') {\n    <div class=\"dbx-pdf-merge-editor-size-error\">\n      <mat-icon>error</mat-icon>\n      <span>Merged file is {{ formattedOutputSizeSignal() }}, exceeds the {{ formattedErrorLimitSignal() }} limit. Remove or compress files to continue.</span>\n    </div>\n  }\n}\n<div class=\"dbx-pdf-merge-editor-actions\">\n  <span class=\"dbx-hint dbx-small\">{{ entryCountSignal() }} file(s)</span>\n  <span class=\"dbx-spacer\"></span>\n  <dbx-button text=\"Clear\" icon=\"delete\" [disabled]=\"entryCountSignal() === 0\" (buttonClick)=\"onClear()\"></dbx-button>\n  @if (showPreviewButtonSignal()) {\n    <dbx-button text=\"Preview\" icon=\"picture_as_pdf\" [disabled]=\"!canMergeSignal()\" (buttonClick)=\"onPreview()\"></dbx-button>\n  }\n  @if (showDownloadButtonSignal() && canMergeSignal()) {\n    <dbx-download-blob-button [config]=\"downloadConfigSignal()\"></dbx-download-blob-button>\n  }\n</div>\n", dependencies: [{ kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i1$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: DbxButtonComponent, selector: "dbx-button", inputs: ["bar", "type", "buttonStyle", "color", "spinnerColor", "customButtonColor", "customTextColor", "customSpinnerColor", "basic", "tonal", "raised", "stroked", "flat", "iconOnly", "fab", "customContent", "allowClickPropagation", "mode"] }, { kind: "component", type: DbxFileUploadComponent, selector: "dbx-file-upload", inputs: ["config", "buttonStyle", "buttonDisplay", "mode", "text", "icon", "hint", "clickAreaToUpload"], outputs: ["filesChanged"] }, { kind: "component", type: DbxDownloadBlobButtonComponent, selector: "dbx-download-blob-button", inputs: ["config"] }, { kind: "component", type: DbxPdfMergeListComponent, selector: "dbx-pdf-merge-list" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxPdfMergeEditorComponent, isStandalone: true, selector: "dbx-pdf-merge-editor", inputs: { accept: { classPropertyName: "accept", publicName: "accept", isSignal: true, isRequired: false, transformFunction: null }, multiple: { classPropertyName: "multiple", publicName: "multiple", isSignal: true, isRequired: false, transformFunction: null }, fileName: { classPropertyName: "fileName", publicName: "fileName", isSignal: true, isRequired: false, transformFunction: null }, showDownloadButton: { classPropertyName: "showDownloadButton", publicName: "showDownloadButton", isSignal: true, isRequired: false, transformFunction: null }, showPreviewButton: { classPropertyName: "showPreviewButton", publicName: "showPreviewButton", isSignal: true, isRequired: false, transformFunction: null }, downloadButton: { classPropertyName: "downloadButton", publicName: "downloadButton", isSignal: true, isRequired: false, transformFunction: null }, showAddFiles: { classPropertyName: "showAddFiles", publicName: "showAddFiles", isSignal: true, isRequired: false, transformFunction: null }, showFileList: { classPropertyName: "showFileList", publicName: "showFileList", isSignal: true, isRequired: false, transformFunction: null }, pageEditing: { classPropertyName: "pageEditing", publicName: "pageEditing", isSignal: true, isRequired: false, transformFunction: null }, sidecar: { classPropertyName: "sidecar", publicName: "sidecar", isSignal: true, isRequired: false, transformFunction: null }, config: { classPropertyName: "config", publicName: "config", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { entriesChanged: "entriesChanged" }, host: { classAttribute: "dbx-pdf-merge-editor d-block" }, ngImport: i0, template: "@if (showAddFilesSignal()) {\n  <div class=\"dbx-pdf-merge-editor-upload d-block dbx-mb3\">\n    <dbx-file-upload [accept]=\"acceptSignal()\" [multiple]=\"multipleSignal()\" (filesChanged)=\"onFiles($event)\" [hint]=\"'Drop PDFs or images here, or click to browse'\" [text]=\"'Add files'\" icon=\"upload_file\"></dbx-file-upload>\n  </div>\n}\n<ng-content></ng-content>\n@if (showFileListSignal()) {\n  @if (pageEditingSignal()) {\n    <dbx-pdf-merge-page-list></dbx-pdf-merge-page-list>\n  } @else {\n    <dbx-pdf-merge-list></dbx-pdf-merge-list>\n  }\n}\n@if (focusActiveSignal()) {\n  <div class=\"dbx-pdf-merge-editor-encrypted-banner\">\n    <mat-icon>lock</mat-icon>\n    <span>Encrypted PDF detected \u2014 only the encrypted file will be used; other files are ignored.</span>\n  </div>\n}\n@switch (outputSizeStateSignal()) {\n  @case ('warn') {\n    <div class=\"dbx-pdf-merge-editor-size-warning\">\n      <mat-icon>warning</mat-icon>\n      <span>Merged file is {{ formattedOutputSizeSignal() }} \u2014 above the recommended {{ formattedWarnLimitSignal() }} limit.</span>\n    </div>\n  }\n  @case ('error') {\n    <div class=\"dbx-pdf-merge-editor-size-error\">\n      <mat-icon>error</mat-icon>\n      <span>Merged file is {{ formattedOutputSizeSignal() }}, exceeds the {{ formattedErrorLimitSignal() }} limit. Remove or compress files to continue.</span>\n    </div>\n  }\n}\n<div class=\"dbx-pdf-merge-editor-actions\">\n  <span class=\"dbx-hint dbx-small\">{{ entryCountSignal() }} file(s)</span>\n  @if (pageEditingSignal()) {\n    <span class=\"dbx-hint dbx-small\">{{ mergeablePageCountSignal() }} page(s)</span>\n  }\n  <span class=\"dbx-spacer\"></span>\n  <!-- Emptiness gates the button through the action's own disabled channel: dbxActionButton pushes\n       `isDisabled$` into the button, which would otherwise win over a plain [disabled] input. -->\n  <div dbxAction dbxActionSnackbarError [dbxActionDisabled]=\"entryCountSignal() === 0\" [dbxActionHandler]=\"handleClear\" [dbxActionConfirm]=\"clearConfirmSignal()\">\n    <dbx-button dbxActionButton text=\"Clear\" icon=\"delete\"></dbx-button>\n  </div>\n  @if (showPreviewButtonSignal()) {\n    <dbx-button text=\"Preview\" icon=\"picture_as_pdf\" [disabled]=\"!canMergeSignal()\" (buttonClick)=\"onPreview()\"></dbx-button>\n  }\n  @if (showDownloadButtonSignal() && canMergeSignal()) {\n    <dbx-download-blob-button [config]=\"downloadConfigSignal()\"></dbx-download-blob-button>\n  }\n</div>\n", dependencies: [{ kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i1$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: DbxButtonComponent, selector: "dbx-button", inputs: ["bar", "type", "buttonStyle", "color", "spinnerColor", "customButtonColor", "customTextColor", "customSpinnerColor", "basic", "tonal", "raised", "stroked", "flat", "iconOnly", "fab", "customContent", "allowClickPropagation", "mode"] }, { kind: "component", type: DbxFileUploadComponent, selector: "dbx-file-upload", inputs: ["config", "buttonStyle", "buttonDisplay", "mode", "text", "icon", "hint", "clickAreaToUpload"], outputs: ["filesChanged"] }, { kind: "component", type: DbxDownloadBlobButtonComponent, selector: "dbx-download-blob-button", inputs: ["config"] }, { kind: "directive", type: DbxActionDirective, selector: "dbx-action,[dbxAction]", exportAs: ["action", "dbxAction"] }, { kind: "directive", type: DbxActionButtonDirective, selector: "[dbxActionButton]", inputs: ["dbxActionButtonEcho"] }, { kind: "directive", type: DbxActionDisabledDirective, selector: "[dbxActionDisabled]", inputs: ["dbxActionDisabled"] }, { kind: "directive", type: DbxActionHandlerDirective, selector: "[dbxActionHandler]", inputs: ["dbxActionHandler"] }, { kind: "directive", type: DbxActionConfirmDirective, selector: "[dbxActionConfirm]", inputs: ["dbxActionConfirm", "dbxActionConfirmSkip"] }, { kind: "directive", type: DbxActionSnackbarErrorDirective, selector: "[dbxActionSnackbarError]", inputs: ["dbxActionSnackbarError"] }, { kind: "component", type: DbxPdfMergeListComponent, selector: "dbx-pdf-merge-list" }, { kind: "component", type: DbxPdfMergePageListComponent, selector: "dbx-pdf-merge-page-list", inputs: ["slotId", "showGroupLabels"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeEditorComponent, decorators: [{
             type: Component,
             args: [{ selector: 'dbx-pdf-merge-editor', host: {
                         class: 'dbx-pdf-merge-editor d-block'
-                    }, imports: [MatIconModule, DbxButtonComponent, DbxFileUploadComponent, DbxDownloadBlobButtonComponent, DbxPdfMergeListComponent], changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, template: "@if (showAddFilesSignal()) {\n  <div class=\"dbx-pdf-merge-editor-upload d-block dbx-mb3\">\n    <dbx-file-upload [accept]=\"acceptSignal()\" [multiple]=\"multipleSignal()\" (filesChanged)=\"onFiles($event)\" [hint]=\"'Drop PDFs or images here, or click to browse'\" [text]=\"'Add files'\" icon=\"upload_file\"></dbx-file-upload>\n  </div>\n}\n<ng-content></ng-content>\n@if (showFileListSignal()) {\n  <dbx-pdf-merge-list></dbx-pdf-merge-list>\n}\n@if (focusActiveSignal()) {\n  <div class=\"dbx-pdf-merge-editor-encrypted-banner\">\n    <mat-icon>lock</mat-icon>\n    <span>Encrypted PDF detected \u2014 only the encrypted file will be used; other files are ignored.</span>\n  </div>\n}\n@switch (outputSizeStateSignal()) {\n  @case ('warn') {\n    <div class=\"dbx-pdf-merge-editor-size-warning\">\n      <mat-icon>warning</mat-icon>\n      <span>Merged file is {{ formattedOutputSizeSignal() }} \u2014 above the recommended {{ formattedWarnLimitSignal() }} limit.</span>\n    </div>\n  }\n  @case ('error') {\n    <div class=\"dbx-pdf-merge-editor-size-error\">\n      <mat-icon>error</mat-icon>\n      <span>Merged file is {{ formattedOutputSizeSignal() }}, exceeds the {{ formattedErrorLimitSignal() }} limit. Remove or compress files to continue.</span>\n    </div>\n  }\n}\n<div class=\"dbx-pdf-merge-editor-actions\">\n  <span class=\"dbx-hint dbx-small\">{{ entryCountSignal() }} file(s)</span>\n  <span class=\"dbx-spacer\"></span>\n  <dbx-button text=\"Clear\" icon=\"delete\" [disabled]=\"entryCountSignal() === 0\" (buttonClick)=\"onClear()\"></dbx-button>\n  @if (showPreviewButtonSignal()) {\n    <dbx-button text=\"Preview\" icon=\"picture_as_pdf\" [disabled]=\"!canMergeSignal()\" (buttonClick)=\"onPreview()\"></dbx-button>\n  }\n  @if (showDownloadButtonSignal() && canMergeSignal()) {\n    <dbx-download-blob-button [config]=\"downloadConfigSignal()\"></dbx-download-blob-button>\n  }\n</div>\n" }]
-        }], ctorParameters: () => [], propDecorators: { accept: [{ type: i0.Input, args: [{ isSignal: true, alias: "accept", required: false }] }], multiple: [{ type: i0.Input, args: [{ isSignal: true, alias: "multiple", required: false }] }], fileName: [{ type: i0.Input, args: [{ isSignal: true, alias: "fileName", required: false }] }], showDownloadButton: [{ type: i0.Input, args: [{ isSignal: true, alias: "showDownloadButton", required: false }] }], showPreviewButton: [{ type: i0.Input, args: [{ isSignal: true, alias: "showPreviewButton", required: false }] }], downloadButton: [{ type: i0.Input, args: [{ isSignal: true, alias: "downloadButton", required: false }] }], showAddFiles: [{ type: i0.Input, args: [{ isSignal: true, alias: "showAddFiles", required: false }] }], showFileList: [{ type: i0.Input, args: [{ isSignal: true, alias: "showFileList", required: false }] }], config: [{ type: i0.Input, args: [{ isSignal: true, alias: "config", required: false }] }], entriesChanged: [{ type: i0.Output, args: ["entriesChanged"] }] } });
+                    }, imports: [MatIconModule, DbxButtonComponent, DbxFileUploadComponent, DbxDownloadBlobButtonComponent, DbxActionDirective, DbxActionButtonDirective, DbxActionDisabledDirective, DbxActionHandlerDirective, DbxActionConfirmDirective, DbxActionSnackbarErrorDirective, DbxPdfMergeListComponent, DbxPdfMergePageListComponent], changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, template: "@if (showAddFilesSignal()) {\n  <div class=\"dbx-pdf-merge-editor-upload d-block dbx-mb3\">\n    <dbx-file-upload [accept]=\"acceptSignal()\" [multiple]=\"multipleSignal()\" (filesChanged)=\"onFiles($event)\" [hint]=\"'Drop PDFs or images here, or click to browse'\" [text]=\"'Add files'\" icon=\"upload_file\"></dbx-file-upload>\n  </div>\n}\n<ng-content></ng-content>\n@if (showFileListSignal()) {\n  @if (pageEditingSignal()) {\n    <dbx-pdf-merge-page-list></dbx-pdf-merge-page-list>\n  } @else {\n    <dbx-pdf-merge-list></dbx-pdf-merge-list>\n  }\n}\n@if (focusActiveSignal()) {\n  <div class=\"dbx-pdf-merge-editor-encrypted-banner\">\n    <mat-icon>lock</mat-icon>\n    <span>Encrypted PDF detected \u2014 only the encrypted file will be used; other files are ignored.</span>\n  </div>\n}\n@switch (outputSizeStateSignal()) {\n  @case ('warn') {\n    <div class=\"dbx-pdf-merge-editor-size-warning\">\n      <mat-icon>warning</mat-icon>\n      <span>Merged file is {{ formattedOutputSizeSignal() }} \u2014 above the recommended {{ formattedWarnLimitSignal() }} limit.</span>\n    </div>\n  }\n  @case ('error') {\n    <div class=\"dbx-pdf-merge-editor-size-error\">\n      <mat-icon>error</mat-icon>\n      <span>Merged file is {{ formattedOutputSizeSignal() }}, exceeds the {{ formattedErrorLimitSignal() }} limit. Remove or compress files to continue.</span>\n    </div>\n  }\n}\n<div class=\"dbx-pdf-merge-editor-actions\">\n  <span class=\"dbx-hint dbx-small\">{{ entryCountSignal() }} file(s)</span>\n  @if (pageEditingSignal()) {\n    <span class=\"dbx-hint dbx-small\">{{ mergeablePageCountSignal() }} page(s)</span>\n  }\n  <span class=\"dbx-spacer\"></span>\n  <!-- Emptiness gates the button through the action's own disabled channel: dbxActionButton pushes\n       `isDisabled$` into the button, which would otherwise win over a plain [disabled] input. -->\n  <div dbxAction dbxActionSnackbarError [dbxActionDisabled]=\"entryCountSignal() === 0\" [dbxActionHandler]=\"handleClear\" [dbxActionConfirm]=\"clearConfirmSignal()\">\n    <dbx-button dbxActionButton text=\"Clear\" icon=\"delete\"></dbx-button>\n  </div>\n  @if (showPreviewButtonSignal()) {\n    <dbx-button text=\"Preview\" icon=\"picture_as_pdf\" [disabled]=\"!canMergeSignal()\" (buttonClick)=\"onPreview()\"></dbx-button>\n  }\n  @if (showDownloadButtonSignal() && canMergeSignal()) {\n    <dbx-download-blob-button [config]=\"downloadConfigSignal()\"></dbx-download-blob-button>\n  }\n</div>\n" }]
+        }], ctorParameters: () => [], propDecorators: { accept: [{ type: i0.Input, args: [{ isSignal: true, alias: "accept", required: false }] }], multiple: [{ type: i0.Input, args: [{ isSignal: true, alias: "multiple", required: false }] }], fileName: [{ type: i0.Input, args: [{ isSignal: true, alias: "fileName", required: false }] }], showDownloadButton: [{ type: i0.Input, args: [{ isSignal: true, alias: "showDownloadButton", required: false }] }], showPreviewButton: [{ type: i0.Input, args: [{ isSignal: true, alias: "showPreviewButton", required: false }] }], downloadButton: [{ type: i0.Input, args: [{ isSignal: true, alias: "downloadButton", required: false }] }], showAddFiles: [{ type: i0.Input, args: [{ isSignal: true, alias: "showAddFiles", required: false }] }], showFileList: [{ type: i0.Input, args: [{ isSignal: true, alias: "showFileList", required: false }] }], pageEditing: [{ type: i0.Input, args: [{ isSignal: true, alias: "pageEditing", required: false }] }], sidecar: [{ type: i0.Input, args: [{ isSignal: true, alias: "sidecar", required: false }] }], config: [{ type: i0.Input, args: [{ isSignal: true, alias: "config", required: false }] }], entriesChanged: [{ type: i0.Output, args: ["entriesChanged"] }] } });
 
 /**
  * Directive that registers as the active {@link DbxPdfMergeEditorValidator} on a {@link DbxPdfMergeEditorStore} and gates merge emissions on the readiness of every registered slot. {@link DbxPdfMergeEditorFileUploadComponent} instances walk the injector tree, find this directive, and call {@link registerSlot}/{@link unregisterSlot} during their own lifecycle.
  *
+ * This slot set is intentionally separate from {@link DbxPdfMergeEditorStore.registeredSlotIds$}, and the two should not be merged. This one is keyed by object identity because it exists solely to `combineLatest` each slot's `isValid$`; the store's is keyed by slot id, answers "which sections does this editor declare", and must be populated whether or not a validator is present — which is why it cannot live on this optional directive.
+ *
  * @example
  * ```html
  * <dbx-pdf-merge-editor [showAddFiles]="false" [showFileList]="false">
@@ -19293,11 +20639,19 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
 
 const DEFAULT_MIN_FILES = 1;
 const DEFAULT_REQUIRED = true;
+const DEFAULT_ADD_BUTTON_TEXT = 'Add';
+const DEFAULT_CLEAR_BUTTON_TEXT = 'Clear';
+const DEFAULT_CLEAR_CONFIRM_TITLE = 'Clear this section?';
+const DEFAULT_CLEAR_CONFIRM_PROMPT = 'Every file in this section will be removed, along with any page edits made to them.';
+const DEFAULT_CLEAR_CONFIRM_CONFIRM_TEXT = 'Clear';
+const DEFAULT_CLEAR_CONFIRM_CANCEL_TEXT = 'Cancel';
 /**
  * Slot-scoped uploader for use inside a {@link DbxPdfMergeEditorComponent}. Adds files to the shared {@link DbxPdfMergeEditorStore} tagged with this slot's `slotId`, displays the slot's owned entries inline using {@link DbxPdfMergeEntryComponent}, and reports its readiness to the optional ancestor {@link DbxPdfMergeEditorFileUploadValidatorDirective}. On destroy the slot removes its owned entries from the store.
  *
  * Projects an `<ng-content>` slot inside its header element so consumers can render state-aware indicators (e.g. via the `dbxPdfMergeEditorFileUploadHasState` structural directive) alongside the optional `label`.
  *
+ * Once the slot owns entries its header gains an Add button (while the slot is under capacity) and a Clear button, so a section that already has content can still be extended, emptied, or replaced. Clearing runs as its own `dbxAction` behind a `dbxActionConfirm` prompt — a misclick costs a dialog, not the section's files.
+ *
  * @example
  * ```html
  * <dbx-pdf-merge-editor-file-upload slotId="license" [config]="{ label: 'Driver’s License', accept: ['application/pdf'] }">
@@ -19310,6 +20664,10 @@ class DbxPdfMergeEditorFileUploadComponent {
     _validator = inject(DbxPdfMergeEditorFileUploadValidatorDirective, { optional: true });
     _injectedConfig = inject(DBX_PDF_MERGE_EDITOR_CONFIG, { optional: true });
     _preserveEntriesOnDestroy = inject(DBX_PDF_MERGE_EDITOR_PRESERVE_ENTRIES_ON_SLOT_DESTROY, { optional: true }) ?? false;
+    /**
+     * The slot id this component registered with the store, captured at registration time so destroy deregisters the same key. `null` before {@link ngOnInit} and after teardown.
+     */
+    _registeredSlotId = null;
     slotId = input.required(...(ngDevMode ? [{ debugName: "slotId" }] : /* istanbul ignore next */ []));
     config = input(...(ngDevMode ? [undefined, { debugName: "config" }] : /* istanbul ignore next */ []));
     acceptSignal = computed(() => this.config()?.accept ?? DEFAULT_PDF_MERGE_ACCEPT, ...(ngDevMode ? [{ debugName: "acceptSignal" }] : /* istanbul ignore next */ []));
@@ -19346,13 +20704,78 @@ class DbxPdfMergeEditorFileUploadComponent {
     ownedEntries$ = toObservable(this.slotId).pipe(switchMap((slotId) => this.store.entriesForSlotId$(slotId)), shareReplay(1));
     ownedEntriesSignal = toSignal(this.ownedEntries$, { initialValue: [] });
     /**
-     * Whether the slot still has room for more files. Drives visibility of the upload UI — once the slot is at capacity, the uploader is hidden and the user must remove an existing entry to add another.
+     * Whether the shared store has page editing enabled. Drives whether this slot lists its own pages or its own files.
+     */
+    pageEditingSignal = toSignal(this.store.pageEditing$, { initialValue: false });
+    /**
+     * Pages contributed by this slot's entries. Empty while page editing is disabled.
+     */
+    ownedPages$ = toObservable(this.slotId).pipe(switchMap((slotId) => this.store.pagesForSlotId$(slotId)), shareReplay(1));
+    /**
+     * Whether the slot still has room for more files. Gates every add affordance — once the slot is at capacity neither the drop area nor the header Add button is offered, and the user must clear the slot (or remove an entry) to add another.
      */
     canAddFilesSignal = computed(() => this.ownedEntriesSignal().length < this.capacitySignal(), ...(ngDevMode ? [{ debugName: "canAddFilesSignal" }] : /* istanbul ignore next */ []));
+    showAddButtonConfigSignal = computed(() => this.config()?.showAddButton ?? true, ...(ngDevMode ? [{ debugName: "showAddButtonConfigSignal" }] : /* istanbul ignore next */ []));
+    showClearButtonConfigSignal = computed(() => this.config()?.showClearButton ?? true, ...(ngDevMode ? [{ debugName: "showClearButtonConfigSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * Whether the compact header Add button is rendered. Only meaningful once the slot owns something — while it is empty the drop area is already the add affordance.
+     */
+    showAddButtonSignal = computed(() => {
+        const ownedEntries = this.ownedEntriesSignal();
+        const canAddFiles = this.canAddFilesSignal();
+        return this.showAddButtonConfigSignal() && ownedEntries.length > 0 && canAddFiles;
+    }, ...(ngDevMode ? [{ debugName: "showAddButtonSignal" }] : /* istanbul ignore next */ []));
+    showClearButtonSignal = computed(() => {
+        const ownedEntries = this.ownedEntriesSignal();
+        return this.showClearButtonConfigSignal() && ownedEntries.length > 0;
+    }, ...(ngDevMode ? [{ debugName: "showClearButtonSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * Whether the full drop area is rendered. It is the slot's empty state while the header Add button is enabled; with the button turned off it falls back to staying visible until the slot reaches capacity.
+     */
+    showUploadAreaSignal = computed(() => {
+        const showAddButtonConfig = this.showAddButtonConfigSignal();
+        const canAddFiles = this.canAddFilesSignal();
+        const isEmpty = this.ownedEntriesSignal().length === 0;
+        return canAddFiles && (isEmpty || !showAddButtonConfig);
+    }, ...(ngDevMode ? [{ debugName: "showUploadAreaSignal" }] : /* istanbul ignore next */ []));
+    addButtonTextSignal = computed(() => this.config()?.addButtonText ?? DEFAULT_ADD_BUTTON_TEXT, ...(ngDevMode ? [{ debugName: "addButtonTextSignal" }] : /* istanbul ignore next */ []));
+    clearButtonTextSignal = computed(() => this.config()?.clearButtonText ?? DEFAULT_CLEAR_BUTTON_TEXT, ...(ngDevMode ? [{ debugName: "clearButtonTextSignal" }] : /* istanbul ignore next */ []));
+    addButtonAriaLabelSignal = computed(() => {
+        const label = this.labelSignal();
+        return label ? `Add files to ${label}` : 'Add files to this section';
+    }, ...(ngDevMode ? [{ debugName: "addButtonAriaLabelSignal" }] : /* istanbul ignore next */ []));
+    clearButtonAriaLabelSignal = computed(() => {
+        const label = this.labelSignal();
+        return label ? `Clear ${label}` : 'Clear this section';
+    }, ...(ngDevMode ? [{ debugName: "clearButtonAriaLabelSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * Config for the confirmation shown before the slot is cleared. The slot's `label` is folded into the default title so a page of sections says which one is about to be emptied; `clearConfirm` overrides any field of it.
+     */
+    clearConfirmSignal = computed(() => {
+        const label = this.labelSignal();
+        const overrides = this.config()?.clearConfirm;
+        return {
+            title: label ? `Clear ${label}?` : DEFAULT_CLEAR_CONFIRM_TITLE,
+            prompt: DEFAULT_CLEAR_CONFIRM_PROMPT,
+            confirmText: DEFAULT_CLEAR_CONFIRM_CONFIRM_TEXT,
+            cancelText: DEFAULT_CLEAR_CONFIRM_CANCEL_TEXT,
+            ...overrides
+        };
+    }, ...(ngDevMode ? [{ debugName: "clearConfirmSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * Clears every entry this slot owns. Runs as the handler of the header's own `dbxAction`, so the `dbxActionConfirm` on that action is what stands between a misclick and the section's files.
+     *
+     * @param _value - Unused. The confirmation supplies no value, only the go-ahead.
+     * @param context - Work context completed as soon as the store drops the entries.
+     */
+    handleClear = (_value, context) => {
+        this.store.removeEntriesBySlotId(this.slotId());
+        context.success();
+    };
     /**
      * High-level state of the slot — `no_file` when empty, `valid` when owned entries satisfy the slot's thresholds, `invalid` when owned entries fail or are still being validated.
      */
-    state$ = this.ownedEntries$.pipe(map((entries) => {
+    state$ = combineLatest([this.ownedEntries$, this.store.pageEditing$, this.ownedPages$]).pipe(map(([entries, pageEditing, pages]) => {
         let state;
         if (entries.length === 0) {
             state = 'no_file';
@@ -19362,6 +20785,10 @@ class DbxPdfMergeEditorFileUploadComponent {
             const readyCount = entries.filter((entry) => entry.status === 'ready').length;
             const minFiles = this.minFilesSignal();
             const maxFiles = this.maxFilesSignal();
+            // Only meaningful once the slot actually has pages: an empty list means editing is off, the
+            // entry is still hydrating, or it could not be expanded (encrypted) — none of which are the
+            // user deleting their own content.
+            const allPagesRemoved = pageEditing && pages.length > 0 && pages.every((page) => page.removed);
             if (validating) {
                 state = 'invalid';
             }
@@ -19371,6 +20798,9 @@ class DbxPdfMergeEditorFileUploadComponent {
             else if (maxFiles != null && readyCount > maxFiles) {
                 state = 'invalid';
             }
+            else if (allPagesRemoved) {
+                state = 'invalid';
+            }
             else {
                 state = 'valid';
             }
@@ -19397,9 +20827,26 @@ class DbxPdfMergeEditorFileUploadComponent {
     }), distinctUntilChanged(), shareReplay(1));
     isValidSignal = toSignal(this.isValid$, { initialValue: false });
     ngOnInit() {
+        // Two registrations, deliberately: the store learns this slot's ID (so consumers like
+        // <dbx-pdf-merge-import> can enumerate the sections this editor declares), while the optional
+        // validator directive tracks the component itself to aggregate `isValid$`. They are separate
+        // because the store is always present while the validator is not, and because the store's
+        // `setValidator` seam exists precisely so it never has to hold slot component references.
+        this._registeredSlotId = this.slotId();
+        this.store.registerSlotId(this._registeredSlotId);
         this._validator?.registerSlot(this);
     }
     ngOnDestroy() {
+        // Unconditional, and deliberately OUTSIDE the `_preserveEntriesOnDestroy` check below: that
+        // token governs whether the slot's ENTRIES survive, not whether the slot is mounted. The
+        // upload dialog sets it to `true` and is torn down on every close, so gating this on it would
+        // leave the store permanently claiming a section that is no longer on screen. The captured id
+        // (rather than a fresh `slotId()` read) guarantees this decrements the same key `ngOnInit`
+        // incremented, and clearing it keeps a repeat destroy from evicting a still-mounted duplicate.
+        if (this._registeredSlotId != null) {
+            this.store.unregisterSlotId(this._registeredSlotId);
+            this._registeredSlotId = null;
+        }
         this._validator?.unregisterSlot(this);
         // Default behavior: removing a slot from a template (e.g. via `@if`) also drops the slot's
         // entries from the store. Opt out by providing `DBX_PDF_MERGE_EDITOR_PRESERVE_ENTRIES_ON_SLOT_DESTROY`
@@ -19460,20 +20907,36 @@ class DbxPdfMergeEditorFileUploadComponent {
         <span class="dbx-pdf-merge-editor-file-upload-label">{{ label }}</span>
       }
       <ng-content></ng-content>
+      @if (showAddButtonSignal() || showClearButtonSignal()) {
+        <div class="dbx-pdf-merge-editor-file-upload-actions">
+          @if (showAddButtonSignal()) {
+            <dbx-file-upload-button [accept]="acceptSignal()" [multiple]="multipleSignal()" [text]="addButtonTextSignal()" icon="add" [ariaLabel]="addButtonAriaLabelSignal()" (filesChanged)="onFiles($event)"></dbx-file-upload-button>
+          }
+          @if (showClearButtonSignal()) {
+            <div dbxAction dbxActionSnackbarError [dbxActionHandler]="handleClear" [dbxActionConfirm]="clearConfirmSignal()">
+              <dbx-button dbxActionButton [text]="clearButtonTextSignal()" icon="delete" [ariaLabel]="clearButtonAriaLabelSignal()"></dbx-button>
+            </div>
+          }
+        </div>
+      }
     </div>
-    @if (canAddFilesSignal()) {
+    @if (showUploadAreaSignal()) {
       <dbx-file-upload [accept]="acceptSignal()" [multiple]="multipleSignal()" [mode]="modeSignal()" [hint]="hintSignal()" [text]="textSignal()" [icon]="iconSignal()" (filesChanged)="onFiles($event)"></dbx-file-upload>
     }
     @if (ownedEntriesSignal(); as owned) {
       @if (owned.length > 0) {
-        <div class="dbx-pdf-merge-editor-file-upload-entries" cdkDropList (cdkDropListDropped)="onDrop($event)">
-          @for (entry of owned; track entry.id) {
-            <dbx-pdf-merge-entry [entry]="entry"></dbx-pdf-merge-entry>
-          }
-        </div>
+        @if (pageEditingSignal()) {
+          <dbx-pdf-merge-page-list class="dbx-pdf-merge-editor-file-upload-pages" [slotId]="slotId()"></dbx-pdf-merge-page-list>
+        } @else {
+          <div class="dbx-pdf-merge-editor-file-upload-entries" cdkDropList (cdkDropListDropped)="onDrop($event)">
+            @for (entry of owned; track entry.id) {
+              <dbx-pdf-merge-entry [entry]="entry"></dbx-pdf-merge-entry>
+            }
+          </div>
+        }
       }
     }
-  `, isInline: true, dependencies: [{ kind: "directive", type: CdkDropList, selector: "[cdkDropList], cdk-drop-list", inputs: ["cdkDropListConnectedTo", "cdkDropListData", "cdkDropListOrientation", "id", "cdkDropListLockAxis", "cdkDropListDisabled", "cdkDropListSortingDisabled", "cdkDropListEnterPredicate", "cdkDropListSortPredicate", "cdkDropListAutoScrollDisabled", "cdkDropListAutoScrollStep", "cdkDropListElementContainer", "cdkDropListHasAnchor"], outputs: ["cdkDropListDropped", "cdkDropListEntered", "cdkDropListExited", "cdkDropListSorted"], exportAs: ["cdkDropList"] }, { kind: "component", type: DbxFileUploadComponent, selector: "dbx-file-upload", inputs: ["config", "buttonStyle", "buttonDisplay", "mode", "text", "icon", "hint", "clickAreaToUpload"], outputs: ["filesChanged"] }, { kind: "component", type: DbxPdfMergeEntryComponent, selector: "dbx-pdf-merge-entry", inputs: ["entry"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, dependencies: [{ kind: "directive", type: CdkDropList, selector: "[cdkDropList], cdk-drop-list", inputs: ["cdkDropListConnectedTo", "cdkDropListData", "cdkDropListOrientation", "id", "cdkDropListLockAxis", "cdkDropListDisabled", "cdkDropListSortingDisabled", "cdkDropListEnterPredicate", "cdkDropListSortPredicate", "cdkDropListAutoScrollDisabled", "cdkDropListAutoScrollStep", "cdkDropListElementContainer", "cdkDropListHasAnchor"], outputs: ["cdkDropListDropped", "cdkDropListEntered", "cdkDropListExited", "cdkDropListSorted"], exportAs: ["cdkDropList"] }, { kind: "component", type: DbxButtonComponent, selector: "dbx-button", inputs: ["bar", "type", "buttonStyle", "color", "spinnerColor", "customButtonColor", "customTextColor", "customSpinnerColor", "basic", "tonal", "raised", "stroked", "flat", "iconOnly", "fab", "customContent", "allowClickPropagation", "mode"] }, { kind: "component", type: DbxFileUploadComponent, selector: "dbx-file-upload", inputs: ["config", "buttonStyle", "buttonDisplay", "mode", "text", "icon", "hint", "clickAreaToUpload"], outputs: ["filesChanged"] }, { kind: "component", type: DbxFileUploadButtonComponent, selector: "dbx-file-upload-button", inputs: ["text", "icon", "ariaLabel", "buttonStyle"], outputs: ["filesChanged"] }, { kind: "directive", type: DbxActionDirective, selector: "dbx-action,[dbxAction]", exportAs: ["action", "dbxAction"] }, { kind: "directive", type: DbxActionButtonDirective, selector: "[dbxActionButton]", inputs: ["dbxActionButtonEcho"] }, { kind: "directive", type: DbxActionHandlerDirective, selector: "[dbxActionHandler]", inputs: ["dbxActionHandler"] }, { kind: "directive", type: DbxActionConfirmDirective, selector: "[dbxActionConfirm]", inputs: ["dbxActionConfirm", "dbxActionConfirmSkip"] }, { kind: "directive", type: DbxActionSnackbarErrorDirective, selector: "[dbxActionSnackbarError]", inputs: ["dbxActionSnackbarError"] }, { kind: "component", type: DbxPdfMergeEntryComponent, selector: "dbx-pdf-merge-entry", inputs: ["entry"] }, { kind: "component", type: DbxPdfMergePageListComponent, selector: "dbx-pdf-merge-page-list", inputs: ["slotId", "showGroupLabels"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeEditorFileUploadComponent, decorators: [{
             type: Component,
@@ -19485,17 +20948,33 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
         <span class="dbx-pdf-merge-editor-file-upload-label">{{ label }}</span>
       }
       <ng-content></ng-content>
+      @if (showAddButtonSignal() || showClearButtonSignal()) {
+        <div class="dbx-pdf-merge-editor-file-upload-actions">
+          @if (showAddButtonSignal()) {
+            <dbx-file-upload-button [accept]="acceptSignal()" [multiple]="multipleSignal()" [text]="addButtonTextSignal()" icon="add" [ariaLabel]="addButtonAriaLabelSignal()" (filesChanged)="onFiles($event)"></dbx-file-upload-button>
+          }
+          @if (showClearButtonSignal()) {
+            <div dbxAction dbxActionSnackbarError [dbxActionHandler]="handleClear" [dbxActionConfirm]="clearConfirmSignal()">
+              <dbx-button dbxActionButton [text]="clearButtonTextSignal()" icon="delete" [ariaLabel]="clearButtonAriaLabelSignal()"></dbx-button>
+            </div>
+          }
+        </div>
+      }
     </div>
-    @if (canAddFilesSignal()) {
+    @if (showUploadAreaSignal()) {
       <dbx-file-upload [accept]="acceptSignal()" [multiple]="multipleSignal()" [mode]="modeSignal()" [hint]="hintSignal()" [text]="textSignal()" [icon]="iconSignal()" (filesChanged)="onFiles($event)"></dbx-file-upload>
     }
     @if (ownedEntriesSignal(); as owned) {
       @if (owned.length > 0) {
-        <div class="dbx-pdf-merge-editor-file-upload-entries" cdkDropList (cdkDropListDropped)="onDrop($event)">
-          @for (entry of owned; track entry.id) {
-            <dbx-pdf-merge-entry [entry]="entry"></dbx-pdf-merge-entry>
-          }
-        </div>
+        @if (pageEditingSignal()) {
+          <dbx-pdf-merge-page-list class="dbx-pdf-merge-editor-file-upload-pages" [slotId]="slotId()"></dbx-pdf-merge-page-list>
+        } @else {
+          <div class="dbx-pdf-merge-editor-file-upload-entries" cdkDropList (cdkDropListDropped)="onDrop($event)">
+            @for (entry of owned; track entry.id) {
+              <dbx-pdf-merge-entry [entry]="entry"></dbx-pdf-merge-entry>
+            }
+          </div>
+        }
       }
     }
   `,
@@ -19505,7 +20984,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
                         '[class.dbx-pdf-merge-editor-file-upload--valid]': 'stateSignal() === "valid"',
                         '[class.dbx-pdf-merge-editor-file-upload--no-file]': 'stateSignal() === "no_file"'
                     },
-                    imports: [CdkDropList, DbxFileUploadComponent, DbxPdfMergeEntryComponent],
+                    imports: [CdkDropList, DbxButtonComponent, DbxFileUploadComponent, DbxFileUploadButtonComponent, DbxActionDirective, DbxActionButtonDirective, DbxActionHandlerDirective, DbxActionConfirmDirective, DbxActionSnackbarErrorDirective, DbxPdfMergeEntryComponent, DbxPdfMergePageListComponent],
                     changeDetection: ChangeDetectionStrategy.OnPush,
                     standalone: true
                 }]
@@ -19544,6 +21023,252 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
                 }]
         }], propDecorators: { targetState: [{ type: i0.Input, args: [{ isSignal: true, alias: "dbxPdfMergeEditorFileUploadHasState", required: false }] }] } });
 
+/**
+ * Messages shown for each reason an import can fail.
+ */
+const DBX_PDF_MERGE_IMPORT_ERROR_MESSAGES = {
+    unreadable: 'This file could not be read as a PDF. It may be corrupt or password protected.',
+    no_sidecar: 'This PDF has no embedded manifest, so its pages cannot be matched back to sections. Choose a PDF that was exported from this editor.',
+    no_documents: 'This PDF has a manifest, but none of its recorded pages could be found in the file.'
+};
+/**
+ * Loads a PDF that was previously exported from the editor with an embedded manifest, and repopulates the editor's slots from it.
+ *
+ * This is the payoff of the sidecar: a completed single-file document goes back to being the set of per-slot documents it was assembled from, so a user can replace or edit one section in place instead of rebuilding the whole file. Every entry currently in the store is replaced.
+ *
+ * **Zero configuration.** The sections this editor accepts are read from the `<dbx-pdf-merge-editor-file-upload>` slots mounted against the shared {@link DbxPdfMergeEditorStore} (see {@link DbxPdfMergeEditorStore.registeredSlotIds$}), so the common case needs no bindings at all. A file naming any other section is rejected rather than partially imported — without that check, entries carrying an unrecognized slot id would import and then render nowhere.
+ *
+ * **Renders nothing when no sections are configured.** This component exists to split a document back into slots, so with no slots mounted (and no explicit {@link expectedSlotIds}) it has nothing to import into and collapses to zero size. Bind {@link enforceExpectedSlots} to `false` for the unusual case of an editor that wants the import affordance without declaring slots.
+ *
+ * @example
+ * ```html
+ * <!-- derives its sections from the slots below it -->
+ * <dbx-pdf-merge-import (imported)="onImported($event)"></dbx-pdf-merge-import>
+ * <dbx-pdf-merge-editor>
+ *   <dbx-pdf-merge-editor-file-upload slotId="license"></dbx-pdf-merge-editor-file-upload>
+ *   <dbx-pdf-merge-editor-file-upload slotId="cert"></dbx-pdf-merge-editor-file-upload>
+ * </dbx-pdf-merge-editor>
+ * ```
+ */
+class DbxPdfMergeImportComponent {
+    store = inject(DbxPdfMergeEditorStore);
+    config = input(...(ngDevMode ? [undefined, { debugName: "config" }] : /* istanbul ignore next */ []));
+    /**
+     * Optional override for the slot ids this editor renders. Leave unbound to derive them from the slots mounted against the store — the zero-configuration default. When set, a file whose manifest names any other slot is rejected rather than partially imported.
+     *
+     * An explicitly bound empty array reads as "this editor deliberately has no sections" and hides the component, the same as having no slots mounted.
+     */
+    expectedSlotIds = input(...(ngDevMode ? [undefined, { debugName: "expectedSlotIds" }] : /* istanbul ignore next */ []));
+    /**
+     * Whether the imported file's sections must match this editor's. Defaults to `true`.
+     *
+     * Binding `false` is the single escape hatch for an editor with no slots that still wants the import affordance: it both skips the check and keeps the component rendered.
+     */
+    enforceExpectedSlots = input(true, ...(ngDevMode ? [{ debugName: "enforceExpectedSlots" }] : /* istanbul ignore next */ []));
+    imported = output();
+    importFailed = output();
+    /**
+     * Emits the expected sections the imported file did not fill, when there are any. The import itself still succeeds — a missing section is a partial state the user can fill in.
+     */
+    missingSlots = output();
+    _error = signal(null, ...(ngDevMode ? [{ debugName: "_error" }] : /* istanbul ignore next */ []));
+    _result = signal(null, ...(ngDevMode ? [{ debugName: "_result" }] : /* istanbul ignore next */ []));
+    _missingSlotIds = signal([], ...(ngDevMode ? [{ debugName: "_missingSlotIds" }] : /* istanbul ignore next */ []));
+    errorSignal = this._error.asReadonly();
+    resultSignal = this._result.asReadonly();
+    missingSlotIdsSignal = this._missingSlotIds.asReadonly();
+    _registeredSlotIdsSignal = toSignal(this.store.registeredSlotIds$, { initialValue: [] });
+    /**
+     * The exact import state the notices below currently describe — the one this component's own picked file produced. Identity, not contents: it is the only reliable way to tell "still my file" from "the store moved on".
+     */
+    _displayedState;
+    constructor() {
+        // The notices are set from what `onFiles` gets back rather than from `importState$`, so that
+        // they only ever describe a file picked here. They must not outlive it, though: once the store
+        // is showing anything other than this component's own import — cleared outright, restored to a
+        // programmatic baseline, or replaced by an import from elsewhere — the notice is describing
+        // content the editor no longer holds, and goes.
+        this.store.importState$.pipe(takeUntilDestroyed()).subscribe((state) => {
+            if (state !== this._displayedState) {
+                this.resetDisplay();
+            }
+        });
+    }
+    /**
+     * The sections an imported file is allowed to name, or `null` when no check applies. Resolves the explicit {@link expectedSlotIds} binding over the slots registered with the store.
+     */
+    effectiveExpectedSlotIdsSignal = computed(() => {
+        const registered = this._registeredSlotIdsSignal();
+        const bound = this.expectedSlotIds();
+        let expected;
+        if (!this.enforceExpectedSlots()) {
+            expected = null;
+        }
+        else if (bound == null) {
+            // An empty registry is "nothing declared yet", not "nothing allowed" — the component hides
+            // rather than rejecting, so a null here never becomes a check that fails every file.
+            expected = registered.length > 0 ? registered : null;
+        }
+        else {
+            expected = bound;
+        }
+        return expected;
+    }, ...(ngDevMode ? [{ debugName: "effectiveExpectedSlotIdsSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * Whether this component has anything to import into. `false` collapses it to nothing — see the class docs.
+     */
+    activeSignal = computed(() => {
+        const expected = this.effectiveExpectedSlotIdsSignal();
+        return !this.enforceExpectedSlots() || (expected != null && expected.length > 0);
+    }, ...(ngDevMode ? [{ debugName: "activeSignal" }] : /* istanbul ignore next */ []));
+    acceptSignal = computed(() => this.config()?.accept ?? [PDF_MIME_TYPE], ...(ngDevMode ? [{ debugName: "acceptSignal" }] : /* istanbul ignore next */ []));
+    modeSignal = computed(() => this.config()?.mode ?? 'default', ...(ngDevMode ? [{ debugName: "modeSignal" }] : /* istanbul ignore next */ []));
+    labelSignal = computed(() => this.config()?.label, ...(ngDevMode ? [{ debugName: "labelSignal" }] : /* istanbul ignore next */ []));
+    hintSignal = computed(() => this.config()?.hint ?? 'Choose a PDF previously exported from this editor', ...(ngDevMode ? [{ debugName: "hintSignal" }] : /* istanbul ignore next */ []));
+    textSignal = computed(() => this.config()?.text ?? 'Import merged PDF', ...(ngDevMode ? [{ debugName: "textSignal" }] : /* istanbul ignore next */ []));
+    iconSignal = computed(() => this.config()?.icon ?? 'upload_file', ...(ngDevMode ? [{ debugName: "iconSignal" }] : /* istanbul ignore next */ []));
+    successLabelSignal = computed(() => {
+        const result = this._result();
+        let label;
+        if (result == null) {
+            label = null;
+        }
+        else {
+            const sections = result.slotIds.map((slotId) => slotId ?? 'unsectioned').join(', ');
+            label = `Imported ${result.entries.length} section(s): ${sections}.`;
+        }
+        return label;
+    }, ...(ngDevMode ? [{ debugName: "successLabelSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * Warning shown when the imported file left one or more expected sections empty. The import succeeded — this only explains why a slot is still blank.
+     */
+    missingLabelSignal = computed(() => {
+        const missing = this._missingSlotIds();
+        return missing.length > 0 ? `This PDF did not include section(s): ${missing.join(', ')}.` : null;
+    }, ...(ngDevMode ? [{ debugName: "missingLabelSignal" }] : /* istanbul ignore next */ []));
+    async onFiles(event) {
+        const file = event.matchResult.accepted[0];
+        if (file != null) {
+            this.resetDisplay();
+            // Delegates to the store so the picker and a programmatic import share one implementation
+            // and one set of error semantics. The slot check is opt-in on the store, so the component's
+            // own resolved expectation is what preserves the picker's behavior. The returned state is
+            // used rather than `importState$` so these outputs only ever describe a picked file.
+            // `origin: 'user'` marks this as discardable — it must not become the store's clear-time
+            // restore point, which belongs to whatever document the app itself supplied.
+            const state = await this.store.importMergedPdf({ source: file, expectedSlotIds: this.effectiveExpectedSlotIdsSignal(), origin: 'user' });
+            // Claim this state before rendering it: the subscription above resets on anything it does
+            // not recognise, and the 'importing'/terminal emissions have already gone past by now.
+            this._displayedState = state;
+            if (state.status === 'failed') {
+                this.fail(this.messageForFailure(state));
+            }
+            else if (state.result != null) {
+                const { result } = state;
+                this._result.set(result);
+                this._missingSlotIds.set(result.missingSlotIds);
+                this.imported.emit(result);
+                if (result.missingSlotIds.length > 0) {
+                    this.missingSlots.emit(result.missingSlotIds);
+                }
+            }
+        }
+    }
+    messageForFailure(state) {
+        const unexpected = state.unexpectedSlotIds ?? [];
+        let message;
+        if (state.error === 'unexpected_slots') {
+            message = `This PDF contains section(s) this editor does not have: ${unexpected.map((slotId) => slotId ?? 'unsectioned').join(', ')}.`;
+        }
+        else {
+            message = DBX_PDF_MERGE_IMPORT_ERROR_MESSAGES[state.error ?? 'unreadable'];
+        }
+        return message;
+    }
+    fail(message) {
+        this._error.set(message);
+        this.importFailed.emit(message);
+    }
+    /**
+     * Drops every notice this component renders, returning it to its pre-import appearance and releasing its claim on the store's import state.
+     */
+    resetDisplay() {
+        this._displayedState = null;
+        this._error.set(null);
+        this._result.set(null);
+        this._missingSlotIds.set([]);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeImportComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.11", type: DbxPdfMergeImportComponent, isStandalone: true, selector: "dbx-pdf-merge-import", inputs: { config: { classPropertyName: "config", publicName: "config", isSignal: true, isRequired: false, transformFunction: null }, expectedSlotIds: { classPropertyName: "expectedSlotIds", publicName: "expectedSlotIds", isSignal: true, isRequired: false, transformFunction: null }, enforceExpectedSlots: { classPropertyName: "enforceExpectedSlots", publicName: "enforceExpectedSlots", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { imported: "imported", importFailed: "importFailed", missingSlots: "missingSlots" }, host: { properties: { "class.d-block": "activeSignal()", "class.dbx-mb3": "activeSignal()" }, classAttribute: "dbx-pdf-merge-import" }, ngImport: i0, template: `
+    @if (activeSignal()) {
+      @if (labelSignal(); as label) {
+        <div class="dbx-pdf-merge-import-label">{{ label }}</div>
+      }
+      <dbx-file-upload [accept]="acceptSignal()" [multiple]="false" [mode]="modeSignal()" [hint]="hintSignal()" [text]="textSignal()" [icon]="iconSignal()" (filesChanged)="onFiles($event)"></dbx-file-upload>
+      @if (errorSignal(); as error) {
+        <div class="dbx-pdf-merge-import-error">
+          <mat-icon class="dbx-pdf-merge-import-icon">error</mat-icon>
+          <span>{{ error }}</span>
+        </div>
+      }
+      @if (successLabelSignal(); as success) {
+        <div class="dbx-pdf-merge-import-success">
+          <mat-icon class="dbx-pdf-merge-import-icon">check_circle</mat-icon>
+          <span>{{ success }}</span>
+        </div>
+      }
+      @if (missingLabelSignal(); as missing) {
+        <div class="dbx-pdf-merge-import-warning">
+          <mat-icon class="dbx-pdf-merge-import-icon">warning</mat-icon>
+          <span>{{ missing }}</span>
+        </div>
+      }
+    }
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i1$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: DbxFileUploadComponent, selector: "dbx-file-upload", inputs: ["config", "buttonStyle", "buttonDisplay", "mode", "text", "icon", "hint", "clickAreaToUpload"], outputs: ["filesChanged"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeImportComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-pdf-merge-import',
+                    template: `
+    @if (activeSignal()) {
+      @if (labelSignal(); as label) {
+        <div class="dbx-pdf-merge-import-label">{{ label }}</div>
+      }
+      <dbx-file-upload [accept]="acceptSignal()" [multiple]="false" [mode]="modeSignal()" [hint]="hintSignal()" [text]="textSignal()" [icon]="iconSignal()" (filesChanged)="onFiles($event)"></dbx-file-upload>
+      @if (errorSignal(); as error) {
+        <div class="dbx-pdf-merge-import-error">
+          <mat-icon class="dbx-pdf-merge-import-icon">error</mat-icon>
+          <span>{{ error }}</span>
+        </div>
+      }
+      @if (successLabelSignal(); as success) {
+        <div class="dbx-pdf-merge-import-success">
+          <mat-icon class="dbx-pdf-merge-import-icon">check_circle</mat-icon>
+          <span>{{ success }}</span>
+        </div>
+      }
+      @if (missingLabelSignal(); as missing) {
+        <div class="dbx-pdf-merge-import-warning">
+          <mat-icon class="dbx-pdf-merge-import-icon">warning</mat-icon>
+          <span>{{ missing }}</span>
+        </div>
+      }
+    }
+  `,
+                    host: {
+                        class: 'dbx-pdf-merge-import',
+                        // Collapsed rather than merely emptied while inactive: without `d-block` the host is an empty
+                        // inline element of zero size, and dropping the margin keeps it from occupying layout.
+                        '[class.d-block]': 'activeSignal()',
+                        '[class.dbx-mb3]': 'activeSignal()'
+                    },
+                    imports: [MatIconModule, DbxFileUploadComponent],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true
+                }]
+        }], ctorParameters: () => [], propDecorators: { config: [{ type: i0.Input, args: [{ isSignal: true, alias: "config", required: false }] }], expectedSlotIds: [{ type: i0.Input, args: [{ isSignal: true, alias: "expectedSlotIds", required: false }] }], enforceExpectedSlots: [{ type: i0.Input, args: [{ isSignal: true, alias: "enforceExpectedSlots", required: false }] }], imported: [{ type: i0.Output, args: ["imported"] }], importFailed: [{ type: i0.Output, args: ["importFailed"] }], missingSlots: [{ type: i0.Output, args: ["missingSlots"] }] } });
+
 const DEFAULT_UPLOAD_FOOTER_ICON = 'cloud_upload';
 const DEFAULT_UPLOAD_FOOTER_TEXT = 'Upload';
 const DEFAULT_UPLOAD_FOOTER_COLOR = 'primary';
@@ -19605,7 +21330,7 @@ class DbxPdfMergeUploadDialogComponent extends AbstractDialogDirective {
         </div>
       }
     </dbx-dialog-content>
-  `, isInline: true, dependencies: [{ kind: "directive", type: DbxDialogContentDirective, selector: "dbx-dialog-content,[dbxDialogContent],.dbx-dialog-content", inputs: ["width"] }, { kind: "component", type: DbxDialogContentCloseComponent, selector: "dbx-dialog-content-close", inputs: ["padded"], outputs: ["close"] }, { kind: "component", type: DbxInjectionComponent, selector: "dbx-injection, [dbxInjection], [dbx-injection]", inputs: ["config", "template"] }, { kind: "component", type: DbxPdfMergeEditorComponent, selector: "dbx-pdf-merge-editor", inputs: ["accept", "multiple", "fileName", "showDownloadButton", "showPreviewButton", "downloadButton", "showAddFiles", "showFileList", "config"], outputs: ["entriesChanged"] }, { kind: "component", type: DbxButtonComponent, selector: "dbx-button", inputs: ["bar", "type", "buttonStyle", "color", "spinnerColor", "customButtonColor", "customTextColor", "customSpinnerColor", "basic", "tonal", "raised", "stroked", "flat", "iconOnly", "fab", "customContent", "allowClickPropagation", "mode"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, dependencies: [{ kind: "directive", type: DbxDialogContentDirective, selector: "dbx-dialog-content,[dbxDialogContent],.dbx-dialog-content", inputs: ["width"] }, { kind: "component", type: DbxDialogContentCloseComponent, selector: "dbx-dialog-content-close", inputs: ["padded"], outputs: ["close"] }, { kind: "component", type: DbxInjectionComponent, selector: "dbx-injection, [dbxInjection], [dbx-injection]", inputs: ["config", "template"] }, { kind: "component", type: DbxPdfMergeEditorComponent, selector: "dbx-pdf-merge-editor", inputs: ["accept", "multiple", "fileName", "showDownloadButton", "showPreviewButton", "downloadButton", "showAddFiles", "showFileList", "pageEditing", "sidecar", "config"], outputs: ["entriesChanged"] }, { kind: "component", type: DbxButtonComponent, selector: "dbx-button", inputs: ["bar", "type", "buttonStyle", "color", "spinnerColor", "customButtonColor", "customTextColor", "customSpinnerColor", "basic", "tonal", "raised", "stroked", "flat", "iconOnly", "fab", "customContent", "allowClickPropagation", "mode"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImport: i0, type: DbxPdfMergeUploadDialogComponent, decorators: [{
             type: Component,
@@ -19808,5 +21533,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { APP_POPUP_MINIMIZED_WIDTH, APP_POPUP_NORMAL_HEIGHT, APP_POPUP_NORMAL_WIDTH, AbstractDbxClipboardDirective, AbstractDbxErrorWidgetComponent, AbstractDbxFileUploadComponent, AbstractDbxHelpWidgetDirective, AbstractDbxListAccordionViewDirective, AbstractDbxListGridViewDirective, AbstractDbxListViewDirective, AbstractDbxListWrapperDirective, AbstractDbxPartialPresetFilterMenuDirective, AbstractDbxSegueAnchorDirective, AbstractDbxSelectionListViewDirective, AbstractDbxSelectionListWrapperDirective, AbstractDbxValueListItemModifierDirective, AbstractDbxValueListViewDirective, AbstractDbxValueListViewItemComponent, AbstractDbxWidgetComponent, AbstractDialogDirective, AbstractFilterPopoverButtonDirective, AbstractPopoverDirective, AbstractPopoverRefDirective, AbstractPopoverRefWithEventsDirective, AbstractPopupDirective, AbstractPromptConfirmDirective, CompactContextStore, CompactMode, DBX_ACTION_SNACKBAR_DEFAULTS, DBX_ACTION_SNACKBAR_SERVICE_CONFIG, DBX_AVATAR_CONTEXT_DATA_TOKEN, DBX_COLOR_CUSTOM_BG_CSS_CLASS, DBX_COLOR_CUSTOM_TEXT_CSS_CLASS, DBX_CURATED_COLOR_COUNT, DBX_CURATED_COLOR_TEMPLATES, DBX_CURATED_COLOR_TEMPLATE_KEY_PREFIX, DBX_DARK_STYLE_CLASS_SUFFIX, DBX_HELP_WIDGET_ENTRY_DATA_TOKEN, DBX_LIST_ACCORDION_VIEW_COMPONENT_IMPORTS_AND_EXPORTS, DBX_LIST_GRID_VIEW_COMPONENT_IMPORTS_AND_EXPORTS, DBX_LIST_ITEM_DISABLE_RIPPLE_LIST_ITEM_MODIFIER_KEY, DBX_LIST_ITEM_IS_SELECTED_ITEM_MODIFIER_KEY, DBX_MODEL_VIEW_TRACKER_STORAGE_ACCESSOR_TOKEN, DBX_PDF_MERGE_EDITOR_CONFIG, DBX_PDF_MERGE_EDITOR_INITIAL_STATE, DBX_PDF_MERGE_EDITOR_PRESERVE_ENTRIES_ON_SLOT_DESTROY, DBX_PDF_MERGE_ENCRYPTED_ERROR_MESSAGE, DBX_PROGRESS_BUTTON_GLOBAL_CONFIG, DBX_ROUTER_ANCHOR_COMPONENTS, DBX_ROUTER_VALUE_LIST_ITEM_MODIFIER_KEY, DBX_THEME_COLORS, DBX_THEME_COLORS_EXTRA, DBX_THEME_COLORS_EXTRA_SECONDARY, DBX_THEME_COLORS_MAIN, DBX_VALUE_LIST_VIEW_ITEM, DBX_WEB_FILE_PREVIEW_SERVICE_ENTRIES_TOKEN, DBX_WEB_FILE_PREVIEW_SERVICE_ZIP_COMPONENT_PRESET, DBX_WEB_FILE_PREVIEW_SERVICE_ZIP_PRESET_ENTRY, DBX_WEB_PAGE_TITLE_SERVICE_CONFIG, DEFAULT_DBX_CHIP_TONE, DEFAULT_DBX_DETACH_KEY, DEFAULT_DBX_ERROR_SNACKBAR_CONFIG, DEFAULT_DBX_HELP_VIEW_POPOVER_KEY, DEFAULT_DBX_LINKIFY_STRING_TYPE, DEFAULT_DBX_LIST_ACCORDION_VIEW_COMPONENT_CONFIGURATION_TEMPLATE, DEFAULT_DBX_LIST_GRID_VIEW_COMPONENT_CONFIGURATION_TEMPLATE, DEFAULT_DBX_LIST_ITEM_DISABLE_FUNCTION, DEFAULT_DBX_LIST_ITEM_IS_SELECTED_FUNCTION, DEFAULT_DBX_LIST_SCROLL_DISTANCE, DEFAULT_DBX_LIST_THROTTLE_SCROLL, DEFAULT_DBX_LIST_VIEW_META_ICON, DEFAULT_DBX_PDF_MERGE_ENCRYPTED_HANDLING, DEFAULT_DBX_PROMPT_CONFIRM_DIALOG_CONFIG, DEFAULT_DBX_SELECTION_VALUE_LIST_COMPONENT_CONFIGURATION_TEMPLATE, DEFAULT_DBX_SIDENAV_MENU_ICON, DEFAULT_DBX_STYLE_CONFIG_TOKEN, DEFAULT_DBX_VALUE_LIST_COMPONENT_CONFIGURATION_TEMPLATE, DEFAULT_DBX_WEB_FILE_PREVIEW_SERVICE_DIALOG_WITH_COMPONENT_FUNCTION, DEFAULT_DBX_WEB_FILE_PREVIEW_SERVICE_PREVIEW_COMPONENT_FUNCTION, DEFAULT_ERROR_POPOVER_KEY, DEFAULT_ERROR_WIDGET_CODE, DEFAULT_FILTER_POPOVER_KEY, DEFAULT_IMAGE_BITMAP_TO_BLOB_ENCODER, DEFAULT_IMAGE_JPEG_QUALITY, DEFAULT_LIST_GRID_SIZE_CONFIG, DEFAULT_LIST_WRAPPER_COMPONENT_CONFIGURATION_TEMPLATE, DEFAULT_LOADING_PROGRESS_DIAMETER, DEFAULT_PDF_MERGE_ACCEPT, DEFAULT_SCREEN_MEDIA_SERVICE_CONFIG, DEFAULT_SNACKBAR_DIRECTIVE_DURATION, DEFAULT_TWO_COLUMNS_MIN_RIGHT_WIDTH, DEFAULT_VALUE_LIST_VIEW_CONTENT_COMPONENT_TRACK_BY_FUNCTION, DbxAccordionHeaderHeightDirective, DbxActionConfirmDirective, DbxActionDialogDirective, DbxActionErrorDirective, DbxActionKeyTriggerDirective, DbxActionLoadingContextDirective, DbxActionModule, DbxActionPopoverDirective, DbxActionSnackbarComponent, DbxActionSnackbarDirective, DbxActionSnackbarErrorDirective, DbxActionSnackbarModule, DbxActionSnackbarService, DbxActionTransitionSafetyDirective, DbxActionUIRouterTransitionSafetyDialogComponent, DbxAnchorComponent, DbxAnchorContentComponent, DbxAnchorIconComponent, DbxAnchorListComponent, DbxAngularRouterSegueAnchorComponent, DbxAvatarComponent, DbxAvatarViewComponent, DbxAvatarViewService, DbxAvatarViewServiceConfig, DbxBarDirective, DbxBarHeaderComponent, DbxBarLayoutModule, DbxBasicLoadingComponent, DbxBodyDirective, DbxButtonComponent, DbxButtonModule, DbxButtonSpacerDirective, DbxCardBoxComponent, DbxCardBoxContainerDirective, DbxCardBoxLayoutModule, DbxChipDirective, DbxChipListComponent, DbxClickToCopyTextComponent, DbxClickToCopyTextDirective, DbxColorDirective, DbxColorService, DbxColorServiceConfig, DbxColumnLayoutModule, DbxCompactDirective, DbxCompactLayoutModule, DbxContentBorderDirective, DbxContentBoxDirective, DbxContentContainerDirective, DbxContentDirective, DbxContentElevateDirective, DbxContentLayoutModule, DbxContentPageDirective, DbxContentPitDirective, DbxDetachContentComponent, DbxDetachControlButtonsComponent, DbxDetachController, DbxDetachControlsComponent, DbxDetachInitDirective, DbxDetachInteractionModule, DbxDetachOutletComponent, DbxDetachOverlayComponent, DbxDetachService, DbxDetachWindowState, DbxDetailBlockComponent, DbxDetailBlockHeaderComponent, DbxDialogContentCloseComponent, DbxDialogContentDirective, DbxDialogContentFooterComponent, DbxDialogInteractionModule, DbxDialogModule, DbxDownloadBlobButtonComponent, DbxDownloadTextViewComponent, DbxEmbedComponent, DbxErrorComponent, DbxErrorDefaultErrorWidgetComponent, DbxErrorDetailsComponent, DbxErrorPopoverComponent, DbxErrorSnackbarComponent, DbxErrorSnackbarService, DbxErrorViewComponent, DbxErrorWidgetService, DbxErrorWidgetViewComponent, DbxFileUploadActionCompatable, DbxFileUploadActionSyncDirective, DbxFileUploadAreaComponent, DbxFileUploadButtonComponent, DbxFileUploadComponent, DbxFilterInteractionModule, DbxFilterPopoverButtonComponent, DbxFilterPopoverComponent, DbxFilterWrapperComponent, DbxFlagComponent, DbxFlagLayoutModule, DbxFlagPromptComponent, DbxFlexGroupDirective, DbxFlexLayoutModule, DbxFlexSizeDirective, DbxHelpContextDirective, DbxHelpContextService, DbxHelpViewListComponent, DbxHelpViewListEntryComponent, DbxHelpViewPopoverButtonComponent, DbxHelpViewPopoverComponent, DbxHelpWidgetService, DbxHelpWidgetServiceConfig, DbxIconButtonComponent, DbxIconButtonModule, DbxIconItemComponent, DbxIconSpacerDirective, DbxIconTileComponent, DbxIconTileDirective, DbxIfSidenavDisplayModeDirective, DbxIframeComponent, DbxInjectionDialogComponent, DbxInteractionModule, DbxIntroActionSectionComponent, DbxLabelBlockComponent, DbxLayoutModule, DbxLinkComponent, DbxLinkifyComponent, DbxLinkifyService, DbxLinkifyServiceConfig, DbxListAccordionViewComponentImportsModule, DbxListComponent, DbxListEmptyContentComponent, DbxListGridViewComponentImportsModule, DbxListInternalContentDirective, DbxListItemAnchorModifierDirective, DbxListItemDisableRippleModifierDirective, DbxListItemIsSelectedModifierDirective, DbxListModifierModule, DbxListModule, DbxListTitleGroupDirective, DbxListView, DbxListViewMetaIconComponent, DbxListViewWrapper, DbxListWrapperComponentImportsModule, DbxLoadingComponent, DbxLoadingErrorDirective, DbxLoadingModule, DbxLoadingProgressComponent, DbxModelObjectStateService, actions as DbxModelStateActions, model_actions as DbxModelStateModelActions, DbxModelTrackerService, DbxModelTypesService, DbxModelViewTrackerStorage, DbxNavbarComponent, DbxNumberWithLimitComponent, DbxOneColumnComponent, DbxOneColumnLayoutModule, DbxPagebarComponent, DbxPartialPresetFilterListComponent, DbxPartialPresetFilterMenuComponent, DbxPdfMergeEditorComponent, DbxPdfMergeEditorFileUploadComponent, DbxPdfMergeEditorFileUploadHasStateDirective, DbxPdfMergeEditorFileUploadValidatorDirective, DbxPdfMergeEditorStore, DbxPdfMergeEditorStoreDirective, DbxPdfMergeEntryComponent, DbxPdfMergeListComponent, DbxPdfMergeUploadActionDirective, DbxPdfMergeUploadButtonDirective, DbxPdfMergeUploadDialogComponent, DbxPdfPreviewComponent, DbxPopoverCloseButtonComponent, DbxPopoverComponent, DbxPopoverComponentController, DbxPopoverContentComponent, DbxPopoverController, DbxPopoverControlsDirective, DbxPopoverCoordinatorComponent, DbxPopoverCoordinatorService, DbxPopoverHeaderComponent, DbxPopoverInteractionContentModule, DbxPopoverInteractionModule, DbxPopoverScrollContentDirective, DbxPopoverService, DbxPopupComponent, DbxPopupComponentController, DbxPopupContentComponent, DbxPopupControlButtonsComponent, DbxPopupController, DbxPopupControlsComponent, DbxPopupCoordinatorComponent, DbxPopupCoordinatorService, DbxPopupInteractionModule, DbxPopupService, DbxPopupWindowState, DbxPresetFilterListComponent, DbxPresetFilterMenuComponent, DbxProgressBarButtonComponent, DbxProgressButtonsModule, DbxProgressSpinnerButtonComponent, DbxPromptBoxDirective, DbxPromptComponent, DbxPromptConfirm, DbxPromptConfirmButtonDirective, DbxPromptConfirmComponent, DbxPromptConfirmDialogComponent, DbxPromptConfirmDirective, DbxPromptModule, DbxPromptPageComponent, DbxReadableErrorModule, DbxResizedDirective, DbxRouterAnchorModule, DbxRouterLayoutModule, DbxRouterSidenavModule, DbxRouterWebProviderConfig, DbxScreenMediaService, DbxScreenMediaServiceConfig, DbxSectionComponent, DbxSectionHeaderComponent, DbxSectionLayoutModule, DbxSectionPageComponent, DbxSelectionValueListViewComponent, DbxSelectionValueListViewComponentImportsModule, DbxSelectionValueListViewContentComponent, DbxSetStyleDirective, DbxSidenavButtonComponent, DbxSidenavComponent, DbxSidenavPageComponent, DbxSidenavPagebarComponent, DbxSpacerDirective, DbxStepBlockComponent, DbxStructureDirective, DbxStructureModule, DbxStyleBodyDirective, DbxStyleDirective, DbxStyleLayoutModule, DbxStyleService, DbxSubSectionComponent, DbxTextChipsComponent, DbxTextColorDirective, DbxTextModule, DbxTwoBlockComponent, DbxTwoColumnBackDirective, DbxTwoColumnColumnHeadDirective, DbxTwoColumnComponent, DbxTwoColumnContextDirective, DbxTwoColumnFullLeftDirective, DbxTwoColumnLayoutModule, DbxTwoColumnRightComponent, DbxTwoColumnSrefDirective, DbxTwoColumnSrefShowRightDirective, DbxUIRouterSegueAnchorComponent, DbxUnitedStatesAddressComponent, DbxValueListAccordionViewComponent, DbxValueListAccordionViewContentComponent, DbxValueListAccordionViewContentGroupComponent, DbxValueListGridSizeDirective, DbxValueListGridViewComponent, DbxValueListGridViewContentComponent, DbxValueListGridViewContentGroupComponent, DbxValueListItemModifier, DbxValueListItemModifierDirective, DbxValueListView, DbxValueListViewComponent, DbxValueListViewComponentImportsModule, DbxValueListViewContentComponent, DbxValueListViewContentGroupComponent, DbxValueListViewGroupDelegate, DbxWebFilePreviewComponent, DbxWebFilePreviewService, DbxWebModule, DbxWebPageTitleInfoDirective, DbxWebPageTitleService, DbxWidgetListGridComponent, DbxWidgetListGridViewComponent, DbxWidgetListGridViewItemComponent, DbxWidgetService, DbxWidgetViewComponent, DbxWindowKeyDownListenerDirective, DbxZipBlobPreviewComponent, DbxZipPreviewComponent, PDF_MERGE_RESULT_MIME_TYPE, PopoverPositionStrategy, PopupGlobalPositionStrategy, SCREEN_MEDIA_WIDTH_TYPE_SIZE_MAP, SIDE_NAV_DISPLAY_MODE_ORDER, SideNavDisplayMode, TRACK_BY_MODEL_ID, TRACK_BY_MODEL_KEY, TwoColumnsContextStore, UNKNOWN_ERROR_WIDGET_CODE, addConfigToValueListItems, allDbxModelViewTrackerEventModelKeys, allDbxModelViewTrackerEventSetModelKeys, buildPdfMergeEntry, buildPdfMergeEntrySync, catchErrorServerParams, classifyPdfMergeFile, compactModeFromInput, compareScreenMediaWidthTypes, compressImageFile, convertServerErrorParams, convertToPOJOServerErrorResponse, convertToServerErrorResponse, copyToClipboardFunction, dbxColorBackground, dbxCuratedColorConfigForString, dbxListAccordionViewComponentImportsAndExports, dbxListGridViewComponentImportsAndExports, dbxPresetFilterMenuButtonIconObservable, dbxPresetFilterMenuButtonTextObservable, dbxStyleClassCleanSuffix, dbxThemeColorCssToken, dbxThemeColorCssTokenVar, dbxThemeColorCssVariable, dbxThemeColorCssVariableVar, dbxValueListItemDecisionFunction, dbxValueListItemKeyForItemValue, dbxWebDefaultPageTitleDelegate, dbxZipBlobPreviewEntryTreeFromEntries, defaultDbxModelViewTrackerStorageAccessorFactory, defaultDbxValueListViewGroupDelegate, defaultDbxValueListViewGroupValuesFunction, disableRightClickInCdkBackdrop, fileAcceptFilterTypeStringArray, fileAcceptFunction, fileAcceptString, fileArrayAcceptMatchFunction, flattenAccordionGroups, formatPdfMergeEntrySize, index as fromDbxModel, injectCopyToClipboardFunction, injectCopyToClipboardFunctionWithSnackbarMessage, isDbxColorConfig, listItemModifier, makeDbxActionSnackbarDisplayConfigGeneratorFunction, mapCompactModeObs, mapValuesToValuesListItemConfigObs, mergePdfMergeEntries, index$1 as onDbxModel, openEmbedDialog, openIframeDialog, openPdfPreviewDialog, openZipPreviewDialog, overrideClickElementEffect, provideDbxDetachController, provideDbxFileUploadActionCompatable, provideDbxHelpServices, provideDbxLinkify, provideDbxListView, provideDbxListViewWrapper, provideDbxModelService, provideDbxPdfMergeEditorConfig, provideDbxPdfMergeEditorPreserveEntriesOnSlotDestroy, provideDbxProgressButtonGlobalConfig, provideDbxPromptConfirm, provideDbxRouterWebAngularRouterProviderConfig, provideDbxRouterWebUiRouterProviderConfig, provideDbxScreenMediaService, provideDbxStyleService, provideDbxValueListView, provideDbxValueListViewGroupDelegate, provideDbxValueListViewModifier, provideDbxWebFilePreviewServiceEntries, provideDbxWebPageTitleService, provideTwoColumnsContext, registerHelpContextKeysWithDbxHelpContextService, resizeSignal, resolveSideNavDisplayMode, sanitizeDbxDialogContentConfig, screenMediaWidthTypeIsActive, trackByModelKeyRef, trackByUniqueIdentifier, validatePdfMergeEntry };
+export { APP_POPUP_MINIMIZED_WIDTH, APP_POPUP_NORMAL_HEIGHT, APP_POPUP_NORMAL_WIDTH, AbstractDbxClipboardDirective, AbstractDbxErrorWidgetComponent, AbstractDbxFileUploadComponent, AbstractDbxHelpWidgetDirective, AbstractDbxListAccordionViewDirective, AbstractDbxListGridViewDirective, AbstractDbxListViewDirective, AbstractDbxListWrapperDirective, AbstractDbxPartialPresetFilterMenuDirective, AbstractDbxSegueAnchorDirective, AbstractDbxSelectionListViewDirective, AbstractDbxSelectionListWrapperDirective, AbstractDbxValueListItemModifierDirective, AbstractDbxValueListViewDirective, AbstractDbxValueListViewItemComponent, AbstractDbxWidgetComponent, AbstractDialogDirective, AbstractFilterPopoverButtonDirective, AbstractPopoverDirective, AbstractPopoverRefDirective, AbstractPopoverRefWithEventsDirective, AbstractPopupDirective, AbstractPromptConfirmDirective, CompactContextStore, CompactMode, DBX_ACTION_SNACKBAR_DEFAULTS, DBX_ACTION_SNACKBAR_SERVICE_CONFIG, DBX_AVATAR_CONTEXT_DATA_TOKEN, DBX_COLOR_CUSTOM_BG_CSS_CLASS, DBX_COLOR_CUSTOM_TEXT_CSS_CLASS, DBX_CURATED_COLOR_COUNT, DBX_CURATED_COLOR_TEMPLATES, DBX_CURATED_COLOR_TEMPLATE_KEY_PREFIX, DBX_DARK_STYLE_CLASS_SUFFIX, DBX_HELP_WIDGET_ENTRY_DATA_TOKEN, DBX_LIST_ACCORDION_VIEW_COMPONENT_IMPORTS_AND_EXPORTS, DBX_LIST_GRID_VIEW_COMPONENT_IMPORTS_AND_EXPORTS, DBX_LIST_ITEM_DISABLE_RIPPLE_LIST_ITEM_MODIFIER_KEY, DBX_LIST_ITEM_IS_SELECTED_ITEM_MODIFIER_KEY, DBX_MODEL_VIEW_TRACKER_STORAGE_ACCESSOR_TOKEN, DBX_PDF_MERGE_EDITOR_CONFIG, DBX_PDF_MERGE_EDITOR_INITIAL_STATE, DBX_PDF_MERGE_EDITOR_PRESERVE_ENTRIES_ON_SLOT_DESTROY, DBX_PDF_MERGE_ENCRYPTED_ERROR_MESSAGE, DBX_PDF_MERGE_ENCRYPTED_NOT_EDITABLE_MESSAGE, DBX_PDF_MERGE_IMPORT_ERROR_MESSAGES, DBX_PROGRESS_BUTTON_GLOBAL_CONFIG, DBX_ROUTER_ANCHOR_COMPONENTS, DBX_ROUTER_VALUE_LIST_ITEM_MODIFIER_KEY, DBX_THEME_COLORS, DBX_THEME_COLORS_EXTRA, DBX_THEME_COLORS_EXTRA_SECONDARY, DBX_THEME_COLORS_MAIN, DBX_VALUE_LIST_VIEW_ITEM, DBX_WEB_FILE_PREVIEW_SERVICE_ENTRIES_TOKEN, DBX_WEB_FILE_PREVIEW_SERVICE_ZIP_COMPONENT_PRESET, DBX_WEB_FILE_PREVIEW_SERVICE_ZIP_PRESET_ENTRY, DBX_WEB_PAGE_TITLE_SERVICE_CONFIG, DEFAULT_DBX_CHIP_TONE, DEFAULT_DBX_DETACH_KEY, DEFAULT_DBX_ERROR_SNACKBAR_CONFIG, DEFAULT_DBX_HELP_VIEW_POPOVER_KEY, DEFAULT_DBX_LINKIFY_STRING_TYPE, DEFAULT_DBX_LIST_ACCORDION_VIEW_COMPONENT_CONFIGURATION_TEMPLATE, DEFAULT_DBX_LIST_GRID_VIEW_COMPONENT_CONFIGURATION_TEMPLATE, DEFAULT_DBX_LIST_ITEM_DISABLE_FUNCTION, DEFAULT_DBX_LIST_ITEM_IS_SELECTED_FUNCTION, DEFAULT_DBX_LIST_SCROLL_DISTANCE, DEFAULT_DBX_LIST_THROTTLE_SCROLL, DEFAULT_DBX_LIST_VIEW_META_ICON, DEFAULT_DBX_PDF_MERGE_ENCRYPTED_HANDLING, DEFAULT_DBX_PDF_MERGE_PAGE_EDITING, DEFAULT_DBX_PDF_MERGE_RESTORE_IMPORT_ON_CLEAR, DEFAULT_DBX_PDF_MERGE_SIDECAR, DEFAULT_DBX_PROMPT_CONFIRM_DIALOG_CONFIG, DEFAULT_DBX_SELECTION_VALUE_LIST_COMPONENT_CONFIGURATION_TEMPLATE, DEFAULT_DBX_SIDENAV_MENU_ICON, DEFAULT_DBX_STYLE_CONFIG_TOKEN, DEFAULT_DBX_VALUE_LIST_COMPONENT_CONFIGURATION_TEMPLATE, DEFAULT_DBX_WEB_FILE_PREVIEW_SERVICE_DIALOG_WITH_COMPONENT_FUNCTION, DEFAULT_DBX_WEB_FILE_PREVIEW_SERVICE_PREVIEW_COMPONENT_FUNCTION, DEFAULT_ERROR_POPOVER_KEY, DEFAULT_ERROR_WIDGET_CODE, DEFAULT_FILTER_POPOVER_KEY, DEFAULT_IMAGE_BITMAP_TO_BLOB_ENCODER, DEFAULT_IMAGE_JPEG_QUALITY, DEFAULT_LIST_GRID_SIZE_CONFIG, DEFAULT_LIST_WRAPPER_COMPONENT_CONFIGURATION_TEMPLATE, DEFAULT_LOADING_PROGRESS_DIAMETER, DEFAULT_PDF_MERGE_ACCEPT, DEFAULT_PDF_MERGE_PAGE_GROUP_KEY, DEFAULT_SCREEN_MEDIA_SERVICE_CONFIG, DEFAULT_SNACKBAR_DIRECTIVE_DURATION, DEFAULT_TWO_COLUMNS_MIN_RIGHT_WIDTH, DEFAULT_VALUE_LIST_VIEW_CONTENT_COMPONENT_TRACK_BY_FUNCTION, DbxAccordionHeaderHeightDirective, DbxActionConfirmDirective, DbxActionDialogDirective, DbxActionErrorDirective, DbxActionKeyTriggerDirective, DbxActionLoadingContextDirective, DbxActionModule, DbxActionPopoverDirective, DbxActionSnackbarComponent, DbxActionSnackbarDirective, DbxActionSnackbarErrorDirective, DbxActionSnackbarModule, DbxActionSnackbarService, DbxActionTransitionSafetyDirective, DbxActionUIRouterTransitionSafetyDialogComponent, DbxAnchorComponent, DbxAnchorContentComponent, DbxAnchorIconComponent, DbxAnchorListComponent, DbxAngularRouterSegueAnchorComponent, DbxAvatarComponent, DbxAvatarViewComponent, DbxAvatarViewService, DbxAvatarViewServiceConfig, DbxBarDirective, DbxBarHeaderComponent, DbxBarLayoutModule, DbxBasicLoadingComponent, DbxBodyDirective, DbxButtonComponent, DbxButtonModule, DbxButtonSpacerDirective, DbxCardBoxComponent, DbxCardBoxContainerDirective, DbxCardBoxLayoutModule, DbxChipDirective, DbxChipListComponent, DbxClickToCopyTextComponent, DbxClickToCopyTextDirective, DbxColorDirective, DbxColorService, DbxColorServiceConfig, DbxColumnLayoutModule, DbxCompactDirective, DbxCompactLayoutModule, DbxContentBorderDirective, DbxContentBoxDirective, DbxContentContainerDirective, DbxContentDirective, DbxContentElevateDirective, DbxContentLayoutModule, DbxContentPageDirective, DbxContentPitDirective, DbxDetachContentComponent, DbxDetachControlButtonsComponent, DbxDetachController, DbxDetachControlsComponent, DbxDetachInitDirective, DbxDetachInteractionModule, DbxDetachOutletComponent, DbxDetachOverlayComponent, DbxDetachService, DbxDetachWindowState, DbxDetailBlockComponent, DbxDetailBlockHeaderComponent, DbxDialogContentCloseComponent, DbxDialogContentDirective, DbxDialogContentFooterComponent, DbxDialogInteractionModule, DbxDialogModule, DbxDownloadBlobButtonComponent, DbxDownloadTextViewComponent, DbxEmbedComponent, DbxErrorComponent, DbxErrorDefaultErrorWidgetComponent, DbxErrorDetailsComponent, DbxErrorPopoverComponent, DbxErrorSnackbarComponent, DbxErrorSnackbarService, DbxErrorViewComponent, DbxErrorWidgetService, DbxErrorWidgetViewComponent, DbxFileUploadActionCompatable, DbxFileUploadActionSyncDirective, DbxFileUploadAreaComponent, DbxFileUploadButtonComponent, DbxFileUploadComponent, DbxFilterInteractionModule, DbxFilterPopoverButtonComponent, DbxFilterPopoverComponent, DbxFilterWrapperComponent, DbxFlagComponent, DbxFlagLayoutModule, DbxFlagPromptComponent, DbxFlexGroupDirective, DbxFlexLayoutModule, DbxFlexSizeDirective, DbxHelpContextDirective, DbxHelpContextService, DbxHelpViewListComponent, DbxHelpViewListEntryComponent, DbxHelpViewPopoverButtonComponent, DbxHelpViewPopoverComponent, DbxHelpWidgetService, DbxHelpWidgetServiceConfig, DbxIconButtonComponent, DbxIconButtonModule, DbxIconItemComponent, DbxIconSpacerDirective, DbxIconTileComponent, DbxIconTileDirective, DbxIfSidenavDisplayModeDirective, DbxIframeComponent, DbxInjectionDialogComponent, DbxInteractionModule, DbxIntroActionSectionComponent, DbxLabelBlockComponent, DbxLayoutModule, DbxLinkComponent, DbxLinkifyComponent, DbxLinkifyService, DbxLinkifyServiceConfig, DbxListAccordionViewComponentImportsModule, DbxListComponent, DbxListEmptyContentComponent, DbxListGridViewComponentImportsModule, DbxListInternalContentDirective, DbxListItemAnchorModifierDirective, DbxListItemDisableRippleModifierDirective, DbxListItemIsSelectedModifierDirective, DbxListModifierModule, DbxListModule, DbxListTitleGroupDirective, DbxListView, DbxListViewMetaIconComponent, DbxListViewWrapper, DbxListWrapperComponentImportsModule, DbxLoadingComponent, DbxLoadingErrorDirective, DbxLoadingModule, DbxLoadingProgressComponent, DbxModelObjectStateService, actions as DbxModelStateActions, model_actions as DbxModelStateModelActions, DbxModelTrackerService, DbxModelTypesService, DbxModelViewTrackerStorage, DbxNavbarComponent, DbxNumberWithLimitComponent, DbxOneColumnComponent, DbxOneColumnLayoutModule, DbxPagebarComponent, DbxPartialPresetFilterListComponent, DbxPartialPresetFilterMenuComponent, DbxPdfMergeEditorComponent, DbxPdfMergeEditorFileUploadComponent, DbxPdfMergeEditorFileUploadHasStateDirective, DbxPdfMergeEditorFileUploadValidatorDirective, DbxPdfMergeEditorStore, DbxPdfMergeEditorStoreDirective, DbxPdfMergeEntryComponent, DbxPdfMergeImportComponent, DbxPdfMergeListComponent, DbxPdfMergePageComponent, DbxPdfMergePageListComponent, DbxPdfMergeUploadActionDirective, DbxPdfMergeUploadButtonDirective, DbxPdfMergeUploadDialogComponent, DbxPdfPreviewComponent, DbxPopoverCloseButtonComponent, DbxPopoverComponent, DbxPopoverComponentController, DbxPopoverContentComponent, DbxPopoverController, DbxPopoverControlsDirective, DbxPopoverCoordinatorComponent, DbxPopoverCoordinatorService, DbxPopoverHeaderComponent, DbxPopoverInteractionContentModule, DbxPopoverInteractionModule, DbxPopoverScrollContentDirective, DbxPopoverService, DbxPopupComponent, DbxPopupComponentController, DbxPopupContentComponent, DbxPopupControlButtonsComponent, DbxPopupController, DbxPopupControlsComponent, DbxPopupCoordinatorComponent, DbxPopupCoordinatorService, DbxPopupInteractionModule, DbxPopupService, DbxPopupWindowState, DbxPresetFilterListComponent, DbxPresetFilterMenuComponent, DbxProgressBarButtonComponent, DbxProgressButtonsModule, DbxProgressSpinnerButtonComponent, DbxPromptBoxDirective, DbxPromptComponent, DbxPromptConfirm, DbxPromptConfirmButtonDirective, DbxPromptConfirmComponent, DbxPromptConfirmDialogComponent, DbxPromptConfirmDirective, DbxPromptModule, DbxPromptPageComponent, DbxReadableErrorModule, DbxResizedDirective, DbxRouterAnchorModule, DbxRouterLayoutModule, DbxRouterSidenavModule, DbxRouterWebProviderConfig, DbxScreenMediaService, DbxScreenMediaServiceConfig, DbxSectionComponent, DbxSectionHeaderComponent, DbxSectionLayoutModule, DbxSectionPageComponent, DbxSelectionValueListViewComponent, DbxSelectionValueListViewComponentImportsModule, DbxSelectionValueListViewContentComponent, DbxSetStyleDirective, DbxSidenavButtonComponent, DbxSidenavComponent, DbxSidenavPageComponent, DbxSidenavPagebarComponent, DbxSpacerDirective, DbxStepBlockComponent, DbxStructureDirective, DbxStructureModule, DbxStyleBodyDirective, DbxStyleDirective, DbxStyleLayoutModule, DbxStyleService, DbxSubSectionComponent, DbxTextChipsComponent, DbxTextColorDirective, DbxTextModule, DbxTwoBlockComponent, DbxTwoColumnBackDirective, DbxTwoColumnColumnHeadDirective, DbxTwoColumnComponent, DbxTwoColumnContextDirective, DbxTwoColumnFullLeftDirective, DbxTwoColumnLayoutModule, DbxTwoColumnRightComponent, DbxTwoColumnSrefDirective, DbxTwoColumnSrefShowRightDirective, DbxUIRouterSegueAnchorComponent, DbxUnitedStatesAddressComponent, DbxValueListAccordionViewComponent, DbxValueListAccordionViewContentComponent, DbxValueListAccordionViewContentGroupComponent, DbxValueListGridSizeDirective, DbxValueListGridViewComponent, DbxValueListGridViewContentComponent, DbxValueListGridViewContentGroupComponent, DbxValueListItemModifier, DbxValueListItemModifierDirective, DbxValueListView, DbxValueListViewComponent, DbxValueListViewComponentImportsModule, DbxValueListViewContentComponent, DbxValueListViewContentGroupComponent, DbxValueListViewGroupDelegate, DbxWebFilePreviewComponent, DbxWebFilePreviewService, DbxWebModule, DbxWebPageTitleInfoDirective, DbxWebPageTitleService, DbxWidgetListGridComponent, DbxWidgetListGridViewComponent, DbxWidgetListGridViewItemComponent, DbxWidgetService, DbxWidgetViewComponent, DbxWindowKeyDownListenerDirective, DbxZipBlobPreviewComponent, DbxZipPreviewComponent, PDF_MERGE_PAGE_ID_SEPARATOR, PDF_MERGE_PAGE_TAG_KEY, PDF_MERGE_RESULT_MIME_TYPE, PDF_MERGE_SIDECAR_DESCRIPTION, PDF_MERGE_SIDECAR_FILE_NAME, PDF_MERGE_SIDECAR_VERSION, PopoverPositionStrategy, PopupGlobalPositionStrategy, SCREEN_MEDIA_WIDTH_TYPE_SIZE_MAP, SIDE_NAV_DISPLAY_MODE_ORDER, SideNavDisplayMode, TRACK_BY_MODEL_ID, TRACK_BY_MODEL_KEY, TwoColumnsContextStore, UNKNOWN_ERROR_WIDGET_CODE, addConfigToValueListItems, allDbxModelViewTrackerEventModelKeys, allDbxModelViewTrackerEventSetModelKeys, asPdfMergeFile, attachPdfMergeSidecar, buildPdfMergeEntriesFromSidecar, buildPdfMergeEntry, buildPdfMergeEntrySync, buildPdfMergePagePlan, catchErrorServerParams, classifyPdfMergeFile, compactModeFromInput, compareScreenMediaWidthTypes, compressImageFile, convertServerErrorParams, convertToPOJOServerErrorResponse, convertToServerErrorResponse, copyToClipboardFunction, dbxColorBackground, dbxCuratedColorConfigForString, dbxListAccordionViewComponentImportsAndExports, dbxListGridViewComponentImportsAndExports, dbxPresetFilterMenuButtonIconObservable, dbxPresetFilterMenuButtonTextObservable, dbxStyleClassCleanSuffix, dbxThemeColorCssToken, dbxThemeColorCssTokenVar, dbxThemeColorCssVariable, dbxThemeColorCssVariableVar, dbxValueListItemDecisionFunction, dbxValueListItemKeyForItemValue, dbxWebDefaultPageTitleDelegate, dbxZipBlobPreviewEntryTreeFromEntries, defaultDbxModelViewTrackerStorageAccessorFactory, defaultDbxValueListViewGroupDelegate, defaultDbxValueListViewGroupValuesFunction, disableRightClickInCdkBackdrop, entryIdForPdfMergePageId, fileAcceptFilterTypeStringArray, fileAcceptFunction, fileAcceptString, fileArrayAcceptMatchFunction, flattenAccordionGroups, formatPdfMergeEntrySize, index as fromDbxModel, injectCopyToClipboardFunction, injectCopyToClipboardFunctionWithSnackbarMessage, isDbxColorConfig, listItemModifier, makeDbxActionSnackbarDisplayConfigGeneratorFunction, makePdfMergePageId, makePdfMergeSidecar, makePdfMergeSidecarPageTag, mapCompactModeObs, mapValuesToValuesListItemConfigObs, mergePdfMergeEntries, index$1 as onDbxModel, openEmbedDialog, openIframeDialog, openPdfPreviewDialog, openZipPreviewDialog, overrideClickElementEffect, pdfMergePageGroupKeyForSlotId, provideDbxDetachController, provideDbxFileUploadActionCompatable, provideDbxHelpServices, provideDbxLinkify, provideDbxListView, provideDbxListViewWrapper, provideDbxModelService, provideDbxPdfMergeEditorConfig, provideDbxPdfMergeEditorPreserveEntriesOnSlotDestroy, provideDbxProgressButtonGlobalConfig, provideDbxPromptConfirm, provideDbxRouterWebAngularRouterProviderConfig, provideDbxRouterWebUiRouterProviderConfig, provideDbxScreenMediaService, provideDbxStyleService, provideDbxValueListView, provideDbxValueListViewGroupDelegate, provideDbxValueListViewModifier, provideDbxWebFilePreviewServiceEntries, provideDbxWebPageTitleService, provideTwoColumnsContext, readPdfMergeEntryPageMetas, readPdfMergePageTag, readPdfMergeSidecar, registerHelpContextKeysWithDbxHelpContextService, resizeSignal, resolveSideNavDisplayMode, sanitizeDbxDialogContentConfig, screenMediaWidthTypeIsActive, splitPdfMergeSidecarDocuments, trackByModelKeyRef, trackByUniqueIdentifier, validatePdfMergeEntry, writePdfMergePageTag };
 //# sourceMappingURL=dereekb-dbx-web.mjs.map