@crustjs/style 0.0.1

package/dist/index.js

@@ -0,0 +1,721 @@
+// @bun
+// src/ansiCodes.ts
+function pair(open, close) {
+  return { open: `\x1B[${open}m`, close: `\x1B[${close}m` };
+}
+var reset = pair(0, 0);
+var bold = pair(1, 22);
+var dim = pair(2, 22);
+var italic = pair(3, 23);
+var underline = pair(4, 24);
+var inverse = pair(7, 27);
+var hidden = pair(8, 28);
+var strikethrough = pair(9, 29);
+var black = pair(30, 39);
+var red = pair(31, 39);
+var green = pair(32, 39);
+var yellow = pair(33, 39);
+var blue = pair(34, 39);
+var magenta = pair(35, 39);
+var cyan = pair(36, 39);
+var white = pair(37, 39);
+var gray = pair(90, 39);
+var brightRed = pair(91, 39);
+var brightGreen = pair(92, 39);
+var brightYellow = pair(93, 39);
+var brightBlue = pair(94, 39);
+var brightMagenta = pair(95, 39);
+var brightCyan = pair(96, 39);
+var brightWhite = pair(97, 39);
+var bgBlack = pair(40, 49);
+var bgRed = pair(41, 49);
+var bgGreen = pair(42, 49);
+var bgYellow = pair(43, 49);
+var bgBlue = pair(44, 49);
+var bgMagenta = pair(45, 49);
+var bgCyan = pair(46, 49);
+var bgWhite = pair(47, 49);
+var bgBrightBlack = pair(100, 49);
+var bgBrightRed = pair(101, 49);
+var bgBrightGreen = pair(102, 49);
+var bgBrightYellow = pair(103, 49);
+var bgBrightBlue = pair(104, 49);
+var bgBrightMagenta = pair(105, 49);
+var bgBrightCyan = pair(106, 49);
+var bgBrightWhite = pair(107, 49);
+// src/text/stripAnsi.ts
+var ANSI_REGEX = /[\x1b\x9b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><~]/g;
+function stripAnsi(text) {
+  return text.replace(ANSI_REGEX, "");
+}
+
+// src/text/width.ts
+function isFullWidth(codePoint) {
+  return codePoint >= 19968 && codePoint <= 40959 || codePoint >= 13312 && codePoint <= 19903 || codePoint >= 131072 && codePoint <= 173791 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65281 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 11904 && codePoint <= 12031 || codePoint >= 12032 && codePoint <= 12255 || codePoint >= 12288 && codePoint <= 12351 || codePoint >= 12352 && codePoint <= 12447 || codePoint >= 12448 && codePoint <= 12543 || codePoint >= 12544 && codePoint <= 12591 || codePoint >= 12592 && codePoint <= 12687 || codePoint >= 12800 && codePoint <= 13055 || codePoint >= 13056 && codePoint <= 13311 || codePoint >= 44032 && codePoint <= 55215 || codePoint >= 65072 && codePoint <= 65103;
+}
+function visibleWidth(text) {
+  const plain = stripAnsi(text);
+  let width = 0;
+  for (const char of plain) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint === undefined) {
+      continue;
+    }
+    width += isFullWidth(codePoint) ? 2 : 1;
+  }
+  return width;
+}
+
+// src/blocks/lists.ts
+function indentMultiline(text, contentIndent) {
+  const lines = text.split(`
+`);
+  if (lines.length <= 1) {
+    return text;
+  }
+  const padding = " ".repeat(contentIndent);
+  return lines.map((line, idx) => idx === 0 ? line : padding + line).join(`
+`);
+}
+function unorderedList(items, options) {
+  const marker = options?.marker ?? "\u2022";
+  const markerGap = options?.markerGap ?? 1;
+  const indent = options?.indent ?? 0;
+  const prefix = " ".repeat(indent);
+  const gap = " ".repeat(markerGap);
+  const markerWidth = visibleWidth(marker);
+  const contentIndent = indent + markerWidth + markerGap;
+  return items.map((item) => {
+    const adjusted = indentMultiline(item, contentIndent);
+    return `${prefix}${marker}${gap}${adjusted}`;
+  }).join(`
+`);
+}
+function orderedList(items, options) {
+  const start = options?.start ?? 1;
+  const markerGap = options?.markerGap ?? 1;
+  const indent = options?.indent ?? 0;
+  if (items.length === 0) {
+    return "";
+  }
+  const prefix = " ".repeat(indent);
+  const gap = " ".repeat(markerGap);
+  const lastIndex = start + items.length - 1;
+  const maxMarkerWidth = `${lastIndex}.`.length;
+  return items.map((item, idx) => {
+    const index = start + idx;
+    const markerText = `${index}.`;
+    const paddedMarker = markerText.padStart(maxMarkerWidth, " ");
+    const contentIndent = indent + maxMarkerWidth + markerGap;
+    const adjusted = indentMultiline(item, contentIndent);
+    return `${prefix}${paddedMarker}${gap}${adjusted}`;
+  }).join(`
+`);
+}
+function taskList(items, options) {
+  const checkedMarker = options?.checkedMarker ?? "[x]";
+  const uncheckedMarker = options?.uncheckedMarker ?? "[ ]";
+  const markerGap = options?.markerGap ?? 1;
+  const indent = options?.indent ?? 0;
+  const prefix = " ".repeat(indent);
+  const gap = " ".repeat(markerGap);
+  const markerWidth = Math.max(visibleWidth(checkedMarker), visibleWidth(uncheckedMarker));
+  const contentIndent = indent + markerWidth + markerGap;
+  return items.map((item) => {
+    const marker = item.checked ? checkedMarker : uncheckedMarker;
+    const adjusted = indentMultiline(item.text, contentIndent);
+    return `${prefix}${marker}${gap}${adjusted}`;
+  }).join(`
+`);
+}
+// src/text/pad.ts
+function padStart(text, width, fillChar = " ") {
+  const currentWidth = visibleWidth(text);
+  if (currentWidth >= width) {
+    return text;
+  }
+  const padding = fillChar.repeat(width - currentWidth);
+  return padding + text;
+}
+function padEnd(text, width, fillChar = " ") {
+  const currentWidth = visibleWidth(text);
+  if (currentWidth >= width) {
+    return text;
+  }
+  const padding = fillChar.repeat(width - currentWidth);
+  return text + padding;
+}
+function center(text, width, fillChar = " ") {
+  const currentWidth = visibleWidth(text);
+  if (currentWidth >= width) {
+    return text;
+  }
+  const totalPadding = width - currentWidth;
+  const leftPadding = Math.floor(totalPadding / 2);
+  const rightPadding = totalPadding - leftPadding;
+  return fillChar.repeat(leftPadding) + text + fillChar.repeat(rightPadding);
+}
+
+// src/blocks/tables.ts
+function computeColumnWidths(headers, rows, minWidth) {
+  const columnCount = headers.length;
+  const widths = new Array(columnCount).fill(minWidth);
+  for (let col = 0;col < columnCount; col++) {
+    const header = headers[col];
+    if (header !== undefined) {
+      widths[col] = Math.max(widths[col] ?? 0, visibleWidth(header));
+    }
+  }
+  for (const row of rows) {
+    for (let col = 0;col < columnCount; col++) {
+      const cell = row[col];
+      if (cell !== undefined) {
+        widths[col] = Math.max(widths[col] ?? 0, visibleWidth(cell));
+      }
+    }
+  }
+  return widths;
+}
+function alignCell(value, width, alignment) {
+  switch (alignment) {
+    case "right":
+      return padStart(value, width);
+    case "center":
+      return center(value, width);
+    default:
+      return padEnd(value, width);
+  }
+}
+function formatRow(cells, columnWidths, alignments, cellPadding, borderChar) {
+  const pad = " ".repeat(cellPadding);
+  const formattedCells = columnWidths.map((width, col) => {
+    const cell = cells[col] ?? "";
+    const alignment = alignments[col] ?? "left";
+    const aligned = alignCell(cell, width, alignment);
+    return `${pad}${aligned}${pad}`;
+  });
+  return `${borderChar}${formattedCells.join(borderChar)}${borderChar}`;
+}
+function formatSeparator(columnWidths, cellPadding, separatorChar, borderChar) {
+  const segments = columnWidths.map((width) => {
+    return separatorChar.repeat(width + cellPadding * 2);
+  });
+  return `${borderChar}${segments.join(borderChar)}${borderChar}`;
+}
+function table(headers, rows, options) {
+  const alignments = options?.align ?? [];
+  const minColumnWidth = options?.minColumnWidth ?? 0;
+  const cellPadding = options?.cellPadding ?? 1;
+  const separatorChar = options?.separatorChar ?? "-";
+  const borderChar = options?.borderChar ?? "|";
+  const columnWidths = computeColumnWidths(headers, rows, minColumnWidth);
+  const lines = [];
+  lines.push(formatRow(headers, columnWidths, alignments, cellPadding, borderChar));
+  lines.push(formatSeparator(columnWidths, cellPadding, separatorChar, borderChar));
+  for (const row of rows) {
+    lines.push(formatRow(row, columnWidths, alignments, cellPadding, borderChar));
+  }
+  return lines.join(`
+`);
+}
+// src/capability.ts
+function resolveCapability(mode, overrides) {
+  if (mode === "always") {
+    return true;
+  }
+  if (mode === "never") {
+    return false;
+  }
+  const isTTY = overrides?.isTTY ?? process.stdout?.isTTY ?? false;
+  const noColor = overrides?.noColor !== undefined ? overrides.noColor : process.env.NO_COLOR;
+  if (noColor !== undefined) {
+    return false;
+  }
+  return isTTY;
+}
+// src/styleEngine.ts
+function applyStyle(text, style) {
+  if (text === "") {
+    return "";
+  }
+  const { open, close } = style;
+  if (text.includes(close)) {
+    text = text.replaceAll(close, close + open);
+  }
+  return open + text + close;
+}
+function composeStyles(...styles) {
+  return {
+    open: styles.map((s) => s.open).join(""),
+    close: styles.map((s) => s.close).reverse().join("")
+  };
+}
+
+// src/colors.ts
+function black2(text) {
+  return applyStyle(text, black);
+}
+function red2(text) {
+  return applyStyle(text, red);
+}
+function green2(text) {
+  return applyStyle(text, green);
+}
+function yellow2(text) {
+  return applyStyle(text, yellow);
+}
+function blue2(text) {
+  return applyStyle(text, blue);
+}
+function magenta2(text) {
+  return applyStyle(text, magenta);
+}
+function cyan2(text) {
+  return applyStyle(text, cyan);
+}
+function white2(text) {
+  return applyStyle(text, white);
+}
+function gray2(text) {
+  return applyStyle(text, gray);
+}
+function brightRed2(text) {
+  return applyStyle(text, brightRed);
+}
+function brightGreen2(text) {
+  return applyStyle(text, brightGreen);
+}
+function brightYellow2(text) {
+  return applyStyle(text, brightYellow);
+}
+function brightBlue2(text) {
+  return applyStyle(text, brightBlue);
+}
+function brightMagenta2(text) {
+  return applyStyle(text, brightMagenta);
+}
+function brightCyan2(text) {
+  return applyStyle(text, brightCyan);
+}
+function brightWhite2(text) {
+  return applyStyle(text, brightWhite);
+}
+function bgBlack2(text) {
+  return applyStyle(text, bgBlack);
+}
+function bgRed2(text) {
+  return applyStyle(text, bgRed);
+}
+function bgGreen2(text) {
+  return applyStyle(text, bgGreen);
+}
+function bgYellow2(text) {
+  return applyStyle(text, bgYellow);
+}
+function bgBlue2(text) {
+  return applyStyle(text, bgBlue);
+}
+function bgMagenta2(text) {
+  return applyStyle(text, bgMagenta);
+}
+function bgCyan2(text) {
+  return applyStyle(text, bgCyan);
+}
+function bgWhite2(text) {
+  return applyStyle(text, bgWhite);
+}
+function bgBrightBlack2(text) {
+  return applyStyle(text, bgBrightBlack);
+}
+function bgBrightRed2(text) {
+  return applyStyle(text, bgBrightRed);
+}
+function bgBrightGreen2(text) {
+  return applyStyle(text, bgBrightGreen);
+}
+function bgBrightYellow2(text) {
+  return applyStyle(text, bgBrightYellow);
+}
+function bgBrightBlue2(text) {
+  return applyStyle(text, bgBrightBlue);
+}
+function bgBrightMagenta2(text) {
+  return applyStyle(text, bgBrightMagenta);
+}
+function bgBrightCyan2(text) {
+  return applyStyle(text, bgBrightCyan);
+}
+function bgBrightWhite2(text) {
+  return applyStyle(text, bgBrightWhite);
+}
+// src/createStyle.ts
+function makeStyleFn(pair2, enabled) {
+  if (enabled) {
+    return (text) => applyStyle(text, pair2);
+  }
+  return (text) => text;
+}
+function createStyle(options) {
+  const mode = options?.mode ?? "auto";
+  const enabled = resolveCapability(mode, options?.overrides);
+  const instance = {
+    enabled,
+    apply: enabled ? (text, pair2) => applyStyle(text, pair2) : (text, _pair) => text,
+    bold: makeStyleFn(bold, enabled),
+    dim: makeStyleFn(dim, enabled),
+    italic: makeStyleFn(italic, enabled),
+    underline: makeStyleFn(underline, enabled),
+    inverse: makeStyleFn(inverse, enabled),
+    hidden: makeStyleFn(hidden, enabled),
+    strikethrough: makeStyleFn(strikethrough, enabled),
+    black: makeStyleFn(black, enabled),
+    red: makeStyleFn(red, enabled),
+    green: makeStyleFn(green, enabled),
+    yellow: makeStyleFn(yellow, enabled),
+    blue: makeStyleFn(blue, enabled),
+    magenta: makeStyleFn(magenta, enabled),
+    cyan: makeStyleFn(cyan, enabled),
+    white: makeStyleFn(white, enabled),
+    gray: makeStyleFn(gray, enabled),
+    brightRed: makeStyleFn(brightRed, enabled),
+    brightGreen: makeStyleFn(brightGreen, enabled),
+    brightYellow: makeStyleFn(brightYellow, enabled),
+    brightBlue: makeStyleFn(brightBlue, enabled),
+    brightMagenta: makeStyleFn(brightMagenta, enabled),
+    brightCyan: makeStyleFn(brightCyan, enabled),
+    brightWhite: makeStyleFn(brightWhite, enabled),
+    bgBlack: makeStyleFn(bgBlack, enabled),
+    bgRed: makeStyleFn(bgRed, enabled),
+    bgGreen: makeStyleFn(bgGreen, enabled),
+    bgYellow: makeStyleFn(bgYellow, enabled),
+    bgBlue: makeStyleFn(bgBlue, enabled),
+    bgMagenta: makeStyleFn(bgMagenta, enabled),
+    bgCyan: makeStyleFn(bgCyan, enabled),
+    bgWhite: makeStyleFn(bgWhite, enabled),
+    bgBrightBlack: makeStyleFn(bgBrightBlack, enabled),
+    bgBrightRed: makeStyleFn(bgBrightRed, enabled),
+    bgBrightGreen: makeStyleFn(bgBrightGreen, enabled),
+    bgBrightYellow: makeStyleFn(bgBrightYellow, enabled),
+    bgBrightBlue: makeStyleFn(bgBrightBlue, enabled),
+    bgBrightMagenta: makeStyleFn(bgBrightMagenta, enabled),
+    bgBrightCyan: makeStyleFn(bgBrightCyan, enabled),
+    bgBrightWhite: makeStyleFn(bgBrightWhite, enabled)
+  };
+  return Object.freeze(instance);
+}
+var style = createStyle();
+// src/modifiers.ts
+function bold2(text) {
+  return applyStyle(text, bold);
+}
+function dim2(text) {
+  return applyStyle(text, dim);
+}
+function italic2(text) {
+  return applyStyle(text, italic);
+}
+function underline2(text) {
+  return applyStyle(text, underline);
+}
+function inverse2(text) {
+  return applyStyle(text, inverse);
+}
+function hidden2(text) {
+  return applyStyle(text, hidden);
+}
+function strikethrough2(text) {
+  return applyStyle(text, strikethrough);
+}
+// src/text/wrap.ts
+var ANSI_SEQUENCE = /[\x1b\x9b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><~]/;
+function isFullWidth2(codePoint) {
+  return codePoint >= 19968 && codePoint <= 40959 || codePoint >= 13312 && codePoint <= 19903 || codePoint >= 131072 && codePoint <= 173791 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65281 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 11904 && codePoint <= 12031 || codePoint >= 12032 && codePoint <= 12255 || codePoint >= 12288 && codePoint <= 12351 || codePoint >= 12352 && codePoint <= 12447 || codePoint >= 12448 && codePoint <= 12543 || codePoint >= 12544 && codePoint <= 12591 || codePoint >= 12592 && codePoint <= 12687 || codePoint >= 12800 && codePoint <= 13055 || codePoint >= 13056 && codePoint <= 13311 || codePoint >= 44032 && codePoint <= 55215 || codePoint >= 65072 && codePoint <= 65103;
+}
+function isReset(seq) {
+  return seq === "\x1B[0m";
+}
+function isSGR(seq) {
+  return seq.endsWith("m") && seq.startsWith("\x1B[");
+}
+function wrapText(text, width, options) {
+  if (width <= 0) {
+    return text;
+  }
+  const wordBreak = options?.wordBreak ?? true;
+  const inputLines = text.split(`
+`);
+  const resultLines = [];
+  let activeStyles = [];
+  for (const inputLine of inputLines) {
+    const wrapped = wrapLine(inputLine, width, wordBreak, activeStyles);
+    resultLines.push(...wrapped.lines);
+    activeStyles = wrapped.activeStyles;
+  }
+  return resultLines.join(`
+`);
+}
+function wrapLine(line, width, wordBreak, initialStyles) {
+  const activeStyles = [...initialStyles];
+  const lines = [];
+  let currentLine = activeStyles.length > 0 ? activeStyles.join("") : "";
+  let currentWidth = 0;
+  let lastSpaceIdx = -1;
+  let lastSpaceWidth = 0;
+  let lastSpaceStyleSnapshot = [];
+  let i = 0;
+  while (i < line.length) {
+    const ansiMatch = line.slice(i).match(ANSI_SEQUENCE);
+    if (ansiMatch && ansiMatch.index === 0) {
+      const seq = ansiMatch[0];
+      if (isSGR(seq)) {
+        if (isReset(seq)) {
+          activeStyles.length = 0;
+        } else {
+          activeStyles.push(seq);
+        }
+      }
+      currentLine += seq;
+      i += seq.length;
+      continue;
+    }
+    const char = line[i];
+    if (char === undefined) {
+      break;
+    }
+    const codePoint = char.codePointAt(0) ?? 0;
+    const charWidth = isFullWidth2(codePoint) ? 2 : 1;
+    if (currentWidth + charWidth > width) {
+      if (wordBreak && lastSpaceIdx !== -1) {
+        const beforeSpace = currentLine.slice(0, lastSpaceIdx);
+        const afterSpace = currentLine.slice(lastSpaceIdx + 1);
+        const closeSeq = activeStyles.length > 0 ? "\x1B[0m" : "";
+        lines.push(beforeSpace + closeSeq);
+        const reopenSeq = lastSpaceStyleSnapshot.length > 0 ? lastSpaceStyleSnapshot.join("") : "";
+        currentLine = reopenSeq + afterSpace;
+        currentWidth = currentWidth - lastSpaceWidth;
+        lastSpaceIdx = -1;
+        lastSpaceWidth = 0;
+        lastSpaceStyleSnapshot = [];
+        if (currentWidth + charWidth > width) {
+          const closeSeq2 = activeStyles.length > 0 ? "\x1B[0m" : "";
+          lines.push(currentLine + closeSeq2);
+          const reopenSeq2 = activeStyles.length > 0 ? activeStyles.join("") : "";
+          currentLine = reopenSeq2 + char;
+          currentWidth = charWidth;
+        } else {
+          currentLine += char;
+          currentWidth += charWidth;
+        }
+      } else {
+        const closeSeq = activeStyles.length > 0 ? "\x1B[0m" : "";
+        lines.push(currentLine + closeSeq);
+        const reopenSeq = activeStyles.length > 0 ? activeStyles.join("") : "";
+        currentLine = reopenSeq + char;
+        currentWidth = charWidth;
+        lastSpaceIdx = -1;
+        lastSpaceWidth = 0;
+        lastSpaceStyleSnapshot = [];
+      }
+    } else {
+      if (wordBreak && char === " ") {
+        currentLine += char;
+        currentWidth += charWidth;
+        lastSpaceIdx = currentLine.length - 1;
+        lastSpaceWidth = currentWidth;
+        lastSpaceStyleSnapshot = [...activeStyles];
+      } else {
+        currentLine += char;
+        currentWidth += charWidth;
+      }
+    }
+    i += char.length;
+  }
+  if (currentLine.length > 0) {
+    const hasVisibleContent = currentLine.replace(/[\x1b\x9b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><~]/g, "");
+    if (hasVisibleContent.length > 0 || currentLine.length > 0) {
+      lines.push(currentLine);
+    }
+  } else {
+    lines.push("");
+  }
+  return { lines, activeStyles };
+}
+// src/theme/markdownTheme.ts
+function buildDefaultMarkdownTheme(s) {
+  const theme = {
+    heading1: (value) => s.bold(s.underline(value)),
+    heading2: (value) => s.bold(value),
+    heading3: (value) => s.bold(s.yellow(value)),
+    heading4: (value) => s.yellow(value),
+    heading5: (value) => s.dim(s.yellow(value)),
+    heading6: (value) => s.dim(value),
+    text: (value) => value,
+    emphasis: (value) => s.italic(value),
+    strong: (value) => s.bold(value),
+    strongEmphasis: (value) => s.bold(s.italic(value)),
+    strikethrough: (value) => s.strikethrough(value),
+    inlineCode: (value) => s.cyan(value),
+    linkText: (value) => s.blue(s.underline(value)),
+    linkUrl: (value) => s.dim(s.underline(value)),
+    autolink: (value) => s.blue(s.underline(value)),
+    blockquoteMarker: (value) => s.dim(s.green(value)),
+    blockquoteText: (value) => s.italic(value),
+    listMarker: (value) => s.dim(value),
+    orderedListMarker: (value) => s.dim(value),
+    taskChecked: (value) => s.green(value),
+    taskUnchecked: (value) => s.dim(value),
+    codeFence: (value) => s.dim(value),
+    codeInfo: (value) => s.dim(s.italic(value)),
+    codeText: (value) => s.cyan(value),
+    thematicBreak: (value) => s.dim(value),
+    tableHeader: (value) => s.bold(value),
+    tableCell: (value) => value,
+    tableBorder: (value) => s.dim(value),
+    imageAltText: (value) => s.italic(s.magenta(value)),
+    imageUrl: (value) => s.dim(s.underline(value))
+  };
+  return Object.freeze(theme);
+}
+
+// src/theme/createMarkdownTheme.ts
+function createMarkdownTheme(options) {
+  const styleInstance = createStyle(options?.style);
+  const base = buildDefaultMarkdownTheme(styleInstance);
+  const overrides = options?.overrides;
+  if (!overrides) {
+    return base;
+  }
+  const merged = {
+    heading1: overrides.heading1 ?? base.heading1,
+    heading2: overrides.heading2 ?? base.heading2,
+    heading3: overrides.heading3 ?? base.heading3,
+    heading4: overrides.heading4 ?? base.heading4,
+    heading5: overrides.heading5 ?? base.heading5,
+    heading6: overrides.heading6 ?? base.heading6,
+    text: overrides.text ?? base.text,
+    emphasis: overrides.emphasis ?? base.emphasis,
+    strong: overrides.strong ?? base.strong,
+    strongEmphasis: overrides.strongEmphasis ?? base.strongEmphasis,
+    strikethrough: overrides.strikethrough ?? base.strikethrough,
+    inlineCode: overrides.inlineCode ?? base.inlineCode,
+    linkText: overrides.linkText ?? base.linkText,
+    linkUrl: overrides.linkUrl ?? base.linkUrl,
+    autolink: overrides.autolink ?? base.autolink,
+    blockquoteMarker: overrides.blockquoteMarker ?? base.blockquoteMarker,
+    blockquoteText: overrides.blockquoteText ?? base.blockquoteText,
+    listMarker: overrides.listMarker ?? base.listMarker,
+    orderedListMarker: overrides.orderedListMarker ?? base.orderedListMarker,
+    taskChecked: overrides.taskChecked ?? base.taskChecked,
+    taskUnchecked: overrides.taskUnchecked ?? base.taskUnchecked,
+    codeFence: overrides.codeFence ?? base.codeFence,
+    codeInfo: overrides.codeInfo ?? base.codeInfo,
+    codeText: overrides.codeText ?? base.codeText,
+    thematicBreak: overrides.thematicBreak ?? base.thematicBreak,
+    tableHeader: overrides.tableHeader ?? base.tableHeader,
+    tableCell: overrides.tableCell ?? base.tableCell,
+    tableBorder: overrides.tableBorder ?? base.tableBorder,
+    imageAltText: overrides.imageAltText ?? base.imageAltText,
+    imageUrl: overrides.imageUrl ?? base.imageUrl
+  };
+  return Object.freeze(merged);
+}
+var defaultTheme = createMarkdownTheme();
+export {
+  yellow as yellowCode,
+  yellow2 as yellow,
+  wrapText,
+  white as whiteCode,
+  white2 as white,
+  visibleWidth,
+  unorderedList,
+  underline as underlineCode,
+  underline2 as underline,
+  taskList,
+  table,
+  style,
+  stripAnsi,
+  strikethrough as strikethroughCode,
+  strikethrough2 as strikethrough,
+  resolveCapability,
+  reset,
+  red as redCode,
+  red2 as red,
+  padStart,
+  padEnd,
+  orderedList,
+  magenta as magentaCode,
+  magenta2 as magenta,
+  italic as italicCode,
+  italic2 as italic,
+  inverse as inverseCode,
+  inverse2 as inverse,
+  hidden as hiddenCode,
+  hidden2 as hidden,
+  green as greenCode,
+  green2 as green,
+  gray as grayCode,
+  gray2 as gray,
+  dim as dimCode,
+  dim2 as dim,
+  defaultTheme,
+  cyan as cyanCode,
+  cyan2 as cyan,
+  createStyle,
+  createMarkdownTheme,
+  composeStyles,
+  center,
+  buildDefaultMarkdownTheme,
+  brightYellow as brightYellowCode,
+  brightYellow2 as brightYellow,
+  brightWhite as brightWhiteCode,
+  brightWhite2 as brightWhite,
+  brightRed as brightRedCode,
+  brightRed2 as brightRed,
+  brightMagenta as brightMagentaCode,
+  brightMagenta2 as brightMagenta,
+  brightGreen as brightGreenCode,
+  brightGreen2 as brightGreen,
+  brightCyan as brightCyanCode,
+  brightCyan2 as brightCyan,
+  brightBlue as brightBlueCode,
+  brightBlue2 as brightBlue,
+  bold as boldCode,
+  bold2 as bold,
+  blue as blueCode,
+  blue2 as blue,
+  black as blackCode,
+  black2 as black,
+  bgYellow as bgYellowCode,
+  bgYellow2 as bgYellow,
+  bgWhite as bgWhiteCode,
+  bgWhite2 as bgWhite,
+  bgRed as bgRedCode,
+  bgRed2 as bgRed,
+  bgMagenta as bgMagentaCode,
+  bgMagenta2 as bgMagenta,
+  bgGreen as bgGreenCode,
+  bgGreen2 as bgGreen,
+  bgCyan as bgCyanCode,
+  bgCyan2 as bgCyan,
+  bgBrightYellow as bgBrightYellowCode,
+  bgBrightYellow2 as bgBrightYellow,
+  bgBrightWhite as bgBrightWhiteCode,
+  bgBrightWhite2 as bgBrightWhite,
+  bgBrightRed as bgBrightRedCode,
+  bgBrightRed2 as bgBrightRed,
+  bgBrightMagenta as bgBrightMagentaCode,
+  bgBrightMagenta2 as bgBrightMagenta,
+  bgBrightGreen as bgBrightGreenCode,
+  bgBrightGreen2 as bgBrightGreen,
+  bgBrightCyan as bgBrightCyanCode,
+  bgBrightCyan2 as bgBrightCyan,
+  bgBrightBlue as bgBrightBlueCode,
+  bgBrightBlue2 as bgBrightBlue,
+  bgBrightBlack as bgBrightBlackCode,
+  bgBrightBlack2 as bgBrightBlack,
+  bgBlue as bgBlueCode,
+  bgBlue2 as bgBlue,
+  bgBlack as bgBlackCode,
+  bgBlack2 as bgBlack,
+  applyStyle
+};