@cantoo/fontkit 2.0.4

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@cantoo/fontkit",
+  "version": "2.0.4",
+  "description": "An advanced font engine for Node and the browser",
+  "keywords": [
+    "opentype",
+    "font",
+    "typography",
+    "subset",
+    "emoji",
+    "glyph",
+    "layout"
+  ],
+  "scripts": {
+    "clean": "shx rm -rf src/opentype/shapers/data.trie src/opentype/shapers/use.trie src/opentype/shapers/use.json src/opentype/shapers/indic.trie src/opentype/shapers/indic.json dist src/packages/unicode-trie/dist src/packages/unicode-properties/dist",
+    "trie:data": "node src/opentype/shapers/generate-data.js",
+    "trie:use": "node src/opentype/shapers/gen-use.js",
+    "trie:indic": "node src/opentype/shapers/gen-indic.js",
+    "tries": "npm run trie:data && npm run trie:use && npm run trie:indic",
+    "build:packages": "node scripts/build-unicode-packages.js",
+    "build": "npm run build:packages && tsup",
+    "prebuild": "node --input-type=module -e \"import fs from 'node:fs'; if (!fs.existsSync('src/opentype/shapers/data.trie')) { console.error('Missing trie files. Run: npm run tries'); process.exit(1); }\"",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run tries && npm run build",
+    "release": "release-it"
+  },
+  "type": "module",
+  "main": "dist/main.cjs",
+  "node-module": "dist/module.mjs",
+  "browser": "dist/browser.cjs",
+  "module": "dist/browser-module.mjs",
+  "source": "src/index.js",
+  "exports": {
+    ".": {
+      "node": {
+        "import": "./dist/module.mjs",
+        "require": "./dist/main.cjs"
+      },
+      "import": "./dist/browser-module.mjs",
+      "require": "./dist/browser.cjs"
+    },
+    "./unicode-trie": {
+      "import": "./src/packages/unicode-trie/dist/index.mjs",
+      "require": "./src/packages/unicode-trie/dist/index.cjs"
+    },
+    "./unicode-trie/builder.js": {
+      "import": "./src/packages/unicode-trie/dist/builder.mjs",
+      "require": "./src/packages/unicode-trie/dist/builder.cjs"
+    },
+    "./unicode-properties": {
+      "import": "./src/packages/unicode-properties/dist/index.mjs",
+      "require": "./src/packages/unicode-properties/dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "author": "Devon Govett <devongovett@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/cantoo-scribe/fontkit.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "brotli": "^1.3.2",
+    "clone": "^2.1.2",
+    "dfa": "^1.2.0",
+    "fast-deep-equal": "^3.1.3",
+    "fflate": "^0.8.3",
+    "restructure": "^3.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^8.0.1",
+    "@babel/eslint-parser": "^8.0.1",
+    "@babel/plugin-proposal-decorators": "^8.0.2",
+    "@eslint/js": "^10.0.1",
+    "@vitest/coverage-v8": "^5.0.0",
+    "codepoints": "^1.3.0",
+    "esbuild": "^0.28.2",
+    "eslint": "^10.10.0",
+    "globals": "^17.12.0",
+    "release-it": "^21.0.2",
+    "shx": "^0.4.0",
+    "tsup": "^8.5.1",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.0"
+  },
+  "overrides": {
+    "esbuild": "^0.28.2"
+  }
+}

package/src/CmapProcessor.js

