@doccloak/core 0.9.0 → 0.11.0

package/CHANGELOG.md

@@ -4,6 +4,90 @@ All notable changes to `@doccloak/core` are documented here. The format is
 based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the
 project follows [Semantic Versioning](https://semver.org/).
 
+## [0.11.0] - 2026-09-23
+
+### Changed
+
+- **Variant-faithful restore (T171):** person variants still share one
+  identity, but every distinct variant now gets its own token, so
+  `deanonymize` writes back exactly what was there instead of the longest
+  known form. In labeled mode the token keeps the group's number and adds
+  a positional suffix: `[PERSON_2]` for "John Smith", `[PERSON_2_LAST]`
+  for "Smith", `[PERSON_2_FIRST]` for "John", `_MIDDLE` / `_SHORT` /
+  `_FULL` / `_ALT` for the other shapes, with a counter on collisions
+  (`[PERSON_2_LAST_2]` for "smith"). In surrogate mode a variant that is a
+  strict part of the canonical name takes the matching words of the
+  surrogate with the variant's casing ("Smith" -> "Nowak", "smith" ->
+  "nowak"); fuller forms and reshaped surrogates fall back to the group
+  surrogate as before. Blanked mode is unchanged. The tolerant restore
+  pass resolves mangled variant tokens like any other.
+- **PERSON pre-pass in `anonymizeText`:** people are mapped before other
+  entities, fullest name first and then in reading order, so a variant
+  group always forms around the full name and several people are numbered
+  in the order they appear (`[PERSON_1]` is now the first person in the
+  text; other entity types keep their historical numbering order).
+- **`renameLabel` returns the applied `[oldLabel, newLabel]` pairs** (was
+  `void`). Renaming a group's base token re-derives its variant tokens
+  (`[PERSON_1]` -> `[CLIENT]` takes `[PERSON_1_LAST]` to `[CLIENT_LAST]`);
+  renaming a variant token renames only that token and detaches it from
+  the group.
+- `deserialize` / `importEntries` re-link variant tokens to their base and
+  keep legacy many-to-one maps restoring the longest variant.
+
+### Fixed
+
+- **Office value scrubbing applies longer values first and sees URL-encoded
+  forms:** hyperlink targets, field instructions and formula literals in
+  .docx / .xlsx exports are scrubbed with the longest sensitive value first,
+  so a name variant listed before the full name ("Kowalski" before
+  "Jan Kowalski") no longer leaves "Jan" behind. External relationship
+  targets also match the percent-encoded form of each value, so
+  "Jan%20Kowalski" in a link is removed as a whole. `.docx` and `.xlsx`
+  writers now share one `replaceSensitiveValues` implementation.
+
+## [0.10.0] - 2026-09-23
+
+### Added
+
+- **GLiNER PII Base provider (T122):** new `gliner-base` provider for
+  `knowledgator/gliner-pii-base-v1.0` (~197 MB quint8, Apache-2.0,
+  pinned revision + SHA-256). Span-level (`markerV0`) decoding with
+  zero-shot custom labels; strongest option for English and dates.
+  Exported as `GlinerBaseProvider` plus `GLINER_BASE_MODEL_URL` /
+  `_REVISION` / `_SHA256`, `buildSpanIndices` and `decodeSpanLogits`.
+  `ProviderId` now includes `'gliner-base'` and `createEngine` registers it.
+
+- **Office file redaction (T110):** `@doccloak/core/dom` gains
+  `readXlsx` / `writeAnonymizedXlsx` / `isExcelFile` and a
+  detection-driven `redactOfficeFile` / `analyzeOfficeFile` flow for
+  .docx and .xlsx that keeps placeholders consistent with a live
+  `AnonymizationSession`. `writeAnonymizedDocx` accepts an option to
+  accept tracked changes (deletions dropped, insertions unwrapped,
+  author/date change records removed). Defaults preserve the previous
+  output byte-for-byte.
+
+### Changed
+
+- **Light model swapped (T121):** the `gliner` provider now loads
+  `knowledgator/gliner-pii-small-v1.0` (~83 MB, same tokenizer family)
+  instead of `gliner-pii-edge-v1.0`. Cached copies of the old edge model
+  are evicted best-effort on load. Labels read "GLiNER PII Small".
+
+- **Provider descriptions (T127):** registry copy reflects the 2026-08
+  14-language benchmark. `pickDefaultProvider` is unchanged: `bardsai` on
+  capable devices, `gliner` on mobile / low-memory devices.
+
+- **ONNX Runtime 1.29.0:** providers import `onnxruntime-web/webgpu`
+  (native WebGPU EP with wasm fallback). Hosts that self-host the ORT
+  runtime files must now serve `ort-wasm-simd-threaded.asyncify.wasm`
+  and `.asyncify.mjs` instead of the plain / `.jsep` pair.
+
+### Fixed
+
+- **bardsai with transformers.js 4.x:** subtoken alignment no longer calls
+  the removed `tokenizer.model.convert_ids_to_tokens` (which made
+  detection throw on transformers.js 4); it uses `tokenizer.tokenize()`.
+
 ## [0.9.0] - 2026-08-21
 
 ### Added

