@stacksjs/ts-md 0.1.0

package/dist/index.js

@@ -0,0 +1,1130 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/frontmatter.ts
+var exports_frontmatter = {};
+__export(exports_frontmatter, {
+  stringify: () => stringify2,
+  parse: () => parse2,
+  hasFrontmatter: () => hasFrontmatter,
+  extractFrontmatter: () => extractFrontmatter
+});
+
+// src/yaml.ts
+var exports_yaml = {};
+__export(exports_yaml, {
+  stringify: () => stringify,
+  parse: () => parse
+});
+function convertYaml11Booleans(obj) {
+  if (obj === null || obj === undefined) {
+    return obj;
+  }
+  if (typeof obj === "string") {
+    const lower = obj.toLowerCase();
+    if (lower === "yes" || lower === "on")
+      return true;
+    if (lower === "no" || lower === "off")
+      return false;
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(convertYaml11Booleans);
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = convertYaml11Booleans(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function parse(input, options = {}) {
+  const strict = options.strict ?? false;
+  try {
+    const content = input.replace(/^\uFEFF/, "");
+    if (!content.trim()) {
+      return {};
+    }
+    let result = Bun.YAML.parse(content);
+    if (Array.isArray(result) && result.length === 1) {
+      result = result[0];
+    }
+    return convertYaml11Booleans(result);
+  } catch (error) {
+    if (strict) {
+      throw new Error(`YAML parsing failed: ${error}`);
+    }
+    return {};
+  }
+}
+function stringify(obj, _options = {}) {
+  try {
+    return Bun.YAML.stringify(obj, null, 2);
+  } catch {
+    return stringifyFallback(obj, 0);
+  }
+}
+function stringifyFallback(obj, indent) {
+  return stringifyValue(obj, indent);
+}
+function stringifyValue(value, indent) {
+  const spaces = " ".repeat(indent);
+  if (value === null || value === undefined) {
+    return "null";
+  }
+  if (typeof value === "boolean") {
+    return value.toString();
+  }
+  if (typeof value === "number") {
+    return value.toString();
+  }
+  if (typeof value === "string") {
+    if (value.includes(":") || value.includes("#") || value.includes(`
+`)) {
+      return `"${value.replace(/"/g, "\\\"")}"`;
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return "[]";
+    return value.map((item) => {
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        const itemStr = stringifyValue(item, indent + 2);
+        return `
+${spaces}- ${itemStr.trim()}`;
+      }
+      return `
+${spaces}- ${stringifyValue(item, indent + 2)}`;
+    }).join("");
+  }
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    if (keys.length === 0)
+      return "{}";
+    return keys.map((key) => {
+      const val = value[key];
+      if (typeof val === "object" && val !== null) {
+        return `
+${spaces}${key}:${stringifyValue(val, indent + 2)}`;
+      }
+      return `
+${spaces}${key}: ${stringifyValue(val, indent + 2)}`;
+    }).join("");
+  }
+  return String(value);
+}
+
+// src/frontmatter.ts
+var FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n/;
+var FRONTMATTER_REGEX_ALT = /^\+\+\+\r?\n([\s\S]*?)\r?\n\+\+\+\r?\n/;
+function parse2(content) {
+  const original = content;
+  let match = content.match(FRONTMATTER_REGEX);
+  let data = {};
+  let matter;
+  let markdown = content;
+  if (match) {
+    matter = match[1];
+    markdown = content.substring(match[0].length);
+    data = parse(matter);
+  } else {
+    match = content.match(FRONTMATTER_REGEX_ALT);
+    if (match) {
+      matter = match[1];
+      markdown = content.substring(match[0].length);
+      data = parseToml(matter);
+    }
+  }
+  return {
+    data,
+    content: markdown,
+    original,
+    matter
+  };
+}
+function parseToml(content) {
+  const result = {};
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const equalIndex = trimmed.indexOf("=");
+    if (equalIndex > 0) {
+      const key = trimmed.substring(0, equalIndex).trim();
+      const value = trimmed.substring(equalIndex + 1).trim();
+      result[key] = parseTomlValue(value);
+    }
+  }
+  return result;
+}
+function parseTomlValue(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.substring(1, value.length - 1);
+  }
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (/^-?\d+$/.test(value)) {
+    return Number.parseInt(value, 10);
+  }
+  if (/^-?\d+\.\d+$/.test(value)) {
+    return Number.parseFloat(value);
+  }
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const items = value.substring(1, value.length - 1).split(",");
+    return items.map((item) => parseTomlValue(item.trim()));
+  }
+  return value;
+}
+function stringify2(data, content, format = "yaml") {
+  if (!data || Object.keys(data).length === 0) {
+    return content;
+  }
+  const delimiter = format === "yaml" ? "---" : "+++";
+  const matter = format === "yaml" ? stringify(data).trim() : stringifyToml(data).trim();
+  return `${delimiter}
+${matter}
+${delimiter}
+${content}`;
+}
+function stringifyToml(obj) {
+  const lines = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === "string") {
+      lines.push(`${key} = "${value}"`);
+    } else if (typeof value === "boolean" || typeof value === "number") {
+      lines.push(`${key} = ${value}`);
+    } else if (Array.isArray(value)) {
+      const items = value.map((item) => {
+        if (typeof item === "string")
+          return `"${item}"`;
+        return String(item);
+      });
+      lines.push(`${key} = [${items.join(", ")}]`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function hasFrontmatter(content) {
+  return FRONTMATTER_REGEX.test(content) || FRONTMATTER_REGEX_ALT.test(content);
+}
+function extractFrontmatter(content) {
+  let match = content.match(FRONTMATTER_REGEX);
+  if (match)
+    return match[1];
+  match = content.match(FRONTMATTER_REGEX_ALT);
+  if (match)
+    return match[1];
+  return null;
+}
+
+// src/parser.ts
+var defaultOptions = {
+  gfm: true,
+  breaks: false,
+  headerIds: true,
+  headerPrefix: "",
+  pedantic: false,
+  smartLists: true,
+  smartypants: false,
+  sanitize: false
+};
+var CODE_NEWLINE = 10;
+var CODE_HASH = 35;
+var CODE_STAR = 42;
+var CODE_UNDERSCORE = 95;
+var CODE_BACKTICK = 96;
+var CODE_LBRACKET = 91;
+var CODE_BANG = 33;
+var CODE_TILDE = 126;
+var CODE_PIPE = 124;
+var CODE_GT = 62;
+var CODE_MINUS = 45;
+var CODE_PLUS = 43;
+var CODE_SPACE = 32;
+function isAlphanumeric(code) {
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function parse3(markdown, options = {}) {
+  const opts = { ...defaultOptions, ...options };
+  const state = {
+    src: markdown.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`),
+    pos: 0,
+    posMax: markdown.length,
+    tokens: [],
+    pending: "",
+    level: 0,
+    options: opts,
+    cache: {},
+    delimiters: []
+  };
+  parseBlocks(state);
+  return renderTokens(state.tokens, opts);
+}
+function parseSync(markdown, options = {}) {
+  return parse3(markdown, options);
+}
+function parseBlocks(state) {
+  while (state.pos < state.posMax) {
+    const char = state.src.charCodeAt(state.pos);
+    if (char === CODE_NEWLINE) {
+      state.pos++;
+      continue;
+    }
+    if (char === CODE_HASH && isStartOfLine(state)) {
+      if (parseHeading(state))
+        continue;
+    }
+    if (char === CODE_BACKTICK && lookAhead(state, "```")) {
+      if (parseCodeBlock(state))
+        continue;
+    }
+    if ((char === CODE_STAR || char === CODE_MINUS || char === CODE_UNDERSCORE) && isStartOfLine(state)) {
+      if (parseHR(state))
+        continue;
+    }
+    if (char === CODE_GT && isStartOfLine(state)) {
+      if (parseBlockquote(state))
+        continue;
+    }
+    if (isListMarker(char) && isStartOfLine(state)) {
+      if (parseList(state))
+        continue;
+    }
+    if (state.options.gfm && char === CODE_PIPE && isStartOfLine(state)) {
+      if (parseTable(state))
+        continue;
+    }
+    if (parseParagraph(state))
+      continue;
+    state.pos++;
+  }
+  if (state.pending) {
+    pushPending(state);
+  }
+}
+function isStartOfLine(state) {
+  return state.pos === 0 || state.src.charCodeAt(state.pos - 1) === CODE_NEWLINE;
+}
+function lookAhead(state, str) {
+  return state.src.slice(state.pos, state.pos + str.length) === str;
+}
+function isListMarker(char) {
+  return char === CODE_STAR || char === CODE_MINUS || char === CODE_PLUS || char >= 48 && char <= 57;
+}
+function pushPending(state) {
+  if (!state.pending)
+    return;
+  state.tokens.push({
+    type: "text",
+    content: state.pending,
+    level: state.level
+  });
+  state.pending = "";
+}
+function pushToken(state, type, tag, nesting) {
+  pushPending(state);
+  if (nesting < 0)
+    state.level--;
+  const token = {
+    type,
+    tag,
+    nesting,
+    level: state.level
+  };
+  if (nesting > 0)
+    state.level++;
+  state.tokens.push(token);
+  return token;
+}
+function parseHeading(state) {
+  const start = state.pos;
+  let level = 0;
+  while (state.pos < state.posMax && state.src.charCodeAt(state.pos) === CODE_HASH && level < 6) {
+    level++;
+    state.pos++;
+  }
+  if (level === 0 || state.pos >= state.posMax || state.src.charCodeAt(state.pos) !== CODE_SPACE) {
+    state.pos = start;
+    return false;
+  }
+  state.pos++;
+  const textStart = state.pos;
+  let textEnd = state.pos;
+  while (textEnd < state.posMax && state.src.charCodeAt(textEnd) !== CODE_NEWLINE) {
+    textEnd++;
+  }
+  const content = state.src.slice(textStart, textEnd).trim();
+  const token = pushToken(state, "heading_open", `h${level}`, 1);
+  if (state.options.headerIds) {
+    token.markup = `${state.options.headerPrefix}${slugify(content)}`;
+  }
+  parseInline(state, content);
+  pushToken(state, "heading_close", `h${level}`, -1);
+  state.pos = textEnd + 1;
+  return true;
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim();
+}
+function parseCodeBlock(state) {
+  const start = state.pos;
+  state.pos += 3;
+  const langStart = state.pos;
+  while (state.pos < state.posMax && state.src.charCodeAt(state.pos) !== CODE_NEWLINE) {
+    state.pos++;
+  }
+  const lang = state.src.slice(langStart, state.pos).trim();
+  state.pos++;
+  const codeStart = state.pos;
+  if (state.src.slice(state.pos, state.pos + 3) === "```") {
+    const token2 = pushToken(state, "fence", "code", 0);
+    token2.content = "";
+    token2.markup = lang;
+    state.pos += 3;
+    return true;
+  }
+  const closing = state.src.indexOf("\n```", state.pos);
+  if (closing === -1) {
+    state.pos = start;
+    return false;
+  }
+  const code = state.src.slice(codeStart, closing);
+  const token = pushToken(state, "fence", "code", 0);
+  token.content = code;
+  token.markup = lang;
+  state.pos = closing + 4;
+  return true;
+}
+function parseHR(state) {
+  const start = state.pos;
+  const marker = state.src.charCodeAt(state.pos);
+  let count = 0;
+  while (state.pos < state.posMax) {
+    const char = state.src.charCodeAt(state.pos);
+    if (char === marker)
+      count++;
+    else if (char !== CODE_SPACE && char !== CODE_NEWLINE)
+      break;
+    state.pos++;
+    if (char === CODE_NEWLINE)
+      break;
+  }
+  if (count >= 3) {
+    pushToken(state, "hr", "hr", 0);
+    return true;
+  }
+  state.pos = start;
+  return false;
+}
+function parseBlockquote(state) {
+  pushToken(state, "blockquote_open", "blockquote", 1);
+  while (state.pos < state.posMax && state.src.charCodeAt(state.pos) === CODE_GT) {
+    state.pos++;
+    if (state.src.charCodeAt(state.pos) === CODE_SPACE)
+      state.pos++;
+    const lineStart = state.pos;
+    let lineEnd = state.pos;
+    while (lineEnd < state.posMax && state.src.charCodeAt(lineEnd) !== CODE_NEWLINE) {
+      lineEnd++;
+    }
+    const content = state.src.slice(lineStart, lineEnd).trim();
+    if (content) {
+      pushToken(state, "paragraph_open", "p", 1);
+      parseInline(state, content);
+      pushToken(state, "paragraph_close", "p", -1);
+    }
+    state.pos = lineEnd + 1;
+  }
+  pushToken(state, "blockquote_close", "blockquote", -1);
+  return true;
+}
+function parseList(state) {
+  const firstChar = state.src.charCodeAt(state.pos);
+  const isOrdered = firstChar >= 48 && firstChar <= 57;
+  if (!isOrdered) {
+    const nextChar = state.src.charCodeAt(state.pos + 1);
+    if (nextChar === firstChar || nextChar !== CODE_SPACE) {
+      return false;
+    }
+  }
+  pushToken(state, isOrdered ? "ordered_list_open" : "bullet_list_open", isOrdered ? "ol" : "ul", 1);
+  while (state.pos < state.posMax) {
+    const char = state.src.charCodeAt(state.pos);
+    if (isOrdered) {
+      let num = 0;
+      while (state.src.charCodeAt(state.pos) >= 48 && state.src.charCodeAt(state.pos) <= 57) {
+        state.pos++;
+        num++;
+      }
+      if (num === 0 || state.src.charCodeAt(state.pos) !== 46)
+        break;
+      state.pos++;
+    } else {
+      if (char !== CODE_STAR && char !== CODE_MINUS && char !== CODE_PLUS)
+        break;
+      if (state.src.charCodeAt(state.pos + 1) === char)
+        break;
+      state.pos++;
+    }
+    if (state.src.charCodeAt(state.pos) !== CODE_SPACE)
+      break;
+    state.pos++;
+    const itemStart = state.pos;
+    let itemEnd = state.pos;
+    while (itemEnd < state.posMax && state.src.charCodeAt(itemEnd) !== CODE_NEWLINE) {
+      itemEnd++;
+    }
+    let content = state.src.slice(itemStart, itemEnd).trim();
+    const taskMatch = content.match(/^\[([ x])\]\s+(.+)/i);
+    if (taskMatch) {
+      const checked = taskMatch[1].toLowerCase() === "x";
+      content = taskMatch[2];
+      const token = pushToken(state, "list_item_open", "li", 1);
+      token.markup = checked ? "checked" : "unchecked";
+      parseInline(state, content);
+      pushToken(state, "list_item_close", "li", -1);
+    } else {
+      pushToken(state, "list_item_open", "li", 1);
+      parseInline(state, content);
+      pushToken(state, "list_item_close", "li", -1);
+    }
+    state.pos = itemEnd + 1;
+    const nextChar = state.src.charCodeAt(state.pos);
+    if (!isListMarker(nextChar))
+      break;
+  }
+  pushToken(state, isOrdered ? "ordered_list_close" : "bullet_list_close", isOrdered ? "ol" : "ul", -1);
+  return true;
+}
+function splitTableCells(line) {
+  const cells = [];
+  let current = "";
+  let inCode = false;
+  let escaped = false;
+  for (let i = 0;i < line.length; i++) {
+    const char = line[i];
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      current += char;
+      escaped = true;
+      continue;
+    }
+    if (char === "`") {
+      inCode = !inCode;
+      current += char;
+      continue;
+    }
+    if (char === "|" && !inCode) {
+      cells.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current || cells.length > 0) {
+    cells.push(current.trim());
+  }
+  return cells.slice(1, -1);
+}
+function parseTable(state) {
+  const start = state.pos;
+  let lineEnd = state.pos;
+  while (lineEnd < state.posMax && state.src.charCodeAt(lineEnd) !== CODE_NEWLINE) {
+    lineEnd++;
+  }
+  const headerLine = state.src.slice(state.pos, lineEnd);
+  if (!headerLine.startsWith("|") || !headerLine.trim().endsWith("|")) {
+    return false;
+  }
+  state.pos = lineEnd + 1;
+  lineEnd = state.pos;
+  while (lineEnd < state.posMax && state.src.charCodeAt(lineEnd) !== CODE_NEWLINE) {
+    lineEnd++;
+  }
+  const alignLine = state.src.slice(state.pos, lineEnd);
+  if (!/^\|(?:\s*:?-+:?\s*\|)+$/.test(alignLine.trim())) {
+    state.pos = start;
+    return false;
+  }
+  const alignCells = alignLine.split("|").slice(1, -1);
+  const align = alignCells.map((cell) => {
+    const trimmed = cell.trim();
+    if (trimmed.startsWith(":") && trimmed.endsWith(":"))
+      return "center";
+    if (trimmed.endsWith(":"))
+      return "right";
+    if (trimmed.startsWith(":"))
+      return "left";
+    return null;
+  });
+  state.pos = lineEnd + 1;
+  const headerCells = splitTableCells(headerLine);
+  pushToken(state, "table_open", "table", 1);
+  pushToken(state, "thead_open", "thead", 1);
+  pushToken(state, "tr_open", "tr", 1);
+  for (let i = 0;i < headerCells.length; i++) {
+    const token = pushToken(state, "th_open", "th", 1);
+    if (align[i]) {
+      token.markup = align[i] ?? undefined;
+    }
+    parseInline(state, headerCells[i]);
+    pushToken(state, "th_close", "th", -1);
+  }
+  pushToken(state, "tr_close", "tr", -1);
+  pushToken(state, "thead_close", "thead", -1);
+  pushToken(state, "tbody_open", "tbody", 1);
+  while (state.pos < state.posMax) {
+    lineEnd = state.pos;
+    while (lineEnd < state.posMax && state.src.charCodeAt(lineEnd) !== CODE_NEWLINE) {
+      lineEnd++;
+    }
+    const rowLine = state.src.slice(state.pos, lineEnd).trim();
+    if (!rowLine.startsWith("|") || !rowLine.endsWith("|")) {
+      break;
+    }
+    const cells = splitTableCells(rowLine);
+    pushToken(state, "tr_open", "tr", 1);
+    for (let i = 0;i < cells.length; i++) {
+      const token = pushToken(state, "td_open", "td", 1);
+      if (align[i]) {
+        token.markup = align[i] ?? undefined;
+      }
+      parseInline(state, cells[i]);
+      pushToken(state, "td_close", "td", -1);
+    }
+    pushToken(state, "tr_close", "tr", -1);
+    state.pos = lineEnd + 1;
+  }
+  pushToken(state, "tbody_close", "tbody", -1);
+  pushToken(state, "table_close", "table", -1);
+  return true;
+}
+function parseParagraph(state) {
+  const start = state.pos;
+  let end = state.pos;
+  while (end < state.posMax) {
+    if (state.src.charCodeAt(end) === CODE_NEWLINE) {
+      if (end + 1 < state.posMax && state.src.charCodeAt(end + 1) === CODE_NEWLINE) {
+        break;
+      }
+    }
+    end++;
+  }
+  const content = state.src.slice(start, end).trim();
+  if (!content) {
+    state.pos = end + 1;
+    return false;
+  }
+  pushToken(state, "paragraph_open", "p", 1);
+  parseInline(state, content);
+  pushToken(state, "paragraph_close", "p", -1);
+  state.pos = end + 1;
+  return true;
+}
+function parseInline(state, content) {
+  const savedSrc = state.src;
+  const savedPos = state.pos;
+  const savedPosMax = state.posMax;
+  state.src = content;
+  state.pos = 0;
+  state.posMax = content.length;
+  while (state.pos < state.posMax) {
+    const char = state.src.charCodeAt(state.pos);
+    if ((char === CODE_STAR || char === CODE_UNDERSCORE) && state.src.charCodeAt(state.pos + 1) === char) {
+      if (scanStrong(state, char))
+        continue;
+    }
+    if (char === CODE_STAR || char === CODE_UNDERSCORE) {
+      if (scanEmphasisDirect(state, char))
+        continue;
+    }
+    if (char === CODE_BACKTICK) {
+      if (scanCode(state))
+        continue;
+    }
+    if (char === CODE_LBRACKET) {
+      if (scanLink(state))
+        continue;
+    }
+    if (char === CODE_BANG && state.src.charCodeAt(state.pos + 1) === CODE_LBRACKET) {
+      if (scanImage(state))
+        continue;
+    }
+    if (state.options.gfm && char === CODE_TILDE && state.src.charCodeAt(state.pos + 1) === CODE_TILDE) {
+      if (scanStrikethrough(state))
+        continue;
+    }
+    if (state.options.breaks && char === CODE_NEWLINE) {
+      pushPending(state);
+      pushToken(state, "br", "br", 0);
+      state.pos++;
+      continue;
+    }
+    state.pending += state.src[state.pos];
+    state.pos++;
+  }
+  if (state.pending)
+    pushPending(state);
+  state.src = savedSrc;
+  state.pos = savedPos;
+  state.posMax = savedPosMax;
+}
+function scanStrong(state, marker) {
+  const start = state.pos;
+  const markerStr = String.fromCharCode(marker);
+  const searchStart = start + 2;
+  if (marker === 95) {
+    const prevChar = start > 0 ? state.src.charCodeAt(start - 1) : 0;
+    if (isAlphanumeric(prevChar) || prevChar === 95) {
+      return false;
+    }
+  }
+  const closePos = state.src.indexOf(markerStr + markerStr, searchStart);
+  if (closePos === -1) {
+    return false;
+  }
+  if (marker === 95) {
+    const nextChar = closePos + 2 < state.posMax ? state.src.charCodeAt(closePos + 2) : 0;
+    if (isAlphanumeric(nextChar) || nextChar === 95) {
+      return false;
+    }
+  }
+  pushPending(state);
+  const text = state.src.substring(searchStart, closePos);
+  pushToken(state, "strong_open", "strong", 1);
+  parseInline(state, text);
+  pushToken(state, "strong_close", "strong", -1);
+  state.pos = closePos + 2;
+  return true;
+}
+function scanEmphasisDirect(state, marker) {
+  const start = state.pos;
+  const markerStr = String.fromCharCode(marker);
+  const searchStart = start + 1;
+  if (marker === 95) {
+    const prevChar = start > 0 ? state.src.charCodeAt(start - 1) : 0;
+    if (isAlphanumeric(prevChar) || prevChar === 95) {
+      return false;
+    }
+  }
+  let closePos = state.src.indexOf(markerStr, searchStart);
+  while (closePos !== -1) {
+    if (state.src.charCodeAt(closePos + 1) === marker) {
+      closePos = state.src.indexOf(markerStr, closePos + 2);
+      continue;
+    }
+    if (marker === 95) {
+      const nextChar = closePos + 1 < state.posMax ? state.src.charCodeAt(closePos + 1) : 0;
+      if (isAlphanumeric(nextChar) || nextChar === 95) {
+        closePos = state.src.indexOf(markerStr, closePos + 1);
+        continue;
+      }
+    }
+    break;
+  }
+  if (closePos === -1 || closePos === searchStart) {
+    return false;
+  }
+  pushPending(state);
+  const text = state.src.substring(searchStart, closePos);
+  pushToken(state, "em_open", "em", 1);
+  parseInline(state, text);
+  pushToken(state, "em_close", "em", -1);
+  state.pos = closePos + 1;
+  return true;
+}
+function scanCode(state) {
+  const start = state.pos;
+  state.pos++;
+  const codeStart = state.pos;
+  const closeIdx = state.src.indexOf("`", state.pos);
+  if (closeIdx === -1) {
+    state.pos = start;
+    return false;
+  }
+  const code = state.src.slice(codeStart, closeIdx);
+  pushToken(state, "code_inline", "code", 0).content = code;
+  state.pos = closeIdx + 1;
+  return true;
+}
+function scanLink(state) {
+  const start = state.pos;
+  state.pos++;
+  const textStart = state.pos;
+  const textEnd = state.src.indexOf("]", state.pos);
+  if (textEnd === -1) {
+    state.pos = start;
+    return false;
+  }
+  if (state.src.charCodeAt(textEnd + 1) !== 40) {
+    state.pos = start;
+    return false;
+  }
+  const urlStart = textEnd + 2;
+  const urlEnd = state.src.indexOf(")", urlStart);
+  if (urlEnd === -1) {
+    state.pos = start;
+    return false;
+  }
+  pushPending(state);
+  const text = state.src.slice(textStart, textEnd);
+  const urlPart = state.src.slice(urlStart, urlEnd);
+  let url = urlPart;
+  let title = "";
+  const titleMatch = urlPart.match(/^(.*?)\s+["'](.*)["']$/);
+  if (titleMatch) {
+    url = titleMatch[1];
+    title = titleMatch[2];
+  }
+  const token = pushToken(state, "link_open", "a", 1);
+  token.markup = url;
+  if (title) {
+    token.content = title;
+  }
+  parseInline(state, text);
+  pushToken(state, "link_close", "a", -1);
+  state.pos = urlEnd + 1;
+  return true;
+}
+function scanImage(state) {
+  const start = state.pos;
+  state.pos += 2;
+  const altStart = state.pos;
+  const altEnd = state.src.indexOf("]", state.pos);
+  if (altEnd === -1) {
+    state.pos = start;
+    return false;
+  }
+  if (state.src.charCodeAt(altEnd + 1) !== 40) {
+    state.pos = start;
+    return false;
+  }
+  const urlStart = altEnd + 2;
+  const urlEnd = state.src.indexOf(")", urlStart);
+  if (urlEnd === -1) {
+    state.pos = start;
+    return false;
+  }
+  const alt = state.src.slice(altStart, altEnd);
+  const urlPart = state.src.slice(urlStart, urlEnd);
+  let url = urlPart;
+  let title = "";
+  const titleMatch = urlPart.match(/^(.*?)\s+["'](.*)["']$/);
+  if (titleMatch) {
+    url = titleMatch[1];
+    title = titleMatch[2];
+  }
+  pushToken(state, "image", "img", 0).markup = `${alt}|${url}|${title}`;
+  state.pos = urlEnd + 1;
+  return true;
+}
+function scanStrikethrough(state) {
+  const start = state.pos;
+  state.pos += 2;
+  const textStart = state.pos;
+  const closeIdx = state.src.indexOf("~~", state.pos);
+  if (closeIdx === -1) {
+    state.pos = start;
+    return false;
+  }
+  pushPending(state);
+  const text = state.src.slice(textStart, closeIdx);
+  pushToken(state, "del_open", "del", 1);
+  parseInline(state, text);
+  pushToken(state, "del_close", "del", -1);
+  state.pos = closeIdx + 2;
+  return true;
+}
+function renderTokens(tokens, options) {
+  let html = "";
+  for (const token of tokens) {
+    switch (token.type) {
+      case "heading_open":
+        if (token.markup) {
+          html += `<${token.tag} id="${token.markup}">`;
+        } else {
+          html += `<${token.tag}>`;
+        }
+        break;
+      case "heading_close":
+        html += `</${token.tag}>
+`;
+        break;
+      case "paragraph_open":
+        html += "<p>";
+        break;
+      case "paragraph_close":
+        html += `</p>
+`;
+        break;
+      case "fence":
+      case "code_block": {
+        let code = token.content || "";
+        const lang = token.markup || "";
+        if (options.highlight && lang) {
+          code = options.highlight(code, lang);
+        } else {
+          code = escapeHtml(code);
+        }
+        if (lang) {
+          html += `<pre><code class="language-${lang}">${code}</code></pre>
+`;
+        } else {
+          html += `<pre><code>${code}</code></pre>
+`;
+        }
+        break;
+      }
+      case "code_inline":
+        html += `<code>${escapeHtml(token.content || "")}</code>`;
+        break;
+      case "hr":
+        html += `<hr>
+`;
+        break;
+      case "blockquote_open":
+        html += `<blockquote>
+`;
+        break;
+      case "blockquote_close":
+        html += `</blockquote>
+`;
+        break;
+      case "bullet_list_open":
+        html += `<ul>
+`;
+        break;
+      case "bullet_list_close":
+        html += `</ul>
+`;
+        break;
+      case "ordered_list_open":
+        html += `<ol>
+`;
+        break;
+      case "ordered_list_close":
+        html += `</ol>
+`;
+        break;
+      case "list_item_open":
+        html += "<li>";
+        if (token.markup === "checked") {
+          html += '<input type="checkbox" checked disabled> ';
+        } else if (token.markup === "unchecked") {
+          html += '<input type="checkbox" disabled> ';
+        }
+        break;
+      case "list_item_close":
+        html += `</li>
+`;
+        break;
+      case "table_open":
+        html += `<table>
+`;
+        break;
+      case "table_close":
+        html += `</table>
+`;
+        break;
+      case "thead_open":
+        html += `<thead>
+`;
+        break;
+      case "thead_close":
+        html += `</thead>
+`;
+        break;
+      case "tbody_open":
+        html += `<tbody>
+`;
+        break;
+      case "tbody_close":
+        html += `</tbody>
+`;
+        break;
+      case "tr_open":
+        html += `<tr>
+`;
+        break;
+      case "tr_close":
+        html += `</tr>
+`;
+        break;
+      case "th_open":
+        if (token.markup) {
+          html += `<th align="${token.markup}">`;
+        } else {
+          html += "<th>";
+        }
+        break;
+      case "th_close":
+        html += `</th>
+`;
+        break;
+      case "td_open":
+        if (token.markup) {
+          html += `<td align="${token.markup}">`;
+        } else {
+          html += "<td>";
+        }
+        break;
+      case "td_close":
+        html += `</td>
+`;
+        break;
+      case "strong_open":
+        html += "<strong>";
+        break;
+      case "strong_close":
+        html += "</strong>";
+        break;
+      case "em_open":
+        html += "<em>";
+        break;
+      case "em_close":
+        html += "</em>";
+        break;
+      case "del_open":
+        html += "<del>";
+        break;
+      case "del_close":
+        html += "</del>";
+        break;
+      case "br":
+        html += "<br>";
+        break;
+      case "link_open":
+        if (token.content) {
+          html += `<a href="${escapeHtml(token.markup || "")}" title="${escapeHtml(token.content)}">`;
+        } else {
+          html += `<a href="${escapeHtml(token.markup || "")}">`;
+        }
+        break;
+      case "link_close":
+        html += "</a>";
+        break;
+      case "image": {
+        const [alt, url, imageTitle] = (token.markup || "||").split("|");
+        if (imageTitle) {
+          html += `<img src="${escapeHtml(url)}" alt="${escapeHtml(alt)}" title="${escapeHtml(imageTitle)}">`;
+        } else {
+          html += `<img src="${escapeHtml(url)}" alt="${escapeHtml(alt)}">`;
+        }
+        break;
+      }
+      case "text":
+        html += escapeHtml(token.content || "");
+        break;
+    }
+  }
+  return html;
+}
+var CHAR_AMP = 38;
+var CHAR_LT = 60;
+var CHAR_GT = 62;
+var CHAR_QUOT = 34;
+var CHAR_APOS = 39;
+function escapeHtml(text) {
+  const len = text.length;
+  let lastPos = 0;
+  let needsEscape = false;
+  for (let i = 0;i < len; i++) {
+    const code = text.charCodeAt(i);
+    if (code === CHAR_AMP || code === CHAR_LT || code === CHAR_GT || code === CHAR_QUOT || code === CHAR_APOS) {
+      needsEscape = true;
+      break;
+    }
+  }
+  if (!needsEscape)
+    return text;
+  const parts = [];
+  for (let i = 0;i < len; i++) {
+    const code = text.charCodeAt(i);
+    let replacement = null;
+    switch (code) {
+      case CHAR_AMP:
+        replacement = "&amp;";
+        break;
+      case CHAR_LT:
+        replacement = "&lt;";
+        break;
+      case CHAR_GT:
+        replacement = "&gt;";
+        break;
+      case CHAR_QUOT:
+        replacement = "&quot;";
+        break;
+      case CHAR_APOS:
+        replacement = "&#39;";
+        break;
+    }
+    if (replacement) {
+      if (i > lastPos) {
+        parts.push(text.substring(lastPos, i));
+      }
+      parts.push(replacement);
+      lastPos = i + 1;
+    }
+  }
+  if (lastPos < len) {
+    parts.push(text.substring(lastPos));
+  }
+  return parts.join("");
+}
+
+// src/index.ts
+function parseMarkdownWithFrontmatter(content, options) {
+  const { data, content: markdown } = parse2(content);
+  const html = parse3(markdown, options);
+  return {
+    data,
+    content: markdown,
+    html
+  };
+}
+var markdownParser = {
+  parseFrontmatter: parse2,
+  parseMarkdown: parse3,
+  parseMarkdownWithFrontmatter
+};
+var src_default = markdownParser;
+export {
+  exports_yaml as yaml,
+  stringify as stringifyYaml,
+  stringify2 as stringifyFrontmatter,
+  parse as parseYaml,
+  parseSync,
+  parseMarkdownWithFrontmatter,
+  parseSync as parseMarkdownSync,
+  parse3 as parseMarkdown,
+  parse2 as parseFrontmatter,
+  parse3 as parse,
+  exports_frontmatter as frontmatter,
+  src_default as default
+};
+
+//# debugId=4EC4EE35429AE4D764756E2164756E21