@ssobig/writer-cli 0.2.2 → 0.3.2

package/templates/mystery-v1/component-navigation-counts.js

@@ -10,11 +10,8 @@
   }
 
   function commonCount(data) {
-    const sections = data?.sections && typeof data.sections === "object" ? data.sections : {};
-    const deleted = new Set(Array.isArray(data?.deletedBaseSections) ? data.deletedBaseSections : []);
-    const customIds = new Set((Array.isArray(data?.customSections) ? data.customSections : []).map(item => item?.id).filter(Boolean));
-    return (Array.isArray(data?.sectionOrder) ? data.sectionOrder : [])
-      .filter(id => !deleted.has(id) && (Object.hasOwn(sections, id) || customIds.has(id))).length;
+    const deleted = new Set(Array.isArray(data?.deletedDocumentIds) ? data.deletedDocumentIds : []);
+    return (Array.isArray(data?.documents) ? data.documents : []).filter(document => !deleted.has(document?.id)).length;
   }
 
   function characterCount(data) {
@@ -24,6 +21,11 @@
       .filter(id => !deleted.has(id) && Object.hasOwn(characters, id)).length;
   }
 
+  // v2는 항목이, legacy는 사건이 세는 단위다.
+  function timelineCount(data) {
+    return Array.isArray(data?.entries) ? data.entries.length : listLength(data?.events);
+  }
+
   function endingCount(data) {
     const conditions = Array.isArray(data?.conditions) ? data.conditions : [];
     const outcomes = Array.isArray(data?.outcomes) ? data.outcomes : [];
@@ -38,16 +40,14 @@
   function componentItemCount(instance, data = instance?.data) {
     switch (String(instance?.templateId || "")) {
       case "ssobig.progress": return listLength(data?.steps);
-      case "ssobig.common":
-      case "ssobig.choice": return commonCount(data);
+      case "ssobig.common": return commonCount(data);
       case "ssobig.character": return characterCount(data);
       case "ssobig.clues": return listLength(data?.clues);
       case "ssobig.clue-combinations": return listLength(data?.combinations);
       case "ssobig.ai-response": return listLength(data?.responses);
-      case "ssobig.timeline": return listLength(data?.events);
+      case "ssobig.timeline": return timelineCount(data);
       case "ssobig.investigation-board": return listLength(data?.nodes);
       case "ssobig.ending": return endingCount(data);
-      case "ssobig.postgame": return listLength(data?.truth) + listLength(data?.epilogue);
       case "ssobig.author-notes": return listLength(data?.notes);
       case "ssobig.documents": return listLength(data?.blocks);
       default: return 0;

package/templates/mystery-v1/component-registry.js

@@ -48,8 +48,7 @@
     { key: "image", label: "이미지", description: "단서 이미지 등록과 미리보기" },
     { key: "location", label: "위치", description: "단서를 발견하거나 사용하는 위치" },
     { key: "tags", label: "태그", description: "단서 분류와 미리보기 필터" },
-    { key: "color", label: "컬러", description: "단서 분류용 대표 색상" },
-    { key: "secret", label: "작가 노트", description: "제작자만 확인하는 단서 메모" }
+    { key: "color", label: "컬러", description: "단서 분류용 대표 색상" }
   ]);
 
   const BASIC_FIELD_CONFIGURATION = deepFreeze([
@@ -73,8 +72,7 @@
     { key: "containers", label: "원고 Container", required: true, description: "캐릭터 기본정보와 원고 section의 묶음·순서" },
     { key: "image", label: "캐릭터 이미지", required: true, description: "캐릭터 이미지 등록과 미리보기" },
     { key: "color", label: "컬러", required: true, description: "캐릭터 카드의 대표 색상" },
-    { key: "tag", label: "태그", required: true, description: "캐릭터의 역할과 분류 태그" },
-    { key: "authorNote", label: "작가 노트", description: "연기 방향과 설계 의도 메모" }
+    { key: "tag", label: "태그", required: true, description: "캐릭터의 역할과 분류 태그" }
   ]);
 
   function template(input) {
@@ -113,7 +111,7 @@
 
   const INITIAL_TEMPLATE_CATALOG = deepFreeze(catalogContract.list().map(descriptor => template({
     templateId: descriptor.templateId,
-    name: descriptor.tabLabel,
+    name: descriptor.displayLabel,
     required: descriptor.required,
     internal: descriptor.internal,
     allowMultiple: descriptor.allowMultiple,
@@ -186,12 +184,20 @@
       return selected.allowMultiple || !instances.some(instance => instance?.templateId === selected.templateId);
     }
 
+    function displayLabelFor(instance, defaultLabel = "") {
+      const selected = get(instance?.templateId);
+      const instanceLabel = String(instance?.tab || "").trim();
+      if (selected?.allowMultiple && instanceLabel) return instanceLabel;
+      return String(selected?.name || instanceLabel || defaultLabel || instance?.instanceId || instance?.templateId || "");
+    }
+
     initialTemplates.forEach(item => register(item));
     return Object.freeze({
       register,
       get,
       has: id => Boolean(get(id)),
       canInstantiate,
+      displayLabelFor,
       list: () => [...templates.values()].sort((left, right) => left.templateId.localeCompare(right.templateId))
     });
   }

package/templates/mystery-v1/component-renderers.js

@@ -10,7 +10,6 @@
     aiResponse: root.WriterWorkbenchAiResponseRenderer,
     timeline: root.WriterWorkbenchTimelineRenderer,
     ending: root.WriterWorkbenchEndingRenderer,
-    postgame: root.WriterWorkbenchPostgameRenderer,
     authorNotes: root.WriterWorkbenchAuthorNotesRenderer,
     investigationBoard: root.WriterWorkbenchInvestigationBoardRenderer,
     documents: root.WriterWorkbenchDocumentRenderers
@@ -26,7 +25,6 @@
     aiResponse: require("./renderers/ai-response.js"),
     timeline: require("./renderers/timeline.js"),
     ending: require("./renderers/ending.js"),
-    postgame: require("./renderers/postgame.js"),
     authorNotes: require("./renderers/author-notes.js"),
     investigationBoard: require("./renderers/investigation-board.js"),
     documents: require("./renderers/documents.js")
@@ -36,8 +34,8 @@
   if (root) root.WriterWorkbenchComponentRenderers = api;
 })(typeof globalThis !== "undefined" ? globalThis : this, function (dependencies) {
   "use strict";
-  const { appearance, shared, basic, common, character, clues, clueCombinations, aiResponse, timeline, ending, postgame, authorNotes, investigationBoard, documents } = dependencies;
-  if (!appearance || !shared || !basic || !common || !character || !clues || !clueCombinations || !aiResponse || !timeline || !ending || !postgame || !authorNotes || !investigationBoard || !documents) throw new Error("Component renderer modules are incomplete");
+  const { appearance, shared, basic, common, character, clues, clueCombinations, aiResponse, timeline, ending, authorNotes, investigationBoard, documents } = dependencies;
+  if (!appearance || !shared || !basic || !common || !character || !clues || !clueCombinations || !aiResponse || !timeline || !ending || !authorNotes || !investigationBoard || !documents) throw new Error("Component renderer modules are incomplete");
 
   const renderers = new Map();
   function register(renderer) {
@@ -45,9 +43,10 @@
     if (renderers.has(key)) throw new Error(`중복 Component 렌더러입니다: ${key}`);
     renderers.set(key, Object.freeze({ ...renderer }));
   }
-  [basic, common, { ...common, templateId: "ssobig.choice" }, character, clues, clueCombinations, aiResponse, timeline, ending, postgame, authorNotes, investigationBoard].forEach(register);
+  [basic, common, character, clues, clueCombinations, aiResponse, timeline, ending, authorNotes, investigationBoard].forEach(register);
   Object.entries(documents.definitions).forEach(([templateId, definition]) => register({
     templateId,
+    unifiedAuthoring: definition.unifiedAuthoring === true,
     renderAuthoring: documents.renderAuthoring,
     renderPreview: documents.renderPreview,
     bind: documents.bind
@@ -71,6 +70,8 @@
     return renderer;
   }
   function defaultView() { return "preview"; }
+  function usesUnifiedAuthoring(instance) { return resolve(instance).unifiedAuthoring === true; }
+  function usesUnifiedAuthoringView(viewModel) { return resolveView(viewModel).unifiedAuthoring === true; }
   function context(instance, data, extra = {}) {
     return { instance, data, ...extra, view: shared.rendererView(extra, defaultView(instance)) };
   }
@@ -90,8 +91,9 @@
       .replace(/data-renderer-view="(?:input|preview)"/, `data-renderer-view="${view}"`);
   }
   function renderAuthoring(instance, data, extra) {
-    const rendererContext = context(instance, data, extra);
-    return applyRendererView(resolve(instance).renderAuthoring(rendererContext), rendererContext.view);
+    const renderer = resolve(instance);
+    const rendererContext = context(instance, data, renderer.unifiedAuthoring === true ? { ...extra, view: "preview" } : extra);
+    return applyRendererView(renderer.renderAuthoring(rendererContext), rendererContext.view);
   }
   function renderPreview(instance, data = instance?.data, extra) { return resolve(instance).renderPreview(context(instance, data, extra)); }
   function bind(instance, root, data, extra) {
@@ -102,7 +104,7 @@
   }
   function renderAuthoringView(viewModel, extra) {
     const renderer = resolveView(viewModel);
-    const rendererContext = viewContext(viewModel, extra);
+    const rendererContext = viewContext(viewModel, renderer.unifiedAuthoring === true ? { ...extra, view: "preview" } : extra);
     return applyRendererView(renderer.renderAuthoring(rendererContext), rendererContext.view);
   }
   function renderPreviewView(viewModel, extra) {
@@ -119,6 +121,8 @@
     resolve,
     resolveView,
     defaultView,
+    usesUnifiedAuthoring,
+    usesUnifiedAuthoringView,
     renderAuthoring,
     renderPreview,
     bind,

package/templates/mystery-v1/component-storage-contract.js

@@ -123,20 +123,39 @@
       || (component.internal && instance.config?.hidden !== true ? "에셋 Component는 내부 전용으로 숨김 처리되어야 합니다." : null);
   }
 
+  function legacyTimelineError(timeline, characterIds) {
+    for (const event of timeline.data.events) {
+      const missing = Object.keys(event.memories).find(id => !characterIds.has(id));
+      if (missing) return `${timeline.instanceId} timeline memory가 존재하지 않는 character(${missing})를 가리킵니다.`;
+      const unassigned = Object.keys(event.unassignedMemories || {});
+      const assigned = unassigned.find(id => characterIds.has(id));
+      if (assigned) return `${timeline.instanceId} unassigned memory(${assigned})는 현재 character에 연결할 수 있습니다.`;
+      const overlap = unassigned.find(id => Object.hasOwn(event.memories, id));
+      if (overlap) return `${timeline.instanceId} memory(${overlap})가 assigned와 unassigned에 중복 저장되어 있습니다.`;
+    }
+    return null;
+  }
+
+  function timelineLaneCharacterError(timeline, characterIds) {
+    for (const entry of timeline.data.entries) {
+      if (entry.lane.kind === "character" && !characterIds.has(entry.lane.characterId)) {
+        return `${timeline.instanceId} timeline 항목이 존재하지 않는 character(${entry.lane.characterId})를 가리킵니다.`;
+      }
+    }
+    return null;
+  }
+
   function compositionRelationError(instances) {
     const character = instances.find(instance => instance.templateId === "ssobig.character");
     if (character) {
       const characterIds = new Set(Object.keys(character.data.characters || {}));
+      // 타임라인의 모양 배타, 시간 레벨 참조, lane/when 종류별 규칙은 validateComponentData가 이미 검증한다.
+      // 여기서는 다른 Component를 봐야 판정할 수 있는 character 참조만 확인한다.
       for (const timeline of instances.filter(instance => instance.templateId === "ssobig.timeline")) {
-        for (const event of timeline.data.events) {
-          const missing = Object.keys(event.memories).find(id => !characterIds.has(id));
-          if (missing) return `${timeline.instanceId} timeline memory가 존재하지 않는 character(${missing})를 가리킵니다.`;
-          const unassigned = Object.keys(event.unassignedMemories || {});
-          const assigned = unassigned.find(id => characterIds.has(id));
-          if (assigned) return `${timeline.instanceId} unassigned memory(${assigned})는 현재 character에 연결할 수 있습니다.`;
-          const overlap = unassigned.find(id => Object.hasOwn(event.memories, id));
-          if (overlap) return `${timeline.instanceId} memory(${overlap})가 assigned와 unassigned에 중복 저장되어 있습니다.`;
-        }
+        const invalid = Array.isArray(timeline.data.events)
+          ? legacyTimelineError(timeline, characterIds)
+          : timelineLaneCharacterError(timeline, characterIds);
+        if (invalid) return invalid;
       }
     }
     const clues = instances.find(instance => instance.templateId === "ssobig.clues");

package/templates/mystery-v1/markdown-document-model.js

@@ -0,0 +1,444 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === "object" && module.exports) module.exports = api;
+  if (root) root.WriterMarkdownDocumentModel = api;
+})(typeof globalThis !== "undefined" ? globalThis : this, function () {
+  "use strict";
+
+  function normalizedSource(value, preserveBlankLines = false) {
+    const source = String(value ?? "").replace(/\r\n?/g, "\n");
+    if (preserveBlankLines) return source;
+    return source
+      .replace(/^(?:[ \t]*\n)+/, "")
+      .replace(/(?:\n[ \t]*)+$/, "");
+  }
+
+  function lineStarts(source) {
+    const starts = [0];
+    for (let index = 0; index < source.length; index += 1) {
+      if (source[index] === "\n") starts.push(index + 1);
+    }
+    return starts;
+  }
+
+  // Only project-owned asset references are renderable; URLs and paths stay text.
+  function imageReference(value) {
+    const match = String(value ?? "").match(/^ {0,3}!\[([^\]\n]*)\]\(asset:([a-zA-Z0-9_-]{1,160})\)[ \t]*$/);
+    return match ? { alt: match[1], assetId: match[2] } : null;
+  }
+
+  function imageMarkdown(assetId, alt = "") {
+    if (!/^[a-zA-Z0-9_-]{1,160}$/.test(String(assetId))) throw new Error("올바른 이미지 에셋 ID가 아닙니다.");
+    return `![${String(alt).replace(/[\[\]\r\n]/g, " ")}](asset:${assetId})`;
+  }
+
+  function parseLine(text, index = 0, from = 0) {
+    const source = String(text ?? "");
+    const heading = source.match(/^( {0,3})(#{1,4})(?:[ \t]+)(.*)$/);
+    const quote = source.match(/^( {0,3})>[ \t]?(.*)$/);
+    const unordered = source.match(/^( {0,3})([-*])([ \t]+)(.*)$/);
+    const ordered = source.match(/^( {0,3})(\d+)([.)])([ \t]+)(.*)$/);
+    const list = unordered || ordered;
+    const listType = unordered ? "unordered" : ordered ? "ordered" : "";
+    const marker = unordered ? unordered[2] : ordered ? `${ordered[2]}${ordered[3]}` : "";
+    const indent = list ? list[1] : "";
+    const separator = unordered ? unordered[3] : ordered ? ordered[4] : "";
+    const body = unordered ? unordered[4] : ordered ? ordered[5] : "";
+    const markerFrom = list ? indent.length : -1;
+    const markerTo = list ? markerFrom + marker.length : -1;
+
+    return Object.freeze({
+      index,
+      text: source,
+      from,
+      to: from + source.length,
+      empty: !source.trim(),
+      headingLevel: heading ? heading[2].length : 0,
+      headingMarkerFrom: heading ? heading[1].length : -1,
+      headingMarkerTo: heading ? source.length - heading[3].length : -1,
+      headingBody: heading ? heading[3] : "",
+      quoteMarkerFrom: quote ? quote[1].length : -1,
+      quoteMarkerTo: quote ? quote[0].length - quote[2].length : -1,
+      quoteBody: quote ? quote[2] : "",
+      listType,
+      listIndent: indent,
+      listIndentTo: list ? indent.length : -1,
+      listMarker: marker,
+      listMarkerFrom: markerFrom,
+      listMarkerTo: markerTo,
+      listPrefixTo: list ? markerTo + separator.length : -1,
+      listSeparator: separator,
+      listBody: body,
+      listNumberText: ordered ? ordered[2] : "",
+      listNumber: ordered ? Number.parseInt(ordered[2], 10) : null,
+      listDelimiter: ordered ? ordered[3] : unordered ? unordered[2] : ""
+    });
+  }
+
+  function markerCharacterWidth(marker) {
+    return Math.max(1, [...String(marker || "")].length);
+  }
+
+  function isEscaped(source, index) {
+    let backslashes = 0;
+    for (let cursor = index - 1; cursor >= 0 && source[cursor] === "\\"; cursor -= 1) {
+      backslashes += 1;
+    }
+    return backslashes % 2 === 1;
+  }
+
+  function backtickRunLength(source, index) {
+    let cursor = index;
+    while (source[cursor] === "`") cursor += 1;
+    return cursor - index;
+  }
+
+  function closingCodeSpan(source, from, markerLength) {
+    let cursor = from;
+    while (cursor < source.length) {
+      if (source[cursor] !== "`") {
+        cursor += 1;
+        continue;
+      }
+      const runLength = backtickRunLength(source, cursor);
+      if (runLength === markerLength) return cursor + runLength;
+      cursor += runLength;
+    }
+    return -1;
+  }
+
+  function tablePipeOffsets(value) {
+    const source = String(value ?? "");
+    const offsets = [];
+    let index = 0;
+    while (index < source.length) {
+      if (source[index] === "`" && !isEscaped(source, index)) {
+        const markerLength = backtickRunLength(source, index);
+        const closeTo = closingCodeSpan(source, index + markerLength, markerLength);
+        if (closeTo >= 0) {
+          index = closeTo;
+          continue;
+        }
+        index += markerLength;
+        continue;
+      }
+      if (source[index] === "|" && !isEscaped(source, index)) offsets.push(index);
+      index += 1;
+    }
+    return offsets;
+  }
+
+  function unescapeTableCellPipes(value) {
+    const source = String(value ?? "");
+    let result = "";
+    let index = 0;
+    while (index < source.length) {
+      if (source[index] !== "\\") {
+        result += source[index];
+        index += 1;
+        continue;
+      }
+      let cursor = index;
+      while (source[cursor] === "\\") cursor += 1;
+      const count = cursor - index;
+      if (source[cursor] === "|" && count % 2 === 1) {
+        result += "\\".repeat(count - 1);
+        result += "|";
+        index = cursor + 1;
+        continue;
+      }
+      result += "\\".repeat(count);
+      index = cursor;
+    }
+    return result;
+  }
+
+  function tableCell(source, lineIndex, lineFrom, rawFrom, rawTo, columnIndex) {
+    let contentFrom = rawFrom;
+    let contentTo = rawTo;
+    while (contentFrom < contentTo && /[ \t]/.test(source[contentFrom])) contentFrom += 1;
+    while (contentTo > contentFrom && /[ \t]/.test(source[contentTo - 1])) contentTo -= 1;
+    const raw = source.slice(rawFrom, rawTo);
+    return {
+      type: "tableCell",
+      columnIndex,
+      lineIndex,
+      from: lineFrom + contentFrom,
+      to: lineFrom + contentTo,
+      rawFrom: lineFrom + rawFrom,
+      rawTo: lineFrom + rawTo,
+      raw,
+      text: unescapeTableCellPipes(source.slice(contentFrom, contentTo)),
+      synthetic: false
+    };
+  }
+
+  function parseTableRow(text, index = 0, from = 0) {
+    const source = String(text ?? "");
+    const firstContent = source.search(/[^ \t]/);
+    if (firstContent < 0 || firstContent > 3 || /\t/.test(source.slice(0, firstContent))) return null;
+    let lastContent = source.length - 1;
+    while (lastContent >= 0 && /[ \t]/.test(source[lastContent])) lastContent -= 1;
+
+    const offsets = tablePipeOffsets(source);
+    const offsetSet = new Set(offsets);
+    const hasLeadingPipe = source[firstContent] === "|" && offsetSet.has(firstContent);
+    const hasTrailingPipe = source[lastContent] === "|" && offsetSet.has(lastContent);
+    const contentFrom = hasLeadingPipe ? firstContent + 1 : 0;
+    const contentTo = hasTrailingPipe ? lastContent : source.length;
+    if (contentFrom > contentTo) return null;
+
+    const separators = offsets.filter(offset => offset >= contentFrom && offset < contentTo);
+    const cells = [];
+    let cellFrom = contentFrom;
+    separators.forEach((separator, columnIndex) => {
+      cells.push(tableCell(source, index, from, cellFrom, separator, columnIndex));
+      cellFrom = separator + 1;
+    });
+    cells.push(tableCell(source, index, from, cellFrom, contentTo, cells.length));
+
+    return {
+      type: "tableRow",
+      role: "",
+      lineIndex: index,
+      from,
+      to: from + source.length,
+      raw: source,
+      cells,
+      pipes: offsets.map(offset => ({ from: from + offset, to: from + offset + 1 })),
+      hasLeadingPipe,
+      hasTrailingPipe
+    };
+  }
+
+  function parseTableDelimiterCell(cell) {
+    const match = String(cell?.text ?? "").match(/^(:)?(-{3,})(:)?$/);
+    if (!match) return null;
+    const alignment = match[1] && match[3]
+      ? "center"
+      : match[1]
+        ? "left"
+        : match[3]
+          ? "right"
+          : null;
+    return { ...cell, type: "tableDelimiterCell", alignment };
+  }
+
+  function tableRowWithRole(row, role, columnCount = row.cells.length) {
+    const cells = row.cells.slice();
+    while (cells.length < columnCount) {
+      cells.push({
+        type: "tableCell",
+        columnIndex: cells.length,
+        lineIndex: row.lineIndex,
+        from: row.to,
+        to: row.to,
+        rawFrom: row.to,
+        rawTo: row.to,
+        raw: "",
+        text: "",
+        synthetic: true
+      });
+    }
+    return { ...row, role, cells };
+  }
+
+  function parseTableBlock(lines, startIndex, source) {
+    const headerLine = lines[startIndex];
+    const delimiterLine = lines[startIndex + 1];
+    if (!headerLine || !delimiterLine) return null;
+    if (
+      headerLine.empty || headerLine.headingLevel || headerLine.quoteMarkerFrom >= 0 || headerLine.listType ||
+      delimiterLine.empty || delimiterLine.headingLevel || delimiterLine.quoteMarkerFrom >= 0 || delimiterLine.listType
+    ) return null;
+
+    const parsedHeader = parseTableRow(headerLine.text, headerLine.index, headerLine.from);
+    const parsedDelimiter = parseTableRow(delimiterLine.text, delimiterLine.index, delimiterLine.from);
+    if (!parsedHeader || !parsedDelimiter) return null;
+    if (!parsedHeader.pipes.length && !parsedDelimiter.pipes.length) return null;
+    if (!parsedHeader.cells.length || parsedHeader.cells.length !== parsedDelimiter.cells.length) return null;
+
+    const delimiterCells = parsedDelimiter.cells.map(parseTableDelimiterCell);
+    if (delimiterCells.some(cell => !cell)) return null;
+    const columnCount = parsedHeader.cells.length;
+    const rows = [];
+    let nextIndex = startIndex + 2;
+    while (nextIndex < lines.length) {
+      const line = lines[nextIndex];
+      if (line.empty || line.headingLevel || line.quoteMarkerFrom >= 0 || line.listType) break;
+      const parsedRow = parseTableRow(line.text, line.index, line.from);
+      if (!parsedRow || !parsedRow.pipes.length) break;
+      if (parsedRow.cells.length > columnCount) return null;
+      rows.push(tableRowWithRole(parsedRow, "body", columnCount));
+      nextIndex += 1;
+    }
+
+    const header = tableRowWithRole(parsedHeader, "header");
+    const delimiter = {
+      ...parsedDelimiter,
+      role: "delimiter",
+      cells: delimiterCells
+    };
+    const allRows = [header, delimiter, ...rows];
+    const from = header.from;
+    const to = allRows.at(-1).to;
+    return {
+      block: {
+        type: "table",
+        from,
+        to,
+        raw: source.slice(from, to),
+        lineIndices: allRows.map(row => row.lineIndex),
+        columnCount,
+        alignments: delimiterCells.map(cell => cell.alignment),
+        header,
+        delimiter,
+        rows
+      },
+      nextIndex
+    };
+  }
+
+  function parseDocument(value, options = {}) {
+    const preserveBlankLines = options.preserveBlankLines === true;
+    const source = normalizedSource(value, preserveBlankLines);
+    if (!source && !preserveBlankLines) return Object.freeze({ source, lines: Object.freeze([]), blocks: Object.freeze([]) });
+
+    const starts = lineStarts(source);
+    const lines = source.split("\n").map((text, index) => parseLine(text, index, starts[index]));
+    const blocks = [];
+    let paragraph = null;
+    let quote = null;
+    let list = null;
+
+    const closeParagraph = () => { paragraph = null; };
+    const closeQuote = () => { quote = null; };
+    const closeList = () => {
+      if (list) {
+        list.markerWidth = Math.max(1, ...list.items.map(item => markerCharacterWidth(item.marker)));
+      }
+      list = null;
+    };
+    const closeAll = () => {
+      closeParagraph();
+      closeQuote();
+      closeList();
+    };
+    const appendParagraph = line => {
+      if (!paragraph) {
+        paragraph = { type: "paragraph", lines: [], lineIndices: [] };
+        blocks.push(paragraph);
+      }
+      paragraph.lines.push(line.text);
+      paragraph.lineIndices.push(line.index);
+    };
+    const appendQuote = (container, line) => {
+      let current = container.at(-1);
+      if (!current || current.type !== "quote") {
+        current = { type: "quote", lines: [], lineIndices: [] };
+        container.push(current);
+      }
+      current.lines.push(line.quoteBody);
+      current.lineIndices.push(line.index);
+      return current;
+    };
+
+    for (let lineIndex = 0; lineIndex < lines.length;) {
+      const line = lines[lineIndex];
+      const image = imageReference(line.text);
+      if (image) {
+        closeAll();
+        blocks.push({ type: "image", ...image, from: line.from, to: line.to, lineIndex });
+        lineIndex += 1;
+        continue;
+      }
+      const table = parseTableBlock(lines, lineIndex, source);
+      if (table) {
+        closeAll();
+        blocks.push(table.block);
+        lineIndex = table.nextIndex;
+        continue;
+      }
+
+      if (line.quoteMarkerFrom >= 0) {
+        closeParagraph();
+        if (list?.items.length) {
+          quote = null;
+          appendQuote(list.items.at(-1).children, line);
+        } else {
+          closeList();
+          if (!quote) {
+            quote = { type: "quote", lines: [], lineIndices: [] };
+            blocks.push(quote);
+          }
+          quote.lines.push(line.quoteBody);
+          quote.lineIndices.push(line.index);
+        }
+        lineIndex += 1;
+        continue;
+      }
+
+      closeQuote();
+      if (line.empty) {
+        closeAll();
+        blocks.push({ type: "blank", lineIndex: line.index });
+        lineIndex += 1;
+        continue;
+      }
+
+      if (line.headingLevel) {
+        closeAll();
+        blocks.push({ type: "heading", level: line.headingLevel, text: line.headingBody, lineIndex: line.index });
+        lineIndex += 1;
+        continue;
+      }
+
+      if (line.listType) {
+        closeParagraph();
+        if (list && list.listType !== line.listType) closeList();
+        if (!list) {
+          list = { type: "list", listType: line.listType, items: [], lineIndices: [], markerWidth: 1 };
+          blocks.push(list);
+        }
+        list.items.push({
+          type: "listItem",
+          marker: line.listMarker,
+          number: line.listNumber,
+          delimiter: line.listDelimiter,
+          indent: line.listIndent,
+          separator: line.listSeparator,
+          body: line.listBody,
+          numberText: line.listNumberText,
+          lineIndex: line.index,
+          children: []
+        });
+        list.lineIndices.push(line.index);
+        lineIndex += 1;
+        continue;
+      }
+
+      closeList();
+      appendParagraph(line);
+      lineIndex += 1;
+    }
+    closeList();
+
+    return Object.freeze({
+      source,
+      lines: Object.freeze(lines),
+      blocks: Object.freeze(blocks)
+    });
+  }
+
+  return Object.freeze({
+    imageReference,
+    imageMarkdown,
+    normalizedSource,
+    lineStarts,
+    parseLine,
+    parseTableRow,
+    parseTableDelimiterCell,
+    parseDocument,
+    markerCharacterWidth
+  });
+});