@tycoworks/tycoslide 0.7.0

package/dist/markdown/slideParser.d.ts

@@ -0,0 +1,14 @@
+export interface RawSlide {
+    index: number;
+    frontmatter: Record<string, unknown>;
+    body: string;
+    slots: Record<string, string>;
+}
+export interface ParsedDocument {
+    global: Record<string, unknown>;
+    slides: RawSlide[];
+}
+export declare function parseSlideDocument(source: string): ParsedDocument;
+export declare class FrontmatterParseError extends Error {
+    constructor(slideIndex: number, yamlSource: string, cause: unknown);
+}

package/dist/markdown/slideParser.js

@@ -0,0 +1,196 @@
+import { parse as parseYaml } from "yaml";
+// ============================================
+// PUBLIC API
+// ============================================
+export function parseSlideDocument(source) {
+    const { global, rest } = extractGlobalFrontmatter(source);
+    const rawSlides = splitIntoSlides(rest);
+    const slides = [];
+    for (const raw of rawSlides) {
+        slides.push(buildSlide(slides.length, raw.frontmatter, raw.content));
+    }
+    return { global, slides };
+}
+// ============================================
+// GLOBAL FRONTMATTER
+// ============================================
+const GLOBAL_FM_RE = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/;
+function extractGlobalFrontmatter(source) {
+    const match = source.match(GLOBAL_FM_RE);
+    if (!match)
+        return { global: {}, rest: source };
+    const parsed = parseYaml(match[1]);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return {
+            global: parsed,
+            rest: source.slice(match[0].length),
+        };
+    }
+    if (parsed !== null && parsed !== undefined) {
+        throw new Error(`Global frontmatter must be a YAML mapping (key: value pairs), got ${Array.isArray(parsed) ? "array" : typeof parsed}.`);
+    }
+    return { global: {}, rest: source };
+}
+const SEPARATOR_RE = /^---[ \t]*$/;
+const CODE_FENCE_OPEN_RE = /^(`{3,}|~{3,})/;
+/**
+ * States:
+ * - BODY: accumulating body content lines for current slide
+ * - FM: accumulating frontmatter lines (between --- pair)
+ *
+ * Transitions:
+ * - BODY + `---` -> flush current slide, start new slide, enter FM state
+ * - FM + `---` -> close frontmatter, enter BODY state
+ * - FM + blank line (before any non-blank FM line) -> no frontmatter, enter BODY
+ * - EOF while in FM -> unterminated frontmatter, treat accumulated lines as body
+ */
+function splitIntoSlides(text) {
+    const lines = text.split(/\r?\n/);
+    const slides = [];
+    let inFM = false;
+    let fmStarted = false;
+    let fmClosed = false;
+    let fmLines = [];
+    let bodyLines = [];
+    let inCodeFence = false;
+    let codeFenceChar = "";
+    let codeFenceLen = 0;
+    function flushSlide() {
+        const fm = fmLines.join("\n").trim();
+        const body = bodyLines.join("\n").trim();
+        if (fm || body) {
+            slides.push({ frontmatter: fm, content: body });
+        }
+        fmLines = [];
+        bodyLines = [];
+    }
+    for (const line of lines) {
+        if (!inCodeFence) {
+            const fenceMatch = line.match(CODE_FENCE_OPEN_RE);
+            if (fenceMatch) {
+                inCodeFence = true;
+                codeFenceChar = fenceMatch[1][0];
+                codeFenceLen = fenceMatch[1].length;
+            }
+        }
+        else {
+            const trimmed = line.trim();
+            if (trimmed.length >= codeFenceLen && trimmed === codeFenceChar.repeat(trimmed.length)) {
+                inCodeFence = false;
+            }
+        }
+        const isSeparator = !inCodeFence && SEPARATOR_RE.test(line);
+        if (isSeparator) {
+            if (inFM) {
+                inFM = false;
+                fmClosed = true;
+            }
+            else {
+                if (fmLines.length > 0 && !fmClosed) {
+                    bodyLines = [...fmLines, ...bodyLines];
+                    fmLines = [];
+                }
+                flushSlide();
+                inFM = true;
+                fmStarted = false;
+                fmClosed = false;
+            }
+        }
+        else if (inFM) {
+            if (!fmStarted && line.trim() === "") {
+                inFM = false;
+                bodyLines.push(line);
+            }
+            else {
+                fmStarted = true;
+                fmLines.push(line);
+            }
+        }
+        else {
+            bodyLines.push(line);
+        }
+    }
+    // Unterminated FM at EOF -> treat as body content
+    if (fmLines.length > 0 && !fmClosed) {
+        bodyLines = [...fmLines, ...bodyLines];
+        fmLines = [];
+    }
+    flushSlide();
+    return slides;
+}
+// ============================================
+// SLIDE BUILDER
+// ============================================
+function buildSlide(index, fmString, rawContent) {
+    const frontmatter = parseFrontmatter(fmString, index);
+    const { defaultSlot, slots } = extractSlots(rawContent);
+    return { index, frontmatter, body: defaultSlot, slots };
+}
+export class FrontmatterParseError extends Error {
+    constructor(slideIndex, yamlSource, cause) {
+        const preview = yamlSource.length > 80 ? `${yamlSource.slice(0, 80)}...` : yamlSource;
+        super(`Invalid YAML in slide ${slideIndex} frontmatter:\n${preview}`);
+        this.name = "FrontmatterParseError";
+        this.cause = cause;
+    }
+}
+function parseFrontmatter(yaml, slideIndex) {
+    if (!yaml)
+        return {};
+    try {
+        const result = parseYaml(yaml);
+        if (result && typeof result === "object" && !Array.isArray(result)) {
+            return result;
+        }
+    }
+    catch (err) {
+        throw new FrontmatterParseError(slideIndex, yaml, err);
+    }
+    throw new Error(`Slide ${slideIndex + 1}: frontmatter must be a YAML mapping (key: value pairs), got ${Array.isArray(parseYaml(yaml)) ? "array" : typeof parseYaml(yaml)}.`);
+}
+// ============================================
+// CONTENT SLOTS
+// ============================================
+const SLOT_LINE_RE = /^::(\w+)::[ \t]*$/;
+function extractSlots(content) {
+    const lines = content.split(/\r?\n/);
+    let currentSlot = null;
+    const slotLines = new Map([[null, []]]);
+    let inCodeFence = false;
+    let codeFenceChar = "";
+    let codeFenceLen = 0;
+    for (const line of lines) {
+        if (!inCodeFence) {
+            const fenceMatch = line.match(CODE_FENCE_OPEN_RE);
+            if (fenceMatch) {
+                inCodeFence = true;
+                codeFenceChar = fenceMatch[1][0];
+                codeFenceLen = fenceMatch[1].length;
+            }
+        }
+        else {
+            const trimmed = line.trim();
+            if (trimmed.length >= codeFenceLen && trimmed === codeFenceChar.repeat(trimmed.length)) {
+                inCodeFence = false;
+            }
+        }
+        const slotMatch = !inCodeFence && line.match(SLOT_LINE_RE);
+        if (slotMatch) {
+            currentSlot = slotMatch[1];
+            if (!slotLines.has(currentSlot)) {
+                slotLines.set(currentSlot, []);
+            }
+        }
+        else {
+            slotLines.get(currentSlot).push(line);
+        }
+    }
+    const defaultSlot = slotLines.get(null).join("\n").trim();
+    const slots = {};
+    for (const [name, sLines] of slotLines) {
+        if (name !== null) {
+            slots[name] = sLines.join("\n").trim();
+        }
+    }
+    return { defaultSlot, slots };
+}

package/dist/markdown/textTemplate.d.ts

@@ -0,0 +1,15 @@
+import type { TemplateSegment } from "../engine/index.js";
+/**
+ * The unique keys named by a template's placeholders, in first-seen order. A key
+ * repeated in the template appears once — it is filled once, everywhere it occurs.
+ */
+export declare function templateKeys(template: string): string[];
+/**
+ * Parse a template into per-line segment lists: split on newlines, then tokenize
+ * each line into an ordered list of literal and variable segments. Variables
+ * carry their substituted value (escapes collapse: `{{` → `{`, `}}` → `}`).
+ * Fails fast — a placeholder with no supplied value throws, naming the shape and
+ * the key, since a partially-filled text parameter is an authoring error.
+ * `shapeName` is the target PPTX shape's name, used only for the error message.
+ */
+export declare function templateToSegments(template: string, values: Map<string, string>, shapeName: string): TemplateSegment[][];

package/dist/markdown/textTemplate.js

@@ -0,0 +1,75 @@
+/**
+ * Text-template parsing. A text parameter's `template` is a single string with
+ * `{key}` placeholders; newlines in it are line breaks. Filling substitutes the
+ * author's values; the substituted result is written into the shape's existing
+ * runs by the engine. Lives in the compiler — the engine never parses `{}`.
+ *
+ * Syntax:
+ * - `{name}` — a placeholder for the key `name`; `name` matches `[A-Za-z0-9_]+`.
+ * - `{{` / `}}` — an escaped literal `{` / `}`.
+ * - A `{` not followed by a valid name + `}` is a literal brace, left as-is.
+ */
+// Order matters: escapes (`{{`, `}}`) are tried before a placeholder so
+// `{{name}}` reads as a literal-brace-wrapped `name`, not a `{name}` placeholder.
+const TOKEN_RE = /\{\{|\}\}|\{([A-Za-z0-9_]+)\}/g;
+/**
+ * The unique keys named by a template's placeholders, in first-seen order. A key
+ * repeated in the template appears once — it is filled once, everywhere it occurs.
+ */
+export function templateKeys(template) {
+    const seen = new Set();
+    const keys = [];
+    for (const match of template.matchAll(TOKEN_RE)) {
+        const name = match[1];
+        if (name !== undefined && !seen.has(name)) {
+            seen.add(name);
+            keys.push(name);
+        }
+    }
+    return keys;
+}
+/**
+ * Parse a template into per-line segment lists: split on newlines, then tokenize
+ * each line into an ordered list of literal and variable segments. Variables
+ * carry their substituted value (escapes collapse: `{{` → `{`, `}}` → `}`).
+ * Fails fast — a placeholder with no supplied value throws, naming the shape and
+ * the key, since a partially-filled text parameter is an authoring error.
+ * `shapeName` is the target PPTX shape's name, used only for the error message.
+ */
+export function templateToSegments(template, values, shapeName) {
+    return template.split("\n").map((line) => lineToSegments(line, values, shapeName));
+}
+function lineToSegments(line, values, shapeName) {
+    const segments = [];
+    const pushLiteral = (text) => {
+        if (text === "")
+            return;
+        const last = segments[segments.length - 1];
+        if (last?.kind === "literal")
+            last.text += text;
+        else
+            segments.push({ kind: "literal", text });
+    };
+    let lastIndex = 0;
+    for (const match of line.matchAll(TOKEN_RE)) {
+        pushLiteral(line.slice(lastIndex, match.index));
+        const token = match[0];
+        const name = match[1];
+        if (token === "{{") {
+            pushLiteral("{");
+        }
+        else if (token === "}}") {
+            pushLiteral("}");
+        }
+        else {
+            const value = values.get(name);
+            if (value === undefined) {
+                throw new Error(`Text parameter "${shapeName}": no value supplied for key "${name}" (placeholder "{${name}}")`);
+            }
+            segments.push({ kind: "variable", key: name, value });
+        }
+        lastIndex = match.index + token.length;
+    }
+    pushLiteral(line.slice(lastIndex));
+    return segments;
+}

package/dist/markdown/types.d.ts

@@ -0,0 +1,239 @@
+import { type FitMode, type ImageFill, type TableFill, type TemplateFill, type TextFill } from "../engine/index.js";
+import type { MermaidConfig } from "./resolvers/mermaidTheme.js";
+/**
+ * A theme's declaration of a reusable image asset. Purely compiler-facing —
+ * the engine never sees this type; the compiler resolves an entry's `path`
+ * to a fully-qualified filesystem path and wraps it as an ImageFill before
+ * handing the deck to the engine.
+ */
+export type AssetEntry = {
+    path: string;
+    description: string;
+    whenToUse?: string;
+};
+/** Two-level catalog: `{ category: { name: AssetEntry } }`. */
+export type AssetCatalog = Record<string, Record<string, AssetEntry>>;
+/**
+ * Discriminator strings for the compiler-internal fence shapes produced by
+ * deckCompiler.ts. `Code` and `Mermaid` are resolved away entirely (syntax
+ * highlighting → TextFill, PNG rendering → ImageFill), so neither reaches the
+ * engine. Prose has no FenceType: it becomes a `TextFill` (`{ paragraphs }`),
+ * one of the engine's own fill shapes.
+ */
+export declare const FenceType: {
+    readonly Code: "code";
+    readonly Mermaid: "mermaid";
+};
+export type FenceType = (typeof FenceType)[keyof typeof FenceType];
+/**
+ * Discriminator for a layout's frontmatter *parameters* — inputs the author
+ * writes as a single `key: value` line. Two kinds: `Template` (fills a styled
+ * shape's runs via fillTemplate) and `Image` (a filesystem path filled via
+ * fillImage). Both share their value with the engine's `SlotType`, since a
+ * parameter maps straight to an engine slot with no resolution step.
+ */
+export declare const ParameterType: {
+    readonly Template: "template";
+    readonly Image: "image";
+};
+export type ParameterType = (typeof ParameterType)[keyof typeof ParameterType];
+/**
+ * Compiler-facing slot type for a layout's *slots* — multi-line body regions
+ * (the default body region, or a `::name::` region). Narrowed to four kinds;
+ * `Template` and `Image` left this list to become parameters. `Code` and `Mermaid`
+ * are compiler-only, resolved (syntax highlighting, mermaid PNG rendering)
+ * before the engine sees the deck. Required on every CompilerSlot — no silent
+ * default.
+ */
+export declare const CompilerSlotType: {
+    readonly Text: "text";
+    readonly Table: "table";
+    readonly Code: "code";
+    readonly Mermaid: "mermaid";
+};
+export type CompilerSlotType = (typeof CompilerSlotType)[keyof typeof CompilerSlotType];
+/**
+ * A fenced code block awaiting syntax highlighting. Produced by deckCompiler,
+ * consumed by CodeResolver. Never crosses the engine boundary.
+ */
+export type CodeFence = {
+    type: typeof FenceType.Code;
+    language: string;
+    source: string;
+};
+/**
+ * A mermaid code fence awaiting rendering. Produced by deckCompiler, consumed
+ * by MermaidResolver — the resulting PNG is wrapped as an ImageFill in
+ * step.content, so the engine never learns mermaid exists.
+ */
+export type MermaidFence = {
+    type: typeof FenceType.Mermaid;
+    definition: string;
+};
+/**
+ * The full set of value shapes a slot may hold during compilation, before code
+ * fences are highlighted (→ TextFill) and mermaid fences are rendered
+ * (→ ImageFill). CodeFence, MermaidFence, and ImageFill carry a `.type`
+ * discriminator; the three engine fills without one — TextFill, TableFill,
+ * TemplateFill — are identified structurally by their signature field.
+ */
+export type MarkdownBlock = TextFill | TableFill | CodeFence | MermaidFence | ImageFill | TemplateFill;
+/**
+ * A DeckStep as compileDeck produces it — content values may still be
+ * unresolved (CodeFence, MermaidFence) at this point. `resolveFences` narrows
+ * these into StyledParagraph[] / ImageFill before the engine sees the deck.
+ */
+export type CompilerDeckStep = {
+    layout: string;
+    content?: Record<string, MarkdownBlock>;
+};
+/**
+ * The intermediate deck shape produced by compileDeck. buildDeck runs the
+ * resolvers and hands the resulting engine-shaped Deck to generate().
+ */
+export type CompilerDeck = {
+    theme: string;
+    output?: string;
+    steps: CompilerDeckStep[];
+};
+/**
+ * A DeckStep whose content values have been narrowed post-resolution — no
+ * CodeFence or MermaidFence remains, only shapes the engine understands.
+ * Structurally equivalent to the engine's DeckStep.
+ */
+export type ResolvedCompilerDeckStep = {
+    layout: string;
+    content?: Record<string, TextFill | TableFill | ImageFill | TemplateFill>;
+};
+/**
+ * A CompilerDeck whose steps have been passed through the resolvers via
+ * `resolveFences`. Structurally equivalent to the engine's Deck — deck
+ * resolution returns this shape so `generate` can consume it without any cast.
+ */
+export type ResolvedCompilerDeck = {
+    theme: string;
+    output: string;
+    steps: ResolvedCompilerDeckStep[];
+};
+/**
+ * Fields common to every text shape, image parameter, and slot. A text shape is
+ * addressed by `shapeName` and owns a `template` (its placeholders are the
+ * fillable keys); image parameters and slots additionally carry a single `key`.
+ */
+type CompilerShapeBase = {
+    shapeName: string;
+    limit?: {
+        maxChars?: number;
+        maxLines?: number;
+        maxItems?: number;
+    };
+    /**
+     * Whether the parameter/slot may be omitted from a slide. Optional (defaults
+     * to false): a required one with no value causes the compiler to throw with
+     * layout + key names.
+     */
+    required?: boolean;
+};
+/**
+ * Shape base plus a single `key` — the addressing model for image parameters
+ * and every slot. Template parameters do NOT extend this: their fillable keys are
+ * the placeholders in their `template`, not a single top-level key.
+ */
+type CompilerSlotBase = CompilerShapeBase & {
+    key: string;
+};
+/**
+ * Template parameter: a styled text shape filled by expanding a `template` into the
+ * shape's paragraphs via fillTemplate. The template is one string with `{key}`
+ * placeholders and newlines for line breaks (`"{lastname}, {firstname} -
+ * {company}"`, or `"{name}\n{jobTitle}"`); a shape's fillable keys are the
+ * placeholders in its template. The shape carries no top-level `key`; its
+ * placeholders are the keys the author fills in frontmatter.
+ */
+export type CompilerTemplateParameter = CompilerShapeBase & {
+    type: typeof ParameterType.Template;
+    /** The shape's text as one template with `{key}` placeholders; newlines are line breaks. */
+    template: string;
+};
+/** Image parameter: one frontmatter path filled by fillImage. */
+export type CompilerImageParameter = CompilerSlotBase & {
+    type: typeof ParameterType.Image;
+    /** How the picture scales inside its frame (required — no silent default). */
+    fit: FitMode;
+};
+/**
+ * Compiler-facing parameter. A layout's frontmatter inputs — each written as a
+ * single `key: value` line, resolved against the layout's `parameters` list.
+ */
+export type CompilerParameter = CompilerTemplateParameter | CompilerImageParameter;
+/** Multi-paragraph body filled by fillText (specimen-style rebuild). */
+export type CompilerTextSlot = CompilerSlotBase & {
+    type: typeof CompilerSlotType.Text;
+    /** Leave the first N specimen paragraphs untouched. */
+    startAt?: number;
+};
+/** Table shape backed by an `<a:tbl>` with header + data specimen rows. */
+export type CompilerTableSlot = CompilerSlotBase & {
+    type: typeof CompilerSlotType.Table;
+    /** Enforced column count. */
+    columns?: number;
+};
+/**
+ * Text slot that consumes a fenced code block. The resolver (`CodeResolver`)
+ * uses `codeTheme` to Shiki-highlight the source into StyledParagraph[]; the
+ * engine sees the projected Text slot.
+ */
+export type CompilerCodeSlot = CompilerSlotBase & {
+    type: typeof CompilerSlotType.Code;
+    /** Shiki theme id (required — no silent default). */
+    codeTheme: string;
+};
+/**
+ * Slot that consumes a mermaid code fence. The resolver (`MermaidResolver`)
+ * uses `mermaidVariant` to select colors and renders a PNG; the engine sees the
+ * projected Image slot with `contain` fit. Mermaid slots do NOT declare `fit` —
+ * mermaid diagrams are always contained.
+ */
+export type CompilerMermaidSlot = CompilerSlotBase & {
+    type: typeof CompilerSlotType.Mermaid;
+    /** Name of the mermaid variant (required — no silent default). */
+    mermaidVariant: string;
+};
+/**
+ * Compiler-facing slot. Discriminated union on `type` — each variant declares
+ * ONLY the fields legal for that slot type. A layout's body regions (the
+ * default region, or a `::name::` region), resolved against the layout's
+ * `slots` list. Adds markdown-flavored concepts (limit hints, code-fence theme
+ * selection, mermaid variant naming) on top of the engine's minimal Slot.
+ * Compiler-only types (Code, Mermaid) are projected down to engine types (Text,
+ * Image) at the engine boundary before the engine sees the layout.
+ */
+export type CompilerSlot = CompilerTextSlot | CompilerTableSlot | CompilerCodeSlot | CompilerMermaidSlot;
+export type CompilerLayout = {
+    name: string;
+    slideNumber: number;
+    description: string;
+    whenToUse: string;
+    whenNotToUse: string;
+    /** Frontmatter inputs (template, image) — one value per `key: value` line. */
+    parameters: CompilerParameter[];
+    /** Body regions (text, table, code, mermaid) — the body or `::name::` regions. */
+    slots: CompilerSlot[];
+};
+/**
+ * Compiler-facing theme configuration. Mirrors the engine's ThemeConfig but
+ * carries markdown-flavored fields (mermaid variants) that live outside the
+ * engine's awareness. Fields are declared explicitly rather than
+ * inherit-and-omit, so the boundary is visible.
+ */
+export type CompilerThemeConfig = {
+    layouts: CompilerLayout[];
+    assets: AssetCatalog;
+    template: string;
+    outputDir?: string;
+    mermaid?: MermaidConfig;
+};
+export type CompilerConfig = CompilerThemeConfig & {
+    rootDir: string;
+};
+export {};

package/dist/markdown/types.js

@@ -0,0 +1,40 @@
+import { SlotType, } from "../engine/index.js";
+// ── FenceType discriminator ───────────────────────────────────────────────────
+/**
+ * Discriminator strings for the compiler-internal fence shapes produced by
+ * deckCompiler.ts. `Code` and `Mermaid` are resolved away entirely (syntax
+ * highlighting → TextFill, PNG rendering → ImageFill), so neither reaches the
+ * engine. Prose has no FenceType: it becomes a `TextFill` (`{ paragraphs }`),
+ * one of the engine's own fill shapes.
+ */
+export const FenceType = {
+    Code: "code",
+    Mermaid: "mermaid",
+};
+// ── ParameterType discriminator (frontmatter, one value) ──────────────────────
+/**
+ * Discriminator for a layout's frontmatter *parameters* — inputs the author
+ * writes as a single `key: value` line. Two kinds: `Template` (fills a styled
+ * shape's runs via fillTemplate) and `Image` (a filesystem path filled via
+ * fillImage). Both share their value with the engine's `SlotType`, since a
+ * parameter maps straight to an engine slot with no resolution step.
+ */
+export const ParameterType = {
+    Template: SlotType.Template,
+    Image: SlotType.Image,
+};
+// ── CompilerSlotType discriminator (body region, multi-line) ──────────────────
+/**
+ * Compiler-facing slot type for a layout's *slots* — multi-line body regions
+ * (the default body region, or a `::name::` region). Narrowed to four kinds;
+ * `Template` and `Image` left this list to become parameters. `Code` and `Mermaid`
+ * are compiler-only, resolved (syntax highlighting, mermaid PNG rendering)
+ * before the engine sees the deck. Required on every CompilerSlot — no silent
+ * default.
+ */
+export const CompilerSlotType = {
+    Text: SlotType.Text,
+    Table: SlotType.Table,
+    Code: FenceType.Code,
+    Mermaid: FenceType.Mermaid,
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@tycoworks/tycoslide",
+  "version": "0.7.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "tycoslide": "bin/tycoslide.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "SKILL.md",
+    "syntax.md"
+  ],
+  "scripts": {
+    "build": "tsc --build",
+    "test": "tsc --build && node --test --experimental-transform-types test/**/*.test.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write ."
+  },
+  "dependencies": {
+    "commander": "^15.0.0",
+    "image-size": "^2.0.2",
+    "pptx-automizer": "^0.8.2",
+    "remark-gfm": "^4.0.1",
+    "remark-ins": "^1.2.5",
+    "remark-parse": "^11.0.0",
+    "shiki": "^4.3.0",
+    "unified": "^11.0.0",
+    "yaml": "^2.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.1",
+    "@types/node": "^22.20.0",
+    "@xmldom/xmldom": "^0.9.10",
+    "typescript": "^5.8.0"
+  }
+}