pagyra-js 0.0.1

package/src/compression/deflate.ts

@@ -0,0 +1,295 @@
+import { Adler32 } from './adler32.js';
+import type {
+  DeflateOptions,
+  InflateOptions,
+  DeflateResult,
+  CompressionStats,
+} from './types.js';
+import { CompressionMethod } from './types.js';
+import {
+  writeUInt32BE,
+  readUInt32BE,
+  concatUint8Arrays,
+  toUint8Array,
+} from './utils.js';
+
+/**
+ * DEFLATE compression/decompression module for WOFF 1.0
+ *
+ * WOFF 1.0 uses zlib-compressed data, which consists of:
+ * - 2-byte zlib header
+ * - DEFLATE-compressed data
+ * - 4-byte Adler-32 checksum
+ */
+export class WOFFDeflate {
+  private static readonly ZLIB_HEADER_CM_DEFLATE = 0x78; // CMF byte for DEFLATE
+  private static readonly DEFAULT_COMPRESSION_LEVEL = 6;
+
+  /**
+   * Compress data using DEFLATE algorithm (zlib format for WOFF)
+   */
+  static async compress(
+    input: Uint8Array | ArrayBuffer,
+    options: DeflateOptions = {}
+  ): Promise<DeflateResult> {
+    const data = toUint8Array(input);
+    const level = options.level ?? this.DEFAULT_COMPRESSION_LEVEL;
+
+    // Compress using available implementation
+    const compressed = await this.deflateCompress(data, level);
+
+    // Create zlib format: header + compressed data + checksum
+    const zlibData = this.wrapWithZlibFormat(compressed, data);
+
+    return {
+      data: zlibData,
+      compressedSize: zlibData.length,
+      uncompressedSize: data.length,
+    };
+  }
+
+  /**
+   * Decompress DEFLATE data (zlib format)
+   */
+  static async decompress(
+    input: Uint8Array | ArrayBuffer,
+    _options: InflateOptions = {}
+  ): Promise<Uint8Array> {
+    const data = toUint8Array(input);
+
+    // Verify and strip zlib wrapper
+    const { compressed, checksum } = this.unwrapZlibFormat(data);
+
+    // Decompress
+    const decompressed = await this.deflateDecompress(compressed);
+
+    // Verify checksum
+    const calculatedChecksum = Adler32.calculate(decompressed);
+    if (calculatedChecksum !== checksum) {
+      throw new Error(
+        `Adler-32 checksum mismatch: expected ${checksum}, got ${calculatedChecksum}`
+      );
+    }
+
+    return decompressed;
+  }
+
+  /**
+   * Get compression statistics
+   */
+  static getCompressionStats(
+    original: Uint8Array,
+    compressed: Uint8Array
+  ): CompressionStats {
+    return {
+      originalSize: original.length,
+      compressedSize: compressed.length,
+      compressionRatio: compressed.length / original.length,
+      checksum: Adler32.calculate(original),
+    };
+  }
+
+  /**
+   * Wrap compressed data with zlib format header and checksum
+   */
+  private static wrapWithZlibFormat(
+    compressed: Uint8Array,
+    original: Uint8Array
+  ): Uint8Array {
+    const checksum = Adler32.calculate(original);
+    const result = new Uint8Array(compressed.length + 6);
+
+    // Zlib header (2 bytes)
+    // CMF (Compression Method and flags)
+    const cmf = 0x78; // DEFLATE with 32K window
+
+    // FLG (Flags)
+    let flg = 0x9c; // Default compression
+
+    // Ensure (CMF * 256 + FLG) is a multiple of 31
+    const fcheck = 31 - ((cmf * 256 + flg) % 31);
+    flg = (flg & 0xe0) | fcheck;
+
+    result[0] = cmf;
+    result[1] = flg;
+
+    // Compressed data
+    result.set(compressed, 2);
+
+    // Adler-32 checksum (4 bytes, big-endian)
+    writeUInt32BE(checksum, result, result.length - 4);
+
+    return result;
+  }
+
+  /**
+   * Unwrap zlib format to get compressed data and checksum
+   */
+  private static unwrapZlibFormat(data: Uint8Array): {
+    compressed: Uint8Array;
+    checksum: number;
+    uncompressedSize: number;
+  } {
+    if (data.length < 6) {
+      throw new Error('Invalid zlib data: too short');
+    }
+
+    // Verify zlib header
+    const cmf = data[0];
+    const flg = data[1];
+
+    // Check compression method
+    const cm = cmf & 0x0f;
+    if (cm !== CompressionMethod.DEFLATE) {
+      throw new Error(`Unsupported compression method: ${cm}`);
+    }
+
+    // Verify header checksum
+    if ((cmf * 256 + flg) % 31 !== 0) {
+      throw new Error('Invalid zlib header checksum');
+    }
+
+    // Extract compressed data (between header and checksum)
+    const compressed = data.slice(2, -4);
+
+    // Extract Adler-32 checksum
+    const checksum = readUInt32BE(data, data.length - 4);
+
+    return {
+      compressed,
+      checksum,
+      uncompressedSize: 0, // Unknown until decompressed
+    };
+  }
+
+  /**
+   * Platform-specific DEFLATE compression
+   */
+  private static async deflateCompress(
+    data: Uint8Array,
+    level: number
+  ): Promise<Uint8Array> {
+    // Try browser CompressionStream API
+    if (typeof CompressionStream !== 'undefined') {
+      return this.browserDeflateCompress(data);
+    }
+
+    // Fallback to Node zlib when available
+    if (typeof process !== 'undefined' && process.versions?.node) {
+      return this.nodeDeflateCompress(data, level);
+    }
+
+    throw new Error('No DEFLATE implementation available');
+  }
+
+  /**
+   * Platform-specific DEFLATE decompression
+   */
+  private static async deflateDecompress(data: Uint8Array): Promise<Uint8Array> {
+    // Try browser DecompressionStream API
+    if (typeof DecompressionStream !== 'undefined') {
+      return this.browserDeflateDecompress(data);
+    }
+
+    // Fallback to Node zlib when available
+    if (typeof process !== 'undefined' && process.versions?.node) {
+      return this.nodeDeflateDecompress(data);
+    }
+
+    throw new Error('No DEFLATE implementation available');
+  }
+
+  /**
+   * Node.js DEFLATE compression using zlib
+   */
+  private static async nodeDeflateCompress(
+    data: Uint8Array,
+    level: number
+  ): Promise<Uint8Array> {
+    const zlib = await import('zlib');
+    const { promisify } = await import('util');
+    const deflateRaw = promisify(zlib.deflateRaw);
+
+    const compressed = await deflateRaw(data, {
+      level,
+      windowBits: 15,
+    });
+
+    return new Uint8Array(compressed);
+  }
+
+  /**
+   * Node.js DEFLATE decompression using zlib
+   */
+  private static async nodeDeflateDecompress(data: Uint8Array): Promise<Uint8Array> {
+    const zlib = await import('zlib');
+    const { promisify } = await import('util');
+    const inflateRaw = promisify(zlib.inflateRaw);
+
+    const decompressed = await inflateRaw(data, {
+      windowBits: 15,
+    });
+
+    return new Uint8Array(decompressed);
+  }
+
+  /**
+   * Browser DEFLATE compression using CompressionStream API
+   */
+  private static async browserDeflateCompress(data: Uint8Array): Promise<Uint8Array> {
+    const stream = new CompressionStream('deflate-raw');
+    const writer = stream.writable.getWriter();
+    writer.write(data as BufferSource);
+    writer.close();
+
+    const chunks: Uint8Array[] = [];
+    const reader = stream.readable.getReader();
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+
+    return concatUint8Arrays(chunks);
+  }
+
+  /**
+   * Browser DEFLATE decompression using DecompressionStream API
+   */
+  private static async browserDeflateDecompress(data: Uint8Array): Promise<Uint8Array> {
+    const stream = new DecompressionStream('deflate-raw');
+    const writer = stream.writable.getWriter();
+    writer.write(data as BufferSource);
+    writer.close();
+
+    const chunks: Uint8Array[] = [];
+    const reader = stream.readable.getReader();
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+
+    return concatUint8Arrays(chunks);
+  }
+
+  /**
+   * Validate WOFF compressed data
+   */
+  static validateCompressedData(data: Uint8Array): boolean {
+    try {
+      const { compressed, checksum } = this.unwrapZlibFormat(data);
+      return compressed.length > 0 && checksum > 0;
+    } catch {
+      return false;
+    }
+  }
+}
+
+// Export convenience functions
+export const compress = WOFFDeflate.compress.bind(WOFFDeflate);
+export const decompress = WOFFDeflate.decompress.bind(WOFFDeflate);
+export const getCompressionStats = WOFFDeflate.getCompressionStats.bind(WOFFDeflate);
+export const validateCompressedData = WOFFDeflate.validateCompressedData.bind(WOFFDeflate);

