366 lines
11 KiB
TypeScript
366 lines
11 KiB
TypeScript
// This Source Code Form is subject to the terms of the Mozilla Public
|
|
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
// You can obtain one at https://mozilla.org/MPL/2.0/.
|
|
|
|
import { BinaryReader } from '../binary/BinaryReader.js';
|
|
import { readGuid } from '../binary/guid.js';
|
|
import { appendItems } from '../model/append.js';
|
|
import type { ParserDiagnostic } from '../model/diagnostics.js';
|
|
import { parseDesktopOneNoteTableOfContentsStore } from '../onestore/desktop-store.js';
|
|
import type { DesktopOneStore } from '../onestore/desktop-store.js';
|
|
import { parseFssHttpOneStore } from '../onestore/fsshttp-store.js';
|
|
import {
|
|
countObjectReferences,
|
|
findProperty,
|
|
referenceOffset,
|
|
} from '../onestore/property-set.js';
|
|
import type { ExGuid, ObjectSpace, StoreObject } from '../onestore/types.js';
|
|
import { exGuidKey } from '../onestore/types.js';
|
|
import { detectOneNoteFormat, toBytes } from './detect-format.js';
|
|
import { OneNoteParserError } from './error.js';
|
|
import type { OneNoteParserLimits } from './limits.js';
|
|
import { resolveParserLimits } from './limits.js';
|
|
|
|
const TOC_CONTAINER_JCID = 0x0002_0001;
|
|
const TOC_PROPERTY = {
|
|
children: 0x2400_1cf6,
|
|
fileIdentity: 0x1c00_1d94,
|
|
filename: 0x1c00_1d6b,
|
|
orderingId: 0x1400_1cb9,
|
|
color: 0x1400_1cbe,
|
|
enableHistory: 0x0800_1e1e,
|
|
} as const;
|
|
|
|
const UTF16 = new TextDecoder('utf-16le', { fatal: true });
|
|
|
|
export interface OneNoteTableOfContentsEntry {
|
|
filename: string;
|
|
fileIdentity: string;
|
|
orderingId: number;
|
|
color?: number;
|
|
}
|
|
|
|
export interface OneNoteTableOfContents {
|
|
sourceName: string;
|
|
fileIdentity: string;
|
|
color?: number;
|
|
enableHistory?: boolean;
|
|
entries: OneNoteTableOfContentsEntry[];
|
|
diagnostics: ParserDiagnostic[];
|
|
}
|
|
|
|
export interface ParseOneNoteTableOfContentsOptions {
|
|
sourceName?: string;
|
|
limits?: Partial<OneNoteParserLimits>;
|
|
}
|
|
|
|
interface TocContext {
|
|
space: ObjectSpace;
|
|
limits: OneNoteParserLimits;
|
|
diagnostics: ParserDiagnostic[];
|
|
active: Set<string>;
|
|
}
|
|
|
|
/** Parse a supported desktop or FSSHTTPB `.onetoc2` without network access. */
|
|
export function parseOneNoteTableOfContents(
|
|
input: ArrayBuffer | Uint8Array,
|
|
options: ParseOneNoteTableOfContentsOptions = {}
|
|
): OneNoteTableOfContents {
|
|
const bytes = toBytes(input);
|
|
const limits = resolveParserLimits(options.limits);
|
|
const diagnostics: ParserDiagnostic[] = [];
|
|
const store = parseTableOfContentsStore(bytes, limits, diagnostics);
|
|
const space = store.rootObjectSpace;
|
|
const rootId = space.roots.get(1);
|
|
if (!rootId) {
|
|
throw new OneNoteParserError(
|
|
'MISSING_REFERENCE',
|
|
'Table of contents has no default content root',
|
|
{ structure: 'jcidPersistablePropertyContainerForTOC' }
|
|
);
|
|
}
|
|
const root = space.objects.get(exGuidKey(rootId));
|
|
if (!root) {
|
|
throw new OneNoteParserError(
|
|
'MISSING_REFERENCE',
|
|
`Table-of-contents root ${exGuidKey(rootId)} is absent`,
|
|
{ structure: 'jcidPersistablePropertyContainerForTOC' }
|
|
);
|
|
}
|
|
assertTocContainer(root, 'table-of-contents root');
|
|
|
|
const context: TocContext = {
|
|
space,
|
|
limits,
|
|
diagnostics,
|
|
active: new Set([exGuidKey(root.id)]),
|
|
};
|
|
const entries = parseChildren(context, root, 0).sort(
|
|
(left, right) => left.orderingId - right.orderingId
|
|
);
|
|
|
|
return {
|
|
sourceName: options.sourceName ?? 'Open Notebook.onetoc2',
|
|
fileIdentity: store.fileIdentity,
|
|
color: optionalColor(root),
|
|
enableHistory: optionalBool(root, TOC_PROPERTY.enableHistory),
|
|
entries,
|
|
diagnostics,
|
|
};
|
|
}
|
|
|
|
function parseTableOfContentsStore(
|
|
bytes: Uint8Array,
|
|
limits: OneNoteParserLimits,
|
|
diagnostics: ParserDiagnostic[]
|
|
): DesktopOneStore {
|
|
const store =
|
|
detectOneNoteFormat(bytes).kind === 'fsshttp-one'
|
|
? parseFssHttpOneStore(bytes, limits, diagnostics)
|
|
: parseDesktopOneNoteTableOfContentsStore(bytes, limits, diagnostics);
|
|
if (store.kind !== 'table-of-contents') {
|
|
throw new OneNoteParserError(
|
|
'INVALID_FORMAT',
|
|
'Expected a OneNote table of contents, found a section',
|
|
{ structure: 'OneStore table of contents' }
|
|
);
|
|
}
|
|
return store;
|
|
}
|
|
|
|
function parseChildren(
|
|
context: TocContext,
|
|
parent: StoreObject,
|
|
depth: number
|
|
): OneNoteTableOfContentsEntry[] {
|
|
if (depth > context.limits.maxGraphDepth) {
|
|
throw new OneNoteParserError(
|
|
'LIMIT_EXCEEDED',
|
|
`TOC depth exceeds ${context.limits.maxGraphDepth}`,
|
|
{ structure: 'TOCEntryIndex_OidIndex' }
|
|
);
|
|
}
|
|
|
|
const result: OneNoteTableOfContentsEntry[] = [];
|
|
for (const childId of objectReferences(parent, TOC_PROPERTY.children)) {
|
|
const key = exGuidKey(childId);
|
|
try {
|
|
if (context.active.has(key)) {
|
|
throw new OneNoteParserError(
|
|
'INVALID_STRUCTURE',
|
|
`Cycle detected at TOC object ${key}`,
|
|
{ structure: 'TOCEntryIndex_OidIndex' }
|
|
);
|
|
}
|
|
const child = context.space.objects.get(key);
|
|
if (!child) {
|
|
throw new OneNoteParserError(
|
|
'MISSING_REFERENCE',
|
|
`TOC child ${key} is absent`,
|
|
{ structure: 'TOCEntryIndex_OidIndex' }
|
|
);
|
|
}
|
|
assertTocContainer(child, `TOC child ${key}`);
|
|
context.active.add(key);
|
|
try {
|
|
const filename = optionalString(child, TOC_PROPERTY.filename);
|
|
if (filename !== undefined) {
|
|
result.push({
|
|
filename: decodeFolderChildFilename(filename),
|
|
fileIdentity: requiredGuid(child, TOC_PROPERTY.fileIdentity),
|
|
orderingId: requiredU32(child, TOC_PROPERTY.orderingId),
|
|
color: optionalColor(child),
|
|
});
|
|
} else {
|
|
appendItems(result, parseChildren(context, child, depth + 1));
|
|
}
|
|
} finally {
|
|
context.active.delete(key);
|
|
}
|
|
} catch (error) {
|
|
addEntryDiagnostic(context, error, key);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function objectReferences(object: StoreObject, propertyId: number): ExGuid[] {
|
|
const property = findProperty(object.props, propertyId);
|
|
if (!property) return [];
|
|
const count =
|
|
property.value.kind === 'objectId'
|
|
? 1
|
|
: property.value.kind === 'objectIds'
|
|
? property.value.count
|
|
: undefined;
|
|
if (count === undefined) {
|
|
throw new OneNoteParserError(
|
|
'INVALID_STRUCTURE',
|
|
'TOCEntryIndex_OidIndex is not an object-reference property',
|
|
{ structure: 'TOCEntryIndex_OidIndex' }
|
|
);
|
|
}
|
|
const offset = referenceOffset(
|
|
object.props,
|
|
propertyId,
|
|
countObjectReferences
|
|
);
|
|
if (object.resolvedObjectIds) {
|
|
if (offset + count > object.resolvedObjectIds.length) {
|
|
throw new OneNoteParserError(
|
|
'MISSING_REFERENCE',
|
|
'TOC object-reference range exceeds its resolved OID stream',
|
|
{ structure: 'TOCEntryIndex_OidIndex' }
|
|
);
|
|
}
|
|
return object.resolvedObjectIds.slice(offset, offset + count);
|
|
}
|
|
if (offset + count > object.props.objectIds.length) {
|
|
throw new OneNoteParserError(
|
|
'MISSING_REFERENCE',
|
|
'TOC object-reference range exceeds its OID stream',
|
|
{ structure: 'TOCEntryIndex_OidIndex' }
|
|
);
|
|
}
|
|
return object.props.objectIds.slice(offset, offset + count).map((compact) => {
|
|
const guid = object.mapping.get(compact.guidIndex);
|
|
if (!guid) {
|
|
throw new OneNoteParserError(
|
|
'MISSING_REFERENCE',
|
|
`TOC GUID mapping ${compact.guidIndex} is absent`,
|
|
{ structure: 'CompactID' }
|
|
);
|
|
}
|
|
return { guid, value: compact.value };
|
|
});
|
|
}
|
|
|
|
function assertTocContainer(object: StoreObject, structure: string): void {
|
|
if (object.jcid !== TOC_CONTAINER_JCID) {
|
|
throw new OneNoteParserError(
|
|
'INVALID_STRUCTURE',
|
|
`${structure} has JCID 0x${object.jcid.toString(16)}, expected 0x${TOC_CONTAINER_JCID.toString(16)}`,
|
|
{ structure }
|
|
);
|
|
}
|
|
}
|
|
|
|
function optionalString(
|
|
object: StoreObject,
|
|
propertyId: number
|
|
): string | undefined {
|
|
const value = findProperty(object.props, propertyId)?.value;
|
|
if (!value) return undefined;
|
|
if (value.kind !== 'bytes' || value.value.byteLength % 2 !== 0) {
|
|
throw new OneNoteParserError(
|
|
'INVALID_STRUCTURE',
|
|
'FolderChildFilename is not a UTF-16 byte vector',
|
|
{ structure: 'FolderChildFilename' }
|
|
);
|
|
}
|
|
try {
|
|
return UTF16.decode(value.value).split('\0').join('');
|
|
} catch (error) {
|
|
throw new OneNoteParserError(
|
|
'INVALID_STRUCTURE',
|
|
'FolderChildFilename is not valid UTF-16',
|
|
{ structure: 'FolderChildFilename', cause: error }
|
|
);
|
|
}
|
|
}
|
|
|
|
function decodeFolderChildFilename(value: string): string {
|
|
const decoded = value.replaceAll('^M', '+').replaceAll('^J', ',');
|
|
if (decoded.length === 0) {
|
|
throw new OneNoteParserError(
|
|
'INVALID_STRUCTURE',
|
|
'FolderChildFilename is empty',
|
|
{ structure: 'FolderChildFilename' }
|
|
);
|
|
}
|
|
return decoded;
|
|
}
|
|
|
|
function requiredGuid(object: StoreObject, propertyId: number): string {
|
|
const value = findProperty(object.props, propertyId)?.value;
|
|
if (!value || value.kind !== 'bytes' || value.value.byteLength !== 16) {
|
|
throw new OneNoteParserError(
|
|
'INVALID_STRUCTURE',
|
|
'FileIdentityGuid is absent or not 16 bytes',
|
|
{ structure: 'FileIdentityGuid' }
|
|
);
|
|
}
|
|
return readGuid(new BinaryReader(value.value, 0, 16, 'FileIdentityGuid'));
|
|
}
|
|
|
|
function requiredU32(object: StoreObject, propertyId: number): number {
|
|
const value = findProperty(object.props, propertyId)?.value;
|
|
if (!value || value.kind !== 'u32') {
|
|
throw new OneNoteParserError(
|
|
'INVALID_STRUCTURE',
|
|
'NotebookElementOrderingID is absent or not an unsigned integer',
|
|
{ structure: 'NotebookElementOrderingID' }
|
|
);
|
|
}
|
|
return value.value;
|
|
}
|
|
|
|
function optionalU32(
|
|
object: StoreObject,
|
|
propertyId: number
|
|
): number | undefined {
|
|
const value = findProperty(object.props, propertyId)?.value;
|
|
if (!value) return undefined;
|
|
if (value.kind !== 'u32') {
|
|
throw new OneNoteParserError(
|
|
'INVALID_STRUCTURE',
|
|
'NotebookColor is not an unsigned integer',
|
|
{ structure: 'NotebookColor' }
|
|
);
|
|
}
|
|
return value.value;
|
|
}
|
|
|
|
function optionalColor(object: StoreObject): number | undefined {
|
|
const color = optionalU32(object, TOC_PROPERTY.color);
|
|
return color === 0xffff_ffff ? undefined : color;
|
|
}
|
|
|
|
function optionalBool(
|
|
object: StoreObject,
|
|
propertyId: number
|
|
): boolean | undefined {
|
|
const value = findProperty(object.props, propertyId)?.value;
|
|
if (!value) return undefined;
|
|
if (value.kind !== 'bool') {
|
|
throw new OneNoteParserError(
|
|
'INVALID_STRUCTURE',
|
|
'EnableHistory is not a Boolean',
|
|
{ structure: 'EnableHistory' }
|
|
);
|
|
}
|
|
return value.value;
|
|
}
|
|
|
|
function addEntryDiagnostic(
|
|
context: TocContext,
|
|
error: unknown,
|
|
objectKey: string
|
|
): void {
|
|
if (context.diagnostics.length >= context.limits.maxDiagnostics) return;
|
|
context.diagnostics.push({
|
|
severity: 'warning',
|
|
code: 'TOC_ENTRY_PARSE_FAILED',
|
|
message:
|
|
error instanceof Error
|
|
? error.message
|
|
: 'A table-of-contents entry could not be interpreted.',
|
|
offset: error instanceof OneNoteParserError ? error.offset : undefined,
|
|
structure:
|
|
error instanceof OneNoteParserError && error.structure
|
|
? `${error.structure} (${objectKey})`
|
|
: `TOC object ${objectKey}`,
|
|
recoverable: true,
|
|
});
|
|
}
|