reamkit 0.1.0-alpha.0

package/dist/esm/pdf/text-encoding.d.ts

@@ -0,0 +1,2 @@
+export declare function encodeWinAnsi(text: string): Uint8Array;
+export declare function encodeLiteralBytes(text: string): Uint8Array;

package/dist/esm/pdf/text-page-renderer.d.ts

@@ -0,0 +1,16 @@
+import { ParsedTtf } from '../font/index.js';
+export type FontInput = ParsedTtf | {
+    readonly bytes: Uint8Array;
+};
+export interface TextRenderOptions {
+    readonly font: FontInput;
+    readonly pageWidth?: number;
+    readonly pageHeight?: number;
+    readonly marginLeft?: number;
+    readonly marginRight?: number;
+    readonly marginTop?: number;
+    readonly marginBottom?: number;
+    readonly fontSize?: number;
+    readonly lineHeight?: number;
+}
+export declare function renderPlainTextPdf(paragraphs: ReadonlyArray<string>, options: TextRenderOptions): Uint8Array;

package/dist/esm/pdf/text-page-renderer.js

@@ -0,0 +1,4 @@
+import "./cid-font.js";
+import "./writer.js";
+new TextEncoder();
+//#endregion

package/dist/esm/pdf/vector-graphics.d.ts

@@ -0,0 +1,46 @@
+export type PathSegment = {
+    readonly op: 'move';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'line';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'cubic';
+    readonly x1: number;
+    readonly y1: number;
+    readonly x2: number;
+    readonly y2: number;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'close';
+};
+export interface VectorPath {
+    readonly segments: ReadonlyArray<PathSegment>;
+    readonly fillRule?: 'nonzero' | 'evenodd';
+}
+export interface StrokeStyle {
+    readonly colorHex: string;
+    readonly widthPt: number;
+    readonly cap?: 'butt' | 'round' | 'square';
+    readonly join?: 'miter' | 'round' | 'bevel';
+    readonly dash?: ReadonlyArray<number>;
+}
+export interface VectorShape {
+    readonly paths: ReadonlyArray<VectorPath>;
+    readonly fillColorHex?: string;
+    readonly stroke?: StrokeStyle;
+    readonly transform: readonly [number, number, number, number, number, number];
+}
+export declare class PathBuilder {
+    private readonly segments;
+    moveTo(x: number, y: number): this;
+    lineTo(x: number, y: number): this;
+    cubicTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): this;
+    append(segments: ReadonlyArray<PathSegment>): this;
+    close(): this;
+    build(fillRule?: 'nonzero' | 'evenodd'): VectorPath;
+}
+export declare function emitVectorShape(shape: VectorShape): Array<string>;

package/dist/esm/pdf/vector-graphics.js