package/src/compression/index.ts

@@ -0,0 +1,4 @@
+export { WOFFDeflate, compress, decompress, getCompressionStats, validateCompressedData } from './deflate.js';
+export { Adler32 } from './adler32.js';
+export * from './types.js';
+export * from './utils.js';

package/src/compression/types.ts

@@ -0,0 +1,26 @@
+export interface DeflateOptions {
+  level?: number; // Compression level 0-9
+  windowBits?: number; // Size of compression window
+}
+
+export interface InflateOptions {
+  windowBits?: number;
+}
+
+export interface DeflateResult {
+  data: Uint8Array;
+  compressedSize: number;
+  uncompressedSize: number;
+}
+
+export interface CompressionStats {
+  originalSize: number;
+  compressedSize: number;
+  compressionRatio: number;
+  checksum: number;
+}
+
+export enum CompressionMethod {
+  NONE = 0,
+  DEFLATE = 8,
+}

package/src/compression/utils.ts

@@ -0,0 +1,107 @@
+/**
+ * Utility functions for DEFLATE operations
+ */
+
+/**
+ * Read a 16-bit big-endian integer from buffer
+ */
+export function readUInt16BE(buffer: Uint8Array, offset: number): number {
+  return (buffer[offset] << 8) | buffer[offset + 1];
+}
+
+/**
+ * Write a 32-bit big-endian integer to buffer.
+ * No bounds checking is performed for performance reasons.
+ */
+export function writeUInt32BE(value: number, buffer: Uint8Array, offset: number): void {
+  buffer[offset] = (value >>> 24) & 0xff;
+  buffer[offset + 1] = (value >>> 16) & 0xff;
+  buffer[offset + 2] = (value >>> 8) & 0xff;
+  buffer[offset + 3] = value & 0xff;
+}
+
+/**
+ * Read a 32-bit big-endian integer from buffer.
+ */
+export function readUInt32BE(buffer: Uint8Array, offset: number): number {
+  return (
+    ((buffer[offset] << 24) |
+    (buffer[offset + 1] << 16) |
+    (buffer[offset + 2] << 8) |
+    buffer[offset + 3]) >>> 0 // '>>> 0' ensures result is treated as unsigned
+  );
+}
+
+/**
+ * Write a 16-bit big-endian integer to buffer.
+ */
+export function writeUInt16BE(value: number, buffer: Uint8Array, offset: number): void {
+  buffer[offset] = (value >>> 8) & 0xff;
+  buffer[offset + 1] = value & 0xff;
+}
+
+/**
+ * Concatenate multiple Uint8Arrays.
+ */
+export function concatUint8Arrays(arrays: Uint8Array[]): Uint8Array {
+  // Optimization: Check for 0 or 1 array to avoid allocation
+  if (arrays.length === 0) return new Uint8Array(0);
+  if (arrays.length === 1) return arrays[0];
+
+  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+
+  return result;
+}
+
+/**
+ * Convert ArrayBuffer, DataView, or TypedArray to Uint8Array.
+ * This ensures we have a raw byte view regardless of input type.
+ */
+export function toUint8Array(data: ArrayBuffer | ArrayBufferView): Uint8Array {
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  return new Uint8Array(data);
+}
+
+/**
+ * Reads a UBASE128-encoded (Variable Length) number.
+ * Returns the number and the number of bytes read.
+ * 
+ * Note: This implementation assumes "Big Endian" variable length
+ * (most significant group first), common in some compression formats.
+ */
+export function readUBASE128(data: Uint8Array, offset: number): [number, number] {
+  let result = 0;
+  let bytesRead = 0;
+  
+  // Limit to 5 bytes (35 bits) to prevent infinite loops on bad data
+  // and to stay within JS Safe Integer range.
+  for (let i = 0; i < 5; i++) {
+    const byte = data[offset + i];
+    
+    // Use arithmetic (* 128) instead of bitwise (<< 7).
+    // Bitwise operators in JS work on 32-bit integers. 
+    // 5 bytes can exceed 32 bits (up to 35 bits), which would overflow using '<<'.
+    result = (result * 128) + (byte & 0x7f);
+    
+    bytesRead++;
+    
+    // If the high bit is NOT set, this is the last byte
+    if ((byte & 0x80) === 0) {
+      return [result, bytesRead];
+    }
+  }
+  
+  throw new Error("Invalid UBASE128 sequence (too long or incomplete)");
+}

