fix: imageテストを修正（段落分割版）

- float center imageの行全体を削除
- アライメント付き画像で段落を分割
- インライン画像を含む段落は<p>タグ省略
- file3形式のパースを修正
- _closeSpan判定を修正

Author: r74tech

packages/parser/src/parser/rules/block/paragraph.ts

@@ -21,16 +21,15 @@ function processCloseSpanMarkers(elements: Element[]): Element[] {
     if (!elem) continue;
 
     // Check for closeSpan marker
+    // _closeSpan is on data directly, not data.attributes
     if (
       elem.element === "container" &&
       elem.data &&
       typeof elem.data === "object" &&
       "type" in elem.data &&
       elem.data.type === "span" &&
-      "attributes" in elem.data &&
-      typeof elem.data.attributes === "object" &&
-      elem.data.attributes &&
-      "_closeSpan" in elem.data.attributes
+      "_closeSpan" in elem.data &&
+      (elem.data as any)._closeSpan === true
     ) {
       // Wrap all preceding content in a span
       if (result.length > 0) {
@@ -80,6 +79,50 @@ export const paragraphRule: BlockRule = {
     // Process closeSpan markers (for split spans)
     let elements = processCloseSpanMarkers(result.elements);
 
+    // Split paragraph at aligned images (they become block-level elements)
+    // This also removes float center images (invalid in Wikidot)
+    const splitResult = splitAtAlignedImages(elements);
+    const hasAlignedImages = splitResult.some((part) => part.type === "image");
+
+    if (splitResult.length > 1 || hasAlignedImages) {
+      // Return multiple elements: paragraphs and standalone images
+      const outputElements: Element[] = [];
+      for (const part of splitResult) {
+        if (part.type === "image") {
+          outputElements.push(part.element);
+        } else if (part.elements.length > 0) {
+          // Clean up paragraph elements
+          const cleaned = cleanParagraphElements(part.elements);
+          if (cleaned.length > 0) {
+            outputElements.push({
+              element: "container",
+              data: {
+                type: "paragraph",
+                attributes: {},
+                elements: cleaned,
+              },
+            });
+          }
+        }
+      }
+      if (outputElements.length === 0) {
+        return { success: false };
+      }
+      return {
+        success: true,
+        elements: outputElements,
+        consumed: result.consumed,
+      };
+    }
+
+    // Rebuild elements from splitResult (may have float center removed)
+    elements = [];
+    for (const part of splitResult) {
+      if (part.type === "text") {
+        elements.push(...part.elements);
+      }
+    }
+
     // Remove trailing line-breaks (they shouldn't appear at end of paragraph)
     // Exception: line-breaks flagged by preserveTrailingLineBreak context are kept
     while (elements.length > 0 && elements[elements.length - 1]?.element === "line-break") {
@@ -155,3 +198,95 @@ function parseInlineContent(ctx: ParseContext): {
   // The parser will stop at double NEWLINE (paragraph break)
   return parseInlineUntil(ctx, "PARAGRAPH_BREAK" as any);
 }
+
+type SplitPart = { type: "text"; elements: Element[] } | { type: "image"; element: Element };
+
+/**
+ * Split elements at aligned images
+ * Aligned images become block-level elements, splitting the paragraph
+ * Float center images are removed entirely (invalid in Wikidot)
+ */
+function splitAtAlignedImages(elements: Element[]): SplitPart[] {
+  const parts: SplitPart[] = [];
+  let currentText: Element[] = [];
+
+  for (let i = 0; i < elements.length; i++) {
+    const elem = elements[i];
+    if (!elem) continue;
+
+    if (isAlignedImage(elem)) {
+      const imageData = (elem as any).data;
+      // Float center is invalid - skip the image AND preceding text on same line
+      if (imageData?.alignment?.float && imageData.alignment.align === "center") {
+        // Remove text preceding the image on the same line (back to last line-break)
+        while (currentText.length > 0) {
+          const last = currentText[currentText.length - 1];
+          if (last?.element === "line-break") {
+            break;
+          }
+          currentText.pop();
+        }
+        // Also skip line-break after the image if present
+        if (elements[i + 1]?.element === "line-break") {
+          i++;
+        }
+        continue;
+      }
+
+      // Save current text as a part
+      if (currentText.length > 0) {
+        parts.push({ type: "text", elements: [...currentText] });
+        currentText = [];
+      }
+      // Add image as standalone element
+      parts.push({ type: "image", element: elem });
+    } else {
+      currentText.push(elem);
+    }
+  }
+
+  // Add remaining text
+  if (currentText.length > 0) {
+    parts.push({ type: "text", elements: currentText });
+  }
+
+  return parts;
+}
+
+/**
+ * Check if element is an aligned image (has alignment property)
+ */
+function isAlignedImage(elem: Element): boolean {
+  if (elem.element !== "image") return false;
+  const data = (elem as any).data;
+  return data?.alignment != null;
+}
+
+/**
+ * Clean up paragraph elements (remove trailing/leading line-breaks)
+ */
+function cleanParagraphElements(elements: Element[]): Element[] {
+  let result = [...elements];
+
+  // Remove trailing line-breaks
+  while (result.length > 0 && result[result.length - 1]?.element === "line-break") {
+    result.pop();
+  }
+
+  // Remove trailing whitespace
+  while (result.length > 0) {
+    const last = result[result.length - 1];
+    if (last?.element === "text" && typeof last.data === "string" && last.data.trim() === "") {
+      result.pop();
+    } else {
+      break;
+    }
+  }
+
+  // Remove leading line-breaks
+  while (result.length > 0 && result[0]?.element === "line-break") {
+    result.shift();
+  }
+
+  return result;
+}

packages/parser/src/parser/rules/inline/image.ts

@@ -86,23 +86,35 @@ function parseImageSource(src: string): ImageSource {
   }
 
   // File references - determine type based on format
-  // file3: site:page/file
-  // file2: page/file
-  // file1: file
+  // file3: site:page/file or site/page/file (2+ slashes)
+  // file2: page/file (1 slash)
+  // file1: file (no slash)
   const colonIdx = src.indexOf(":");
   const slashIdx = src.indexOf("/");
 
   if (colonIdx > 0 && slashIdx > colonIdx) {
-    // site:page/file format
+    // site:page/file format (colon-based)
     const site = src.substring(0, colonIdx);
     const rest = src.substring(colonIdx + 1);
     const lastSlash = rest.lastIndexOf("/");
     const page = rest.substring(0, lastSlash);
     const file = rest.substring(lastSlash + 1);
     return { type: "file3", data: { site, page, file } };
   }
+
+  // Count slashes to determine format
+  const slashes = src.split("/").length - 1;
+  if (slashes >= 2) {
+    // site/page/file format (2+ slashes = file3)
+    const firstSlash = src.indexOf("/");
+    const lastSlash = src.lastIndexOf("/");
+    const site = src.substring(0, firstSlash);
+    const page = src.substring(firstSlash + 1, lastSlash);
+    const file = src.substring(lastSlash + 1);
+    return { type: "file3", data: { site, page, file } };
+  }
   if (slashIdx > 0) {
-    // page/file format
+    // page/file format (1 slash = file2)
     const page = src.substring(0, slashIdx);
     const file = src.substring(slashIdx + 1);
     return { type: "file2", data: { page, file } };

packages/render/src/elements/container.ts

@@ -1,9 +1,26 @@
-import type { ContainerData } from "@wdprlib/ast";
+import type { ContainerData, Element } from "@wdprlib/ast";
 import { isStringContainerType, isHeaderType, isAlignType } from "@wdprlib/ast";
 import type { RenderContext } from "../context";
 import { escapeAttr, sanitizeAttributes } from "../escape";
 import { renderElements } from "../render";
 
+/**
+ * Check if elements contain an inline image (image without alignment)
+ * Wikidot skips <p> tags for paragraphs containing inline images
+ */
+function hasInlineImage(elements: Element[]): boolean {
+  for (const elem of elements) {
+    if (elem.element === "image") {
+      const data = (elem as any).data;
+      // Inline image = no alignment (alignment is null or undefined)
+      if (data?.alignment == null) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 /** Render a container element */
 export function renderContainer(ctx: RenderContext, data: ContainerData): void {
   const { type, attributes, elements } = data;
@@ -53,9 +70,14 @@ function renderStringContainer(
 ): void {
   switch (type) {
     case "paragraph":
-      ctx.push(`<p${renderAttrs(attributes)}>`);
-      renderElements(ctx, elements);
-      ctx.push("</p>");
+      // Wikidot: paragraphs containing inline images (no alignment) skip <p> tags
+      if (hasInlineImage(elements)) {
+        renderElements(ctx, elements);
+      } else {
+        ctx.push(`<p${renderAttrs(attributes)}>`);
+        renderElements(ctx, elements);
+        ctx.push("</p>");
+      }
       break;
     case "bold":
       ctx.push(`<strong${renderAttrs(attributes)}>`);