@jasy/pdf 1.0.0-alpha.1

package/dist/utils/ttf-parser.d.ts

@@ -0,0 +1,29 @@
+export declare class TTFParser {
+    private data;
+    unitsPerEm: number;
+    ascent: number;
+    descent: number;
+    bbox: [number, number, number, number];
+    private numGlyphs;
+    private numHMetrics;
+    private advanceWidths;
+    private cmap;
+    private cmapGroups;
+    private tables;
+    constructor(data: Buffer);
+    getData(): Buffer;
+    glyphCount(): number;
+    glyphWidths(): number[];
+    reverseCmap(): Map<number, number>;
+    private toGlyphSpace;
+    getGlyphIndex(codePoint: number): number;
+    getAdvanceWidth(glyphIndex: number): number;
+    getCharWidth(char: string, fontSize: number): number;
+    getStringWidth(text: string, fontSize: number): number;
+    private table;
+    private readTableDirectory;
+    private readHmtx;
+    private readCmap;
+    private readCmapFormat4;
+    private readCmapFormat12;
+}

package/dist/utils/ttf-parser.js

@@ -0,0 +1,191 @@
+"use strict";
+// Parses the metric tables of a TrueType (.ttf) font - the binary counterpart to AFMParser.
+// Slice 1: glyph advance widths (hmtx) + the Unicode→glyph map (cmap), enough to compute
+// text width the same way AFMParser does for the standard-14. Embedding/subsetting come later.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TTFParser = void 0;
+class TTFParser {
+    constructor(data) {
+        this.data = data;
+        this.unitsPerEm = 1000;
+        // FontDescriptor metrics, in PDF glyph space (1000 units / em).
+        this.ascent = 0;
+        this.descent = 0;
+        this.bbox = [0, 0, 0, 0];
+        this.numGlyphs = 0;
+        this.numHMetrics = 0;
+        this.advanceWidths = []; // per glyph id, in font units
+        this.cmap = new Map(); // codepoint → glyph id (format 4)
+        this.cmapGroups = []; // format 12, searched on lookup
+        this.tables = {};
+        this.readTableDirectory();
+        const head = this.table("head").offset;
+        this.unitsPerEm = this.data.readUInt16BE(head + 18);
+        this.numGlyphs = this.data.readUInt16BE(this.table("maxp").offset + 4);
+        this.numHMetrics = this.data.readUInt16BE(this.table("hhea").offset + 34);
+        this.bbox = [
+            this.toGlyphSpace(this.data.readInt16BE(head + 36)), // xMin
+            this.toGlyphSpace(this.data.readInt16BE(head + 38)), // yMin
+            this.toGlyphSpace(this.data.readInt16BE(head + 40)), // xMax
+            this.toGlyphSpace(this.data.readInt16BE(head + 42)), // yMax
+        ];
+        const hhea = this.table("hhea").offset;
+        this.ascent = this.toGlyphSpace(this.data.readInt16BE(hhea + 4));
+        this.descent = this.toGlyphSpace(this.data.readInt16BE(hhea + 6));
+        this.readHmtx();
+        this.readCmap();
+    }
+    // The raw font bytes, for the /FontFile2 stream.
+    getData() {
+        return this.data;
+    }
+    glyphCount() {
+        return this.numGlyphs;
+    }
+    // Advance width of every glyph in PDF glyph space (the /W array of the CIDFont).
+    glyphWidths() {
+        const out = [];
+        for (let g = 0; g < this.numGlyphs; g++) {
+            out.push(this.toGlyphSpace(this.getAdvanceWidth(g)));
+        }
+        return out;
+    }
+    // glyph id → Unicode codepoint, for the /ToUnicode CMap (BMP / format-4 coverage).
+    reverseCmap() {
+        const out = new Map();
+        this.cmap.forEach((gid, code) => {
+            if (!out.has(gid))
+                out.set(gid, code);
+        });
+        return out;
+    }
+    toGlyphSpace(v) {
+        return Math.round((v * 1000) / this.unitsPerEm);
+    }
+    // Codepoint → glyph id (0 = .notdef when the font has no glyph for it).
+    getGlyphIndex(codePoint) {
+        const g = this.cmap.get(codePoint);
+        if (g !== undefined)
+            return g;
+        for (const r of this.cmapGroups) {
+            if (codePoint >= r.start && codePoint <= r.end) {
+                return r.startGlyph + (codePoint - r.start);
+            }
+        }
+        return 0;
+    }
+    // Advance width of a glyph in font units. Glyphs past numHMetrics reuse the last advance.
+    getAdvanceWidth(glyphIndex) {
+        var _a;
+        const i = Math.min(glyphIndex, this.numHMetrics - 1);
+        return (_a = this.advanceWidths[i]) !== null && _a !== void 0 ? _a : 0;
+    }
+    // Char width at fontSize, scaled from font units (em = unitsPerEm) to points.
+    getCharWidth(char, fontSize) {
+        const units = this.getAdvanceWidth(this.getGlyphIndex(char.codePointAt(0)));
+        return (units / this.unitsPerEm) * fontSize;
+    }
+    // String width at fontSize.
+    getStringWidth(text, fontSize) {
+        let width = 0;
+        for (const ch of text)
+            width += this.getCharWidth(ch, fontSize);
+        return width;
+    }
+    table(tag) {
+        const t = this.tables[tag];
+        if (!t)
+            throw new Error(`TTF: missing required table "${tag}"`);
+        return t;
+    }
+    readTableDirectory() {
+        const numTables = this.data.readUInt16BE(4);
+        let p = 12; // after the offset table (sfntVersion + numTables + 3 fields)
+        for (let i = 0; i < numTables; i++) {
+            const tag = this.data.toString("latin1", p, p + 4);
+            this.tables[tag] = {
+                offset: this.data.readUInt32BE(p + 8),
+                length: this.data.readUInt32BE(p + 12),
+            };
+            p += 16;
+        }
+    }
+    // hmtx is numHMetrics {advanceWidth, lsb} pairs, then lsb-only entries that reuse the last advance.
+    readHmtx() {
+        const o = this.table("hmtx").offset;
+        let last = 0;
+        for (let i = 0; i < this.numGlyphs; i++) {
+            if (i < this.numHMetrics)
+                last = this.data.readUInt16BE(o + i * 4);
+            this.advanceWidths.push(last);
+        }
+    }
+    readCmap() {
+        const base = this.table("cmap").offset;
+        const numTables = this.data.readUInt16BE(base + 2);
+        // Prefer the Windows Unicode BMP subtable (3,1); accept full-Unicode (3,10) or any (0,x).
+        let subtable = -1;
+        let p = base + 4;
+        for (let i = 0; i < numTables; i++) {
+            const platform = this.data.readUInt16BE(p);
+            const encoding = this.data.readUInt16BE(p + 2);
+            const offset = this.data.readUInt32BE(p + 4);
+            const unicode = (platform === 3 && (encoding === 1 || encoding === 10)) || platform === 0;
+            if (unicode) {
+                subtable = base + offset;
+                if (platform === 3 && encoding === 1)
+                    break; // best fit, stop looking
+            }
+            p += 8;
+        }
+        if (subtable < 0)
+            return;
+        const format = this.data.readUInt16BE(subtable);
+        if (format === 4)
+            this.readCmapFormat4(subtable);
+        else if (format === 12)
+            this.readCmapFormat12(subtable);
+    }
+    // Format 4: segment mapping. Four parallel arrays keyed by segment; the glyph comes either
+    // from idDelta or, when idRangeOffset != 0, from the glyphIdArray it points into.
+    readCmapFormat4(o) {
+        const segCountX2 = this.data.readUInt16BE(o + 6);
+        const endCodes = o + 14;
+        const startCodes = endCodes + segCountX2 + 2; // +2 reservedPad
+        const idDeltas = startCodes + segCountX2;
+        const idRangeOffsets = idDeltas + segCountX2;
+        for (let i = 0; i < segCountX2 / 2; i++) {
+            const end = this.data.readUInt16BE(endCodes + i * 2);
+            const start = this.data.readUInt16BE(startCodes + i * 2);
+            const delta = this.data.readUInt16BE(idDeltas + i * 2);
+            const rangeOffset = this.data.readUInt16BE(idRangeOffsets + i * 2);
+            for (let c = start; c <= end && c !== 0xffff; c++) {
+                let glyph;
+                if (rangeOffset === 0) {
+                    glyph = (c + delta) & 0xffff;
+                }
+                else {
+                    glyph = this.data.readUInt16BE(idRangeOffsets + i * 2 + rangeOffset + (c - start) * 2);
+                    if (glyph !== 0)
+                        glyph = (glyph + delta) & 0xffff;
+                }
+                if (glyph !== 0)
+                    this.cmap.set(c, glyph);
+            }
+        }
+    }
+    // Format 12: sequential groups for full Unicode (incl. astral). Kept un-expanded.
+    readCmapFormat12(o) {
+        const nGroups = this.data.readUInt32BE(o + 12);
+        let p = o + 16;
+        for (let i = 0; i < nGroups; i++) {
+            this.cmapGroups.push({
+                start: this.data.readUInt32BE(p),
+                end: this.data.readUInt32BE(p + 4),
+                startGlyph: this.data.readUInt32BE(p + 8),
+            });
+            p += 12;
+        }
+    }
+}
+exports.TTFParser = TTFParser;

