openfont 1.0.0

package/.github/workflows/publish.yml

@@ -0,0 +1,31 @@
+name: Publish to npm
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+      
+      - name: Install dependencies
+        run: npm ci
+      
+      - name: Build
+        run: npm run build
+      
+      - name: Publish to npm
+        run: npm publish --provenance --access public

package/README.md

@@ -0,0 +1,392 @@
+# OpenFont
+
+A lightweight, TypeScript-based library for extracting detailed information from font files in the browser and Node.js.
+
+[![npm version](https://img.shields.io/npm/v/openfont.svg)](https://www.npmjs.com/package/openfont)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- 🔍 Extract comprehensive font metadata (weight, style, family name, etc.)
+- 🌐 Load fonts from URLs or ArrayBuffer
+- ⚡ Async/await API for seamless integration
+- 📦 Works in both browser and Node.js environments
+- 💪 Full TypeScript support with type definitions
+- 🎨 Perfect for font management tools, design systems, and typography applications
+
+## Installation
+
+```bash
+npm install openfont
+```
+
+## Quick Start
+
+### Load from URL
+
+```typescript
+import Font from 'openfont';
+
+const font = new Font('https://example.com/path/to/font.ttf');
+const info = await font.info();
+
+console.log(info);
+// {
+//   familyName: "Roboto",
+//   styleName: "Bold Italic",
+//   weight: "Bold",
+//   isItalic: true,
+//   isBold: true,
+//   fullName: "Roboto Bold Italic",
+//   postScriptName: "Roboto-BoldItalic",
+//   version: "Version 2.137",
+//   ...
+// }
+```
+
+### Load from File Upload
+
+```typescript
+import Font from 'openfont';
+
+async function handleFileUpload(file: File) {
+  const arrayBuffer = await file.arrayBuffer();
+  const font = new Font(arrayBuffer);
+  
+  const weight = await font.getWeight();
+  const isItalic = await font.isItalic();
+  
+  console.log(`Weight: ${weight}, Italic: ${isItalic}`);
+}
+```
+
+## API Reference
+
+### Constructor
+
+#### `new Font(fontSource: string | ArrayBuffer)`
+
+Creates a new Font instance.
+
+- **fontSource**: Either a URL string pointing to a font file, or an ArrayBuffer containing font data
+
+```typescript
+// From URL
+const font1 = new Font('https://fonts.example.com/myfont.ttf');
+
+// From ArrayBuffer
+const buffer = await fetch('/font.ttf').then(r => r.arrayBuffer());
+const font2 = new Font(buffer);
+```
+
+### Methods
+
+#### `info(): Promise<FontInfo>`
+
+Returns comprehensive information about the font.
+
+```typescript
+const info = await font.info();
+```
+
+**Returns:**
+```typescript
+{
+  familyName: string;        // e.g., "Roboto"
+  styleName: string;         // e.g., "Bold Italic"
+  weight: number | string;   // e.g., 700 or "Bold"
+  isItalic: boolean;
+  isBold: boolean;
+  fullName: string;          // e.g., "Roboto Bold Italic"
+  postScriptName: string;    // e.g., "Roboto-BoldItalic"
+  version: string;
+  copyright: string;
+  trademark: string;
+  manufacturer: string;
+  designer: string;
+  description: string;
+  unitsPerEm: number;
+  ascender: number;
+  descender: number;
+}
+```
+
+#### `getWeight(): Promise<number | string>`
+
+Returns the font weight. Returns a number (100-900) or a string name (e.g., "Bold", "Light").
+
+```typescript
+const weight = await font.getWeight(); // 700 or "Bold"
+```
+
+#### `isItalic(): Promise<boolean>`
+
+Checks if the font is italic or oblique.
+
+```typescript
+const italic = await font.isItalic(); // true or false
+```
+
+#### `isBold(): Promise<boolean>`
+
+Checks if the font is bold (weight >= 700).
+
+```typescript
+const bold = await font.isBold(); // true or false
+```
+
+#### `getFamilyName(): Promise<string>`
+
+Returns the font family name.
+
+```typescript
+const family = await font.getFamilyName(); // "Roboto"
+```
+
+#### `getStyleName(): Promise<string>`
+
+Returns the font style name.
+
+```typescript
+const style = await font.getStyleName(); // "Bold Italic"
+```
+
+#### `getFullName(): Promise<string>`
+
+Returns the full font name.
+
+```typescript
+const fullName = await font.getFullName(); // "Roboto Bold Italic"
+```
+
+#### `getPostScriptName(): Promise<string>`
+
+Returns the PostScript name.
+
+```typescript
+const psName = await font.getPostScriptName(); // "Roboto-BoldItalic"
+```
+
+#### `getVersion(): Promise<string>`
+
+Returns the font version string.
+
+```typescript
+const version = await font.getVersion(); // "Version 2.137"
+```
+
+#### `getCopyright(): Promise<string>`
+
+Returns the copyright notice.
+
+```typescript
+const copyright = await font.getCopyright();
+```
+
+#### `getDesigner(): Promise<string>`
+
+Returns the font designer's name.
+
+```typescript
+const designer = await font.getDesigner();
+```
+
+#### `getRawFont(): opentype.Font | null`
+
+Returns the underlying opentype.js Font object for advanced use cases.
+
+```typescript
+const opentypeFont = font.getRawFont();
+```
+
+## React Example
+
+```typescript
+import React, { useState } from 'react';
+import Font from 'openfont';
+
+function FontAnalyzer() {
+  const [fontInfo, setFontInfo] = useState(null);
+  const [loading, setLoading] = useState(false);
+
+  const handleFileUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0];
+    if (!file) return;
+
+    setLoading(true);
+    try {
+      const arrayBuffer = await file.arrayBuffer();
+      const font = new Font(arrayBuffer);
+      const info = await font.info();
+      setFontInfo(info);
+    } catch (error) {
+      console.error('Failed to analyze font:', error);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const analyzeWebFont = async () => {
+    setLoading(true);
+    try {
+      const font = new Font('https://fonts.gstatic.com/s/roboto/v30/KFOmCnqEu92Fr1Mu4mxK.woff2');
+      const info = await font.info();
+      setFontInfo(info);
+    } catch (error) {
+      console.error('Failed to analyze font:', error);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <div>
+      <h1>Font Analyzer</h1>
+      
+      <input
+        type="file"
+        onChange={handleFileUpload}
+        accept=".ttf,.otf,.woff,.woff2"
+        disabled={loading}
+      />
+      
+      <button onClick={analyzeWebFont} disabled={loading}>
+        Analyze Web Font
+      </button>
+
+      {loading && <p>Loading...</p>}
+
+      {fontInfo && (
+        <div>
+          <h2>Font Information</h2>
+          <table>
+            <tbody>
+              <tr>
+                <td><strong>Family:</strong></td>
+                <td>{fontInfo.familyName}</td>
+              </tr>
+              <tr>
+                <td><strong>Style:</strong></td>
+                <td>{fontInfo.styleName}</td>
+              </tr>
+              <tr>
+                <td><strong>Weight:</strong></td>
+                <td>{fontInfo.weight}</td>
+              </tr>
+              <tr>
+                <td><strong>Italic:</strong></td>
+                <td>{fontInfo.isItalic ? 'Yes' : 'No'}</td>
+              </tr>
+              <tr>
+                <td><strong>Bold:</strong></td>
+                <td>{fontInfo.isBold ? 'Yes' : 'No'}</td>
+              </tr>
+              <tr>
+                <td><strong>Designer:</strong></td>
+                <td>{fontInfo.designer}</td>
+              </tr>
+              <tr>
+                <td><strong>Version:</strong></td>
+                <td>{fontInfo.version}</td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+      )}
+    </div>
+  );
+}
+
+export default FontAnalyzer;
+```
+
+## Node.js Example
+
+```typescript
+import Font from 'openfont';
+import fs from 'fs/promises';
+
+async function analyzeFontFile(filePath: string) {
+  const buffer = await fs.readFile(filePath);
+  const font = new Font(buffer.buffer);
+  
+  const info = await font.info();
+  console.log('Font Family:', info.familyName);
+  console.log('Weight:', info.weight);
+  console.log('Is Italic:', info.isItalic);
+  console.log('Designer:', info.designer);
+}
+
+analyzeFontFile('./fonts/MyFont.ttf');
+```
+
+## Supported Font Formats
+
+- TrueType (.ttf)
+- OpenType (.otf)
+- WOFF (.woff)
+- WOFF2 (.woff2)
+
+## Browser Compatibility
+
+OpenFont works in all modern browsers that support ES2020 and the Fetch API:
+
+- Chrome 80+
+- Firefox 75+
+- Safari 14+
+- Edge 80+
+
+## TypeScript Support
+
+OpenFont is written in TypeScript and includes full type definitions out of the box. No need for `@types` packages.
+
+```typescript
+import Font, { FontInfo } from 'openfont';
+
+const font = new Font('path/to/font.ttf');
+const info: FontInfo = await font.info();
+```
+
+## Error Handling
+
+All async methods can throw errors. Wrap them in try-catch blocks:
+
+```typescript
+try {
+  const font = new Font('https://example.com/font.ttf');
+  const info = await font.info();
+} catch (error) {
+  console.error('Failed to load or parse font:', error);
+}
+```
+
+## Use Cases
+
+- **Design Systems**: Automatically catalog and validate fonts in your design system
+- **Font Managers**: Build font browsing and management applications
+- **Typography Tools**: Create tools for font analysis and comparison
+- **Web Font Optimization**: Analyze web fonts to optimize loading strategies
+- **Font Validation**: Verify font files meet specific requirements
+- **Documentation**: Auto-generate font specimen sheets
+
+## How It Works
+
+OpenFont is built on top of [opentype.js](https://github.com/opentypejs/opentype.js), a powerful font parser. It provides a simplified, promise-based API for common font analysis tasks.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT © [Miles Low](https://github.com/mileslow)
+
+## Links
+
+- [GitHub Repository](https://github.com/mileslow/OpenFont)
+- [npm Package](https://www.npmjs.com/package/openfont)
+- [Report Issues](https://github.com/mileslow/OpenFont/issues)
+
+## Acknowledgments
+
+Built with [opentype.js](https://github.com/opentypejs/opentype.js) - a powerful JavaScript parser and writer for TrueType and OpenType fonts.

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import opentype from 'opentype.js';
+export interface FontInfo {
+    familyName: string;
+    styleName: string;
+    weight: number | string;
+    isItalic: boolean;
+    isBold: boolean;
+    fullName: string;
+    postScriptName: string;
+    version: string;
+    copyright: string;
+    trademark: string;
+    manufacturer: string;
+    designer: string;
+    description: string;
+    unitsPerEm: number;
+    ascender: number;
+    descender: number;
+}
+export declare class Font {
+    private font;
+    private loadPromise;
+    constructor(fontSource: string | ArrayBuffer);
+    private loadFromUrl;
+    private loadFromBuffer;
+    private ensureLoaded;
+    private getNameEntry;
+    info(): Promise<FontInfo>;
+    getWeight(): Promise<number | string>;
+    isItalic(): Promise<boolean>;
+    isBold(): Promise<boolean>;
+    getFamilyName(): Promise<string>;
+    getStyleName(): Promise<string>;
+    getFullName(): Promise<string>;
+    getPostScriptName(): Promise<string>;
+    getVersion(): Promise<string>;
+    getCopyright(): Promise<string>;
+    getDesigner(): Promise<string>;
+    getRawFont(): opentype.Font | null;
+}
+export default Font;

package/dist/index.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Font = void 0;
+const opentype_js_1 = __importDefault(require("opentype.js"));
+class Font {
+    constructor(fontSource) {
+        this.font = null;
+        this.loadPromise = null;
+        if (typeof fontSource === 'string') {
+            this.loadPromise = this.loadFromUrl(fontSource);
+        }
+        else {
+            this.loadFromBuffer(fontSource);
+        }
+    }
+    async loadFromUrl(url) {
+        return new Promise((resolve, reject) => {
+            opentype_js_1.default.load(url, (err, font) => {
+                if (err) {
+                    reject(new Error(`Failed to load font: ${err.message}`));
+                }
+                else if (font) {
+                    this.font = font;
+                    resolve();
+                }
+                else {
+                    reject(new Error('Failed to load font: Unknown error'));
+                }
+            });
+        });
+    }
+    loadFromBuffer(buffer) {
+        this.font = opentype_js_1.default.parse(buffer);
+    }
+    async ensureLoaded() {
+        if (this.loadPromise) {
+            await this.loadPromise;
+        }
+        if (!this.font) {
+            throw new Error('Font not loaded');
+        }
+    }
+    getNameEntry(nameId) {
+        if (!this.font)
+            return '';
+        const names = this.font.names;
+        const nameRecord = names[nameId.toString()];
+        return nameRecord?.en || '';
+    }
+    async info() {
+        await this.ensureLoaded();
+        if (!this.font) {
+            throw new Error('Font not loaded');
+        }
+        const weight = await this.getWeight();
+        const isItalic = await this.isItalic();
+        return {
+            familyName: this.getNameEntry(1) || '',
+            styleName: this.getNameEntry(2) || '',
+            weight,
+            isItalic,
+            isBold: await this.isBold(),
+            fullName: this.getNameEntry(4) || '',
+            postScriptName: this.getNameEntry(6) || '',
+            version: this.getNameEntry(5) || '',
+            copyright: this.getNameEntry(0) || '',
+            trademark: this.getNameEntry(7) || '',
+            manufacturer: this.getNameEntry(8) || '',
+            designer: this.getNameEntry(9) || '',
+            description: this.getNameEntry(10) || '',
+            unitsPerEm: this.font.unitsPerEm,
+            ascender: this.font.ascender,
+            descender: this.font.descender
+        };
+    }
+    async getWeight() {
+        await this.ensureLoaded();
+        if (!this.font) {
+            throw new Error('Font not loaded');
+        }
+        const os2Table = this.font.tables.os2;
+        if (os2Table && 'usWeightClass' in os2Table) {
+            const weightValue = os2Table.usWeightClass;
+            const weightNames = {
+                100: 'Thin',
+                200: 'Extra Light',
+                300: 'Light',
+                400: 'Normal',
+                500: 'Medium',
+                600: 'Semi Bold',
+                700: 'Bold',
+                800: 'Extra Bold',
+                900: 'Black'
+            };
+            return weightNames[weightValue] || weightValue;
+        }
+        const styleName = this.getNameEntry(2).toLowerCase();
+        if (styleName.includes('bold'))
+            return 700;
+        if (styleName.includes('light'))
+            return 300;
+        if (styleName.includes('black'))
+            return 900;
+        return 400;
+    }
+    async isItalic() {
+        await this.ensureLoaded();
+        if (!this.font) {
+            throw new Error('Font not loaded');
+        }
+        const post = this.font.tables.post;
+        if (post && 'italicAngle' in post) {
+            const angle = post.italicAngle;
+            if (angle !== 0)
+                return true;
+        }
+        const os2Table = this.font.tables.os2;
+        if (os2Table && 'fsSelection' in os2Table) {
+            const fsSelection = os2Table.fsSelection;
+            if (fsSelection & 0x01)
+                return true;
+        }
+        const styleName = this.getNameEntry(2).toLowerCase();
+        return styleName.includes('italic') || styleName.includes('oblique');
+    }
+    async isBold() {
+        await this.ensureLoaded();
+        const weight = await this.getWeight();
+        const weightValue = typeof weight === 'number' ? weight : 400;
+        return weightValue >= 700;
+    }
+    async getFamilyName() {
+        await this.ensureLoaded();
+        return this.getNameEntry(1);
+    }
+    async getStyleName() {
+        await this.ensureLoaded();
+        return this.getNameEntry(2);
+    }
+    async getFullName() {
+        await this.ensureLoaded();
+        return this.getNameEntry(4);
+    }
+    async getPostScriptName() {
+        await this.ensureLoaded();
+        return this.getNameEntry(6);
+    }
+    async getVersion() {
+        await this.ensureLoaded();
+        return this.getNameEntry(5);
+    }
+    async getCopyright() {
+        await this.ensureLoaded();
+        return this.getNameEntry(0);
+    }
+    async getDesigner() {
+        await this.ensureLoaded();
+        return this.getNameEntry(9);
+    }
+    getRawFont() {
+        return this.font;
+    }
+}
+exports.Font = Font;
+exports.default = Font;

package/example.ts

@@ -0,0 +1,81 @@
+import Font from './src/index';
+
+// Example 1: Load from URL (in browser/React)
+async function analyzeFromUrl() {
+  const font = new Font('https://example.com/path/to/font.ttf');
+  
+  const info = await font.info();
+  console.log('Font Info:', info);
+  // {
+  //   familyName: "Roboto",
+  //   styleName: "Bold Italic",
+  //   weight: "Bold" or 700,
+  //   isItalic: true,
+  //   isBold: true,
+  //   fullName: "Roboto Bold Italic",
+  //   ...
+  // }
+
+  const weight = await font.getWeight();
+  console.log('Weight:', weight); // 700 or "Bold"
+
+  const isItalic = await font.isItalic();
+  console.log('Is Italic:', isItalic); // true
+
+  const isBold = await font.isBold();
+  console.log('Is Bold:', isBold); // true
+}
+
+// Example 2: Load from ArrayBuffer (e.g., from file upload)
+async function analyzeFromFile(file: File) {
+  const arrayBuffer = await file.arrayBuffer();
+  const font = new Font(arrayBuffer);
+  
+  const info = await font.info();
+  console.log('Font Info:', info);
+}
+
+// Example 3: React component usage
+/*
+import React, { useState } from 'react';
+import Font from 'openfont';
+
+function FontAnalyzer() {
+  const [fontInfo, setFontInfo] = useState(null);
+
+  const handleFileUpload = async (e) => {
+    const file = e.target.files[0];
+    if (file) {
+      const arrayBuffer = await file.arrayBuffer();
+      const font = new Font(arrayBuffer);
+      const info = await font.info();
+      setFontInfo(info);
+    }
+  };
+
+  const analyzeRemoteFont = async () => {
+    const font = new Font('https://example.com/font.ttf');
+    const info = await font.info();
+    setFontInfo(info);
+  };
+
+  return (
+    <div>
+      <input type="file" onChange={handleFileUpload} accept=".ttf,.otf,.woff,.woff2" />
+      <button onClick={analyzeRemoteFont}>Analyze Remote Font</button>
+      
+      {fontInfo && (
+        <div>
+          <h3>Font Information</h3>
+          <p>Family: {fontInfo.familyName}</p>
+          <p>Weight: {fontInfo.weight}</p>
+          <p>Italic: {fontInfo.isItalic ? 'Yes' : 'No'}</p>
+          <p>Bold: {fontInfo.isBold ? 'Yes' : 'No'}</p>
+        </div>
+      )}
+    </div>
+  );
+}
+*/
+
+export { analyzeFromUrl, analyzeFromFile };

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "openfont",
+  "version": "1.0.0",
+  "description": "A library for extracting font information from font files",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "font",
+    "opentype",
+    "truetype",
+    "typography",
+    "font-parser"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "opentype.js": "^1.3.4"
+  },
+  "devDependencies": {
+    "@types/opentype.js": "^1.3.8",
+    "typescript": "^5.3.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1,205 @@
+import opentype from 'opentype.js';
+
+export interface FontInfo {
+  familyName: string;
+  styleName: string;
+  weight: number | string;
+  isItalic: boolean;
+  isBold: boolean;
+  fullName: string;
+  postScriptName: string;
+  version: string;
+  copyright: string;
+  trademark: string;
+  manufacturer: string;
+  designer: string;
+  description: string;
+  unitsPerEm: number;
+  ascender: number;
+  descender: number;
+}
+
+export class Font {
+  private font: opentype.Font | null = null;
+  private loadPromise: Promise<void> | null = null;
+
+  constructor(fontSource: string | ArrayBuffer) {
+    if (typeof fontSource === 'string') {
+      this.loadPromise = this.loadFromUrl(fontSource);
+    } else {
+      this.loadFromBuffer(fontSource);
+    }
+  }
+
+  private async loadFromUrl(url: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      opentype.load(url, (err, font) => {
+        if (err) {
+          reject(new Error(`Failed to load font: ${err.message}`));
+        } else if (font) {
+          this.font = font;
+          resolve();
+        } else {
+          reject(new Error('Failed to load font: Unknown error'));
+        }
+      });
+    });
+  }
+
+  private loadFromBuffer(buffer: ArrayBuffer): void {
+    this.font = opentype.parse(buffer);
+  }
+
+  private async ensureLoaded(): Promise<void> {
+    if (this.loadPromise) {
+      await this.loadPromise;
+    }
+    if (!this.font) {
+      throw new Error('Font not loaded');
+    }
+  }
+
+  private getNameEntry(nameId: number): string {
+    if (!this.font) return '';
+    const names = this.font.names;
+    const nameRecord = (names as unknown as Record<string, { en?: string }>)[nameId.toString()];
+    return nameRecord?.en || '';
+  }
+
+  async info(): Promise<FontInfo> {
+    await this.ensureLoaded();
+    
+    if (!this.font) {
+      throw new Error('Font not loaded');
+    }
+
+    const weight = await this.getWeight();
+    const isItalic = await this.isItalic();
+
+    return {
+      familyName: this.getNameEntry(1) || '',
+      styleName: this.getNameEntry(2) || '',
+      weight,
+      isItalic,
+      isBold: await this.isBold(),
+      fullName: this.getNameEntry(4) || '',
+      postScriptName: this.getNameEntry(6) || '',
+      version: this.getNameEntry(5) || '',
+      copyright: this.getNameEntry(0) || '',
+      trademark: this.getNameEntry(7) || '',
+      manufacturer: this.getNameEntry(8) || '',
+      designer: this.getNameEntry(9) || '',
+      description: this.getNameEntry(10) || '',
+      unitsPerEm: this.font.unitsPerEm,
+      ascender: this.font.ascender,
+      descender: this.font.descender
+    };
+  }
+
+  async getWeight(): Promise<number | string> {
+    await this.ensureLoaded();
+    
+    if (!this.font) {
+      throw new Error('Font not loaded');
+    }
+
+    const os2Table = this.font.tables.os2;
+    if (os2Table && 'usWeightClass' in os2Table) {
+      const weightValue = os2Table.usWeightClass as number;
+      
+      const weightNames: Record<number, string> = {
+        100: 'Thin',
+        200: 'Extra Light',
+        300: 'Light',
+        400: 'Normal',
+        500: 'Medium',
+        600: 'Semi Bold',
+        700: 'Bold',
+        800: 'Extra Bold',
+        900: 'Black'
+      };
+      
+      return weightNames[weightValue] || weightValue;
+    }
+
+    const styleName = this.getNameEntry(2).toLowerCase();
+    if (styleName.includes('bold')) return 700;
+    if (styleName.includes('light')) return 300;
+    if (styleName.includes('black')) return 900;
+    
+    return 400;
+  }
+
+  async isItalic(): Promise<boolean> {
+    await this.ensureLoaded();
+    
+    if (!this.font) {
+      throw new Error('Font not loaded');
+    }
+
+    const post = this.font.tables.post;
+    if (post && 'italicAngle' in post) {
+      const angle = post.italicAngle as number;
+      if (angle !== 0) return true;
+    }
+
+    const os2Table = this.font.tables.os2;
+    if (os2Table && 'fsSelection' in os2Table) {
+      const fsSelection = os2Table.fsSelection as number;
+      if (fsSelection & 0x01) return true;
+    }
+
+    const styleName = this.getNameEntry(2).toLowerCase();
+    return styleName.includes('italic') || styleName.includes('oblique');
+  }
+
+  async isBold(): Promise<boolean> {
+    await this.ensureLoaded();
+    
+    const weight = await this.getWeight();
+    const weightValue = typeof weight === 'number' ? weight : 400;
+    
+    return weightValue >= 700;
+  }
+
+  async getFamilyName(): Promise<string> {
+    await this.ensureLoaded();
+    return this.getNameEntry(1);
+  }
+
+  async getStyleName(): Promise<string> {
+    await this.ensureLoaded();
+    return this.getNameEntry(2);
+  }
+
+  async getFullName(): Promise<string> {
+    await this.ensureLoaded();
+    return this.getNameEntry(4);
+  }
+
+  async getPostScriptName(): Promise<string> {
+    await this.ensureLoaded();
+    return this.getNameEntry(6);
+  }
+
+  async getVersion(): Promise<string> {
+    await this.ensureLoaded();
+    return this.getNameEntry(5);
+  }
+
+  async getCopyright(): Promise<string> {
+    await this.ensureLoaded();
+    return this.getNameEntry(0);
+  }
+
+  async getDesigner(): Promise<string> {
+    await this.ensureLoaded();
+    return this.getNameEntry(9);
+  }
+
+  getRawFont(): opentype.Font | null {
+    return this.font;
+  }
+}
+
+export default Font;

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020", "DOM"],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}