pagyra-js 0.0.1

package/src/compression/adler32.ts

@@ -0,0 +1,45 @@
+/**
+ * Calculates Adler-32 checksum as required by zlib format
+ * Used in WOFF 1.0 for data integrity verification
+ */
+export class Adler32 {
+  private static readonly MOD_ADLER = 65521;
+
+  /**
+   * Calculate Adler-32 checksum for the given data
+   */
+  static calculate(data: Uint8Array): number {
+    let a = 1;
+    let b = 0;
+
+    for (let i = 0; i < data.length; i++) {
+      a = (a + data[i]) % this.MOD_ADLER;
+      b = (b + a) % this.MOD_ADLER;
+    }
+
+    return (b << 16) | a;
+  }
+
+  /**
+   * Verify Adler-32 checksum
+   */
+  static verify(data: Uint8Array, expectedChecksum: number): boolean {
+    const calculated = this.calculate(data);
+    return calculated === expectedChecksum;
+  }
+
+  /**
+   * Update running Adler-32 checksum with new data
+   */
+  static update(adler: number, data: Uint8Array): number {
+    let a = adler & 0xffff;
+    let b = (adler >>> 16) & 0xffff;
+
+    for (let i = 0; i < data.length; i++) {
+      a = (a + data[i]) % this.MOD_ADLER;
+      b = (b + a) % this.MOD_ADLER;
+    }
+
+    return (b << 16) | a;
+  }
+}

package/src/compression/brotli/brotli.ts

