pagyra-js 0.0.21 → 0.0.23

package/dist/src/fonts/woff2/glyf-reconstructor.js

@@ -0,0 +1,357 @@
+import { Buf, read255UShort } from "./buffer.js";
+import { computeULongSum, round4, store16, store32 } from "./utils.js";
+export const GLYF_FLAGS = {
+    ON_CURVE: 1 << 0,
+    X_SHORT: 1 << 1,
+    Y_SHORT: 1 << 2,
+    REPEAT: 1 << 3,
+    X_SAME: 1 << 4,
+    Y_SAME: 1 << 5,
+    OVERLAP_SIMPLE: 1 << 6
+};
+export const COMPOSITE_FLAGS = {
+    ARG_WORDS: 1 << 0,
+    WE_HAVE_A_SCALE: 1 << 3,
+    MORE_COMPONENTS: 1 << 5,
+    WE_HAVE_AN_XY_SCALE: 1 << 6,
+    WE_HAVE_A_TWO_BY_TWO: 1 << 7,
+    WE_HAVE_INSTRUCTIONS: 1 << 8
+};
+export function withSign(flag, base) {
+    return (flag & 1) ? base : -base;
+}
+export function tripletDecode(flagsIn, data, nPoints) {
+    let x = 0;
+    let y = 0;
+    let tripletIndex = 0;
+    const points = new Array(nPoints);
+    for (let i = 0; i < nPoints; i++) {
+        let flag = flagsIn[i];
+        const onCurve = (flag >> 7) === 0;
+        flag &= 0x7f;
+        let nDataBytes = 1;
+        if (flag >= 84 && flag < 120)
+            nDataBytes = 2;
+        else if (flag < 84)
+            nDataBytes = 1;
+        else if (flag < 124)
+            nDataBytes = 3;
+        else
+            nDataBytes = 4;
+        if (tripletIndex + nDataBytes > data.length) {
+            throw new Error("Invalid WOFF2 glyf triplet");
+        }
+        let dx;
+        let dy;
+        if (flag < 10) {
+            dx = 0;
+            dy = withSign(flag, ((flag & 14) << 7) + data[tripletIndex]);
+        }
+        else if (flag < 20) {
+            dx = withSign(flag, (((flag - 10) & 14) << 7) + data[tripletIndex]);
+            dy = 0;
+        }
+        else if (flag < 84) {
+            const b0 = flag - 20;
+            const b1 = data[tripletIndex];
+            dx = withSign(flag, 1 + (b0 & 0x30) + (b1 >> 4));
+            dy = withSign(flag >> 1, 1 + ((b0 & 0x0c) << 2) + (b1 & 0x0f));
+        }
+        else if (flag < 120) {
+            const b0 = flag - 84;
+            dx = withSign(flag, 1 + ((b0 / 12) << 8) + data[tripletIndex]);
+            dy = withSign(flag >> 1, 1 + (((b0 % 12) >> 2) << 8) + data[tripletIndex + 1]);
+        }
+        else if (flag < 124) {
+            const b2 = data[tripletIndex + 1];
+            dx = withSign(flag, (data[tripletIndex] << 4) + (b2 >> 4));
+            dy = withSign(flag >> 1, ((b2 & 0x0f) << 8) + data[tripletIndex + 2]);
+        }
+        else {
+            dx = withSign(flag, (data[tripletIndex] << 8) + data[tripletIndex + 1]);
+            dy = withSign(flag >> 1, (data[tripletIndex + 2] << 8) + data[tripletIndex + 3]);
+        }
+        tripletIndex += nDataBytes;
+        x += dx;
+        y += dy;
+        points[i] = { x, y, onCurve };
+    }
+    return { points, consumed: tripletIndex };
+}
+export function storePoints(points, nContours, instructionLength, hasOverlap) {
+    const nPoints = points.length;
+    const xBytes = [];
+    const yBytes = [];
+    let lastX = 0;
+    let lastY = 0;
+    let lastFlag = -1;
+    let repeatCount = 0;
+    const flagOffset = 10 + 2 * nContours + 2 + instructionLength;
+    const flagsOut = [];
+    for (let i = 0; i < nPoints; i++) {
+        const point = points[i];
+        let flag = point.onCurve ? GLYF_FLAGS.ON_CURVE : 0;
+        if (hasOverlap && i === 0) {
+            flag |= GLYF_FLAGS.OVERLAP_SIMPLE;
+        }
+        const dx = point.x - lastX;
+        const dy = point.y - lastY;
+        if (dx === 0)
+            flag |= GLYF_FLAGS.X_SAME;
+        else if (dx > -256 && dx < 256) {
+            flag |= GLYF_FLAGS.X_SHORT | (dx > 0 ? GLYF_FLAGS.X_SAME : 0);
+            xBytes.push(Math.abs(dx));
+        }
+        else {
+            xBytes.push((dx >> 8) & 0xff, dx & 0xff);
+        }
+        if (dy === 0)
+            flag |= GLYF_FLAGS.Y_SAME;
+        else if (dy > -256 && dy < 256) {
+            flag |= GLYF_FLAGS.Y_SHORT | (dy > 0 ? GLYF_FLAGS.Y_SAME : 0);
+            yBytes.push(Math.abs(dy));
+        }
+        else {
+            yBytes.push((dy >> 8) & 0xff, dy & 0xff);
+        }
+        if (flag === lastFlag && repeatCount !== 255) {
+            flagsOut[flagsOut.length - 1] |= GLYF_FLAGS.REPEAT;
+            repeatCount++;
+        }
+        else {
+            if (repeatCount !== 0) {
+                flagsOut.push(repeatCount);
+            }
+            flagsOut.push(flag);
+            repeatCount = 0;
+            lastFlag = flag;
+        }
+        lastX = point.x;
+        lastY = point.y;
+    }
+    if (repeatCount !== 0) {
+        flagsOut.push(repeatCount);
+    }
+    const totalSize = flagOffset + flagsOut.length + xBytes.length + yBytes.length;
+    const out = new Uint8Array(totalSize);
+    let offset = flagOffset;
+    for (const f of flagsOut)
+        out[offset++] = f;
+    for (const b of xBytes)
+        out[offset++] = b;
+    for (const b of yBytes)
+        out[offset++] = b;
+    return out;
+}
+export function computeBBox(points) {
+    if (points.length === 0) {
+        return [0, 0, 0, 0];
+    }
+    let xMin = points[0].x;
+    let xMax = points[0].x;
+    let yMin = points[0].y;
+    let yMax = points[0].y;
+    for (let i = 1; i < points.length; i++) {
+        const p = points[i];
+        if (p.x < xMin)
+            xMin = p.x;
+        if (p.x > xMax)
+            xMax = p.x;
+        if (p.y < yMin)
+            yMin = p.y;
+        if (p.y > yMax)
+            yMax = p.y;
+    }
+    return [xMin, yMin, xMax, yMax];
+}
+export function sizeOfComposite(stream) {
+    const start = stream.offset;
+    let flags = COMPOSITE_FLAGS.MORE_COMPONENTS;
+    let haveInstructions = false;
+    while (flags & COMPOSITE_FLAGS.MORE_COMPONENTS) {
+        flags = stream.readU16();
+        haveInstructions || (haveInstructions = (flags & COMPOSITE_FLAGS.WE_HAVE_INSTRUCTIONS) !== 0);
+        let argSize = 2; // glyph index
+        if (flags & COMPOSITE_FLAGS.ARG_WORDS)
+            argSize += 4;
+        else
+            argSize += 2;
+        if (flags & COMPOSITE_FLAGS.WE_HAVE_A_SCALE)
+            argSize += 2;
+        else if (flags & COMPOSITE_FLAGS.WE_HAVE_AN_XY_SCALE)
+            argSize += 4;
+        else if (flags & COMPOSITE_FLAGS.WE_HAVE_A_TWO_BY_TWO)
+            argSize += 8;
+        stream.skip(argSize);
+    }
+    return { size: stream.offset - start, haveInstructions };
+}
+export function storeLoca(locaValues, indexFormat) {
+    const offsetSize = indexFormat ? 4 : 2;
+    const buffer = new Uint8Array(locaValues.length * offsetSize);
+    let off = 0;
+    for (const value of locaValues) {
+        if (indexFormat) {
+            off = store32(value, buffer, off);
+        }
+        else {
+            off = store16(value >> 1, buffer, off);
+        }
+    }
+    return { data: buffer, checksum: computeULongSum(buffer) };
+}
+export function reconstructGlyfTable(transformed, locaDstLength) {
+    const stream = new Buf(transformed);
+    /* const version = */ stream.readU16();
+    const flags = stream.readU16();
+    const hasOverlapBitmap = (flags & 1) !== 0;
+    const numGlyphs = stream.readU16();
+    const indexFormat = stream.readU16();
+    const substreamSizes = [];
+    for (let i = 0; i < 7; i++) {
+        substreamSizes.push(stream.readU32());
+    }
+    let dataOffset = (2 + 7) * 4; // header (version/flags/numGlyphs/indexFormat + sizes)
+    const substreams = [];
+    for (const sz of substreamSizes) {
+        if (dataOffset + sz > transformed.length) {
+            throw new Error("Invalid WOFF2 glyf stream");
+        }
+        substreams.push(transformed.subarray(dataOffset, dataOffset + sz));
+        dataOffset += sz;
+    }
+    let overlapBitmap = null;
+    if (hasOverlapBitmap) {
+        const len = (numGlyphs + 7) >> 3;
+        if (dataOffset + len > transformed.length) {
+            throw new Error("Invalid WOFF2 overlap bitmap");
+        }
+        overlapBitmap = transformed.subarray(dataOffset, dataOffset + len);
+    }
+    const nContourStream = new Buf(substreams[0]);
+    const nPointsStream = new Buf(substreams[1]);
+    const flagStream = new Buf(substreams[2]);
+    const glyphStream = new Buf(substreams[3]);
+    const compositeStream = new Buf(substreams[4]);
+    const bboxStream = new Buf(substreams[5]);
+    const instructionStream = new Buf(substreams[6]);
+    const bboxBitmapLen = ((numGlyphs + 31) >> 5) << 2;
+    const bboxBitmap = bboxStream.readBytes(bboxBitmapLen);
+    const locaValues = new Array(numGlyphs + 1).fill(0);
+    const xMins = new Int16Array(numGlyphs);
+    const glyfChunks = [];
+    let glyfChecksum = 0 >>> 0;
+    let currentGlyfOffset = 0;
+    for (let i = 0; i < numGlyphs; i++) {
+        const nContours = nContourStream.readU16();
+        const haveBbox = (bboxBitmap[i >> 3] & (0x80 >> (i & 7))) !== 0;
+        let glyphBytes = null;
+        if (nContours === 0xffff) {
+            // Composite
+            const { size: compositeSize, haveInstructions } = sizeOfComposite(new Buf(compositeStream.peekRemaining()));
+            let instructionSize = 0;
+            if (haveInstructions) {
+                instructionSize = read255UShort(glyphStream);
+            }
+            const total = 12 + compositeSize + instructionSize; // nContours + bbox + composite + instructions
+            const out = new Uint8Array(total);
+            let off = 0;
+            off = store16(nContours, out, off);
+            if (!haveBbox) {
+                throw new Error("Invalid WOFF2 glyf: composite without bbox");
+            }
+            const bboxData = bboxStream.readBytes(8);
+            const xMinRaw = (bboxData[0] << 8) | bboxData[1];
+            xMins[i] = xMinRaw & 0x8000 ? xMinRaw - 0x10000 : xMinRaw;
+            out.set(bboxData, off);
+            off += 8;
+            out.set(compositeStream.readBytes(compositeSize), off);
+            off += compositeSize;
+            if (haveInstructions) {
+                off = store16(instructionSize, out, off);
+                out.set(instructionStream.readBytes(instructionSize), off);
+            }
+            glyphBytes = out;
+        }
+        else if (nContours > 0) {
+            const nPoints = [];
+            let totalPoints = 0;
+            for (let c = 0; c < nContours; c++) {
+                const pts = read255UShort(nPointsStream);
+                totalPoints += pts;
+                nPoints.push(pts);
+            }
+            const flagData = flagStream.readBytes(totalPoints);
+            const tripletsView = glyphStream.peekRemaining();
+            const { points, consumed } = tripletDecode(flagData, tripletsView, totalPoints);
+            glyphStream.offset += consumed;
+            const instructionSize = read255UShort(glyphStream);
+            const bbox = haveBbox ? bboxStream.readBytes(8) : null;
+            // const _baseSize = 12 + 2 * nContours + instructionSize;
+            const ptsBuf = storePoints(points, nContours, instructionSize, !!(overlapBitmap && (overlapBitmap[i >> 3] & (0x80 >> (i & 7)))));
+            const glyphBuf = new Uint8Array(ptsBuf.length);
+            glyphBuf.set(ptsBuf);
+            let off = 0;
+            off = store16(nContours, glyphBuf, off);
+            if (bbox) {
+                glyphBuf.set(bbox, off);
+                off += 8;
+            }
+            else {
+                const [xMin, yMin, xMax, yMax] = computeBBox(points);
+                off = store16(xMin, glyphBuf, off);
+                off = store16(yMin, glyphBuf, off);
+                off = store16(xMax, glyphBuf, off);
+                off = store16(yMax, glyphBuf, off);
+            }
+            let endPoint = -1;
+            for (const count of nPoints) {
+                endPoint += count;
+                off = store16(endPoint, glyphBuf, off);
+            }
+            off = store16(instructionSize, glyphBuf, off);
+            const remaining = instructionStream.peekRemaining().length;
+            const safeSize = Math.min(instructionSize, remaining);
+            const instructions = instructionStream.readBytes(safeSize);
+            glyphBuf.set(instructions, off);
+            glyphBytes = glyphBuf;
+            const xMinRaw = (glyphBuf[2] << 8) | glyphBuf[3];
+            xMins[i] = xMinRaw & 0x8000 ? xMinRaw - 0x10000 : xMinRaw;
+        }
+        else {
+            // Empty glyph
+            if (haveBbox) {
+                throw new Error("Invalid WOFF2 glyf: empty glyph with bbox");
+            }
+            glyphBytes = new Uint8Array(0);
+        }
+        locaValues[i] = currentGlyfOffset;
+        glyfChunks.push(glyphBytes);
+        currentGlyfOffset += round4(glyphBytes.length);
+        glyfChecksum = (glyfChecksum + computeULongSum(glyphBytes)) >>> 0;
+    }
+    locaValues[numGlyphs] = currentGlyfOffset;
+    if (locaDstLength !== (indexFormat ? 4 : 2) * (numGlyphs + 1)) {
+        throw new Error("Invalid WOFF2 loca length");
+    }
+    // Build glyf table with per-glyph padding
+    const glyfSize = locaValues[numGlyphs];
+    const glyfData = new Uint8Array(glyfSize);
+    let glyfOffset = 0;
+    for (const chunk of glyfChunks) {
+        glyfData.set(chunk, glyfOffset);
+        glyfOffset += chunk.length;
+        const padded = round4(glyfOffset) - glyfOffset;
+        glyfOffset += padded;
+    }
+    const loca = storeLoca(locaValues, indexFormat);
+    return {
+        glyfData,
+        locaData: loca.data,
+        glyfChecksum,
+        locaChecksum: loca.checksum,
+        numGlyphs,
+        indexFormat,
+        xMins
+    };
+}