package/src/core.ts

@@ -0,0 +1,18 @@
+export { LayoutNode } from "./dom/node.js";
+export type { NodeVisitor } from "./dom/node.js";
+
+export { ComputedStyle } from "./css/style.js";
+export type { StyleProperties, FlexDirection, GridAutoFlow, AlignSelfValue, TrackDefinition } from "./css/style.js";
+
+export * from "./css/enums.js";
+
+export type { Viewport, ContainingBlock } from "./geometry/box.js";
+export { Box } from "./geometry/box.js";
+
+export { LayoutEngine } from "./layout/pipeline/engine.js";
+export { createDefaultLayoutEngine } from "./layout/pipeline/default-engine.js";
+export { layoutTree } from "./layout/pipeline/layout-tree.js";
+export { renderPdf } from "./pdf/render.js";
+export { buildRenderTree } from "./pdf/layout-tree-builder.js";
+export type { RenderPdfOptions } from "./pdf/render.js";
+export type { LayoutTree as PdfLayoutTree } from "./pdf/types.js";

package/src/css/apply-declarations.ts

@@ -0,0 +1,86 @@
+// src/css/apply-declarations.ts
+
+import { getPropertyParser, type PropertyParser } from "./parsers/registry.js";
+import { registerAllPropertyParsers } from "./parsers/register-parsers.js";
+import { type StyleAccumulator } from "./style.js";
+import { type UnitParsers } from "../units/units.js";
+
+export { setViewportSize } from "./viewport.js";
+
+// Initialize the property parsers registry
+registerAllPropertyParsers();
+
+// Define shorthand properties that should be applied before longhands
+const SHORTHAND_PROPERTIES = new Set([
+  "border",
+  "border-color",
+  "border-style",
+  "border-width",
+  "border-radius",
+  "margin",
+  "padding",
+  "background",
+  "font",
+  "text-decoration",
+  "flex",
+  "gap"
+]);
+
+// Cache for frequently used parsers to reduce Map lookups
+const parserCache = new Map<string, PropertyParser>();
+
+function getCachedParser(property: string) {
+  if (parserCache.has(property)) {
+    return parserCache.get(property);
+  }
+  const parser = getPropertyParser(property);
+  if (parser) {
+    parserCache.set(property, parser);
+  }
+  return parser;
+}
+
+export function applyDeclarationsToStyle(
+  declarations: Record<string, string>,
+  target: StyleAccumulator,
+  units: UnitParsers,
+  inheritedFontWeight?: number
+): void {
+  // Pre-normalize declarations (lowercase keys and trim values)
+  const normalizedDeclarations: Record<string, string> = {};
+  for (const [property, value] of Object.entries(declarations)) {
+    normalizedDeclarations[property.toLowerCase()] = value.trim();
+  }
+
+  // Separate shorthands and longhands
+  const shorthands: Array<[string, string]> = [];
+  const longhands: Array<[string, string]> = [];
+
+  for (const [property, value] of Object.entries(normalizedDeclarations)) {
+    if (SHORTHAND_PROPERTIES.has(property)) {
+      shorthands.push([property, value]);
+    } else {
+      longhands.push([property, value]);
+    }
+  }
+
+  // Pass 1: Apply shorthands first
+  for (const [property, value] of shorthands) {
+    const parser = getCachedParser(property);
+    if (parser) {
+      parser(value, target, units, inheritedFontWeight);
+    } else if (!property.startsWith('--')) {
+      console.warn(`Unsupported CSS property: ${property}`);
+    }
+  }
+
+  // Pass 2: Apply longhands (they can override shorthands)
+  for (const [property, value] of longhands) {
+    const parser = getCachedParser(property);
+    if (parser) {
+      parser(value, target, units, inheritedFontWeight);
+    } else if (!property.startsWith('--')) {
+      console.warn(`Unsupported CSS property: ${property}`);
+    }
+  }
+}

