markdown-patch 0.1.2 → 0.2.0

package/dist/tests/patch.test.js

@@ -1,64 +1,60 @@
 import fs from "fs";
 import path from "path";
 import { applyPatch, PatchFailed } from "../patch";
+import { ContentType } from "../types";
 describe("patch", () => {
     const sample = fs.readFileSync(path.join(__dirname, "sample.md"), "utf-8");
+    const assertPatchResultsMatch = (inputDocumentPath, outputDocumentPath, instruction) => {
+        const inputDocument = fs.readFileSync(path.join(__dirname, inputDocumentPath), "utf-8");
+        const outputDocument = fs.readFileSync(path.join(__dirname, outputDocumentPath), "utf-8");
+        expect(applyPatch(inputDocument, instruction)).toEqual(outputDocument);
+    };
     describe("heading", () => {
         test("prepend", () => {
-            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.prepend.md"), "utf-8");
             const instruction = {
                 targetType: "heading",
                 target: ["Overview"],
                 operation: "prepend",
                 content: "Beep Boop\n",
             };
-            const actualResult = applyPatch(sample, instruction);
-            expect(actualResult).toEqual(expected);
+            assertPatchResultsMatch("sample.md", "sample.patch.heading.prepend.md", instruction);
         });
         test("append", () => {
-            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.append.md"), "utf-8");
             const instruction = {
                 targetType: "heading",
                 target: ["Overview"],
                 operation: "append",
                 content: "Beep Boop\n",
             };
-            const actualResult = applyPatch(sample, instruction);
-            expect(actualResult).toEqual(expected);
+            assertPatchResultsMatch("sample.md", "sample.patch.heading.append.md", instruction);
         });
         test("replace", () => {
-            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.replace.md"), "utf-8");
             const instruction = {
                 targetType: "heading",
                 target: ["Overview"],
                 operation: "replace",
                 content: "Beep Boop\n",
             };
-            const actualResult = applyPatch(sample, instruction);
-            expect(actualResult).toEqual(expected);
+            assertPatchResultsMatch("sample.md", "sample.patch.heading.replace.md", instruction);
         });
         describe("document", () => {
             test("prepend", () => {
-                const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.document.prepend.md"), "utf-8");
                 const instruction = {
                     targetType: "heading",
                     target: null,
                     operation: "prepend",
                     content: "Beep Boop\n",
                 };
-                const actualResult = applyPatch(sample, instruction);
-                expect(actualResult).toEqual(expected);
+                assertPatchResultsMatch("sample.md", "sample.patch.heading.document.prepend.md", instruction);
             });
             test("append", () => {
-                const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.document.append.md"), "utf-8");
                 const instruction = {
                     targetType: "heading",
                     target: null,
                     operation: "append",
                     content: "Beep Boop\n",
                 };
-                const actualResult = applyPatch(sample, instruction);
-                expect(actualResult).toEqual(expected);
+                assertPatchResultsMatch("sample.md", "sample.patch.heading.document.append.md", instruction);
             });
         });
     });
@@ -66,7 +62,6 @@ describe("patch", () => {
         describe("trimTargetWhitespace", () => {
             describe("heading", () => {
                 test("prepend", () => {
-                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.trimTargetWhitespace.prepend.md"), "utf-8");
                     const instruction = {
                         targetType: "heading",
                         target: ["Page Targets", "Document Properties (Exploratory)"],
@@ -74,11 +69,9 @@ describe("patch", () => {
                         content: "Beep Boop",
                         trimTargetWhitespace: true,
                     };
-                    const actualResult = applyPatch(sample, instruction);
-                    expect(actualResult).toEqual(expected);
+                    assertPatchResultsMatch("sample.md", "sample.patch.heading.trimTargetWhitespace.prepend.md", instruction);
                 });
                 test("append", () => {
-                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.heading.trimTargetWhitespace.append.md"), "utf-8");
                     const instruction = {
                         targetType: "heading",
                         target: ["Problems"],
@@ -86,11 +79,32 @@ describe("patch", () => {
                         content: "Beep Boop\n",
                         trimTargetWhitespace: true,
                     };
-                    const actualResult = applyPatch(sample, instruction);
-                    expect(actualResult).toEqual(expected);
+                    assertPatchResultsMatch("sample.md", "sample.patch.heading.trimTargetWhitespace.append.md", instruction);
                 });
             });
         });
+        describe("createTargetIfMissing", () => {
+            test("nested", () => {
+                const instruction = {
+                    targetType: "heading",
+                    target: ["Page Targets", "Block", "Test"],
+                    operation: "replace",
+                    content: "Beep Boop\n",
+                    createTargetIfMissing: true,
+                };
+                assertPatchResultsMatch("sample.md", "sample.patch.heading.createIfMissing.nested.md", instruction);
+            });
+            test("root", () => {
+                const instruction = {
+                    targetType: "heading",
+                    target: ["Alpha", "Beta", "Test"],
+                    operation: "replace",
+                    content: "Beep Boop\n",
+                    createTargetIfMissing: true,
+                };
+                assertPatchResultsMatch("sample.md", "sample.patch.heading.createIfMissing.root.md", instruction);
+            });
+        });
         describe("applyIfContentPreexists", () => {
             describe("disabled (default)", () => {
                 describe("heading", () => {
@@ -140,81 +154,296 @@ describe("patch", () => {
     });
     describe("block", () => {
         test("prepend", () => {
-            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.prepend.md"), "utf-8");
             const instruction = {
                 targetType: "block",
                 target: "e6068e",
                 operation: "prepend",
                 content: "- OK\n",
             };
-            const actualResult = applyPatch(sample, instruction);
-            expect(actualResult).toEqual(expected);
+            assertPatchResultsMatch("sample.md", "sample.patch.block.prepend.md", instruction);
         });
         test("append", () => {
-            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.append.md"), "utf-8");
             const instruction = {
                 targetType: "block",
                 target: "e6068e",
                 operation: "append",
                 content: "\n- OK",
             };
-            const actualResult = applyPatch(sample, instruction);
-            expect(actualResult).toEqual(expected);
+            assertPatchResultsMatch("sample.md", "sample.patch.block.append.md", instruction);
         });
         test("replace", () => {
-            const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.replace.md"), "utf-8");
             const instruction = {
                 targetType: "block",
                 target: "259a73",
                 operation: "replace",
                 content: "- OK",
             };
-            const actualResult = applyPatch(sample, instruction);
-            expect(actualResult).toEqual(expected);
+            assertPatchResultsMatch("sample.md", "sample.patch.block.replace.md", instruction);
         });
         describe("tagetBlockTypeBehavior", () => {
             describe("table", () => {
                 test("prepend", () => {
-                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.targetBlockTypeBehavior.table.prepend.md"), "utf-8");
                     const instruction = {
                         targetType: "block",
-                        targetBlockTypeBehavior: "table",
                         target: "2c67a6",
                         operation: "prepend",
+                        contentType: ContentType.json,
                         content: [
                             ["`something else`", "Some other application", "✅", "✅", "✅"],
                         ],
                     };
-                    const actualResult = applyPatch(sample, instruction);
-                    expect(actualResult).toEqual(expected);
+                    assertPatchResultsMatch("sample.md", "sample.patch.block.targetBlockTypeBehavior.table.prepend.md", instruction);
                 });
                 test("append", () => {
-                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.targetBlockTypeBehavior.table.append.md"), "utf-8");
                     const instruction = {
                         targetType: "block",
-                        targetBlockTypeBehavior: "table",
                         target: "2c67a6",
                         operation: "append",
+                        contentType: ContentType.json,
                         content: [
                             ["`something else`", "Some other application", "✅", "✅", "✅"],
                         ],
                     };
-                    const actualResult = applyPatch(sample, instruction);
-                    expect(actualResult).toEqual(expected);
+                    assertPatchResultsMatch("sample.md", "sample.patch.block.targetBlockTypeBehavior.table.append.md", instruction);
                 });
                 test("replace", () => {
-                    const expected = fs.readFileSync(path.join(__dirname, "sample.patch.block.targetBlockTypeBehavior.table.replace.md"), "utf-8");
                     const instruction = {
                         targetType: "block",
-                        targetBlockTypeBehavior: "table",
                         target: "2c67a6",
                         operation: "replace",
+                        contentType: ContentType.json,
                         content: [
                             ["`something else`", "Some other application", "✅", "✅", "✅"],
                         ],
                     };
-                    const actualResult = applyPatch(sample, instruction);
-                    expect(actualResult).toEqual(expected);
+                    assertPatchResultsMatch("sample.md", "sample.patch.block.targetBlockTypeBehavior.table.replace.md", instruction);
+                });
+            });
+        });
+    });
+    describe("frontmatter", () => {
+        describe("append", () => {
+            test("mismatched types", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "array-value",
+                    operation: "append",
+                    contentType: ContentType.json,
+                    content: "OK",
+                };
+                expect(() => {
+                    applyPatch(sample, instruction);
+                }).toThrow(PatchFailed);
+            });
+            test("invalid type", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "array-value",
+                    operation: "append",
+                    contentType: ContentType.json,
+                    content: 10,
+                };
+                expect(() => {
+                    applyPatch(sample, instruction);
+                }).toThrow(PatchFailed);
+            });
+            test("list", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "array-value",
+                    operation: "append",
+                    contentType: ContentType.json,
+                    content: ["Beep"],
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.append.list.md", instruction);
+            });
+            test("dictionary", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "object-value",
+                    operation: "append",
+                    contentType: ContentType.json,
+                    content: { three: "Beep" },
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.append.dictionary.md", instruction);
+            });
+            test("string", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "string-value",
+                    operation: "append",
+                    contentType: ContentType.json,
+                    content: "Beep",
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.append.string.md", instruction);
+            });
+        });
+        describe("prepend", () => {
+            test("mismatched types", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "array-value",
+                    operation: "prepend",
+                    contentType: ContentType.json,
+                    content: "OK",
+                };
+                expect(() => {
+                    applyPatch(sample, instruction);
+                }).toThrow(PatchFailed);
+            });
+            test("invalid type", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "array-value",
+                    operation: "prepend",
+                    contentType: ContentType.json,
+                    content: 10,
+                };
+                expect(() => {
+                    applyPatch(sample, instruction);
+                }).toThrow(PatchFailed);
+            });
+            test("list", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "array-value",
+                    operation: "prepend",
+                    contentType: ContentType.json,
+                    content: ["Beep"],
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.prepend.list.md", instruction);
+            });
+            test("dictionary", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "object-value",
+                    operation: "prepend",
+                    contentType: ContentType.json,
+                    content: { three: "Beep" },
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.prepend.dictionary.md", instruction);
+            });
+            test("string", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "string-value",
+                    operation: "prepend",
+                    contentType: ContentType.json,
+                    content: "Beep",
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.prepend.string.md", instruction);
+            });
+        });
+        describe("replace", () => {
+            test("list", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "array-value",
+                    operation: "replace",
+                    contentType: ContentType.json,
+                    content: ["Replaced"],
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.replace.list.md", instruction);
+            });
+            test("dictionary", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "object-value",
+                    operation: "replace",
+                    contentType: ContentType.json,
+                    content: {
+                        replaced: true,
+                    },
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.replace.dictionary.md", instruction);
+            });
+            test("string", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "string-value",
+                    operation: "replace",
+                    contentType: ContentType.json,
+                    content: "Replaced",
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.replace.string.md", instruction);
+            });
+            test("number", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "number-value",
+                    operation: "replace",
+                    contentType: ContentType.json,
+                    content: 10,
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.replace.number.md", instruction);
+            });
+            test("boolean", () => {
+                const instruction = {
+                    targetType: "frontmatter",
+                    target: "boolean-value",
+                    operation: "replace",
+                    contentType: ContentType.json,
+                    content: true,
+                };
+                assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.replace.boolean.md", instruction);
+            });
+            describe("createTargetIfMissing", () => {
+                test("list", () => {
+                    const instruction = {
+                        targetType: "frontmatter",
+                        target: "new-field",
+                        operation: "replace",
+                        contentType: ContentType.json,
+                        content: ["New Value"],
+                        createTargetIfMissing: true,
+                    };
+                    assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.createTargetIfMissing.list.md", instruction);
+                });
+                test("dictionary", () => {
+                    const instruction = {
+                        targetType: "frontmatter",
+                        target: "new-field",
+                        operation: "replace",
+                        contentType: ContentType.json,
+                        content: {
+                            newValue: true,
+                        },
+                        createTargetIfMissing: true,
+                    };
+                    assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.createTargetIfMissing.dictionary.md", instruction);
+                });
+                test("string", () => {
+                    const instruction = {
+                        targetType: "frontmatter",
+                        target: "new-field",
+                        operation: "replace",
+                        contentType: ContentType.json,
+                        content: "New Value",
+                        createTargetIfMissing: true,
+                    };
+                    assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.createTargetIfMissing.string.md", instruction);
+                });
+                test("number", () => {
+                    const instruction = {
+                        targetType: "frontmatter",
+                        target: "new-field",
+                        operation: "replace",
+                        contentType: ContentType.json,
+                        content: 588600,
+                        createTargetIfMissing: true,
+                    };
+                    assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.createTargetIfMissing.number.md", instruction);
+                });
+                test("boolean", () => {
+                    const instruction = {
+                        targetType: "frontmatter",
+                        target: "new-field",
+                        operation: "replace",
+                        contentType: ContentType.json,
+                        content: true,
+                        createTargetIfMissing: true,
+                    };
+                    assertPatchResultsMatch("sample.frontmatter.md", "sample.patch.frontmatter.createTargetIfMissing.boolean.md", instruction);
                 });
             });
         });

