@sillsdev/docu-notion 0.12.0

package/dist/images.js

@@ -0,0 +1,230 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupOldImages = exports.parseImageBlock = exports.markdownToMDImageTransformer = exports.standardImageTransformer = exports.initImageHandling = void 0;
+const fs = __importStar(require("fs-extra"));
+const file_type_1 = __importDefault(require("file-type"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const Path = __importStar(require("path"));
+const MakeImagePersistencePlan_1 = require("./MakeImagePersistencePlan");
+const log_1 = require("./log");
+// We several things here:
+// 1) copy images locally instead of leaving them in Notion
+// 2) change the links to point here
+// 3) read the caption and if there are localized images, get those too
+// 4) prepare for localized documents, which need a copy of every image
+let existingImagesNotSeenYetInPull = [];
+let imageOutputPath = ""; // default to putting in the same directory as the document referring to it.
+let imagePrefix = ""; // default to "./"
+let locales;
+function initImageHandling(prefix, outputPath, incomingLocales) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // If they gave us a trailing slash, remove it because we add it back later.
+        // Note that it's up to the caller to have a *leading* slash or not.
+        imagePrefix = prefix.replace(/\/$/, "");
+        imageOutputPath = outputPath;
+        locales = incomingLocales;
+        // Currently we don't delete the image directory, because if an image
+        // changes, it gets a new id. This way can then prevent downloading
+        // and image after the 1st time. The downside is currently we don't
+        // have the smarts to remove unused images.
+        if (imageOutputPath) {
+            yield fs.mkdir(imageOutputPath, { recursive: true });
+        }
+    });
+}
+exports.initImageHandling = initImageHandling;
+exports.standardImageTransformer = {
+    name: "DownloadImagesToRepo",
+    notionToMarkdownTransforms: [
+        {
+            type: "image",
+            // we have to set this one up for each page because we need to
+            // give it two extra parameters that are context for each page
+            getStringFromBlock: (context, block) => markdownToMDImageTransformer(block, context.directoryContainingMarkdown, context.relativeFilePathToFolderContainingPage),
+        },
+    ],
+};
+// This is a "custom transformer" function passed to notion-to-markdown
+// eslint-disable-next-line @typescript-eslint/require-await
+function markdownToMDImageTransformer(block, fullPathToDirectoryContainingMarkdown, relativePathToThisPage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const image = block.image;
+        yield processImageBlock(image, fullPathToDirectoryContainingMarkdown, relativePathToThisPage);
+        // just concatenate the caption text parts together
+        const altText = image.caption
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            .map((item) => item.plain_text)
+            .join("");
+        const href = image.type === "external" ? image.external.url : image.file.url;
+        return `![${altText}](${href})`;
+    });
+}
+exports.markdownToMDImageTransformer = markdownToMDImageTransformer;
+function processImageBlock(imageBlock, pathToParentDocument, relativePathToThisPage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        (0, log_1.logDebug)("processImageBlock", JSON.stringify(imageBlock));
+        const imageSet = parseImageBlock(imageBlock);
+        imageSet.pathToParentDocument = pathToParentDocument;
+        imageSet.relativePathToParentDocument = relativePathToThisPage;
+        // enhance: it would much better if we could split the changes to markdown separately from actual reading/writing,
+        // so that this wasn't part of the markdown-creation loop. It's already almost there; we just need to
+        // save the imageSets somewhere and then do the actual reading/writing later.
+        yield readPrimaryImage(imageSet);
+        (0, MakeImagePersistencePlan_1.makeImagePersistencePlan)(imageSet, imageOutputPath, imagePrefix);
+        yield saveImage(imageSet);
+        // change the src to point to our copy of the image
+        if ("file" in imageBlock) {
+            imageBlock.file.url = imageSet.filePathToUseInMarkdown;
+        }
+        else {
+            imageBlock.external.url = imageSet.filePathToUseInMarkdown;
+        }
+        // put back the simplified caption, stripped of the meta information
+        if (imageSet.caption) {
+            imageBlock.caption = [
+                {
+                    type: "text",
+                    text: { content: imageSet.caption, link: null },
+                    plain_text: imageSet.caption,
+                },
+            ];
+        }
+        else {
+            imageBlock.caption = [];
+        }
+    });
+}
+function readPrimaryImage(imageSet) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, node_fetch_1.default)(imageSet.primaryUrl);
+        const arrayBuffer = yield response.arrayBuffer();
+        imageSet.primaryBuffer = Buffer.from(arrayBuffer);
+        imageSet.fileType = yield file_type_1.default.fromBuffer(imageSet.primaryBuffer);
+    });
+}
+function saveImage(imageSet) {
+    return __awaiter(this, void 0, void 0, function* () {
+        writeImageIfNew(imageSet.primaryFileOutputPath, imageSet.primaryBuffer);
+        for (const localizedImage of imageSet.localizedUrls) {
+            let buffer = imageSet.primaryBuffer;
+            // if we have a urls for the localized screenshot, download it
+            if ((localizedImage === null || localizedImage === void 0 ? void 0 : localizedImage.url.length) > 0) {
+                (0, log_1.verbose)(`Retrieving ${localizedImage.iso632Code} version...`);
+                const response = yield (0, node_fetch_1.default)(localizedImage.url);
+                const arrayBuffer = yield response.arrayBuffer();
+                buffer = Buffer.from(arrayBuffer);
+            }
+            else {
+                (0, log_1.verbose)(`No localized image specified for ${localizedImage.iso632Code}, will use primary image.`);
+                // otherwise, we're going to fall back to outputting the primary image here
+            }
+            const directory = `./i18n/${localizedImage.iso632Code}/docusaurus-plugin-content-docs/current/${imageSet.relativePathToParentDocument}`;
+            writeImageIfNew((directory + "/" + imageSet.outputFileName).replaceAll("//", "/"), buffer);
+        }
+    });
+}
+function writeImageIfNew(path, buffer) {
+    imageWasSeen(path);
+    // Note: it's tempting to not spend time writing this out if we already have
+    // it from a previous run. But we don't really know it's the same. A) it
+    // could just have the same name, B) it could have been previously
+    // unlocalized and thus filled with a copy of the primary language image
+    // while and now is localized.
+    if (fs.pathExistsSync(path)) {
+        (0, log_1.verbose)("Replacing image " + path);
+    }
+    else {
+        (0, log_1.verbose)("Adding image " + path);
+        fs.mkdirsSync(Path.dirname(path));
+    }
+    fs.createWriteStream(path).write(buffer); // async but we're not waiting
+}
+function parseImageBlock(image) {
+    var _a;
+    if (!locales)
+        throw Error("Did you call initImageHandling()?");
+    const imageSet = {
+        primaryUrl: "",
+        caption: "",
+        localizedUrls: locales.map(l => ({ iso632Code: l, url: "" })),
+    };
+    if ("file" in image) {
+        imageSet.primaryUrl = image.file.url; // image saved on notion (actually AWS)
+    }
+    else {
+        imageSet.primaryUrl = image.external.url; // image still pointing somewhere else. I've see this happen when copying a Google Doc into Notion. Notion kep pointing at the google doc.
+    }
+    const mergedCaption = image.caption
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        .map((c) => c.plain_text)
+        .join("");
+    const lines = mergedCaption.split("\n");
+    // Example:
+    // Caption before images.\nfr https://i.imgur.com/pYmE7OJ.png\nES  https://i.imgur.com/8paSZ0i.png\nCaption after images
+    lines.forEach(l => {
+        const match = /\s*(..)\s*(https:\/\/.*)/.exec(l);
+        if (match) {
+            imageSet.localizedUrls.push({
+                iso632Code: match[1].toLowerCase(),
+                url: match[2],
+            });
+        }
+        else {
+            // NB: carriage returns seem to mess up the markdown, so should be removed
+            imageSet.caption += l + " ";
+        }
+    });
+    // NB: currently notion-md puts the caption in Alt, which noone sees (unless the image isn't found)
+    // We could inject a custom element handler to emit a <figure> in order to show the caption.
+    imageSet.caption = (_a = imageSet.caption) === null || _a === void 0 ? void 0 : _a.trim();
+    //console.log(JSON.stringify(imageSet, null, 2));
+    return imageSet;
+}
+exports.parseImageBlock = parseImageBlock;
+function imageWasSeen(path) {
+    existingImagesNotSeenYetInPull = existingImagesNotSeenYetInPull.filter(p => p !== path);
+}
+function cleanupOldImages() {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const p of existingImagesNotSeenYetInPull) {
+            (0, log_1.verbose)(`Removing old image: ${p}`);
+            yield fs.rm(p);
+        }
+    });
+}
+exports.cleanupOldImages = cleanupOldImages;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+export * as Log from "./log";
+export * from "./types";
+export * from "./config/configuration";
+export * from "./plugins/pluginTypes";
+import type { IDocuNotionConfig } from "./config/configuration";
+export type { IDocuNotionConfig };