package/dist/src/fonts/woff2/hmtx-reconstructor.d.ts

@@ -0,0 +1,5 @@
+export declare function readNumHMetrics(hheaTable: Uint8Array): number;
+export declare function reconstructTransformedHmtx(transformed: Uint8Array, numGlyphs: number, numHMetrics: number, xMins: Int16Array): {
+    data: Uint8Array;
+    checksum: number;
+};

package/dist/src/fonts/woff2/hmtx-reconstructor.js

@@ -0,0 +1,42 @@
+import { Buf } from "./buffer.js";
+import { computeULongSum, store16 } from "./utils.js";
+export function readNumHMetrics(hheaTable) {
+    const buf = new Buf(hheaTable);
+    buf.skip(34);
+    return buf.readU16();
+}
+export function reconstructTransformedHmtx(transformed, numGlyphs, numHMetrics, xMins) {
+    const buf = new Buf(transformed);
+    const flags = buf.readU8();
+    const hasPropLSB = (flags & 1) === 0;
+    const hasMonoLSB = (flags & 2) === 0;
+    if ((flags & 0xfc) !== 0) {
+        throw new Error("Invalid hmtx flags");
+    }
+    if (hasPropLSB && hasMonoLSB) {
+        throw new Error("Invalid hmtx transform state");
+    }
+    if (numHMetrics < 1 || numHMetrics > numGlyphs) {
+        throw new Error("Invalid hmtx metrics count");
+    }
+    const advanceWidths = [];
+    const lsbs = [];
+    for (let i = 0; i < numHMetrics; i++) {
+        advanceWidths.push(buf.readU16());
+    }
+    for (let i = 0; i < numHMetrics; i++) {
+        lsbs.push(hasPropLSB ? buf.readS16() : xMins[i]);
+    }
+    for (let i = numHMetrics; i < numGlyphs; i++) {
+        lsbs.push(hasMonoLSB ? buf.readS16() : xMins[i]);
+    }
+    const out = new Uint8Array(2 * numGlyphs + 2 * numHMetrics);
+    let off = 0;
+    for (let i = 0; i < numGlyphs; i++) {
+        if (i < numHMetrics) {
+            off = store16(advanceWidths[i], out, off);
+        }
+        off = store16(lsbs[i], out, off);
+    }
+    return { data: out, checksum: computeULongSum(out) };
+}

