@ssobig/writer-cli 0.3.0 → 0.3.3

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

@@ -0,0 +1,458 @@
+(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 horizontalRule = /^ {0,3}-(?:[ \t]*-){2,}[ \t]*$/.test(source);
+    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;
+    const task = unordered ? body.match(/^\[([ xX])\](?:[ \t]+|$)/) : null;
+
+    return Object.freeze({
+      index,
+      text: source,
+      from,
+      to: from + source.length,
+      empty: !source.trim(),
+      horizontalRule,
+      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: task ? body.slice(task[0].length) : body,
+      taskChecked: task ? task[1].toLowerCase() === "x" : null,
+      taskStateFrom: task ? markerTo + separator.length + 1 : -1,
+      taskMarkerTo: task ? markerTo + separator.length + 3 : -1,
+      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.horizontalRule) {
+        closeAll();
+        blocks.push({ type: "horizontalRule", lineIndex: line.index });
+        lineIndex += 1;
+        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,
+          taskChecked: line.taskChecked,
+          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
+  });
+});