@regmisatyam/retex 0.1.0 → 0.2.0

package/dist/library.cjs

@@ -0,0 +1,649 @@
+'use strict';
+
+// src/security/sanitize.ts
+function isSafeColor(value) {
+  const v = value.trim();
+  if (/^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(v)) return true;
+  if (/^(rgb|rgba|hsl|hsla)\(\s*[0-9.,%\s/]+\)$/i.test(v)) return true;
+  return CSS_NAMED_COLORS.has(v.toLowerCase());
+}
+function isSafeDimension(value) {
+  return /^-?\d*\.?\d+(px|pt|em|rem|ex|ch|vw|vh|vmin|vmax|cm|mm|in|pc|%|fr)?$/.test(
+    value.trim()
+  );
+}
+var CSS_NAMED_COLORS = /* @__PURE__ */ new Set([
+  "black",
+  "silver",
+  "gray",
+  "grey",
+  "white",
+  "maroon",
+  "red",
+  "purple",
+  "fuchsia",
+  "green",
+  "lime",
+  "olive",
+  "yellow",
+  "navy",
+  "blue",
+  "teal",
+  "aqua",
+  "cyan",
+  "magenta",
+  "orange",
+  "pink",
+  "brown",
+  "gold",
+  "indigo",
+  "violet",
+  "tan",
+  "beige",
+  "ivory",
+  "coral",
+  "salmon",
+  "khaki",
+  "crimson",
+  "turquoise",
+  "lavender",
+  "plum",
+  "orchid",
+  "slateblue",
+  "slategray",
+  "steelblue",
+  "skyblue",
+  "royalblue",
+  "midnightblue",
+  "darkblue",
+  "darkgreen",
+  "darkred",
+  "darkgray",
+  "darkgrey",
+  "lightgray",
+  "lightgrey",
+  "lightblue",
+  "transparent",
+  "currentcolor",
+  "inherit"
+]);
+
+// src/library/colors.ts
+var zero = { offset: 0, line: 1, column: 1 };
+var ZERO_RANGE = { start: zero, end: zero };
+var colorCommands = [
+  {
+    name: "textcolor",
+    category: "inline",
+    args: [
+      { kind: "string", name: "color", format: "color" },
+      { kind: "content", name: "content" }
+    ],
+    summary: "Color text with a hex/named color.",
+    example: "\\textcolor{#2563eb}{OpenAI}",
+    build: ({ args, utils, report }) => {
+      const color = utils.textOf(args[0]).trim();
+      if (color && !isSafeColor(color)) {
+        report({
+          severity: "warning" /* Warning */,
+          code: "RTX3001" /* InvalidColor */,
+          message: `"${color}" is not a recognized color; it will be ignored.`,
+          range: args[0]?.range ?? ZERO_RANGE
+        });
+      }
+      return {
+        type: "color",
+        color: isSafeColor(color) ? color : "",
+        children: args[1]?.children ?? []
+      };
+    }
+  },
+  {
+    name: "themecolor",
+    category: "inline",
+    args: [
+      { kind: "string", name: "token" },
+      { kind: "content", name: "content" }
+    ],
+    summary: "Color text using a token from the active theme.",
+    example: "\\themecolor{primary}{Highlighted}",
+    build: ({ args, utils }) => ({
+      type: "themecolor",
+      token: utils.textOf(args[0]).trim() || "primary",
+      children: args[1]?.children ?? []
+    })
+  }
+];
+var palettes = {
+  slate: {
+    primary: "#0f172a",
+    secondary: "#475569",
+    text: "#1e293b",
+    muted: "#64748b",
+    border: "#cbd5e1",
+    accent: "#0f172a"
+  },
+  blue: {
+    primary: "#2563eb",
+    secondary: "#64748b",
+    text: "#1e293b",
+    muted: "#64748b",
+    border: "#e2e8f0",
+    accent: "#2563eb"
+  },
+  violet: {
+    primary: "#7c3aed",
+    secondary: "#6b7280",
+    text: "#111827",
+    muted: "#6b7280",
+    border: "#e5e7eb",
+    accent: "#7c3aed"
+  },
+  emerald: {
+    primary: "#059669",
+    secondary: "#6b7280",
+    text: "#111827",
+    muted: "#6b7280",
+    border: "#d1fae5",
+    accent: "#059669"
+  },
+  rose: {
+    primary: "#e11d48",
+    secondary: "#6b7280",
+    text: "#111827",
+    muted: "#6b7280",
+    border: "#fecdd3",
+    accent: "#e11d48"
+  },
+  amber: {
+    primary: "#d97706",
+    secondary: "#6b7280",
+    text: "#111827",
+    muted: "#6b7280",
+    border: "#fde68a",
+    accent: "#d97706"
+  }
+};
+var colorsLibrary = {
+  name: "colors",
+  summary: "Text color (\\textcolor, \\themecolor) and named palettes.",
+  commands: colorCommands
+};
+
+// src/library/fonts.ts
+var zero2 = { offset: 0, line: 1, column: 1 };
+var ZERO_RANGE2 = { start: zero2, end: zero2 };
+var scaleSwitch = (name, scale) => ({
+  name,
+  category: "switch",
+  scoped: true,
+  summary: `Set the font size to "${name}" for the rest of the group.`,
+  example: `{\\${name} ...}`,
+  build: ({ scope }) => ({ type: "fontscale", scale, children: scope })
+});
+var fontCommands = [
+  {
+    name: "fontsize",
+    category: "inline",
+    args: [
+      { kind: "string", name: "size", format: "dimension" },
+      { kind: "content", name: "content" }
+    ],
+    summary: "Set an explicit font size for the wrapped content.",
+    example: "\\fontsize{14pt}{Custom Size}",
+    build: ({ args, utils, report }) => {
+      const size = utils.textOf(args[0]).trim();
+      if (size && !isSafeDimension(size)) {
+        report({
+          severity: "warning" /* Warning */,
+          code: "RTX3003" /* InvalidDimension */,
+          message: `"${size}" is not a valid dimension.`,
+          range: args[0]?.range ?? ZERO_RANGE2
+        });
+      }
+      return {
+        type: "fontsize",
+        size: isSafeDimension(size) ? size : "1em",
+        children: args[1]?.children ?? []
+      };
+    }
+  },
+  {
+    name: "fontfamily",
+    category: "inline",
+    args: [
+      { kind: "string", name: "family" },
+      { kind: "content", name: "content" }
+    ],
+    summary: "Set the font family for the wrapped content.",
+    example: "\\fontfamily{Georgia}{Serif text}",
+    build: ({ args, utils }) => ({
+      type: "fontfamily",
+      family: utils.textOf(args[0]).trim() || "inherit",
+      children: args[1]?.children ?? []
+    })
+  },
+  scaleSwitch("small", "small"),
+  scaleSwitch("large", "large"),
+  scaleSwitch("Large", "Large"),
+  scaleSwitch("Huge", "Huge"),
+  {
+    name: "normalsize",
+    category: "switch",
+    scoped: true,
+    summary: "Reset the font size to the document base size.",
+    build: ({ scope }) => ({ type: "fontscale", scale: "normal", children: scope })
+  },
+  {
+    name: "ttfamily",
+    category: "switch",
+    scoped: true,
+    summary: "Switch to a monospace font for the rest of the group.",
+    build: ({ scope }) => ({
+      type: "fontfamily",
+      family: "monospace",
+      children: scope
+    })
+  }
+];
+var fontStacks = {
+  inter: '"Inter", "Helvetica Neue", Helvetica, Arial, sans-serif',
+  system: 'system-ui, -apple-system, "Segoe UI", Roboto, Arial, sans-serif',
+  helvetica: '"Helvetica Neue", Helvetica, Arial, sans-serif',
+  georgia: 'Georgia, "Times New Roman", Times, serif',
+  times: '"Times New Roman", Times, serif',
+  garamond: '"EB Garamond", Garamond, Georgia, serif',
+  spaceGrotesk: '"Space Grotesk", system-ui, sans-serif',
+  sourceSerif: '"Source Serif 4", Georgia, serif',
+  jetbrainsMono: '"JetBrains Mono", "SF Mono", "Fira Code", Consolas, monospace',
+  firaCode: '"Fira Code", "JetBrains Mono", Consolas, monospace',
+  ibmPlexMono: '"IBM Plex Mono", "SF Mono", Consolas, monospace'
+};
+function fontTheme(spec) {
+  const resolve = (v) => v == null ? void 0 : fontStacks[v] ?? v;
+  return {
+    heading: resolve(spec.heading),
+    body: resolve(spec.body),
+    mono: resolve(spec.mono)
+  };
+}
+var fontsLibrary = {
+  name: "fonts",
+  summary: "Font family & size control (\\fontfamily, \\fontsize, \\small \u2026 \\Huge).",
+  commands: fontCommands
+};
+
+// src/library/shapes.ts
+var rule = (name, style, summary) => ({
+  name,
+  category: "block",
+  summary,
+  example: `\\${name}`,
+  build: () => style ? { type: "rule", style } : { type: "rule" }
+});
+var shapeCommands = [
+  rule("hrule", "solid", "A horizontal rule / divider."),
+  rule("divider", "solid", "A horizontal rule / divider."),
+  rule("dashrule", "dashed", "A dashed horizontal rule."),
+  rule("dotrule", "dotted", "A dotted horizontal rule."),
+  rule("thickrule", "thick", "A thick horizontal rule."),
+  rule("doublerule", "double", "A double horizontal rule."),
+  {
+    name: "vspace",
+    category: "block",
+    args: [{ kind: "string", name: "size", format: "dimension" }],
+    summary: "Vertical space.",
+    example: "\\vspace{1em}",
+    build: ({ args, utils }) => ({
+      type: "space",
+      axis: "vertical",
+      size: utils.textOf(args[0]).trim() || "1em"
+    })
+  },
+  {
+    name: "hspace",
+    category: "inline",
+    args: [{ kind: "string", name: "size", format: "dimension" }],
+    summary: "Horizontal space.",
+    example: "\\hspace{1em}",
+    build: ({ args, utils }) => ({
+      type: "space",
+      axis: "horizontal",
+      size: utils.textOf(args[0]).trim() || "1em"
+    })
+  }
+];
+var shapesLibrary = {
+  name: "shapes",
+  summary: "Horizontal rules / dividers (\\hrule, \\dashrule, \u2026) and spacing.",
+  commands: shapeCommands
+};
+
+// src/theme/default.ts
+var blankTheme = {
+  name: "blank"
+};
+var defaultTheme = blankTheme;
+
+// src/theme/themes.ts
+function resolveTheme(partial, base = defaultTheme) {
+  return {
+    name: partial?.name ?? base.name,
+    colors: { ...base.colors, ...partial?.colors },
+    fonts: { ...base.fonts, ...partial?.fonts },
+    fontSizes: { ...base.fontSizes, ...partial?.fontSizes },
+    spacing: { ...base.spacing, ...partial?.spacing },
+    page: { ...base.page, ...partial?.page },
+    sectionStyle: partial?.sectionStyle ?? base.sectionStyle,
+    headings: { ...base.headings, ...partial?.headings }
+  };
+}
+var styledBase = {
+  fonts: {
+    heading: '"Inter", "Helvetica Neue", Helvetica, Arial, sans-serif',
+    body: '"Inter", "Helvetica Neue", Helvetica, Arial, sans-serif',
+    mono: '"JetBrains Mono", "SF Mono", "Fira Code", Consolas, monospace'
+  },
+  fontSizes: {
+    base: "10.5pt",
+    small: "9pt",
+    large: "12pt",
+    Large: "15pt",
+    Huge: "22pt",
+    name: "26pt",
+    section: "13pt"
+  },
+  spacing: { unit: "4px", section: "1.1rem", item: "0.28rem", page: "0.55in" },
+  page: { size: "Letter", margin: "0.55in", maxWidth: "8.5in" },
+  headings: { transform: "uppercase", tracking: "0.06em", nameTracking: "-0.01em" }
+};
+var modernTheme = resolveTheme({
+  ...styledBase,
+  name: "modern",
+  colors: {
+    primary: "#7c3aed",
+    secondary: "#64748b",
+    text: "#111827",
+    muted: "#64748b",
+    background: "#ffffff",
+    border: "#e2e8f0",
+    accent: "#7c3aed"
+  },
+  sectionStyle: "underline"
+});
+var classicTheme = resolveTheme({
+  ...styledBase,
+  name: "classic",
+  colors: {
+    primary: "#111827",
+    secondary: "#4b5563",
+    text: "#1e293b",
+    muted: "#4b5563",
+    background: "#ffffff",
+    border: "#cbd5e1",
+    accent: "#111827"
+  },
+  fonts: {
+    heading: 'Georgia, "Times New Roman", serif',
+    body: 'Georgia, "Times New Roman", serif',
+    mono: 'Consolas, "Courier New", monospace'
+  },
+  sectionStyle: "rule"
+});
+var compactTheme = resolveTheme({
+  ...styledBase,
+  name: "compact",
+  colors: {
+    primary: "#2563eb",
+    secondary: "#64748b",
+    text: "#1e293b",
+    muted: "#64748b",
+    background: "#ffffff",
+    border: "#e2e8f0",
+    accent: "#2563eb"
+  },
+  fontSizes: {
+    base: "9.5pt",
+    small: "8pt",
+    large: "11pt",
+    Large: "13pt",
+    Huge: "18pt",
+    name: "20pt",
+    section: "11pt"
+  },
+  spacing: { unit: "3px", section: "0.7rem", item: "0.18rem", page: "0.4in" },
+  sectionStyle: "bar"
+});
+
+// src/library/themes.ts
+var stylingCommands = [...colorCommands, ...fontCommands, ...shapeCommands];
+var modernLibrary = {
+  name: "modern",
+  summary: "A modern, accent-forward theme (violet, underlined headings).",
+  theme: modernTheme,
+  commands: stylingCommands
+};
+var classicLibrary = {
+  name: "classic",
+  summary: "A classic serif theme with ruled section headings.",
+  theme: classicTheme,
+  commands: stylingCommands
+};
+var compactLibrary = {
+  name: "compact",
+  summary: "A compact, single-accent theme maximizing content density.",
+  theme: compactTheme,
+  commands: stylingCommands
+};
+
+// src/types/ast.ts
+function isParent(node) {
+  return Array.isArray(node.children);
+}
+
+// src/ast/walk.ts
+function childrenOf(node) {
+  if (node.type === "list") return node.items;
+  if (node.type === "columns") return node.columns;
+  if (isParent(node)) return node.children;
+  return [];
+}
+function walk(root, opts) {
+  const visit = (node, parent) => {
+    const descend = opts.enter ? opts.enter(node, parent) : void 0;
+    if (descend !== false) {
+      for (const child of childrenOf(node)) visit(child, node);
+    }
+    opts.exit?.(node, parent);
+  };
+  visit(root, null);
+}
+function collect(root, pred) {
+  const out = [];
+  walk(root, {
+    enter(n) {
+      if (pred(n)) out.push(n);
+    }
+  });
+  return out;
+}
+
+// src/library/registry.ts
+var builtinLibraries = {
+  colors: colorsLibrary,
+  fonts: fontsLibrary,
+  shapes: shapesLibrary,
+  modern: modernLibrary,
+  classic: classicLibrary,
+  compact: compactLibrary
+};
+var ALIASES = {
+  color: "colors",
+  font: "fonts",
+  shape: "shapes"
+};
+function resolveLibraryName(name) {
+  const key = name.trim().toLowerCase();
+  if (builtinLibraries[key]) return key;
+  if (ALIASES[key]) return ALIASES[key];
+  return void 0;
+}
+function getBuiltinLibrary(name) {
+  const key = resolveLibraryName(name);
+  return key ? builtinLibraries[key] : void 0;
+}
+function builtinLibraryNames() {
+  return Object.keys(builtinLibraries);
+}
+var GATED_COMMANDS = (() => {
+  const map = {};
+  const add = (lib) => {
+    for (const c of lib.commands ?? []) map[c.name] = lib.name;
+  };
+  add(colorsLibrary);
+  add(fontsLibrary);
+  add(shapesLibrary);
+  return map;
+})();
+var dedupe = (names) => [...new Set(names)];
+function usedLibraryNamesFromTokens(tokens) {
+  const names = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t.type !== "Command" /* Command */ || t.value !== "usepackage" && t.value !== "use") {
+      continue;
+    }
+    let j = i + 1;
+    while (tokens[j] && (tokens[j].type === "Whitespace" /* Whitespace */ || tokens[j].type === "Comment" /* Comment */)) {
+      j++;
+    }
+    if (!tokens[j] || tokens[j].type !== "LBrace" /* LBrace */) continue;
+    j++;
+    let raw = "";
+    let depth = 0;
+    while (tokens[j] && !(depth === 0 && tokens[j].type === "RBrace" /* RBrace */)) {
+      const tj = tokens[j];
+      if (tj.type === "LBrace" /* LBrace */) depth++;
+      else if (tj.type === "RBrace" /* RBrace */) depth--;
+      raw += tj.type === "Command" /* Command */ ? `\\${tj.value}` : tj.value;
+      j++;
+    }
+    for (const part of raw.split(",")) {
+      const name = part.trim();
+      if (name) names.push(name);
+    }
+    i = j;
+  }
+  return dedupe(names);
+}
+function usedLibraryNamesFromAst(root) {
+  const names = [];
+  for (const node of collect(root, (n) => n.type === "usepackage")) {
+    for (const name of node.names) {
+      const trimmed = name.trim();
+      if (trimmed) names.push(trimmed);
+    }
+  }
+  return dedupe(names);
+}
+function applyLibraries(base, names, lookup = getBuiltinLibrary) {
+  const registry = base.clone();
+  const libraries = [];
+  const missing = [];
+  for (const name of names) {
+    const lib = lookup(name);
+    if (!lib) {
+      missing.push(name);
+      continue;
+    }
+    libraries.push(lib);
+    for (const cmd of lib.commands ?? []) registry.registerCommand(cmd);
+    for (const env of lib.environments ?? []) registry.registerEnvironment(env);
+  }
+  return { registry, libraries, missing };
+}
+function mergeLibraryTheme(base, libraries) {
+  let theme = base;
+  for (const lib of libraries) {
+    if (lib.theme) theme = resolveTheme(lib.theme, theme);
+  }
+  return theme;
+}
+var ZERO_RANGE3 = {
+  start: { offset: 0, line: 1, column: 1 },
+  end: { offset: 0, line: 1, column: 1 }
+};
+function libraryDiagnostics(ast, diagnostics, lookup = getBuiltinLibrary) {
+  const gated = collect(
+    ast,
+    (n) => n.type === "command" && n.name in GATED_COMMANDS
+  );
+  const gatedOffsets = new Set(
+    gated.map((n) => n.range?.start.offset).filter((o) => o != null)
+  );
+  const out = diagnostics.filter(
+    (d) => !(d.code === "RTX2001" /* UnknownCommand */ && gatedOffsets.has(d.range.start.offset))
+  );
+  for (const node of gated) {
+    const lib = GATED_COMMANDS[node.name];
+    out.push({
+      source: "parser",
+      severity: "warning" /* Warning */,
+      code: "RTX4005" /* LibraryRequired */,
+      message: `\\${node.name} requires the "${lib}" library. Add \\usepackage{${lib}} to the preamble (or engine.use(${lib}Library)).`,
+      range: node.range ?? ZERO_RANGE3
+    });
+  }
+  for (const node of collect(ast, (n) => n.type === "usepackage")) {
+    for (const name of node.names) {
+      if (lookup(name)) continue;
+      out.push({
+        source: "parser",
+        severity: "warning" /* Warning */,
+        code: "RTX4004" /* UnknownLibrary */,
+        message: `Unknown library "${name}". Available: ${builtinLibraryNames().join(", ")}.`,
+        range: node.range ?? ZERO_RANGE3
+      });
+    }
+  }
+  return out;
+}
+function collectLibraryOverrides(libraries) {
+  const html = /* @__PURE__ */ new Map();
+  const react = /* @__PURE__ */ new Map();
+  for (const lib of libraries) {
+    for (const cmd of lib.commands ?? []) {
+      if (cmd.render?.html) html.set(`command:${cmd.name}`, cmd.render.html);
+      if (cmd.render?.react) react.set(`command:${cmd.name}`, cmd.render.react);
+    }
+    for (const [k, fn] of Object.entries(lib.htmlRenderers ?? {})) html.set(k, fn);
+    for (const [k, fn] of Object.entries(lib.reactRenderers ?? {})) react.set(k, fn);
+  }
+  return { html, react };
+}
+
+exports.GATED_COMMANDS = GATED_COMMANDS;
+exports.applyLibraries = applyLibraries;
+exports.builtinLibraries = builtinLibraries;
+exports.builtinLibraryNames = builtinLibraryNames;
+exports.classicLibrary = classicLibrary;
+exports.collectLibraryOverrides = collectLibraryOverrides;
+exports.colorCommands = colorCommands;
+exports.colorsLibrary = colorsLibrary;
+exports.compactLibrary = compactLibrary;
+exports.fontCommands = fontCommands;
+exports.fontStacks = fontStacks;
+exports.fontTheme = fontTheme;
+exports.fontsLibrary = fontsLibrary;
+exports.getBuiltinLibrary = getBuiltinLibrary;
+exports.libraryDiagnostics = libraryDiagnostics;
+exports.mergeLibraryTheme = mergeLibraryTheme;
+exports.modernLibrary = modernLibrary;
+exports.palettes = palettes;
+exports.resolveLibraryName = resolveLibraryName;
+exports.shapeCommands = shapeCommands;
+exports.shapesLibrary = shapesLibrary;
+exports.usedLibraryNamesFromAst = usedLibraryNamesFromAst;
+exports.usedLibraryNamesFromTokens = usedLibraryNamesFromTokens;
+//# sourceMappingURL=library.cjs.map
+//# sourceMappingURL=library.cjs.map