gatsby-source-notion-churnotion 1.1.28 → 1.1.30

package/dist/api/service/notionService.js

@@ -0,0 +1,174 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotionService = void 0;
+const fetchData_1 = require("../../util/fetchData");
+class NotionService {
+    reporter;
+    parallelLimit;
+    enableCaching;
+    cache;
+    limiter;
+    constructor(options) {
+        this.reporter = options.reporter;
+        this.parallelLimit = options.parallelLimit || 5; // 기본 동시 요청 수
+        this.enableCaching = options.enableCaching !== false; // 기본값은 캐싱 활성화
+        this.cache = new Map();
+        this.initLimiter();
+    }
+    async initLimiter() {
+        try {
+            const pLimitModule = await Promise.resolve().then(() => __importStar(require("p-limit")));
+            const pLimit = pLimitModule.default;
+            this.limiter = pLimit(this.parallelLimit);
+        }
+        catch (error) {
+            this.reporter.error(`Failed to initialize p-limit: ${error}`);
+            this.limiter = this.createSimpleLimiter(this.parallelLimit);
+        }
+    }
+    createSimpleLimiter(limit) {
+        let running = 0;
+        const queue = [];
+        const next = () => {
+            running--;
+            if (queue.length > 0) {
+                const run = queue.shift();
+                if (run)
+                    run();
+            }
+        };
+        return (fn) => {
+            return new Promise((resolve, reject) => {
+                const run = () => {
+                    running++;
+                    fn().then(resolve).catch(reject).finally(next);
+                };
+                if (running < limit) {
+                    run();
+                }
+                else {
+                    queue.push(run);
+                }
+            });
+        };
+    }
+    /**
+     * 데이터베이스 쿼리
+     */
+    async queryDatabase(databaseId, body = {}) {
+        const cacheKey = `database-${databaseId}-${JSON.stringify(body)}`;
+        if (this.enableCaching && this.cache.has(cacheKey)) {
+            this.reporter.info(`[CACHE] Using cached database query for ${databaseId}`);
+            return this.cache.get(cacheKey);
+        }
+        const databaseUrl = `databases/${databaseId}/query`;
+        try {
+            const result = await (0, fetchData_1.fetchPostWithRetry)(databaseUrl, body);
+            if (this.enableCaching) {
+                this.cache.set(cacheKey, result);
+            }
+            this.reporter.info(`[SUCCESS] Database query ${databaseId} - results: ${result?.results?.length || 0}`);
+            return result;
+        }
+        catch (error) {
+            this.reporter.error(`[ERROR] Failed to query database ${databaseId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * 페이지의 자식 블록 가져오기
+     */
+    async getPageBlocks(pageId) {
+        const cacheKey = `page-blocks-${pageId}`;
+        if (this.enableCaching && this.cache.has(cacheKey)) {
+            this.reporter.info(`[CACHE] Using cached page blocks for ${pageId}`);
+            return this.cache.get(cacheKey);
+        }
+        const pageUrl = `blocks/${pageId}/children?page_size=100`;
+        try {
+            const data = await (0, fetchData_1.fetchGetWithRetry)(pageUrl);
+            const blocks = data.results;
+            if (this.enableCaching) {
+                this.cache.set(cacheKey, blocks);
+            }
+            return blocks;
+        }
+        catch (error) {
+            this.reporter.error(`[ERROR] Failed to get page blocks ${pageId}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * 여러 페이지의 블록 병렬 처리
+     */
+    async getMultiplePagesBlocks(pageIds) {
+        if (!this.limiter) {
+            await this.initLimiter();
+        }
+        this.reporter.info(`[NOTION] Fetching blocks for ${pageIds.length} pages in parallel (limit: ${this.parallelLimit})`);
+        const tasks = pageIds.map((pageId) => this.limiter(async () => {
+            try {
+                const blocks = await this.getPageBlocks(pageId);
+                return { pageId, blocks };
+            }
+            catch (error) {
+                this.reporter.warn(`[WARNING] Failed to fetch blocks for page ${pageId}: ${error}`);
+                return { pageId, blocks: [] };
+            }
+        }));
+        const results = await Promise.all(tasks);
+        return results.reduce((acc, { pageId, blocks }) => {
+            acc[pageId] = blocks;
+            return acc;
+        }, {});
+    }
+    /**
+     * 캐시 초기화
+     */
+    clearCache() {
+        this.reporter.info(`[NOTION] Clearing service cache - entries: ${this.cache.size}`);
+        this.cache.clear();
+    }
+    /**
+     * 병렬 처리 제한 설정
+     */
+    async setParallelLimit(limit) {
+        this.parallelLimit = limit;
+        await this.initLimiter();
+        this.reporter.info(`[NOTION] Updated parallel request limit to ${limit}`);
+    }
+}
+exports.NotionService = NotionService;

package/dist/util/blocks/blockProcessor.d.ts

@@ -0,0 +1,35 @@
+import { BaseContentBlock } from "notion-types";
+import { Actions, GatsbyCache, Reporter } from "gatsby";
+import { CustomImageBlock } from "../../types";
+export interface BlockProcessorContext {
+    actions: Actions;
+    getCache: (this: void, id: string) => GatsbyCache;
+    createNodeId: (this: void, input: string) => string;
+    reporter: Reporter;
+    cache: GatsbyCache;
+}
+export interface ProcessBlockResult {
+    thumbnail?: string | null;
+    plainText?: string;
+    updatedBlock?: BaseContentBlock;
+    tableOfContents?: {
+        type: string;
+        hash: string;
+        title: string;
+    }[];
+}
+export declare abstract class BlockProcessor {
+    protected context: BlockProcessorContext;
+    constructor(context: BlockProcessorContext);
+    abstract canProcess(block: BaseContentBlock): boolean;
+    abstract process(block: BaseContentBlock): Promise<ProcessBlockResult>;
+    protected extractPlainText(block: BaseContentBlock): string | null;
+    protected isTextContentBlock(block: BaseContentBlock): block is BaseContentBlock & {
+        [key in "paragraph" | "heading_1" | "heading_2" | "heading_3" | "quote" | "bulleted_list_item" | "numbered_list_item" | "callout" | "code" | "toggle" | "to_do" | "bookmark" | "table_of_contents" | "breadcrumb" | "divider" | "embed"]?: {
+            rich_text: {
+                plain_text: string;
+            }[];
+        };
+    };
+    protected isImageBlock(block: BaseContentBlock): block is CustomImageBlock;
+}

package/dist/util/blocks/blockProcessor.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockProcessor = void 0;
+class BlockProcessor {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    extractPlainText(block) {
+        if (this.isTextContentBlock(block)) {
+            const richTextArray = block[block.type]?.rich_text || [];
+            return richTextArray
+                .map((text) => block.type === "code" // code의 \n 제거
+                ? text.plain_text.replace(/\\n/g, "")
+                : text.plain_text)
+                .join(" ");
+        }
+        return null;
+    }
+    isTextContentBlock(block) {
+        return [
+            "paragraph",
+            "heading_1",
+            "heading_2",
+            "heading_3",
+            "quote",
+            "bulleted_list_item",
+            "numbered_list_item",
+            "callout",
+            "code",
+            "toggle",
+            "to_do",
+            "bookmark",
+            "table_of_contents",
+            "breadcrumb",
+            "divider",
+            "embed",
+        ].includes(block.type);
+    }
+    isImageBlock(block) {
+        return block.type === "image" && "image" in block;
+    }
+}
+exports.BlockProcessor = BlockProcessor;

package/dist/util/blocks/blockProcessorRegistry.d.ts

@@ -0,0 +1,10 @@
+import { BaseContentBlock } from "notion-types";
+import { BlockProcessor, BlockProcessorContext, ProcessBlockResult } from "./blockProcessor";
+export declare class BlockProcessorRegistry {
+    private processors;
+    private context;
+    constructor(context: BlockProcessorContext);
+    private registerDefaultProcessors;
+    registerProcessor(processor: BlockProcessor): void;
+    processBlock(block: BaseContentBlock): Promise<ProcessBlockResult>;
+}

package/dist/util/blocks/blockProcessorRegistry.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockProcessorRegistry = void 0;
+const textBlockProcessor_1 = require("./textBlockProcessor");
+const imageBlockProcessor_1 = require("./imageBlockProcessor");
+const mediaBlockProcessor_1 = require("./mediaBlockProcessor");
+const structureBlockProcessor_1 = require("./structureBlockProcessor");
+class BlockProcessorRegistry {
+    processors = [];
+    context;
+    constructor(context) {
+        this.context = context;
+        this.registerDefaultProcessors();
+    }
+    registerDefaultProcessors() {
+        // 기본 프로세서 등록
+        this.registerProcessor(new textBlockProcessor_1.TextBlockProcessor(this.context));
+        this.registerProcessor(new imageBlockProcessor_1.ImageBlockProcessor(this.context));
+        this.registerProcessor(new mediaBlockProcessor_1.MediaBlockProcessor(this.context));
+        this.registerProcessor(new structureBlockProcessor_1.StructureBlockProcessor(this.context));
+    }
+    registerProcessor(processor) {
+        this.processors.push(processor);
+    }
+    async processBlock(block) {
+        for (const processor of this.processors) {
+            if (processor.canProcess(block)) {
+                return await processor.process(block);
+            }
+        }
+        // 어떤 프로세서도 처리할 수 없는 경우 (디버깅을 위해 타입 로그)
+        this.context.reporter.warn(`Unsupported block type: ${block.type}`);
+        // 기본 결과 반환
+        return {
+            updatedBlock: block,
+            plainText: "",
+        };
+    }
+}
+exports.BlockProcessorRegistry = BlockProcessorRegistry;

package/dist/util/blocks/imageBlockProcessor.d.ts

@@ -0,0 +1,6 @@
+import { BaseContentBlock } from "notion-types";
+import { BlockProcessor, ProcessBlockResult } from "./blockProcessor";
+export declare class ImageBlockProcessor extends BlockProcessor {
+    canProcess(block: BaseContentBlock): boolean;
+    process(block: BaseContentBlock): Promise<ProcessBlockResult>;
+}

package/dist/util/blocks/imageBlockProcessor.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageBlockProcessor = void 0;
+const blockProcessor_1 = require("./blockProcessor");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const gatsby_source_filesystem_1 = require("gatsby-source-filesystem");
+class ImageBlockProcessor extends blockProcessor_1.BlockProcessor {
+    canProcess(block) {
+        return this.isImageBlock(block);
+    }
+    async process(block) {
+        const { actions, getCache, createNodeId, reporter, cache } = this.context;
+        const { createNode } = actions;
+        const imageBlock = block;
+        if (block.type === "image" && "image" in block) {
+            const imageSourceType = imageBlock.image.type;
+            const imageUrl = imageSourceType === `external`
+                ? imageBlock.image.external?.url
+                : imageBlock.image?.file?.url;
+            if (!imageUrl)
+                return { updatedBlock: block };
+            // GIF 파일 처리
+            if (imageUrl.endsWith(".gif")) {
+                const staticDir = path_1.default.join(process.cwd(), "static"); // Gatsby의 static 디렉토리
+                const gifFileName = path_1.default.basename(imageUrl); // 파일 이름 추출
+                const gifFilePath = path_1.default.join(staticDir, gifFileName);
+                // 이미 static 디렉토리에 파일이 있는지 확인
+                if (!fs_extra_1.default.existsSync(gifFilePath)) {
+                    try {
+                        reporter.info(`[GIF PROCESSING] Downloading GIF: ${imageUrl}`);
+                        const response = await fetch(imageUrl);
+                        if (!response.ok) {
+                            throw new Error(`Failed to download GIF: ${response.statusText}`);
+                        }
+                        const arrayBuffer = await response.arrayBuffer();
+                        const buffer = Buffer.from(arrayBuffer);
+                        await fs_extra_1.default.ensureDir(staticDir); // static 디렉토리 생성
+                        await fs_extra_1.default.writeFile(gifFilePath, buffer); // GIF 파일 저장
+                        reporter.info(`[GIF SUCCESS] Saved GIF to static: ${gifFilePath}`);
+                    }
+                    catch (error) {
+                        reporter.warn(`[GIF WARNING] Failed to process GIF: ${imageUrl}`);
+                        return { updatedBlock: block };
+                    }
+                }
+                else {
+                    reporter.info(`[GIF CACHE HIT] GIF already exists: ${gifFilePath}`);
+                }
+                // GIF 파일을 정적 파일로 추가
+                const updatedBlock = {
+                    ...imageBlock,
+                    image: {
+                        fileId: gifFileName, // static 경로를 기준으로 참조
+                        caption: imageBlock.image.caption,
+                    },
+                };
+                return {
+                    updatedBlock: updatedBlock,
+                    thumbnail: gifFileName,
+                };
+            }
+            // GIF가 아닌 경우 기존 로직 유지
+            const cacheKey = `${imageUrl}-post-image`;
+            const cachedFileNodeId = await cache.get(cacheKey);
+            if (cachedFileNodeId) {
+                reporter.info(`[CACHE HIT] Image already processed: ${imageUrl}`);
+                const updatedBlock = {
+                    ...imageBlock,
+                    image: {
+                        fileId: cachedFileNodeId,
+                        caption: imageBlock.image.caption,
+                    },
+                };
+                return {
+                    updatedBlock: updatedBlock,
+                    thumbnail: cachedFileNodeId,
+                };
+            }
+            try {
+                const fileNode = await (0, gatsby_source_filesystem_1.createRemoteFileNode)({
+                    url: imageUrl,
+                    parentNodeId: block.id,
+                    getCache,
+                    createNode,
+                    createNodeId,
+                });
+                if (fileNode) {
+                    await cache.set(cacheKey, fileNode.id);
+                    const updatedBlock = {
+                        ...imageBlock,
+                        image: {
+                            fileId: fileNode.id,
+                            caption: imageBlock.image.caption,
+                        },
+                    };
+                    return {
+                        updatedBlock: updatedBlock,
+                        thumbnail: fileNode.id,
+                    };
+                }
+            }
+            catch (error) {
+                reporter.warn(`[WARNING] Failed to download or process image: ${imageUrl}`);
+            }
+        }
+        return { updatedBlock: block };
+    }
+}
+exports.ImageBlockProcessor = ImageBlockProcessor;

package/dist/util/blocks/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./blockProcessor";
+export * from "./blockProcessorRegistry";
+export * from "./imageBlockProcessor";
+export * from "./mediaBlockProcessor";
+export * from "./structureBlockProcessor";
+export * from "./textBlockProcessor";

package/dist/util/blocks/index.js

@@ -0,0 +1,22 @@
+"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 __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 });
+__exportStar(require("./blockProcessor"), exports);
+__exportStar(require("./blockProcessorRegistry"), exports);
+__exportStar(require("./imageBlockProcessor"), exports);
+__exportStar(require("./mediaBlockProcessor"), exports);
+__exportStar(require("./structureBlockProcessor"), exports);
+__exportStar(require("./textBlockProcessor"), exports);

package/dist/util/blocks/mediaBlockProcessor.d.ts

@@ -0,0 +1,6 @@
+import { BaseContentBlock } from "notion-types";
+import { BlockProcessor, ProcessBlockResult } from "./blockProcessor";
+export declare class MediaBlockProcessor extends BlockProcessor {
+    canProcess(block: BaseContentBlock): boolean;
+    process(block: BaseContentBlock): Promise<ProcessBlockResult>;
+}

package/dist/util/blocks/mediaBlockProcessor.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaBlockProcessor = void 0;
+const blockProcessor_1 = require("./blockProcessor");
+class MediaBlockProcessor extends blockProcessor_1.BlockProcessor {
+    canProcess(block) {
+        return ["bookmark", "embed", "video", "audio", "pdf", "file"].includes(block.type);
+    }
+    async process(block) {
+        const { reporter } = this.context;
+        // 미디어 블록 타입 처리 로직
+        const blockType = block.type;
+        // 각 블록 타입에 맞는 특별한 처리가 필요한 경우 여기에 추가
+        switch (blockType) {
+            case "bookmark":
+                reporter.info(`Processing bookmark block: ${JSON.stringify(block.bookmark?.url)}`);
+                break;
+            case "embed":
+                reporter.info(`Processing embed block: ${JSON.stringify(block.embed?.url)}`);
+                break;
+            case "video":
+                reporter.info(`Processing video block with type: ${JSON.stringify(block.video?.type)}`);
+                break;
+            case "audio":
+                reporter.info(`Processing audio block with type: ${JSON.stringify(block.audio?.type)}`);
+                break;
+            case "pdf":
+                reporter.info(`Processing pdf block with type: ${JSON.stringify(block.pdf?.type)}`);
+                break;
+            case "file":
+                reporter.info(`Processing file block with type: ${JSON.stringify(block.file?.type)}`);
+                break;
+        }
+        // 블록의 텍스트 컨텐츠를 추출하려고 시도합니다.
+        let plainText = "";
+        // bookmark와 같은 일부 블록은 캡션에 텍스트가 있을 수 있습니다.
+        if (blockType === "bookmark" && block.bookmark?.caption) {
+            plainText = block.bookmark.caption
+                .map((item) => item.plain_text)
+                .join(" ");
+        }
+        return {
+            plainText,
+            updatedBlock: block,
+        };
+    }
+}
+exports.MediaBlockProcessor = MediaBlockProcessor;

package/dist/util/blocks/structureBlockProcessor.d.ts

@@ -0,0 +1,6 @@
+import { BaseContentBlock } from "notion-types";
+import { BlockProcessor, ProcessBlockResult } from "./blockProcessor";
+export declare class StructureBlockProcessor extends BlockProcessor {
+    canProcess(block: BaseContentBlock): boolean;
+    process(block: BaseContentBlock): Promise<ProcessBlockResult>;
+}

package/dist/util/blocks/structureBlockProcessor.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructureBlockProcessor = void 0;
+const blockProcessor_1 = require("./blockProcessor");
+class StructureBlockProcessor extends blockProcessor_1.BlockProcessor {
+    canProcess(block) {
+        return [
+            "column",
+            "column_list",
+            "table",
+            "table_row",
+            "divider",
+            "breadcrumb",
+            "table_of_contents",
+            "equation",
+            "synced_block",
+            "template",
+            "link_to_page",
+            "link_preview",
+        ].includes(block.type);
+    }
+    async process(block) {
+        const { reporter } = this.context;
+        // 구조 블록 타입 처리 로직
+        const blockType = block.type;
+        // 각 블록 타입에 맞는 특별한 처리가 필요한 경우 여기에 추가
+        switch (blockType) {
+            case "column":
+                reporter.info(`Processing column block`);
+                break;
+            case "column_list":
+                reporter.info(`Processing column_list block`);
+                break;
+            case "table":
+                reporter.info(`Processing table block: table_width=${JSON.stringify(block.table?.table_width)}`);
+                break;
+            case "table_row":
+                const cellCount = block.table_row?.cells?.length || 0;
+                reporter.info(`Processing table_row block with ${cellCount} cells`);
+                break;
+            case "divider":
+                reporter.info(`Processing divider block`);
+                break;
+            case "breadcrumb":
+                reporter.info(`Processing breadcrumb block`);
+                break;
+            case "table_of_contents":
+                reporter.info(`Processing table_of_contents block`);
+                break;
+            case "equation":
+                reporter.info(`Processing equation block: ${JSON.stringify(block.equation?.expression)}`);
+                break;
+            case "synced_block":
+                reporter.info(`Processing synced_block`);
+                break;
+            case "template":
+                reporter.info(`Processing template block`);
+                break;
+            case "link_to_page":
+                reporter.info(`Processing link_to_page block`);
+                break;
+            case "link_preview":
+                reporter.info(`Processing link_preview block: ${JSON.stringify(block.link_preview?.url)}`);
+                break;
+        }
+        // 일부 구조 블록은 텍스트를 포함할 수 있음
+        let plainText = "";
+        // 테이블 셀에서 텍스트 추출 예시
+        if (blockType === "table_row" && block.table_row?.cells) {
+            plainText = block.table_row.cells
+                .flat()
+                .map((cell) => cell.plain_text || "")
+                .join(" ");
+        }
+        return {
+            plainText,
+            updatedBlock: block,
+        };
+    }
+}
+exports.StructureBlockProcessor = StructureBlockProcessor;

package/dist/util/blocks/textBlockProcessor.d.ts

@@ -0,0 +1,6 @@
+import { BaseContentBlock } from "notion-types";
+import { BlockProcessor, ProcessBlockResult } from "./blockProcessor";
+export declare class TextBlockProcessor extends BlockProcessor {
+    canProcess(block: BaseContentBlock): boolean;
+    process(block: BaseContentBlock): Promise<ProcessBlockResult>;
+}

package/dist/util/blocks/textBlockProcessor.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextBlockProcessor = void 0;
+const blockProcessor_1 = require("./blockProcessor");
+const tableOfContent_1 = require("../tableOfContent");
+class TextBlockProcessor extends blockProcessor_1.BlockProcessor {
+    canProcess(block) {
+        return this.isTextContentBlock(block);
+    }
+    async process(block) {
+        const tableOfContents = [];
+        // 목차 처리
+        await (0, tableOfContent_1.processTableOfContents)(block, tableOfContents);
+        // 텍스트 추출
+        const plainText = this.extractPlainText(block);
+        return {
+            plainText: plainText || "",
+            updatedBlock: block,
+            tableOfContents: tableOfContents.length > 0 ? tableOfContents : undefined,
+        };
+    }
+}
+exports.TextBlockProcessor = TextBlockProcessor;