package/dist/index.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = void 0;
+const run_1 = require("./run");
+(0, run_1.run)();
+// for plugins to import
+exports.Log = __importStar(require("./log"));
+__exportStar(require("./types"), exports);
+__exportStar(require("./config/configuration"), exports);
+__exportStar(require("./plugins/pluginTypes"), exports);

package/dist/log.d.ts

@@ -0,0 +1,11 @@
+type levels = "info" | "verbose" | "debug";
+export declare function setLogLevel(l: levels): void;
+export declare function error(s: string): void;
+export declare function warning(s: string): void;
+export declare function info(s: string): void;
+export declare function group(s: string): void;
+export declare function endGroup(): void;
+export declare function verbose(s: string): void;
+export declare function logDebugFn(label: string, runIfLoggingDebug: () => string): void;
+export declare function logDebug(label: string, info: string): void;
+export {};

package/dist/log.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logDebug = exports.logDebugFn = exports.verbose = exports.endGroup = exports.group = exports.info = exports.warning = exports.error = exports.setLogLevel = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+chalk_1.default;
+let logLevel;
+function setLogLevel(l) {
+    logLevel = l;
+}
+exports.setLogLevel = setLogLevel;
+function error(s) {
+    console.error(chalk_1.default.red(wrapForCI(s, "error")));
+}
+exports.error = error;
+function warning(s) {
+    console.log(chalk_1.default.hex("#FFA500")(wrapForCI(s, "warning")));
+}
+exports.warning = warning;
+function info(s) {
+    console.log(s);
+}
+exports.info = info;
+// make sure to call endGroup(), eventually, after calling this
+function group(s) {
+    console.log(chalk_1.default.blue(wrapForCI(s, "group")));
+}
+exports.group = group;
+// github actions needs an ::endgroup:: to end a group
+function endGroup() {
+    console.log(wrapForCI("", "endgroup"));
+}
+exports.endGroup = endGroup;
+function verbose(s) {
+    if (logLevel === "verbose" || logLevel === "debug")
+        console.log(chalk_1.default.green(s));
+}
+exports.verbose = verbose;
+// use this one if the debug info would take time to construct,
+// so you want to skip doing it if not in debug mode
+function logDebugFn(label, runIfLoggingDebug) {
+    if (logLevel === "debug") {
+        logDebug(label, runIfLoggingDebug());
+    }
+}
+exports.logDebugFn = logDebugFn;
+function logDebug(label, info) {
+    if (logLevel === "debug") {
+        console.log(chalk_1.default.dim(wrapForCI(`[${label}]`, "debug")));
+        console.log(chalk_1.default.dim(wrapForCI(info, "debug")));
+    }
+}
+exports.logDebug = logDebug;
+function wrapForCI(s, githubActionsPrefix) {
+    // for now, we only know about github actions, but submit a PR if you want to add more
+    return process.env["GITHUB_ACTIONS"] === "true"
+        ? `::${githubActionsPrefix}::${s}`
+        : s;
+}

