n8n-nodes-notion-advanced 1.2.30-beta → 1.2.32-beta

package/nodes/NotionAdvanced/NotionAITool.node.d.ts

@@ -22,6 +22,15 @@ interface XMLNode {
     replacement?: string;
     listProcessor?: (content: string, blocks: IDataObject[]) => void;
 }
+interface HierarchyNode {
+    block: IDataObject;
+    children: HierarchyNode[];
+    metadata?: {
+        sourcePosition?: number;
+        xmlNodeId?: string;
+        tagName?: string;
+    };
+}
 export declare class NotionAITool implements INodeType {
     description: INodeTypeDescription;
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
@@ -43,6 +52,8 @@ export declare class NotionAITool implements INodeType {
     }[]): string;
     static getUtf8BytePosition(str: string, charIndex: number): number;
     static buildXMLTree(content: string, tagProcessors: any[]): XMLNode[];
+    static xmlTreeToHierarchy(nodes: XMLNode[]): HierarchyNode[];
+    static hierarchyToNotionBlocks(hierarchy: HierarchyNode[]): IDataObject[];
     static processXMLTreeDepthFirst(nodes: XMLNode[], blocks: IDataObject[], placeholderCounter: {
         value: number;
     }): Map<string, string>;
@@ -54,7 +65,14 @@ export declare class NotionAITool implements INodeType {
     static cleanupRemainingHtml(content: string, placeholderPrefix?: string): string;
     static processNestedHtmlInListItem(content: string): string;
     static convertInlineHtmlToMarkdown(content: string): string;
-    static processNestedList(listContent: string, listType: 'bulleted_list_item' | 'numbered_list_item', blocks: IDataObject[]): void;
+    static buildListHierarchy(listContent: string, listType: 'bulleted_list_item' | 'numbered_list_item', childHierarchyNodes: HierarchyNode[]): HierarchyNode | null;
+    static getListItemPositions(content: string): Array<{
+        start: number;
+        end: number;
+    }>;
+    static mapChildBlocksToListItems(listContent: string, childBlocks: IDataObject[], childNodes: XMLNode[]): Map<number, IDataObject[]>;
+    static processNestedListWithChildBlocks(listContent: string, listType: 'bulleted_list_item' | 'numbered_list_item', blocks: IDataObject[], listItemChildBlocks: Map<number, IDataObject[]>): void;
+    static processNestedList(listContent: string, listType: 'bulleted_list_item' | 'numbered_list_item', blocks: IDataObject[], childNodes?: XMLNode[]): void;
     static extractListItemsWithBranching(content: string): Array<{
         text: string;
         children: Array<{

package/nodes/NotionAdvanced/NotionAITool.node.js

@@ -749,67 +749,55 @@ class NotionAITool {
     static buildXMLTree(content, tagProcessors) {
         var _a;
         const allMatches = [];
-        // Step 1: Use depth-aware parsing for each tag processor
+        // Step 1: Use regex-based parsing to properly extract capture groups, then enhance with depth-aware structure
         tagProcessors.forEach(({ regex, blockCreator, listProcessor }) => {
             var _a;
-            const tagPattern = (_a = regex.source.match(/<(\w+)/)) === null || _a === void 0 ? void 0 : _a[1];
-            if (!tagPattern)
-                return;
-            // Find all opening tags of this type
-            let pos = 0;
-            while (pos < content.length) {
-                const openTagStart = content.indexOf(`<${tagPattern}`, pos);
-                if (openTagStart === -1)
-                    break;
-                const openTagEnd = content.indexOf('>', openTagStart);
-                if (openTagEnd === -1)
-                    break;
-                // Find matching closing tag using depth tracking
-                let depth = 1;
-                let searchPos = openTagEnd + 1;
-                let closeTagStart = -1;
-                const openPattern = `<${tagPattern}`;
-                const closePattern = `</${tagPattern}>`;
-                while (searchPos < content.length && depth > 0) {
-                    const nextOpen = content.indexOf(openPattern, searchPos);
-                    const nextClose = content.indexOf(closePattern, searchPos);
-                    if (nextClose === -1)
-                        break;
-                    if (nextOpen !== -1 && nextOpen < nextClose) {
-                        // Found nested opening tag
-                        depth++;
-                        searchPos = nextOpen + openPattern.length;
+            const globalRegex = new RegExp(regex.source, 'gis');
+            let match;
+            while ((match = globalRegex.exec(content)) !== null) {
+                const fullMatch = match[0];
+                const matchStart = match.index;
+                const matchEnd = match.index + fullMatch.length;
+                // Extract tag name for identification
+                const tagPattern = ((_a = regex.source.match(/<(\w+)/)) === null || _a === void 0 ? void 0 : _a[1]) || 'unknown';
+                // Extract inner content (between opening and closing tags)
+                let innerContent = '';
+                try {
+                    const openTagRegex = new RegExp(`^<${tagPattern}[^>]*>`, 'i');
+                    const closeTagRegex = new RegExp(`</${tagPattern}>$`, 'i');
+                    const openMatch = fullMatch.match(openTagRegex);
+                    const closeMatch = fullMatch.match(closeTagRegex);
+                    if (openMatch && closeMatch) {
+                        const openTag = openMatch[0];
+                        const closeTag = closeMatch[0];
+                        const startIndex = openTag.length;
+                        const endIndex = fullMatch.length - closeTag.length;
+                        innerContent = fullMatch.substring(startIndex, endIndex);
                     }
                     else {
-                        // Found closing tag
-                        depth--;
-                        if (depth === 0) {
-                            closeTagStart = nextClose;
-                            break;
-                        }
-                        searchPos = nextClose + closePattern.length;
+                        // Fallback for self-closing or malformed tags
+                        innerContent = fullMatch.replace(/^<[^>]*>/, '').replace(/<\/[^>]*>$/, '');
                     }
                 }
-                if (closeTagStart !== -1) {
-                    const fullMatch = content.substring(openTagStart, closeTagStart + closePattern.length);
-                    const innerContent = content.substring(openTagEnd + 1, closeTagStart);
-                    const xmlNode = {
-                        id: `${tagPattern}_${openTagStart}_${Date.now()}_${Math.random()}`,
-                        tagName: tagPattern,
-                        start: openTagStart,
-                        end: closeTagStart + closePattern.length,
-                        match: fullMatch,
-                        processor: blockCreator,
-                        groups: [innerContent], // For list processors, group[0] is the inner content
-                        children: [],
-                        depth: 0,
-                        innerContent,
-                        replacement: undefined,
-                        listProcessor
-                    };
-                    allMatches.push(xmlNode);
+                catch (error) {
+                    console.warn(`Error extracting inner content for ${tagPattern}:`, error);
+                    innerContent = fullMatch;
                 }
-                pos = openTagEnd + 1;
+                const xmlNode = {
+                    id: `${tagPattern}_${matchStart}_${Date.now()}_${Math.random()}`,
+                    tagName: tagPattern,
+                    start: matchStart,
+                    end: matchEnd,
+                    match: fullMatch,
+                    processor: blockCreator,
+                    groups: match.slice(1), // Proper regex capture groups (excluding full match)
+                    children: [],
+                    depth: 0,
+                    innerContent,
+                    replacement: undefined,
+                    listProcessor
+                };
+                allMatches.push(xmlNode);
             }
         });
         // Step 2: Catch ANY remaining XML/HTML tags that weren't processed by specific processors
@@ -869,92 +857,141 @@ class NotionAITool {
         }
         return rootNodes;
     }
-    // Process XML tree depth-first (children before parents)
-    static processXMLTreeDepthFirst(nodes, blocks, placeholderCounter) {
-        const replacements = new Map();
-        const processNode = (node) => {
-            // For lists, use the original match content to preserve structure
-            // This is the only case where we skip child processing to avoid fragmentation
-            if (node.listProcessor && (node.tagName === 'ul' || node.tagName === 'ol')) {
-                try {
-                    // Extract inner content directly from the original match
-                    const tagName = node.tagName.toLowerCase();
+    // Convert XML tree to HierarchyNode structure for cleaner processing
+    static xmlTreeToHierarchy(nodes) {
+        const hierarchyNodes = [];
+        const processNode = (xmlNode) => {
+            try {
+                // Process children first
+                const childHierarchyNodes = [];
+                for (const child of xmlNode.children) {
+                    const childHierarchy = processNode(child);
+                    if (childHierarchy) {
+                        childHierarchyNodes.push(childHierarchy);
+                    }
+                }
+                // For list processors, handle them specially
+                if (xmlNode.listProcessor && (xmlNode.tagName === 'ul' || xmlNode.tagName === 'ol')) {
+                    // Extract inner content and calculate offset
+                    const tagName = xmlNode.tagName.toLowerCase();
                     const openTagRegex = new RegExp(`^<${tagName}[^>]*>`, 'i');
                     const closeTagRegex = new RegExp(`</${tagName}>$`, 'i');
-                    let innerContent = node.match;
-                    const openMatch = node.match.match(openTagRegex);
-                    const closeMatch = node.match.match(closeTagRegex);
+                    let innerContent = xmlNode.match;
+                    let contentStartOffset = 0;
+                    const openMatch = xmlNode.match.match(openTagRegex);
+                    const closeMatch = xmlNode.match.match(closeTagRegex);
                     if (openMatch && closeMatch) {
                         const openTag = openMatch[0];
                         const closeTag = closeMatch[0];
                         const startIndex = openTag.length;
-                        const endIndex = node.match.length - closeTag.length;
-                        innerContent = node.match.substring(startIndex, endIndex);
+                        const endIndex = xmlNode.match.length - closeTag.length;
+                        innerContent = xmlNode.match.substring(startIndex, endIndex);
+                        contentStartOffset = xmlNode.start + startIndex; // Absolute position where list content starts
                     }
-                    // Process the list with complete content
-                    node.listProcessor(innerContent, blocks);
-                    return ''; // Remove completely - no placeholder needed
-                }
-                catch (error) {
-                    console.warn(`Error processing list node ${node.tagName}:`, error);
-                    return ''; // Remove even on error to prevent artifacts
-                }
-            }
-            // For non-list nodes, process children first (normal hierarchical processing)
-            for (const child of node.children) {
-                const childReplacement = processNode(child);
-                replacements.set(child.id, childReplacement);
-            }
-            // Extract inner content (content between opening and closing tags)
-            let innerContent = '';
-            try {
-                // More robust inner content extraction
-                const tagName = node.tagName.toLowerCase();
-                const openTagRegex = new RegExp(`^<${tagName}[^>]*>`, 'i');
-                const closeTagRegex = new RegExp(`</${tagName}>$`, 'i');
-                const openMatch = node.match.match(openTagRegex);
-                const closeMatch = node.match.match(closeTagRegex);
-                if (openMatch && closeMatch) {
-                    const openTag = openMatch[0];
-                    const closeTag = closeMatch[0];
-                    const startIndex = openTag.length;
-                    const endIndex = node.match.length - closeTag.length;
-                    innerContent = node.match.substring(startIndex, endIndex);
+                    // Adjust child hierarchy node positions to be relative to list content
+                    const adjustedChildNodes = childHierarchyNodes.map(child => {
+                        var _a;
+                        return ({
+                            ...child,
+                            metadata: {
+                                ...child.metadata,
+                                sourcePosition: ((_a = child.metadata) === null || _a === void 0 ? void 0 : _a.sourcePosition) !== undefined
+                                    ? child.metadata.sourcePosition - contentStartOffset
+                                    : undefined
+                            }
+                        });
+                    });
+                    // Build hierarchy structure for the list
+                    const listHierarchy = NotionAITool.buildListHierarchy(innerContent, xmlNode.tagName === 'ul' ? 'bulleted_list_item' : 'numbered_list_item', adjustedChildNodes);
+                    return listHierarchy;
                 }
-                else {
-                    // Fallback for self-closing or malformed tags
-                    innerContent = node.match.replace(/^<[^>]*>/, '').replace(/<\/[^>]*>$/, '');
-                }
-                // Replace child nodes in inner content with their processed content
-                for (const child of node.children) {
-                    const childReplacement = replacements.get(child.id) || '';
-                    if (childReplacement !== undefined && innerContent.includes(child.match)) {
-                        innerContent = innerContent.replace(child.match, childReplacement);
+                // For regular nodes, create block and attach children
+                const block = xmlNode.processor(...xmlNode.groups);
+                if (!block)
+                    return null;
+                const hierarchyNode = {
+                    block,
+                    children: childHierarchyNodes,
+                    metadata: {
+                        sourcePosition: xmlNode.start,
+                        xmlNodeId: xmlNode.id,
+                        tagName: xmlNode.tagName
                     }
-                }
-            }
-            catch (error) {
-                console.warn(`Error extracting inner content for ${node.tagName}:`, error);
-                innerContent = node.match;
-            }
-            // Process this node with updated inner content
-            try {
-                // Use blockCreator to create the block
-                const block = node.processor(...node.groups);
-                if (block) {
-                    blocks.push(block);
-                }
-                return ''; // Remove completely - no placeholder needed
+                };
+                return hierarchyNode;
             }
             catch (error) {
-                console.warn(`Error processing XML node ${node.tagName}:`, error);
-                return ''; // Remove even on error to prevent artifacts
+                console.warn(`Error processing XML node ${xmlNode.tagName}:`, error);
+                return null;
             }
         };
         // Process all root nodes
         for (const rootNode of nodes) {
-            const replacement = processNode(rootNode);
-            replacements.set(rootNode.id, replacement);
+            const hierarchyNode = processNode(rootNode);
+            if (hierarchyNode) {
+                if (hierarchyNode.block) {
+                    hierarchyNodes.push(hierarchyNode);
+                }
+                else if (hierarchyNode.children.length > 0) {
+                    // If it's a list container, add its children directly
+                    hierarchyNodes.push(...hierarchyNode.children);
+                }
+            }
+        }
+        return hierarchyNodes;
+    }
+    // Convert HierarchyNode structure to final Notion blocks
+    static hierarchyToNotionBlocks(hierarchy) {
+        return hierarchy.map(node => {
+            const block = { ...node.block };
+            if (node.children.length > 0) {
+                const blockData = block[block.type];
+                if (blockData && typeof blockData === 'object') {
+                    // Check if this block type can have children
+                    const childSupportingTypes = ['bulleted_list_item', 'numbered_list_item', 'toggle', 'quote', 'callout'];
+                    if (childSupportingTypes.includes(block.type)) {
+                        blockData.children = NotionAITool.hierarchyToNotionBlocks(node.children);
+                    }
+                }
+            }
+            return block;
+        });
+    }
+    // Process XML tree using the new hierarchy system
+    static processXMLTreeDepthFirst(nodes, blocks, placeholderCounter) {
+        const replacements = new Map();
+        try {
+            // Convert XML tree to hierarchy structure
+            const hierarchy = NotionAITool.xmlTreeToHierarchy(nodes);
+            // Convert hierarchy to final Notion blocks
+            const finalBlocks = NotionAITool.hierarchyToNotionBlocks(hierarchy);
+            // Add all blocks to the output
+            blocks.push(...finalBlocks);
+            // Mark all nodes as processed (empty replacement)
+            const markProcessed = (nodeList) => {
+                nodeList.forEach(node => {
+                    replacements.set(node.id, '');
+                    markProcessed(node.children);
+                });
+            };
+            markProcessed(nodes);
+        }
+        catch (error) {
+            console.warn('Error in hierarchy processing, falling back to legacy processing:', error);
+            // Fallback to simple processing if hierarchy fails
+            nodes.forEach(node => {
+                try {
+                    const block = node.processor(...node.groups);
+                    if (block) {
+                        blocks.push(block);
+                    }
+                    replacements.set(node.id, '');
+                }
+                catch (nodeError) {
+                    console.warn(`Error processing fallback node ${node.tagName}:`, nodeError);
+                    replacements.set(node.id, '');
+                }
+            });
         }
         return replacements;
     }
@@ -1499,13 +1536,17 @@ class NotionAITool {
         processed = processed.replace(/\s+/g, ' ').trim();
         return processed;
     }
-    // Helper function to process lists using branch-based approach
-    // Each <ul> and <ol> represents a new branch that contains children
-    static processNestedList(listContent, listType, blocks) {
+    // Build hierarchy structure for lists using HierarchyNode approach
+    static buildListHierarchy(listContent, listType, childHierarchyNodes) {
+        var _a;
         try {
-            // Process each <li> element as a potential branch point
+            // Process each <li> element and build hierarchy
             const listItems = NotionAITool.extractListItemsWithBranching(listContent);
-            for (const item of listItems) {
+            const listItemHierarchyNodes = [];
+            // Map child hierarchy nodes to list items based on actual position in source XML
+            const listItemPositions = NotionAITool.getListItemPositions(listContent);
+            for (let i = 0; i < listItems.length; i++) {
+                const item = listItems[i];
                 if (!item.text && !item.children.length)
                     continue;
                 // Create list item block
@@ -1522,17 +1563,191 @@ class NotionAITool {
                         listItemBlock[listType].rich_text = NotionAITool.parseBasicMarkdown(cleanText);
                     }
                 }
-                // Process child branches and add them as nested children
+                // Collect child hierarchy nodes for this list item based on position mapping
+                const itemChildNodes = [];
+                // Map child hierarchy nodes that belong to this specific list item
+                if (i < listItemPositions.length) {
+                    const currentItemStart = listItemPositions[i].start;
+                    const currentItemEnd = listItemPositions[i].end;
+                    for (const childNode of childHierarchyNodes) {
+                        const childPosition = (_a = childNode.metadata) === null || _a === void 0 ? void 0 : _a.sourcePosition;
+                        if (childPosition !== undefined &&
+                            childPosition >= currentItemStart &&
+                            childPosition < currentItemEnd) {
+                            itemChildNodes.push(childNode);
+                        }
+                    }
+                }
+                // Process nested list children (traditional nested lists)
                 if (item.children.length > 0) {
-                    const childBlocks = [];
                     for (const child of item.children) {
                         const childListType = child.type === 'ul' ? 'bulleted_list_item' : 'numbered_list_item';
-                        NotionAITool.processNestedList(child.content, childListType, childBlocks);
+                        const childListHierarchy = NotionAITool.buildListHierarchy(child.content, childListType, []);
+                        if (childListHierarchy && childListHierarchy.children) {
+                            itemChildNodes.push(...childListHierarchy.children);
+                        }
                     }
-                    // Add children to the parent block
-                    if (childBlocks.length > 0) {
-                        listItemBlock[listType].children = childBlocks;
+                }
+                // Create hierarchy node for this list item
+                const listItemHierarchyNode = {
+                    block: listItemBlock,
+                    children: itemChildNodes,
+                    metadata: {
+                        sourcePosition: i,
+                        tagName: listType
                     }
+                };
+                // Only add if it has content or children
+                const listData = listItemBlock[listType];
+                if ((listData.rich_text && listData.rich_text.length > 0) || itemChildNodes.length > 0) {
+                    listItemHierarchyNodes.push(listItemHierarchyNode);
+                }
+            }
+            // Return a container that holds all list items
+            return {
+                block: null, // No container block needed
+                children: listItemHierarchyNodes,
+                metadata: {
+                    tagName: listType === 'bulleted_list_item' ? 'ul' : 'ol'
+                }
+            };
+        }
+        catch (error) {
+            console.warn('Error building list hierarchy:', error);
+            // Fallback: create a simple text block
+            return {
+                block: {
+                    type: 'paragraph',
+                    paragraph: {
+                        rich_text: [{ type: 'text', text: { content: 'Error processing list content' } }],
+                    },
+                },
+                children: [],
+                metadata: { tagName: 'paragraph' }
+            };
+        }
+    }
+    // Helper function to get position ranges for each list item in the content
+    static getListItemPositions(content) {
+        const positions = [];
+        let pos = 0;
+        while (pos < content.length) {
+            // Find next <li> tag
+            const liStart = content.indexOf('<li', pos);
+            if (liStart === -1)
+                break;
+            const liOpenEnd = content.indexOf('>', liStart);
+            if (liOpenEnd === -1)
+                break;
+            // Find the matching </li> using proper depth tracking
+            let depth = 0;
+            let searchPos = liOpenEnd + 1;
+            let liEnd = -1;
+            while (searchPos < content.length) {
+                const nextLiOpen = content.indexOf('<li', searchPos);
+                const nextLiClose = content.indexOf('</li>', searchPos);
+                if (nextLiClose === -1)
+                    break;
+                if (nextLiOpen !== -1 && nextLiOpen < nextLiClose) {
+                    depth++;
+                    searchPos = nextLiOpen + 3;
+                }
+                else {
+                    if (depth === 0) {
+                        liEnd = nextLiClose + 5; // Include the '</li>'
+                        break;
+                    }
+                    else {
+                        depth--;
+                        searchPos = nextLiClose + 5;
+                    }
+                }
+            }
+            if (liEnd !== -1) {
+                positions.push({
+                    start: liStart,
+                    end: liEnd
+                });
+                pos = liEnd;
+            }
+            else {
+                pos = liOpenEnd + 1;
+            }
+        }
+        return positions;
+    }
+    // Helper function to map child blocks to specific list items (legacy support)
+    static mapChildBlocksToListItems(listContent, childBlocks, childNodes) {
+        const listItemChildBlocks = new Map();
+        // Find all <li> positions in the content
+        const liPositions = [];
+        let pos = 0;
+        while (pos < listContent.length) {
+            const liStart = listContent.indexOf('<li', pos);
+            if (liStart === -1)
+                break;
+            liPositions.push(liStart);
+            pos = liStart + 3;
+        }
+        // Map child nodes to their corresponding list items
+        childNodes.forEach((childNode, index) => {
+            // Find which <li> this child node belongs to
+            let liIndex = -1;
+            for (let i = 0; i < liPositions.length; i++) {
+                const liStart = liPositions[i];
+                const nextLiStart = i + 1 < liPositions.length ? liPositions[i + 1] : listContent.length;
+                if (childNode.start >= liStart && childNode.start < nextLiStart) {
+                    liIndex = i;
+                    break;
+                }
+            }
+            if (liIndex >= 0 && index < childBlocks.length) {
+                if (!listItemChildBlocks.has(liIndex)) {
+                    listItemChildBlocks.set(liIndex, []);
+                }
+                listItemChildBlocks.get(liIndex).push(childBlocks[index]);
+            }
+        });
+        return listItemChildBlocks;
+    }
+    // Enhanced list processor that handles child blocks (legacy support)
+    static processNestedListWithChildBlocks(listContent, listType, blocks, listItemChildBlocks) {
+        try {
+            // Process each <li> element as a potential branch point
+            const listItems = NotionAITool.extractListItemsWithBranching(listContent);
+            for (let i = 0; i < listItems.length; i++) {
+                const item = listItems[i];
+                if (!item.text && !item.children.length)
+                    continue;
+                // Create list item block
+                const listItemBlock = {
+                    type: listType,
+                    [listType]: {
+                        rich_text: [],
+                    },
+                };
+                // Add parent text if present
+                if (item.text && item.text.trim()) {
+                    const cleanText = NotionAITool.processNestedHtmlInListItem(item.text);
+                    if (cleanText) {
+                        listItemBlock[listType].rich_text = NotionAITool.parseBasicMarkdown(cleanText);
+                    }
+                }
+                // Collect all child blocks
+                const allChildBlocks = [];
+                // Add child blocks from hierarchical processing
+                const childBlocks = listItemChildBlocks.get(i) || [];
+                allChildBlocks.push(...childBlocks);
+                // Process nested list children (traditional nested lists)
+                if (item.children.length > 0) {
+                    for (const child of item.children) {
+                        const childListType = child.type === 'ul' ? 'bulleted_list_item' : 'numbered_list_item';
+                        NotionAITool.processNestedList(child.content, childListType, allChildBlocks);
+                    }
+                }
+                // Add children to the parent block
+                if (allChildBlocks.length > 0) {
+                    listItemBlock[listType].children = allChildBlocks;
                 }
                 // Only add the block if it has text or children
                 const listData = listItemBlock[listType];
@@ -1542,17 +1757,21 @@ class NotionAITool {
             }
         }
         catch (error) {
-            console.warn('Error processing nested list:', error);
+            console.warn('Error processing nested list with child blocks:', error);
             // Fallback: create a simple text block with the content
             blocks.push({
                 type: 'paragraph',
                 paragraph: {
-                    rich_text: [{ type: 'text', text: { content: 'Error processing list content' } }],
+                    rich_text: [{ type: 'text', text: { content: 'Error processing list content with child blocks' } }],
                 },
             });
         }
     }
-    // Extract list items with proper branching structure - only process top-level <li> tags
+    // Legacy function for backward compatibility
+    static processNestedList(listContent, listType, blocks, childNodes) {
+        NotionAITool.processNestedListWithChildBlocks(listContent, listType, blocks, new Map());
+    }
+    // Extract list items with proper branching structure - simplified for hierarchical processing
     static extractListItemsWithBranching(content) {
         const items = [];
         let pos = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-notion-advanced",
-  "version": "1.2.30-beta",
+  "version": "1.2.32-beta",
   "description": "Advanced n8n Notion nodes: Full-featured workflow node + AI Agent Tool for intelligent Notion automation with 25+ block types (BETA)",
   "scripts": {},
   "files": [