@@ -0,0 +1,463 @@
+import type {
+  BrotliOptions,
+  BrotliResult,
+  CompressionStats,
+  DecompressOptions,
+  WOFF2TableEntry,
+} from './types.js';
+import { BrotliMode } from './types.js';
+import {
+  toUint8Array,
+  concatUint8Arrays,
+  padTo4Bytes,
+} from './utils.js';
+import { WOFF2Transform } from './transform.js';
+
+// Cache Node.js zlib module to avoid repeated imports
+let nodeZlib: typeof import('zlib') | null = null;
+let nodeUtil: typeof import('util') | null = null;
+
+/**
+ * Brotli compression/decompression module for WOFF 2.0
+ */
+export class WOFF2Brotli {
+  private static readonly DEFAULT_QUALITY = 11; // Maximum compression for fonts
+  private static readonly DEFAULT_MODE = BrotliMode.FONT;
+  private static readonly DEFAULT_LGWIN = 22; // 4MB window
+  private static readonly DEFAULT_LGBLOCK = 0; // Auto
+
+  /**
+   * Compress data using Brotli algorithm
+   */
+  static async compress(
+    input: Uint8Array | ArrayBuffer,
+    options: BrotliOptions = {}
+  ): Promise<BrotliResult> {
+    const data = toUint8Array(input);
+    const quality = options.quality ?? this.DEFAULT_QUALITY;
+    const mode = options.mode ?? this.DEFAULT_MODE;
+    const lgwin = options.lgwin ?? this.DEFAULT_LGWIN;
+    const lgblock = options.lgblock ?? this.DEFAULT_LGBLOCK;
+
+    if (quality < 0 || quality > 11) {
+      throw new Error('Brotli quality must be between 0 and 11');
+    }
+
+    const compressed = await this.brotliCompress(data, {
+      quality,
+      mode,
+      lgwin,
+      lgblock,
+    });
+
+    return {
+      data: compressed,
+      compressedSize: compressed.length,
+      uncompressedSize: data.length,
+    };
+  }
+
+  /**
+   * Decompress Brotli data
+   */
+  static async decompress(
+    input: Uint8Array | ArrayBuffer,
+    options: DecompressOptions = {}
+  ): Promise<Uint8Array> {
+    const data = toUint8Array(input);
+    const decompressed = await this.brotliDecompress(data);
+
+    if (options.expectedSize && options.validateSize) {
+      if (decompressed.length !== options.expectedSize) {
+        throw new Error(
+          `Size mismatch: expected ${options.expectedSize}, got ${decompressed.length}`
+        );
+      }
+    }
+
+    return decompressed;
+  }
+
+  /**
+   * Compress with table transformation (WOFF 2.0 specific)
+   */
+  static async compressWithTransform(
+    input: Uint8Array,
+    tableTag: string,
+    entry: WOFF2TableEntry,
+    options: BrotliOptions = {}
+  ): Promise<BrotliResult> {
+    const transformed = WOFF2Transform.transform(tableTag, input, entry);
+    const transformLength = WOFF2Transform.getTransformedLength(tableTag, input);
+    const result = await this.compress(transformed, options);
+
+    return {
+      ...result,
+      transformLength,
+    };
+  }
+
+  /**
+   * Decompress with reverse transformation (WOFF 2.0 specific)
+   */
+  static async decompressWithTransform(
+    input: Uint8Array,
+    tableTag: string,
+    entry: WOFF2TableEntry,
+    options: DecompressOptions = {}
+  ): Promise<Uint8Array> {
+    const decompressed = await this.decompress(input, options);
+    const untransformed = WOFF2Transform.untransform(tableTag, decompressed, entry);
+    return untransformed;
+  }
+
+  /**
+   * Get compression statistics
+   */
+  static getCompressionStats(
+    original: Uint8Array,
+    compressed: Uint8Array,
+    transformed?: Uint8Array
+  ): CompressionStats {
+    return {
+      originalSize: original.length,
+      compressedSize: compressed.length,
+      compressionRatio: compressed.length / original.length,
+      transformedSize: transformed?.length,
+      transformApplied: !!transformed && transformed.length !== original.length,
+    };
+  }
+
+  /**
+   * Platform-specific Brotli compression
+   */
+  private static async brotliCompress(
+    data: Uint8Array,
+    options: BrotliOptions
+  ): Promise<Uint8Array> {
+    if (typeof process !== 'undefined' && process.versions?.node) {
+      return this.nodeBrotliCompress(data, options);
+    }
+    if (typeof CompressionStream !== 'undefined') {
+      return this.browserBrotliCompress(data);
+    }
+    throw new Error('No Brotli implementation available (Platform not supported)');
+  }
+
+  /**
+   * Platform-specific Brotli decompression
+   */
+  private static async brotliDecompress(data: Uint8Array): Promise<Uint8Array> {
+    if (typeof process !== 'undefined' && process.versions?.node) {
+      return this.nodeBrotliDecompress(data);
+    }
+    if (typeof DecompressionStream !== 'undefined') {
+      try {
+        return await this.browserBrotliDecompress(data);
+      } catch {
+        // fall through to JS fallback
+      }
+    }
+    return this.jsBrotliDecompress(data);
+  }
+
+  /**
+   * Node.js Brotli compression
+   */
+  private static async nodeBrotliCompress(
+    data: Uint8Array,
+    options: BrotliOptions
+  ): Promise<Uint8Array> {
+    if (!nodeZlib || !nodeUtil) {
+      nodeZlib = await import('zlib');
+      nodeUtil = await import('util');
+    }
+
+    const brotliCompress = nodeUtil.promisify(nodeZlib.brotliCompress);
+
+    const params: Record<number, number> = {
+      [nodeZlib.constants.BROTLI_PARAM_QUALITY]: options.quality ?? this.DEFAULT_QUALITY,
+      [nodeZlib.constants.BROTLI_PARAM_MODE]: options.mode ?? this.DEFAULT_MODE,
+    };
+
+    if (options.lgwin !== undefined) {
+      params[nodeZlib.constants.BROTLI_PARAM_LGWIN] = options.lgwin;
+    }
+
+    if (options.lgblock !== undefined && options.lgblock > 0) {
+      params[nodeZlib.constants.BROTLI_PARAM_LGBLOCK] = options.lgblock;
+    }
+
+    const compressed = await brotliCompress(data, { params });
+    return new Uint8Array(compressed);
+  }
+
+  /**
+   * Node.js Brotli decompression
+   */
+  private static async nodeBrotliDecompress(data: Uint8Array): Promise<Uint8Array> {
+    if (!nodeZlib || !nodeUtil) {
+      nodeZlib = await import('zlib');
+      nodeUtil = await import('util');
+    }
+    const brotliDecompress = nodeUtil.promisify(nodeZlib.brotliDecompress);
+
+    const decompressed = await brotliDecompress(data);
+    return new Uint8Array(decompressed);
+  }
+
+  /**
+   * Browser Brotli compression using CompressionStream API
+   */
+  private static async browserBrotliCompress(data: Uint8Array): Promise<Uint8Array> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const stream = new CompressionStream('br' as any);
+    const writer = stream.writable.getWriter();
+
+    // Forçamos o cast para BufferSource para evitar conflito com tipos do Node
+    writer.write(data as BufferSource).catch(() => { /* ignore write errors here */ });
+    writer.close();
+
+    const chunks: Uint8Array[] = [];
+    const reader = stream.readable.getReader();
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) chunks.push(value);
+      }
+    } catch (e) {
+      throw new Error('Browser Brotli compression failed: ' + e);
+    }
+
+    return concatUint8Arrays(chunks);
+  }
+
+  /**
+   * Browser Brotli decompression using DecompressionStream API
+   */
+  private static async browserBrotliDecompress(data: Uint8Array): Promise<Uint8Array> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const stream = new DecompressionStream('br' as any);
+    const writer = stream.writable.getWriter();
+
+    writer.write(data as BufferSource).catch(() => { /* ignore */ });
+    writer.close();
+
+    const chunks: Uint8Array[] = [];
+    const reader = stream.readable.getReader();
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) chunks.push(value);
+      }
+    } catch (e) {
+      throw new Error('Browser Brotli decompression failed: ' + e);
+    }
+
+    return concatUint8Arrays(chunks);
+  }
+
+  /**
+   * Pure JS fallback using vendored decoder (CommonJS converted by bundler).
+   * This is slower but keeps compatibility when DecompressionStream('br') is unavailable.
+   */
+  private static async jsBrotliDecompress(data: Uint8Array): Promise<Uint8Array> {
+    const mod = await import("./vendor/decode.js");
+    const decoder = mod.BrotliDecompressBuffer ?? mod.BrotliDecompress;
+    if (typeof decoder !== "function") {
+      throw new Error("No JS Brotli decoder available");
+    }
+    const out = decoder(data);
+    return out instanceof Uint8Array ? out : new Uint8Array(out);
+  }
+
+  /**
+   * Validate Brotli compressed data
+   */
+  static async validateCompressedData(data: Uint8Array): Promise<boolean> {
+    try {
+      const decompressed = await this.decompress(data);
+      return decompressed.length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Compress multiple tables into single stream (WOFF 2.0 spec)
+   */
+  static async compressMultipleTables(
+    tables: Array<{ tag: string; data: Uint8Array; entry: WOFF2TableEntry }>,
+    options: BrotliOptions = {}
+  ): Promise<BrotliResult> {
+    const concatenated = concatUint8Arrays(
+      tables.map(({ data }) => padTo4Bytes(data))
+    );
+
+    return this.compress(concatenated, {
+      ...options,
+      mode: BrotliMode.FONT,
+      quality: options.quality ?? 11,
+    });
+  }
+
+  /**
+   * Decompress single stream into multiple tables (WOFF 2.0 spec)
+   */
+  static async decompressMultipleTables(
+    compressed: Uint8Array,
+    tables: WOFF2TableEntry[],
+    options: DecompressOptions = {}
+  ): Promise<Map<string, Uint8Array>> {
+    const expectedSize = tables.reduce((sum, entry) =>
+      sum + (entry.transformLength ?? entry.origLength), 0);
+
+    const decompressed = await this.decompress(compressed, {
+      ...options,
+      expectedSize,
+      validateSize: false, // Don't validate size strictly due to padding
+    });
+
+    const result = new Map<string, Uint8Array>();
+    let offset = 0;
+
+    // First pass: extract all tables from the compressed stream
+    console.log(`WOFF2-BROTLI: Extracting ${tables.length} tables from ${decompressed.length} bytes`);
+
+    for (const entry of tables) {
+      const lengthInStream = entry.transformLength ?? entry.origLength;
+
+      console.log(`WOFF2-BROTLI: Processing table ${entry.tag} - origLength: ${entry.origLength}, transformLength: ${entry.transformLength}, transformVersion: ${entry.transformVersion}`);
+
+      if (offset + lengthInStream > decompressed.length) {
+        console.warn(`Table ${entry.tag} extends beyond decompressed data, using available data`);
+        const availableData = decompressed.subarray(offset);
+        if (availableData.length > 0) {
+          result.set(entry.tag, availableData);
+        }
+        break;
+      }
+
+      const tableData = decompressed.subarray(offset, offset + lengthInStream);
+      offset += lengthInStream;
+
+      const final = WOFF2Transform.untransform(entry.tag, tableData, entry, result);
+      result.set(entry.tag, final);
+      console.log(`WOFF2-BROTLI: Added table ${entry.tag} (${final.length} bytes)`);
+    }
+
+    console.log(`WOFF2-BROTLI: Extracted tables: ${Array.from(result.keys()).join(', ')}`);
+
+    // Second pass: handle glyf/loca transformation
+    // Check for gloc table OR separate transformed glyf/loca tables
+    // WOFF2 spec allows glyf/loca to be separate but transformed (transformVersion 0)
+    const hasGloc = result.has('gloc');
+    const glyfEntry = tables.find(t => t.tag === 'glyf');
+    const hasTransformedGlyf = result.has('glyf') && glyfEntry?.transformVersion === 0;
+
+    if (hasGloc || hasTransformedGlyf) {
+      console.log('WOFF2: Found transformed glyf/loca data, reconstructing...');
+
+      let glocData: Uint8Array;
+
+      if (hasGloc) {
+        console.log('WOFF2: Using gloc table');
+        glocData = result.get('gloc')!;
+        result.delete('gloc');
+      } else {
+        console.log('WOFF2: Using transformed glyf table');
+        // If glyf is transformed, it contains the streams needed for reconstruction
+        glocData = result.get('glyf')!;
+      }
+
+      console.log(`WOFF2: Transform data size: ${glocData.length} bytes`);
+
+      // We need maxp table to get numGlyphs and head table to get indexToLocFormat
+      const maxpData = result.get('maxp');
+      const headData = result.get('head');
+
+      console.log(`WOFF2: maxp table present: ${!!maxpData}, head table present: ${!!headData}`);
+
+      if (maxpData && headData) {
+        // Read numGlyphs from maxp table (offset 4, UInt16)
+        const numGlyphs = new DataView(maxpData.buffer, maxpData.byteOffset).getUint16(4, false);
+
+        // Read indexToLocFormat from head table (offset 50, Int16)
+        const indexFormat = new DataView(headData.buffer, headData.byteOffset).getInt16(50, false);
+
+        console.log(`WOFF2: Reconstructing glyf/loca with numGlyphs=${numGlyphs}, indexFormat=${indexFormat}`);
+
+        // Reconstruct glyf and loca tables
+        const { glyf, loca } = WOFF2Transform.reconstructGlyfLoca(glocData, numGlyphs, indexFormat);
+
+        console.log(`WOFF2: Reconstructed glyf size: ${glyf.length}, loca size: ${loca.length}`);
+
+        result.set('glyf', glyf);
+        result.set('loca', loca);
+
+        console.log('WOFF2: Successfully reconstructed glyf/loca tables');
+      } else {
+        console.warn('Cannot reconstruct glyf/loca: missing maxp or head table');
+      }
+      console.log(`WOFF2: Available tables: ${Array.from(result.keys()).join(', ')}`);
+    }
+
+    // Third pass: reconstruct hmtx if needed
+    this.reconstructHmtxIfNeeded(result, tables);
+
+    return result;
+  }
+
+  /**
+   * Helper to reconstruct hmtx table if needed
+   */
+  private static reconstructHmtxIfNeeded(
+    result: Map<string, Uint8Array>,
+    tables: WOFF2TableEntry[]
+  ): void {
+    const hmtxEntry = tables.find(t => t.tag === 'hmtx');
+    if (!hmtxEntry || !result.has('hmtx')) return;
+
+    // Check if hmtx is transformed (version 0 or 1 usually indicates transform in WOFF2)
+    // But strictly, we should check if the data size matches the expected untransformed size.
+    // If the data is smaller than expected, it's likely transformed.
+    // Or we can check the flags byte if we assume it's transformed.
+
+    // Better check: if transformVersion is 0, it IS transformed.
+    if (hmtxEntry.transformVersion !== 0) return;
+
+    // If transformLength is missing, it means the table length matches origLength.
+    // For hmtx, transformed data is usually smaller (or larger by 1 byte).
+    // If it matches origLength exactly, it's likely raw data despite the version flag.
+    if (hmtxEntry.transformLength === undefined) return;
+
+    const hmtxData = result.get('hmtx')!;
+    const hheaData = result.get('hhea');
+    const maxpData = result.get('maxp');
+
+    if (!hheaData || !maxpData) {
+      console.warn('WOFF2: Cannot reconstruct hmtx: missing hhea or maxp');
+      return;
+    }
+
+    const numHMetrics = new DataView(hheaData.buffer, hheaData.byteOffset).getUint16(34, false);
+    const numGlyphs = new DataView(maxpData.buffer, maxpData.byteOffset).getUint16(4, false);
+
+    const reconstructed = WOFF2Transform.reconstructHmtx(hmtxData, numHMetrics, numGlyphs);
+    result.set('hmtx', reconstructed);
+  }
+}
+
+// Export convenience functions
+export const compress = WOFF2Brotli.compress.bind(WOFF2Brotli);
+export const decompress = WOFF2Brotli.decompress.bind(WOFF2Brotli);
+export const compressWithTransform = WOFF2Brotli.compressWithTransform.bind(WOFF2Brotli);
+export const decompressWithTransform = WOFF2Brotli.decompressWithTransform.bind(WOFF2Brotli);
+export const getCompressionStats = WOFF2Brotli.getCompressionStats.bind(WOFF2Brotli);
+export const validateCompressedData = WOFF2Brotli.validateCompressedData.bind(WOFF2Brotli);
+export const compressMultipleTables = WOFF2Brotli.compressMultipleTables.bind(WOFF2Brotli);
+export const decompressMultipleTables = WOFF2Brotli.decompressMultipleTables.bind(WOFF2Brotli);

package/src/compression/brotli/index.ts

@@ -0,0 +1,15 @@
+export {
+  WOFF2Brotli,
+  compress,
+  decompress,
+  compressWithTransform,
+  decompressWithTransform,
+  getCompressionStats,
+  validateCompressedData,
+  compressMultipleTables,
+  decompressMultipleTables,
+} from './brotli.js';
+
+export { WOFF2Transform } from './transform.js';
+export * from './types.js';
+export * from './utils.js';

package/src/compression/brotli/transform.ts

@@ -0,0 +1,184 @@
+import type { WOFF2TableEntry } from './types.js';
+import { WOFF2GlyfTransform } from './woff2-glyf-transform.js';
+
+/**
+ * WOFF 2.0 table transformations
+ * Specific transformations for glyf, loca, and hmtx tables
+ */
+export class WOFF2Transform {
+  /**
+   * Check if a table should be transformed
+   */
+  static shouldTransform(tag: string): boolean {
+    return tag === 'glyf' || tag === 'loca' || tag === 'hmtx';
+  }
+
+  /**
+   * Get transformation version for a table
+   */
+  static getTransformVersion(tag: string): number {
+    switch (tag) {
+      case 'glyf':
+      case 'loca':
+        return 0; // Version 0 for glyf/loca transformation
+      case 'hmtx':
+        return 0; // Version 0 for hmtx transformation
+      default:
+        return 255; // No transformation
+    }
+  }
+
+  /**
+   * Apply transformation to table data
+   * Note: This is for encoding WOFF2, not typically used in this library
+   */
+  static transform(tag: string, data: Uint8Array, _entry: WOFF2TableEntry): Uint8Array {
+    const version = this.getTransformVersion(tag);
+
+    if (version === 255) {
+      return data; // No transformation
+    }
+
+    // Encoding transformations not implemented (we only decode WOFF2)
+    console.warn(`Transformation for ${tag} not implemented (encoding not supported)`);
+    return data;
+  }
+
+  /**
+   * Reverse transformation (for decompression)
+   * This is the critical path for WOFF2 decoding
+   */
+  static untransform(
+    tag: string,
+    data: Uint8Array,
+    entry: WOFF2TableEntry,
+    allTables?: Map<string, Uint8Array>
+  ): Uint8Array {
+    const version = entry.transformVersion;
+
+    // No transformation needed
+    if (version === 255 || version === 3) {
+      return data;
+    }
+
+    // Handle glyf/loca transformation
+    if ((tag === 'glyf' || tag === 'loca') && version === 0) {
+      // For glyf/loca, we need information from other tables
+      // The transformation produces a 'gloc' table that contains both glyf and loca data
+      // We'll handle this specially in the decompression logic
+      return data;
+    }
+
+    // Other transformations not implemented
+    return data;
+  }
+
+  /**
+   * Calculate transformed length
+   */
+  static getTransformedLength(tag: string, data: Uint8Array): number | undefined {
+    if (!this.shouldTransform(tag)) {
+      return undefined;
+    }
+
+    // Actual implementation would calculate transformed size
+    return data.length;
+  }
+
+  /**
+   * Reconstruct glyf and loca tables from transformed 'gloc' data
+   */
+  /**
+   * Reconstruct glyf and loca tables from transformed 'gloc' data
+   */
+  static reconstructGlyfLoca(
+    glocData: Uint8Array,
+    numGlyphs: number,
+    indexFormat: number
+  ): { glyf: Uint8Array; loca: Uint8Array } {
+    return WOFF2GlyfTransform.untransformGlyf(glocData, numGlyphs, indexFormat);
+  }
+
+  /**
+   * Reconstruct hmtx table from transformed data
+   */
+  static reconstructHmtx(
+    hmtxData: Uint8Array,
+    numHMetrics: number,
+    numGlyphs: number,
+    glyfTable?: Uint8Array,
+    locaTable?: Uint8Array
+  ): Uint8Array {
+    if (hmtxData.length < 1) {
+      return hmtxData;
+    }
+
+    const flags = hmtxData[0];
+    const hasLsbArray = (flags & 1) !== 0;
+    const hasLeftSideBearingArray = (flags & 2) !== 0;
+
+    let offset = 1;
+    const advanceWidths: number[] = [];
+
+    // Read advance widths
+    for (let i = 0; i < numHMetrics; i++) {
+      if (offset + 2 > hmtxData.length) break;
+      advanceWidths.push((hmtxData[offset] << 8) | hmtxData[offset + 1]);
+      offset += 2;
+    }
+
+    const lsbs: number[] = [];
+    if (hasLsbArray) {
+      for (let i = 0; i < numHMetrics; i++) {
+        if (offset + 2 > hmtxData.length) break;
+        const val = (hmtxData[offset] << 8) | hmtxData[offset + 1];
+        lsbs.push(val > 0x7FFF ? val - 0x10000 : val);
+        offset += 2;
+      }
+    } else {
+      // Reconstruct LSBs from glyf table (xMin)
+      // Since we might have simplified glyf table, this might be inaccurate but safe
+      for (let i = 0; i < numHMetrics; i++) {
+        lsbs.push(0); // Default to 0 if derived
+      }
+    }
+
+    const leftSideBearings: number[] = [];
+    if (hasLeftSideBearingArray) {
+      for (let i = numHMetrics; i < numGlyphs; i++) {
+        if (offset + 2 > hmtxData.length) break;
+        const val = (hmtxData[offset] << 8) | hmtxData[offset + 1];
+        leftSideBearings.push(val > 0x7FFF ? val - 0x10000 : val);
+        offset += 2;
+      }
+    } else {
+      // Reconstruct LSBs from glyf table (xMin)
+      for (let i = numHMetrics; i < numGlyphs; i++) {
+        leftSideBearings.push(0); // Default to 0 if derived
+      }
+    }
+
+    // Reconstruct standard hmtx table
+    // Format:
+    // hMetrics[numHMetrics] { advanceWidth: uint16, lsb: int16 }
+    // leftSideBearing[numGlyphs - numHMetrics]: int16
+
+    const hmtxSize = numHMetrics * 4 + (numGlyphs - numHMetrics) * 2;
+    const hmtx = new Uint8Array(hmtxSize);
+    const view = new DataView(hmtx.buffer);
+    let writeOffset = 0;
+
+    for (let i = 0; i < numHMetrics; i++) {
+      view.setUint16(writeOffset, advanceWidths[i] || 0, false);
+      view.setInt16(writeOffset + 2, lsbs[i] || 0, false);
+      writeOffset += 4;
+    }
+
+    for (let i = 0; i < leftSideBearings.length; i++) {
+      view.setInt16(writeOffset, leftSideBearings[i], false);
+      writeOffset += 2;
+    }
+
+    return hmtx;
+  }
+}