package/dist/src/fonts/woff2/sfnt-builder.d.ts

@@ -0,0 +1,7 @@
+export declare const SFNT_HEADER_SIZE = 12;
+export declare const SFNT_ENTRY_SIZE = 16;
+export declare const CHECKSUM_ADJUSTMENT_OFFSET = 8;
+export declare function buildSfnt(flavor: number, tableData: Map<number, Uint8Array>): {
+    ttf: Uint8Array;
+    tables: Record<string, Uint8Array>;
+};

package/dist/src/fonts/woff2/sfnt-builder.js

@@ -0,0 +1,55 @@
+import { computeULongSum, round4, store16, store32, tagToString, TAG_HEAD, } from "./utils.js";
+export const SFNT_HEADER_SIZE = 12;
+export const SFNT_ENTRY_SIZE = 16;
+export const CHECKSUM_ADJUSTMENT_OFFSET = 8;
+export function buildSfnt(flavor, tableData) {
+    const entries = Array.from(tableData.entries()).sort((a, b) => a[0] - b[0]);
+    const numTables = entries.length;
+    let offset = SFNT_HEADER_SIZE + SFNT_ENTRY_SIZE * numTables;
+    const records = [];
+    for (const [tag, data] of entries) {
+        const paddedLen = round4(data.length);
+        records.push({
+            tag,
+            checksum: computeULongSum(data),
+            offset,
+            length: data.length,
+            data
+        });
+        offset += paddedLen;
+    }
+    const ttf = new Uint8Array(offset);
+    let off = 0;
+    off = store32(flavor >>> 0, ttf, off);
+    off = store16(numTables, ttf, off);
+    let maxPow2 = 0;
+    while ((1 << (maxPow2 + 1)) <= numTables)
+        maxPow2++;
+    const searchRange = (1 << maxPow2) * 16;
+    off = store16(searchRange, ttf, off);
+    off = store16(maxPow2, ttf, off);
+    off = store16(numTables * 16 - searchRange, ttf, off);
+    // table records
+    for (const rec of records) {
+        off = store32(rec.tag, ttf, off);
+        off = store32(rec.checksum, ttf, off);
+        off = store32(rec.offset, ttf, off);
+        off = store32(rec.length, ttf, off);
+    }
+    for (const rec of records) {
+        ttf.set(rec.data, rec.offset);
+        // zero padding already present
+    }
+    // checkSumAdjustment for 'head'
+    const headRecord = records.find((r) => r.tag === TAG_HEAD);
+    if (headRecord) {
+        const checksum = computeULongSum(ttf);
+        const adjustment = (0xb1b0afba - checksum) >>> 0;
+        store32(adjustment, ttf, headRecord.offset + CHECKSUM_ADJUSTMENT_OFFSET);
+    }
+    const tables = {};
+    for (const [tag, data] of entries) {
+        tables[tagToString(tag)] = data;
+    }
+    return { ttf, tables };
+}