package/dist/utils/ttf-subsetter.d.ts

@@ -0,0 +1 @@
+export declare function subsetTTF(data: Buffer, used: Set<number>): Buffer;

package/dist/utils/ttf-subsetter.js

@@ -0,0 +1,161 @@
+"use strict";
+// Builds a subset TrueType font that KEEPS the original glyph ids: the PDF content stream emits
+// original gids and /W + CIDToGIDMap=Identity stay valid, so only the font program shrinks. We drop
+// the `glyf` outlines of unused glyphs (the bulk of the file) and rebuild `loca`; every other table
+// is copied verbatim. The used-glyph set is closed over composite-glyph components first, so a glyph
+// built from others (e.g. "ä") keeps its parts. Fonts without `glyf`/`loca` (CFF/OTF) pass through.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subsetTTF = subsetTTF;
+const u32 = (n) => n >>> 0;
+/** TrueType table checksum: sum of big-endian uint32 over the 4-byte-padded table data. */
+function checksum(buf) {
+    let sum = 0;
+    for (let i = 0; i < buf.length; i += 4)
+        sum = u32(sum + buf.readUInt32BE(i));
+    return sum;
+}
+/** Right-pad to a 4-byte boundary (table data is aligned in the sfnt). */
+function pad4(buf) {
+    const rem = buf.length % 4;
+    return rem === 0 ? buf : Buffer.concat([buf, Buffer.alloc(4 - rem)]);
+}
+function subsetTTF(data, used) {
+    const numTables = data.readUInt16BE(4);
+    const dir = new Map();
+    let p = 12;
+    for (let i = 0; i < numTables; i++) {
+        dir.set(data.toString("latin1", p, p + 4), {
+            offset: data.readUInt32BE(p + 8),
+            length: data.readUInt32BE(p + 12),
+        });
+        p += 16;
+    }
+    // No glyf/loca → not a TrueType-outline font we can subset this way; hand it back unchanged.
+    if (!dir.has("glyf") || !dir.has("loca") || !dir.has("head") || !dir.has("maxp"))
+        return data;
+    const headOff = dir.get("head").offset;
+    const longLoca = data.readInt16BE(headOff + 50) === 1;
+    const numGlyphs = data.readUInt16BE(dir.get("maxp").offset + 4);
+    const locaOff = dir.get("loca").offset;
+    const glyfOff = dir.get("glyf").offset;
+    // Original glyph offsets (numGlyphs + 1 entries; short loca stores half-offsets).
+    const loca = [];
+    for (let g = 0; g <= numGlyphs; g++) {
+        loca.push(longLoca ? data.readUInt32BE(locaOff + g * 4) : data.readUInt16BE(locaOff + g * 2) * 2);
+    }
+    const glyphBytes = (g) => data.subarray(glyfOff + loca[g], glyfOff + loca[g + 1]);
+    // Close the used set over composite components (and always keep .notdef = gid 0).
+    const keep = new Set([0]);
+    const stack = [...used, 0];
+    while (stack.length) {
+        const g = stack.pop();
+        if (g < 0 || g >= numGlyphs || keep.has(g))
+            continue;
+        keep.add(g);
+        const gd = glyphBytes(g);
+        if (gd.length >= 10 && gd.readInt16BE(0) < 0) {
+            // Composite glyph: walk the component records to collect the referenced gids.
+            let q = 10; // numberOfContours(2) + xMin/yMin/xMax/yMax(8)
+            for (;;) {
+                const flags = gd.readUInt16BE(q);
+                stack.push(gd.readUInt16BE(q + 2));
+                q += 4 + (flags & 0x0001 ? 4 : 2); // ARG_1_AND_2_ARE_WORDS
+                if (flags & 0x0008)
+                    q += 2; // WE_HAVE_A_SCALE
+                else if (flags & 0x0040)
+                    q += 4; // WE_HAVE_AN_X_AND_Y_SCALE
+                else if (flags & 0x0080)
+                    q += 8; // WE_HAVE_A_TWO_BY_TWO
+                if (!(flags & 0x0020))
+                    break; // MORE_COMPONENTS
+            }
+        }
+    }
+    // Rebuild glyf (kept glyphs only, original numbering) + a long-format loca.
+    const parts = [];
+    const newLoca = Buffer.alloc((numGlyphs + 1) * 4);
+    let off = 0;
+    for (let g = 0; g < numGlyphs; g++) {
+        newLoca.writeUInt32BE(off, g * 4);
+        if (keep.has(g)) {
+            let gd = Buffer.from(glyphBytes(g));
+            if (gd.length % 2 === 1)
+                gd = Buffer.concat([gd, Buffer.alloc(1)]); // keep offsets even
+            parts.push(gd);
+            off += gd.length;
+        }
+    }
+    newLoca.writeUInt32BE(off, numGlyphs * 4);
+    const newGlyf = Buffer.concat(parts);
+    // head copy with indexToLocFormat = 1 (long); checkSumAdjustment zeroed, fixed up at the end.
+    const newHead = Buffer.from(data.subarray(headOff, headOff + dir.get("head").length));
+    newHead.writeInt16BE(1, 50);
+    newHead.writeUInt32BE(0, 8);
+    // Tables a PDF-embedded CIDFontType2 doesn't need - layout (GSUB/GPOS…), hinting hints and the
+    // signature are dead weight; dropping them is most of the size win. `post` is reduced to format 3
+    // (header only, no glyph names). cmap/name/OS-2 are kept for a still-valid standalone font.
+    const DROP = new Set([
+        "GSUB",
+        "GPOS",
+        "GDEF",
+        "BASE",
+        "JSTF",
+        "kern",
+        "DSIG",
+        "hdmx",
+        "LTSH",
+        "VDMX",
+        "PCLT",
+        "gasp",
+    ]);
+    const tags = [...dir.keys()].filter((t) => !DROP.has(t)).sort();
+    const tables = tags.map((tag) => {
+        let body;
+        if (tag === "glyf")
+            body = newGlyf;
+        else if (tag === "loca")
+            body = newLoca;
+        else if (tag === "head")
+            body = newHead;
+        else if (tag === "post") {
+            // Keep the 32-byte header, force version 3.0 (drops the per-glyph name list).
+            body = Buffer.from(data.subarray(dir.get("post").offset, dir.get("post").offset + 32));
+            body.writeUInt32BE(0x00030000, 0);
+        }
+        else {
+            const d = dir.get(tag);
+            body = data.subarray(d.offset, d.offset + d.length);
+        }
+        return { tag, body, length: body.length };
+    });
+    // sfnt: offset table + table directory + 4-byte-aligned table data.
+    const n = tables.length;
+    const maxPow2 = 1 << Math.floor(Math.log2(n));
+    const out = [];
+    const offsetTable = Buffer.alloc(12);
+    offsetTable.writeUInt32BE(data.readUInt32BE(0), 0); // sfntVersion
+    offsetTable.writeUInt16BE(n, 4);
+    offsetTable.writeUInt16BE(maxPow2 * 16, 6); // searchRange
+    offsetTable.writeUInt16BE(Math.floor(Math.log2(n)), 8); // entrySelector
+    offsetTable.writeUInt16BE(n * 16 - maxPow2 * 16, 10); // rangeShift
+    out.push(offsetTable);
+    const dirBuf = Buffer.alloc(n * 16);
+    let tableOffset = 12 + n * 16;
+    const dataBufs = [];
+    tables.forEach((t, i) => {
+        const padded = pad4(t.body);
+        dirBuf.write(t.tag, i * 16, 4, "latin1");
+        dirBuf.writeUInt32BE(checksum(padded), i * 16 + 4);
+        dirBuf.writeUInt32BE(tableOffset, i * 16 + 8);
+        dirBuf.writeUInt32BE(t.length, i * 16 + 12); // real (unpadded) length
+        tableOffset += padded.length;
+        dataBufs.push(padded);
+    });
+    out.push(dirBuf, ...dataBufs);
+    const font = Buffer.concat(out);
+    // head.checkSumAdjustment = 0xB1B0AFBA - checksum(whole font). Locate head in the assembled font.
+    const headIdx = tables.findIndex((t) => t.tag === "head");
+    const headPos = dirBuf.readUInt32BE(headIdx * 16 + 8);
+    font.writeUInt32BE(u32(0xb1b0afba - checksum(font)), headPos + 8);
+    return font;
+}

