@owomark/core 0.1.5 → 0.1.7

package/dist/chunk-BKJCBEI7.js

@@ -0,0 +1,397 @@
+import {
+  createDescriptorRegistry,
+  requireDescriptor,
+  validateSyntaxDescriptors
+} from "./chunk-OOH46GIF.js";
+
+// src/semantic/syntax/builtin/math.ts
+var MATH_FENCE_RE = /^ {0,3}\$\$\s*$/;
+var SINGLE_LINE_MATH_BLOCK_RE = /^ {0,3}\$\$(?!\s*$)([^\n]*?)(?<!\\)\$\$\s*$/;
+var MULTI_LINE_MATH_BLOCK_OPEN_RE = /^ {0,3}\$\$(?!\s*$)(?!.*(?<!\\)\$\$\s*$).+$/;
+var MULTI_LINE_MATH_BLOCK_CLOSE_RE = /(?<!\\)\$\$\s*$/;
+var mathSyntaxDescriptor = {
+  key: "builtin.math",
+  family: "syntax",
+  syntaxKind: "block",
+  consumes: ["parser", "processor", "preview", "runtime"],
+  specIds: ["docs/specs/owomark-math.md"],
+  featureFlag: "enableMath",
+  aliases: ["math-block"]
+};
+function isFenceOnlyMathLine(line) {
+  return MATH_FENCE_RE.test(line);
+}
+function isSingleLineMathBlock(line) {
+  return SINGLE_LINE_MATH_BLOCK_RE.test(line);
+}
+function isMultiLineMathBlockOpen(line) {
+  return MULTI_LINE_MATH_BLOCK_OPEN_RE.test(line);
+}
+function isMultiLineMathBlockClose(line) {
+  return MULTI_LINE_MATH_BLOCK_CLOSE_RE.test(line);
+}
+function getLeadingWhitespace(line) {
+  return line.match(/^ {0,3}/)?.[0] ?? "";
+}
+function splitOpeningMathLine(line) {
+  const prefix = getLeadingWhitespace(line);
+  return [`${prefix}$$`, `${prefix}${line.slice(prefix.length + 2)}`];
+}
+function splitClosingMathLine(line) {
+  const match = line.match(MULTI_LINE_MATH_BLOCK_CLOSE_RE);
+  if (!match || match.index == null) return [line];
+  const prefix = getLeadingWhitespace(line);
+  const content = line.slice(0, match.index);
+  const output = [];
+  if (content.length > 0) {
+    output.push(content);
+  }
+  output.push(`${prefix}$$`);
+  return output;
+}
+function collectMathFenceNormalizationRewrites(source) {
+  const lines = source.split("\n");
+  if (source.endsWith("\n")) {
+    lines.pop();
+  }
+  const rewrites = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!isFenceOnlyMathLine(line) && !isMultiLineMathBlockOpen(line)) {
+      continue;
+    }
+    if (isSingleLineMathBlock(line)) {
+      continue;
+    }
+    let closeIndex = -1;
+    for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+      if (isMultiLineMathBlockClose(lines[cursor])) {
+        closeIndex = cursor;
+        break;
+      }
+    }
+    if (closeIndex === -1) {
+      continue;
+    }
+    const firstLine = lines[index];
+    const lastLine = lines[closeIndex];
+    const needsOpeningSplit = !isFenceOnlyMathLine(firstLine);
+    const needsClosingSplit = !isFenceOnlyMathLine(lastLine);
+    if (!needsOpeningSplit && !needsClosingSplit) {
+      index = closeIndex;
+      continue;
+    }
+    const replacementLines = [];
+    const lineMappings = [];
+    if (needsOpeningSplit) {
+      const openingLines = splitOpeningMathLine(firstLine);
+      replacementLines.push(openingLines[0]);
+      lineMappings.push({ sourceLine: index + 1, sourceColumn: 1 });
+      replacementLines.push(openingLines[1]);
+      lineMappings.push({ sourceLine: index + 1, sourceColumn: 3 });
+    } else {
+      replacementLines.push(firstLine);
+      lineMappings.push({ sourceLine: index + 1, sourceColumn: 1 });
+    }
+    for (let cursor = index + 1; cursor < closeIndex; cursor += 1) {
+      replacementLines.push(lines[cursor]);
+      lineMappings.push({ sourceLine: cursor + 1, sourceColumn: 1 });
+    }
+    if (needsClosingSplit) {
+      const closingLines = splitClosingMathLine(lastLine);
+      const prefixLength = getLeadingWhitespace(lastLine).length;
+      const fenceStart = lastLine.match(MULTI_LINE_MATH_BLOCK_CLOSE_RE)?.index ?? prefixLength;
+      if (closingLines.length === 2) {
+        replacementLines.push(closingLines[0]);
+        lineMappings.push({ sourceLine: closeIndex + 1, sourceColumn: 1 });
+        replacementLines.push(closingLines[1]);
+        lineMappings.push({
+          sourceLine: closeIndex + 1,
+          sourceColumn: fenceStart - prefixLength + 1
+        });
+      } else {
+        replacementLines.push(closingLines[0]);
+        lineMappings.push({ sourceLine: closeIndex + 1, sourceColumn: 1 });
+      }
+    } else {
+      replacementLines.push(lastLine);
+      lineMappings.push({ sourceLine: closeIndex + 1, sourceColumn: 1 });
+    }
+    rewrites.push({
+      kind: "math-fence",
+      startLine: index + 1,
+      endLine: closeIndex + 1,
+      replacementLines,
+      lineMappings
+    });
+    index = closeIndex;
+  }
+  return rewrites;
+}
+
+// src/semantic/syntax/builtin/side-annotation.ts
+var sideAnnotationTypeDescriptors = [
+  { symbol: ":", keyword: "plain", rendererKey: "plain" },
+  { symbol: "}", keyword: "brace", rendererKey: "brace" },
+  { symbol: "{", keyword: "left-brace", rendererKey: "left-brace" },
+  { symbol: "]", keyword: "bracket", rendererKey: "bracket" },
+  { symbol: "[", keyword: "left-bracket", rendererKey: "left-bracket" },
+  { symbol: "|", keyword: "line", rendererKey: "line" },
+  { symbol: "-", keyword: "dash", rendererKey: "dash" },
+  { symbol: "->", keyword: "arrow", rendererKey: "arrow" },
+  { symbol: "=>", keyword: "fat-arrow", rendererKey: "fat-arrow" },
+  { symbol: "~>", keyword: "wave-arrow", rendererKey: "wave-arrow" },
+  { symbol: "!", keyword: "warning", rendererKey: "line" },
+  { symbol: "?", keyword: "question", rendererKey: "line" },
+  { symbol: "}->", keyword: "brace-arrow", rendererKey: "brace-arrow" },
+  { symbol: "}=>", keyword: "brace-fat-arrow", rendererKey: "brace-fat-arrow" },
+  { symbol: "]->", keyword: "bracket-arrow", rendererKey: "bracket-arrow" },
+  { symbol: "]=>", keyword: "bracket-fat-arrow", rendererKey: "bracket-fat-arrow" },
+  { symbol: "|->", keyword: "line-arrow", rendererKey: "line-arrow" },
+  { symbol: "|=>", keyword: "line-fat-arrow", rendererKey: "line-fat-arrow" },
+  { symbol: "}!", keyword: "brace-warning", rendererKey: "brace" },
+  { symbol: "}?", keyword: "brace-question", rendererKey: "brace" }
+];
+var SIDE_ANNOTATION_TYPE_TABLE = Object.freeze(
+  Object.fromEntries(
+    sideAnnotationTypeDescriptors.map((descriptor) => [descriptor.symbol, descriptor.keyword])
+  )
+);
+var SIDE_ANNOTATION_TYPE_SYMBOLS = sideAnnotationTypeDescriptors.map(
+  (descriptor) => descriptor.symbol
+);
+var SIDE_ANNOTATION_TYPE_SYMBOLS_SORTED = [...SIDE_ANNOTATION_TYPE_SYMBOLS].sort((a, b) => b.length - a.length);
+var SIDE_ANNOTATION_SYMBOL_BY_KEYWORD = Object.freeze(
+  Object.fromEntries(
+    sideAnnotationTypeDescriptors.map((descriptor) => [descriptor.keyword, descriptor.symbol])
+  )
+);
+var SIDE_ANNOTATION_RENDERER_KEY_BY_TYPE = Object.freeze(
+  Object.fromEntries(
+    sideAnnotationTypeDescriptors.map((descriptor) => [descriptor.keyword, descriptor.rendererKey])
+  )
+);
+var TYPE_PATTERN = [
+  ...SIDE_ANNOTATION_TYPE_SYMBOLS_SORTED,
+  ...Object.keys(SIDE_ANNOTATION_SYMBOL_BY_KEYWORD).sort((a, b) => b.length - a.length)
+].map((symbol) => symbol.replace(/[|\\{}()[\]^$+*?.-]/g, "\\$&")).join("|");
+var sideAnnotationSyntaxDescriptors = [
+  {
+    key: "builtin.side-inline-head",
+    family: "syntax",
+    syntaxKind: "block",
+    consumes: ["parser", "processor", "preview", "rehype", "runtime"],
+    specIds: ["docs/specs/owomark-side-annotation.md"],
+    featureFlag: "enableSideAnnotation",
+    aliases: ["side-inline-head"]
+  },
+  {
+    key: "builtin.side-continuation",
+    family: "syntax",
+    syntaxKind: "block",
+    consumes: ["parser", "processor", "preview", "rehype", "runtime"],
+    specIds: ["docs/specs/owomark-side-annotation.md"],
+    featureFlag: "enableSideAnnotation",
+    aliases: ["side-continuation"]
+  },
+  {
+    key: "builtin.side-container",
+    family: "syntax",
+    syntaxKind: "container-block",
+    consumes: ["parser", "processor", "preview", "rehype", "runtime"],
+    specIds: ["docs/specs/owomark-side-annotation.md"],
+    featureFlag: "enableSideAnnotation",
+    aliases: ["side-container"]
+  },
+  {
+    key: "builtin.side-reference-definition",
+    family: "syntax",
+    syntaxKind: "block",
+    consumes: ["parser", "processor", "preview", "rehype", "runtime"],
+    specIds: ["docs/specs/owomark-side-annotation.md"],
+    featureFlag: "enableSideAnnotation",
+    aliases: ["side-reference-definition"]
+  }
+];
+var SIDE_ANNOTATION_TAIL_RE = new RegExp(`\\(>(?:${TYPE_PATTERN})[^\\n)]*\\)\\s*$`);
+var SIDE_CONTINUATION_TAIL_RE = /\(>\+\)\s*$/;
+var SIDE_NOTE_REF_RE = /^\[>([\w-]+)\]$/;
+var SIDE_NOTE_DEFINITION_RE = /^\[>([\w-]+)\]:\s*(?:\{type=([^}"]+|"[^"]*")\}\s*)?(.*)$/;
+function findUnescapedClose(text) {
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] === ")") {
+      let backslashCount = 0;
+      for (let cursor = index - 1; cursor >= 0 && text[cursor] === "\\"; cursor -= 1) {
+        backslashCount += 1;
+      }
+      if (backslashCount > 0) {
+        continue;
+      }
+      return index;
+    }
+  }
+  return -1;
+}
+function resolveTypeSymbol(raw) {
+  if (raw in SIDE_ANNOTATION_TYPE_TABLE) {
+    const symbol = raw;
+    return {
+      sideType: SIDE_ANNOTATION_TYPE_TABLE[symbol],
+      sideTypeSymbol: symbol
+    };
+  }
+  const symbolFromKeyword = SIDE_ANNOTATION_SYMBOL_BY_KEYWORD[raw];
+  if (!symbolFromKeyword) {
+    return null;
+  }
+  return {
+    sideType: SIDE_ANNOTATION_TYPE_TABLE[symbolFromKeyword],
+    sideTypeSymbol: symbolFromKeyword
+  };
+}
+function parseInlineSideAnnotationText(inner) {
+  const spaceIndex = inner.indexOf(" ");
+  if (spaceIndex < 0) {
+    return null;
+  }
+  const typeCandidate = inner.slice(0, spaceIndex);
+  if (!typeCandidate || typeCandidate === "+") {
+    return null;
+  }
+  const resolved = resolveTypeSymbol(typeCandidate);
+  if (!resolved) {
+    return null;
+  }
+  const content = inner.slice(spaceIndex + 1).replace(/\\+\)/g, ")").trim();
+  if (!content) {
+    return null;
+  }
+  return {
+    sideType: resolved.sideType,
+    sideTypeSymbol: resolved.sideTypeSymbol,
+    content
+  };
+}
+function parseInlineSideAnnotationFromText(text) {
+  if (!text || /\(\\>/.test(text)) {
+    return null;
+  }
+  const openIndex = text.lastIndexOf("(>");
+  if (openIndex < 0) {
+    return null;
+  }
+  const afterOpen = text.slice(openIndex + 2);
+  const closeIndex = findUnescapedClose(afterOpen);
+  if (closeIndex < 0) {
+    return null;
+  }
+  if (afterOpen.slice(closeIndex + 1).trim()) {
+    return null;
+  }
+  return parseInlineSideAnnotationText(afterOpen.slice(0, closeIndex));
+}
+function stripInlineSideAnnotationTail(text) {
+  if (!parseInlineSideAnnotationFromText(text)) {
+    return text;
+  }
+  const openIndex = text.lastIndexOf("(>");
+  if (openIndex < 0) {
+    return text;
+  }
+  return text.slice(0, openIndex).trimEnd();
+}
+function stripSideContinuationTail(text) {
+  return text.replace(SIDE_CONTINUATION_TAIL_RE, "").trimEnd();
+}
+function parseSideDirectiveLabel(label) {
+  const trimmed = label.trim();
+  const noteRefMatch = SIDE_NOTE_REF_RE.exec(trimmed);
+  if (noteRefMatch) {
+    return { noteRef: noteRefMatch[1] };
+  }
+  const inner = trimmed.replace(/^\(>(.*)\)$/, "$1");
+  return parseInlineSideAnnotationText(inner);
+}
+function parseSideNoteDefinitionRaw(raw) {
+  const lines = raw.split("\n");
+  const firstLine = lines[0]?.trim() ?? "";
+  const prefixMatch = /^\[>([\w-]+)\]:\s*(.*)$/.exec(firstLine);
+  if (!prefixMatch) {
+    return null;
+  }
+  const identifier = prefixMatch[1];
+  let remainder = prefixMatch[2] ?? "";
+  let typeToken = ":";
+  if (remainder.startsWith("{type=")) {
+    const attributeMatch = /^\{type=("[^"]*"|.+?)\}(?:\s+|$)(.*)$/.exec(remainder);
+    if (attributeMatch) {
+      typeToken = attributeMatch[1].replace(/^"|"$/g, "");
+      remainder = attributeMatch[2] ?? "";
+    }
+  }
+  const resolved = resolveTypeSymbol(typeToken);
+  if (!resolved) {
+    return null;
+  }
+  const contentParts = [];
+  const firstLineTail = remainder.trim();
+  if (firstLineTail) {
+    contentParts.push(firstLineTail);
+  }
+  for (let index = 1; index < lines.length; index += 1) {
+    const continuation = lines[index].match(/^(?: {1,4}|\t)(.*)$/);
+    if (!continuation) {
+      break;
+    }
+    contentParts.push(continuation[1]);
+  }
+  return {
+    identifier,
+    sideType: resolved.sideType,
+    sideTypeSymbol: resolved.sideTypeSymbol,
+    content: contentParts.join("\n").trim()
+  };
+}
+
+// src/semantic/syntax/index.ts
+var descriptors = [
+  mathSyntaxDescriptor,
+  ...sideAnnotationSyntaxDescriptors
+];
+validateSyntaxDescriptors(descriptors);
+var syntaxRegistry = createDescriptorRegistry(descriptors, "syntax");
+function getSyntaxDescriptor(key) {
+  return requireDescriptor(syntaxRegistry, key, "syntax");
+}
+
+export {
+  MATH_FENCE_RE,
+  SINGLE_LINE_MATH_BLOCK_RE,
+  MULTI_LINE_MATH_BLOCK_OPEN_RE,
+  MULTI_LINE_MATH_BLOCK_CLOSE_RE,
+  mathSyntaxDescriptor,
+  isFenceOnlyMathLine,
+  isSingleLineMathBlock,
+  isMultiLineMathBlockOpen,
+  isMultiLineMathBlockClose,
+  collectMathFenceNormalizationRewrites,
+  sideAnnotationTypeDescriptors,
+  SIDE_ANNOTATION_TYPE_TABLE,
+  SIDE_ANNOTATION_TYPE_SYMBOLS,
+  SIDE_ANNOTATION_TYPE_SYMBOLS_SORTED,
+  SIDE_ANNOTATION_SYMBOL_BY_KEYWORD,
+  SIDE_ANNOTATION_RENDERER_KEY_BY_TYPE,
+  sideAnnotationSyntaxDescriptors,
+  SIDE_ANNOTATION_TAIL_RE,
+  SIDE_CONTINUATION_TAIL_RE,
+  SIDE_NOTE_REF_RE,
+  SIDE_NOTE_DEFINITION_RE,
+  parseInlineSideAnnotationText,
+  parseInlineSideAnnotationFromText,
+  stripInlineSideAnnotationTail,
+  stripSideContinuationTail,
+  parseSideDirectiveLabel,
+  parseSideNoteDefinitionRaw,
+  syntaxRegistry,
+  getSyntaxDescriptor
+};