@docx4j/core-ts 0.1.0 → 0.1.1

package/dist/office-js/proxy.mjs

@@ -0,0 +1,279 @@
+// The proxies, collections and results of the Word shim (CR-002 section 3.10).
+//
+// The views of `src/model/content/` stay plain objects for direct users (section 3.12); the shim
+// is the only thing that wraps them. A proxy does four things: `load` / `track` / `untrack` are
+// no-ops returning the object, a member the views implement passes through (its result wrapped in
+// turn), an asynchronous member returns a `ClientResult` whose `value` the next `context.sync()`
+// fills, and anything else throws `NotSupportedError` naming the class and the member.
+import { NotSupportedError, ItemNotFoundError, ValueNotLoadedError } from './errors.mjs';
+/** The wrapped object's target, for `unwrap`. */
+const RAW = Symbol('docx4j.officeJs.raw');
+/** Marks an array that is already a collection, so that it is not wrapped a second time. */
+const COLLECTION = Symbol('docx4j.officeJs.collection');
+/**
+ * The result of an asynchronous call, as Office JS hands one out: `value` after `context.sync()`.
+ * It is also awaitable (an extension), so that `await body.insertXml(...)`, which is how the
+ * content API and `toApiScript`'s output read, keeps its order through the shim.
+ */
+export class ClientResult {
+    constructor(
+    /** The call this is the result of ('getOoxml'), for the error message. */
+    member = 'value') {
+        this.member = member;
+        this.loaded = false;
+    }
+    /** @internal the underlying call, which `context.sync()` awaits and `then` delegates to. */
+    attach(promise) {
+        this.promise = promise;
+    }
+    /** Awaiting the result resolves to the value, without waiting for the next sync. */
+    then(onFulfilled, onRejected) {
+        var _a;
+        const promise = (_a = this.promise) !== null && _a !== void 0 ? _a : Promise.resolve(this.value);
+        return promise.then(onFulfilled, onRejected);
+    }
+    /** The value; throws until `context.sync()` has resolved it, as Office JS does. */
+    get value() {
+        if (!this.loaded)
+            throw new ValueNotLoadedError(`The result of ${this.member}() is not loaded yet; await context.sync() first`);
+        return this.result;
+    }
+    /** @internal filled by the context when the underlying promise settles. */
+    resolveWith(value) {
+        this.result = value;
+        this.loaded = true;
+    }
+    /** True once `context.sync()` has filled it. */
+    get isLoaded() {
+        return this.loaded;
+    }
+    toJSON() {
+        return { value: this.loaded ? this.result : undefined };
+    }
+}
+/** The item class name behind a member that returns a collection, for empty ones and for messages. */
+const COLLECTION_ITEM_CLASS = {
+    paragraphs: 'Paragraph',
+    tables: 'Table',
+    rows: 'TableRow',
+    cells: 'TableCell',
+    contentControls: 'ContentControl',
+    inlinePictures: 'InlinePicture',
+    lists: 'List',
+    getLevelParagraphs: 'Paragraph',
+    getDescendants: 'Paragraph',
+    fields: 'Field',
+    search: 'Range',
+    getComments: 'Comment',
+    comments: 'Comment',
+    replies: 'Comment',
+    getTrackedChanges: 'TrackedChange',
+    customXmlParts: 'CustomXmlPart',
+};
+/** Members whose promise is the caller's to await, not a ClientResult: `context.sync()`. */
+const RAW_PROMISE_MEMBERS = new Set(['sync']);
+/** The engine behind the views: handed out as it is, never proxied, so that docx4j code works on it. */
+const RAW_VALUE_MEMBERS = new Set(['package_', 'part']);
+/** Objects that are data, not views: never proxied, handed out as they are. */
+const PLAIN_CONSTRUCTORS = new Set([
+    Object, Array, Date, RegExp, Map, Set, WeakMap, WeakSet, Promise, Error, Uint8Array, ArrayBuffer, Function,
+]);
+/** True for an instance of a class of ours (a view, or one of the shim's own objects). */
+function isView(value) {
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null || proto === Object.prototype)
+        return false;
+    const ctor = value.constructor;
+    return typeof ctor === 'function' && !PLAIN_CONSTRUCTORS.has(ctor);
+}
+function isThenable(value) {
+    return typeof value === 'object' && value !== null && typeof value.then === 'function';
+}
+/** The target behind a proxy the shim handed out; anything else is returned as it is. */
+export function unwrap(value) {
+    if (typeof value === 'object' && value !== null) {
+        const raw = value[RAW];
+        if (raw !== undefined)
+            return raw;
+    }
+    return value;
+}
+/**
+ * A null object: `isNullObject` is true and every other member throws, as Office JS's
+ * `*OrNullObject` results do.
+ */
+export function nullObject(className) {
+    const fail = (member) => {
+        throw new ItemNotFoundError(`Word.${className} is a null object (nothing matched); check isNullObject before using ${member}`);
+    };
+    const proxy = new Proxy({ isNullObject: true }, {
+        get(target, prop) {
+            if (typeof prop === 'symbol')
+                return Reflect.get(target, prop);
+            if (prop === 'isNullObject')
+                return true;
+            if (prop === 'toJSON')
+                return () => ({ isNullObject: true });
+            if (prop === 'then')
+                return undefined;
+            if (prop === 'load' || prop === 'track' || prop === 'untrack')
+                return () => proxy;
+            return fail(prop);
+        },
+        set(_target, prop) {
+            return fail(String(prop));
+        },
+    });
+    return proxy;
+}
+/**
+ * Wraps the views of one `Word.run` in proxies. One wrapper per context, so that the same view
+ * gives the same proxy and object identity holds within a batch, as it does in Office JS.
+ */
+export class Wrapper {
+    constructor(context, 
+    /** Members the shim adds over a view (`getOoxml`), consulted only when the view has none. */
+    extras = {}) {
+        this.context = context;
+        this.extras = extras;
+        this.cache = new WeakMap();
+    }
+    /** Wraps whatever a member returned: a view, an array of views, a promise, or a plain value. */
+    value(value, member = '') {
+        if (value === null || typeof value !== 'object')
+            return value;
+        if (value instanceof ClientResult)
+            return value;
+        if (Array.isArray(value))
+            return value[COLLECTION] === true ? value : this.collection(value, member);
+        if (!isView(value))
+            return value;
+        return this.object(value);
+    }
+    /** The proxy over one view. */
+    object(view, className = view.constructor.name) {
+        const target = unwrap(view);
+        const cached = this.cache.get(target);
+        if (cached !== undefined)
+            return cached;
+        const wrapper = this;
+        const proxy = new Proxy(target, {
+            get(obj, prop, receiver) {
+                var _a;
+                if (typeof prop === 'symbol')
+                    return prop === RAW ? obj : Reflect.get(obj, prop, obj);
+                switch (prop) {
+                    case 'load':
+                    case 'retrieve':
+                    case 'track':
+                    case 'untrack':
+                        if (!(prop in obj))
+                            return () => proxy;
+                        break;
+                    case 'isNullObject':
+                        if (!(prop in obj))
+                            return false;
+                        break;
+                    case 'then':
+                        if (!(prop in obj))
+                            return undefined;
+                        break;
+                    default:
+                        break;
+                }
+                if (!(prop in obj)) {
+                    const extra = (_a = wrapper.extras[className]) === null || _a === void 0 ? void 0 : _a[prop];
+                    if (extra === undefined)
+                        throw new NotSupportedError(className, prop);
+                    const call = extra;
+                    return (...args) => wrapper.result(call(obj, ...args.map(unwrap)), prop);
+                }
+                const member = Reflect.get(obj, prop, obj);
+                if (typeof member === 'function') {
+                    if (RAW_PROMISE_MEMBERS.has(prop))
+                        return (...args) => member.apply(obj, args.map(unwrap));
+                    return (...args) => wrapper.result(member.apply(obj, args.map(unwrap)), prop);
+                }
+                void receiver;
+                return RAW_VALUE_MEMBERS.has(prop) ? member : wrapper.value(member, prop);
+            },
+            set(obj, prop, value) {
+                if (typeof prop === 'symbol')
+                    return Reflect.set(obj, prop, value, obj);
+                if (!(prop in obj))
+                    throw new NotSupportedError(className, prop);
+                return Reflect.set(obj, prop, unwrap(value), obj);
+            },
+        });
+        this.cache.set(target, proxy);
+        return proxy;
+    }
+    /** The result of a call: a promise becomes a ClientResult the next sync() fills. */
+    result(value, member) {
+        if (value instanceof ClientResult || !isThenable(value))
+            return this.value(value, member);
+        const result = new ClientResult(member);
+        const settled = value.then((resolved) => {
+            const wrapped = this.value(resolved, member);
+            result.resolveWith(wrapped);
+            return wrapped;
+        });
+        result.attach(settled);
+        this.context.enqueue(settled);
+        return result;
+    }
+    /** An array of views as an Office JS collection: the array, plus `items` and the getters. */
+    collection(items, member = '') {
+        var _a;
+        if (items.length > 0 && !items.every((i) => typeof i === 'object' && i !== null && isView(i)))
+            return items;
+        const itemClass = items.length > 0 ? items[0].constructor.name : ((_a = COLLECTION_ITEM_CLASS[member]) !== null && _a !== void 0 ? _a : 'Object');
+        const wrapped = items.map((i) => this.value(i, member));
+        const className = `${itemClass}Collection`;
+        const collection = wrapped;
+        const define = (name, value) => {
+            Object.defineProperty(collection, name, { value, enumerable: false, configurable: true, writable: true });
+        };
+        define(COLLECTION, true);
+        define('items', wrapped);
+        define('getFirst', () => {
+            if (wrapped.length === 0)
+                throw new ItemNotFoundError(`Word.${className} is empty; getFirst() found nothing (getFirstOrNullObject() does not throw)`);
+            return wrapped[0];
+        });
+        define('getFirstOrNullObject', () => (wrapped.length === 0 ? nullObject(itemClass) : wrapped[0]));
+        define('getLast', () => {
+            if (wrapped.length === 0)
+                throw new ItemNotFoundError(`Word.${className} is empty; getLast() found nothing (getLastOrNullObject() does not throw)`);
+            return wrapped[wrapped.length - 1];
+        });
+        define('getLastOrNullObject', () => (wrapped.length === 0 ? nullObject(itemClass) : wrapped[wrapped.length - 1]));
+        define('getCount', () => {
+            const result = new ClientResult('getCount');
+            result.resolveWith(wrapped.length);
+            return result;
+        });
+        define('load', () => collectionProxy);
+        define('track', () => collectionProxy);
+        define('untrack', () => collectionProxy);
+        const wrapperSelf = this;
+        const collectionProxy = new Proxy(collection, {
+            get(obj, prop) {
+                if (typeof prop === 'symbol')
+                    return prop === RAW ? obj : Reflect.get(obj, prop, obj);
+                if (prop === 'then' && !(prop in obj))
+                    return undefined;
+                if (prop === 'isNullObject')
+                    return false;
+                if (!(prop in obj))
+                    throw new NotSupportedError(className, prop);
+                const member2 = Reflect.get(obj, prop, obj);
+                if (typeof member2 === 'function' && !/^\d+$/.test(prop)) {
+                    return (...args) => wrapperSelf.result(member2.apply(obj, args.map(unwrap)), prop);
+                }
+                return member2;
+            },
+        });
+        return collectionProxy;
+    }
+}

