@doccloak/core 0.8.0 → 0.10.0

package/CHANGELOG.md

@@ -4,6 +4,157 @@ 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.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
+
+- **Secrets & credentials detection (T099/T116):** new `SECRET` and
+  `API_KEY` entity types plus eleven universal regex rules covering AWS
+  access keys, GitHub/Slack tokens, OpenAI/Anthropic/Google API keys,
+  PEM private-key blocks, JWTs, connection strings with embedded
+  credentials, `secret=`-style assignments and high-entropy tokens, and
+  a GB driving-licence rule. Credentials never receive realistic
+  stand-ins — even in surrogate mode they always fall back to typed
+  placeholders, since a same-shape fake key still reads as a live
+  credential.
+
+- **Tolerant restore-token matching (T098):** new side-effect-free
+  `@doccloak/core/restore-tokens` export that restores placeholders LLM
+  replies have mangled — case changes (`[person_1]`), separator swaps
+  (`[PERSON 1]`), markdown wrapping (`**[PERSON_1]**`), dropped brackets
+  and stray edge punctuation. Restoration only happens on an unambiguous
+  canonical hit; anything ambiguous is left exactly as the model wrote
+  it, because a wrong restore silently corrupts the document while a
+  missed one is visible and recoverable.
+
+- **Model integrity verification:** `fetchModelBlob` verifies downloads
+  against a pinned SHA-256 when the caller provides one and rejects
+  mismatches with a dedicated `ModelIntegrityError` (the corrupt copy is
+  discarded; verified cache entries carry a marker so they are not
+  re-hashed). The GLiNER and bardsai providers export their pinned
+  `*_MODEL_URL` / `*_MODEL_REVISION` / `*_MODEL_SHA256` constants.
+
+- **Multilingual surrogates (T073):** realistic stand-ins now follow the
+  original's language beyond EN/PL. New locale packs matching every
+  region the web app's language picker offers: German, French, Spanish,
+  Italian, Czech, Ukrainian, Dutch, Portuguese, Swedish, Norwegian,
+  Danish, Finnish, Japanese and Chinese: given-name/surname pools with
+  gender detection and surname feminization (-ova, -ska/-cka), month
+  names for date shifting (genitive forms where dates inflect), street
+  formats (Hauptstrasse 5 / 12 rue des Lilas / Calle del Sol 3 / Via dei
+  Tigli 10 / vul. Zelena 98) and company pools with locale-detecting
+  legal suffixes (GmbH, SARL, S.r.l., s.r.o., TOV) kept verbatim.
+  Locale detection scores name-pool and surname matches per token
+  (shared names like "Marie" resolve to the best-matching language);
+  Cyrillic script resolves decisively. Non-Latin surrogate names fall
+  back to an unrelated ASCII identity in derived email local parts.
+  CJK names compose surname-first without spaces via a per-pack
+  formatPerson hook (Chinese given-name length mirrored; kana decides
+  Japanese, surname-prefix scoring separates kanji-only Japanese from
+  Chinese, a Han script fallback catches unpooled surnames); CJK dates
+  (2024\u5e743\u670815\u65e5) shift in place; Finnish dates keep the partitive.
+  Bare legal suffixes (AB/AS) now require a preceding space, so 'SAAB'
+  never sheds an 'AB'. Adding further locales is data-only (one
+  LocalePack entry).
+
+- **Person-variant unification (T057):** repeated mentions of the same
+  person share one replacement. When a new PERSON value is a name-variant
+  of an already-mapped one (case-insensitive token subset with at least
+  one substantive shared token: "John" and "Smith" both match
+  "John Smith"; "Mr. Smith" and "Person 11" do not), the session reuses
+  its placeholder/surrogate instead of issuing a new one. The reverse map
+  keeps the LONGEST variant, so restore always yields the fullest known
+  form; `renameLabel` renames the whole variant group; `deserialize`
+  keeps the longest variant canonical regardless of entry order.
+
+- **Surrogate replacement mode (T043):** `AnonymizationSession` accepts a
+  new `'surrogate'` mode in which replacements are realistic,
+  shape-preserving stand-ins instead of typed placeholders: locale-aware
+  fake names (EN + PL, gendered Polish surname endings), emails whose
+  local part mirrors the in-session person surrogate on reserved example
+  domains, dates shifted by a per-session day offset while keeping their
+  format, phones/IBANs/IDs/cards that keep their shape (IBAN mod-97,
+  PESEL and Luhn checksums valid; generated PESELs encode a 19th-century
+  birth date and SSN shapes use the never-allocated 900-999 area, so a
+  generated identifier can never be a real living person's). Generation
+  is deterministic per session (seeded by a per-session salt, new
+  `src/surrogates.ts` module) and collision-safe against every original
+  value and every already-issued replacement in the session. The default
+  mode remains `'labeled'` (typed placeholders); restore is unchanged
+  exact-literal lookup. Surrogate-mode `serialize()` wraps the entry
+  array in `{ mode, salt, entries }` so `deserialize()` reproduces the
+  mode and salt; placeholder/blanked sessions keep the plain-array
+  Python-parity schema byte-identically.
+
+### Changed
+
+- **Breaking (user-visible output):** `AnonymizationSession` now generates
+  typed placeholders with per-type counters, e.g. `[PERSON_1]`, `[EMAIL_1]`,
+  `[DATE_2]`, instead of the global `<<REDACTED_N>>`. Typed placeholders
+  keep LLM answers coherent (pronouns, date reasoning, formatting), make
+  protected text human-readable, and avoid the `<<...>>` token that
+  Markdown-rendering chats can mangle. Placeholder type names are the
+  stable uppercase `EntityType` ids, so every generated token matches
+  `\[[A-Z_]+_\d+\]`.
+- Blanked-mode replacements no longer consume counter numbers, so labeled
+  placeholders number contiguously per type.
+- `AnonymizationSession.deserialize` rebuilds the per-type counters from
+  `[TYPE_N]` placeholders in the map, and `anonymize` skips any number
+  already present in the reverse map (renamed labels included), so freshly
+  issued placeholders never collide with restored or renamed ones.
+
+### Backward compatibility
+
+- Restoring is unchanged: `deanonymize` performs exact-literal replacement
+  of whatever placeholder strings the map contains. Maps serialized before
+  0.9.0 (or by the Python CLI's `save_map`) with `<<REDACTED_N>>` tokens
+  still deserialize and restore old-format text byte-identically.
+- The serialization schema (`original` / `replacement` / `entity_type`,
+  Python `save_map` parity) is unchanged.
+
 ## [0.8.0] - 2026-07-27
 
 First public release. The engine was extracted from the DocCloak web app

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

@@ -153,6 +153,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 +218,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);
     }

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,42 @@
+/**
+ * @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.
+ */
+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>;