revise 3.1.7 → 4.0.1

package/document.d.ts

@@ -1,439 +0,0 @@
-import * as Y from "yjs";
-import { ydocSourceFidelity, type ReviseServerExportFormat } from "@reviseio/engine";
-import type { ImageFetchPolicy, ReviseDocumentMeasurementData, ReviseToolDefinition, ReviseJsonObject, ReviseToolArguments, ReviseToolName, ReviseToolResult, ServerDocumentSession } from "@reviseio/engine";
-/** How faithfully the document exports back to its original Word file. */
-export type SourceFidelity = Awaited<ReturnType<typeof ydocSourceFidelity>>;
-import { type DocxExportOutcome } from "./docx.js";
-import type { RenderOptions, RenderResult } from "./render.js";
-export type DocumentMode = "suggesting" | "editing";
-export type ExportFormat = ReviseServerExportFormat | "pdf";
-/** Formats the library reads. */
-export declare const READABLE: RegExp;
-/** The export format a file name implies (`out.pdf` → "pdf"). */
-export declare function formatForPath(file: string): ExportFormat | undefined;
-/** A document to read: a path, or bytes with the file name they came from. */
-export type DocumentSource = string | {
-    bytes: Uint8Array;
-    filename: string;
-};
-export interface OpenOptions {
-    /** Who edits and comments: shown as the author of tracked changes. */
-    author?: string;
-    /** "suggesting" records edits as tracked changes (the default for Word
-     * files); "editing" applies them directly (the default for plain text). */
-    mode?: DocumentMode;
-    /** A stable id for this document (tool sessions, collaboration). */
-    documentId?: string;
-    /** How images inserted by URL are fetched. By default only public http(s)
-     * hosts are reachable; see ImageFetchPolicy. */
-    images?: ImageFetchPolicy;
-}
-export interface ChangeEntry {
-    id: string;
-    type: string;
-    author: string;
-    blockId?: string;
-    blockIndex?: number;
-    /** The heading of the section the change is in. */
-    section?: string;
-    deleted: string;
-    inserted: string;
-}
-/** Narrows tracked changes by where they are. Filters combine: a change
- * must pass every one given. */
-export interface ChangeFilter {
-    /** A heading and everything under it, subsections included: its number
-     * ("8", "8.", "8.1", including Word's automatic numbering) or its title
-     * ("Allocation of risk", or part of it). */
-    section?: string;
-    /** Everything outside that section. */
-    exceptSection?: string;
-    /** Block ids, and inclusive `{ from, to }` ranges in document order. Ids
-     * of list items, table cells, and blocks inside them work. */
-    blocks?: Array<string | {
-        from: string;
-        to: string;
-    }>;
-}
-/** Which tracked changes to settle: exactly one of `ids`, `all`, or
- * filters (`section`, `exceptSection`, `blocks`). */
-export interface ChangeSelection extends ChangeFilter {
-    ids?: string[];
-    all?: boolean;
-}
-export interface SettleResult {
-    resolved: string[];
-    /** Requested ids that are not pending tracked changes. */
-    missing: string[];
-    /** Pending changes that could not be settled. */
-    unresolved: string[];
-}
-/** How pending tracked changes read: "tracked" shows them (deleted and
- * inserted text, marked), "accepted" as if every one were accepted (what
- * the editing tools see), "original" as if every one were rejected. */
-export type ReadView = "tracked" | "accepted" | "original";
-export interface GrepMatch {
-    text: string;
-    /** Inside text a pending change inserted or deleted; null for text no
-     * change touches. */
-    change: "inserted" | "deleted" | null;
-    changeId: string | null;
-}
-export interface GrepHit {
-    id: string;
-    blockIndex: number;
-    count: number;
-    /** The block's text in the view. Tracked marks changes inline:
-     * "Fees are [-$100-]{+$120+} per hour." */
-    text: string;
-    matches: GrepMatch[];
-}
-/** Where a block is: the body, a page header or footer, or a note. */
-export type TextRegion = "body" | "header" | "footer" | "footnote" | "endnote";
-export interface ReplaceAllOptions {
-    /** Only in these blocks (ids from `read`, `grep`, `search`). */
-    blocks?: string[];
-    /** @deprecated The older name for `blocks`. */
-    ids?: string[];
-    /** Match regardless of case: "Provider" also finds "PROVIDER". */
-    ignoreCase?: boolean;
-    /** Match characters exactly. By default curly and straight quotes,
-     * non-breaking and ordinary spaces, and non-breaking and ordinary
-     * hyphens match each other, the way Word's Find treats quotes. */
-    exact?: boolean;
-}
-export interface ReplaceTextResult {
-    /** Occurrences replaced. */
-    replaced: number;
-    /** Ids of the blocks that contained the text. */
-    blocks: string[];
-    /** Occurrences replaced in each part of the document. */
-    regions: Partial<Record<TextRegion, number>>;
-    /** Tracked changes the replacement created (none in editing mode). */
-    changeIds: string[];
-    /** Blocks that contained the text but could not be edited. */
-    failures: Array<{
-        blockId: string;
-        code: string;
-        message: string;
-    }>;
-    /** Text that would match with looser options but wasn't replaced: other
-     * capitalization (`ignoreCase`) or other quotes and spaces (`exact`). */
-    nearMisses: Array<{
-        text: string;
-        count: number;
-        reason: "case" | "characters";
-    }>;
-}
-export interface TextDiff {
-    /** Paragraph-level diff with word detail: `~ a [-old-]{+new+} b`. */
-    text: string;
-    changed: number;
-}
-export interface DocumentSummary {
-    text: string;
-    data: {
-        pages?: number;
-        words: number;
-        pageSize: string;
-        orientation: string;
-        pageInches: [number, number];
-        marginsInches: number[];
-        title?: string;
-        headings: Record<string, number>;
-        lists: number[];
-        tables: string[];
-        images: number;
-        headersFooters: Array<{
-            side: string;
-            slot: string;
-            text: string;
-        }>;
-        pendingTrackedChanges: number;
-    };
-}
-export interface ExportOptions {
-    format: ExportFormat;
-    /** "review" keeps tracked changes and comments; "final" accepts them.
-     * Only .docx can hold tracked changes: PDF, Markdown, HTML, and text
-     * always show them accepted. */
-    mode?: "review" | "final";
-    /** The same choice in read's words, and one more: "tracked" is
-     * "review", "accepted" is "final", and "original" writes the document as
-     * it was before every pending change. Give `mode` or `view`, not both. */
-    view?: ReadView;
-    title?: string;
-}
-export interface ExportResult {
-    bytes: Uint8Array;
-    format: ExportFormat;
-    /** The mode the output actually has: only .docx can be "review". */
-    mode: "review" | "final";
-    /** The view the output shows: "tracked" only for a .docx. */
-    view: ReadView;
-    /** Tracked changes still pending in the output. */
-    pendingTrackedChanges: number;
-    /** For .docx, what the export actually did: "graft" carried untouched
-     * content over byte for byte from the original file; "regenerated" wrote
-     * the whole file fresh (fallbackCode says why). */
-    fidelity: DocxExportOutcome | null;
-    warnings: string[];
-}
-/** Bytes of a document in a format, through graft export when the original
- * Word package is available, with what the .docx export actually did. */
-export declare function exportYDoc(ydoc: Y.Doc, pkg: Uint8Array | null, { format, mode, title }: ExportOptions): Promise<{
-    bytes: Uint8Array;
-    outcome: DocxExportOutcome | null;
-}>;
-/**
- * One open document: a live Revise document model plus the agent tool
- * session that edits it. Nothing touches disk unless you export it.
- */
-export declare class ReviseDocument {
-    private currentYDoc;
-    private currentSession;
-    private readonly settings;
-    private originalPackage;
-    /** False when the Y.Doc came from the caller (fromYDoc): it may be
-     * shared with an editor or a provider, so it is never replaced. */
-    private readonly ownsYDoc;
-    private disposed;
-    private queue;
-    private constructor();
-    /** Open a file (path) or bytes. Word files keep their original package,
-     * so untouched content exports byte for byte. */
-    static open(source: DocumentSource, options?: OpenOptions): Promise<ReviseDocument>;
-    /** Start a document from the HTML the tools read and write (headings,
-     * `data-style-id="Title"`, lists, tables), or from Markdown. */
-    static create(content?: {
-        html?: string;
-        markdown?: string;
-        title?: string;
-    }, options?: OpenOptions): Promise<ReviseDocument>;
-    /** Restore a document from `snapshot()` (or a bare Y.js update). Options
-     * override what the snapshot recorded. */
-    static restore(snapshot: Uint8Array, options?: OpenOptions): Promise<ReviseDocument>;
-    /** Wrap an existing Revise Y.Doc, e.g. one shared with an editor. The
-     * Y.Doc stays yours: `dispose()` leaves it intact, and `reload()` is not
-     * available (it would have to replace it). */
-    static fromYDoc(ydoc: Y.Doc, options?: OpenOptions & {
-        package?: Uint8Array | null;
-        title?: string;
-    }): Promise<ReviseDocument>;
-    private static build;
-    private static startSession;
-    private assertOpen;
-    /** Run `work` after every operation already queued on this document. */
-    private serial;
-    /** The live document model. Shared with `@reviseio/editor`. */
-    get ydoc(): Y.Doc;
-    /** The low-level tool session behind `tools`: an escape hatch for what
-     * the methods here don't cover. */
-    get session(): ServerDocumentSession;
-    get mode(): DocumentMode;
-    /** Switch between tracked changes ("suggesting") and direct edits. */
-    setMode(mode: DocumentMode): Promise<void>;
-    get author(): string | undefined;
-    get documentId(): string;
-    /** The original Word package that export grafts onto, if any. */
-    get package(): Uint8Array | null;
-    /** The complete document (versioned; includes the original Word package)
-     * to store or hand to `@reviseio/editor`, as of every operation queued
-     * before this call. Restore with `restore()`. */
-    snapshot(): Promise<Uint8Array>;
-    /** An opaque value that changes whenever the document does (including
-     * edits that only delete, which a state vector misses). */
-    version(): Uint8Array;
-    /**
-     * Re-read the document from new bytes (it changed elsewhere). Block ids
-     * carry over only where identity is provable (Word's paragraph ids, or
-     * identical content); `changedIds` lists kept ids whose content changed,
-     * so earlier reads of them are stale. Replaces the Y.Doc, so it is not
-     * available on a document made with `fromYDoc`.
-     */
-    reload(bytes: Uint8Array, filename: string): Promise<{
-        idsKept: number;
-        idsNew: number;
-        changedIds: string[];
-        removedIds: string[];
-    }>;
-    /** Start the tool session over: forget what the agent has read and
-     * searched (e.g. after the host compacts its transcript). */
-    resetToolContext(): Promise<void>;
-    /** Release the tool session. The document can't be used afterwards; a
-     * Y.Doc it created is destroyed, one passed to fromYDoc is left alone. */
-    dispose(): void;
-    readonly tools: {
-        /** Every editing tool's name, description, and JSON input schema. */
-        definitions: () => ReviseToolDefinition[];
-        /** Run a known tool with typed input. Expected failures come back as
-         * `{ ok: false, error }`; nothing throws for a bad edit. */
-        call: <Name extends ReviseToolName>(name: Name, ...args: ReviseToolArguments<Name>) => Promise<ReviseToolResult<Name>>;
-        /** Run a tool by name with untyped input (agent tool calls). Unknown
-         * tools and bad input come back as `{ ok: false, error }` too. */
-        run: (name: string, input?: ReviseJsonObject, options?: {
-            direct?: boolean;
-        }) => Promise<ReviseToolResult<string>>;
-    };
-    /** The document's title for exports: its saved title property (dc:title
-     * in a .docx, or set_title's), else the name it was opened under. */
-    private title;
-    /** set_title renames the document in the editor. In a file, the title is
-     * the document property (docProps/core.xml in a .docx, the PDF title), so
-     * it is saved there too; without this, the tool reported success and the
-     * saved file kept its old title. */
-    private afterTool;
-    /** Sections with their block ranges and word counts. */
-    outline(options?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<ReviseDocumentMeasurementData>;
-    /** measure_document with every section from `offset` on, page by page. */
-    private allSections;
-    /**
-     * The top-level blocks a selection names, in document order: block ids
-     * and `first..last` ranges (a nested id stands for the block holding it),
-     * a section (its heading's range, subsections included; "4,7,9" for
-     * several), or `count`
-     * blocks from `index`. Naming a block or section that doesn't exist is an
-     * error.
-     */
-    selectBlocks(selection: {
-        blocks?: string;
-        section?: string;
-        index?: number;
-        count?: number;
-    }): Promise<string[]>;
-    /**
-     * Paragraphs that look like section headings but aren't styled as
-     * headings: short, entirely bold, and numbered like the document's real
-     * headings ("12. Overtime" between headings 11 and 13) with a number no
-     * heading has. Word documents often have one typed by hand.
-     */
-    unstyledHeadings(): Promise<Array<{
-        id: string;
-        blockIndex: number;
-        text: string;
-        level: number;
-    }>>;
-    /**
-     * read/search HTML for a reader to look at, leaving out what goes without
-     * saying: in each paragraph or heading, spacing, line height, keep
-     * settings, and text size and color equal to what its paragraph style
-     * (data-style-id, else the default "Normal") already sets; in table
-     * cells, the default 1px border and 8px padding; and grid columns in
-     * tables with no merged cells. Every value left out is one the block
-     * gets anyway when it's written back without it. Starts with a comment
-     * saying so.
-     */
-    compactHtml(html: string): string;
-    /** Blocks, words, pending changes, and how faithfully it exports to Word. */
-    status(): Promise<{
-        blocks: number;
-        words: number;
-        pendingSuggestions: number;
-        fidelity: SourceFidelity | null;
-    }>;
-    /** Text-bearing blocks matching a pattern (paragraphs, headings, list
-     * items, table-cell paragraphs), with their ids. */
-    grep(pattern: string | RegExp, options?: {
-        ignoreCase?: boolean;
-        view?: ReadView;
-    }): GrepHit[];
-    /**
-     * HTML the read tools returned (`read_blocks_from_index`,
-     * `read_specific_blocks`), in a view. The tools read the accepted view;
-     * "tracked" marks pending changes as `<ins>`/`<del>` with
-     * `data-change-id` and `data-author`, and shows whole blocks a change
-     * deletes where they were; "original" shows the text before every change.
-     * Block ids are unchanged. The editing tools read `<ins>` as its text and
-     * ignore `<del>`, so tracked HTML pasted back edits the accepted text.
-     */
-    viewHtml(html: string, view: ReadView): Promise<string>;
-    /** What the document holds, in one glance: page setup, header and footer
-     * text with live fields, title, headings, lists, tables, review state. */
-    summary(): Promise<DocumentSummary>;
-    /**
-     * Replace every occurrence everywhere: the body, tables, lists, page
-     * headers and footers, and footnotes and endnotes. Tracked changes in
-     * suggesting mode. Curly and straight quotes and non-breaking spaces match
-     * each other unless `exact`, and the replacement keeps the document's
-     * characters (see matchDocumentCharacters). Replacing text with itself
-     * changes nothing and is not a failure.
-     */
-    replaceAll(find: string, replace: string, options?: ReplaceAllOptions): Promise<ReplaceTextResult>;
-    /** @deprecated The 3.0 name of `replaceAll`. */
-    replaceText(find: string, replace: string, options?: ReplaceAllOptions): Promise<ReplaceTextResult>;
-    /** The document as it was before every pending change, exported from
-     * a copy: this document keeps its changes. */
-    private exportOriginal;
-    /** Pending tracked changes with where they are and what they do. */
-    changes(filter?: ChangeFilter): Promise<ChangeEntry[]>;
-    private filteredChanges;
-    /** The tracked changes a selection would settle, without settling them. */
-    preview(selection: ChangeSelection): Promise<ChangeEntry[]>;
-    accept(selection: ChangeSelection): Promise<SettleResult>;
-    reject(selection: ChangeSelection): Promise<SettleResult>;
-    private selectedIds;
-    private settle;
-    /**
-     * What the pending tracked changes do to the text (before → after), or
-     * what changed since `baseline` (a snapshot).
-     */
-    diff(baseline?: Uint8Array): Promise<TextDiff>;
-    /** Write the document in a format. Reports what the output actually
-     * contains: its pending changes, and for .docx how much of the original
-     * file was carried over byte for byte. */
-    export(options: ExportOptions): Promise<ExportResult>;
-    /** Pages as images, laid out exactly as the editor lays them out. */
-    renderPages(options?: RenderOptions): Promise<RenderResult>;
-}
-export interface CompareResult {
-    /** The revised document with every difference as a tracked change. */
-    document: ReviseDocument;
-    stats: {
-        inlineChanges: number;
-        insertedBlocks: number;
-        deletedBlocks: number;
-        unmarkedBlocks: number;
-    };
-    untrackedRegions: string[];
-    /** Accepting every change in the exported redline (read back from the
-     * .docx) gives the revised text; rejecting every change gives the
-     * original. Text only: formatting and comments are not compared. */
-    verified: {
-        acceptAllGivesRevised: boolean;
-        rejectAllGivesOriginal: boolean;
-    };
-}
-/** A redline: `revised` with every difference from `original` tracked. */
-/**
- * Seed a collaboration room (a Y.Doc your sync server owns) from a file, and
- * say whether it wrote anything. A room that already holds a document is
- * left alone, so call it on every connection:
- *
- *   onLoadDocument: async ({ document }) => {
- *     await seedYDoc(document, "contract.docx");
- *   }
- *
- * Two peers that both seeded an empty room before syncing are repaired to a
- * single copy. A Word file is stored in the room too, so any session over
- * it (`ReviseDocument.fromYDoc`, or the editor) exports untouched content
- * byte for byte.
- */
-export declare function seedYDoc(ydoc: Y.Doc, source: DocumentSource): Promise<boolean>;
-export declare function compare(originalSource: DocumentSource, revisedSource: DocumentSource, options?: OpenOptions): Promise<CompareResult>;
-/** Convert a document to another format in one step. */
-export declare function convert(source: DocumentSource, format: ExportFormat, options?: {
-    mode?: "review" | "final";
-    view?: ReadView;
-}): Promise<Uint8Array>;
-/** Whether a heading is the one a section query names: "8", "8.", "8.1",
- * "Allocation of risk", or "8. Allocation". */
-export declare function headingMatches(title: string, query: string): boolean;
-/** A --blocks query: block ids and `first..last` ranges ("…" and "..."
- * work too), e.g. "a1,b2..c3". */
-export declare function parseBlockQuery(query: string): Array<string | {
-    from: string;
-    to: string;
-}>;

package/docx.d.ts

@@ -1,73 +0,0 @@
-import * as Y from "yjs";
-import type { DocRoot } from "@reviseio/engine";
-/** What a .docx export actually did. */
-export interface DocxExportOutcome {
-    /** "graft": untouched content copied byte for byte from the original;
-     * "regenerated": the whole file written fresh (no original, or graft
-     * refused it, see fallbackCode). */
-    method: "graft" | "regenerated";
-    exact: boolean;
-    regeneratedBlocks: number;
-    fallbackCode?: string;
-}
-/**
- * The session as a .docx: the model's changes grafted onto the session's
- * package. Without a package (a document not opened from .docx) it is the
- * ordinary export. Paragraphs and rows the export writes fresh get a
- * w14:paraId if they lack one (see stampParaIds); untouched ones never do.
- * Reports what the converter actually did, not what it was asked to do.
- */
-export declare function exportSessionDocx(ydoc: Y.Doc, pkg: Uint8Array | null, mode?: "review" | "final"): Promise<{
-    bytes: Uint8Array;
-    outcome: DocxExportOutcome;
-}>;
-/** The w14:paraId revise writes for a block it created: derived from the
- * block id, so it is the same on every save and maps back on re-read.
- * Word's rules: 8 hex digits, below 0x80000000. */
-export declare function derivedParaId(blockId: string, salt?: number): string;
-/**
- * Give paragraphs and table rows a w14:paraId where they lack one, but only
- * in blocks the export writes fresh (`regenerated`; null = every block):
- * untouched content keeps its exact bytes. Returns a copy.
- */
-/** What graft export copies from the original: whole parts, and changed
- * rows whose own properties (their head) are unchanged. */
-interface GraftKept {
-    whole: Set<string>;
-    head: Set<string>;
-}
-export declare function stampParaIds(doc: DocRoot, regenerated: ReadonlySet<string> | null, 
-/** Parts the graft copies from the original: never stamped. */
-kept?: GraftKept): DocRoot;
-export interface IdMatchReport {
-    /** Ids carried over to the re-read document. */
-    kept: number;
-    /** New blocks (or ones with no provable identity): fresh ids. */
-    fresh: number;
-    /** Kept ids whose content changed: earlier reads of them are stale. */
-    changedIds: string[];
-    /** Old ids that no longer exist. */
-    removedIds: string[];
-}
-/** Carry ids from `previous` onto the re-imported `next` (mutated). */
-export declare function matchIds(previous: DocRoot, next: DocRoot): IdMatchReport;
-export interface SyncResult {
-    ydoc: Y.Doc;
-    pkg: Uint8Array;
-    idsKept: number;
-    idsNew: number;
-    /** Kept ids whose content changed: earlier reads of them are stale. */
-    changedIds: string[];
-    /** Ids that no longer exist. */
-    removedIds: string[];
-    changedBlocks: number;
-    changedStyles: string[];
-}
-/**
- * Make `bytes` (any supported format) the session's model: parse them, carry
- * block ids over where identity is provable (see matchIds), and
- * keep a .docx as the graft package. Used after an xml patch and when the
- * file changed outside revise.
- */
-export declare function relearn(ydoc: Y.Doc, bytes: Uint8Array, filename: string): Promise<SyncResult>;
-export {};

package/errors.d.ts

@@ -1,14 +0,0 @@
-/**
- * The one error type the library throws for expected failures (a missing
- * file, an unsupported format, a malformed patch). `code` is stable and
- * machine-readable; the CLI prints it as `error <code>: <message>`.
- */
-export declare class ReviseError extends Error {
-    readonly code: string;
-    /** The underlying error, when this one wraps another (a filesystem or
-     * parser failure). */
-    readonly cause?: unknown;
-    constructor(message: string, code?: string, options?: {
-        cause?: unknown;
-    });
-}

package/legacy/editor.d.ts

@@ -1,19 +0,0 @@
-/** @deprecated The Revise editor moved to @reviseio/editor. Install it (npm i @reviseio/editor) and change imports of revise/editor to @reviseio/editor. See https://revise.io/developer/docs/editor-sdk/installation#migrate-from-revise-2x */
-declare const moved: never;
-export default moved;
-/** @deprecated The Revise editor moved to @reviseio/editor. Install it (npm i @reviseio/editor) and change imports of revise/editor to @reviseio/editor. See https://revise.io/developer/docs/editor-sdk/installation#migrate-from-revise-2x */
-export declare const ReviseToolError: never;
-/** @deprecated The Revise editor moved to @reviseio/editor. Install it (npm i @reviseio/editor) and change imports of revise/editor to @reviseio/editor. See https://revise.io/developer/docs/editor-sdk/installation#migrate-from-revise-2x */
-export declare const REVISE_SDK_VERSION: never;
-/** @deprecated The Revise editor moved to @reviseio/editor. Install it (npm i @reviseio/editor) and change imports of revise/editor to @reviseio/editor. See https://revise.io/developer/docs/editor-sdk/installation#migrate-from-revise-2x */
-export declare const REVISE_SDK_BUILD: never;
-/** @deprecated The Revise editor moved to @reviseio/editor. Install it (npm i @reviseio/editor) and change imports of revise/editor to @reviseio/editor. See https://revise.io/developer/docs/editor-sdk/installation#migrate-from-revise-2x */
-export declare const createEmptyDocx: never;
-/** @deprecated The Revise editor moved to @reviseio/editor. Install it (npm i @reviseio/editor) and change imports of revise/editor to @reviseio/editor. See https://revise.io/developer/docs/editor-sdk/installation#migrate-from-revise-2x */
-export declare const setAssetBaseUrl: never;
-/** @deprecated The Revise editor moved to @reviseio/editor. Install it (npm i @reviseio/editor) and change imports of revise/editor to @reviseio/editor. See https://revise.io/developer/docs/editor-sdk/installation#migrate-from-revise-2x */
-export declare const rolePolicy: never;
-/** @deprecated The Revise editor moved to @reviseio/editor. Install it (npm i @reviseio/editor) and change imports of revise/editor to @reviseio/editor. See https://revise.io/developer/docs/editor-sdk/installation#migrate-from-revise-2x */
-export declare const ReviseRoleError: never;
-/** @deprecated The Revise editor moved to @reviseio/editor. Install it (npm i @reviseio/editor) and change imports of revise/editor to @reviseio/editor. See https://revise.io/developer/docs/editor-sdk/installation#migrate-from-revise-2x */
-export declare const ReviseEditor: never;

package/legacy/editor.js

@@ -1,16 +0,0 @@
-// Generated from the export list of revise@2.2.0 (frozen). revise 2.x was
-// the Revise editor; these names exist only so that 2.x import statements
-// link and reach the message below instead of an opaque linking error.
-throw new Error(
-  "The Revise editor moved to @reviseio/editor. Install it (npm i @reviseio/editor) and change imports of revise/editor to @reviseio/editor. See https://revise.io/developer/docs/editor-sdk/installation#migrate-from-revise-2x",
-);
-
-export default undefined;
-export const ReviseToolError = undefined;
-export const REVISE_SDK_VERSION = undefined;
-export const REVISE_SDK_BUILD = undefined;
-export const createEmptyDocx = undefined;
-export const setAssetBaseUrl = undefined;
-export const rolePolicy = undefined;
-export const ReviseRoleError = undefined;
-export const ReviseEditor = undefined;

package/legacy/style.css

@@ -1,2 +0,0 @@
-/* The Revise editor moved to @reviseio/editor: import "@reviseio/editor/style.css".
-   From 3.0, `revise` is the CLI and TypeScript library. */

package/package.d.ts

@@ -1,23 +0,0 @@
-/** Parts of a .docx file, from its bytes. */
-export declare function listParts(bytes: Uint8Array): Promise<Array<{
-    path: string;
-    bytes: number;
-}>>;
-/** `catPart` returns at most this many matches. */
-export declare const CAT_MATCH_LIMIT = 20;
-export declare function catPart(bytes: Uint8Array, part: string, match?: string, limit?: number): Promise<string[]>;
-export interface PatchRequest {
-    part: string;
-    find?: string;
-    replace?: string;
-    all?: boolean;
-    file?: string;
-}
-export interface PatchResult {
-    bytes: Uint8Array;
-    replacements: number;
-    /** The part feeds Revise's own view: the model re-learns the package on
-     * the next command that reads it. */
-    modelRead: boolean;
-}
-export declare function patchPackage(pkg: Uint8Array, request: PatchRequest, readFile: (path: string) => string): Promise<PatchResult>;

package/render.d.ts

@@ -1,27 +0,0 @@
-import type * as Y from "yjs";
-export type RenderView = "tracked" | "accepted" | "original";
-export interface RenderOptions {
-    /** First page, 1-based. Default 1. */
-    startPage?: number;
-    /** Pages in one image, 1-6. Default 1. */
-    pageCount?: number;
-    /** Tracked changes shown as marks (default), accepted, or before them. */
-    view?: RenderView;
-    /** Overlay layout boxes (margins, block bounds) for debugging. */
-    layout?: boolean;
-    /** "detailed" (default for one page) or "compact". */
-    quality?: "compact" | "detailed";
-}
-export interface RenderResult {
-    bytes: Uint8Array;
-    mimeType: string;
-    width: number;
-    height: number;
-    pages: number[];
-    totalPages: number;
-    placeholderImageCount: number;
-    failedImageCount: number;
-    description: string;
-}
-/** Lay out the document and draw the requested pages as one image. */
-export declare function renderPages(ydoc: Y.Doc, documentId: string, options: RenderOptions): Promise<RenderResult>;