package/dist/makeImagePersistencePlan.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/makeImagePersistencePlan.spec.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MakeImagePersistencePlan_1 = require("./MakeImagePersistencePlan");
+test("primary file with explicit file output path and prefix", () => {
+    const imageSet = {
+        primaryUrl: "https://s3.us-west-2.amazonaws.com/primaryImage?Blah=foo",
+        localizedUrls: [],
+        pathToParentDocument: "/pathToParentSomewhere/",
+        fileType: { ext: "png", mime: "image/png" },
+    };
+    (0, MakeImagePersistencePlan_1.makeImagePersistencePlan)(imageSet, "./static/notion_imgs", "/notion_imgs");
+    expect(imageSet.outputFileName).toBe("463556435.png");
+    expect(imageSet.primaryFileOutputPath).toBe("static/notion_imgs/463556435.png");
+    expect(imageSet.filePathToUseInMarkdown).toBe("/notion_imgs/463556435.png");
+});
+test("primary file with defaults for image output path and prefix", () => {
+    const imageSet = {
+        primaryUrl: "https://s3.us-west-2.amazonaws.com/primaryImage?Blah=foo",
+        localizedUrls: [],
+        pathToParentDocument: "/pathToParentSomewhere/",
+        fileType: { ext: "png", mime: "image/png" },
+    };
+    (0, MakeImagePersistencePlan_1.makeImagePersistencePlan)(imageSet, "", "");
+    expect(imageSet.outputFileName).toBe("463556435.png");
+    // the default behavior is to put the image next to the markdown file
+    expect(imageSet.primaryFileOutputPath).toBe("/pathToParentSomewhere/463556435.png");
+    expect(imageSet.filePathToUseInMarkdown).toBe("./463556435.png");
+});
+// In order to make image fallback work with other languages, we have to have
+// a file for each image, in each Docusaurus language directory. This is true
+// whether we have a localized version of the image or not.
+// The imageSet is initially populated with placeholders for each language.
+// This test ensures that these placeholders are replaced with actual urls
+// when localized versions of the image are listed.
+// TODO write this test

