web-doc 0.10.0 → 0.11.0

package/dist/adapters/office.js

@@ -86,7 +86,6 @@ export class OfficeDocumentAdapter {
             useGoogleFonts: false,
             maxZipEntryBytes: context.limits.maxZipEntryBytes,
             mode: "main",
-            ...(reopening ? { progressiveLayout: true } : {}),
         };
         try {
             const kind = kindFor(format);
@@ -113,7 +112,10 @@ export class OfficeDocumentAdapter {
             }
             const buffer = exactArrayBuffer(data);
             if (kind === "presentation") {
-                const backend = await this.#loadPptx(buffer, engineOptions);
+                const backend = await this.#loadPptx(buffer, {
+                    ...engineOptions,
+                    ...(reopening ? { progressiveLayout: true } : {}),
+                });
                 throwIfAborted(context.signal, backend);
                 context.reportProgress({
                     phase: "parsing",

package/dist/edit/docx/engine.d.ts

@@ -3,10 +3,12 @@ import type { BatchMode, EditEngine, EngineBatch, EngineChange, MaterializedDocu
 import { OoxmlPackage } from "../ooxml/package.js";
 import type { EditFindOptions, EditOperation, ElementQuery, OperationIssue, PagePoint, TextTarget } from "../types.js";
 import { DocxModel, type AnyRecord } from "./model.js";
-import type { DocxElement, DocxRevision } from "./types.js";
+import type { DocxElement, DocxRevision, DocxTextStyle } from "./types.js";
+import { type TextSpan } from "../range-style.js";
 /** Reads the DOCX session adds on top of the core, served by the engine and the worker client alike. */
 export interface DocxEngineReads {
     revisions(id: string, signal: AbortSignal): Promise<readonly DocxRevision[]>;
+    textStyle(id: string, span: TextSpan | undefined, signal: AbortSignal): Promise<Partial<DocxTextStyle> | undefined>;
 }
 export declare class DocxEditEngine implements EditEngine, DocxEngineReads {
     #private;
@@ -25,6 +27,12 @@ export declare class DocxEditEngine implements EditEngine, DocxEngineReads {
     apply(input: EngineBatch | readonly EditOperation[], signal: AbortSignal): Promise<EngineChange>;
     /** The revisions of a paragraph; none for another element or an unknown id. */
     revisions(id: string, signal: AbortSignal): Promise<readonly DocxRevision[]>;
+    /**
+     * The style a span of a paragraph shows: what every run it covers shares;
+     * the paragraph mark's for an empty paragraph. None for another element,
+     * an unknown id or a span past the text.
+     */
+    textStyle(id: string, span: TextSpan | undefined, signal: AbortSignal): Promise<Partial<DocxTextStyle> | undefined>;
     materialize(purposeOrSignal?: "show" | "save" | AbortSignal, options?: MaterializeOptions, signal?: AbortSignal): Promise<Uint8Array>;
     /**
      * `save` is the package as the session changed it: ids written only on

package/dist/edit/docx/engine.js

@@ -7,9 +7,11 @@ import { NO_PAGE, toElement } from "./elements.js";
 import { docxHandlers } from "./handlers.js";
 import { freshParagraphId, paragraphsOf } from "./ids.js";
 import { DocxModel } from "./model.js";
+import { resolveTextStyle } from "./style.js";
 import { issueCollector, } from "./operations.js";
 import { docxOperationSchemas } from "./schemas.js";
 import { revisionsOf } from "./tracked.js";
+import { runsCovering, sharedStyle, spanFits, } from "../range-style.js";
 import { attributeProblem, namespacePatches } from "./write.js";
 /*
  * The DOCX edit engine: the package layer under a block index of the body
@@ -303,6 +305,26 @@ export class DocxEditEngine {
             return [];
         return revisionsOf(model.document, record.node);
     }
+    /**
+     * The style a span of a paragraph shows: what every run it covers shares;
+     * the paragraph mark's for an empty paragraph. None for another element,
+     * an unknown id or a span past the text.
+     */
+    async textStyle(id, span, signal) {
+        const model = await this.model(signal);
+        const record = model.byId.get(id);
+        if (!record || record.kind !== "paragraph")
+            return undefined;
+        const { text, items } = record.text;
+        const range = span ?? { start: 0, end: text.length };
+        if (!spanFits(range, text.length))
+            return undefined;
+        const covered = runsCovering(items, range);
+        const mark = record.pPr?.children.find((child) => child.local === "rPr");
+        return sharedStyle(covered.length > 0
+            ? covered.map((item) => resolveTextStyle(model.styles, record.pPr, item.rPr))
+            : [resolveTextStyle(model.styles, record.pPr, mark)]);
+    }
     async materialize(purposeOrSignal = "show", options = {}, signal = new AbortController().signal) {
         return (await this.materializeDocument(purposeOrSignal, options, signal))
             .bytes;

package/dist/edit/docx/provider.d.ts

@@ -2,7 +2,8 @@ import type { EditEngineContext } from "../engine.js";
 import { type OoxmlEditProviderOptions } from "../ooxml/worker.js";
 import { WorkerEngineClient } from "../worker-engine.js";
 import type { DocxEngineReads } from "./engine.js";
-import type { DocxRevision } from "./types.js";
+import type { TextSpan } from "../range-style.js";
+import type { DocxRevision, DocxTextStyle } from "./types.js";
 export type DocxEditProviderOptions = OoxmlEditProviderOptions;
 /**
  * Starts the OOXML edit worker for `original` as a DOCX engine. Loaded
@@ -12,5 +13,6 @@ export declare function loadDocxEditEngine(original: Uint8Array, context: EditEn
 export declare class DocxEditEngineClient extends WorkerEngineClient implements DocxEngineReads {
     readonly schemas: import("../types.js").OperationSchemaSet;
     revisions(id: string, signal: AbortSignal): Promise<readonly DocxRevision[]>;
+    textStyle(id: string, span: TextSpan | undefined, signal: AbortSignal): Promise<Partial<DocxTextStyle> | undefined>;
     start(original: Uint8Array): Promise<void>;
 }

package/dist/edit/docx/provider.js

@@ -24,6 +24,9 @@ export class DocxEditEngineClient extends WorkerEngineClient {
     revisions(id, signal) {
         return this.request("edit-docx-revisions", { id }, signal);
     }
+    textStyle(id, span, signal) {
+        return this.request("edit-docx-text-style", { id, span }, signal);
+    }
     async start(original) {
         const data = original.slice().buffer;
         const open = {

package/dist/edit/docx/session.d.ts

@@ -1,7 +1,7 @@
 import type { DescribeOptions, DocumentDescription, EditCheckpoint, OutlineOptions, OutlineResult, TargetCandidate, TargetQuery, ToolCall, ToolCallOptions, ToolResult, ToolSet } from "../ai/types.js";
 import type { EditSessionAccess, EditSessionCore } from "../engine.js";
-import type { ApplyOptions, AssetOptions, EditFindOptions, EditOperation, EditReceipt, EditState, ElementQuery, HistoryOptions, OperationSchemaSet, PagePoint, PageRect, ReadItem, ReadOptions, ReadResult, SavedDocument, TextTarget } from "../types.js";
-import type { DocxDeleteElementOperation, DocxEditSession, DocxElement, DocxFields, DocxInsertImageOperation, DocxInsertParagraphOperation, DocxInsertTableOperation, DocxMoveElementOperation, DocxOperation, DocxReplaceTextOperation, DocxRevision, DocxSaveOptions, DocxSetParagraphStyleOperation, DocxSetTableCellOperation, DocxSetTextStyleOperation } from "./types.js";
+import type { ApplyOptions, AssetOptions, EditFindOptions, EditOperation, EditReceipt, EditState, ElementQuery, HistoryOptions, OperationSchemaSet, PagePoint, PageRect, ReadItem, ReadOptions, ReadResult, SavedDocument, TextRange, TextTarget } from "../types.js";
+import type { DocxDeleteElementOperation, DocxEditSession, DocxElement, DocxFields, DocxInsertImageOperation, DocxInsertParagraphOperation, DocxInsertTableOperation, DocxMoveElementOperation, DocxOperation, DocxReplaceTextOperation, DocxRevision, DocxSaveOptions, DocxSetParagraphStyleOperation, DocxSetTableCellOperation, DocxSetTextStyleOperation, DocxTextStyle } from "./types.js";
 /** Per paragraph id (eight hex digits), the union of its runs per page. */
 type Placement = ReadonlyMap<string, ReadonlyMap<number, PageRect>>;
 export declare class DocxSession implements DocxEditSession {
@@ -33,6 +33,10 @@ export declare class DocxSession implements DocxEditSession {
     get tools(): ToolSet;
     callTool(call: ToolCall, options?: ToolCallOptions): Promise<ToolResult>;
     getRevisions(elementId: string, options?: ReadOptions): Promise<ReadResult<DocxRevision>>;
+    getTextStyle(fields: {
+        readonly target: string;
+        readonly range?: TextRange;
+    }, options?: ReadOptions): Promise<ReadItem<Partial<DocxTextStyle>>>;
     replaceText(fields: DocxFields<DocxReplaceTextOperation>, options?: ApplyOptions): Promise<EditReceipt>;
     setTextStyle(fields: DocxFields<DocxSetTextStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
     setParagraphStyle(fields: DocxFields<DocxSetParagraphStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;

package/dist/edit/docx/session.js

@@ -2,6 +2,7 @@ import { readDescription, readOutline } from "../ai/outline.js";
 import { resolveTargets } from "../ai/targets.js";
 import { buildToolSet, callTool as runTool } from "../ai/tools.js";
 import { ViewerError } from "../../errors.js";
+import { spanOnTarget } from "../range-style.js";
 export class DocxSession {
     format = "docx";
     #core;
@@ -134,6 +135,10 @@ export class DocxSession {
     getRevisions(elementId, options) {
         return this.#core.readItems(options, (engine, signal) => docxReads(engine).revisions(elementId, signal));
     }
+    async getTextStyle(fields, options) {
+        const span = spanOnTarget(fields.target, fields.range);
+        return this.#core.readItem(options, (engine, signal) => docxReads(engine).textStyle(fields.target, span, signal));
+    }
     replaceText(fields, options) {
         return this.apply([{ op: "replaceText", ...fields }], options);
     }
@@ -461,7 +466,8 @@ function matchesQuery(element, query) {
 }
 function docxReads(engine) {
     const candidate = engine;
-    if (typeof candidate.revisions !== "function")
+    if (typeof candidate.revisions !== "function" ||
+        typeof candidate.textStyle !== "function")
         throw new ViewerError("edit-unsupported", "The engine does not provide the DOCX reads", { details: { format: "docx", reason: "no-reads" } });
     return candidate;
 }

package/dist/edit/docx/style.d.ts

@@ -34,7 +34,7 @@ export declare class DocxStyles {
     /** A style and the styles it is based on, nearest first; cycles stop. */
     chain(id: string | undefined): StyleRecord[];
 }
-/** `w:b`, `w:i`, `w:default`-style toggles: present without a value means on. */
+/** `w:b`/`w:i` toggle values: a present element without `w:val` means on. */
 export declare function isOn(value: string | undefined): boolean;
 /** The run property holders in resolution order for a run of a paragraph. */
 export declare function runPropertySources(styles: DocxStyles, pPr: XmlElement | undefined, rPr: XmlElement | undefined): readonly XmlElement[];

package/dist/edit/docx/style.js

@@ -95,11 +95,12 @@ export class DocxStyles {
             if (!id)
                 continue;
             const basedOn = part.attribute(node.children.find((child) => child.local === "basedOn") ?? node, "w:val");
+            const defaultAttribute = part.attribute(node, "w:default");
             const record = {
                 id,
                 type: part.attribute(node, "w:type") ?? "paragraph",
                 ...(basedOn && basedOn !== id ? { basedOn } : {}),
-                isDefault: isOn(part.attribute(node, "w:default")),
+                isDefault: defaultAttribute !== undefined && isOn(defaultAttribute),
                 ...pick(node, "rPr", "pPr"),
             };
             styles.set(id, record);
@@ -175,7 +176,7 @@ async function readTheme(pkg, themePart, signal) {
         return none;
     }
 }
-/** `w:b`, `w:i`, `w:default`-style toggles: present without a value means on. */
+/** `w:b`/`w:i` toggle values: a present element without `w:val` means on. */
 export function isOn(value) {
     return value === undefined || !/^(0|false|off)$/i.test(value);
 }

package/dist/edit/docx/types.d.ts

@@ -1,4 +1,4 @@
-import type { ApplyOptions, BinaryData, EditColor, EditElement, EditReceipt, EditSessionBase, ReadOptions, ReadResult, SavedDocument, SaveOptions, TextRange } from "../types.js";
+import type { ApplyOptions, BinaryData, EditColor, EditElement, EditReceipt, EditSessionBase, ReadItem, ReadOptions, ReadResult, SavedDocument, SaveOptions, TextRange } from "../types.js";
 export type DocxElementKind = "paragraph" | "table" | "image" | "other";
 export type DocxTextAlign = "left" | "center" | "right" | "justify";
 /** Word's sixteen highlight colours (`w:highlight/@w:val`). */
@@ -193,6 +193,16 @@ export interface DocxEditSession extends EditSessionBase<DocxOperation, DocxElem
     save(options?: DocxSaveOptions): Promise<SavedDocument>;
     /** The tracked changes a paragraph holds, in document order; empty for other elements. */
     getRevisions(elementId: string, options?: ReadOptions): Promise<ReadResult<DocxRevision>>;
+    /**
+     * The text style a range of a paragraph shows: each property every run it
+     * covers shares, a property they differ on left out. Without a range, the
+     * whole text; a collapsed range reads the run before it, whose style text
+     * typed there takes. `undefined` for an element without text.
+     */
+    getTextStyle(fields: {
+        readonly target: string;
+        readonly range?: TextRange;
+    }, options?: ReadOptions): Promise<ReadItem<Partial<DocxTextStyle>>>;
     /** Replaces the whole text of a paragraph, or the part a range covers. */
     replaceText(fields: DocxFields<DocxReplaceTextOperation>, options?: ApplyOptions): Promise<EditReceipt>;
     /** Changes run properties; unspecified ones keep their bytes. */

package/dist/edit/pptx/elements.d.ts

@@ -4,7 +4,8 @@ import { type Matrix, type PlacedFrame, type Xfrm } from "./geometry.js";
 import type { DeckModel, SlideRecord } from "./model.js";
 import { type StyleSource } from "./style.js";
 import { type TextModel } from "./text.js";
-import type { PptxElement, PptxPlaceholder } from "./types.js";
+import { type TextSpan } from "../range-style.js";
+import type { PptxElement, PptxPlaceholder, PptxTextStyle } from "./types.js";
 /** What the engine knows about one element beyond what it reports. */
 export interface ShapeRecord {
     readonly element: PptxElement;
@@ -28,6 +29,8 @@ export interface ShapeRecord {
     /** Inside the fallback branch of `mc:AlternateContent`. */
     readonly readOnly: boolean;
     readonly parent?: ShapeRecord;
+    /** The style a span of the shape's text shows: what every run it covers shares. */
+    readonly styleOf?: (span: TextSpan) => Partial<PptxTextStyle> | undefined;
 }
 export interface SlideElements {
     readonly slide: SlideRecord;

package/dist/edit/pptx/elements.js

@@ -1,6 +1,7 @@
 import { groupMatrix, IDENTITY, multiply, placeFrame, readXfrm, } from "./geometry.js";
 import { resolveTextStyle, readShapeStyle } from "./style.js";
 import { firstTextRun, readTableCells, readTextModel, } from "./text.js";
+import { runsCovering, sharedStyle } from "../range-style.js";
 /*
  * The elements of a slide, read from its XML: every child of the shape tree
  * with its frame (own, or inherited from the layout and master for a
@@ -236,6 +237,11 @@ function readRecord(context, node, parents, parent, readOnly, walk) {
         ...(text ? { text } : {}),
         readOnly,
         ...(parent ? { parent } : {}),
+        ...(text && txBody
+            ? {
+                styleOf: (span) => rangeStyleOf(context, placeholder, txBody, text, span),
+            }
+            : {}),
     };
 }
 function operationsFor(kind, hasText) {
@@ -285,6 +291,35 @@ export function listStylesOf(context, txBody, placeholder) {
         lists.push(defaults);
     return lists;
 }
+/**
+ * The style a span of a text body shows: each run it covers resolves through
+ * its paragraph and the inherited lists, and the properties they all share
+ * are kept. An empty paragraph reads its end-of-paragraph properties.
+ */
+function rangeStyleOf(context, placeholder, txBody, text, span) {
+    const lists = listStylesOf(context, txBody, placeholder);
+    const styleOf = (paragraph, rPr) => resolveTextStyle({
+        ...(rPr ? { rPr: { part: context.part, node: rPr } } : {}),
+        ...(paragraph.pPr
+            ? { pPr: { part: context.part, node: paragraph.pPr } }
+            : {}),
+        level: paragraph.level,
+        lists,
+        fonts: context.fonts,
+    });
+    const runs = text.paragraphs.flatMap((paragraph) => paragraph.runs.map((run) => ({
+        start: run.start,
+        end: run.end,
+        style: () => styleOf(paragraph, run.rPr),
+    })));
+    const covered = runsCovering(runs, span);
+    if (covered.length > 0)
+        return sharedStyle(covered.map((run) => run.style()));
+    const paragraph = text.paragraphs.find((candidate) => candidate.start <= span.start && span.start <= candidate.end) ?? text.paragraphs[0];
+    return paragraph
+        ? sharedStyle([styleOf(paragraph, paragraph.endParaRPr)])
+        : undefined;
+}
 function textStyleOf(context, placeholder, txBody, text) {
     const first = firstTextRun(text);
     const paragraph = first?.paragraph ?? text.paragraphs[0];

package/dist/edit/pptx/engine.d.ts

@@ -3,11 +3,13 @@ import type { EditEngine, EngineBatch, EngineChange, MaterializedDocument, Mater
 import { OoxmlPackage } from "../ooxml/package.js";
 import type { EditFindOptions, EditOperation, ElementQuery, OperationIssue, PagePoint, TextTarget } from "../types.js";
 import { DeckModel } from "./model.js";
-import type { PptxElement, PptxLayoutInfo, PptxSlideInfo } from "./types.js";
+import type { PptxElement, PptxLayoutInfo, PptxSlideInfo, PptxTextStyle } from "./types.js";
+import { type TextSpan } from "../range-style.js";
 /** The reads behind `getSlides` and `getLayouts`, beyond the core engine interface. */
 export interface PptxEngineReads {
     slides(signal: AbortSignal): Promise<readonly PptxSlideInfo[]>;
     layouts(signal: AbortSignal): Promise<readonly PptxLayoutInfo[]>;
+    textStyle(id: string, span: TextSpan | undefined, signal: AbortSignal): Promise<Partial<PptxTextStyle> | undefined>;
 }
 export declare class PptxEditEngine implements EditEngine, PptxEngineReads {
     #private;
@@ -32,6 +34,8 @@ export declare class PptxEditEngine implements EditEngine, PptxEngineReads {
     elementsAt(pageIndex: number, point: PagePoint, signal: AbortSignal): Promise<readonly PptxElement[]>;
     findText(query: string, options: EditFindOptions, signal: AbortSignal): Promise<readonly TextTarget[]>;
     slides(signal: AbortSignal): Promise<readonly PptxSlideInfo[]>;
+    /** The style a span of a shape's text shows; none for an element without text or a span past it. */
+    textStyle(id: string, span: TextSpan | undefined, signal: AbortSignal): Promise<Partial<PptxTextStyle> | undefined>;
     layouts(signal: AbortSignal): Promise<readonly PptxLayoutInfo[]>;
     dispose(): Promise<void>;
 }

package/dist/edit/pptx/engine.js

@@ -8,6 +8,7 @@ import { DeckModel } from "./model.js";
 import { pptxHandlers } from "./handlers.js";
 import { issueCollector, } from "./operations.js";
 import { pptxOperationSchemas } from "./schemas.js";
+import { spanFits } from "../range-style.js";
 const SLIDE_PART = /^\/ppt\/slides\/slide(\d+)\.xml$/i;
 const SLIDE_RELS = /^\/ppt\/slides\/_rels\/slide(\d+)\.xml\.rels$/i;
 export class PptxEditEngine {
@@ -357,6 +358,16 @@ export class PptxEditEngine {
             });
         return out;
     }
+    /** The style a span of a shape's text shows; none for an element without text or a span past it. */
+    async textStyle(id, span, signal) {
+        const record = await this.#locate(id, signal);
+        if (!record?.styleOf || !record.text)
+            return undefined;
+        const range = span ?? { start: 0, end: record.text.text.length };
+        if (!spanFits(range, record.text.text.length))
+            return undefined;
+        return record.styleOf(range);
+    }
     async layouts(signal) {
         const model = await this.model(signal);
         return model.layouts.map((layout) => ({

package/dist/edit/pptx/handler.js

@@ -88,6 +88,14 @@ export function createOoxmlEditHandler() {
                 return pptx().layouts(signal);
             case "edit-docx-revisions":
                 return docx().revisions(payload.id, signal);
+            case "edit-docx-text-style": {
+                const { id, span } = payload;
+                return docx().textStyle(id, span, signal);
+            }
+            case "edit-pptx-text-style": {
+                const { id, span } = payload;
+                return pptx().textStyle(id, span, signal);
+            }
             case "edit-dispose":
                 await state?.dispose();
                 state = undefined;

package/dist/edit/pptx/provider.d.ts

@@ -1,8 +1,9 @@
 import type { EditEngineContext } from "../engine.js";
 import { type OoxmlEditProviderOptions } from "../ooxml/worker.js";
 import { WorkerEngineClient } from "../worker-engine.js";
+import type { TextSpan } from "../range-style.js";
 import type { PptxEngineReads } from "./engine.js";
-import type { PptxLayoutInfo, PptxSlideInfo } from "./types.js";
+import type { PptxLayoutInfo, PptxSlideInfo, PptxTextStyle } from "./types.js";
 export type PptxEditProviderOptions = OoxmlEditProviderOptions;
 /**
  * Starts the OOXML edit worker for `original` as a PPTX engine. Loaded
@@ -14,4 +15,5 @@ export declare class PptxEditEngineClient extends WorkerEngineClient implements
     start(original: Uint8Array): Promise<void>;
     slides(signal: AbortSignal): Promise<readonly PptxSlideInfo[]>;
     layouts(signal: AbortSignal): Promise<readonly PptxLayoutInfo[]>;
+    textStyle(id: string, span: TextSpan | undefined, signal: AbortSignal): Promise<Partial<PptxTextStyle> | undefined>;
 }

package/dist/edit/pptx/provider.js

@@ -37,4 +37,7 @@ export class PptxEditEngineClient extends WorkerEngineClient {
     layouts(signal) {
         return this.request("edit-pptx-layouts", undefined, signal);
     }
+    textStyle(id, span, signal) {
+        return this.request("edit-pptx-text-style", { id, span }, signal);
+    }
 }

package/dist/edit/pptx/session.d.ts

@@ -1,7 +1,7 @@
 import type { DescribeOptions, DocumentDescription, EditCheckpoint, OutlineOptions, OutlineResult, TargetCandidate, TargetQuery, ToolCall, ToolCallOptions, ToolResult, ToolSet } from "../ai/types.js";
 import type { EditSessionAccess, EditSessionCore } from "../engine.js";
-import type { ApplyOptions, AssetOptions, EditFindOptions, EditOperation, EditReceipt, EditState, ElementQuery, HistoryOptions, OperationSchemaSet, PagePoint, ReadItem, ReadOptions, ReadResult, SavedDocument, TextTarget } from "../types.js";
-import type { PptxDeleteElementOperation, PptxDeleteSlideOperation, PptxDuplicateSlideOperation, PptxEditSession, PptxElement, PptxFields, PptxInsertImageOperation, PptxInsertSlideOperation, PptxInsertTableOperation, PptxInsertTextBoxOperation, PptxLayoutInfo, PptxMoveElementOperation, PptxMoveSlideOperation, PptxOperation, PptxReplaceTextOperation, PptxResizeElementOperation, PptxSaveOptions, PptxSetShapeStyleOperation, PptxSetTableCellOperation, PptxSetTextStyleOperation, PptxSlideInfo } from "./types.js";
+import type { ApplyOptions, AssetOptions, EditFindOptions, EditOperation, EditReceipt, EditState, ElementQuery, HistoryOptions, OperationSchemaSet, PagePoint, ReadItem, ReadOptions, ReadResult, SavedDocument, TextRange, TextTarget } from "../types.js";
+import type { PptxDeleteElementOperation, PptxDeleteSlideOperation, PptxDuplicateSlideOperation, PptxEditSession, PptxElement, PptxFields, PptxInsertImageOperation, PptxInsertSlideOperation, PptxInsertTableOperation, PptxInsertTextBoxOperation, PptxLayoutInfo, PptxMoveElementOperation, PptxMoveSlideOperation, PptxOperation, PptxReplaceTextOperation, PptxResizeElementOperation, PptxSaveOptions, PptxSetShapeStyleOperation, PptxSetTableCellOperation, PptxSetTextStyleOperation, PptxSlideInfo, PptxTextStyle } from "./types.js";
 /**
  * The PPTX session: the core session narrowed to PPTX operations and
  * elements, plus the slide and layout reads. Each typed method is `apply()`
@@ -42,6 +42,10 @@ export declare class PptxSession implements PptxEditSession {
     callTool(call: ToolCall, options?: ToolCallOptions): Promise<ToolResult>;
     getSlides(options?: ReadOptions): Promise<ReadResult<PptxSlideInfo>>;
     getLayouts(options?: ReadOptions): Promise<ReadResult<PptxLayoutInfo>>;
+    getTextStyle(fields: {
+        readonly target: string;
+        readonly range?: TextRange;
+    }, options?: ReadOptions): Promise<ReadItem<Partial<PptxTextStyle>>>;
     replaceText(fields: PptxFields<PptxReplaceTextOperation>, options?: ApplyOptions): Promise<EditReceipt>;
     setTextStyle(fields: PptxFields<PptxSetTextStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
     setShapeStyle(fields: PptxFields<PptxSetShapeStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;

package/dist/edit/pptx/session.js

@@ -2,6 +2,7 @@ import { ViewerError } from "../../errors.js";
 import { readDescription, readOutline } from "../ai/outline.js";
 import { resolveTargets } from "../ai/targets.js";
 import { buildToolSet, callTool as runTool } from "../ai/tools.js";
+import { spanOnTarget } from "../range-style.js";
 /**
  * The PPTX session: the core session narrowed to PPTX operations and
  * elements, plus the slide and layout reads. Each typed method is `apply()`
@@ -118,6 +119,10 @@ export class PptxSession {
     getLayouts(options) {
         return this.#core.readItems(options, (engine, signal) => pptxReads(engine).layouts(signal));
     }
+    async getTextStyle(fields, options) {
+        const span = spanOnTarget(fields.target, fields.range);
+        return this.#core.readItem(options, (engine, signal) => pptxReads(engine).textStyle(fields.target, span, signal));
+    }
     replaceText(fields, options) {
         return this.apply([{ op: "replaceText", ...fields }], options);
     }
@@ -165,7 +170,8 @@ export class PptxSession {
 function pptxReads(engine) {
     const candidate = engine;
     if (typeof candidate.slides !== "function" ||
-        typeof candidate.layouts !== "function")
+        typeof candidate.layouts !== "function" ||
+        typeof candidate.textStyle !== "function")
         throw new ViewerError("edit-unsupported", "The engine does not provide the PPTX reads", { details: { format: "pptx", reason: "no-reads" } });
     return candidate;
 }

package/dist/edit/pptx/types.d.ts

@@ -1,4 +1,4 @@
-import type { ApplyOptions, BinaryData, EditColor, EditElement, EditReceipt, EditSessionBase, PagePoint, PageRect, ReadOptions, ReadResult, SavedDocument, SaveOptions, TextRange } from "../types.js";
+import type { ApplyOptions, BinaryData, EditColor, EditElement, EditReceipt, EditSessionBase, PagePoint, PageRect, ReadItem, ReadOptions, ReadResult, SavedDocument, SaveOptions, TextRange } from "../types.js";
 export type PptxElementKind = "shape" | "image" | "table" | "connector" | "group" | "other";
 export type PptxTextAlign = "left" | "center" | "right" | "justify";
 /** The style of the first run with text, resolved through the placeholder chain and the theme. */
@@ -201,6 +201,16 @@ export interface PptxEditSession extends EditSessionBase<PptxOperation, PptxElem
     getSlides(options?: ReadOptions): Promise<ReadResult<PptxSlideInfo>>;
     /** Every layout of every master, for `insertSlide`. */
     getLayouts(options?: ReadOptions): Promise<ReadResult<PptxLayoutInfo>>;
+    /**
+     * The text style a range of a shape's text shows: each property every run
+     * it covers shares, a property they differ on left out. Without a range,
+     * the whole text; a collapsed range reads the run before it, whose style
+     * text typed there takes. `undefined` for an element without text.
+     */
+    getTextStyle(fields: {
+        readonly target: string;
+        readonly range?: TextRange;
+    }, options?: ReadOptions): Promise<ReadItem<Partial<PptxTextStyle>>>;
     /** Replaces the whole text of a shape, or the part a range covers. */
     replaceText(fields: PptxFields<PptxReplaceTextOperation>, options?: ApplyOptions): Promise<EditReceipt>;
     /** Changes run and paragraph properties; unspecified ones keep their bytes. */

package/dist/edit/range-style.d.ts

@@ -0,0 +1,24 @@
+import type { TextRange } from "./types.js";
+/** Half-open UTF-16 offsets in an element's text. */
+export interface TextSpan {
+    readonly start: number;
+    readonly end: number;
+}
+/**
+ * The span a range names on its target, or `undefined` for no range (the
+ * whole text). Both ends must lie on the target.
+ */
+export declare function spanOnTarget(target: string, range: TextRange | undefined): TextSpan | undefined;
+/**
+ * The runs a span covers. A collapsed span reads the run before it, whose
+ * style text typed there takes, or the first run after it at the very start.
+ */
+export declare function runsCovering<R extends TextSpan>(runs: readonly R[], span: TextSpan): R[];
+/**
+ * What every style has in common: a property two of them differ on, or one
+ * some leave out, is left out. Values compare as JSON, so a theme colour and
+ * its plain form differ.
+ */
+export declare function sharedStyle<T extends object>(styles: readonly T[]): Partial<T> | undefined;
+/** Whether a span lies inside a text of `length` code units. */
+export declare function spanFits(span: TextSpan, length: number): boolean;

package/dist/edit/range-style.js

@@ -0,0 +1,46 @@
+import { ViewerError } from "../errors.js";
+/**
+ * The span a range names on its target, or `undefined` for no range (the
+ * whole text). Both ends must lie on the target.
+ */
+export function spanOnTarget(target, range) {
+    if (!range)
+        return undefined;
+    if (range.start.elementId !== target || range.end.elementId !== target)
+        throw new ViewerError("invalid-operation", "Both ends of the range must lie on the target", { details: { target } });
+    return { start: range.start.offset, end: range.end.offset };
+}
+/**
+ * The runs a span covers. A collapsed span reads the run before it, whose
+ * style text typed there takes, or the first run after it at the very start.
+ */
+export function runsCovering(runs, span) {
+    if (span.start < span.end)
+        return runs.filter((run) => run.start < span.end && run.end > span.start);
+    const before = runs
+        .filter((run) => run.start < span.start && run.end >= span.start)
+        .at(-1);
+    const at = before ?? runs.find((run) => run.start >= span.start);
+    return at ? [at] : [];
+}
+/**
+ * What every style has in common: a property two of them differ on, or one
+ * some leave out, is left out. Values compare as JSON, so a theme colour and
+ * its plain form differ.
+ */
+export function sharedStyle(styles) {
+    const [first, ...rest] = styles;
+    if (!first)
+        return undefined;
+    const shared = {};
+    for (const key of Object.keys(first)) {
+        const value = JSON.stringify(first[key]);
+        if (rest.every((style) => key in style && JSON.stringify(style[key]) === value))
+            shared[key] = first[key];
+    }
+    return shared;
+}
+/** Whether a span lies inside a text of `length` code units. */
+export function spanFits(span, length) {
+    return span.start >= 0 && span.start <= span.end && span.end <= length;
+}

package/dist/worker-protocol.d.ts

@@ -2,7 +2,7 @@ import type { DocumentFormat, DocumentInfo, ResourceLimits, TextRun, ViewerError
 import type { EditableFormat } from "./edit/types.js";
 export type DocumentWorkerOperation = "init" | "open" | "get-info" | "render" | "get-text-map" | "close" | "destroy";
 /** Operations of an edit engine worker; payloads mirror the engine interface. */
-export type EditWorkerOperation = "edit-init" | "edit-open" | "edit-validate" | "edit-apply" | "edit-materialize" | "edit-restore" | "edit-put-asset" | "edit-elements" | "edit-element" | "edit-elements-at" | "edit-find-text" | "edit-text-layout" | "edit-text-font" | "edit-position-at" | "edit-range-rects" | "edit-render-without" | "edit-page-layout" | "edit-pptx-slides" | "edit-pptx-layouts" | "edit-docx-revisions" | "edit-dispose";
+export type EditWorkerOperation = "edit-init" | "edit-open" | "edit-validate" | "edit-apply" | "edit-materialize" | "edit-restore" | "edit-put-asset" | "edit-elements" | "edit-element" | "edit-elements-at" | "edit-find-text" | "edit-text-layout" | "edit-text-font" | "edit-position-at" | "edit-range-rects" | "edit-render-without" | "edit-page-layout" | "edit-pptx-slides" | "edit-pptx-layouts" | "edit-docx-revisions" | "edit-docx-text-style" | "edit-pptx-text-style" | "edit-dispose";
 export type WorkerOperation = DocumentWorkerOperation | EditWorkerOperation;
 export interface WorkerRequest {
     readonly kind: "request";

package/dist/workers/ooxml-edit-worker.js

@@ -2166,11 +2166,12 @@ var DocxStyles = class _DocxStyles {
         node.children.find((child) => child.local === "basedOn") ?? node,
         "w:val"
       );
+      const defaultAttribute = part.attribute(node, "w:default");
       const record = {
         id,
         type: part.attribute(node, "w:type") ?? "paragraph",
         ...basedOn && basedOn !== id ? { basedOn } : {},
-        isDefault: isOn(part.attribute(node, "w:default")),
+        isDefault: defaultAttribute !== void 0 && isOn(defaultAttribute),
         ...pick(node, "rPr", "pPr")
       };
       styles.set(id, record);
@@ -5329,6 +5330,31 @@ function issueCollector(operationIndex, issues) {
   return (path, code, message) => issues.push({ operationIndex, path, code, message });
 }
 
+// src/edit/range-style.ts
+function runsCovering(runs, span) {
+  if (span.start < span.end)
+    return runs.filter((run2) => run2.start < span.end && run2.end > span.start);
+  const before = runs.filter((run2) => run2.start < span.start && run2.end >= span.start).at(-1);
+  const at = before ?? runs.find((run2) => run2.start >= span.start);
+  return at ? [at] : [];
+}
+function sharedStyle(styles) {
+  const [first, ...rest] = styles;
+  if (!first) return void 0;
+  const shared = {};
+  for (const key of Object.keys(first)) {
+    const value = JSON.stringify(first[key]);
+    if (rest.every(
+      (style) => key in style && JSON.stringify(style[key]) === value
+    ))
+      shared[key] = first[key];
+  }
+  return shared;
+}
+function spanFits(span, length) {
+  return span.start >= 0 && span.start <= span.end && span.end <= length;
+}
+
 // src/edit/docx/engine.ts
 var UNAUTHORED_PART = "/webdoc/unauthored.xml";
 var UNAUTHORED_NS = "urn:web-doc:docx-edit";
@@ -5602,6 +5628,26 @@ var DocxEditEngine = class _DocxEditEngine {
     if (!record || record.kind !== "paragraph") return [];
     return revisionsOf(model.document, record.node);
   }
+  /**
+   * The style a span of a paragraph shows: what every run it covers shares;
+   * the paragraph mark's for an empty paragraph. None for another element,
+   * an unknown id or a span past the text.
+   */
+  async textStyle(id, span, signal) {
+    const model = await this.model(signal);
+    const record = model.byId.get(id);
+    if (!record || record.kind !== "paragraph") return void 0;
+    const { text, items } = record.text;
+    const range = span ?? { start: 0, end: text.length };
+    if (!spanFits(range, text.length)) return void 0;
+    const covered = runsCovering(items, range);
+    const mark = record.pPr?.children.find((child) => child.local === "rPr");
+    return sharedStyle(
+      covered.length > 0 ? covered.map(
+        (item) => resolveTextStyle(model.styles, record.pPr, item.rPr)
+      ) : [resolveTextStyle(model.styles, record.pPr, mark)]
+    );
+  }
   async materialize(purposeOrSignal = "show", options = {}, signal = new AbortController().signal) {
     return (await this.materializeDocument(purposeOrSignal, options, signal)).bytes;
   }
@@ -6469,7 +6515,10 @@ function readRecord(context, node, parents, parent, readOnly, walk) {
     ...spPr ? { spPr } : {},
     ...text ? { text } : {},
     readOnly,
-    ...parent ? { parent } : {}
+    ...parent ? { parent } : {},
+    ...text && txBody ? {
+      styleOf: (span) => rangeStyleOf(context, placeholder, txBody, text, span)
+    } : {}
   };
 }
 function operationsFor(kind, hasText) {
@@ -6513,6 +6562,29 @@ function listStylesOf(context, txBody, placeholder) {
   if (defaults) lists.push(defaults);
   return lists;
 }
+function rangeStyleOf(context, placeholder, txBody, text, span) {
+  const lists = listStylesOf(context, txBody, placeholder);
+  const styleOf = (paragraph2, rPr) => resolveTextStyle2({
+    ...rPr ? { rPr: { part: context.part, node: rPr } } : {},
+    ...paragraph2.pPr ? { pPr: { part: context.part, node: paragraph2.pPr } } : {},
+    level: paragraph2.level,
+    lists,
+    fonts: context.fonts
+  });
+  const runs = text.paragraphs.flatMap(
+    (paragraph2) => paragraph2.runs.map((run2) => ({
+      start: run2.start,
+      end: run2.end,
+      style: () => styleOf(paragraph2, run2.rPr)
+    }))
+  );
+  const covered = runsCovering(runs, span);
+  if (covered.length > 0) return sharedStyle(covered.map((run2) => run2.style()));
+  const paragraph = text.paragraphs.find(
+    (candidate) => candidate.start <= span.start && span.start <= candidate.end
+  ) ?? text.paragraphs[0];
+  return paragraph ? sharedStyle([styleOf(paragraph, paragraph.endParaRPr)]) : void 0;
+}
 function textStyleOf(context, placeholder, txBody, text) {
   const first = firstTextRun(text);
   const paragraph = first?.paragraph ?? text.paragraphs[0];
@@ -8918,6 +8990,14 @@ var PptxEditEngine = class _PptxEditEngine {
       });
     return out;
   }
+  /** The style a span of a shape's text shows; none for an element without text or a span past it. */
+  async textStyle(id, span, signal) {
+    const record = await this.#locate(id, signal);
+    if (!record?.styleOf || !record.text) return void 0;
+    const range = span ?? { start: 0, end: record.text.text.length };
+    if (!spanFits(range, record.text.text.length)) return void 0;
+    return record.styleOf(range);
+  }
   async layouts(signal) {
     const model = await this.model(signal);
     return model.layouts.map((layout) => ({
@@ -9136,6 +9216,14 @@ function createOoxmlEditHandler() {
           payload.id,
           signal
         );
+      case "edit-docx-text-style": {
+        const { id, span } = payload;
+        return docx().textStyle(id, span, signal);
+      }
+      case "edit-pptx-text-style": {
+        const { id, span } = payload;
+        return pptx().textStyle(id, span, signal);
+      }
       case "edit-dispose":
         await state?.dispose();
         state = void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-doc",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "web-doc — embeddable browser-only document viewer with Rust/WASM adapters (a fork of Zrimo)",
   "keywords": [
     "document-viewer",