package/dist/src/fonts/woff2/utils.d.ts

@@ -0,0 +1,12 @@
+export declare const TAG: (text: string) => number;
+export declare const TAG_GLYF: number;
+export declare const TAG_LOCA: number;
+export declare const TAG_HMTX: number;
+export declare const TAG_HHEA: number;
+export declare const TAG_HEAD: number;
+export declare const KNOWN_TAGS: number[];
+export declare function tagToString(tag: number): string;
+export declare const round4: (v: number) => number;
+export declare function computeULongSum(data: Uint8Array): number;
+export declare function store16(value: number, out: Uint8Array, offset: number): number;
+export declare function store32(value: number, out: Uint8Array, offset: number): number;

package/dist/src/fonts/woff2/utils.js

@@ -0,0 +1,111 @@
+export const TAG = (text) => (text.charCodeAt(0) << 24) |
+    (text.charCodeAt(1) << 16) |
+    (text.charCodeAt(2) << 8) |
+    text.charCodeAt(3);
+export const TAG_GLYF = TAG("glyf");
+export const TAG_LOCA = TAG("loca");
+export const TAG_HMTX = TAG("hmtx");
+export const TAG_HHEA = TAG("hhea");
+export const TAG_HEAD = TAG("head");
+// Known tag lookup as defined in table_tags.cc
+export const KNOWN_TAGS = [
+    TAG("cmap"),
+    TAG("head"),
+    TAG("hhea"),
+    TAG("hmtx"),
+    TAG("maxp"),
+    TAG("name"),
+    TAG("OS/2"),
+    TAG("post"),
+    TAG("cvt "),
+    TAG("fpgm"),
+    TAG_GLYF,
+    TAG_LOCA,
+    TAG("prep"),
+    TAG("CFF "),
+    TAG("VORG"),
+    TAG("EBDT"),
+    TAG("EBLC"),
+    TAG("gasp"),
+    TAG("hdmx"),
+    TAG("kern"),
+    TAG("LTSH"),
+    TAG("PCLT"),
+    TAG("VDMX"),
+    TAG("vhea"),
+    TAG("vmtx"),
+    TAG("BASE"),
+    TAG("GDEF"),
+    TAG("GPOS"),
+    TAG("GSUB"),
+    TAG("EBSC"),
+    TAG("JSTF"),
+    TAG("MATH"),
+    TAG("CBDT"),
+    TAG("CBLC"),
+    TAG("COLR"),
+    TAG("CPAL"),
+    TAG("SVG "),
+    TAG("sbix"),
+    TAG("acnt"),
+    TAG("avar"),
+    TAG("bdat"),
+    TAG("bloc"),
+    TAG("bsln"),
+    TAG("cvar"),
+    TAG("fdsc"),
+    TAG("feat"),
+    TAG("fmtx"),
+    TAG("fvar"),
+    TAG("gvar"),
+    TAG("hsty"),
+    TAG("just"),
+    TAG("lcar"),
+    TAG("mort"),
+    TAG("morx"),
+    TAG("opbd"),
+    TAG("prop"),
+    TAG("trak"),
+    TAG("Zapf"),
+    TAG("Silf"),
+    TAG("Glat"),
+    TAG("Gloc"),
+    TAG("Feat"),
+    TAG("Sill")
+];
+export function tagToString(tag) {
+    return String.fromCharCode((tag >> 24) & 0xff, (tag >> 16) & 0xff, (tag >> 8) & 0xff, tag & 0xff);
+}
+export const round4 = (v) => (v + 3) & ~3;
+export function computeULongSum(data) {
+    let checksum = 0 >>> 0;
+    const aligned = data.length & ~3;
+    for (let i = 0; i < aligned; i += 4) {
+        const value = (data[i] << 24) |
+            (data[i + 1] << 16) |
+            (data[i + 2] << 8) |
+            data[i + 3];
+        checksum = (checksum + value) >>> 0;
+    }
+    if (aligned !== data.length) {
+        let v = 0;
+        for (let i = aligned; i < data.length; i++) {
+            v |= data[i] << (24 - 8 * (i & 3));
+        }
+        checksum = (checksum + v) >>> 0;
+    }
+    return checksum >>> 0;
+}
+export function store16(value, out, offset) {
+    const v = value & 0xffff;
+    out[offset] = (v >> 8) & 0xff;
+    out[offset + 1] = v & 0xff;
+    return offset + 2;
+}
+export function store32(value, out, offset) {
+    out[offset] = (value >>> 24) & 0xff;
+    out[offset + 1] = (value >>> 16) & 0xff;
+    out[offset + 2] = (value >>> 8) & 0xff;
+    out[offset + 3] = value & 0xff;
+    return offset + 4;
+}