@@ -0,0 +1,103 @@
+//#region src/pdf/vector-graphics.ts
+var PathBuilder = class {
+	segments = [];
+	moveTo(x, y) {
+		this.segments.push({
+			op: "move",
+			x,
+			y
+		});
+		return this;
+	}
+	lineTo(x, y) {
+		this.segments.push({
+			op: "line",
+			x,
+			y
+		});
+		return this;
+	}
+	cubicTo(x1, y1, x2, y2, x, y) {
+		this.segments.push({
+			op: "cubic",
+			x1,
+			y1,
+			x2,
+			y2,
+			x,
+			y
+		});
+		return this;
+	}
+	append(segments) {
+		for (const s of segments) this.segments.push(s);
+		return this;
+	}
+	close() {
+		this.segments.push({ op: "close" });
+		return this;
+	}
+	build(fillRule) {
+		return {
+			segments: this.segments.slice(),
+			...fillRule ? { fillRule } : {}
+		};
+	}
+};
+function emitVectorShape(shape) {
+	const out = [];
+	out.push("q");
+	const [a, b, c, d, e, f] = shape.transform;
+	out.push(`${num(a)} ${num(b)} ${num(c)} ${num(d)} ${num(e)} ${num(f)} cm`);
+	const stroke = shape.stroke;
+	if (stroke) {
+		out.push(`${num(stroke.widthPt)} w`);
+		if (stroke.cap !== void 0) out.push(`${capCode(stroke.cap)} J`);
+		if (stroke.join !== void 0) out.push(`${joinCode(stroke.join)} j`);
+		if (stroke.dash && stroke.dash.length > 0) out.push(`[${stroke.dash.map(num).join(" ")}] 0 d`);
+		const [r, g, bl] = hexToRgb01(stroke.colorHex);
+		out.push(`${num(r)} ${num(g)} ${num(bl)} RG`);
+	}
+	if (shape.fillColorHex) {
+		const [r, g, bl] = hexToRgb01(shape.fillColorHex);
+		out.push(`${num(r)} ${num(g)} ${num(bl)} rg`);
+	}
+	let evenodd = false;
+	for (const path of shape.paths) {
+		if (path.fillRule === "evenodd") evenodd = true;
+		for (const seg of path.segments) out.push(emitSegment(seg));
+	}
+	out.push(paintOp(shape.fillColorHex !== void 0, stroke !== void 0, evenodd));
+	out.push("Q");
+	return out;
+}
+function emitSegment(seg) {
+	switch (seg.op) {
+		case "move": return `${num(seg.x)} ${num(seg.y)} m`;
+		case "line": return `${num(seg.x)} ${num(seg.y)} l`;
+		case "cubic": return `${num(seg.x1)} ${num(seg.y1)} ${num(seg.x2)} ${num(seg.y2)} ${num(seg.x)} ${num(seg.y)} c`;
+		case "close": return "h";
+	}
+}
+function paintOp(fill, stroke, evenodd) {
+	if (fill && stroke) return evenodd ? "B*" : "B";
+	if (fill) return evenodd ? "f*" : "f";
+	if (stroke) return "S";
+	return "n";
+}
+var capCode = (c) => c === "round" ? 1 : c === "square" ? 2 : 0;
+var joinCode = (j) => j === "round" ? 1 : j === "bevel" ? 2 : 0;
+function num(n) {
+	if (!Number.isFinite(n)) return "0";
+	if (Number.isInteger(n)) return String(n);
+	return n.toFixed(6).replace(/0+$/, "").replace(/\.$/, "");
+}
+function hexToRgb01(hex) {
+	return [
+		parseInt(hex.slice(0, 2), 16) / 255,
+		parseInt(hex.slice(2, 4), 16) / 255,
+		parseInt(hex.slice(4, 6), 16) / 255
+	];
+}
+//#endregion
+export { PathBuilder, emitVectorShape };

package/dist/esm/pdf/writer.d.ts

@@ -0,0 +1,10 @@
+import { PdfValue, PdfRef } from './objects.js';
+export interface BuildOptions {
+    readonly version?: string;
+    readonly id?: boolean;
+}
+export declare class PdfDocument {
+    private readonly objects;
+    add(value: PdfValue): PdfRef;
+    build(root: PdfRef, info?: PdfRef, options?: BuildOptions): Uint8Array;
+}

package/dist/esm/pdf/writer.js