package/dist/office-js/run.d.mts

@@ -0,0 +1,32 @@
+import type { WordprocessingMLPackage } from '../packages/WordprocessingMLPackage.mjs';
+import { Document, type RunOptions } from './document.mjs';
+import { type PendingSink } from './proxy.mjs';
+export type { RunOptions };
+/** Office JS's `context.trackedObjects`: object lifetime is the garbage collector's business here. */
+export interface TrackedObjects {
+    add<T>(object: T): T;
+    remove<T>(object: T): T;
+}
+/** A subset of Office JS `Word.RequestContext` over a package. */
+export declare class RequestContext implements PendingSink {
+    /** The package this context is over (extension: Office JS has a host document). */
+    readonly package_: WordprocessingMLPackage;
+    readonly document: Document;
+    /** Tracking is a no-op: nothing here is a remote proxy. */
+    readonly trackedObjects: TrackedObjects;
+    private pending;
+    constructor(
+    /** The package this context is over (extension: Office JS has a host document). */
+    package_: WordprocessingMLPackage, options?: RunOptions);
+    /** @internal a promise whose result the next `sync()` must resolve. */
+    enqueue(promise: Promise<unknown>): void;
+    /** Resolves the pending results, filling every `ClientResult.value` handed out since the last sync. */
+    sync<T>(value?: T): Promise<T | RequestContext>;
+}
+/**
+ * Runs an add-in style callback against a package: `Word.run(pkg, async (context) => { ... })`.
+ * Office JS's `Word.run(batch)` takes the host document; there is none here, so the package comes
+ * first. The callback gets a proxied `RequestContext`; a final `sync()` resolves anything it left
+ * pending, and the callback's value is the result.
+ */
+export declare function run<T>(pkg: WordprocessingMLPackage, batch: (context: RequestContext) => Promise<T> | T, options?: RunOptions): Promise<T>;