package/dist/notion-styles.css

@@ -0,0 +1,58 @@
+/* Note, I haven't figure out how a Docusaurus app can actually include this, yet.
+  So currently this has to be duplicated by the client.
+*/
+
+/* Copied from
+    https://github1s.com/NotionX/react-notion-x/blob/master/packages/react-notion-x/src/styles.css#L934
+    and
+    https://github1s.com/NotionX/react-notion-x/blob/master/packages/react-notion-x/src/styles.css#L1063
+*/
+.notion-column {
+  display: flex;
+  flex-direction: column;
+  padding-top: 12px;
+  padding-bottom: 12px;
+}
+
+.notion-column > *:first-child {
+  margin-top: 0;
+  margin-left: 0;
+  margin-right: 0;
+}
+
+.notion-column > *:last-child {
+  margin-left: 0;
+  margin-right: 0;
+  margin-bottom: 0;
+}
+
+.notion-row {
+  display: flex;
+  overflow: hidden;
+  width: 100%;
+  max-width: 100%;
+}
+
+@media (max-width: 640px) {
+  .notion-row {
+    flex-direction: column;
+  }
+
+  .notion-row .notion-column {
+    width: 100% !important;
+  }
+
+  .notion-row .notion-spacer {
+    display: none;
+  }
+}
+
+.notion-spacer {
+  /* This matches the value in ColumnTransformer.ts */
+  width: calc(min(32px, 4vw));
+}
+
+.notion-spacer:last-child {
+  display: none;
+}
+/* End copied from NotionX */

package/dist/plugins/CalloutTransformer.d.ts