package/dist/typeGuards.d.ts

@@ -0,0 +1,7 @@
+import { AppendableFrontmatterType } from "./types";
+export declare function isStringArrayArray(obj: unknown): obj is string[][];
+export declare function isAppendableFrontmatterType(obj: unknown): obj is AppendableFrontmatterType;
+export declare function isString(obj: unknown): obj is string;
+export declare function isDictionary(obj: unknown): obj is Record<string, unknown>;
+export declare function isList(obj: unknown): obj is Array<unknown>;
+//# sourceMappingURL=typeGuards.d.ts.map

package/dist/typeGuards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["../src/typeGuards.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEpD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,EAAE,EAAE,CAUlE;AACD,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,OAAO,GACX,GAAG,IAAI,yBAAyB,CAElC;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,CAEpD;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,wBAAgB,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAE1D"}

package/dist/typeGuards.js

@@ -0,0 +1,20 @@
+export function isStringArrayArray(obj) {
+    // Check if the object is an array
+    if (!Array.isArray(obj))
+        return false;
+    // Check if every element is an array of strings
+    return obj.every((item) => Array.isArray(item) &&
+        item.every((subItem) => typeof subItem === "string"));
+}
+export function isAppendableFrontmatterType(obj) {
+    return isString(obj) || isDictionary(obj) || isList(obj);
+}
+export function isString(obj) {
+    return typeof obj === "string";
+}
+export function isDictionary(obj) {
+    return typeof obj === "object" && obj !== null && !Array.isArray(obj);
+}
+export function isList(obj) {
+    return Array.isArray(obj);
+}