package/dist/office-js/run.mjs

@@ -0,0 +1,66 @@
+// `Word.run(pkg, fn)` and its RequestContext (CR-002 section 3.10).
+//
+// Office JS batches proxy calls and resolves them on `context.sync()`. Here the tree is in memory,
+// so a call acts at once (CR-002 section 3.1) and `sync()` only resolves what was asynchronous:
+// the marshalling and unmarshalling calls, whose `ClientResult.value` it fills. An add-in script
+// written for Word therefore runs unchanged, `load` / `sync` lines and all.
+import { Document } from './document.mjs';
+import { EXTRA_MEMBERS } from './extras.mjs';
+import { Wrapper, unwrap } from './proxy.mjs';
+/** A subset of Office JS `Word.RequestContext` over a package. */
+export class RequestContext {
+    constructor(
+    /** The package this context is over (extension: Office JS has a host document). */
+    package_, options = {}) {
+        this.package_ = package_;
+        /** Tracking is a no-op: nothing here is a remote proxy. */
+        this.trackedObjects = { add: (o) => o, remove: (o) => o };
+        this.pending = [];
+        this.document = new Document(package_, options);
+    }
+    /** @internal a promise whose result the next `sync()` must resolve. */
+    enqueue(promise) {
+        this.pending.push(promise);
+    }
+    /** Resolves the pending results, filling every `ClientResult.value` handed out since the last sync. */
+    async sync(value) {
+        while (this.pending.length > 0) {
+            const batch = this.pending;
+            this.pending = [];
+            await Promise.all(batch);
+        }
+        return value === undefined ? this : value;
+    }
+}
+/** Unmarshals what the document-level members read synchronously, as Office JS's host has already. */
+async function prepare(pkg, options) {
+    const main = pkg.getMainDocumentPart();
+    await main.getContents();
+    if (options.unmarshalSideParts === false)
+        return;
+    const sideParts = [pkg.docPropsCorePart, pkg.docPropsExtendedPart, main.documentSettingsPart];
+    for (const part of sideParts) {
+        if (part && !part.isUnmarshalled) {
+            try {
+                await part.getContents();
+            }
+            catch {
+                // A side part that will not unmarshal is not worth failing the batch for; reads report nothing.
+            }
+        }
+    }
+}
+/**
+ * Runs an add-in style callback against a package: `Word.run(pkg, async (context) => { ... })`.
+ * Office JS's `Word.run(batch)` takes the host document; there is none here, so the package comes
+ * first. The callback gets a proxied `RequestContext`; a final `sync()` resolves anything it left
+ * pending, and the callback's value is the result.
+ */
+export async function run(pkg, batch, options = {}) {
+    await prepare(pkg, options);
+    const context = new RequestContext(pkg, options);
+    const wrapper = new Wrapper(context, EXTRA_MEMBERS);
+    const result = await batch(wrapper.object(context, 'RequestContext'));
+    await context.sync();
+    return unwrap(result);
+}