@@ -0,0 +1,24 @@
+import { IPlugin } from "./pluginTypes";
+type TextRequest = string;
+type Annotations = {
+    bold: boolean;
+    italic: boolean;
+    strikethrough: boolean;
+    underline: boolean;
+    code: boolean;
+    color: "default" | "gray" | "brown" | "orange" | "yellow" | "green" | "blue" | "purple" | "pink" | "red" | "gray_background" | "brown_background" | "orange_background" | "yellow_background" | "green_background" | "blue_background" | "purple_background" | "pink_background" | "red_background";
+};
+export type Text = {
+    type: "text";
+    text: {
+        content: string;
+        link: {
+            url: TextRequest;
+        } | null;
+    };
+    annotations: Annotations;
+    plain_text: string;
+    href: string | null;
+};
+export declare const standardCalloutTransformer: IPlugin;
+export {};

package/dist/plugins/CalloutTransformer.js

@@ -0,0 +1,88 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standardCalloutTransformer = void 0;
+// In Notion, you can make a callout and change its emoji. We map 5 of these
+// to the 5 Docusaurus admonition styles.
+// This is mostly a copy of the callout code from notion-to-md. The change is to output docusaurus
+// admonitions instead of emulating a callout with markdown > syntax.
+// Note: I haven't yet tested this with any emoji except "💡"/"tip", nor the case where the
+// callout has-children. Not even sure what that would mean, since the document I was testing
+// with has quite complex markup inside the callout, but still takes the no-children branch.
+function notionCalloutToAdmonition(notionToMarkdown, getBlockChildren, block) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // In this case typescript is not able to index the types properly, hence ignoring the error
+        // @ts-ignore
+        const blockContent = block.callout.text || block.callout.rich_text || [];
+        // @ts-ignore
+        const icon = block.callout.icon;
+        let parsedData = "";
+        blockContent.map((content) => {
+            const annotations = content.annotations;
+            let plain_text = content.plain_text;
+            plain_text = notionToMarkdown.annotatePlainText(plain_text, annotations);
+            if (content["href"])
+                plain_text = `[${plain_text}](${content["href"]})`;
+            parsedData += plain_text;
+        });
+        let callout_string = "";
+        const { id, has_children } = block;
+        if (!has_children) {
+            const result1 = callout(parsedData, icon);
+            return result1;
+        }
+        const callout_children_object = yield getBlockChildren(id);
+        // // parse children blocks to md object
+        const callout_children = yield notionToMarkdown.blocksToMarkdown(callout_children_object);
+        callout_string += `${parsedData}\n`;
+        callout_children.map(child => {
+            callout_string += `${child.parent}\n\n`;
+        });
+        const result = callout(callout_string.trim(), icon);
+        return result;
+    });
+}
+const calloutsToAdmonitions = {
+    /* prettier-ignore */ "ℹ️": "note",
+    "📝": "note",
+    "💡": "tip",
+    "❗": "info",
+    "⚠️": "caution",
+    "🔥": "danger",
+};
+// This is the main change from the notion-to-md code.
+function callout(text, icon) {
+    var _a;
+    let emoji;
+    if ((icon === null || icon === void 0 ? void 0 : icon.type) === "emoji") {
+        emoji = icon.emoji;
+    }
+    let docusaurusAdmonition = "note";
+    if (emoji) {
+        // the keyof typeof magic persuades typescript that it really is OK to use emoji as a key into calloutsToAdmonitions
+        docusaurusAdmonition =
+            (_a = calloutsToAdmonitions[emoji]) !== null && _a !== void 0 ? _a : 
+            // For Notion callouts with other emojis, pass them through using hte emoji as the name.
+            // For this to work on a Docusaurus site, it will need to define that time on the remark-admonitions options in the docusaurus.config.js.
+            // See https://github.com/elviswolcott/remark-admonitions and https://docusaurus.io/docs/using-plugins#using-presets.
+            emoji;
+    }
+    return `:::${docusaurusAdmonition}\n\n${text}\n\n:::\n\n`;
+}
+exports.standardCalloutTransformer = {
+    name: "standardCalloutTransformer",
+    notionToMarkdownTransforms: [
+        {
+            type: "callout",
+            getStringFromBlock: (context, block) => notionCalloutToAdmonition(context.notionToMarkdown, context.getBlockChildren, block),
+        },
+    ],
+};

package/dist/plugins/CalloutTransformer.spec.d.ts

@@ -0,0 +1 @@
+export {};