package/dist/dom/docx.d.ts

@@ -13,8 +13,10 @@ export { normalizeReplacements };
 export type { ValueReplacement };
 /**
  * Represents a text node in the docx XML with its position in the flat text.
+ * Also reused by the xlsx module (T110): the same flat-text replacement
+ * machinery applies to any XML part whose text lives in leaf elements.
  */
-interface TextNodeMapping {
+export interface TextNodeMapping {
     /** The <w:t> element */
     element: Element;
     /** Start index in the flat text */
@@ -59,6 +61,31 @@ interface ContentPartExtraction {
  * Read a .docx file and extract its text content with position mapping.
  */
 export declare function readDocx(file: File): Promise<DocxExtraction>;
+/**
+ * Options for writeAnonymizedDocx (T110). All default to off, preserving the
+ * historical output byte-for-byte for existing callers.
+ */
+export interface DocxWriteOptions {
+    /**
+     * Accept and remove tracked changes: deletions (w:del and friends) are
+     * dropped, insertions (w:ins, w:moveTo) are unwrapped into plain runs, and
+     * property-change records (w:rPrChange etc., which carry author and date
+     * fingerprints) are removed. Oregon SB 2025-205 flags revision metadata as
+     * identifying, so the file-redaction flow turns this on.
+     */
+    acceptTrackedChanges?: boolean;
+}
+/**
+ * Apply a list of flat-text replacements to mapped text nodes, handling
+ * replacements that span multiple elements. Ranges are normalized (sorted,
+ * overlaps clamped) and applied end-to-start so earlier positions stay valid.
+ * Shared by the docx and xlsx writers (T110).
+ */
+export declare function applyTextReplacements(textNodes: TextNodeMapping[], replacements: Array<{
+    start: number;
+    end: number;
+    replacement: string;
+}>): void;
 /**
  * Apply text replacements to the docx XML, preserving all formatting.
  * Takes the original extraction and a list of replacements (sorted by position),
@@ -71,7 +98,7 @@ export declare function writeAnonymizedDocx(extraction: DocxExtraction, replacem
     start: number;
     end: number;
     replacement: string;
-}>, valueReplacements?: ValueReplacement[]): Promise<Blob>;
+}>, valueReplacements?: ValueReplacement[], options?: DocxWriteOptions): Promise<Blob>;
 /**
  * Get the file extension from a filename.
  */

package/dist/dom/docx.js

@@ -8,6 +8,7 @@
  */
 import JSZip from 'jszip';
 import { normalizeReplacements } from "../docx.js";
+import { replaceSensitiveValues } from "./opc.js";
 export { normalizeReplacements };
 const W_NS = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 /**
@@ -153,6 +154,63 @@ export async function readDocx(file) {
         contentParts,
     };
 }
+/**
+ * Apply a list of flat-text replacements to mapped text nodes, handling
+ * replacements that span multiple elements. Ranges are normalized (sorted,
+ * overlaps clamped) and applied end-to-start so earlier positions stay valid.
+ * Shared by the docx and xlsx writers (T110).
+ */
+export function applyTextReplacements(textNodes, replacements) {
+    const sorted = normalizeReplacements(replacements);
+    for (const repl of [...sorted].reverse()) {
+        applyReplacement(textNodes, repl.start, repl.end, repl.replacement);
+    }
+}
+/**
+ * Tracked-change elements that are removed outright when accepting changes:
+ * deleted content, move sources, and every *PrChange record (each carries a
+ * w:author/w:date pair identifying the reviser).
+ */
+const TRACKED_REMOVE = new Set([
+    'del', 'moveFrom', 'delText', 'delInstrText',
+    'rPrChange', 'pPrChange', 'sectPrChange', 'tblPrChange', 'tblGridChange',
+    'tcPrChange', 'trPrChange', 'numberingChange',
+    'cellDel', 'cellIns', 'cellMerge',
+    'moveFromRangeStart', 'moveFromRangeEnd', 'moveToRangeStart', 'moveToRangeEnd',
+    'customXmlDelRangeStart', 'customXmlDelRangeEnd',
+    'customXmlInsRangeStart', 'customXmlInsRangeEnd',
+    'customXmlMoveFromRangeStart', 'customXmlMoveFromRangeEnd',
+    'customXmlMoveToRangeStart', 'customXmlMoveToRangeEnd',
+]);
+/** Tracked-change wrappers whose content is kept: the wrapper is unwrapped. */
+const TRACKED_UNWRAP = new Set(['ins', 'moveTo']);
+/**
+ * Accept all tracked changes in one content part: remove deletions and
+ * change records, unwrap insertions. Operates on the live DOM after text
+ * replacements have been applied, so redaction offsets are unaffected.
+ */
+function acceptTrackedChangesInPart(xmlDoc) {
+    // Snapshot first: live HTMLCollections reorder while elements are removed.
+    const all = xmlDoc.getElementsByTagName('*');
+    const snapshot = [];
+    for (let i = 0; i < all.length; i++)
+        snapshot.push(all[i]);
+    for (const el of snapshot) {
+        if (el.namespaceURI !== W_NS)
+            continue;
+        if (TRACKED_REMOVE.has(el.localName)) {
+            el.parentNode?.removeChild(el);
+        }
+        else if (TRACKED_UNWRAP.has(el.localName)) {
+            const parent = el.parentNode;
+            if (!parent)
+                continue;
+            while (el.firstChild)
+                parent.insertBefore(el.firstChild, el);
+            parent.removeChild(el);
+        }
+    }
+}
 /**
  * Apply text replacements to the docx XML, preserving all formatting.
  * Takes the original extraction and a list of replacements (sorted by position),
@@ -161,20 +219,17 @@ export async function readDocx(file) {
  *
  * Returns a new .docx file as a Blob.
  */
-export async function writeAnonymizedDocx(extraction, replacements, valueReplacements = []) {
-    const sorted = normalizeReplacements(replacements);
-    // For each text node, compute what its new text should be
-    // We need to handle replacements that may span multiple <w:t> elements
-    // Build a map of flat-text ranges that need replacement
-    // Process from end to start to preserve positions
-    const reverseSorted = [...sorted].reverse();
-    for (const repl of reverseSorted) {
-        applyReplacement(extraction.textNodes, repl.start, repl.end, repl.replacement);
-    }
+export async function writeAnonymizedDocx(extraction, replacements, valueReplacements = [], options = {}) {
+    // Apply flat-text replacements to the mapped text nodes (spanning runs when
+    // needed), from end to start so positions stay valid.
+    applyTextReplacements(extraction.textNodes, replacements);
     // Serialize all modified XML documents back to the zip
     const serializer = new XMLSerializer();
     for (const part of extraction.contentParts) {
         sanitizeContentPartAttributes(part.xmlDoc, valueReplacements);
+        if (options.acceptTrackedChanges) {
+            acceptTrackedChangesInPart(part.xmlDoc);
+        }
         const xmlStr = serializer.serializeToString(part.xmlDoc);
         extraction.zip.file(part.path, xmlStr);
     }
@@ -201,7 +256,7 @@ function sanitizeContentPartAttributes(xmlDoc, valueReplacements) {
                 attr.value = 'R';
             }
             else if (attr.localName === 'instr') {
-                attr.value = replaceValues(attr.value, valueReplacements, false);
+                attr.value = replaceSensitiveValues(attr.value, valueReplacements, false);
             }
         }
         if (el.localName === 'docPr' || el.localName === 'cNvPr') {
@@ -214,21 +269,6 @@ function sanitizeContentPartAttributes(xmlDoc, valueReplacements) {
         }
     }
 }
-/**
- * Replace every occurrence of each sensitive value (case-insensitive) in a string.
- * Uses a replacer function so '$' sequences in values or placeholders are inert.
- */
-function replaceValues(input, valueReplacements, urlEncode) {
-    let result = input;
-    for (const { value, replacement } of valueReplacements) {
-        if (!value)
-            continue;
-        const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const substitute = urlEncode ? encodeURIComponent(replacement) : replacement;
-        result = result.replace(new RegExp(escaped, 'gi'), () => substitute);
-    }
-    return result;
-}
 /**
  * Scrub metadata parts of the package that survive text replacement untouched:
  * document properties, comment author registry, revision fingerprints,
@@ -329,7 +369,7 @@ async function sanitizeDocxMetadata(zip, valueReplacements) {
             }
             if (rel.getAttribute('TargetMode') === 'External') {
                 const target = rel.getAttribute('Target') ?? '';
-                const scrubbed = replaceValues(target, valueReplacements, true);
+                const scrubbed = replaceSensitiveValues(target, valueReplacements, true);
                 if (scrubbed !== target)
                     rel.setAttribute('Target', scrubbed);
             }

package/dist/dom/index.d.ts

@@ -9,3 +9,5 @@
  */
 export * from './docx.js';
 export * from './ocr.js';
+export * from './xlsx.js';
+export * from './office.js';

package/dist/dom/index.js

@@ -9,3 +9,6 @@
  */
 export * from "./docx.js";
 export * from "./ocr.js";
+// T110: xlsx + detection-driven office file redaction
+export * from "./xlsx.js";
+export * from "./office.js";

package/dist/dom/office.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @doccloak/core/dom - detection-driven office file redaction (T110).
+ *
+ * Ties the format modules (docx.ts, xlsx.ts) to the detection pipeline and an
+ * AnonymizationSession, so a host can hand over a File plus its live session
+ * and get back a redacted copy whose placeholders are consistent with every
+ * prompt redacted in the same session: an AI reply that mentions the file's
+ * placeholders restores through the same session map.
+ *
+ * PDF is intentionally NOT handled here: layout-preserving PDF redaction is
+ * out of scope for this module.
+ */
+import type { DetectedEntity } from '../types.js';
+import type { AnonymizationSession } from '../session.js';
+/** File kinds the office redaction flow can regenerate. */
+export type OfficeFileKind = 'docx' | 'xlsx';
+/**
+ * Classify a filename into a supported office kind, or null when the format
+ * cannot be regenerated by this module (.doc has its own binary writer in
+ * src/doc.ts; PDF output is permanently out of scope for browser hosts).
+ */
+export declare function officeFileKind(filename: string): OfficeFileKind | null;
+/** A detect function, typically DocCloakEngine.detect or detectEntities. */
+export type DetectFn = (text: string) => Promise<DetectedEntity[]>;
+export interface OfficeAnalysis {
+    kind: OfficeFileKind;
+    /** Flat text extracted from every text-bearing part of the package */
+    plainText: string;
+    /** Entities detected in the flat text (offsets refer to plainText) */
+    entities: DetectedEntity[];
+}
+/**
+ * Extract a file's text and run detection WITHOUT touching the session. Hosts
+ * use this to show the user what was found before asking for consent to
+ * regenerate; a cancelled upload then leaves no trace in the session map.
+ * Extraction is deterministic, so entities returned here can be passed to
+ * redactOfficeFile later and land on identical offsets.
+ */
+export declare function analyzeOfficeFile(file: File, detect: DetectFn): Promise<OfficeAnalysis>;
+export interface RedactOfficeFileOptions {
+    /** The live session; file placeholders join the same map as prompt ones. */
+    session: AnonymizationSession;
+    /**
+     * Entities to redact, from a prior analyzeOfficeFile call (offsets refer to
+     * that call's plainText). When omitted, detect is required and is run here.
+     */
+    entities?: DetectedEntity[];
+    /** Detect function; used only when entities were not supplied. */
+    detect?: DetectFn;
+    /** Accept and strip tracked changes in docx output. Default: true. */
+    acceptTrackedChanges?: boolean;
+}
+export interface OfficeRedactionResult {
+    kind: OfficeFileKind;
+    /** The redacted file; the input file/buffer is never modified. */
+    blob: Blob;
+    /** Suggested output name: "report.docx" becomes "report.redacted.docx". */
+    suggestedName: string;
+    /** The entities that were redacted (offsets refer to plainText) */
+    entities: DetectedEntity[];
+    /** Flat text the detection ran on */
+    plainText: string;
+    /** The redacted flat text (placeholders applied), for preview UIs */
+    redactedText: string;
+}
+/** "report.docx" -> "report.redacted.docx"; extensionless names get a suffix. */
+export declare function redactedFileName(filename: string): string;
+/**
+ * Redact a DOCX or XLSX file: extract text, detect (or reuse supplied
+ * entities), map every entity through the session, and regenerate the file
+ * with placeholders spliced into the XML, formatting preserved and metadata
+ * stripped. Placeholder issuing goes through session.anonymize, so a value
+ * already seen in a prompt reuses its existing placeholder and vice versa.
+ */
+export declare function redactOfficeFile(file: File, options: RedactOfficeFileOptions): Promise<OfficeRedactionResult>;

package/dist/dom/office.js

@@ -0,0 +1,116 @@
+/**
+ * @doccloak/core/dom - detection-driven office file redaction (T110).
+ *
+ * Ties the format modules (docx.ts, xlsx.ts) to the detection pipeline and an
+ * AnonymizationSession, so a host can hand over a File plus its live session
+ * and get back a redacted copy whose placeholders are consistent with every
+ * prompt redacted in the same session: an AI reply that mentions the file's
+ * placeholders restores through the same session map.
+ *
+ * PDF is intentionally NOT handled here: layout-preserving PDF redaction is
+ * out of scope for this module.
+ */
+import { getFileExtension, readDocx, writeAnonymizedDocx } from "./docx.js";
+import { readXlsx, writeAnonymizedXlsx } from "./xlsx.js";
+/**
+ * Classify a filename into a supported office kind, or null when the format
+ * cannot be regenerated by this module (.doc has its own binary writer in
+ * src/doc.ts; PDF output is permanently out of scope for browser hosts).
+ */
+export function officeFileKind(filename) {
+    const ext = getFileExtension(filename);
+    if (ext === 'docx')
+        return 'docx';
+    if (ext === 'xlsx')
+        return 'xlsx';
+    return null;
+}
+/**
+ * Extract a file's text and run detection WITHOUT touching the session. Hosts
+ * use this to show the user what was found before asking for consent to
+ * regenerate; a cancelled upload then leaves no trace in the session map.
+ * Extraction is deterministic, so entities returned here can be passed to
+ * redactOfficeFile later and land on identical offsets.
+ */
+export async function analyzeOfficeFile(file, detect) {
+    const kind = officeFileKind(file.name);
+    if (!kind)
+        throw new Error(`Unsupported office file: ${file.name}`);
+    const plainText = kind === 'docx'
+        ? (await readDocx(file)).plainText
+        : (await readXlsx(file)).plainText;
+    const entities = await detect(plainText);
+    return { kind, plainText, entities };
+}
+/** "report.docx" -> "report.redacted.docx"; extensionless names get a suffix. */
+export function redactedFileName(filename) {
+    const dot = filename.lastIndexOf('.');
+    if (dot <= 0)
+        return `${filename}.redacted`;
+    return `${filename.slice(0, dot)}.redacted${filename.slice(dot)}`;
+}
+/**
+ * Redact a DOCX or XLSX file: extract text, detect (or reuse supplied
+ * entities), map every entity through the session, and regenerate the file
+ * with placeholders spliced into the XML, formatting preserved and metadata
+ * stripped. Placeholder issuing goes through session.anonymize, so a value
+ * already seen in a prompt reuses its existing placeholder and vice versa.
+ */
+export async function redactOfficeFile(file, options) {
+    const kind = officeFileKind(file.name);
+    if (!kind)
+        throw new Error(`Unsupported office file: ${file.name}`);
+    const extraction = kind === 'docx' ? await readDocx(file) : await readXlsx(file);
+    const plainText = extraction.plainText;
+    let entities = options.entities;
+    if (!entities) {
+        if (!options.detect) {
+            throw new Error('redactOfficeFile requires either entities or a detect function');
+        }
+        entities = await options.detect(plainText);
+    }
+    const { session } = options;
+    // Drop entities whose offsets do not match this extraction (defensive: a
+    // stale analysis of a different file must not splice garbage), then map
+    // through the session in reading order. Surrogate mode maps PERSON values
+    // first, mirroring AnonymizationSession.anonymizeText, so derived
+    // surrogates (emails from owner names) stay consistent with prompts.
+    const valid = entities
+        .filter((e) => e.start >= 0 && e.end <= plainText.length && e.start < e.end
+        && plainText.slice(e.start, e.end) === e.value)
+        .sort((a, b) => a.start - b.start || a.end - b.end);
+    if (session.getMode() === 'surrogate') {
+        for (const entity of valid) {
+            if (entity.type === 'PERSON')
+                session.anonymize(entity.value, entity.type);
+        }
+    }
+    const replacements = valid.map((entity) => ({
+        start: entity.start,
+        end: entity.end,
+        replacement: session.anonymize(entity.value, entity.type),
+    }));
+    // Value-level scrubbing (relationship targets, formulas, field instructions)
+    // uses the whole session map, so a value redacted in an earlier prompt is
+    // also caught when it hides in a hyperlink target of this file.
+    const valueReplacements = session.getEntries()
+        .filter((entry) => entry.replacement !== '________')
+        .map((entry) => ({ value: entry.original, replacement: entry.replacement }));
+    let redactedText = plainText;
+    for (const repl of [...replacements].sort((a, b) => b.start - a.start)) {
+        redactedText = redactedText.slice(0, repl.start) + repl.replacement + redactedText.slice(repl.end);
+    }
+    const blob = kind === 'docx'
+        ? await writeAnonymizedDocx(extraction, replacements, valueReplacements, {
+            acceptTrackedChanges: options.acceptTrackedChanges ?? true,
+        })
+        : await writeAnonymizedXlsx(extraction, replacements, valueReplacements);
+    return {
+        kind,
+        blob,
+        suggestedName: redactedFileName(file.name),
+        entities: valid,
+        plainText,
+        redactedText,
+    };
+}

package/dist/dom/opc.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @doccloak/core/dom - shared OPC (Open Packaging Conventions) helpers (T110).
+ *
+ * Both .docx and .xlsx are OPC packages: a zip with XML parts, docProps
+ * metadata, relationship files and an optional thumbnail. The metadata
+ * scrubbing that is format-independent lives here so the xlsx module does not
+ * duplicate the docx module's logic. The docx module keeps its historical
+ * implementation untouched (behavior-preservation for existing callers); new
+ * code paths use these helpers.
+ */
+import type JSZip from 'jszip';
+import type { ValueReplacement } from '../docx.js';
+/** Parse one XML part from the zip; null when absent or malformed. */
+export declare function readXmlPart(zip: JSZip, path: string): Promise<Document | null>;
+/** Serialize an XML document back into the zip at the given path. */
+export declare function writeXmlPart(zip: JSZip, path: string, doc: Document): void;
+/** Blank the text content of every element whose local name is in the set. */
+export declare function blankElementsByLocalName(doc: Document, names: Set<string>): void;
+/**
+ * Replace every occurrence of each sensitive value (case-insensitive) in a
+ * string. A replacer function keeps '$' sequences in values/placeholders inert.
+ *
+ * Longer values are applied first so a name variant ("Kowalski") can never
+ * pre-empt the fuller form it is part of ("Jan Kowalski") and leave the rest
+ * of it behind. When the input is a URL (urlEncode), the percent-encoded form
+ * of each value is matched too, so "Jan%20Kowalski" in a hyperlink target is
+ * scrubbed as a whole.
+ */
+export declare function replaceSensitiveValues(input: string, valueReplacements: ValueReplacement[], urlEncode: boolean): string;
+/**
+ * Scrub the shared docProps parts:
+ * - core.xml: author identities and content-describing fields
+ * - app.xml: organization and template/path hints
+ * - custom.xml: every leaf value (property names/structure kept)
+ */
+export declare function scrubDocPropsParts(zip: JSZip): Promise<void>;
+/**
+ * Remove the package thumbnail (a rendered image of page/sheet one leaks
+ * content wholesale) together with its package relationship and content-type
+ * override.
+ */
+export declare function removePackageThumbnail(zip: JSZip): Promise<void>;
+/**
+ * Scrub external relationship targets (mailto:/https: hyperlinks keep the raw
+ * sensitive value even when the display text was redacted) in every .rels file
+ * matched by the given pattern.
+ */
+export declare function scrubExternalRelTargets(zip: JSZip, relsPattern: RegExp, valueReplacements: ValueReplacement[]): Promise<void>;