package/dist/src/html-to-pdf/render-finalize.js

@@ -1,6 +1,6 @@
 import { FontEmbedder } from "../pdf/font/embedder.js";
 import { PdfDocument } from "../pdf/primitives/pdf-document.js";
-import { applyPageVerticalMarginsWithHf, offsetRenderTree } from "../render/offset.js";
+import { applyBreakInsideAvoid, applyPageVerticalMarginsWithHf, offsetRenderTree } from "../render/offset.js";
 import { applyTextLayoutAdjustments } from "../pdf/utils/text-layout-adjuster.js";
 import { buildRenderTree } from "../pdf/layout-tree-builder.js";
 export async function initializeFontEmbedder(fontConfig) {
@@ -17,6 +17,10 @@ export function finalizeRenderTreePositioning(options) {
     applyTextLayoutAdjustments(renderTree.root);
     const headerHeightPx = resolvedHeaderFooter?.maxHeaderHeightPx ?? 0;
     const footerHeightPx = resolvedHeaderFooter?.maxFooterHeightPx ?? 0;
+    const usablePageHeight = pageHeight - marginsPx.top - marginsPx.bottom - headerHeightPx - footerHeightPx;
+    if (usablePageHeight > 0) {
+        applyBreakInsideAvoid(renderTree.root, usablePageHeight);
+    }
     applyPageVerticalMarginsWithHf(renderTree.root, {
         pageHeight,
         margins: marginsPx,

package/dist/src/layout/inline/run-placer.js

@@ -18,7 +18,7 @@ export class RunPlacer {
         if (parts.length === 0) {
             return;
         }
-        const { lineTop, lineHeight, lineStartX, lineIndex, availableWidth, offsetShift, isLastLine, contentX, inlineOffsetStart } = lineContext;
+        const { lineTop, lineStartX, lineIndex, availableWidth, offsetShift, isLastLine, contentX, inlineOffsetStart } = lineContext;
         const lineWidth = parts.reduce((max, part) => Math.max(max, part.offset + part.item.width), 0);
         const currentAvailableWidth = Math.max(availableWidth, 0);
         const spaceCount = parts.reduce((count, part) => {

package/dist/src/layout/strategies/flex/alignment.d.ts

@@ -0,0 +1,10 @@
+import { AlignItems, JustifyContent } from "../../../css/enums.js";
+import type { AlignSelfValue } from "../../../css/style.js";
+import type { AlignContentResolution, FlexLine } from "./types.js";
+export declare function resolveAlignContentLayout(lines: FlexLine[], alignContent: string, containerCrossSize: number, crossAxisGap: number): AlignContentResolution;
+export declare function resolveItemAlignment(alignSelf: AlignSelfValue | undefined, containerAlign: AlignItems): AlignItems;
+export declare function computeCrossOffset(alignment: AlignItems, containerSize: number, itemSize: number, marginStart: number, marginEnd: number): number;
+export declare function resolveJustifySpacing(justify: JustifyContent, freeSpace: number, itemCount: number): {
+    offset: number;
+    gap: number;
+};