package/dist/office-js/supported.d.mts

@@ -0,0 +1,7 @@
+import { SUBSET_MEMBERS } from './supported.generated.mjs';
+/**
+ * Every member this package implements, as `Class.member` (`'Body.insertParagraph'`). A member
+ * that is not here throws `NotSupportedError` when an add-in calls it through the shim.
+ */
+export declare const supported: ReadonlySet<string>;
+export { SUBSET_MEMBERS };

package/dist/office-js/supported.generated.d.mts

@@ -0,0 +1 @@
+export declare const SUBSET_MEMBERS: readonly string[];

package/dist/office-js/supported.generated.mjs

@@ -0,0 +1,235 @@
+// Generated by scripts/generate-supported.mjs from test/office-js-subset.ts. Do not edit.
+// Every member the Office JS subset declares, as `Class.member`: what this package implements
+// of the Word API (CR-002 sections 3.4 and 3.10). Regenerate with `npm run generate`.
+export const SUBSET_MEMBERS = [
+    'Body.clear',
+    'Body.contentControls',
+    'Body.getComments',
+    'Body.getTrackedChanges',
+    'Body.inlinePictures',
+    'Body.insertBreak',
+    'Body.insertInlinePictureFromBase64',
+    'Body.insertParagraph',
+    'Body.insertTable',
+    'Body.insertText',
+    'Body.lists',
+    'Body.paragraphs',
+    'Body.search',
+    'Body.tables',
+    'Body.text',
+    'CheckboxContentControl.isChecked',
+    'Comment.authorEmail',
+    'Comment.authorName',
+    'Comment.content',
+    'Comment.creationDate',
+    'Comment.delete',
+    'Comment.replies',
+    'Comment.reply',
+    'Comment.resolved',
+    'ContentControl.appearance',
+    'ContentControl.cannotDelete',
+    'ContentControl.cannotEdit',
+    'ContentControl.checkboxContentControl',
+    'ContentControl.color',
+    'ContentControl.comboBoxContentControl',
+    'ContentControl.contentControls',
+    'ContentControl.datePickerContentControl',
+    'ContentControl.delete',
+    'ContentControl.dropDownListContentControl',
+    'ContentControl.getRange',
+    'ContentControl.groupContentControl',
+    'ContentControl.id',
+    'ContentControl.insertParagraph',
+    'ContentControl.insertText',
+    'ContentControl.paragraphs',
+    'ContentControl.pictureContentControl',
+    'ContentControl.placeholderText',
+    'ContentControl.removeWhenEdited',
+    'ContentControl.repeatingSectionContentControl',
+    'ContentControl.search',
+    'ContentControl.tables',
+    'ContentControl.tag',
+    'ContentControl.text',
+    'ContentControl.title',
+    'ContentControl.type',
+    'ContentControl.xmlMapping',
+    'ContentControlListItem.delete',
+    'ContentControlListItem.displayText',
+    'ContentControlListItem.index',
+    'ContentControlListItem.value',
+    'CustomXmlNode.attributes',
+    'CustomXmlNode.baseName',
+    'CustomXmlNode.childNodes',
+    'CustomXmlNode.delete',
+    'CustomXmlNode.firstChild',
+    'CustomXmlNode.hasChildNodes',
+    'CustomXmlNode.insertNodeBefore',
+    'CustomXmlNode.lastChild',
+    'CustomXmlNode.namespaceUri',
+    'CustomXmlNode.nextSibling',
+    'CustomXmlNode.nodeType',
+    'CustomXmlNode.nodeValue',
+    'CustomXmlNode.ownerPart',
+    'CustomXmlNode.parentNode',
+    'CustomXmlNode.previousSibling',
+    'CustomXmlNode.removeChild',
+    'CustomXmlNode.replaceChildNode',
+    'CustomXmlNode.selectNodes',
+    'CustomXmlNode.selectSingleNode',
+    'CustomXmlNode.text',
+    'CustomXmlNode.xml',
+    'CustomXmlNode.xpath',
+    'CustomXmlPart.builtIn',
+    'CustomXmlPart.delete',
+    'CustomXmlPart.documentElement',
+    'CustomXmlPart.getXml',
+    'CustomXmlPart.id',
+    'CustomXmlPart.namespaceManager',
+    'CustomXmlPart.namespaceUri',
+    'CustomXmlPart.schemaCollection',
+    'CustomXmlPart.selectNodes',
+    'CustomXmlPart.selectSingleNode',
+    'CustomXmlPart.setXml',
+    'CustomXmlPartCollection.add',
+    'CustomXmlPartCollection.getByNamespace',
+    'CustomXmlPartCollection.getItem',
+    'CustomXmlPartCollection.items',
+    'CustomXmlPrefixMappingCollection.addNamespace',
+    'CustomXmlPrefixMappingCollection.items',
+    'CustomXmlPrefixMappingCollection.lookupNamespace',
+    'CustomXmlPrefixMappingCollection.lookupPrefix',
+    'DatePickerContentControl.dateCalendarType',
+    'DatePickerContentControl.dateDisplayFormat',
+    'DatePickerContentControl.dateDisplayLocale',
+    'DatePickerContentControl.dateStorageFormat',
+    'Document.body',
+    'Document.changeTrackingMode',
+    'Document.getTrackedChanges',
+    'Font.bold',
+    'Font.color',
+    'Font.highlightColor',
+    'Font.italic',
+    'Font.name',
+    'Font.size',
+    'Font.strikeThrough',
+    'Font.subscript',
+    'Font.superscript',
+    'Font.underline',
+    'InlinePicture.altTextDescription',
+    'InlinePicture.altTextTitle',
+    'InlinePicture.delete',
+    'InlinePicture.getBase64ImageSrc',
+    'InlinePicture.height',
+    'InlinePicture.imageFormat',
+    'InlinePicture.paragraph',
+    'InlinePicture.width',
+    'List.getLevelFont',
+    'List.getLevelParagraphs',
+    'List.getLevelString',
+    'List.id',
+    'List.insertParagraph',
+    'List.levelExistences',
+    'List.levelTypes',
+    'List.paragraphs',
+    'List.setLevelAlignment',
+    'List.setLevelBullet',
+    'List.setLevelIndents',
+    'List.setLevelNumbering',
+    'List.setLevelStartingNumber',
+    'ListContentControl.addListItem',
+    'ListContentControl.deleteAllListItems',
+    'ListContentControl.listItems',
+    'ListItem.getAncestor',
+    'ListItem.getDescendants',
+    'ListItem.level',
+    'ListItem.listString',
+    'ListItem.siblingIndex',
+    'Paragraph.alignment',
+    'Paragraph.attachToList',
+    'Paragraph.delete',
+    'Paragraph.detachFromList',
+    'Paragraph.firstLineIndent',
+    'Paragraph.font',
+    'Paragraph.getComments',
+    'Paragraph.getRange',
+    'Paragraph.getTrackedChanges',
+    'Paragraph.insertBreak',
+    'Paragraph.insertComment',
+    'Paragraph.insertParagraph',
+    'Paragraph.insertText',
+    'Paragraph.isListItem',
+    'Paragraph.leftIndent',
+    'Paragraph.lineSpacing',
+    'Paragraph.list',
+    'Paragraph.listItem',
+    'Paragraph.listItemOrNullObject',
+    'Paragraph.listOrNullObject',
+    'Paragraph.outlineLevel',
+    'Paragraph.rightIndent',
+    'Paragraph.search',
+    'Paragraph.spaceAfter',
+    'Paragraph.spaceBefore',
+    'Paragraph.startNewList',
+    'Paragraph.style',
+    'Paragraph.styleBuiltIn',
+    'Paragraph.text',
+    'PictureContentControl.inlinePicture',
+    'Range.delete',
+    'Range.font',
+    'Range.getComments',
+    'Range.getRange',
+    'Range.getTrackedChanges',
+    'Range.insertComment',
+    'Range.insertParagraph',
+    'Range.insertText',
+    'Range.search',
+    'Range.style',
+    'Range.text',
+    'RepeatingSectionContentControl.allowInsertDeleteSection',
+    'RepeatingSectionContentControl.items',
+    'RepeatingSectionContentControl.sectionTitle',
+    'SearchOptions.matchCase',
+    'SearchOptions.matchWholeWord',
+    'SearchOptions.matchWildcards',
+    'Table.addRows',
+    'Table.delete',
+    'Table.deleteRows',
+    'Table.getCell',
+    'Table.headerRowCount',
+    'Table.rowCount',
+    'Table.rows',
+    'Table.style',
+    'Table.styleBuiltIn',
+    'Table.values',
+    'TableCell.body',
+    'TableCell.cellIndex',
+    'TableCell.columnWidth',
+    'TableCell.parentRow',
+    'TableCell.parentTable',
+    'TableCell.rowIndex',
+    'TableCell.value',
+    'TableCell.width',
+    'TableRow.cellCount',
+    'TableRow.cells',
+    'TableRow.delete',
+    'TableRow.insertRows',
+    'TableRow.isHeader',
+    'TableRow.parentTable',
+    'TableRow.rowIndex',
+    'TableRow.values',
+    'TrackedChange.accept',
+    'TrackedChange.author',
+    'TrackedChange.date',
+    'TrackedChange.getRange',
+    'TrackedChange.reject',
+    'TrackedChange.text',
+    'TrackedChange.type',
+    'XmlMapping.customXmlNode',
+    'XmlMapping.customXmlPart',
+    'XmlMapping.delete',
+    'XmlMapping.isMapped',
+    'XmlMapping.prefixMappings',
+    'XmlMapping.setMapping',
+    'XmlMapping.setMappingByNode',
+    'XmlMapping.xpath',
+];