package/src/css/background-types.ts

@@ -0,0 +1,65 @@
+import type { ImageInfo } from "../image/types.js";
+
+export interface ColorBackgroundLayer {
+  kind: "color";
+  color: string; // ex: #fff, rgba(...)
+  clip?: BackgroundClip;
+}
+
+export interface ImageBackgroundLayer {
+  kind: "image";
+  url: string;
+  repeat?: BackgroundRepeat;
+  position?: BackgroundPosition;
+  size?: BackgroundSize;
+  origin?: BackgroundOrigin;
+  clip?: BackgroundClip;
+  attachment?: "scroll" | "fixed" | "local";
+  originalUrl?: string;
+  resolvedUrl?: string;
+  imageInfo?: ImageInfo;
+}
+
+export interface GradientBackgroundLayer {
+  kind: "gradient";
+  gradient: Gradient;
+  repeat?: BackgroundRepeat;
+  position?: BackgroundPosition;
+  size?: BackgroundSize;
+  origin?: BackgroundOrigin;
+  clip?: BackgroundClip;
+}
+
+export type BackgroundLayer = ColorBackgroundLayer | ImageBackgroundLayer | GradientBackgroundLayer;
+
+export type BackgroundRepeat = "repeat" | "repeat-x" | "repeat-y" | "no-repeat" | "space" | "round";
+export type BackgroundOrigin = "padding-box" | "border-box" | "content-box";
+export type BackgroundClip = "border-box" | "padding-box" | "content-box" | "text";
+
+export type BackgroundPosition = { x: string; y: string }; // "left"/"center"/"right"/<length|%>
+export type BackgroundSize = "auto" | "cover" | "contain" | { width: string; height: string };
+
+export type Gradient = LinearGradient | RadialGradient | ConicGradient;
+
+export interface LinearGradient {
+  type: "linear";
+  angleOrTo?: string; // "to right", "45deg"
+  stops: { color: string; pos?: number }[];
+  renderOffset?: { x: number; y: number };
+  renderScale?: { x: number; y: number };
+}
+
+export interface RadialGradient {
+  type: "radial";
+  shape?: "circle" | "ellipse";
+  sizeHint?: "closest-side" | "farthest-side" | "closest-corner" | "farthest-corner";
+  at?: { x: string; y: string };
+  stops: { color: string; pos?: number }[];
+}
+
+export interface ConicGradient {
+  type: "conic";
+  from?: string; // "0deg", "90deg"
+  at?: { x: string; y: string };
+  stops: { color: string; pos?: number }[];
+}