package/dist/utils/utf8-to-windows1252-encoder.d.ts

@@ -0,0 +1,2 @@
+/** Encodes a JavaScript string to a Windows-1252 byte buffer (the PDF text encoding). */
+export declare function getArrayBuffer(data: string): ArrayBuffer;

package/dist/utils/utf8-to-windows1252-encoder.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArrayBuffer = getArrayBuffer;
+// Windows-1252 equals Latin-1 (codepoint == byte) EXCEPT in 0x80-0x9F, where it carries
+// printable punctuation - the Euro sign, smart quotes, dashes, ellipsis, ... - instead of
+// C1 controls. Those glyphs sit at Unicode codepoints far outside 0x00-0xFF, so a naive
+// low-byte cast turns "€" (U+20AC) into 0xAC ("¬"). This table maps each back to its
+// Windows-1252 byte. (The font metrics already resolve these via the Adobe Glyph List, so
+// only the emitted byte was wrong.)
+const CP1252_FROM_UNICODE = {
+    0x20ac: 0x80, // € Euro
+    0x201a: 0x82, // ‚ single low-9 quote
+    0x0192: 0x83, // ƒ florin
+    0x201e: 0x84, // „ double low-9 quote
+    0x2026: 0x85, // … ellipsis
+    0x2020: 0x86, // † dagger
+    0x2021: 0x87, // ‡ double dagger
+    0x02c6: 0x88, // ˆ circumflex
+    0x2030: 0x89, // ‰ per mille
+    0x0160: 0x8a, // Š S caron
+    0x2039: 0x8b, // ‹ single left angle quote
+    0x0152: 0x8c, // ΠOE ligature
+    0x017d: 0x8e, // Ž Z caron
+    0x2018: 0x91, // ' left single quote
+    0x2019: 0x92, // ' right single quote
+    0x201c: 0x93, // " left double quote
+    0x201d: 0x94, // " right double quote
+    0x2022: 0x95, // • bullet
+    0x2013: 0x96, // – en dash
+    0x2014: 0x97, // — em dash
+    0x02dc: 0x98, // ˜ small tilde
+    0x2122: 0x99, // ™ trademark
+    0x0161: 0x9a, // š s caron
+    0x203a: 0x9b, // › single right angle quote
+    0x0153: 0x9c, // œ oe ligature
+    0x017e: 0x9e, // ž z caron
+    0x0178: 0x9f, // Ÿ Y diaeresis
+};
+/** Encodes a JavaScript string to a Windows-1252 byte buffer (the PDF text encoding). */
+function getArrayBuffer(data) {
+    const u8 = new Uint8Array(data.length);
+    for (let i = 0; i < data.length; i++) {
+        const code = data.charCodeAt(i);
+        if (code <= 0xff) {
+            u8[i] = code; // Latin-1 range: codepoint is the Windows-1252 byte
+        }
+        else if (CP1252_FROM_UNICODE[code] !== undefined) {
+            u8[i] = CP1252_FROM_UNICODE[code];
+        }
+        else {
+            u8[i] = 0x3f; // "?" - not representable in Windows-1252
+        }
+    }
+    return u8.buffer;
+}

