@marvalt/wparser 0.1.6 → 0.1.7

package/dist/index.d.ts

@@ -47,6 +47,46 @@ interface ComponentRegistry {
     /** Fallback renderer for unknown blocks */
     fallback: BlockRenderer;
 }
+/**
+ * Pattern matching for blocks - allows matching blocks by name and attributes
+ */
+interface BlockPattern {
+    /** Block name (e.g., 'core/cover', 'core/media-text') */
+    name: string;
+    /** Optional attribute matching - all specified attributes must match */
+    attributes?: Record<string, any>;
+    /** Optional nested block patterns for innerBlocks */
+    innerBlocks?: BlockPattern[];
+}
+/**
+ * Component mapping configuration for enhanced registry
+ * Maps block patterns to React components with prop extraction
+ */
+interface ComponentMapping<TProps = any> {
+    /** Pattern to match against blocks */
+    pattern: BlockPattern;
+    /** React component to render when pattern matches */
+    component: React.ComponentType<TProps>;
+    /** Function to extract props from block data */
+    extractProps: (block: WordPressBlock, context: RenderContext) => TProps;
+    /** Optional wrapper component (e.g., for section spacing) */
+    wrapper?: React.ComponentType<{
+        children: React.ReactNode;
+        block?: WordPressBlock;
+    }>;
+    /** Priority for matching (higher = more specific, checked first) */
+    priority?: number;
+}
+/**
+ * Enhanced registry that supports pattern-based component mapping
+ * Extends the base ComponentRegistry with pattern matching capabilities
+ */
+interface EnhancedRegistry extends ComponentRegistry {
+    /** Array of component mappings with patterns */
+    mappings: ComponentMapping[];
+    /** Find matching component mapping for a block */
+    matchBlock: (block: WordPressBlock) => ComponentMapping | null;
+}
 
 type WPNode = WordPressBlock;
 interface ParseOptions {
@@ -60,6 +100,36 @@ declare function renderNodes(blocks: WordPressBlock[], registry: ComponentRegist
 
 declare function createDefaultRegistry(): ComponentRegistry;
 
+/**
+ * Create an enhanced registry that supports pattern-based component mapping
+ *
+ * This combines the default registry (for fallback) with app-specific component mappings.
+ * When a block matches a pattern, it uses the mapped component. Otherwise, it falls back
+ * to the default renderer.
+ *
+ * @param mappings - Array of component mappings with patterns
+ * @param baseRegistry - Optional base registry (defaults to createDefaultRegistry())
+ * @returns Enhanced registry with pattern matching capabilities
+ *
+ * @example
+ * ```ts
+ * const mappings: ComponentMapping[] = [
+ *   {
+ *     pattern: { name: 'core/cover' },
+ *     component: HomeHeroSection,
+ *     extractProps: (block) => ({
+ *       backgroundImage: extractBackgroundImage(block),
+ *       title: extractTitle(block),
+ *     }),
+ *     wrapper: SectionWrapper,
+ *   },
+ * ];
+ *
+ * const registry = createEnhancedRegistry(mappings);
+ * ```
+ */
+declare function createEnhancedRegistry(mappings?: ComponentMapping[], baseRegistry?: ComponentRegistry): EnhancedRegistry;
+
 interface WPContentProps {
     blocks: WordPressBlock[];
     registry: ComponentRegistry;
@@ -202,5 +272,141 @@ declare const isCloudflareImageUrl: (url: string | undefined | null) => boolean;
  */
 declare const getCloudflareVariantUrl: (url: string, options: CloudflareVariantOptions) => string;
 
-export { WPContent, WPErrorBoundary, WPPage, buildClassName, createDefaultRegistry, extractTextFromHTML, findShortcodes, getAlignmentClasses, getBlockTextContent, getCloudflareVariantUrl, getContainerClasses, getContentSpacingClasses, getFontSizeClasses, getImageAttributes, getImageUrl, getSectionSpacingClasses, getTextAlignClasses, isCloudflareImageUrl, parseGutenbergBlocks, parseShortcodeAttrs, renderNodes, renderTextWithShortcodes };
-export type { AuthMode, BlockRenderer, BlockRendererProps, CloudflareVariantOptions, ComponentRegistry, ParseOptions, ParsedShortcode, RenderContext, RenderOptions, ShortcodeAttributes, ShortcodeRenderer, WPContentProps, WPNode, WPPageProps, WordPressBlock, WordPressEmbedded, WordPressFeaturedMedia, WordPressPageMinimal, WordPressTitleField };
+/**
+ * Check if a block matches a pattern
+ */
+declare function matchesPattern(block: WordPressBlock, pattern: BlockPattern): boolean;
+/**
+ * Find the best matching component mapping for a block
+ * Returns the mapping with highest priority that matches, or null
+ */
+declare function findMatchingMapping(block: WordPressBlock, mappings: ComponentMapping[]): ComponentMapping | null;
+
+/**
+ * Extract background image URL from a block
+ * Checks various possible sources: url, backgroundImage, innerHTML
+ */
+declare function extractBackgroundImage(block: WordPressBlock): string | null;
+/**
+ * Extract image URL from a block
+ * Returns Cloudflare URL if available, otherwise WordPress URL
+ */
+declare function extractImageUrl(block: WordPressBlock): string | null;
+/**
+ * Extract image attributes (url, alt, width, height)
+ */
+declare function extractImageAttributes(block: WordPressBlock): {
+    url: string | null;
+    alt: string;
+    width?: number;
+    height?: number;
+};
+/**
+ * Extract title/heading text from a block
+ */
+declare function extractTitle(block: WordPressBlock): string | null;
+/**
+ * Extract content/text from a block
+ * Returns React node for rendering
+ */
+declare function extractContent(block: WordPressBlock, context: RenderContext): React$1.ReactNode;
+/**
+ * Extract media position from media-text block
+ */
+declare function extractMediaPosition(block: WordPressBlock): 'left' | 'right';
+/**
+ * Extract vertical alignment from block
+ */
+declare function extractVerticalAlignment(block: WordPressBlock): 'top' | 'center' | 'bottom';
+/**
+ * Extract alignment (full, wide, contained) from block
+ */
+declare function extractAlignment(block: WordPressBlock): 'full' | 'wide' | 'contained';
+/**
+ * Extract overlay color from cover block
+ */
+declare function extractOverlayColor(block: WordPressBlock): string | null;
+/**
+ * Extract dim ratio (overlay opacity) from cover block
+ */
+declare function extractDimRatio(block: WordPressBlock): number;
+/**
+ * Extract min height from block
+ */
+declare function extractMinHeight(block: WordPressBlock): {
+    value: number;
+    unit: string;
+} | null;
+/**
+ * Extract heading level from heading block
+ */
+declare function extractHeadingLevel(block: WordPressBlock): number;
+/**
+ * Extract text alignment from block
+ */
+declare function extractTextAlign(block: WordPressBlock): 'left' | 'center' | 'right' | null;
+/**
+ * Extract font size from block
+ */
+declare function extractFontSize(block: WordPressBlock): string | null;
+/**
+ * Convert image URL to Cloudflare variant if it's a Cloudflare URL
+ */
+declare function convertImageToCloudflareVariant(url: string | null, options?: {
+    width?: number;
+    height?: number;
+}): string | null;
+
+interface ImageConversionOptions {
+    /** Convert to Cloudflare variant if URL is already Cloudflare */
+    convertToCloudflare?: boolean;
+    /** Default width for Cloudflare variant */
+    defaultWidth?: number;
+    /** Default height for Cloudflare variant */
+    defaultHeight?: number;
+    /** Force conversion even if URL is not Cloudflare (not recommended) */
+    forceCloudflare?: boolean;
+}
+/**
+ * Convert image URL with optional Cloudflare variant transformation
+ *
+ * @param url - Image URL (WordPress or Cloudflare)
+ * @param options - Conversion options
+ * @returns Converted URL or original if conversion not applicable
+ */
+declare function convertImageUrl(url: string | null | undefined, options?: ImageConversionOptions): string | null;
+/**
+ * Batch convert multiple image URLs
+ */
+declare function convertImageUrls(urls: (string | null | undefined)[], options?: ImageConversionOptions): (string | null)[];
+
+interface SectionWrapperProps {
+    children: React$1.ReactNode;
+    /** Background color variant */
+    background?: 'light' | 'dark' | 'transparent';
+    /** Vertical spacing between sections */
+    spacing?: 'none' | 'small' | 'medium' | 'large';
+    /** Container width */
+    container?: 'full' | 'wide' | 'contained';
+    /** Additional CSS classes */
+    className?: string;
+    /** Optional block reference for extracting additional props */
+    block?: WordPressBlock;
+}
+/**
+ * Generic section wrapper component for consistent spacing and layout
+ *
+ * Usage in component mappings:
+ * ```ts
+ * {
+ *   pattern: { name: 'core/cover' },
+ *   component: HeroSection,
+ *   wrapper: SectionWrapper,
+ *   extractProps: (block) => ({ ... })
+ * }
+ * ```
+ */
+declare const SectionWrapper: React$1.FC<SectionWrapperProps>;
+
+export { SectionWrapper, WPContent, WPErrorBoundary, WPPage, buildClassName, convertImageToCloudflareVariant, convertImageUrl, convertImageUrls, createDefaultRegistry, createEnhancedRegistry, extractAlignment, extractBackgroundImage, extractContent, extractDimRatio, extractFontSize, extractHeadingLevel, extractImageAttributes, extractImageUrl, extractMediaPosition, extractMinHeight, extractOverlayColor, extractTextAlign, extractTextFromHTML, extractTitle, extractVerticalAlignment, findMatchingMapping, findShortcodes, getAlignmentClasses, getBlockTextContent, getCloudflareVariantUrl, getContainerClasses, getContentSpacingClasses, getFontSizeClasses, getImageAttributes, getImageUrl, getSectionSpacingClasses, getTextAlignClasses, isCloudflareImageUrl, matchesPattern, parseGutenbergBlocks, parseShortcodeAttrs, renderNodes, renderTextWithShortcodes };
+export type { AuthMode, BlockPattern, BlockRenderer, BlockRendererProps, CloudflareVariantOptions, ComponentMapping, ComponentRegistry, EnhancedRegistry, ImageConversionOptions, ParseOptions, ParsedShortcode, RenderContext, RenderOptions, SectionWrapperProps, ShortcodeAttributes, ShortcodeRenderer, WPContentProps, WPNode, WPPageProps, WordPressBlock, WordPressEmbedded, WordPressFeaturedMedia, WordPressPageMinimal, WordPressTitleField };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC"}

package/dist/index.esm.js

@@ -1931,6 +1931,138 @@ function getString(block) {
     return getBlockTextContent(block);
 }
 
+/**
+ * Check if a block matches a pattern
+ */
+function matchesPattern(block, pattern) {
+    // Check block name
+    if (block.name !== pattern.name) {
+        return false;
+    }
+    // Check attributes if specified
+    if (pattern.attributes) {
+        const blockAttrs = block.attributes || {};
+        for (const [key, value] of Object.entries(pattern.attributes)) {
+            if (blockAttrs[key] !== value) {
+                return false;
+            }
+        }
+    }
+    // Check innerBlocks patterns if specified
+    if (pattern.innerBlocks && pattern.innerBlocks.length > 0) {
+        const blockInnerBlocks = block.innerBlocks || [];
+        // If pattern specifies innerBlocks, check if block has matching innerBlocks
+        for (const innerPattern of pattern.innerBlocks) {
+            // Find at least one matching innerBlock
+            const hasMatch = blockInnerBlocks.some(innerBlock => matchesPattern(innerBlock, innerPattern));
+            if (!hasMatch) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Find the best matching component mapping for a block
+ * Returns the mapping with highest priority that matches, or null
+ */
+function findMatchingMapping(block, mappings) {
+    // Sort by priority (higher first), then by order in array
+    const sortedMappings = [...mappings].sort((a, b) => {
+        const priorityA = a.priority ?? 0;
+        const priorityB = b.priority ?? 0;
+        if (priorityA !== priorityB) {
+            return priorityB - priorityA; // Higher priority first
+        }
+        return 0; // Keep original order for same priority
+    });
+    // Find first matching mapping
+    for (const mapping of sortedMappings) {
+        if (matchesPattern(block, mapping.pattern)) {
+            return mapping;
+        }
+    }
+    return null;
+}
+
+/**
+ * Create an enhanced registry that supports pattern-based component mapping
+ *
+ * This combines the default registry (for fallback) with app-specific component mappings.
+ * When a block matches a pattern, it uses the mapped component. Otherwise, it falls back
+ * to the default renderer.
+ *
+ * @param mappings - Array of component mappings with patterns
+ * @param baseRegistry - Optional base registry (defaults to createDefaultRegistry())
+ * @returns Enhanced registry with pattern matching capabilities
+ *
+ * @example
+ * ```ts
+ * const mappings: ComponentMapping[] = [
+ *   {
+ *     pattern: { name: 'core/cover' },
+ *     component: HomeHeroSection,
+ *     extractProps: (block) => ({
+ *       backgroundImage: extractBackgroundImage(block),
+ *       title: extractTitle(block),
+ *     }),
+ *     wrapper: SectionWrapper,
+ *   },
+ * ];
+ *
+ * const registry = createEnhancedRegistry(mappings);
+ * ```
+ */
+function createEnhancedRegistry(mappings = [], baseRegistry) {
+    const base = baseRegistry || createDefaultRegistry();
+    // Create enhanced renderers that check patterns first
+    const enhancedRenderers = {
+        ...base.renderers,
+    };
+    // Override renderers for blocks that have mappings
+    // We need to check patterns at render time, so we create a wrapper renderer
+    const createPatternRenderer = (blockName) => {
+        return (props) => {
+            const { block, context } = props;
+            // Find matching mapping
+            const mapping = findMatchingMapping(block, mappings);
+            if (mapping) {
+                // Extract props from block
+                const componentProps = mapping.extractProps(block, context);
+                // Render component
+                const Component = mapping.component;
+                const content = jsxRuntimeExports.jsx(Component, { ...componentProps });
+                // Wrap with wrapper if provided
+                if (mapping.wrapper) {
+                    const Wrapper = mapping.wrapper;
+                    return jsxRuntimeExports.jsx(Wrapper, { block: block, children: content });
+                }
+                return content;
+            }
+            // Fall back to default renderer
+            const defaultRenderer = base.renderers[blockName] || base.fallback;
+            return defaultRenderer(props);
+        };
+    };
+    // For each mapping, override the renderer for that block name
+    for (const mapping of mappings) {
+        const blockName = mapping.pattern.name;
+        if (blockName) {
+            enhancedRenderers[blockName] = createPatternRenderer(blockName);
+        }
+    }
+    // Create matchBlock function
+    const matchBlock = (block) => {
+        return findMatchingMapping(block, mappings);
+    };
+    return {
+        ...base,
+        renderers: enhancedRenderers,
+        mappings,
+        matchBlock,
+    };
+}
+
 const WPContent = ({ blocks, registry, className }) => {
     if (!Array.isArray(blocks)) {
         if (process.env.NODE_ENV !== 'production') {
@@ -2011,5 +2143,252 @@ class WPErrorBoundary extends React.Component {
     }
 }
 
-export { WPContent, WPErrorBoundary, WPPage, buildClassName, createDefaultRegistry, extractTextFromHTML, findShortcodes, getAlignmentClasses, getBlockTextContent, getCloudflareVariantUrl, getContainerClasses, getContentSpacingClasses, getFontSizeClasses, getImageAttributes, getImageUrl, getSectionSpacingClasses, getTextAlignClasses, isCloudflareImageUrl, parseGutenbergBlocks, parseShortcodeAttrs, renderNodes, renderTextWithShortcodes };
+/**
+ * Extract background image URL from a block
+ * Checks various possible sources: url, backgroundImage, innerHTML
+ */
+function extractBackgroundImage(block) {
+    const attrs = block.attributes || {};
+    // Try various attribute keys
+    let url = attrs['url'] ||
+        attrs['backgroundImage'] ||
+        (typeof attrs['backgroundImage'] === 'object' && attrs['backgroundImage']?.url);
+    if (typeof url === 'string' && url.trim()) {
+        return url.trim();
+    }
+    // Try to extract from innerHTML if not found in attributes
+    if (block.innerHTML) {
+        // Try img src from innerHTML
+        const imgMatch = block.innerHTML.match(/<img[^>]+src=["']([^"']+)["']/i);
+        if (imgMatch && imgMatch[1]) {
+            return imgMatch[1];
+        }
+        // Try background-image in style attribute
+        const bgMatch = block.innerHTML.match(/background-image:\s*url\(["']?([^"')]+)["']?\)/i);
+        if (bgMatch && bgMatch[1]) {
+            return bgMatch[1];
+        }
+    }
+    return null;
+}
+/**
+ * Extract image URL from a block
+ * Returns Cloudflare URL if available, otherwise WordPress URL
+ */
+function extractImageUrl(block) {
+    return getImageUrl(block);
+}
+/**
+ * Extract image attributes (url, alt, width, height)
+ */
+function extractImageAttributes(block) {
+    return getImageAttributes(block);
+}
+/**
+ * Extract title/heading text from a block
+ */
+function extractTitle(block) {
+    const attrs = block.attributes || {};
+    const title = attrs['title'] || attrs['content'] || getBlockTextContent(block);
+    return typeof title === 'string' ? title.trim() : null;
+}
+/**
+ * Extract content/text from a block
+ * Returns React node for rendering
+ */
+function extractContent(block, context) {
+    const text = getBlockTextContent(block);
+    return text || null;
+}
+/**
+ * Extract media position from media-text block
+ */
+function extractMediaPosition(block) {
+    const attrs = block.attributes || {};
+    const position = attrs['mediaPosition'] || 'left';
+    return position === 'right' ? 'right' : 'left';
+}
+/**
+ * Extract vertical alignment from block
+ */
+function extractVerticalAlignment(block) {
+    const attrs = block.attributes || {};
+    const alignment = attrs['verticalAlignment'] || 'center';
+    if (alignment === 'top' || alignment === 'bottom') {
+        return alignment;
+    }
+    return 'center';
+}
+/**
+ * Extract alignment (full, wide, contained) from block
+ */
+function extractAlignment(block) {
+    const attrs = block.attributes || {};
+    const align = attrs['align'];
+    if (align === 'full' || align === 'wide') {
+        return align;
+    }
+    return 'contained';
+}
+/**
+ * Extract overlay color from cover block
+ */
+function extractOverlayColor(block) {
+    const attrs = block.attributes || {};
+    const overlayColor = attrs['overlayColor'];
+    if (typeof overlayColor === 'string') {
+        return overlayColor;
+    }
+    return null;
+}
+/**
+ * Extract dim ratio (overlay opacity) from cover block
+ */
+function extractDimRatio(block) {
+    const attrs = block.attributes || {};
+    const dimRatio = attrs['dimRatio'];
+    if (typeof dimRatio === 'number') {
+        return dimRatio;
+    }
+    return 0;
+}
+/**
+ * Extract min height from block
+ */
+function extractMinHeight(block) {
+    const attrs = block.attributes || {};
+    const minHeight = attrs['minHeight'];
+    const minHeightUnit = attrs['minHeightUnit'] || 'vh';
+    if (typeof minHeight === 'number') {
+        return { value: minHeight, unit: minHeightUnit };
+    }
+    return null;
+}
+/**
+ * Extract heading level from heading block
+ */
+function extractHeadingLevel(block) {
+    const attrs = block.attributes || {};
+    const level = attrs['level'];
+    if (typeof level === 'number' && level >= 1 && level <= 6) {
+        return level;
+    }
+    return 2; // Default to h2
+}
+/**
+ * Extract text alignment from block
+ */
+function extractTextAlign(block) {
+    const attrs = block.attributes || {};
+    const align = attrs['align'] || attrs['textAlign'];
+    if (align === 'left' || align === 'center' || align === 'right') {
+        return align;
+    }
+    return null;
+}
+/**
+ * Extract font size from block
+ */
+function extractFontSize(block) {
+    const attrs = block.attributes || {};
+    const fontSize = attrs['fontSize'];
+    return typeof fontSize === 'string' ? fontSize : null;
+}
+/**
+ * Convert image URL to Cloudflare variant if it's a Cloudflare URL
+ */
+function convertImageToCloudflareVariant(url, options = {}) {
+    if (!url)
+        return null;
+    if (isCloudflareImageUrl(url)) {
+        const width = options.width || 1024;
+        const height = options.height;
+        return getCloudflareVariantUrl(url, { width, height });
+    }
+    return url;
+}
+
+/**
+ * Convert image URL with optional Cloudflare variant transformation
+ *
+ * @param url - Image URL (WordPress or Cloudflare)
+ * @param options - Conversion options
+ * @returns Converted URL or original if conversion not applicable
+ */
+function convertImageUrl(url, options = {}) {
+    if (!url)
+        return null;
+    const { convertToCloudflare = true, defaultWidth = 1024, defaultHeight, forceCloudflare = false, } = options;
+    // If already Cloudflare URL and conversion is enabled
+    if (isCloudflareImageUrl(url)) {
+        if (convertToCloudflare) {
+            return getCloudflareVariantUrl(url, {
+                width: defaultWidth,
+                height: defaultHeight,
+            });
+        }
+        return url;
+    }
+    // If force conversion is enabled (not recommended - requires WordPress plugin to provide Cloudflare URLs)
+    if (forceCloudflare) {
+        // This would require additional logic to map WordPress URLs to Cloudflare URLs
+        // which should be handled by the WordPress plugin providing Cloudflare URLs in block data
+        console.warn('forceCloudflare is enabled but URL is not Cloudflare. WordPress plugin should provide Cloudflare URLs in block metadata.');
+    }
+    // Return original URL if not Cloudflare
+    return url;
+}
+/**
+ * Batch convert multiple image URLs
+ */
+function convertImageUrls(urls, options = {}) {
+    return urls.map(url => convertImageUrl(url, options));
+}
+
+/**
+ * Generic section wrapper component for consistent spacing and layout
+ *
+ * Usage in component mappings:
+ * ```ts
+ * {
+ *   pattern: { name: 'core/cover' },
+ *   component: HeroSection,
+ *   wrapper: SectionWrapper,
+ *   extractProps: (block) => ({ ... })
+ * }
+ * ```
+ */
+const SectionWrapper = ({ children, background = 'light', spacing = 'medium', container = 'contained', className, block, }) => {
+    // Background classes
+    const backgroundClasses = {
+        light: 'bg-white',
+        dark: 'bg-gray-900 text-white',
+        transparent: 'bg-transparent',
+    };
+    // Spacing classes (vertical padding)
+    const spacingClasses = {
+        none: '',
+        small: 'py-8 md:py-12',
+        medium: 'py-16 md:py-24',
+        large: 'py-24 md:py-32',
+    };
+    // Container classes
+    const containerClasses = {
+        full: 'w-full',
+        wide: 'max-w-7xl mx-auto px-4',
+        contained: 'container mx-auto px-4',
+    };
+    // Extract additional props from block if provided
+    const blockAttrs = block?.attributes || {};
+    const blockBackground = blockAttrs['backgroundColor'] || blockAttrs['background'];
+    const blockSpacing = blockAttrs['spacing'];
+    const blockContainer = blockAttrs['container'] || blockAttrs['align'];
+    // Override with block attributes if present
+    const finalBackground = blockBackground || background;
+    const finalSpacing = blockSpacing || spacing;
+    const finalContainer = blockContainer || container;
+    return (jsxRuntimeExports.jsx("section", { className: buildClassName(backgroundClasses[finalBackground] || backgroundClasses.light, spacingClasses[finalSpacing] || spacingClasses.medium, containerClasses[finalContainer] || containerClasses.contained, className), children: children }));
+};
+
+export { SectionWrapper, WPContent, WPErrorBoundary, WPPage, buildClassName, convertImageToCloudflareVariant, convertImageUrl, convertImageUrls, createDefaultRegistry, createEnhancedRegistry, extractAlignment, extractBackgroundImage, extractContent, extractDimRatio, extractFontSize, extractHeadingLevel, extractImageAttributes, extractImageUrl, extractMediaPosition, extractMinHeight, extractOverlayColor, extractTextAlign, extractTextFromHTML, extractTitle, extractVerticalAlignment, findMatchingMapping, findShortcodes, getAlignmentClasses, getBlockTextContent, getCloudflareVariantUrl, getContainerClasses, getContentSpacingClasses, getFontSizeClasses, getImageAttributes, getImageUrl, getSectionSpacingClasses, getTextAlignClasses, isCloudflareImageUrl, matchesPattern, parseGutenbergBlocks, parseShortcodeAttrs, renderNodes, renderTextWithShortcodes };
 //# sourceMappingURL=index.esm.js.map