@@ -0,0 +1,81 @@
+import { PdfRef } from "./objects.js";
+import { serializeIndirectObject } from "./serialize.js";
+//#region src/pdf/writer.ts
+var encoder = new TextEncoder();
+var BINARY_MARKER = new Uint8Array([
+	37,
+	226,
+	227,
+	207,
+	211,
+	10
+]);
+var PdfDocument = class {
+	objects = [];
+	add(value) {
+		const id = this.objects.length + 1;
+		this.objects.push({
+			id,
+			value
+		});
+		return new PdfRef(id);
+	}
+	build(root, info, options = {}) {
+		const parts = [];
+		const offsets = new Array(this.objects.length + 1).fill(0);
+		let pos = 0;
+		const push = (bytes) => {
+			parts.push(bytes);
+			pos += bytes.length;
+		};
+		push(encoder.encode(`%PDF-${options.version ?? "1.7"}\n`));
+		push(BINARY_MARKER);
+		for (const obj of this.objects) {
+			offsets[obj.id] = pos;
+			push(serializeIndirectObject(obj.id, 0, obj.value));
+		}
+		const xrefOffset = pos;
+		const totalObjects = this.objects.length + 1;
+		let xref = `xref\n0 ${totalObjects}\n0000000000 65535 f \n`;
+		for (let i = 1; i < totalObjects; i++) {
+			const off = offsets[i].toString().padStart(10, "0");
+			xref += `${off} 00000 n \n`;
+		}
+		push(encoder.encode(xref));
+		const infoEntry = info ? ` /Info ${info.id} ${info.generation} R` : "";
+		let idEntry = "";
+		if (options.id) {
+			const hashHex = hash128Hex(parts);
+			idEntry = ` /ID [<${hashHex}> <${hashHex}>]`;
+		}
+		const trailer = `trailer\n<</Size ${totalObjects} /Root ${root.id} ${root.generation} R${infoEntry}${idEntry}>>\nstartxref\n${xrefOffset}\n%%EOF\n`;
+		push(encoder.encode(trailer));
+		const out = new Uint8Array(pos);
+		let off = 0;
+		for (const p of parts) {
+			out.set(p, off);
+			off += p.length;
+		}
+		return out;
+	}
+};
+function hash128Hex(parts) {
+	const acc = new Uint32Array([
+		2166136261,
+		16777619,
+		2654435769,
+		2246822507
+	]);
+	for (const part of parts) for (let i = 0; i < part.length; i++) {
+		const b = part[i];
+		for (let s = 0; s < 4; s++) {
+			acc[s] = (acc[s] ^ b) >>> 0;
+			acc[s] = Math.imul(acc[s], 16777619) >>> 0;
+		}
+	}
+	let hex = "";
+	for (let s = 0; s < 4; s++) hex += acc[s].toString(16).padStart(8, "0").toUpperCase();
+	return hex;
+}
+//#endregion
+export { PdfDocument };

package/dist/esm/pdf/xmp.d.ts

@@ -0,0 +1,13 @@
+export interface XmpInput {
+    readonly title?: string;
+    readonly author?: string;
+    readonly subject?: string;
+    readonly keywords?: string;
+    readonly creator?: string;
+    readonly producer?: string;
+    readonly createDate?: Date;
+    readonly modifyDate?: Date;
+    readonly pdfaPart?: '1' | '2' | '3';
+    readonly pdfaConformance?: 'A' | 'B' | 'U';
+}
+export declare function buildXmpPacket(input: XmpInput): Uint8Array;

package/dist/esm/pdf/xmp.js

