@ncukondo/slide-generation 0.1.0

package/dist/index.js

@@ -0,0 +1,1469 @@
+// src/core/parser.ts
+import { z } from "zod";
+import { parse as parseYaml } from "yaml";
+import { readFile } from "fs/promises";
+var referencesConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  style: z.string().default("author-year-pmid")
+});
+var metaSchema = z.object({
+  title: z.string(),
+  author: z.string().optional(),
+  date: z.string().optional(),
+  theme: z.string().default("default"),
+  references: referencesConfigSchema.optional()
+});
+var slideSchema = z.object({
+  template: z.string(),
+  content: z.record(z.unknown()).default({}),
+  class: z.string().optional(),
+  notes: z.string().optional(),
+  raw: z.string().optional()
+});
+var presentationSchema = z.object({
+  meta: metaSchema,
+  slides: z.array(slideSchema).default([])
+});
+var ParseError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+    this.name = "ParseError";
+  }
+};
+var ValidationError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+    this.name = "ValidationError";
+  }
+};
+var Parser = class {
+  parse(yamlContent) {
+    let rawData;
+    try {
+      rawData = parseYaml(yamlContent);
+    } catch (error) {
+      throw new ParseError("Failed to parse YAML", error);
+    }
+    const result = presentationSchema.safeParse(rawData);
+    if (!result.success) {
+      throw new ValidationError(
+        "Schema validation failed",
+        result.error.format()
+      );
+    }
+    return result.data;
+  }
+  async parseFile(filePath) {
+    let content;
+    try {
+      content = await readFile(filePath, "utf-8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new ParseError(`File not found: ${filePath}`);
+      }
+      throw new ParseError(`Failed to read file: ${filePath}`, error);
+    }
+    return this.parse(content);
+  }
+};
+
+// src/core/transformer.ts
+var ICON_PLACEHOLDER_PREFIX = "___ICON_PLACEHOLDER_";
+var ICON_PLACEHOLDER_SUFFIX = "___";
+var REFS_CITE_PLACEHOLDER_PREFIX = "___REFS_CITE_PLACEHOLDER_";
+var REFS_CITE_PLACEHOLDER_SUFFIX = "___";
+var REFS_EXPAND_PLACEHOLDER_PREFIX = "___REFS_EXPAND_PLACEHOLDER_";
+var REFS_EXPAND_PLACEHOLDER_SUFFIX = "___";
+var TransformError = class extends Error {
+  constructor(message, slide, details) {
+    super(message);
+    this.slide = slide;
+    this.details = details;
+    this.name = "TransformError";
+  }
+};
+var Transformer = class {
+  constructor(templateEngine, templateLoader, iconResolver, citationFormatter) {
+    this.templateEngine = templateEngine;
+    this.templateLoader = templateLoader;
+    this.iconResolver = iconResolver;
+    this.citationFormatter = citationFormatter;
+  }
+  /**
+   * Transform a single slide using its template
+   */
+  async transform(slide, context) {
+    if (slide.template === "raw") {
+      return slide.raw ?? "";
+    }
+    const template = this.templateLoader.get(slide.template);
+    if (!template) {
+      throw new TransformError(
+        `Template "${slide.template}" not found`,
+        slide
+      );
+    }
+    const validationResult = this.templateLoader.validateContent(
+      slide.template,
+      slide.content
+    );
+    if (!validationResult.valid) {
+      throw new TransformError(
+        `Slide content validation failed: ${validationResult.errors?.join(", ")}`,
+        slide,
+        validationResult.errors
+      );
+    }
+    const pending = {
+      icons: /* @__PURE__ */ new Map(),
+      cites: /* @__PURE__ */ new Map(),
+      expands: /* @__PURE__ */ new Map()
+    };
+    const templateContext = this.buildTemplateContext(slide, context, pending);
+    let output = this.templateEngine.render(template.output, templateContext);
+    output = await this.resolvePlaceholders(output, pending);
+    if (slide.class) {
+      output = `<!-- _class: ${slide.class} -->
+${output}`;
+    }
+    return output.trim();
+  }
+  /**
+   * Transform all slides in a presentation
+   */
+  async transformAll(presentation) {
+    const results = [];
+    const totalSlides = presentation.slides.length;
+    for (let i = 0; i < presentation.slides.length; i++) {
+      const slide = presentation.slides[i];
+      const context = {
+        meta: presentation.meta,
+        slideIndex: i,
+        totalSlides
+      };
+      const transformed = await this.transform(slide, context);
+      results.push(transformed);
+    }
+    return results;
+  }
+  /**
+   * Build the full template context with helpers that collect async operations
+   */
+  buildTemplateContext(slide, context, pending) {
+    let iconCounter = 0;
+    let citeCounter = 0;
+    let expandCounter = 0;
+    const icons = {
+      render: (name, options) => {
+        const id = `${iconCounter++}`;
+        const placeholder = `${ICON_PLACEHOLDER_PREFIX}${id}${ICON_PLACEHOLDER_SUFFIX}`;
+        pending.icons.set(id, { name, options });
+        return placeholder;
+      }
+    };
+    const refs = {
+      cite: (id) => {
+        const counterId = `${citeCounter++}`;
+        const placeholder = `${REFS_CITE_PLACEHOLDER_PREFIX}${counterId}${REFS_CITE_PLACEHOLDER_SUFFIX}`;
+        pending.cites.set(counterId, id);
+        return placeholder;
+      },
+      expand: (text) => {
+        const counterId = `${expandCounter++}`;
+        const placeholder = `${REFS_EXPAND_PLACEHOLDER_PREFIX}${counterId}${REFS_EXPAND_PLACEHOLDER_SUFFIX}`;
+        pending.expands.set(counterId, text);
+        return placeholder;
+      }
+    };
+    return {
+      content: slide.content,
+      meta: {
+        title: context.meta.title,
+        author: context.meta.author,
+        theme: context.meta.theme
+      },
+      slide: {
+        index: context.slideIndex,
+        total: context.totalSlides
+      },
+      icons,
+      refs
+    };
+  }
+  /**
+   * Resolve all placeholders by executing async operations
+   */
+  async resolvePlaceholders(output, pending) {
+    const iconResults = /* @__PURE__ */ new Map();
+    for (const [id, { name, options }] of pending.icons) {
+      const rendered = await this.iconResolver.render(
+        name,
+        options
+      );
+      iconResults.set(id, rendered);
+    }
+    const citeResults = /* @__PURE__ */ new Map();
+    for (const [counterId, id] of pending.cites) {
+      const formatted = await this.citationFormatter.formatInline(id);
+      citeResults.set(counterId, formatted);
+    }
+    const expandResults = /* @__PURE__ */ new Map();
+    for (const [counterId, text] of pending.expands) {
+      const expanded = await this.citationFormatter.expandCitations(text);
+      expandResults.set(counterId, expanded);
+    }
+    let result = output;
+    for (const [id, rendered] of iconResults) {
+      const placeholder = `${ICON_PLACEHOLDER_PREFIX}${id}${ICON_PLACEHOLDER_SUFFIX}`;
+      result = result.replace(placeholder, rendered);
+    }
+    for (const [counterId, formatted] of citeResults) {
+      const placeholder = `${REFS_CITE_PLACEHOLDER_PREFIX}${counterId}${REFS_CITE_PLACEHOLDER_SUFFIX}`;
+      result = result.replace(placeholder, formatted);
+    }
+    for (const [counterId, expanded] of expandResults) {
+      const placeholder = `${REFS_EXPAND_PLACEHOLDER_PREFIX}${counterId}${REFS_EXPAND_PLACEHOLDER_SUFFIX}`;
+      result = result.replace(placeholder, expanded);
+    }
+    return result;
+  }
+};
+
+// src/core/renderer.ts
+var Renderer = class {
+  /**
+   * Render slides and metadata into final Marp markdown
+   */
+  render(slides, meta, options) {
+    const frontMatter = this.renderFrontMatter(meta, options);
+    const slidesContent = this.joinSlides(slides, options?.notes);
+    if (slides.length === 0) {
+      return frontMatter;
+    }
+    return `${frontMatter}
+
+${slidesContent}`;
+  }
+  /**
+   * Render the YAML front matter block
+   */
+  renderFrontMatter(meta, options) {
+    const lines = ["---", "marp: true"];
+    lines.push(`title: ${meta.title}`);
+    if (meta.author) {
+      lines.push(`author: ${meta.author}`);
+    }
+    if (meta.date) {
+      lines.push(`date: ${meta.date}`);
+    }
+    const includeTheme = options?.includeTheme ?? true;
+    if (includeTheme && meta.theme) {
+      lines.push(`theme: ${meta.theme}`);
+    }
+    if (options?.additionalFrontMatter) {
+      for (const [key, value] of Object.entries(options.additionalFrontMatter)) {
+        lines.push(`${key}: ${this.formatFrontMatterValue(value)}`);
+      }
+    }
+    lines.push("---");
+    return lines.join("\n");
+  }
+  /**
+   * Format a front matter value for YAML
+   */
+  formatFrontMatterValue(value) {
+    if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    }
+    if (typeof value === "number") {
+      return String(value);
+    }
+    if (typeof value === "string") {
+      if (/[:#[\]{}|>]/.test(value)) {
+        return `"${value.replace(/"/g, '\\"')}"`;
+      }
+      return value;
+    }
+    return String(value);
+  }
+  /**
+   * Join slides with Marp slide separator
+   */
+  joinSlides(slides, notes) {
+    const parts = [];
+    for (let i = 0; i < slides.length; i++) {
+      let slideContent = slides[i];
+      const note = notes?.[i];
+      if (note && note.trim()) {
+        slideContent = `${slideContent}
+
+${this.renderSpeakerNotes(note)}`;
+      }
+      parts.push(slideContent);
+    }
+    return parts.map((slide) => `---
+
+${slide}`).join("\n\n");
+  }
+  /**
+   * Render speaker notes as HTML comment
+   */
+  renderSpeakerNotes(notes) {
+    return `<!--
+${notes}
+-->`;
+  }
+};
+
+// src/core/pipeline.ts
+import { writeFile } from "fs/promises";
+
+// src/templates/engine.ts
+import nunjucks from "nunjucks";
+var TemplateEngine = class {
+  env;
+  constructor() {
+    this.env = new nunjucks.Environment(null, {
+      autoescape: false,
+      // HTML output for Marp
+      throwOnUndefined: false
+    });
+    this.registerFilters();
+    this.registerGlobals();
+  }
+  render(template, context) {
+    return this.env.renderString(template, context);
+  }
+  registerFilters() {
+  }
+  registerGlobals() {
+    const icons = {
+      render: (name, options) => {
+        const size = options?.["size"] ?? "24px";
+        const color = options?.["color"] ?? "currentColor";
+        return `<span class="icon icon-${name}" style="font-size: ${size}; color: ${color};">[${name}]</span>`;
+      }
+    };
+    this.env.addGlobal("icons", icons);
+    const refs = {
+      cite: (id) => {
+        const cleanId = id.replace("@", "");
+        return `(${cleanId})`;
+      },
+      expand: (text) => {
+        return text.replace(/\[@(\w+)\]/g, "($1)");
+      }
+    };
+    this.env.addGlobal("refs", refs);
+  }
+};
+
+// src/templates/loader.ts
+import { z as z3 } from "zod";
+import * as yaml from "yaml";
+import * as fs from "fs/promises";
+import * as path from "path";
+
+// src/templates/validators.ts
+import { z as z2 } from "zod";
+function jsonSchemaToZod(schema) {
+  if (schema.oneOf && schema.oneOf.length > 0) {
+    const schemas = schema.oneOf.map((s) => jsonSchemaToZod(s));
+    if (schemas.length === 1) {
+      return schemas[0];
+    }
+    return z2.union(schemas);
+  }
+  const type = schema.type ?? "object";
+  switch (type) {
+    case "string": {
+      if (schema.enum && schema.enum.length > 0) {
+        const enumValues = schema.enum;
+        return z2.enum(enumValues);
+      }
+      let zodSchema = z2.string();
+      if (schema.pattern) {
+        zodSchema = zodSchema.regex(new RegExp(schema.pattern));
+      }
+      return zodSchema;
+    }
+    case "number":
+      return z2.number();
+    case "integer":
+      return z2.number().int();
+    case "boolean":
+      return z2.boolean();
+    case "array": {
+      const itemSchema = schema.items ? jsonSchemaToZod(schema.items) : z2.unknown();
+      let arraySchema = z2.array(itemSchema);
+      if (schema.minItems !== void 0) {
+        arraySchema = arraySchema.min(schema.minItems);
+      }
+      if (schema.maxItems !== void 0) {
+        arraySchema = arraySchema.max(schema.maxItems);
+      }
+      return arraySchema;
+    }
+    case "object": {
+      if (!schema.properties) {
+        return z2.record(z2.unknown());
+      }
+      const shape = {};
+      const required = new Set(schema.required ?? []);
+      for (const [key, propSchema] of Object.entries(schema.properties)) {
+        const propZod = jsonSchemaToZod(propSchema);
+        shape[key] = required.has(key) ? propZod : propZod.optional();
+      }
+      return z2.object(shape).passthrough();
+    }
+    default:
+      return z2.unknown();
+  }
+}
+function validateWithJsonSchema(schema, content) {
+  const zodSchema = jsonSchemaToZod(schema);
+  const result = zodSchema.safeParse(content);
+  if (result.success) {
+    return { valid: true, errors: [] };
+  }
+  const errors = result.error.errors.map((issue) => {
+    const path3 = issue.path.join(".");
+    return path3 ? `${path3}: ${issue.message}` : issue.message;
+  });
+  return { valid: false, errors };
+}
+
+// src/templates/loader.ts
+var jsonSchemaSchema = z3.record(z3.unknown());
+var templateDefSchema = z3.object({
+  name: z3.string().min(1, "Template name is required"),
+  description: z3.string(),
+  category: z3.string(),
+  schema: jsonSchemaSchema,
+  example: z3.record(z3.unknown()).optional(),
+  output: z3.string().min(1, "Template output is required"),
+  css: z3.string().optional()
+});
+var TemplateLoader = class {
+  templates;
+  constructor() {
+    this.templates = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Load a template from a YAML string
+   */
+  async loadFromString(yamlContent) {
+    const parsed = yaml.parse(yamlContent);
+    const result = templateDefSchema.safeParse(parsed);
+    if (!result.success) {
+      const errors = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+      throw new Error(`Invalid template definition: ${errors}`);
+    }
+    this.templates.set(result.data.name, result.data);
+  }
+  /**
+   * Load a template from a file
+   */
+  async loadFromFile(filePath) {
+    const content = await fs.readFile(filePath, "utf-8");
+    await this.loadFromString(content);
+  }
+  /**
+   * Load all templates from a directory (recursively)
+   */
+  async loadBuiltIn(directory) {
+    await this.loadDirectory(directory);
+  }
+  /**
+   * Load custom templates from a directory (can override built-in)
+   */
+  async loadCustom(directory) {
+    await this.loadDirectory(directory);
+  }
+  /**
+   * Internal method to load templates from a directory
+   */
+  async loadDirectory(directory) {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        await this.loadDirectory(fullPath);
+      } else if (entry.isFile() && (entry.name.endsWith(".yaml") || entry.name.endsWith(".yml"))) {
+        await this.loadFromFile(fullPath);
+      }
+    }
+  }
+  /**
+   * Get a template by name
+   */
+  get(name) {
+    return this.templates.get(name);
+  }
+  /**
+   * List all loaded templates
+   */
+  list() {
+    return Array.from(this.templates.values());
+  }
+  /**
+   * List templates filtered by category
+   */
+  listByCategory(category) {
+    return this.list().filter((t) => t.category === category);
+  }
+  /**
+   * Validate content against a template's schema
+   */
+  validateContent(templateName, content) {
+    const template = this.get(templateName);
+    if (!template) {
+      return {
+        valid: false,
+        errors: [`Template "${templateName}" not found`]
+      };
+    }
+    return validateWithJsonSchema(template.schema, content);
+  }
+};
+
+// src/icons/registry.ts
+import * as fs2 from "fs/promises";
+import { parse as parseYaml2 } from "yaml";
+
+// src/icons/schema.ts
+import { z as z4 } from "zod";
+var iconSourceTypeSchema = z4.enum([
+  "web-font",
+  "svg-inline",
+  "svg-sprite",
+  "local-svg"
+]);
+var iconSourceSchema = z4.object({
+  name: z4.string(),
+  type: iconSourceTypeSchema,
+  prefix: z4.string(),
+  url: z4.string().optional(),
+  path: z4.string().optional(),
+  render: z4.string().optional()
+});
+var iconDefaultsSchema = z4.object({
+  size: z4.string().default("24px"),
+  color: z4.string().default("currentColor")
+});
+var iconRegistrySchema = z4.object({
+  sources: z4.array(iconSourceSchema),
+  aliases: z4.record(z4.string()).default({}),
+  colors: z4.record(z4.string()).optional(),
+  defaults: iconDefaultsSchema.default({})
+});
+
+// src/icons/registry.ts
+var IconRegistryLoader = class {
+  registry = null;
+  sourcesByPrefix = /* @__PURE__ */ new Map();
+  aliasMap = /* @__PURE__ */ new Map();
+  colorMap = /* @__PURE__ */ new Map();
+  /**
+   * Load registry from YAML file
+   */
+  async load(configPath) {
+    const content = await fs2.readFile(configPath, "utf-8");
+    const parsed = parseYaml2(content);
+    const validated = iconRegistrySchema.parse(parsed);
+    this.registry = validated;
+    this.buildMaps();
+    return validated;
+  }
+  /**
+   * Resolve an alias to its icon reference
+   * @returns The resolved icon reference or the original name if not an alias
+   */
+  resolveAlias(nameOrAlias) {
+    return this.aliasMap.get(nameOrAlias) ?? nameOrAlias;
+  }
+  /**
+   * Get icon source by prefix
+   */
+  getSource(prefix) {
+    return this.sourcesByPrefix.get(prefix);
+  }
+  /**
+   * Parse an icon reference string (e.g., "mi:home" or "iconify:mdi:account")
+   * @returns Parsed reference or null if invalid format
+   */
+  parseIconReference(reference) {
+    const colonIndex = reference.indexOf(":");
+    if (colonIndex === -1) {
+      return null;
+    }
+    const prefix = reference.substring(0, colonIndex);
+    const name = reference.substring(colonIndex + 1);
+    return { prefix, name };
+  }
+  /**
+   * Get registry defaults
+   */
+  getDefaults() {
+    if (!this.registry) {
+      return { size: "24px", color: "currentColor" };
+    }
+    return this.registry.defaults;
+  }
+  /**
+   * Get color by name from color palette
+   */
+  getColor(name) {
+    return this.colorMap.get(name);
+  }
+  /**
+   * Get all sources
+   */
+  getSources() {
+    return this.registry?.sources ?? [];
+  }
+  /**
+   * Get all aliases
+   */
+  getAliases() {
+    return this.registry?.aliases ?? {};
+  }
+  /**
+   * Check if registry is loaded
+   */
+  isLoaded() {
+    return this.registry !== null;
+  }
+  /**
+   * Build internal lookup maps from registry
+   */
+  buildMaps() {
+    this.sourcesByPrefix.clear();
+    this.aliasMap.clear();
+    this.colorMap.clear();
+    if (!this.registry) {
+      return;
+    }
+    for (const source of this.registry.sources) {
+      this.sourcesByPrefix.set(source.prefix, source);
+    }
+    for (const [alias, target] of Object.entries(this.registry.aliases)) {
+      this.aliasMap.set(alias, target);
+    }
+    if (this.registry.colors) {
+      for (const [name, color] of Object.entries(this.registry.colors)) {
+        this.colorMap.set(name, color);
+      }
+    }
+  }
+};
+
+// src/icons/resolver.ts
+import * as fs3 from "fs/promises";
+import * as path2 from "path";
+import nunjucks2 from "nunjucks";
+var IconResolver = class {
+  constructor(registry) {
+    this.registry = registry;
+    this.nunjucksEnv = new nunjucks2.Environment(null, {
+      autoescape: false
+    });
+  }
+  nunjucksEnv;
+  /**
+   * Render an icon by name or alias
+   */
+  async render(nameOrAlias, options) {
+    const resolved = this.registry.resolveAlias(nameOrAlias);
+    const parsed = this.registry.parseIconReference(resolved);
+    if (!parsed) {
+      throw new Error(
+        `Invalid icon reference format: "${resolved}". Expected format: "prefix:name"`
+      );
+    }
+    const source = this.registry.getSource(parsed.prefix);
+    if (!source) {
+      throw new Error(`Unknown icon source prefix: "${parsed.prefix}"`);
+    }
+    const defaults = this.registry.getDefaults();
+    const mergedOptions = {
+      size: options?.size ?? defaults.size,
+      color: options?.color ?? defaults.color,
+      ...options?.class !== void 0 ? { class: options.class } : {}
+    };
+    switch (source.type) {
+      case "web-font":
+        return this.renderWebFont(source, parsed.name, mergedOptions);
+      case "local-svg":
+        return await this.renderLocalSvg(source, parsed.name, mergedOptions);
+      case "svg-inline":
+        return await this.renderSvgInline(source, parsed.name, mergedOptions);
+      case "svg-sprite":
+        return this.renderSvgSprite(source, parsed.name, mergedOptions);
+      default:
+        throw new Error(`Unsupported icon source type: "${source.type}"`);
+    }
+  }
+  /**
+   * Render a web-font icon
+   */
+  renderWebFont(source, name, options) {
+    const style = this.buildStyle(options);
+    const className = this.buildClassName(name, options);
+    if (source.render) {
+      return this.nunjucksEnv.renderString(source.render, {
+        name,
+        style,
+        class: className,
+        size: options.size,
+        color: options.color
+      });
+    }
+    return `<span class="${className}" style="${style}">${name}</span>`;
+  }
+  /**
+   * Render a local SVG icon
+   */
+  async renderLocalSvg(source, name, options) {
+    if (!source.path) {
+      throw new Error(`Local SVG source "${source.name}" has no path defined`);
+    }
+    const svgPath = path2.join(source.path, `${name}.svg`);
+    try {
+      const svgContent = await fs3.readFile(svgPath, "utf-8");
+      return this.processSvg(svgContent, name, options);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`Icon file not found: ${svgPath}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Render an SVG from external URL (placeholder without cache)
+   */
+  async renderSvgInline(source, name, options) {
+    const className = this.buildClassName(name, options);
+    const style = this.buildStyle(options);
+    return `<span class="${className}" style="${style}" data-icon-source="${source.name}" data-icon-name="${name}">[${name}]</span>`;
+  }
+  /**
+   * Render an SVG sprite reference
+   */
+  renderSvgSprite(source, name, options) {
+    const className = this.buildClassName(name, options);
+    const size = options.size ?? "24px";
+    const color = options.color ?? "currentColor";
+    const spriteUrl = source.url ?? "";
+    return `<svg class="${className}" width="${size}" height="${size}" fill="${color}">
+  <use xlink:href="${spriteUrl}#${name}"/>
+</svg>`;
+  }
+  /**
+   * Process SVG content and apply options
+   */
+  processSvg(svgContent, name, options) {
+    const className = this.buildClassName(name, options);
+    const size = options.size ?? "24px";
+    const color = options.color ?? "currentColor";
+    let processed = svgContent.trim();
+    if (processed.includes("class=")) {
+      processed = processed.replace(/class="[^"]*"/, `class="${className}"`);
+    } else {
+      processed = processed.replace("<svg", `<svg class="${className}"`);
+    }
+    if (processed.includes("width=")) {
+      processed = processed.replace(/width="[^"]*"/, `width="${size}"`);
+    } else {
+      processed = processed.replace("<svg", `<svg width="${size}"`);
+    }
+    if (processed.includes("height=")) {
+      processed = processed.replace(/height="[^"]*"/, `height="${size}"`);
+    } else {
+      processed = processed.replace("<svg", `<svg height="${size}"`);
+    }
+    if (color !== "currentColor") {
+      processed = processed.replace(/fill="currentColor"/g, `fill="${color}"`);
+    }
+    return processed;
+  }
+  /**
+   * Build CSS style string
+   */
+  buildStyle(options) {
+    const styles = [];
+    if (options.size) {
+      styles.push(`font-size: ${options.size}`);
+    }
+    if (options.color) {
+      styles.push(`color: ${options.color}`);
+    }
+    return styles.join("; ");
+  }
+  /**
+   * Build class name string
+   */
+  buildClassName(name, options) {
+    const classes = ["icon", `icon-${name}`];
+    if (options.class) {
+      classes.push(options.class);
+    }
+    return classes.join(" ");
+  }
+};
+
+// src/references/manager.ts
+import { exec } from "child_process";
+var ReferenceManagerError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "ReferenceManagerError";
+  }
+};
+var ReferenceManager = class {
+  constructor(command = "ref") {
+    this.command = command;
+  }
+  /**
+   * Check if reference-manager CLI is available
+   */
+  async isAvailable() {
+    try {
+      await this.execCommand(`${this.command} --version`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get all references from the library
+   */
+  async getAll() {
+    const result = await this.execCommand(`${this.command} list --format json`);
+    return this.parseJSON(result);
+  }
+  /**
+   * Get a single reference by ID
+   */
+  async getById(id) {
+    const result = await this.execCommand(
+      `${this.command} list --id ${id} --format json`
+    );
+    const items = this.parseJSON(result);
+    return items[0] || null;
+  }
+  /**
+   * Get multiple references by IDs
+   */
+  async getByIds(ids) {
+    if (ids.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const result = await this.execCommand(`${this.command} list --format json`);
+    const allItems = this.parseJSON(result);
+    const idSet = new Set(ids);
+    const map = /* @__PURE__ */ new Map();
+    for (const item of allItems) {
+      if (idSet.has(item.id)) {
+        map.set(item.id, item);
+      }
+    }
+    return map;
+  }
+  execCommand(cmd) {
+    return new Promise((resolve, reject) => {
+      exec(cmd, (error, stdout) => {
+        if (error) {
+          reject(
+            new ReferenceManagerError(`Failed to execute: ${cmd}`, error)
+          );
+          return;
+        }
+        resolve(stdout.toString());
+      });
+    });
+  }
+  parseJSON(data) {
+    try {
+      return JSON.parse(data);
+    } catch (error) {
+      throw new ReferenceManagerError(
+        "Failed to parse reference-manager output as JSON",
+        error
+      );
+    }
+  }
+};
+
+// src/references/extractor.ts
+var SINGLE_CITATION_PATTERN = /@([\w-]+)(?:,\s*([^;\]]+))?/g;
+var CITATION_BRACKET_PATTERN = /\[(@[\w-]+(?:,\s*[^;\]]+)?(?:;\s*@[\w-]+(?:,\s*[^;\]]+)?)*)\]/g;
+var SOURCE_CITATION_PATTERN = /^@([\w-]+)$/;
+var CitationExtractor = class {
+  /**
+   * Extract citations from a text string
+   */
+  extract(text) {
+    const citations = [];
+    let bracketMatch;
+    CITATION_BRACKET_PATTERN.lastIndex = 0;
+    while ((bracketMatch = CITATION_BRACKET_PATTERN.exec(text)) !== null) {
+      const bracketStart = bracketMatch.index;
+      const bracketContent = bracketMatch[1];
+      SINGLE_CITATION_PATTERN.lastIndex = 0;
+      let singleMatch;
+      while ((singleMatch = SINGLE_CITATION_PATTERN.exec(bracketContent)) !== null) {
+        const id = singleMatch[1];
+        const locator = singleMatch[2]?.trim();
+        citations.push({
+          id,
+          locator: locator ?? void 0,
+          position: {
+            start: bracketStart,
+            end: bracketStart + bracketMatch[0].length
+          }
+        });
+      }
+    }
+    return citations;
+  }
+  /**
+   * Extract citations from a slide's content
+   */
+  extractFromSlide(slide) {
+    const allCitations = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    const extractFromValue = (value) => {
+      if (typeof value === "string") {
+        const sourceMatch = SOURCE_CITATION_PATTERN.exec(value);
+        if (sourceMatch && sourceMatch[1]) {
+          const id = sourceMatch[1];
+          if (!seenIds.has(id)) {
+            seenIds.add(id);
+            allCitations.push({
+              id,
+              locator: void 0,
+              position: { start: 0, end: value.length }
+            });
+          }
+          return;
+        }
+        const citations = this.extract(value);
+        for (const citation of citations) {
+          if (!seenIds.has(citation.id)) {
+            seenIds.add(citation.id);
+            allCitations.push(citation);
+          }
+        }
+      } else if (Array.isArray(value)) {
+        for (const item of value) {
+          extractFromValue(item);
+        }
+      } else if (value && typeof value === "object") {
+        for (const v of Object.values(value)) {
+          extractFromValue(v);
+        }
+      }
+    };
+    extractFromValue(slide.content);
+    if (slide.notes) {
+      const notesCitations = this.extract(slide.notes);
+      for (const citation of notesCitations) {
+        if (!seenIds.has(citation.id)) {
+          seenIds.add(citation.id);
+          allCitations.push(citation);
+        }
+      }
+    }
+    return allCitations;
+  }
+  /**
+   * Extract citations from all slides in a presentation
+   */
+  extractFromPresentation(presentation) {
+    const allCitations = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const slide of presentation.slides) {
+      const slideCitations = this.extractFromSlide(slide);
+      for (const citation of slideCitations) {
+        if (!seenIds.has(citation.id)) {
+          seenIds.add(citation.id);
+          allCitations.push(citation);
+        }
+      }
+    }
+    return allCitations;
+  }
+  /**
+   * Get unique citation IDs in order of first appearance
+   */
+  getUniqueIds(citations) {
+    const seen = /* @__PURE__ */ new Set();
+    const uniqueIds = [];
+    for (const citation of citations) {
+      if (!seen.has(citation.id)) {
+        seen.add(citation.id);
+        uniqueIds.push(citation.id);
+      }
+    }
+    return uniqueIds;
+  }
+};
+
+// src/references/formatter.ts
+var DEFAULT_CONFIG = {
+  author: {
+    maxAuthors: 2,
+    etAl: "et al.",
+    etAlJa: "\u307B\u304B",
+    separatorJa: "\u30FB"
+  },
+  inline: {
+    authorSep: ", ",
+    identifierSep: "; ",
+    multiSep: "), ("
+  }
+};
+var JAPANESE_PATTERN = /[\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FAF]/;
+var CITATION_BRACKET_PATTERN2 = /\[(@[\w-]+(?:,\s*[^;\]]+)?(?:;\s*@[\w-]+(?:,\s*[^;\]]+)?)*)\]/g;
+var SINGLE_CITATION_PATTERN2 = /@([\w-]+)(?:,\s*([^;\]]+))?/g;
+var CitationFormatter = class {
+  constructor(manager, config) {
+    this.manager = manager;
+    this.config = {
+      author: { ...DEFAULT_CONFIG.author, ...config?.author },
+      inline: { ...DEFAULT_CONFIG.inline, ...config?.inline }
+    };
+  }
+  config;
+  /**
+   * Format an inline citation
+   * e.g., "(Smith et al., 2024; PMID: 12345678)"
+   */
+  async formatInline(id) {
+    const item = await this.manager.getById(id);
+    if (!item) {
+      return `[${id}]`;
+    }
+    return this.formatInlineItem(item);
+  }
+  /**
+   * Format a full bibliography citation
+   */
+  async formatFull(id) {
+    const item = await this.manager.getById(id);
+    if (!item) {
+      return `[${id}]`;
+    }
+    return this.formatFullItem(item);
+  }
+  /**
+   * Expand all citations in text
+   * e.g., "[@smith2024]" -> "(Smith et al., 2024; PMID: 12345678)"
+   */
+  async expandCitations(text) {
+    const ids = /* @__PURE__ */ new Set();
+    CITATION_BRACKET_PATTERN2.lastIndex = 0;
+    let match;
+    while ((match = CITATION_BRACKET_PATTERN2.exec(text)) !== null) {
+      const content = match[1];
+      SINGLE_CITATION_PATTERN2.lastIndex = 0;
+      let singleMatch;
+      while ((singleMatch = SINGLE_CITATION_PATTERN2.exec(content)) !== null) {
+        ids.add(singleMatch[1]);
+      }
+    }
+    const items = await this.manager.getByIds([...ids]);
+    CITATION_BRACKET_PATTERN2.lastIndex = 0;
+    let result = text;
+    const matches = [];
+    CITATION_BRACKET_PATTERN2.lastIndex = 0;
+    while ((match = CITATION_BRACKET_PATTERN2.exec(text)) !== null) {
+      const content = match[1];
+      const replacements = [];
+      SINGLE_CITATION_PATTERN2.lastIndex = 0;
+      let singleMatch;
+      while ((singleMatch = SINGLE_CITATION_PATTERN2.exec(content)) !== null) {
+        const id = singleMatch[1];
+        const item = items.get(id);
+        if (item) {
+          replacements.push(this.formatInlineItem(item));
+        } else {
+          replacements.push(`[${id}]`);
+        }
+      }
+      matches.push({
+        start: match.index,
+        end: match.index + match[0].length,
+        replacement: replacements.join(", ")
+      });
+    }
+    for (const m of [...matches].reverse()) {
+      result = result.slice(0, m.start) + m.replacement + result.slice(m.end);
+    }
+    return result;
+  }
+  /**
+   * Generate bibliography entries
+   */
+  async generateBibliography(ids, sort = "citation-order") {
+    if (ids.length === 0) {
+      return [];
+    }
+    const items = await this.manager.getByIds(ids);
+    let sortedItems;
+    if (sort === "citation-order") {
+      sortedItems = ids.map((id) => items.get(id)).filter((item) => item !== void 0);
+    } else if (sort === "author") {
+      sortedItems = [...items.values()].sort((a, b) => {
+        const authorA = this.getFirstAuthorFamily(a);
+        const authorB = this.getFirstAuthorFamily(b);
+        return authorA.localeCompare(authorB);
+      });
+    } else {
+      sortedItems = [...items.values()].sort((a, b) => {
+        const yearA = this.getYear(a);
+        const yearB = this.getYear(b);
+        return yearA - yearB;
+      });
+    }
+    return sortedItems.map((item) => this.formatFullItem(item));
+  }
+  formatInlineItem(item) {
+    const author = this.formatAuthorInline(item.author);
+    const year = this.getYear(item);
+    const identifier = this.getIdentifier(item);
+    if (identifier) {
+      return `(${author}, ${year}; ${identifier})`;
+    }
+    return `(${author}, ${year})`;
+  }
+  formatFullItem(item) {
+    const parts = [];
+    const isJapanese = this.isJapaneseAuthors(item.author);
+    const authors = this.formatAuthorsFull(item.author, isJapanese);
+    parts.push(authors);
+    const year = this.getYear(item);
+    parts.push(`(${year}).`);
+    if (item.title) {
+      parts.push(`${item.title}.`);
+    }
+    if (item["container-title"]) {
+      const journal = isJapanese ? item["container-title"] : `*${item["container-title"]}*`;
+      let location = "";
+      if (item.volume) {
+        location = item.issue ? `${item.volume}(${item.issue})` : item.volume;
+      }
+      if (item.page) {
+        location = location ? `${location}, ${item.page}` : item.page;
+      }
+      parts.push(location ? `${journal}, ${location}.` : `${journal}.`);
+    }
+    const identifier = this.getIdentifier(item);
+    if (identifier) {
+      parts.push(identifier);
+    }
+    return parts.join(" ");
+  }
+  formatAuthorInline(authors) {
+    if (!authors || authors.length === 0) {
+      return "Unknown";
+    }
+    const isJapanese = this.isJapaneseAuthors(authors);
+    const { etAl, etAlJa, separatorJa } = this.config.author;
+    const firstAuthor = authors[0];
+    if (authors.length === 1) {
+      return firstAuthor.family;
+    }
+    if (authors.length === 2) {
+      const separator = isJapanese ? separatorJa : " & ";
+      return `${firstAuthor.family}${separator}${authors[1].family}`;
+    }
+    const suffix = isJapanese ? etAlJa : ` ${etAl}`;
+    return `${firstAuthor.family}${suffix}`;
+  }
+  formatAuthorsFull(authors, isJapanese) {
+    if (!authors || authors.length === 0) {
+      return "Unknown";
+    }
+    if (isJapanese) {
+      return authors.map((a) => `${a.family}${a.given || ""}`).join(", ");
+    }
+    if (authors.length === 1) {
+      const a = authors[0];
+      const initial = a.given ? `${a.given.charAt(0)}.` : "";
+      return `${a.family}, ${initial}`;
+    }
+    const formatted = authors.map((a, i) => {
+      const initial = a.given ? `${a.given.charAt(0)}.` : "";
+      if (i === authors.length - 1) {
+        return `& ${a.family}, ${initial}`;
+      }
+      return `${a.family}, ${initial}`;
+    });
+    return formatted.join(", ").replace(", &", ", &");
+  }
+  isJapaneseAuthors(authors) {
+    if (!authors || authors.length === 0) {
+      return false;
+    }
+    return JAPANESE_PATTERN.test(authors[0].family);
+  }
+  getFirstAuthorFamily(item) {
+    return item.author?.[0]?.family || "";
+  }
+  getYear(item) {
+    const dateParts = item.issued?.["date-parts"];
+    if (dateParts && dateParts[0] && dateParts[0][0]) {
+      return dateParts[0][0];
+    }
+    return 0;
+  }
+  getIdentifier(item) {
+    if (item.PMID) {
+      return `PMID: ${item.PMID}`;
+    }
+    if (item.DOI) {
+      return `DOI: ${item.DOI}`;
+    }
+    return null;
+  }
+};
+
+// src/core/pipeline.ts
+var PipelineError = class extends Error {
+  constructor(message, stage, details) {
+    super(message);
+    this.stage = stage;
+    this.details = details;
+    this.name = "PipelineError";
+  }
+};
+var Pipeline = class {
+  constructor(config) {
+    this.config = config;
+    this.parser = new Parser();
+    this.templateEngine = new TemplateEngine();
+    this.templateLoader = new TemplateLoader();
+    this.iconRegistry = new IconRegistryLoader();
+    this.iconResolver = new IconResolver(this.iconRegistry);
+    this.referenceManager = new ReferenceManager(
+      config.references.connection.command
+    );
+    this.citationExtractor = new CitationExtractor();
+    this.citationFormatter = new CitationFormatter(
+      this.referenceManager,
+      {
+        author: {
+          maxAuthors: config.references.format.maxAuthors,
+          etAl: config.references.format.etAl,
+          etAlJa: config.references.format.etAlJa
+        },
+        inline: {
+          authorSep: config.references.format.authorSep,
+          identifierSep: config.references.format.identifierSep
+        }
+      }
+    );
+    this.transformer = new Transformer(
+      this.templateEngine,
+      this.templateLoader,
+      this.iconResolver,
+      this.citationFormatter
+    );
+    this.renderer = new Renderer();
+  }
+  parser;
+  templateEngine;
+  templateLoader;
+  iconRegistry;
+  iconResolver;
+  referenceManager;
+  citationExtractor;
+  citationFormatter;
+  transformer;
+  renderer;
+  warnings = [];
+  /**
+   * Run the full conversion pipeline
+   */
+  async run(inputPath, options) {
+    this.warnings = [];
+    try {
+      const presentation = await this.parseSource(inputPath);
+      const citationIds = this.collectCitations(presentation);
+      await this.resolveReferences(citationIds);
+      const transformedSlides = await this.transformSlides(presentation);
+      const output = this.render(transformedSlides, presentation);
+      if (options?.outputPath) {
+        await writeFile(options.outputPath, output, "utf-8");
+      }
+      return output;
+    } catch (error) {
+      if (error instanceof PipelineError) {
+        throw error;
+      }
+      throw new PipelineError(
+        error instanceof Error ? error.message : "Unknown error",
+        "unknown",
+        error
+      );
+    }
+  }
+  /**
+   * Run the full pipeline with detailed result
+   */
+  async runWithResult(inputPath, options) {
+    this.warnings = [];
+    try {
+      const presentation = await this.parseSource(inputPath);
+      const citationIds = this.collectCitations(presentation);
+      await this.resolveReferences(citationIds);
+      const transformedSlides = await this.transformSlides(presentation);
+      const output = this.render(transformedSlides, presentation);
+      if (options?.outputPath) {
+        await writeFile(options.outputPath, output, "utf-8");
+      }
+      return {
+        output,
+        citations: citationIds,
+        warnings: this.warnings,
+        slideCount: presentation.slides.length
+      };
+    } catch (error) {
+      if (error instanceof PipelineError) {
+        throw error;
+      }
+      throw new PipelineError(
+        error instanceof Error ? error.message : "Unknown error",
+        "unknown",
+        error
+      );
+    }
+  }
+  /**
+   * Initialize the pipeline by loading templates and icon registry
+   */
+  async initialize() {
+    try {
+      await this.templateLoader.loadBuiltIn(this.config.templates.builtin);
+      if (this.config.templates.custom) {
+        await this.templateLoader.loadCustom(this.config.templates.custom);
+      }
+      await this.iconRegistry.load(this.config.icons.registry);
+    } catch (error) {
+      throw new PipelineError(
+        `Failed to initialize pipeline: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "initialize",
+        error
+      );
+    }
+  }
+  /**
+   * Get collected warnings
+   */
+  getWarnings() {
+    return [...this.warnings];
+  }
+  // --- Private Stage Methods ---
+  /**
+   * Stage 1: Parse the YAML source file
+   */
+  async parseSource(inputPath) {
+    try {
+      return await this.parser.parseFile(inputPath);
+    } catch (error) {
+      throw new PipelineError(
+        `Failed to parse source file: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "parse",
+        error
+      );
+    }
+  }
+  /**
+   * Stage 2: Collect all citation IDs from the presentation
+   */
+  collectCitations(presentation) {
+    const citations = this.citationExtractor.extractFromPresentation(presentation);
+    return this.citationExtractor.getUniqueIds(citations);
+  }
+  /**
+   * Stage 3: Resolve references from the reference manager
+   */
+  async resolveReferences(ids) {
+    if (!this.config.references.enabled || ids.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    try {
+      const items = await this.referenceManager.getByIds(ids);
+      for (const id of ids) {
+        if (!items.has(id)) {
+          this.warnings.push(`Reference not found: ${id}`);
+        }
+      }
+      return items;
+    } catch (error) {
+      this.warnings.push(
+        `Failed to resolve references: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      return /* @__PURE__ */ new Map();
+    }
+  }
+  /**
+   * Stage 4: Transform all slides using templates
+   */
+  async transformSlides(presentation) {
+    try {
+      return await this.transformer.transformAll(presentation);
+    } catch (error) {
+      throw new PipelineError(
+        `Failed to transform slides: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "transform",
+        error
+      );
+    }
+  }
+  /**
+   * Stage 5: Render the final Marp markdown
+   */
+  render(slides, presentation) {
+    try {
+      const notes = presentation.slides.map((slide) => slide.notes);
+      const renderOptions = {
+        includeTheme: true,
+        notes
+      };
+      return this.renderer.render(slides, presentation.meta, renderOptions);
+    } catch (error) {
+      throw new PipelineError(
+        `Failed to render output: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "render",
+        error
+      );
+    }
+  }
+};
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  ParseError,
+  Parser,
+  Pipeline,
+  PipelineError,
+  Renderer,
+  TemplateEngine,
+  TemplateLoader,
+  TransformError,
+  Transformer,
+  VERSION,
+  ValidationError,
+  jsonSchemaToZod,
+  presentationSchema,
+  templateDefSchema,
+  validateWithJsonSchema
+};
+//# sourceMappingURL=index.js.map