@@ -0,0 +1,285 @@
+import { binarySearch } from './utils';
+import { getEncoding, getEncodingMapping } from './encodings';
+import { cache } from './decorators';
+import { range } from './utils';
+
+export default class CmapProcessor {
+  constructor(cmapTable) {
+    // Attempt to find a Unicode cmap first
+    this.encoding = null;
+    this.cmap = this.findSubtable(cmapTable, [
+      // 32-bit subtables
+      [3, 10],
+      [0, 6],
+      [0, 4],
+
+      // 16-bit subtables
+      [3, 1],
+      [0, 3],
+      [0, 2],
+      [0, 1],
+      [0, 0]
+    ]);
+
+    // If not unicode cmap was found, take the first table with a supported encoding.
+    if (!this.cmap) {
+      for (let cmap of cmapTable.tables) {
+        let encoding = getEncoding(cmap.platformID, cmap.encodingID, cmap.table.language - 1);
+        let mapping = getEncodingMapping(encoding);
+        if (mapping) {
+          this.cmap = cmap.table;
+          this.encoding = mapping;
+        }
+      }
+    }
+
+    if (!this.cmap) {
+      throw new Error("Could not find a supported cmap table");
+    }
+
+    this.uvs = this.findSubtable(cmapTable, [[0, 5]]);
+    if (this.uvs && this.uvs.version !== 14) {
+      this.uvs = null;
+    }
+  }
+
+  findSubtable(cmapTable, pairs) {
+    for (let [platformID, encodingID] of pairs) {
+      for (let cmap of cmapTable.tables) {
+        if (cmap.platformID === platformID && cmap.encodingID === encodingID) {
+          return cmap.table;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  lookup(codepoint, variationSelector) {
+    // If there is no Unicode cmap in this font, we need to re-encode
+    // the codepoint in the encoding that the cmap supports.
+    if (this.encoding) {
+      codepoint = this.encoding.get(codepoint) || codepoint;
+
+      // Otherwise, try to get a Unicode variation selector for this codepoint if one is provided.
+    } else if (variationSelector) {
+      let gid = this.getVariationSelector(codepoint, variationSelector);
+      if (gid) {
+        return gid;
+      }
+    }
+
+    let cmap = this.cmap;
+    switch (cmap.version) {
+      case 0:
+        return cmap.codeMap.get(codepoint) || 0;
+
+      case 4: {
+        let min = 0;
+        let max = cmap.segCount - 1;
+        while (min <= max) {
+          let mid = (min + max) >> 1;
+
+          if (codepoint < cmap.startCode.get(mid)) {
+            max = mid - 1;
+          } else if (codepoint > cmap.endCode.get(mid)) {
+            min = mid + 1;
+          } else {
+            let rangeOffset = cmap.idRangeOffset.get(mid);
+            let gid;
+
+            if (rangeOffset === 0) {
+              gid = codepoint + cmap.idDelta.get(mid);
+            } else {
+              let index = rangeOffset / 2 + (codepoint - cmap.startCode.get(mid)) - (cmap.segCount - mid);
+              gid = cmap.glyphIndexArray.get(index) || 0;
+              if (gid !== 0) {
+                gid += cmap.idDelta.get(mid);
+              }
+            }
+
+            return gid & 0xffff;
+          }
+        }
+
+        return 0;
+      }
+
+      case 8:
+        throw new Error('TODO: cmap format 8');
+
+      case 6:
+      case 10:
+        return cmap.glyphIndices.get(codepoint - cmap.firstCode) || 0;
+
+      case 12:
+      case 13: {
+        let min = 0;
+        let max = cmap.nGroups - 1;
+        while (min <= max) {
+          let mid = (min + max) >> 1;
+          let group = cmap.groups.get(mid);
+
+          if (codepoint < group.startCharCode) {
+            max = mid - 1;
+          } else if (codepoint > group.endCharCode) {
+            min = mid + 1;
+          } else {
+            if (cmap.version === 12) {
+              return group.glyphID + (codepoint - group.startCharCode);
+            } else {
+              return group.glyphID;
+            }
+          }
+        }
+
+        return 0;
+      }
+
+      case 14:
+        throw new Error('TODO: cmap format 14');
+
+      default:
+        throw new Error(`Unknown cmap format ${cmap.version}`);
+    }
+  }
+
+  getVariationSelector(codepoint, variationSelector) {
+    if (!this.uvs) {
+      return 0;
+    }
+
+    let selectors = this.uvs.varSelectors.toArray();
+    let i = binarySearch(selectors, x => variationSelector - x.varSelector);
+    if (i === -1) {
+      return 0;
+    }
+
+    let {defaultUVS, nonDefaultUVS} = selectors[i];
+
+    // Default UVS: fall back to the base character's normal cmap glyph.
+    if (defaultUVS && binarySearch(defaultUVS, x =>
+      codepoint < x.startUnicodeValue ? -1 : codepoint > x.startUnicodeValue + x.additionalCount ? 1 : 0
+    ) !== -1) return 0;
+
+    if (!nonDefaultUVS) return 0;
+
+    let ni = binarySearch(nonDefaultUVS, x => codepoint - x.unicodeValue);
+    return ni !== -1 ? nonDefaultUVS[ni].glyphID : 0;
+  }
+
+  @cache
+  getCharacterSet() {
+    let cmap = this.cmap;
+    switch (cmap.version) {
+      case 0:
+        return range(0, cmap.codeMap.length);
+
+      case 4: {
+        let res = [];
+        let endCodes = cmap.endCode.toArray();
+        for (let i = 0; i < endCodes.length; i++) {
+          let tail = endCodes[i] + 1;
+          let start = cmap.startCode.get(i);
+          res.push(...range(start, tail));
+        }
+
+        return res;
+      }
+
+      case 8:
+        throw new Error('TODO: cmap format 8');
+
+      case 6:
+      case 10:
+        return range(cmap.firstCode, cmap.firstCode + cmap.glyphIndices.length);
+
+      case 12:
+      case 13: {
+        let res = [];
+        for (let group of cmap.groups.toArray()) {
+          res.push(...range(group.startCharCode, group.endCharCode + 1));
+        }
+
+        return res;
+      }
+
+      case 14:
+        throw new Error('TODO: cmap format 14');
+
+      default:
+        throw new Error(`Unknown cmap format ${cmap.version}`);
+    }
+  }
+
+  @cache
+  codePointsForGlyph(gid) {
+    let cmap = this.cmap;
+    switch (cmap.version) {
+      case 0: {
+        let res = [];
+        for (let i = 0; i < 256; i++) {
+          if (cmap.codeMap.get(i) === gid) {
+            res.push(i);
+          }
+        }
+
+        return res;
+      }
+
+      case 4: {
+        let res = [];
+        for (let i = 0; i < cmap.segCount; i++) {
+          let end = cmap.endCode.get(i);
+          let start = cmap.startCode.get(i);
+          let rangeOffset = cmap.idRangeOffset.get(i);
+          let delta = cmap.idDelta.get(i);
+
+          for (var c = start; c <= end; c++) {
+            let g;
+            if (rangeOffset === 0) {
+              g = c + delta;
+            } else {
+              let index = rangeOffset / 2 + (c - start) - (cmap.segCount - i);
+              g = cmap.glyphIndexArray.get(index) || 0;
+              if (g !== 0) {
+                g += delta;
+              }
+            }
+
+            if ((g & 0xffff) === gid) {
+              res.push(c);
+            }
+          }
+        }
+
+        return res;
+      }
+
+      case 12: {
+        let res = [];
+        for (let group of cmap.groups.toArray()) {
+          if (gid >= group.glyphID && gid <= group.glyphID + (group.endCharCode - group.startCharCode)) {
+            res.push(group.startCharCode + (gid - group.glyphID));
+          }
+        }
+
+        return res;
+      }
+
+      case 13: {
+        let res = [];
+        for (let group of cmap.groups.toArray()) {
+          if (gid === group.glyphID) {
+            res.push(...range(group.startCharCode, group.endCharCode + 1));
+          }
+        }
+
+        return res;
+      }
+
+      default:
+        throw new Error(`Unknown cmap format ${cmap.version}`);
+    }
+  }
+}

package/src/DFont.js

@@ -0,0 +1,113 @@
+import * as r from 'restructure';
+import TTFFont from './TTFFont';
+
+let DFontName = new r.String(r.uint8);
+
+let Ref = new r.Struct({
+  id: r.uint16,
+  nameOffset: r.int16,
+  attr: r.uint8,
+  dataOffset: r.uint24,
+  handle: r.uint32
+});
+
+let Type = new r.Struct({
+  name: new r.String(4),
+  maxTypeIndex: r.uint16,
+  refList: new r.Pointer(r.uint16, new r.Array(Ref, t => t.maxTypeIndex + 1), { type: 'parent' })
+});
+
+let TypeList = new r.Struct({
+  length: r.uint16,
+  types: new r.Array(Type, t => t.length + 1)
+});
+
+let DFontMap = new r.Struct({
+  reserved: new r.Reserved(r.uint8, 24),
+  typeList: new r.Pointer(r.uint16, TypeList),
+  nameListOffset: new r.Pointer(r.uint16, 'void')
+});
+
+let DFontHeader = new r.Struct({
+  dataOffset: r.uint32,
+  map: new r.Pointer(r.uint32, DFontMap),
+  dataLength: r.uint32,
+  mapLength: r.uint32
+});
+
+export default class DFont {
+  type = 'DFont';
+
+  static probe(buffer) {
+    let stream = new r.DecodeStream(buffer);
+
+    try {
+      var header = DFontHeader.decode(stream);
+    } catch (e) {
+      return false;
+    }
+
+    for (let type of header.map.typeList.types) {
+      if (type.name === 'sfnt') {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  constructor(stream) {
+    this.stream = stream;
+    this.header = DFontHeader.decode(this.stream);
+
+    for (let type of this.header.map.typeList.types) {
+      for (let ref of type.refList) {
+        if (ref.nameOffset >= 0) {
+          this.stream.pos = ref.nameOffset + this.header.map.nameListOffset;
+          ref.name = DFontName.decode(this.stream);
+        } else {
+          ref.name = null;
+        }
+      }
+
+      if (type.name === 'sfnt') {
+        this.sfnt = type;
+      }
+    }
+  }
+
+  getFont(name) {
+    if (!this.sfnt) {
+      return null;
+    }
+
+    for (let ref of this.sfnt.refList) {
+      let pos = this.header.dataOffset + ref.dataOffset + 4;
+      let stream = new r.DecodeStream(this.stream.buffer.slice(pos));
+      let font = new TTFFont(stream);
+      if (
+        font.postscriptName === name ||
+        (
+          font.postscriptName instanceof Uint8Array && 
+          name instanceof Uint8Array && 
+          font.postscriptName.every((v, i) => name[i] === v)
+        )
+      ) {
+        return font;
+      }
+    }
+
+    return null;
+  }
+
+  get fonts() {
+    let fonts = [];
+    for (let ref of this.sfnt.refList) {
+      let pos = this.header.dataOffset + ref.dataOffset + 4;
+      let stream = new r.DecodeStream(this.stream.buffer.slice(pos));
+      fonts.push(new TTFFont(stream));
+    }
+
+    return fonts;
+  }
+}