@@ -0,0 +1,38 @@
+//#region src/pdf/xmp.ts
+function escapeXml(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function xmpDate(d) {
+	const pad = (n, w = 2) => String(n).padStart(w, "0");
+	return `${pad(d.getUTCFullYear(), 4)}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}T${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())}Z`;
+}
+function buildXmpPacket(input) {
+	const props = [];
+	if (input.pdfaPart) props.push(`      <rdf:Description rdf:about="" xmlns:pdfaid="http://www.aiim.org/pdfa/ns/id/">`, `        <pdfaid:part>${input.pdfaPart}</pdfaid:part>`, `        <pdfaid:conformance>${input.pdfaConformance ?? "B"}</pdfaid:conformance>`, `      </rdf:Description>`);
+	const dc = [];
+	if (input.title) dc.push(`        <dc:title><rdf:Alt><rdf:li xml:lang="x-default">${escapeXml(input.title)}</rdf:li></rdf:Alt></dc:title>`);
+	if (input.author) dc.push(`        <dc:creator><rdf:Seq><rdf:li>${escapeXml(input.author)}</rdf:li></rdf:Seq></dc:creator>`);
+	if (input.subject) dc.push(`        <dc:description><rdf:Alt><rdf:li xml:lang="x-default">${escapeXml(input.subject)}</rdf:li></rdf:Alt></dc:description>`);
+	if (dc.length > 0) props.push(`      <rdf:Description rdf:about="" xmlns:dc="http://purl.org/dc/elements/1.1/">`, ...dc, `      </rdf:Description>`);
+	const xmp = [];
+	if (input.creator) xmp.push(`        <xmp:CreatorTool>${escapeXml(input.creator)}</xmp:CreatorTool>`);
+	if (input.createDate) xmp.push(`        <xmp:CreateDate>${xmpDate(input.createDate)}</xmp:CreateDate>`);
+	if (input.modifyDate) xmp.push(`        <xmp:ModifyDate>${xmpDate(input.modifyDate)}</xmp:ModifyDate>`);
+	if (xmp.length > 0) props.push(`      <rdf:Description rdf:about="" xmlns:xmp="http://ns.adobe.com/xap/1.0/">`, ...xmp, `      </rdf:Description>`);
+	const pdf = [];
+	if (input.producer) pdf.push(`        <pdf:Producer>${escapeXml(input.producer)}</pdf:Producer>`);
+	if (input.keywords) pdf.push(`        <pdf:Keywords>${escapeXml(input.keywords)}</pdf:Keywords>`);
+	if (pdf.length > 0) props.push(`      <rdf:Description rdf:about="" xmlns:pdf="http://ns.adobe.com/pdf/1.3/">`, ...pdf, `      </rdf:Description>`);
+	const body = [
+		`<?xpacket begin="\uFEFF" id="W5M0MpCehiHzreSzNTczkc9d"?>`,
+		`<x:xmpmeta xmlns:x="adobe:ns:meta/">`,
+		`  <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">`,
+		...props,
+		`  </rdf:RDF>`,
+		`</x:xmpmeta>`,
+		`<?xpacket end="w"?>`
+	].join("\n");
+	return new TextEncoder().encode(body);
+}
+//#endregion
+export { buildXmpPacket };

package/dist/esm/style-cascade/index.d.ts

@@ -0,0 +1,3 @@
+export { resolveRunProperties, resolveParagraphProperties } from './resolver.js';
+export type { ResolvedRunProperties, ResolvedParagraphProperties } from './types.js';
+export { DEFAULT_RESOLVED_RUN, DEFAULT_RESOLVED_PARAGRAPH } from './types.js';

package/dist/esm/style-cascade/resolver.d.ts

@@ -0,0 +1,4 @@
+import { ParagraphProperties, RunProperties, StyleSheet } from '../document-model/index.js';
+import { ResolvedParagraphProperties, ResolvedRunProperties } from './types.js';
+export declare function resolveRunProperties(runDirect: RunProperties, paragraphDirect: ParagraphProperties, sheet: StyleSheet): ResolvedRunProperties;
+export declare function resolveParagraphProperties(paragraphDirect: ParagraphProperties, sheet: StyleSheet): ResolvedParagraphProperties;

package/dist/esm/style-cascade/resolver.js

@@ -0,0 +1,96 @@
+import { DEFAULT_RESOLVED_PARAGRAPH, DEFAULT_RESOLVED_RUN } from "./types.js";
+//#region src/style-cascade/resolver.ts
+function resolveRunProperties(runDirect, paragraphDirect, sheet) {
+	let acc = mergeRun(DEFAULT_RESOLVED_RUN, sheet.defaultRunProperties);
+	if (paragraphDirect.styleId) {
+		const chain = resolveStyleChain(paragraphDirect.styleId, sheet);
+		acc = mergeRun(acc, chain.rPr);
+	}
+	if (runDirect.styleId) {
+		const chain = resolveStyleChain(runDirect.styleId, sheet);
+		acc = mergeRun(acc, chain.rPr);
+	}
+	return mergeRun(acc, runDirect);
+}
+function resolveParagraphProperties(paragraphDirect, sheet) {
+	let acc = mergePar(DEFAULT_RESOLVED_PARAGRAPH, sheet.defaultParagraphProperties);
+	if (paragraphDirect.styleId) {
+		const chain = resolveStyleChain(paragraphDirect.styleId, sheet);
+		acc = mergePar(acc, chain.pPr);
+	}
+	return mergePar(acc, paragraphDirect);
+}
+function resolveStyleChain(styleId, sheet) {
+	const chain = [];
+	const visited = /* @__PURE__ */ new Set();
+	let cursor = styleId;
+	while (cursor && !visited.has(cursor)) {
+		visited.add(cursor);
+		const style = sheet.styles.get(cursor);
+		if (!style) break;
+		chain.unshift({
+			rPr: style.runProperties,
+			pPr: style.paragraphProperties
+		});
+		cursor = style.basedOn;
+	}
+	let rPr = {};
+	let pPr = {};
+	for (const link of chain) {
+		rPr = mergeRunPartial(rPr, link.rPr);
+		pPr = mergeParPartial(pPr, link.pPr);
+	}
+	return {
+		rPr,
+		pPr
+	};
+}
+function mergeRun(base, override) {
+	const lang = override.lang ?? base.lang;
+	return {
+		bold: override.bold ?? base.bold,
+		italic: override.italic ?? base.italic,
+		underline: override.underline ?? base.underline,
+		strike: override.strike ?? base.strike,
+		fontSizeHalfPoints: override.fontSizeHalfPoints ?? base.fontSizeHalfPoints,
+		colorHex: override.colorHex ?? base.colorHex,
+		fontFamily: override.fontFamily ?? base.fontFamily,
+		verticalAlign: override.verticalAlign ?? base.verticalAlign,
+		rtl: override.rtl ?? base.rtl,
+		...lang !== void 0 ? { lang } : {}
+	};
+}
+function mergePar(base, override) {
+	const outlineLevel = override.outlineLevel ?? base.outlineLevel;
+	const styleId = override.styleId ?? base.styleId;
+	return {
+		alignment: override.alignment ?? base.alignment,
+		spacingBeforeTwips: override.spacingBeforeTwips ?? base.spacingBeforeTwips,
+		spacingAfterTwips: override.spacingAfterTwips ?? base.spacingAfterTwips,
+		spacingLineTwips: override.spacingLineTwips ?? base.spacingLineTwips,
+		spacingLineRule: override.spacingLineRule ?? base.spacingLineRule,
+		indentLeftTwips: override.indentLeftTwips ?? base.indentLeftTwips,
+		indentRightTwips: override.indentRightTwips ?? base.indentRightTwips,
+		indentFirstLineTwips: override.indentFirstLineTwips ?? base.indentFirstLineTwips,
+		pageBreakBefore: override.pageBreakBefore ?? base.pageBreakBefore,
+		bidi: override.bidi ?? base.bidi,
+		...outlineLevel !== void 0 ? { outlineLevel } : {},
+		...styleId !== void 0 ? { styleId } : {}
+	};
+}
+function mergeRunPartial(base, override) {
+	return copyDefined(base, override);
+}
+function mergeParPartial(base, override) {
+	return copyDefined(base, override);
+}
+function copyDefined(base, override) {
+	const out = { ...base };
+	for (const key of Object.keys(override)) {
+		const v = override[key];
+		if (v !== void 0) out[key] = v;
+	}
+	return out;
+}
+//#endregion
+export { resolveParagraphProperties, resolveRunProperties };

package/dist/esm/style-cascade/types.d.ts

@@ -0,0 +1,29 @@
+import { Alignment, FontFamilyMap, UnderlineStyle, VerticalAlign } from '../document-model/index.js';
+export interface ResolvedRunProperties {
+    readonly bold: boolean;
+    readonly italic: boolean;
+    readonly underline: UnderlineStyle;
+    readonly strike: boolean;
+    readonly fontSizeHalfPoints: number;
+    readonly colorHex: string;
+    readonly fontFamily: FontFamilyMap;
+    readonly verticalAlign: VerticalAlign;
+    readonly rtl: boolean;
+    readonly lang?: string;
+}
+export interface ResolvedParagraphProperties {
+    readonly alignment: Alignment;
+    readonly spacingBeforeTwips: number;
+    readonly spacingAfterTwips: number;
+    readonly spacingLineTwips: number;
+    readonly spacingLineRule: 'auto' | 'exact' | 'atLeast';
+    readonly indentLeftTwips: number;
+    readonly indentRightTwips: number;
+    readonly indentFirstLineTwips: number;
+    readonly pageBreakBefore: boolean;
+    readonly bidi: boolean;
+    readonly outlineLevel?: number;
+    readonly styleId?: string;
+}
+export declare const DEFAULT_RESOLVED_RUN: ResolvedRunProperties;
+export declare const DEFAULT_RESOLVED_PARAGRAPH: ResolvedParagraphProperties;

package/dist/esm/style-cascade/types.js

@@ -0,0 +1,26 @@
+//#region src/style-cascade/types.ts
+var DEFAULT_RESOLVED_RUN = {
+	bold: false,
+	italic: false,
+	underline: "none",
+	strike: false,
+	fontSizeHalfPoints: 22,
+	colorHex: "000000",
+	fontFamily: {},
+	verticalAlign: "baseline",
+	rtl: false
+};
+var DEFAULT_RESOLVED_PARAGRAPH = {
+	alignment: "left",
+	spacingBeforeTwips: 0,
+	spacingAfterTwips: 0,
+	spacingLineTwips: 240,
+	spacingLineRule: "auto",
+	indentLeftTwips: 0,
+	indentRightTwips: 0,
+	indentFirstLineTwips: 0,
+	pageBreakBefore: false,
+	bidi: false
+};
+//#endregion
+export { DEFAULT_RESOLVED_PARAGRAPH, DEFAULT_RESOLVED_RUN };

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "reamkit",
+  "version": "0.1.0-alpha.0",
+  "description": "Ream — DOCX/XLSX to PDF, built from scratch on the ECMA-376 and ISO 32000 specifications (alpha; more document formats to come)",
+  "license": "MIT",
+  "author": "Alex Krassavin",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alex-krassavin/reamkit.git"
+  },
+  "homepage": "https://github.com/alex-krassavin/reamkit#readme",
+  "bugs": {
+    "url": "https://github.com/alex-krassavin/reamkit/issues"
+  },
+  "type": "module",
+  "main": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js"
+    },
+    "./document-model": {
+      "types": "./dist/esm/document-model/index.d.ts",
+      "import": "./dist/esm/document-model/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "keywords": [
+    "docx",
+    "xlsx",
+    "pdf",
+    "ooxml",
+    "ecma-376",
+    "iso-32000",
+    "pdf/a",
+    "office",
+    "word",
+    "excel",
+    "converter"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run build && npm run test:build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:lib": "vitest run",
+    "test:types": "tsc -p tsconfig.json --noEmit",
+    "test:eslint": "eslint .",
+    "test:build": "publint --strict && attw --pack . --profile esm-only",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\" \"scripts/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\" \"scripts/**/*.ts\"",
+    "docs:api": "tsx scripts/docs/generate-api.ts",
+    "corpus:build": "tsx scripts/corpus/build-corpus.ts",
+    "corpus:fetch": "tsx scripts/corpus/fetch-corpus.ts",
+    "corpus:sandbox:build": "docker build -t docgen-losandbox:latest scripts/corpus/sandbox/",
+    "corpus": "tsx scripts/corpus/run.ts"
+  },
+  "dependencies": {
+    "fast-xml-parser": "5.7.0",
+    "fflate": "^0.8.2"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.3",
+    "@tanstack/config": "^0.22.2",
+    "@types/node": "^22.10.0",
+    "prettier": "^3.8.3",
+    "publint": "^0.3.21",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vite": "8.0.5",
+    "vitest": "^2.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}