package/src/css/browser-defaults.ts

@@ -0,0 +1,16 @@
+/**
+ * Browser-like User Agent (UA) defaults for PDF conversion.
+ * SRP: this file now acts as a façade, re-exporting focused UA defaults modules.
+ */
+
+export type { ElementDefaults } from "./ua-defaults/types.js";
+export {
+  TypographyDefaults,
+  BoxModelDefaults,
+  LayoutDefaults,
+  TextLayoutDefaults,
+  createBaseDefaultsObject,
+} from "./ua-defaults/base-defaults.js";
+export { ElementSpecificDefaults } from "./ua-defaults/element-defaults.js";
+export { BrowserDefaults } from "./ua-defaults/browser-defaults.js";
+export * from "./unit-conversion.js";

package/src/css/clip-path-types.ts

@@ -0,0 +1,13 @@
+export type ClipPathReferenceBox = "border-box" | "padding-box" | "content-box";
+
+export type ClipPathLength =
+  | { unit: "px"; value: number }
+  | { unit: "percent"; value: number };
+
+export interface ClipPathPolygon {
+  type: "polygon";
+  points: Array<{ x: ClipPathLength; y: ClipPathLength }>;
+  referenceBox?: ClipPathReferenceBox;
+}
+
+export type ClipPath = ClipPathPolygon;