@patrickdk77/office-defuse 0.2.0 → 0.2.1

package/dist/odf.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntryRules = exports.packagePath = exports.hrefOf = exports.odfNamespace = exports.NS = void 0;
 exports.oattr = oattr;
 exports.folderOf = folderOf;
+exports.nameOdf = nameOdf;
 exports.inspectOdf = inspectOdf;
 const contained_1 = require("./contained");
 const context_1 = require("./context");
@@ -286,12 +287,16 @@ function folderOf(name) {
 }
 /** The most of the mimetype entry that is kept. The longest media type in the table is 56 characters. */
 const MAX_MIMETYPE = 256;
-/** Inspects an OpenDocument package. */
-async function inspectOdf(ctx) {
+/**
+ * Names an OpenDocument package's format by the media type in its mimetype entry or, without one, its manifest's root
+ * entry. Throws when the two name different formats, or the media type is not one this package reads. `layout` hears,
+ * with the entry it concerns, of each way the mimetype entry and the manifest leave the layout OpenDocument asks for.
+ */
+async function nameOdf(ctx, layout = () => undefined) {
     const zip = ctx.zip;
     const mimetype = zip.entries.find(e => e.name === 'mimetype');
     const manifestEntry = zip.get('META-INF/manifest.xml');
-    const layout = (reason) => ctx.report(types_1.OfficeCategory.Package, types_1.OfficeDetail.OdfLayout, mimetype?.name ?? 'META-INF/manifest.xml', { reason });
+    const note = (reason) => layout(mimetype?.name ?? 'META-INF/manifest.xml', reason);
     let declared;
     if (mimetype) {
         let head = Buffer.alloc(0);
@@ -303,28 +308,34 @@ async function inspectOdf(ctx) {
         declared = head.toString('latin1') + (mimetype.size > MAX_MIMETYPE ? '...' : '');
         const first = zip.entries.reduce((a, b) => (b.localOffset < a.localOffset ? b : a));
         if (first !== mimetype)
-            layout('mimetype is not the first entry');
+            note('mimetype is not the first entry');
         if (mimetype.method !== 0)
-            layout('mimetype is compressed');
+            note('mimetype is compressed');
         if (mimetype.localExtra)
-            layout('mimetype has an extra field');
+            note('mimetype has an extra field');
         if (declared !== declared.trim())
-            layout('mimetype has white space around the media type');
+            note('mimetype has white space around the media type');
         declared = declared.trim();
     }
     else
-        layout('there is no mimetype entry');
+        note('there is no mimetype entry');
     const manifest = manifestEntry ? await readManifest(ctx, manifestEntry) : undefined;
     if (!manifest)
-        layout('there is no manifest');
+        note('there is no manifest');
     const root = manifest?.root;
     if (declared !== undefined && root !== undefined && declared !== root && formats_1.ODF_FORMATS.has(declared) && formats_1.ODF_FORMATS.has(root)) {
         throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.AmbiguousFormat, 'The mimetype entry and the manifest name different formats', { mimetype: (0, context_1.clip)(declared), manifest: (0, context_1.clip)(root) });
     }
-    const type = declared ?? root ?? '';
-    const format = formats_1.ODF_FORMATS.get(type);
+    const mediaType = declared ?? root ?? '';
+    const format = formats_1.ODF_FORMATS.get(mediaType);
     if (!format)
-        throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.Unrecognized, 'The OpenDocument media type is not one this package reads', { mediaType: (0, context_1.clip)(type) });
+        throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.Unrecognized, 'The OpenDocument media type is not one this package reads', { mediaType: (0, context_1.clip)(mediaType) });
+    return { format, mediaType, mimetype, manifestEntry, manifest };
+}
+/** Inspects an OpenDocument package. */
+async function inspectOdf(ctx) {
+    const zip = ctx.zip;
+    const { format, mediaType: type, mimetype, manifestEntry, manifest } = await nameOdf(ctx, (location, reason) => ctx.report(types_1.OfficeCategory.Package, types_1.OfficeDetail.OdfLayout, location, { reason }));
     ctx.format = format;
     if (manifest?.encrypted)
         throw new errors_1.StopError(types_1.OfficeCategory.Encrypted, types_1.OfficeDetail.PasswordRequired, 'The manifest lists encrypted entries');

package/dist/ole.d.ts

@@ -1,12 +1,29 @@
 import type { CompoundFile } from './cfb';
 import type { RunContext } from './context';
+import type { Format } from './formats';
+import { ZipArchive } from './zip';
 /** The families a compound file can hold, by the stream or storage that marks each. */
-type Family = 'word' | 'excel' | 'powerpoint' | 'visio' | 'outlook' | 'publisher' | 'project' | 'encrypted';
+export type Family = 'word' | 'excel' | 'powerpoint' | 'visio' | 'outlook' | 'publisher' | 'project' | 'encrypted';
 /** What the root of a compound file holds, read by the names of its children, ignoring case as MS-CFB does. */
 export declare function families(cfb: CompoundFile): Family[];
+/**
+ * The family whose format a compound file holds, by the streams and storages at its root. Throws for a root that
+ * holds no Office document, or the documents of two families.
+ */
+export declare function mainFamily(cfb: CompoundFile): Family;
+/**
+ * The format of a compound file of `family`. A Word document is a template when its FIB says so, and a workbook a
+ * template or an add-in when its globals do; both are read without a password. An encrypted package names no format
+ * until it is decrypted, so for one this is undefined.
+ */
+export declare function compoundFormat(cfb: CompoundFile, family: Family, deadline?: number): Promise<Format | undefined>;
+/**
+ * Decrypts the package of an encrypted compound file with the run's passwords, then VelvetSweatshop, and reads it as
+ * a ZIP archive. Throws ENCRYPTED/PASSWORD_REQUIRED when no password opens it.
+ */
+export declare function openEncryptedPackage(ctx: RunContext, cfb: CompoundFile): Promise<ZipArchive>;
 /**
  * Inspects a compound file: the rules every compound file gets, over its whole tree, and then those of the format
  * its root names.
  */
 export declare function inspectCompound(ctx: RunContext, cfb: CompoundFile): Promise<void>;
-export {};

package/dist/ole.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.families = families;
+exports.mainFamily = mainFamily;
+exports.compoundFormat = compoundFormat;
+exports.openEncryptedPackage = openEncryptedPackage;
 exports.inspectCompound = inspectCompound;
 const errors_1 = require("./errors");
 const msg_1 = require("./msg");
@@ -43,10 +46,10 @@ function families(cfb) {
     return out;
 }
 /**
- * Inspects a compound file: the rules every compound file gets, over its whole tree, and then those of the format
- * its root names.
+ * The family whose format a compound file holds, by the streams and storages at its root. Throws for a root that
+ * holds no Office document, or the documents of two families.
  */
-async function inspectCompound(ctx, cfb) {
+function mainFamily(cfb) {
     const found = families(cfb);
     // Word 2007 writes a Word document beside an encrypted package, for readers that cannot decrypt it.
     const main = found.filter(x => !(x === 'word' && found.includes('encrypted')));
@@ -54,40 +57,88 @@ async function inspectCompound(ctx, cfb) {
         throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.AmbiguousFormat, `The compound file holds ${main.join(' and ')} streams`, { reason: `${main.join(' and ')} streams` });
     if (main.length === 0)
         throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.Unrecognized, 'The compound file holds no Office document stream', { reason: 'a compound file of another kind' });
-    const family = main[0];
-    ctx.format = formatOf(family, cfb);
+    return main[0];
+}
+/** A stream at the root of a compound file, by name, ignoring case. */
+const rootStream = (cfb, name) => {
+    const e = cfb.child(cfb.root, name);
+    return e?.kind === 'stream' ? e : undefined;
+};
+/**
+ * The format of a compound file of `family`. A Word document is a template when its FIB says so, and a workbook a
+ * template or an add-in when its globals do; both are read without a password. An encrypted package names no format
+ * until it is decrypted, so for one this is undefined.
+ */
+async function compoundFormat(cfb, family, deadline) {
+    switch (family) {
+        case 'word': {
+            const word = rootStream(cfb, 'WordDocument');
+            return word && (await (0, word_1.isWordTemplate)(cfb, word)) ? f('dot', 'application/msword') : f('doc', 'application/msword');
+        }
+        case 'excel': {
+            // Excel 97 to 2003 reads Workbook, and Excel 5.0 and 95 read Book. A file can hold both.
+            let template = false;
+            let addIn = false;
+            for (const name of ['Workbook', 'Book']) {
+                const s = rootStream(cfb, name);
+                if (!s)
+                    continue;
+                const kind = await (0, xls_1.workbookKind)(cfb, s, deadline);
+                template ||= kind.template;
+                addIn ||= kind.addIn;
+            }
+            return addIn ? f('xla', 'application/vnd.ms-excel') : template ? f('xlt', 'application/vnd.ms-excel') : f('xls', 'application/vnd.ms-excel');
+        }
+        case 'powerpoint':
+            return f('ppt', 'application/vnd.ms-powerpoint');
+        case 'visio':
+            return f('vsd', 'application/vnd.visio');
+        case 'outlook':
+            return cfb.root.clsid === '0006F046-0000-0000-C000-000000000046' ? f('oft', 'application/vnd.ms-outlook') : f('msg', 'application/vnd.ms-outlook');
+        case 'publisher':
+            return f('pub', 'application/x-mspublisher');
+        case 'project':
+            return f('mpp', 'application/vnd.ms-project');
+        default:
+            // An encrypted package names its format only once it is decrypted.
+            return undefined;
+    }
+}
+/**
+ * Decrypts the package of an encrypted compound file with the run's passwords, then VelvetSweatshop, and reads it as
+ * a ZIP archive. Throws ENCRYPTED/PASSWORD_REQUIRED when no password opens it.
+ */
+async function openEncryptedPackage(ctx, cfb) {
+    const info = rootStream(cfb, 'EncryptionInfo');
+    const pkg = rootStream(cfb, 'EncryptedPackage');
+    if (!info || !pkg)
+        throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.Unrecognized, 'The compound file holds no encrypted package', { reason: 'no EncryptionInfo and EncryptedPackage streams' });
+    const { source } = await (0, offcrypto_1.openPackage)(ctx, cfb, info, pkg);
+    return zip_1.ZipArchive.open(source, ctx.settings, ctx.settings.deadline);
+}
+/**
+ * Inspects a compound file: the rules every compound file gets, over its whole tree, and then those of the format
+ * its root names.
+ */
+async function inspectCompound(ctx, cfb) {
+    const family = mainFamily(cfb);
+    ctx.format = await compoundFormat(cfb, family, ctx.settings.deadline);
     const plan = new plan_1.CompoundPlan();
     if (family !== 'encrypted')
         ctx.run.output = { kind: 'cfb', cfb, plan };
     await (0, objects_1.compoundRules)(ctx, cfb, '', false, plan);
-    const stream = (name) => {
-        const e = cfb.child(cfb.root, name);
-        return e?.kind === 'stream' ? e : undefined;
-    };
+    const stream = (name) => rootStream(cfb, name);
     // Beside an encrypted package, Word 2007 writes a WordDocument stream for older readers, of zeros in the files at
     // hand. Those readers read it if it holds a document, so it gets the Word rules when it does.
     const word = stream('WordDocument');
-    if (word) {
-        const r = await (0, word_1.wordRules)(ctx, cfb, word, family === 'encrypted');
-        if (r?.template && family === 'word')
-            ctx.format = f('dot', 'application/msword');
-    }
+    if (word)
+        await (0, word_1.wordRules)(ctx, cfb, word, family === 'encrypted');
     if (family === 'excel') {
-        // Excel 97 to 2003 reads Workbook, and Excel 5.0 and 95 read Book. A file can hold both.
-        let template = false;
-        let addIn = false;
         for (const name of ['Workbook', 'Book']) {
             const s = stream(name);
-            if (!s)
-                continue;
-            const r = await (0, xls_1.excelRules)(ctx, cfb, s, offcrypto_1.unlockWorkbook);
-            template ||= r.template;
-            addIn ||= r.addIn;
+            if (s)
+                await (0, xls_1.excelRules)(ctx, cfb, s, offcrypto_1.unlockWorkbook);
         }
-        if (addIn)
-            ctx.format = f('xla', 'application/vnd.ms-excel');
-        else if (template)
-            ctx.format = f('xlt', 'application/vnd.ms-excel');
         // Excel keeps the data of a workbook's ActiveX controls in one Ctls stream.
         const controls = stream('Ctls');
         if (controls && controls.size > 0 && ctx.report(types_1.OfficeCategory.Control, types_1.OfficeDetail.ActiveX, controls.name, { stream: controls.name }).action === 'strip')
@@ -101,14 +152,12 @@ async function inspectCompound(ctx, cfb) {
     const visio = stream('VisioDocument');
     if (family === 'visio' && visio)
         await (0, vsd_1.visioRules)(ctx, cfb, visio);
-    const info = stream('EncryptionInfo');
-    const pkg = stream('EncryptedPackage');
-    if (family === 'encrypted' && info && pkg) {
+    if (family === 'encrypted') {
         // The package goes through the OOXML rules once a password opens it, and names the format.
-        const { source } = await (0, offcrypto_1.openPackage)(ctx, cfb, info, pkg);
-        const zip = await zip_1.ZipArchive.open(source, ctx.settings, ctx.settings.deadline);
+        const zip = await openEncryptedPackage(ctx, cfb);
+        const location = stream('EncryptedPackage')?.name ?? 'EncryptedPackage';
         for (const n of zip.notes)
-            ctx.report(types_1.OfficeCategory.Container, n.detail, pkg.name, { bytes: n.bytes });
+            ctx.report(types_1.OfficeCategory.Container, n.detail, location, { bytes: n.bytes });
         // The rewrite writes the package decrypted, since office-defuse does not encrypt.
         const zctx = ctx.withZip(zip);
         await (0, package_1.inspectPackage)(zctx);
@@ -116,24 +165,3 @@ async function inspectCompound(ctx, cfb) {
             ctx.run.output = { kind: 'zip', zip, plan: zctx.plan, format: ctx.format };
     }
 }
-function formatOf(family, cfb) {
-    switch (family) {
-        case 'word':
-            return f('doc', 'application/msword');
-        case 'excel':
-            return f('xls', 'application/vnd.ms-excel');
-        case 'powerpoint':
-            return f('ppt', 'application/vnd.ms-powerpoint');
-        case 'visio':
-            return f('vsd', 'application/vnd.visio');
-        case 'outlook':
-            return cfb.root.clsid === '0006F046-0000-0000-C000-000000000046' ? f('oft', 'application/vnd.ms-outlook') : f('msg', 'application/vnd.ms-outlook');
-        case 'publisher':
-            return f('pub', 'application/x-mspublisher');
-        case 'project':
-            return f('mpp', 'application/vnd.ms-project');
-        default:
-            // An encrypted package names its format only once it is decrypted.
-            return undefined;
-    }
-}

package/dist/ooxml.d.ts

@@ -1,4 +1,5 @@
 import { type ZipContext } from './context';
+import { type Format } from './formats';
 import { type XmlElement } from './xml';
 import { type ZipEntry } from './zip';
 export declare const CONTENT_TYPES_NS = "http://schemas.openxmlformats.org/package/2006/content-types";
@@ -81,9 +82,33 @@ export declare function resolvePartRef(part: string, ref: string): string;
 export declare function xpsResources(el: XmlElement): Array<[string, string]>;
 /** Reads a relationships part and hands each relationship to `each` as it is read. Ids given twice are reported. */
 export declare function readRelationships(ctx: ZipContext, entry: ZipEntry, each: (r: Relationship) => void): Promise<void>;
+/** An OOXML package's parts, typed by its [Content_Types].xml, and its relationships parts by the key of the part each belongs to. */
+export interface OoxmlParts {
+    parts: Map<string, Part>;
+    relsOf: Map<string, ZipEntry>;
+}
+/** Reads [Content_Types].xml and types each part by it. Directory entries are neither parts nor relationships parts. */
+export declare function readParts(ctx: ZipContext, contentTypes: ZipEntry): Promise<OoxmlParts>;
+/** The format the package relationships name, and the relationship types they use. */
+export interface OoxmlMain {
+    format: Format;
+    /** The package uses the relationship types of Strict OOXML. */
+    strict: boolean;
+    /** The package is XPS or OpenXPS. */
+    xps: boolean;
+}
+/**
+ * Reads the package relationships and names the format by the one main part they name: by its content type, or for
+ * XPS by the relationship type too, since XPS and OpenXPS share their content types. `each` sees every package
+ * relationship as it is read. Throws when no main part, or more than one, is named, or its format is unknown.
+ */
+export declare function readMain(ctx: ZipContext, { parts, relsOf }: OoxmlParts, each?: (rels: ZipEntry, r: Relationship) => void): Promise<OoxmlMain>;
+/** Names an OOXML package's format as its inspection does, reading only [Content_Types].xml and the package relationships. */
+export declare function nameOoxml(ctx: ZipContext, contentTypes: ZipEntry): Promise<Format>;
 /**
  * Inspects an OOXML package. The package relationships come first, since they name the main part and so the format.
  * Then each part is read in archive order, followed by its relationships, which are reported as they are read and
- * leave behind only which parts they reach and how.
+ * leave behind only which parts they reach and how. The run names `outer` as the format when given, as for a Flat
+ * OPC package unpacked into a ZIP archive, and the package's own format is returned.
  */
-export declare function inspectOoxml(ctx: ZipContext, contentTypes: ZipEntry): Promise<void>;
+export declare function inspectOoxml(ctx: ZipContext, contentTypes: ZipEntry, outer?: Format): Promise<Format>;

package/dist/ooxml.js

@@ -5,6 +5,9 @@ exports.resolveTarget = resolveTarget;
 exports.resolvePartRef = resolvePartRef;
 exports.xpsResources = xpsResources;
 exports.readRelationships = readRelationships;
+exports.readParts = readParts;
+exports.readMain = readMain;
+exports.nameOoxml = nameOoxml;
 exports.inspectOoxml = inspectOoxml;
 const biff_1 = require("./biff");
 const contained_1 = require("./contained");
@@ -540,24 +543,14 @@ class PartRules {
         }
     }
 }
-/**
- * Inspects an OOXML package. The package relationships come first, since they name the main part and so the format.
- * Then each part is read in archive order, followed by its relationships, which are reported as they are read and
- * leave behind only which parts they reach and how.
- */
-async function inspectOoxml(ctx, contentTypes) {
+/** Reads [Content_Types].xml and types each part by it. Directory entries are neither parts nor relationships parts. */
+async function readParts(ctx, contentTypes) {
     const { defaults, overrides } = await readContentTypes(ctx, contentTypes);
     const parts = new Map();
     const relsOf = new Map();
-    const plan = ctx.plan;
     for (const entry of ctx.zip.entries) {
-        if (entry === contentTypes)
-            continue;
-        // OPC has no folders. A directory entry is still inflated once, so its bytes are checked like any other.
-        if (entry.directory) {
-            await ctx.drain(entry);
+        if (entry === contentTypes || entry.directory)
             continue;
-        }
         const source = (0, exports.relsSource)(entry.name);
         if (source !== undefined) {
             relsOf.set(source, entry);
@@ -567,8 +560,54 @@ async function inspectOoxml(ctx, contentTypes) {
         const ext = /\.([^./]*)$/.exec(entry.name)?.[1]?.toLowerCase();
         parts.set(key, { entry, contentType: overrides.get(key) ?? (ext === undefined ? undefined : defaults.get(ext)), reachedAs: 0, claimed: false, targets: new Set(), ole: false });
     }
-    const roots = new Set();
+    return { parts, relsOf };
+}
+/**
+ * Reads the package relationships and names the format by the one main part they name: by its content type, or for
+ * XPS by the relationship type too, since XPS and OpenXPS share their content types. `each` sees every package
+ * relationship as it is read. Throws when no main part, or more than one, is named, or its format is unknown.
+ */
+async function readMain(ctx, { parts, relsOf }, each) {
+    const packageRels = relsOf.get('');
     const mains = [];
+    let strict = false;
+    let mainType = '';
+    if (packageRels) {
+        await readRelationships(ctx, packageRels, r => {
+            if (exports.REL.main.has(r.type)) {
+                mains.push(r.external ? undefined : parts.get(resolveTarget(packageRels.name, r.target)));
+                strict = r.type.startsWith(S);
+                mainType = r.type;
+            }
+            each?.(packageRels, r);
+        });
+    }
+    if (mains.length > 1)
+        throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.AmbiguousFormat, 'The package names more than one main part', { reason: 'more than one main part' });
+    const main = mains[0];
+    if (!main)
+        throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.Unrecognized, 'The package has no main part', { reason: 'no main document part' });
+    const xps = mainType === exports.XPS_MAIN.xps || mainType === exports.XPS_MAIN.oxps;
+    const format = xps ? (main.contentType === formats_1.XPS_SEQUENCE ? formats_1.XPS_FORMATS[mainType === exports.XPS_MAIN.oxps ? 'oxps' : 'xps'] : undefined) : formats_1.OOXML_FORMATS.get(main.contentType ?? '');
+    if (!format)
+        throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.Unrecognized, 'The main part has an unknown content type', { contentType: (0, context_1.clip)(main.contentType ?? '') });
+    return { format, strict, xps };
+}
+/** Names an OOXML package's format as its inspection does, reading only [Content_Types].xml and the package relationships. */
+async function nameOoxml(ctx, contentTypes) {
+    return (await readMain(ctx, await readParts(ctx, contentTypes))).format;
+}
+/**
+ * Inspects an OOXML package. The package relationships come first, since they name the main part and so the format.
+ * Then each part is read in archive order, followed by its relationships, which are reported as they are read and
+ * leave behind only which parts they reach and how. The run names `outer` as the format when given, as for a Flat
+ * OPC package unpacked into a ZIP archive, and the package's own format is returned.
+ */
+async function inspectOoxml(ctx, contentTypes, outer) {
+    const typed = await readParts(ctx, contentTypes);
+    const { parts, relsOf } = typed;
+    const plan = ctx.plan;
+    const roots = new Set();
     /** The labels each part gives its hyperlinks, by part key and relationship Id. */
     const labelsOf = new Map();
     const relate = (rels, from, r) => {
@@ -598,30 +637,12 @@ async function inspectOoxml(ctx, contentTypes) {
         if (reported?.action === 'strip')
             plan.dropRelationship(rels.name, r.id);
     };
-    const packageRels = relsOf.get('');
-    let strict = false;
-    let mainType = '';
-    if (packageRels) {
-        await readRelationships(ctx, packageRels, r => {
-            if (exports.REL.main.has(r.type)) {
-                mains.push(r.external ? undefined : parts.get(resolveTarget(packageRels.name, r.target)));
-                strict = r.type.startsWith(S);
-                mainType = r.type;
-            }
-            relate(packageRels, undefined, r);
-        });
-    }
-    if (mains.length > 1)
-        throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.AmbiguousFormat, 'The package names more than one main part', { reason: 'more than one main part' });
-    const main = mains[0];
-    if (!main)
-        throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.Unrecognized, 'The package has no main part', { reason: 'no main document part' });
-    const xps = mainType === exports.XPS_MAIN.xps || mainType === exports.XPS_MAIN.oxps;
-    // XPS and OpenXPS share their content types, so the relationship type tells them apart.
-    const format = xps ? (main.contentType === formats_1.XPS_SEQUENCE ? formats_1.XPS_FORMATS[mainType === exports.XPS_MAIN.oxps ? 'oxps' : 'xps'] : undefined) : formats_1.OOXML_FORMATS.get(main.contentType ?? '');
-    if (!format)
-        throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.Unrecognized, 'The main part has an unknown content type', { contentType: (0, context_1.clip)(main.contentType ?? '') });
-    ctx.format = format;
+    const { format, strict, xps } = await readMain(ctx, typed, (rels, r) => relate(rels, undefined, r));
+    ctx.format = outer ?? format;
+    // OPC has no folders. A directory entry is still inflated once, so its bytes are checked like any other.
+    for (const entry of ctx.zip.entries)
+        if (entry.directory)
+            await ctx.drain(entry);
     for (const [key, p] of parts) {
         const ct = p.contentType;
         if (ct === undefined) {
@@ -663,6 +684,7 @@ async function inspectOoxml(ctx, contentTypes) {
         await partRules(ctx, p);
     unreferenced(ctx, parts, relsOf, roots);
     plan.graph = { contentTypes, parts, relsOf, roots, strict, xps };
+    return format;
 }
 /**
  * Findings about a whole part, from its content type and the relationships that reach it. The files inside the

package/dist/package.d.ts

@@ -1,3 +1,17 @@
 import type { ZipContext } from './context';
+import type { Format } from './formats';
+import type { ZipArchive, ZipEntry } from './zip';
+/**
+ * The package a ZIP archive's markers name: OOXML by [Content_Types].xml, OpenDocument by a mimetype entry or a
+ * manifest. Throws for an archive with both or neither.
+ */
+export declare function packageKind(zip: ZipArchive): {
+    kind: 'ooxml';
+    contentTypes: ZipEntry;
+} | {
+    kind: 'odf';
+};
 /** Inspects an OOXML or OpenDocument package, which its markers name. */
 export declare function inspectPackage(ctx: ZipContext): Promise<void>;
+/** Names an OOXML or OpenDocument package's format as its inspection does, without the rules. */
+export declare function namePackage(ctx: ZipContext): Promise<Format>;

package/dist/package.js

@@ -1,21 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageKind = packageKind;
 exports.inspectPackage = inspectPackage;
+exports.namePackage = namePackage;
 const errors_1 = require("./errors");
 const odf_1 = require("./odf");
 const ooxml_1 = require("./ooxml");
 const types_1 = require("./types");
-/** Inspects an OOXML or OpenDocument package, which its markers name. */
-async function inspectPackage(ctx) {
-    const zip = ctx.zip;
+/**
+ * The package a ZIP archive's markers name: OOXML by [Content_Types].xml, OpenDocument by a mimetype entry or a
+ * manifest. Throws for an archive with both or neither.
+ */
+function packageKind(zip) {
     const contentTypes = zip.get('[Content_Types].xml');
     const odf = zip.entries.some(e => e.name === 'mimetype') || zip.get('META-INF/manifest.xml') !== undefined;
     if (contentTypes && odf)
         throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.AmbiguousFormat, 'The file has both [Content_Types].xml and an OpenDocument mimetype or manifest', { reason: 'OOXML and OpenDocument markers' });
     if (contentTypes)
-        await (0, ooxml_1.inspectOoxml)(ctx, contentTypes);
-    else if (odf)
-        await (0, odf_1.inspectOdf)(ctx);
+        return { kind: 'ooxml', contentTypes };
+    if (odf)
+        return { kind: 'odf' };
+    throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.Unrecognized, 'The archive has neither [Content_Types].xml nor an OpenDocument mimetype or manifest', { reason: 'a plain ZIP archive' });
+}
+/** Inspects an OOXML or OpenDocument package, which its markers name. */
+async function inspectPackage(ctx) {
+    const k = packageKind(ctx.zip);
+    if (k.kind === 'ooxml')
+        await (0, ooxml_1.inspectOoxml)(ctx, k.contentTypes);
     else
-        throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.Unrecognized, 'The archive has neither [Content_Types].xml nor an OpenDocument mimetype or manifest', { reason: 'a plain ZIP archive' });
+        await (0, odf_1.inspectOdf)(ctx);
+}
+/** Names an OOXML or OpenDocument package's format as its inspection does, without the rules. */
+async function namePackage(ctx) {
+    const k = packageKind(ctx.zip);
+    return k.kind === 'ooxml' ? (0, ooxml_1.nameOoxml)(ctx, k.contentTypes) : (await (0, odf_1.nameOdf)(ctx)).format;
 }

package/dist/plugins.js

@@ -2,34 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.officePlugin = officePlugin;
 const contained_1 = require("./contained");
+const detect_1 = require("./detect");
 const engine_1 = require("./engine");
-const flat_1 = require("./flat");
 const score_1 = require("./score");
-const zip_1 = require("./zip");
-/** What the ZIP reader needs to look for the markers of an Office package, with the default limits. */
-const PROBE = { entries: 10_000, decompressedBytes: 512 * 1024 * 1024, totalDecompressedBytes: 2 * 1024 * 1024 * 1024 };
-/**
- * Whether the content is a file office-defuse reads: a compound file, RTF, a ZIP archive with the marker of an Office
- * Open XML or OpenDocument package, or XML whose root is a flat OpenDocument document or a Flat OPC package. A ZIP
- * archive without a marker, or one the ZIP reader refuses, is not.
- */
-async function isOffice(source, sniffed) {
-    if (sniffed === 'application/x-ole-storage' || sniffed === 'application/rtf')
-        return true;
-    if (sniffed === 'application/xml') {
-        const head = await source.read(0, Math.min(16384, await source.size()));
-        return (0, flat_1.isFlatHead)(Buffer.from(head).toString('utf8'));
-    }
-    if (sniffed !== 'application/zip')
-        return false;
-    try {
-        const zip = await zip_1.ZipArchive.open(source, PROBE);
-        return zip.get('[Content_Types].xml') !== undefined || zip.entries.some(e => e.name === 'mimetype') || zip.get('META-INF/manifest.xml') !== undefined;
-    }
-    catch {
-        return false;
-    }
-}
 /**
  * Defuses Office and OpenDocument files inside other files, with `options` when given. Without them, it takes the
  * options of the office-defuse run that found the file, or none when another package found it. `limits.nestingDepth`
@@ -40,8 +15,8 @@ function officePlugin(options) {
     return {
         kind: 'file',
         name: 'office',
-        // It can only read what it can parse, so the content decides, whatever the name says.
-        accepts: f => isOffice(f.source, f.sniffedType),
+        // It takes what detectOffice names: the content decides, whatever the name says.
+        accepts: async (f) => (await (0, detect_1.detectOfficeSource)(f.source, { name: f.name, declaredType: f.declaredType })) !== undefined,
         async process(file, sink, context) {
             const run = options ?? context[contained_1.RUN_OPTIONS] ?? {};
             const r = await (0, engine_1.disarmAtDepth)(file.source, sink, run, context.depth, context.deadline);

package/dist/rtf.js

@@ -6,6 +6,7 @@ const contained_1 = require("./contained");
 const context_1 = require("./context");
 const errors_1 = require("./errors");
 const fields_1 = require("./fields");
+const formats_1 = require("./formats");
 const io_1 = require("./io");
 const links_1 = require("./links");
 const objects_1 = require("./objects");
@@ -102,7 +103,7 @@ const isDigit = (c) => c >= 0x30 && c <= 0x39;
  * text after the document's last brace is still read, as rtfobj reads it, and reported as trailing data.
  */
 async function inspectRtf(ctx, source, size) {
-    ctx.format = { format: 'rtf', mimeType: 'application/rtf' };
+    ctx.format = formats_1.RTF_FORMAT;
     const cuts = [];
     ctx.run.output = { kind: 'rtf', size, cuts };
     const reader = new RtfReader(ctx, size, cuts);

package/dist/types.d.ts

@@ -234,6 +234,29 @@ export interface OfficeLimits {
     /** Milliseconds for the whole run. Not enforced unless set. */
     timeMs?: number;
 }
+export interface FormatDetection {
+    /** The format's MIME type, such as application/vnd.openxmlformats-officedocument.wordprocessingml.document. */
+    mimeType: string;
+    /** The format's usual extension, lowercase and without the dot. */
+    extension: string;
+    /** Where the format starts in the file: 0, or the offset of its data when other data comes first. */
+    offset: number;
+    /** Set when the match rests on more than the content, and says what it rests on. */
+    heuristic?: string;
+}
+/** What a detect function may know of a file besides its content. */
+export interface DetectOptions {
+    /** The file's name, as the upload or the container that holds it gives it. */
+    name?: string;
+    /** The MIME type the upload or the container declares. */
+    declaredType?: string;
+    /** The Date.now() value detection must finish by, as `PluginContext.deadline`. */
+    deadline?: number;
+    /** Folder for temporary files. Defaults to `os.tmpdir()`. */
+    tempDir?: string;
+    /** Bytes held in memory before a temporary file takes over. */
+    memoryThreshold?: number;
+}
 /** What a contained file plugin learns of the run, with nothing format-specific, so any package of the family can make one. */
 export interface PluginContext {
     /** The depth of the file itself: 0 for the upload, 1 for a file inside it, and so on, whatever the formats. */

package/dist/word.d.ts

@@ -1,9 +1,9 @@
 import type { CfbEntry, CompoundFile } from './cfb';
 import type { RunContext } from './context';
+/** Whether a WordDocument stream holds a template: its FIB has fDot set. */
+export declare function isWordTemplate(cfb: CompoundFile, stream: CfbEntry): Promise<boolean>;
 /**
  * Inspects a Word 6.0 to 2003 document: its FIB, whether it is encrypted, the fields in its text and the template it
- * attaches. Returns whether it is a template, or undefined for an `optional` stream that holds no FIB.
+ * attaches. An `optional` stream that holds no FIB is not read.
  */
-export declare function wordRules(ctx: RunContext, cfb: CompoundFile, stream: CfbEntry, optional?: boolean): Promise<{
-    template: boolean;
-} | undefined>;
+export declare function wordRules(ctx: RunContext, cfb: CompoundFile, stream: CfbEntry, optional?: boolean): Promise<void>;