@orangecheck/app-design 1.0.0 → 1.1.1

package/dist/code.d.mts

@@ -0,0 +1,52 @@
+type TokenKind = 'keyword' | 'string' | 'number' | 'function' | 'type' | 'property' | 'comment' | 'tag' | 'url';
+interface Token {
+    text: string;
+    kind?: TokenKind;
+}
+type CodeLine = Token[];
+declare const TOKEN_CLASS: Record<TokenKind, string>;
+type Grammar = 'js' | 'json' | 'shell' | 'python' | 'yaml' | 'diff' | 'plain';
+declare const CODE_LANGS: readonly string[];
+declare function grammarOf(lang?: string | null): Grammar;
+declare function highlight(code: string, lang?: string | null): CodeLine[];
+type DiffMark = 'add' | 'remove';
+interface LineMarks {
+    highlight?: ReadonlySet<number>;
+    diff?: ReadonlyMap<number, DiffMark>;
+}
+declare function readDiff(code: string): {
+    code: string;
+    diff: Map<number, DiffMark>;
+};
+declare function parseLineRanges(spec: string | readonly number[] | undefined | null): Set<number>;
+interface CodeMeta {
+    title?: string;
+    highlight?: string;
+    diff?: boolean;
+    lineNumbers?: boolean;
+}
+declare function parseCodeMeta(meta?: string | null): CodeMeta;
+declare function escapeHtml(s: string): string;
+declare function linesToHtml(lines: CodeLine[], marks?: LineMarks): string;
+declare function highlightToHtml(code: string, lang?: string | null, opts?: {
+    highlight?: string | readonly number[];
+    diff?: boolean;
+}): string;
+
+interface HastNode {
+    type: string;
+    tagName?: string;
+    value?: string;
+    properties?: Record<string, unknown>;
+    children?: HastNode[];
+    data?: {
+        meta?: string | null;
+    };
+}
+interface RehypeCodeOptions {
+    tokenize?: (code: string, lang: string | undefined) => CodeLine[] | null;
+    skip?: readonly string[];
+}
+declare function rehypeCode(options?: RehypeCodeOptions): (tree: HastNode) => void;
+
+export { CODE_LANGS, type CodeLine, type CodeMeta, type DiffMark, type LineMarks, type RehypeCodeOptions, TOKEN_CLASS, type Token, type TokenKind, escapeHtml, grammarOf, highlight, highlightToHtml, linesToHtml, parseCodeMeta, parseLineRanges, readDiff, rehypeCode };

package/dist/code.d.ts

@@ -0,0 +1,52 @@
+type TokenKind = 'keyword' | 'string' | 'number' | 'function' | 'type' | 'property' | 'comment' | 'tag' | 'url';
+interface Token {
+    text: string;
+    kind?: TokenKind;
+}
+type CodeLine = Token[];
+declare const TOKEN_CLASS: Record<TokenKind, string>;
+type Grammar = 'js' | 'json' | 'shell' | 'python' | 'yaml' | 'diff' | 'plain';
+declare const CODE_LANGS: readonly string[];
+declare function grammarOf(lang?: string | null): Grammar;
+declare function highlight(code: string, lang?: string | null): CodeLine[];
+type DiffMark = 'add' | 'remove';
+interface LineMarks {
+    highlight?: ReadonlySet<number>;
+    diff?: ReadonlyMap<number, DiffMark>;
+}
+declare function readDiff(code: string): {
+    code: string;
+    diff: Map<number, DiffMark>;
+};
+declare function parseLineRanges(spec: string | readonly number[] | undefined | null): Set<number>;
+interface CodeMeta {
+    title?: string;
+    highlight?: string;
+    diff?: boolean;
+    lineNumbers?: boolean;
+}
+declare function parseCodeMeta(meta?: string | null): CodeMeta;
+declare function escapeHtml(s: string): string;
+declare function linesToHtml(lines: CodeLine[], marks?: LineMarks): string;
+declare function highlightToHtml(code: string, lang?: string | null, opts?: {
+    highlight?: string | readonly number[];
+    diff?: boolean;
+}): string;
+
+interface HastNode {
+    type: string;
+    tagName?: string;
+    value?: string;
+    properties?: Record<string, unknown>;
+    children?: HastNode[];
+    data?: {
+        meta?: string | null;
+    };
+}
+interface RehypeCodeOptions {
+    tokenize?: (code: string, lang: string | undefined) => CodeLine[] | null;
+    skip?: readonly string[];
+}
+declare function rehypeCode(options?: RehypeCodeOptions): (tree: HastNode) => void;
+
+export { CODE_LANGS, type CodeLine, type CodeMeta, type DiffMark, type LineMarks, type RehypeCodeOptions, TOKEN_CLASS, type Token, type TokenKind, escapeHtml, grammarOf, highlight, highlightToHtml, linesToHtml, parseCodeMeta, parseLineRanges, readDiff, rehypeCode };