package/dist/types.d.ts

@@ -0,0 +1,199 @@
+export interface DocumentRange {
+    start: number;
+    end: number;
+}
+export interface DocumentMapMarkerContentPair {
+    marker: DocumentRange;
+    content: DocumentRange;
+}
+export interface HeadingMarkerContentPair extends DocumentMapMarkerContentPair {
+    level: number;
+}
+export interface DocumentMap {
+    heading: Record<string, HeadingMarkerContentPair>;
+    block: Record<string, DocumentMapMarkerContentPair>;
+    frontmatter: Record<string, any>;
+    contentOffset: number;
+    lineEnding: string;
+}
+export type PatchTargetType = "heading" | "block" | "frontmatter";
+export type PatchOperation = "replace" | "prepend" | "append";
+export interface BasePatchInstructionTarget {
+    targetType: PatchTargetType;
+    target: any;
+    createTargetIfMissing?: boolean;
+}
+export interface BasePatchInstructionOperation {
+    operation: string;
+}
+export interface BaseHeadingPatchInstruction extends BasePatchInstructionTarget {
+    targetType: "heading";
+    target: string[] | null;
+}
+export interface BaseFrontmatterPatchInstruction extends BasePatchInstructionTarget {
+    targetType: "frontmatter";
+    target: string;
+}
+export interface BaseBlockPatchInstruction extends BasePatchInstructionTarget {
+    targetType: "block";
+    target: string;
+}
+export interface NonExtendingPatchInstruction extends BasePatchInstructionOperation {
+}
+export interface TextExtendingPatchInstruction extends BasePatchInstructionOperation {
+    /** Trim whitepsace from target before joining with content
+     *
+     * - For `prepend`: Trims content from the beginning of
+     *   the target content.
+     * - For `append`: Trims content from the end of the target
+     *   content.  Your content should probably end in a newline
+     *   in this case, or the trailing heading will no longer
+     *   be the start of its own line
+     */
+    trimTargetWhitespace?: boolean;
+    /** Apply patch even if content already exists at target
+     *
+     * By default, we will fail to apply a patch if the supplied
+     * content is found anywhere in your target content.  If you
+     * would instead like the patch to occur, regardless of whether
+     * it appears the content is already there, you can set
+     * `applyIfContentPreexists` to `true`.
+     */
+    applyIfContentPreexists?: boolean;
+}
+export interface StringContent {
+    contentType?: ContentType.text;
+    content: string;
+}
+export interface JsonContent {
+    contentType: ContentType.json;
+    content: unknown;
+}
+/**
+ * Prepend content to content existing under a heading
+ *
+ * @category Patch Instructions
+ */
+export interface PrependHeadingPatchInstruction extends TextExtendingPatchInstruction, BaseHeadingPatchInstruction, StringContent {
+    operation: "prepend";
+}
+/**
+ * Append content to content existing under a heading
+ *
+ * @category Patch Instructions
+ */
+export interface AppendHeadingPatchInstruction extends TextExtendingPatchInstruction, BaseHeadingPatchInstruction, StringContent {
+    operation: "append";
+}
+/**
+ * Replace content under a heading
+ *
+ * @category Patch Instructions
+ */
+export interface ReplaceHeadingPatchInstruction extends NonExtendingPatchInstruction, BaseHeadingPatchInstruction, StringContent {
+    operation: "replace";
+}
+/**
+ * Prepend content to a block referenced by a block reference
+ *
+ * @category Patch Instructions
+ */
+export interface PrependBlockPatchInstruction extends TextExtendingPatchInstruction, BaseBlockPatchInstruction, StringContent {
+    operation: "prepend";
+}
+/**
+ * Append content to a block referenced by a block reference
+ *
+ * @category Patch Instructions
+ */
+export interface AppendBlockPatchInstruction extends TextExtendingPatchInstruction, BaseBlockPatchInstruction, StringContent {
+    operation: "append";
+}
+/**
+ * Replace content of block referenced by a block reference.
+ *
+ * @category Patch Instructions
+ */
+export interface ReplaceBlockPatchInstruction extends NonExtendingPatchInstruction, BaseBlockPatchInstruction, StringContent {
+    operation: "replace";
+}
+/**
+ * Prepend rows to a table referenced by a block reference.
+ *
+ * @category Patch Instructions
+ */
+export interface PrependTableRowsBlockPatchInstruction extends TextExtendingPatchInstruction, BaseBlockPatchInstruction, JsonContent {
+    operation: "prepend";
+}
+/**
+ * Patch Instruction for appending rows to a table
+ * referenced by a block reference.
+ *
+ * @category Patch Instructions
+ */
+export interface AppendTableRowsBlockPatchInstruction extends TextExtendingPatchInstruction, BaseBlockPatchInstruction, JsonContent {
+    operation: "append";
+}
+/**
+ * Patch Instruction for replacing all rows of a table
+ * referenced by a block reference.
+ *
+ * @category Patch Instructions
+ */
+export interface ReplaceTableRowsBlockPatchInstruction extends NonExtendingPatchInstruction, BaseBlockPatchInstruction, JsonContent {
+    operation: "replace";
+}
+/**
+ * Prepend content to a frontmatter field
+ *
+ * @category Patch Instructions
+ */
+export interface PrependFrontmatterPatchInstruction extends NonExtendingPatchInstruction, BaseFrontmatterPatchInstruction, JsonContent {
+    operation: "prepend";
+}
+/**
+ * Append content to a frontmatter field
+ *
+ * @category Patch Instructions
+ */
+export interface AppendFrontmatterPatchInstruction extends NonExtendingPatchInstruction, BaseFrontmatterPatchInstruction, JsonContent {
+    operation: "append";
+}
+/**
+ * Replace content of frontmatter field
+ *
+ * @category Patch Instructions
+ */
+export interface ReplaceFrontmatterPatchInstruction extends NonExtendingPatchInstruction, BaseFrontmatterPatchInstruction, JsonContent {
+    operation: "replace";
+}
+/**
+ * Patch Instruction for Headings
+ */
+export type HeadingPatchInstruction = PrependHeadingPatchInstruction | AppendHeadingPatchInstruction | ReplaceHeadingPatchInstruction;
+/**
+ * Patch Instruction for Block References
+ */
+export type BlockPatchInstruction = PrependBlockPatchInstruction | AppendBlockPatchInstruction | ReplaceBlockPatchInstruction | PrependTableRowsBlockPatchInstruction | AppendTableRowsBlockPatchInstruction | ReplaceTableRowsBlockPatchInstruction;
+export type FrontmatterPatchInstruction = PrependFrontmatterPatchInstruction | AppendFrontmatterPatchInstruction | ReplaceFrontmatterPatchInstruction;
+/**
+ * Patch Instruction
+ */
+export type PatchInstruction = HeadingPatchInstruction | BlockPatchInstruction | FrontmatterPatchInstruction;
+export declare enum ContentType {
+    /**
+     * Content is simple text.
+     */
+    text = "text/plain",
+    /**
+     * Content is a JSON document
+     */
+    json = "application/json"
+}
+export interface PreprocessedDocument {
+    frontmatter: Record<string, any>;
+    contentOffset: number;
+    content: string;
+}
+export type AppendableFrontmatterType = string | Array<unknown> | Record<string, unknown>;
+//# sourceMappingURL=types.d.ts.map