package/dist/office-js/supported.mjs

@@ -0,0 +1,53 @@
+// `Word.supported`: the `Class.member` strings this package implements, so that a tool (CR-003's
+// console, an agent writing a script) can check an add-in script before running it. The Office JS
+// half is generated from `test/office-js-subset.ts`, which is the compile-time promise that those
+// members exist and have Office JS's shape; the shim's own surface is listed here.
+import { SUBSET_MEMBERS } from './supported.generated.mjs';
+/** What every proxied object answers, whatever its class. */
+const UNIVERSAL_MEMBERS = ['load', 'track', 'untrack', 'isNullObject', 'toJSON'];
+/** The collection members the shim adds to an array of views. */
+const COLLECTION_MEMBERS = ['items', 'getFirst', 'getFirstOrNullObject', 'getLast', 'getLastOrNullObject', 'getCount', 'length', ...UNIVERSAL_MEMBERS];
+/** The classes a collection is of; phases C, E and G fill in the ones whose views are not here yet. */
+const COLLECTION_CLASSES = ['Paragraph', 'Range', 'Table', 'TableRow', 'TableCell', 'ContentControl', 'Comment', 'InlinePicture', 'List', 'ListItem', 'Field', 'TrackedChange', 'CustomXmlPart'];
+/** The shim's own members: the context, the document and what it adds over the views. */
+const SHIM_MEMBERS = [
+    'RequestContext.document', 'RequestContext.sync', 'RequestContext.trackedObjects', 'RequestContext.package_',
+    'Document.body', 'Document.properties', 'Document.changeTrackingMode', 'Document.getSelection', 'Document.getComments',
+    'Document.getOoxml', 'Document.save', 'Document.package_',
+    'DocumentProperties.title', 'DocumentProperties.subject', 'DocumentProperties.author', 'DocumentProperties.comments',
+    'DocumentProperties.keywords', 'DocumentProperties.category', 'DocumentProperties.lastAuthor', 'DocumentProperties.revisionNumber',
+    'DocumentProperties.creationDate', 'DocumentProperties.lastSaveTime', 'DocumentProperties.lastPrintDate',
+    'DocumentProperties.manager', 'DocumentProperties.company', 'DocumentProperties.applicationName', 'DocumentProperties.template',
+    'DocumentProperties.security',
+    // over the views (src/office-js/extras.mts) and the extensions the views themselves offer
+    'Body.getOoxml', 'Body.getXml', 'Body.insertXml', 'Body.insertElement', 'Body.content', 'Body.tables',
+    'Body.paragraphAt', 'Body.elementAt', 'Body.addressOf', 'Body.outline', 'Body.getContent',
+    'Paragraph.getOoxml', 'Paragraph.getXml', 'Paragraph.paraId', 'Paragraph.runs', 'Paragraph.element', 'Paragraph.p',
+    'Paragraph.parentBody', 'Paragraph.index', 'Paragraph.splitAt', 'Paragraph.segments',
+    'Range.getOoxml', 'Range.getXml', 'Range.runs', 'Range.paragraph', 'Range.paragraphs', 'Range.start', 'Range.end',
+    // lists (CR-002 phase H): the extensions beside the Office JS members the subset declares
+    'Body.listLabels', 'Paragraph.restartList', 'Paragraph.numPr', 'Paragraph.pPr',
+    'List.numId', 'List.definition', 'List.element', 'List.abstractElement', 'List.level',
+    'List.levelExists', 'List.separate', 'List.restart', 'List.body',
+    'ListItem.list', 'ListItem.paragraph',
+];
+function build() {
+    const all = new Set(SUBSET_MEMBERS);
+    for (const className of new Set([...SUBSET_MEMBERS].map((m) => m.split('.')[0]))) {
+        for (const member of UNIVERSAL_MEMBERS)
+            all.add(`${className}.${member}`);
+    }
+    for (const member of SHIM_MEMBERS)
+        all.add(member);
+    for (const className of COLLECTION_CLASSES) {
+        for (const member of COLLECTION_MEMBERS)
+            all.add(`${className}Collection.${member}`);
+    }
+    return all;
+}
+/**
+ * Every member this package implements, as `Class.member` (`'Body.insertParagraph'`). A member
+ * that is not here throws `NotSupportedError` when an add-in calls it through the shim.
+ */
+export const supported = build();
+export { SUBSET_MEMBERS };