package/dist/code.js

@@ -0,0 +1,534 @@
+'use strict';
+
+// src/code/highlight.ts
+var TOKEN_CLASS = {
+  keyword: "oca-k",
+  string: "oca-s",
+  number: "oca-n",
+  function: "oca-f",
+  type: "oca-y",
+  property: "oca-p",
+  comment: "oca-c",
+  tag: "oca-g",
+  url: "oca-u"
+};
+var ALIASES = {
+  ts: "js",
+  typescript: "js",
+  tsx: "js",
+  js: "js",
+  javascript: "js",
+  jsx: "js",
+  mjs: "js",
+  cjs: "js",
+  json: "json",
+  jsonc: "json",
+  json5: "json",
+  bash: "shell",
+  sh: "shell",
+  shell: "shell",
+  zsh: "shell",
+  console: "shell",
+  terminal: "shell",
+  py: "python",
+  python: "python",
+  yaml: "yaml",
+  yml: "yaml",
+  diff: "diff"
+};
+var CODE_LANGS = Object.keys(ALIASES);
+function grammarOf(lang) {
+  return lang && ALIASES[lang.toLowerCase()] || "plain";
+}
+function collector() {
+  const tokens = [];
+  const emit = (text, kind) => {
+    if (!text) return;
+    const last = tokens[tokens.length - 1];
+    if (last && last.kind === kind) last.text += text;
+    else tokens.push(kind ? { text, kind } : { text });
+  };
+  return { emit, tokens };
+}
+function at(re, src, i) {
+  re.lastIndex = i;
+  const m = re.exec(src);
+  return m ? m[0] : null;
+}
+var WS = /[ \t]+/y;
+var NEWLINE = /\r?\n/y;
+var JS_KEYWORDS = new Set(
+  "abstract as async await break case catch class const continue debugger declare default delete do else enum export extends finally for from function get if implements import in infer instanceof interface is keyof let module namespace new of override private protected public readonly return satisfies set static super switch this throw try type typeof unique var void while with yield".split(" ")
+);
+var JS_CONSTANTS = /* @__PURE__ */ new Set(["true", "false", "null", "undefined", "NaN", "Infinity"]);
+var TS_PRIMITIVES = /* @__PURE__ */ new Set(["string", "number", "boolean", "bigint", "symbol", "object", "unknown", "any", "never"]);
+var isConstant = (m) => /^[A-Z][A-Z\d_]+$/.test(m) && (m.includes("_") || m.length > 4);
+var JS_LINE_COMMENT = /\/\/[^\n]*/y;
+var JS_BLOCK_COMMENT = /\/\*[\s\S]*?(?:\*\/|$)/y;
+var JS_TEMPLATE = /`(?:\\[\s\S]|[^\\`])*`?/y;
+var JS_STRING = /'(?:\\.|[^\\'\n])*'?|"(?:\\.|[^\\"\n])*"?/y;
+var JS_NUMBER = /(?:0[xX][\da-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+|\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?|\.\d[\d_]*(?:[eE][+-]?\d+)?)n?/y;
+var JS_IDENT = /[A-Za-z_$][\w$]*/y;
+var JS_DECORATOR = /@[A-Za-z_$][\w$.]*/y;
+var JS_CALL_AFTER = /\s*(?:<[\w$\s,.[\]|&'"]*>)?\s*\(/y;
+var JS_TAG = /<\/?(?=[A-Za-z])/y;
+var JS_TAG_NAME = /[A-Za-z][\w$.:-]*/y;
+var JS_PUNCT = /=>|\.\.\.|[{}()[\];,.<>=+\-*/%!?:&|^~#]/y;
+var JSX_BEFORE = /* @__PURE__ */ new Set(["(", ",", "=", "?", ":", "{", "[", ";", ">", "&&", "||", "=>", "return"]);
+function scanJs(src, emit, jsx) {
+  let i = 0;
+  let prev = "";
+  let tagDepth = 0;
+  let braceInTag = 0;
+  const sig = (t) => {
+    prev = t;
+  };
+  while (i < src.length) {
+    let m;
+    if ((m = at(WS, src, i)) || (m = at(NEWLINE, src, i))) {
+      emit(m);
+      i += m.length;
+      continue;
+    }
+    if ((m = at(JS_LINE_COMMENT, src, i)) || (m = at(JS_BLOCK_COMMENT, src, i))) {
+      emit(m, "comment");
+      i += m.length;
+      continue;
+    }
+    if ((m = at(JS_TEMPLATE, src, i)) || (m = at(JS_STRING, src, i))) {
+      emit(m, "string");
+      i += m.length;
+      sig('"');
+      continue;
+    }
+    if (jsx && tagDepth === 0 && (m = at(JS_TAG, src, i)) && (prev === "" || JSX_BEFORE.has(prev))) {
+      const name = at(JS_TAG_NAME, src, i + m.length);
+      if (name) {
+        emit(m);
+        emit(name, "tag");
+        i += m.length + name.length;
+        tagDepth = 1;
+        braceInTag = 0;
+        sig("tag");
+        continue;
+      }
+    }
+    if (jsx && tagDepth > 0 && braceInTag === 0) {
+      if (src.startsWith("/>", i) || src[i] === ">") {
+        const close = src[i] === ">" ? ">" : "/>";
+        emit(close);
+        i += close.length;
+        tagDepth = 0;
+        sig(">");
+        continue;
+      }
+      if ((m = at(JS_IDENT, src, i)) && /^\s*=/.test(src.slice(i + m.length, i + m.length + 4))) {
+        emit(m, "property");
+        i += m.length;
+        continue;
+      }
+      if (m = at(JS_IDENT, src, i)) {
+        emit(m, "property");
+        i += m.length;
+        continue;
+      }
+      if (src[i] === "{") braceInTag = 1;
+    } else if (jsx && tagDepth > 0 && braceInTag > 0) {
+      if (src[i] === "{") braceInTag++;
+      else if (src[i] === "}") braceInTag--;
+    }
+    if (m = at(JS_DECORATOR, src, i)) {
+      emit(m, "function");
+      i += m.length;
+      sig("@");
+      continue;
+    }
+    if (m = at(JS_IDENT, src, i)) {
+      const end = i + m.length;
+      let kind;
+      if (prev !== "." && JS_CONSTANTS.has(m)) kind = "number";
+      else if (prev !== "." && JS_KEYWORDS.has(m)) kind = "keyword";
+      else if (at(JS_CALL_AFTER, src, end) !== null) kind = "function";
+      else if (prev !== "." && TS_PRIMITIVES.has(m)) kind = "type";
+      else if (isConstant(m)) kind = "number";
+      else if (/^[A-Z]/.test(m)) kind = "type";
+      emit(m, kind);
+      i = end;
+      sig(kind === "keyword" ? m : "id");
+      continue;
+    }
+    if (m = at(JS_NUMBER, src, i)) {
+      emit(m, "number");
+      i += m.length;
+      sig("0");
+      continue;
+    }
+    if (m = at(JS_PUNCT, src, i)) {
+      emit(m);
+      i += m.length;
+      sig(m === "." ? "." : m);
+      continue;
+    }
+    emit(src[i]);
+    i++;
+  }
+}
+var JSON_STRING = /"(?:\\.|[^\\"\n])*"?/y;
+var JSON_KEY_AFTER = /\s*:/y;
+var JSON_NUMBER = /-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
+var JSON_WORD = /true|false|null/y;
+function scanJson(src, emit) {
+  let i = 0;
+  while (i < src.length) {
+    let m;
+    if ((m = at(JS_LINE_COMMENT, src, i)) || (m = at(JS_BLOCK_COMMENT, src, i))) {
+      emit(m, "comment");
+    } else if (m = at(JSON_STRING, src, i)) {
+      emit(m, at(JSON_KEY_AFTER, src, i + m.length) !== null ? "property" : "string");
+    } else if ((m = at(JSON_NUMBER, src, i)) || (m = at(JSON_WORD, src, i))) {
+      emit(m, "number");
+    } else {
+      m = src[i];
+      emit(m);
+    }
+    i += m.length;
+  }
+}
+var SH_KEYWORDS = new Set(
+  "if then else elif fi for in do done case esac while until function return export local select time".split(" ")
+);
+var SH_PROMPT = /\$ (?=\S)/y;
+var SH_COMMENT = /#[^\n]*/y;
+var SH_SINGLE = /'[^']*'?/y;
+var SH_DOUBLE = /"(?:\\.|[^\\"])*"?/y;
+var SH_VAR = /\$(?:\{[^}\n]*\}?|[A-Za-z_][\w]*|[@*#?$!\d])/y;
+var SH_URL = /https?:\/\/[^\s'"`)]+/y;
+var SH_FLAG = /--?[A-Za-z][\w-]*/y;
+var SH_ASSIGN = /[A-Za-z_][\w]*(?==)/y;
+var SH_VALUE = /=[^\s|&;()<>'"`$]*/y;
+var SH_WORD = /[^\s|&;()<>'"`$#]+/y;
+var SH_OPERATOR = /\|\||&&|[|;&]|\$\(|[()<>]/y;
+function scanShell(src, emit) {
+  let i = 0;
+  let command = true;
+  let lineStart = true;
+  while (i < src.length) {
+    let m;
+    if (m = at(NEWLINE, src, i)) {
+      emit(m);
+      i += m.length;
+      command = !/\\\s*$/.test(src.slice(0, i - m.length));
+      lineStart = true;
+      continue;
+    }
+    if (m = at(WS, src, i)) {
+      emit(m);
+      i += m.length;
+      continue;
+    }
+    if (lineStart && (m = at(SH_PROMPT, src, i))) {
+      emit(m, "comment");
+      i += m.length;
+      lineStart = false;
+      continue;
+    }
+    lineStart = false;
+    if ((m = at(SH_COMMENT, src, i)) && (i === 0 || /\s/.test(src[i - 1]))) {
+      emit(m, "comment");
+      i += m.length;
+      continue;
+    }
+    if ((m = at(SH_SINGLE, src, i)) || (m = at(SH_DOUBLE, src, i))) {
+      emit(m, "string");
+      i += m.length;
+      command = false;
+      continue;
+    }
+    if (m = at(SH_OPERATOR, src, i)) {
+      emit(m);
+      i += m.length;
+      command = m !== ")" && m !== ">" && m !== "<";
+      continue;
+    }
+    if (m = at(SH_VAR, src, i)) {
+      emit(m, "type");
+      i += m.length;
+      command = false;
+      continue;
+    }
+    if (m = at(SH_URL, src, i)) {
+      emit(m, "url");
+      i += m.length;
+      command = false;
+      continue;
+    }
+    if (command && (m = at(SH_ASSIGN, src, i))) {
+      emit(m, "property");
+      i += m.length;
+      const v = at(SH_VALUE, src, i);
+      emit(v);
+      i += v.length;
+      continue;
+    }
+    if ((m = at(SH_FLAG, src, i)) && !command) {
+      emit(m, "keyword");
+      i += m.length;
+      continue;
+    }
+    if (m = at(SH_WORD, src, i)) {
+      if (command && SH_KEYWORDS.has(m)) emit(m, "keyword");
+      else if (command) {
+        emit(m, "function");
+        command = m === "sudo" || m === "npx" || m === "env" || m === "time";
+        i += m.length;
+        continue;
+      } else emit(m);
+      i += m.length;
+      continue;
+    }
+    emit(src[i]);
+    i++;
+  }
+}
+var PY_KEYWORDS = new Set(
+  "and as assert async await break class continue def del elif else except finally for from global if import in is lambda match case nonlocal not or pass raise return try while with yield self cls".split(" ")
+);
+var PY_CONSTANTS = /* @__PURE__ */ new Set(["True", "False", "None"]);
+var PY_TYPES = /* @__PURE__ */ new Set(["int", "str", "bool", "float", "bytes", "list", "dict", "tuple", "set", "object"]);
+var PY_COMMENT = /#[^\n]*/y;
+var PY_TRIPLE = /[rRbBuUfF]{0,2}(?:"""[\s\S]*?(?:"""|$)|'''[\s\S]*?(?:'''|$))/y;
+var PY_STRING = /[rRbBuUfF]{0,2}(?:'(?:\\.|[^\\'\n])*'?|"(?:\\.|[^\\"\n])*"?)/y;
+var PY_NUMBER = /(?:0[xX][\da-fA-F_]+|\d[\d_]*(?:\.[\d_]*)?(?:[eE][+-]?\d+)?j?)/y;
+var PY_IDENT = /[A-Za-z_]\w*/y;
+var PY_DECORATOR = /@[A-Za-z_][\w.]*/y;
+var PY_CALL_AFTER = /\s*\(/y;
+function scanPython(src, emit) {
+  let i = 0;
+  let prev = "";
+  while (i < src.length) {
+    let m;
+    if ((m = at(WS, src, i)) || (m = at(NEWLINE, src, i))) {
+      emit(m);
+      i += m.length;
+      continue;
+    }
+    if (m = at(PY_COMMENT, src, i)) {
+      emit(m, "comment");
+    } else if ((m = at(PY_TRIPLE, src, i)) || (m = at(PY_STRING, src, i))) {
+      if (/^[A-Za-z]+$/.test(m)) {
+        emit(m);
+      } else emit(m, "string");
+      prev = '"';
+    } else if (m = at(PY_DECORATOR, src, i)) {
+      emit(m, "function");
+      prev = "@";
+    } else if (m = at(PY_IDENT, src, i)) {
+      let kind;
+      if (PY_CONSTANTS.has(m)) kind = "number";
+      else if (prev !== "." && PY_KEYWORDS.has(m)) kind = "keyword";
+      else if (prev === "def" || at(PY_CALL_AFTER, src, i + m.length) !== null) kind = "function";
+      else if (prev === "class" || /^[A-Z][a-z]/.test(m) || PY_TYPES.has(m)) kind = "type";
+      else if (isConstant(m)) kind = "number";
+      emit(m, kind);
+      prev = kind === "keyword" ? m : "id";
+    } else if (m = at(PY_NUMBER, src, i)) {
+      emit(m, "number");
+      prev = "0";
+    } else {
+      m = src[i];
+      emit(m);
+      prev = m;
+    }
+    i += m.length;
+  }
+}
+var YAML_KEY = /[ \t]*(?:- )?[\w.$/-]+(?=[ \t]*:(?:\s|$))/y;
+var YAML_VALUE_WORD = /(?:true|false|null|yes|no|~|-?\d+(?:\.\d+)?)(?=\s*(?:#|$))/y;
+function scanYaml(src, emit) {
+  let i = 0;
+  let lineStart = true;
+  while (i < src.length) {
+    let m;
+    if (m = at(NEWLINE, src, i)) {
+      emit(m);
+      i += m.length;
+      lineStart = true;
+      continue;
+    }
+    if (lineStart && (m = at(YAML_KEY, src, i))) {
+      const dash = m.match(/^([ \t]*(?:- )?)/)[1];
+      emit(dash);
+      emit(m.slice(dash.length), "property");
+      i += m.length;
+      lineStart = false;
+      continue;
+    }
+    lineStart = false;
+    if ((m = at(SH_COMMENT, src, i)) && (i === 0 || /\s/.test(src[i - 1]))) emit(m, "comment");
+    else if ((m = at(SH_SINGLE, src, i)) || (m = at(JSON_STRING, src, i))) emit(m, "string");
+    else if (m = at(YAML_VALUE_WORD, src, i)) emit(m, "number");
+    else if (m = at(SH_URL, src, i)) emit(m, "url");
+    else {
+      m = src[i];
+      emit(m);
+    }
+    i += m.length;
+  }
+}
+function toLines(tokens) {
+  const lines = [[]];
+  for (const t of tokens) {
+    const parts = t.text.split(/\r?\n/);
+    parts.forEach((part, j) => {
+      if (j > 0) lines.push([]);
+      if (part) lines[lines.length - 1].push(t.kind ? { text: part, kind: t.kind } : { text: part });
+    });
+  }
+  return lines;
+}
+function highlight(code, lang) {
+  const src = code.replace(/\r?\n$/, "");
+  const grammar = grammarOf(lang);
+  const { emit, tokens } = collector();
+  const name = (lang ?? "").toLowerCase();
+  switch (grammar) {
+    case "js":
+      scanJs(src, emit, name === "tsx" || name === "jsx");
+      break;
+    case "json":
+      scanJson(src, emit);
+      break;
+    case "shell":
+      scanShell(src, emit);
+      break;
+    case "python":
+      scanPython(src, emit);
+      break;
+    case "yaml":
+      scanYaml(src, emit);
+      break;
+    default:
+      emit(src);
+  }
+  return toLines(tokens);
+}
+function readDiff(code) {
+  const diff = /* @__PURE__ */ new Map();
+  const lines = code.replace(/\r?\n$/, "").split(/\r?\n/);
+  const out = lines.map((line, i) => {
+    const c = line[0];
+    if (c === "+" || c === "-") {
+      diff.set(i + 1, c === "+" ? "add" : "remove");
+      return line.slice(1);
+    }
+    return c === " " ? line.slice(1) : line;
+  });
+  return { code: out.join("\n"), diff };
+}
+function parseLineRanges(spec) {
+  if (!spec) return /* @__PURE__ */ new Set();
+  if (typeof spec !== "string") return new Set(spec);
+  const out = /* @__PURE__ */ new Set();
+  for (const part of spec.split(",")) {
+    const m = part.trim().match(/^(\d+)(?:\s*-\s*(\d+))?$/);
+    if (!m) continue;
+    const a = Number(m[1]);
+    const b = m[2] ? Number(m[2]) : a;
+    for (let n = Math.min(a, b); n <= Math.max(a, b) && n - a < 1e4; n++) out.add(n);
+  }
+  return out;
+}
+function parseCodeMeta(meta) {
+  if (!meta) return {};
+  const out = {};
+  const title = meta.match(/(?:title|filename)=(?:"([^"]*)"|'([^']*)'|(\S+))/);
+  if (title) out.title = title[1] ?? title[2] ?? title[3];
+  const lines = meta.match(/\{([\d,\s-]+)\}/);
+  if (lines) out.highlight = lines[1].replace(/\s+/g, "");
+  const rest = meta.replace(/(?:title|filename)=(?:"[^"]*"|'[^']*'|\S+)/, "");
+  if (/\bdiff\b/.test(rest)) out.diff = true;
+  if (/\b(?:showLineNumbers|lineNumbers|numbers)\b/.test(rest)) out.lineNumbers = true;
+  return out;
+}
+var ESCAPE = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
+function escapeHtml(s) {
+  return s.replace(/[&<>"]/g, (c) => ESCAPE[c]);
+}
+function linesToHtml(lines, marks = {}) {
+  return lines.map((line, i) => {
+    const n = i + 1;
+    const attrs = [
+      'data-line=""',
+      marks.highlight?.has(n) ? 'data-mark=""' : "",
+      marks.diff?.has(n) ? `data-diff="${marks.diff.get(n)}"` : ""
+    ].filter(Boolean).join(" ");
+    const body = line.map((t) => t.kind ? `<span class="${TOKEN_CLASS[t.kind]}">${escapeHtml(t.text)}</span>` : escapeHtml(t.text)).join("");
+    return `<span ${attrs}>${body}</span>`;
+  }).join("\n");
+}
+function highlightToHtml(code, lang, opts = {}) {
+  const d = opts.diff ? readDiff(code) : null;
+  return linesToHtml(highlight(d ? d.code : code, lang), {
+    highlight: parseLineRanges(opts.highlight),
+    diff: d?.diff
+  });
+}
+
+// src/code/rehype.ts
+function textOf(node) {
+  if (node.type === "text") return node.value ?? "";
+  return (node.children ?? []).map(textOf).join("");
+}
+function langOf(code) {
+  const cls = code.properties?.className;
+  const list = Array.isArray(cls) ? cls : typeof cls === "string" ? cls.split(" ") : [];
+  for (const c of list) {
+    const m = String(c).match(/^language-(.+)$/);
+    if (m) return m[1];
+  }
+  return void 0;
+}
+function rehypeCode(options = {}) {
+  const skip = new Set(options.skip ?? ["mermaid"]);
+  const visit = (node) => {
+    for (const child of node.children ?? []) {
+      const code = child.type === "element" && child.tagName === "pre" ? child.children?.[0] : void 0;
+      if (code && code.type === "element" && code.tagName === "code" && child.children?.length === 1) {
+        const lang = langOf(code);
+        if (lang && skip.has(lang)) continue;
+        const meta = parseCodeMeta(code.data?.meta);
+        let source = textOf(code);
+        const diff = meta.diff || lang === "diff" ? readDiff(source) : null;
+        if (diff) source = diff.code;
+        const lines = options.tokenize?.(source, lang) ?? highlight(source, lang === "diff" ? void 0 : lang);
+        child.properties = {
+          ...child.properties,
+          dataOcaCode: "",
+          dataHtml: linesToHtml(lines, { highlight: parseLineRanges(meta.highlight), diff: diff?.diff }),
+          ...lang ? { dataLang: lang } : {},
+          ...meta.title ? { dataTitle: meta.title } : {},
+          ...diff ? { dataDiff: "" } : {},
+          ...meta.lineNumbers ? { dataLineNumbers: "" } : {}
+        };
+        child.children = [];
+        continue;
+      }
+      visit(child);
+    }
+  };
+  return (tree) => visit(tree);
+}
+
+exports.CODE_LANGS = CODE_LANGS;
+exports.TOKEN_CLASS = TOKEN_CLASS;
+exports.escapeHtml = escapeHtml;
+exports.grammarOf = grammarOf;
+exports.highlight = highlight;
+exports.highlightToHtml = highlightToHtml;
+exports.linesToHtml = linesToHtml;
+exports.parseCodeMeta = parseCodeMeta;
+exports.parseLineRanges = parseLineRanges;
+exports.readDiff = readDiff;
+exports.rehypeCode = rehypeCode;
+//# sourceMappingURL=code.js.map
+//# sourceMappingURL=code.js.map