package/dist/validators/element-validator.d.ts

@@ -0,0 +1,8 @@
+import { PDFDocumentElement } from "../elements/pdf-document-element";
+import { PDFElement, FlexiblePDFElement, SizedPDFElement } from "../elements/pdf-element";
+export declare class Validator {
+    static validateDocument(document: PDFDocumentElement): void;
+    static validateElement(element: PDFElement): void;
+    static validateSizedElement(element: SizedPDFElement): void;
+    static validateFlexElement(element: FlexiblePDFElement): void;
+}

package/dist/validators/element-validator.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+const pdf_document_element_1 = require("../elements/pdf-document-element");
+const pdf_element_1 = require("../elements/pdf-element");
+class Validator {
+    static validateDocument(document) {
+        // More validation will be added later...
+        document.getProps().children.forEach((page) => {
+            page.getProps().children.forEach((element) => {
+                if (element instanceof pdf_document_element_1.PDFDocumentElement) {
+                    throw new Error("PDFDocument cannot be nested inside another element.");
+                }
+            });
+        });
+    }
+    static validateElement(element) {
+        // Structural validation
+        if (element instanceof pdf_document_element_1.PDFDocumentElement) {
+            throw new Error("PDFDocument cannot be nested inside another element.");
+        }
+        // Layout validation: geometry comes from the typed getSize(), not the props bag.
+        if (element instanceof pdf_element_1.SizedPDFElement) {
+            const { x, y, width, height } = element.getSize();
+            if (x < 0 || y < 0) {
+                throw new Error(`Element ${element.constructor.name} has invalid coordinates (x: ${x}, y: ${y})`);
+            }
+            // 0 is legitimate (a hairline divider, an empty spacer); only a NEGATIVE size is invalid.
+            if ((width !== undefined && width < 0) || (height !== undefined && height < 0)) {
+                throw new Error(`Element ${element.constructor.name} has invalid size (width: ${width}, height: ${height})`);
+            }
+        }
+        // Logical validation: Flexible and fixed elements
+        if (element instanceof pdf_element_1.FlexiblePDFElement) {
+            this.validateFlexElement(element);
+        }
+    }
+    static validateSizedElement(element) {
+        const { x, y, width, height } = element.getSize();
+        if (x < 0 || y < 0) {
+            throw new Error(`Element ${element.constructor.name} has invalid coordinates (x: ${x}, y: ${y})`);
+        }
+        // A size must be set, but 0 is legitimate (a hairline divider); only NEGATIVE is invalid.
+        if (width === undefined || height === undefined || width < 0 || height < 0) {
+            throw new Error(`Element ${element.constructor.name} has invalid size (width: ${width}, height: ${height})`);
+        }
+    }
+    static validateFlexElement(element) {
+        // Ensure flexible elements have valid flex values
+        if (element.getFlex() <= 0) {
+            throw new Error(`Flexible element ${element.constructor.name} has invalid flex value`);
+        }
+        // Ensure a flexible element does not contain another flexible element
+        if ((0, pdf_element_1.hasChildProp)(element)) {
+            if (element.child instanceof pdf_element_1.FlexiblePDFElement) {
+                throw new Error(`Flexible element ${element.constructor.name} cannot hold another flexible element`);
+            }
+        }
+    }
+}
+exports.Validator = Validator;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@jasy/pdf",
+  "version": "1.0.0-alpha.1",
+  "description": "Declarative, component-based PDF generation in pure TypeScript - Flutter-style components, real AFM font metrics, a hand-rolled PDF writer. No headless browser, no Java.",
+  "keywords": [
+    "declarative",
+    "factur-x",
+    "invoice",
+    "layout",
+    "pagination",
+    "pdf",
+    "pdf-a",
+    "pdf-generation",
+    "typescript",
+    "zugferd"
+  ],
+  "license": "MIT",
+  "author": "Florian Heuberger",
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "jimp": "^1.6.0"
+  },
+  "devDependencies": {
+    "@jimp/types": "^1.6.0",
+    "@types/node": "^25.9.3",
+    "@vitest/coverage-v8": "^2.1.1",
+    "ncp": "^2.0.0",
+    "oxfmt": "^0.55.0",
+    "oxlint": "^1.70.0",
+    "typescript": "^5.5.4",
+    "vitest": "^2.1.1"
+  },
+  "scripts": {
+    "copy-assets": "ncp ./src/lib/assets ./dist/assets",
+    "cli": "pnpm --filter @jasy/cli dev",
+    "cli:watch": "pnpm --filter @jasy/cli watch",
+    "play": "pnpm --filter @jasy/playground play",
+    "test": "vitest",
+    "test:coverage": "vitest --coverage",
+    "build": "tsc && pnpm run copy-assets",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "fmt": "oxfmt",
+    "fmt:check": "oxfmt --check"
+  }
+}