@chr33s/pdf-standard-fonts 5.0.0

package/scripts/encodings/parse-win1252.ts

@@ -0,0 +1,120 @@
+/**
+ * Array of WinAnsi glyph names.
+ * Allows lookups of character names given a character code.
+ *
+ * From:
+ *   https://github.com/foliojs/pdfkit/blob/83f5f7243172a017adcf6a7faa5547c55982c57b/lib/font/afm.js#L33-L105
+ */
+const WinAnsiCharNames = `
+.notdef       .notdef        .notdef        .notdef
+.notdef       .notdef        .notdef        .notdef
+.notdef       .notdef        .notdef        .notdef
+.notdef       .notdef        .notdef        .notdef
+.notdef       .notdef        .notdef        .notdef
+.notdef       .notdef        .notdef        .notdef
+.notdef       .notdef        .notdef        .notdef
+.notdef       .notdef        .notdef        .notdef
+
+space         exclam         quotedbl       numbersign
+dollar        percent        ampersand      quotesingle
+parenleft     parenright     asterisk       plus
+comma         hyphen         period         slash
+zero          one            two            three
+four          five           six            seven
+eight         nine           colon          semicolon
+less          equal          greater        question
+
+at            A              B              C
+D             E              F              G
+H             I              J              K
+L             M              N              O
+P             Q              R              S
+T             U              V              W
+X             Y              Z              bracketleft
+backslash     bracketright   asciicircum    underscore
+
+grave         a              b              c
+d             e              f              g
+h             i              j              k
+l             m              n              o
+p             q              r              s
+t             u              v              w
+x             y              z              braceleft
+bar           braceright     asciitilde     .notdef
+
+Euro          .notdef        quotesinglbase florin
+quotedblbase  ellipsis       dagger         daggerdbl
+circumflex    perthousand    Scaron         guilsinglleft
+OE            .notdef        Zcaron         .notdef
+.notdef       quoteleft      quoteright     quotedblleft
+quotedblright bullet         endash         emdash
+tilde         trademark      scaron         guilsinglright
+oe            .notdef        zcaron         ydieresis
+
+space         exclamdown     cent           sterling
+currency      yen            brokenbar      section
+dieresis      copyright      ordfeminine    guillemotleft
+logicalnot    hyphen         registered     macron
+degree        plusminus      twosuperior    threesuperior
+acute         mu             paragraph      periodcentered
+cedilla       onesuperior    ordmasculine   guillemotright
+onequarter    onehalf        threequarters  questiondown
+
+Agrave        Aacute         Acircumflex    Atilde
+Adieresis     Aring          AE             Ccedilla
+Egrave        Eacute         Ecircumflex    Edieresis
+Igrave        Iacute         Icircumflex    Idieresis
+Eth           Ntilde         Ograve         Oacute
+Ocircumflex   Otilde         Odieresis      multiply
+Oslash        Ugrave         Uacute         Ucircumflex
+Udieresis     Yacute         Thorn          germandbls
+
+agrave        aacute         acircumflex    atilde
+adieresis     aring          ae             ccedilla
+egrave        eacute         ecircumflex    edieresis
+igrave        iacute         icircumflex    idieresis
+eth           ntilde         ograve         oacute
+ocircumflex   otilde         odieresis      divide
+oslash        ugrave         uacute         ucircumflex
+udieresis     yacute         thorn          ydieresis
+`
+  .trim()
+  .split(/\s+/);
+
+export type EncodingMap = Record<number, [number, string]>;
+
+type EncodingTuple = [number, number, string, string];
+
+const isValidEncodingTuple = (
+  entry: [number, number, string, string | undefined],
+): entry is EncodingTuple => {
+  const [, , , postscriptName] = entry;
+  return typeof postscriptName === "string" && postscriptName !== ".notdef";
+};
+
+export const parseWin1252 = (data: string): EncodingMap => {
+  const rows = data
+    .split("\n")
+    .filter((line) => line[0] !== "#")
+    .filter(Boolean)
+    .map((line) => line.split("\t"))
+    .map(([postscriptCode, unicodeCode, unicodeName]) => {
+      const unicode = Number(unicodeCode);
+      const postscript = Number(postscriptCode);
+      const postscriptName = WinAnsiCharNames[postscript];
+      return [unicode, postscript, unicodeName.substring(1), postscriptName] as [
+        number,
+        number,
+        string,
+        string | undefined,
+      ];
+    })
+    .filter(isValidEncodingTuple);
+
+  const encodings: EncodingMap = {};
+  for (const [unicodeCode, postscriptCode, , postscriptName] of rows) {
+    encodings[unicodeCode] = [postscriptCode, postscriptName];
+  }
+
+  return encodings;
+};

package/scripts/encodings/parse-zapf-dingbats-or-symbol.ts

@@ -0,0 +1,22 @@
+import type { EncodingMap } from "./parse-win1252.ts";
+
+export const parseZapfDingbatsOrSymbol = (data: string): EncodingMap => {
+  const rows = data
+    .split("\n")
+    .filter((line) => line[0] !== "#")
+    .filter(Boolean)
+    .map((line) => line.split("\t"))
+    .map(([unicodeCode, postscriptCode, unicodeName, postscriptName]) => [
+      Number(`0x${unicodeCode}`),
+      Number(`0x${postscriptCode}`),
+      unicodeName.substring(2),
+      postscriptName.substring(2).replace(" (CUS)", ""),
+    ]) as Array<[number, number, string, string]>;
+
+  const encodings: EncodingMap = {};
+  for (const [unicodeCode, postscriptCode, , postscriptName] of rows) {
+    encodings[unicodeCode] = [postscriptCode, postscriptName];
+  }
+
+  return encodings;
+};

package/scripts/encodings/parse.ts

@@ -0,0 +1,72 @@
+import { base64, deflate } from "@chr33s/pdf-common";
+import fs from "node:fs/promises";
+import { basename, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import type { EncodingMap } from "./parse-win1252.ts";
+import { parseWin1252 } from "./parse-win1252.ts";
+import { parseZapfDingbatsOrSymbol } from "./parse-zapf-dingbats-or-symbol.ts";
+
+const textEncoder = new TextEncoder();
+
+const compressJson = async (json: string) => {
+  const jsonBytes = textEncoder.encode(json);
+  const compressed = await deflate(jsonBytes);
+  const arrBuf = compressed.buffer.slice(
+    compressed.byteOffset,
+    compressed.byteOffset + compressed.byteLength,
+  ) as ArrayBuffer;
+  const base64DeflatedJson = JSON.stringify(base64.encode(arrBuf));
+  return base64DeflatedJson;
+};
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const copyFileToSrc = async (src: string) => {
+  const fileName = basename(src);
+  const dest = dirname(dirname(__dirname)) + "/src/" + fileName;
+  await fs.copyFile(src, dest);
+};
+
+const main = async () => {
+  const parent = dirname(dirname(__dirname));
+
+  const fontNames = ["symbol", "zapfdingbats", "win1252"] as const;
+  const allEncodings: Record<(typeof fontNames)[number], EncodingMap> = {
+    symbol: {},
+    zapfdingbats: {},
+    win1252: {},
+  };
+
+  for (const fontName of fontNames) {
+    const file = `${parent}/encoding-metrics/${fontName}.txt`;
+    console.log("Parsing:", file);
+    const data = await fs.readFile(file);
+
+    const parser: (input: string) => EncodingMap =
+      fontName === "win1252" ? parseWin1252 : parseZapfDingbatsOrSymbol;
+    const jsonMetrics = parser(String(data));
+    allEncodings[fontName] = jsonMetrics;
+
+    const json = JSON.stringify(jsonMetrics);
+
+    const jsonFile = `${parent}/encoding-metrics/${fontName}-encoding.json`;
+    await fs.writeFile(jsonFile, json);
+  }
+
+  const allJson = JSON.stringify(allEncodings);
+  const allCompressedJson = await compressJson(allJson);
+
+  const allJsonFile = `${parent}/encoding-metrics/all-encodings.json`;
+  const allCompressedJsonFile = `${parent}/encoding-metrics/all-encodings.compressed.json`;
+
+  await fs.writeFile(allJsonFile, allJson);
+  await fs.writeFile(allCompressedJsonFile, allCompressedJson);
+  await copyFileToSrc(allCompressedJsonFile);
+};
+
+main().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});

package/scripts/fonts/parse-character-metrics.ts

@@ -0,0 +1,73 @@
+import {
+  error,
+  extractLinesFromSection,
+  takeAfterFirstSpace,
+  takeUntilFirstSpace,
+} from "./utils.ts";
+
+export interface ICharMetrics {
+  WX: number;
+  N: string;
+}
+
+/**
+ * From https://www.adobe.com/content/dam/acom/en/devnet/font/pdfs/5004.AFM_Spec.pdf :
+ *
+ * C integer:
+ *   Decimal value of default character code (−1 if not encoded).
+ *
+ * WX number:
+ *   Width of character.
+ *
+ * N name:
+ *   (Optional.) PostScript language character name.
+ *
+ * B llx lly urx ury:
+ *   (Optional.) Character bounding box where llx, lly, urx, and ury are all
+ *   numbers. If a character makes no marks on the page (for example, the space
+ *   character), this fi eld reads B 0 0 0 0 , and these values are not
+ *   considered when computing the FontBBox.
+ *
+ * L successor ligature:
+ *   (Optional.) Ligature sequence where successor and ligature are both names.
+ *   The current character may join with the character named successor to form
+ *   the character named ligature. Note that characters can have more than one
+ *   such entry.
+ *
+ * Fallback link for AFM Spec:
+ *   https://ia800603.us.archive.org/30/items/afm-format/afm-format.pdf
+ */
+
+// prettier-ignore
+const parseCharMetrics = (
+  // E.g. 'C 35 ; WX 600 ; N numbersign ; B 56 -45 544 651 ;'
+  line: string,
+): ICharMetrics => {
+  const SEMICOLON_WITH_SURROUDING_WHITESPACE = /\s*;\s*/;
+  const segments = line
+    .split(SEMICOLON_WITH_SURROUDING_WHITESPACE)
+    .map((segment) => segment.trim())
+    .filter((segment) => segment.length > 0);
+
+  const metrics = new Map<string, string>();
+  for (const metric of segments) {
+    const key = takeUntilFirstSpace(metric);
+    const value = takeAfterFirstSpace(metric);
+    metrics.set(key, value);
+  }
+
+  const rawWx = metrics.get("WX") ?? error("Missing WX metric in character data");
+  const rawName = metrics.get("N") ?? error("Missing N metric in character data");
+
+  return {
+    WX: Number(rawWx),
+    N: rawName,
+  };
+};
+
+export const parseCharMetricsSection = (data: string): ICharMetrics[] => {
+  return extractLinesFromSection(data, {
+    startAt: "StartCharMetrics",
+    endAt: "EndCharMetrics",
+  }).map(parseCharMetrics);
+};

package/scripts/fonts/parse-font-metrics.ts

@@ -0,0 +1,95 @@
+import {
+  error,
+  extractLinesFromSection,
+  takeAfterFirstSpace,
+  takeUntilFirstSpace,
+} from "./utils.ts";
+
+export interface IFontMetrics {
+  Comment: string;
+  FontName: string;
+  FullName: string;
+  FamilyName: string;
+  Weight: string;
+  CharacterSet: string;
+  Version: string;
+  Notice: string;
+  EncodingScheme: string;
+  ItalicAngle: number;
+  UnderlinePosition: number;
+  UnderlineThickness: number;
+  CapHeight: number | void;
+  XHeight: number | void;
+  Ascender: number | void;
+  Descender: number | void;
+  StdHW: number;
+  StdVW: number;
+  IsFixedPitch: boolean;
+  FontBBox: [number, number, number, number];
+}
+
+type IFontMetricKey = keyof IFontMetrics;
+
+type FontMetricEntry = {
+  key: IFontMetricKey;
+  value: IFontMetrics[IFontMetricKey];
+};
+
+const parseString = (raw: string): string => raw;
+const parseNumber = (raw: string): number => Number(raw);
+const parseBoolean = (raw: string): boolean => Boolean(raw);
+const parseFontBBox = (raw: string): [number, number, number, number] =>
+  raw.split(" ").map(Number) as [number, number, number, number];
+
+const metricParsers: {
+  [K in IFontMetricKey]: (raw: string) => IFontMetrics[K];
+} = {
+  Comment: parseString,
+  FontName: parseString,
+  FullName: parseString,
+  FamilyName: parseString,
+  Weight: parseString,
+  CharacterSet: parseString,
+  Version: parseString,
+  Notice: parseString,
+  EncodingScheme: parseString,
+  ItalicAngle: parseNumber,
+  UnderlinePosition: parseNumber,
+  UnderlineThickness: parseNumber,
+  CapHeight: parseNumber,
+  XHeight: parseNumber,
+  Ascender: parseNumber,
+  Descender: parseNumber,
+  StdHW: parseNumber,
+  StdVW: parseNumber,
+  IsFixedPitch: parseBoolean,
+  FontBBox: parseFontBBox,
+};
+
+const isFontMetricKey = (value: string): value is IFontMetricKey => value in metricParsers;
+
+const parseFontMetric = (line: string): FontMetricEntry => {
+  const key = takeUntilFirstSpace(line);
+  const rawValue = takeAfterFirstSpace(line).trim();
+
+  if (!isFontMetricKey(key)) {
+    return error(`Unrecognized font metric key: "${key}"`);
+  }
+
+  const parse = metricParsers[key];
+  return { key, value: parse(rawValue) };
+};
+
+export const parseFontMetricsSection = (data: string): IFontMetrics => {
+  const metrics = extractLinesFromSection(data, {
+    startAt: "StartFontMetrics",
+    endAt: "StartCharMetrics",
+  }).map(parseFontMetric);
+
+  const result: Partial<Record<IFontMetricKey, IFontMetrics[IFontMetricKey]>> = {};
+  for (const metric of metrics) {
+    result[metric.key] = metric.value;
+  }
+
+  return result as IFontMetrics;
+};

package/scripts/fonts/parse-kern-pairs.ts

@@ -0,0 +1,30 @@
+import { extractLinesFromSection } from "./utils.ts";
+
+export type IKernPair = [string, string, number];
+
+/**
+ * From https://www.adobe.com/content/dam/acom/en/devnet/font/pdfs/5004.AFM_Spec.pdf :
+ *
+ * KPX name_1 name_2 number_x:
+ *   Name of the first character in the kerning pair followed by the name of the
+ *   second character followed by the kerning amount in the x direction
+ *   (y is zero). The kerning amount is specified in the units of the character
+ *   coordinate system.
+ *
+ * Fallback link for AFM Spec:
+ *   https://ia800603.us.archive.org/30/items/afm-format/afm-format.pdf
+ */
+const parseKernPair = (
+  // E.g. 'KPX A G -50'
+  line: string,
+): IKernPair => {
+  const [, firstCharName, secondCharName, kernXAmount] = line.split(" ");
+  return [String(firstCharName), String(secondCharName), Number(kernXAmount)];
+};
+
+export const parseKernPairsSection = (data: string): IKernPair[] => {
+  return extractLinesFromSection(data, {
+    startAt: "StartKernPairs",
+    endAt: "EndKernPairs",
+  }).map(parseKernPair);
+};

package/scripts/fonts/parse.ts

@@ -0,0 +1,91 @@
+import { base64, deflate } from "@chr33s/pdf-common";
+import fs from "node:fs/promises";
+import { basename, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { type ICharMetrics, parseCharMetricsSection } from "./parse-character-metrics.ts";
+import { type IFontMetrics, parseFontMetricsSection } from "./parse-font-metrics.ts";
+import { type IKernPair, parseKernPairsSection } from "./parse-kern-pairs.ts";
+
+export interface IMetrics extends IFontMetrics {
+  CharMetrics: ICharMetrics[];
+  KernPairs: IKernPair[];
+}
+
+export const parseFontMetrics = (data: string): IMetrics => ({
+  ...parseFontMetricsSection(data),
+  CharMetrics: parseCharMetricsSection(data),
+  KernPairs: parseKernPairsSection(data),
+});
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const getAfmFilePaths = async () => {
+  const parentDir = dirname(dirname(__dirname));
+  const metricsDir = `${parentDir}/font-metrics`;
+  const files = await fs.readdir(metricsDir);
+  const afmFiles = files.filter((name) => name.includes(".afm"));
+  return afmFiles.map((name) => `${metricsDir}/${name}`);
+};
+
+const textEncoder = new TextEncoder();
+
+const compressJson = async (json: string) => {
+  const jsonBytes = textEncoder.encode(json);
+  const compressed = await deflate(jsonBytes);
+  const arrBuf = compressed.buffer.slice(
+    compressed.byteOffset,
+    compressed.byteOffset + compressed.byteLength,
+  ) as ArrayBuffer;
+  const base64DeflatedJson = JSON.stringify(base64.encode(arrBuf));
+  return base64DeflatedJson;
+};
+
+const fontFileNameMap: Record<string, string> = {
+  "courier.compressed.json": "courier.compressed.json",
+  "courier-bold.compressed.json": "courier-bold.compressed.json",
+  "courier-oblique.compressed.json": "courier-oblique.compressed.json",
+  "courier-bold-oblique.compressed.json": "courier-bold-oblique.compressed.json",
+  "helvetica.compressed.json": "helvetica.compressed.json",
+  "helvetica-bold.compressed.json": "helvetica-bold.compressed.json",
+  "helvetica-oblique.compressed.json": "helvetica-oblique.compressed.json",
+  "helvetica-bold-oblique.compressed.json": "helvetica-bold-oblique.compressed.json",
+  "times-roman.compressed.json": "times-roman.compressed.json",
+  "times-bold.compressed.json": "times-bold.compressed.json",
+  "times-italic.compressed.json": "times-italic.compressed.json",
+  "times-bold-italic.compressed.json": "times-bold-italic.compressed.json",
+  "symbol.compressed.json": "symbol.compressed.json",
+  "zapf-dingbats.compressed.json": "zapf-dingbats.compressed.json",
+};
+
+const copyFileToSrc = async (src: string) => {
+  const fileName = basename(src);
+  const canonicalFileName = fontFileNameMap[fileName] ?? fileName;
+  const dest = `${dirname(dirname(__dirname))}/src/${canonicalFileName}`;
+  await fs.copyFile(src, dest);
+};
+
+const main = async () => {
+  const afmFiles = await getAfmFilePaths();
+
+  for (const afmFile of afmFiles) {
+    console.log("Parsing:", afmFile);
+    const data = await fs.readFile(afmFile);
+
+    const metrics = parseFontMetrics(String(data));
+    const jsonMetrics = JSON.stringify(metrics);
+
+    const jsonFile = afmFile.replace(".afm", ".json");
+    const compressedJsonFile = afmFile.replace(".afm", ".compressed.json");
+
+    await fs.writeFile(jsonFile, jsonMetrics);
+    await fs.writeFile(compressedJsonFile, await compressJson(jsonMetrics));
+    await copyFileToSrc(compressedJsonFile);
+  }
+};
+
+main().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});

package/scripts/fonts/utils.ts

@@ -0,0 +1,43 @@
+export const takeUntilFirstSpace = (str: string): string => str.substring(0, str.indexOf(" "));
+
+export const takeAfterFirstSpace = (str: string): string => str.substring(str.indexOf(" ") + 1);
+
+export const error = (msg: string) => {
+  throw new Error(msg);
+};
+
+type ISectionName =
+  | "StartFontMetrics"
+  | "StartCharMetrics"
+  | "StartKernPairs"
+  | "EndFontMetrics"
+  | "EndCharMetrics"
+  | "EndKernPairs";
+
+export const extractLinesFromSection = (
+  data: string,
+  { startAt, endAt }: { startAt: ISectionName; endAt: ISectionName },
+) => {
+  // E.g. /^StartFontMetrics\s+\d+(\.\d+)?/m
+  const startRegex = new RegExp(`^${startAt}\\s+\\d+(\\.\\d+)?`, "m");
+
+  // E.g. /^StartCharMetrics/m
+  const endRegex = new RegExp(`^${endAt}`, "m");
+
+  const startMatch = data.match(startRegex);
+  if (!startMatch || startMatch.index === undefined) {
+    return [];
+  }
+
+  const endMatch = data.match(endRegex);
+  if (!endMatch || endMatch.index === undefined) {
+    return [];
+  }
+
+  const startIdx = startMatch.index + startMatch[0].length;
+
+  const sectionData = data.slice(startIdx, endMatch.index);
+  const sectionLines = sectionData.trim().split(/\r\n|\r|\n|\t/);
+
+  return sectionLines;
+};

package/src/all-encodings.compressed.json

@@ -0,0 +1 @@
+"eJztWk2T4zhy/S8488AECRKcW3tda7c/tte70/Z+xB6yJJRENyVqKKm7qzfmvzvyJRKkyjOO2dirL4pAQgQfEomHfEn81V1fT8/z5L77q2u8++7Pja/c9cK75P5SuaYRS1O59HU38QmmIKZQufP99JyW63g4w9yLua/cJS27dL7BFsUWK8enS1qufN6Lta3dd39u68pdeEnnKb3gvy2JlbJ1GQ9HNQuAtqncZbpfYWjF0FZuN59ODEsnlg5vHmd9hYBp+8pdJ74eYREobazct7TMMAxiGCo3nzHTIKhCXbnbF/QHwROocrfjkvQf4p3gK/cy3xcYBFtoKvcyftZ/CLbQVu46fkVbXBVC5a7pc4KXgmANXeWSTTAI1NBX7jxmIII0RJngNOtDAjUMMsxpLNZOAHd15aZ0hWc6QdxR5dIPd55gEcSdr9xhSXxLAN0J6K6p3A/3dL2NOtYgjw5UueeFd5/SzRZlkD8PTbGXZRlkZkOo3P28T8t1Ny/ATl4eIJ+fSDYO+Rb2tnLPvKglwBLyP8vIhHk9BCH1Mg9PXeWm+TDueDrP+t9e3El9V7l9OuRlor6HsdeYOY1nDRyKMkmqh8qd7mLwBAixFsN0Gy/TK8wIHopt5fbj53GfNGYFAnVd5V6meRmz1+DLULl30+XIapKJyt/+Id2yRd7SU+X+iXPADiSwu1i5f0yT/Ute2g2Ve7pcx8lWRUJhqCv3pzKYhELvK/eUDV68Faly3x/tP17m2TeVez+bRcD3oXL/ypdLNgl0cdy/8el5n22CXfz273dtA3ms3G9yW2DHWLk/jNoWzP1QuQ+ncbdkzF4wi09/m/8kiKOv3O+Os4aUwItN5X4/HrI/wDvi8O9Z3wTaiaFyHzfeaABPRj7q0GCirq/cr8wAgEPlfnvNBkEYe0GYDvquFpHbV47LmoFAhli5Z3OhhkDdVO5QFg0MQnUtsWarBhKhWvbcBiiohLwXssl/DBp7beWKBQFFjRBMsWH31KFyoy0dKIXqvnKfytqBVqiOlZvWxQOzbKJ7ALEQ1ULUasAEfF25r+od8AoRVW7eLCD2H5Gv3EX/Bl4haiu35CUEr8ROeO5wYlIbsFPIRrUBvOzbW17YDtCpr9x947BOscsr80p2An4YKrczg4KX8yGvbafohcHL4mLr9232qQLr8aTwYg4mNWc26PDObNIliXlEGKNH1JME7PN9mtJNrQ28JJshTdN4uY5XtbfKE75yQjy3lK1wjmyla9rNegxGr57u2sq9LLwzLo6Nuk2o/emuh1Vs1XFCxe9fFv500xMotqBGEib+ksa0XG8L62kQWyXHoa3c7x4eid3bTRFDDW8MXrZFuhzVOGBsYRtelvmLkXkMg06nyR33SzYDt7gf5kLpMeC4IGEg9OznL+fcoQROueN5vum7O9AGyZG042UZ+ZCWdLsv+liHYPcSyjre81TAdYh772nty/g6bADv/dqzQuywGbxv1s6CssNCeQk16ytA+1om3bRyEo6fJcmZsl3DxiOhuY087ceXl9yFVEmSgK/j9ZbO0pt7dNYSVafL7fWao62n+u2BEXuSJfOy4Q8L78eccsWecFhKYKcpnVZzA7MkGvPtsQcJnaQX993xdmQzwyFCUJdl3t932YzTxXv8/XTiErU9Dpk2aOBfsy38ZIT3ODlaWYjrLS3j9dOJzZ+N+lrYhvdy1mczQk4OussyX+ZFxip9ul+ENs8v43m8vWY7okR4ks+HSbdij63ohYFyLpGz0tgjs/Sy/XPPvOQO3XuDjH9LyzVtZtLqO2qsfzEiBGV+8sBhMaAIW9lkt2Na0ktOmmKvG96DUE/jxPm9PdILpLrnw3IvC6YbW3YwXy7L/LXkezHWSktBV3ljx/4Wyk4/3MfPPKWz5lYx1uq9RhPJ7TO6aYeSPm764HIv55ksR1qu92cL1ohj2de09slP6VWHNUD48Bh2pxx+S3qZ0teHPsSiHBDWtx1Sj00503fjspuSSYUY9aQcOuvZ5nkx4gQRfryk5ZLO+3F3N98PcJiX42w/30p0DqBEL3rEVvZ2yT2IqzasPc+aKdc6lGS6CMOSW9e1Dka5Y02uux7ulXR5mr+l8yHl80kJtkZuvDcjznlJg3bT/TnbwCOSTh4TLzpo1CNLWGQ/8imfQl1DilzSgN18eQWKa1rGF+vWbVGL7w/CV8tDLxZbsoXbwvt04uXTprtHWiv+z5s5fbUOnMrRKPVzWm5rn7KgsftxXsZvpRMJr5e9UuDw+Wqd6up+O5VNL/zt4xbrphduaLa6VNdW+uCDhjZ9KyB4oPGbPl156UOwN82DsFpHBU3I2bHpXcfFfmjCQ+86MnaEHCJFaJVxlUJFi5e+07i3TrhIRHnpLIMiD/dyFKCvQGk0tts1ttcueAbqu+j2FQhcIzp87VyfhG9Ekq+dKxJl0OFRea4Dwzei1rfd69BwTqDH7jI4ChBelPwqPcvQqEP40Gw7V+8hvfOh3fbKuD9W7htfXvbj+fDMt+tPF1N+QtrmpAnHLFNHm6wIZyBT12Rbb4TE1LVOldSaoJGvs23NzchTtq2JGXmfbWtKJqpdbUVOsyh2tRU1zaLZ1RYtnWXyXbYNdlow+V5tvjaBzeRjtpEd5Ex+yNLBm1Thvsk6oTY5wX2XRUJtaoL7PvNkbXKC+5hNg4kj7rMyib0pBY5ZEyCi4bhG56QrK3uGdeI9zg7kKJQfQv7YqmcfCBmTqYcHPoZzyv8GI24mqh/oGA7LbxhiyOU2NkOXs0v22dDn6hv72kwxp5OsvhuG2spuIRsoZ3hMNGSTz0U4JorZ1OQKHBP12dTlYhuTjd3nLI+pzZaYy29M9rohV9+YsHRU18hLWvikDmajXIFjfZ2YfC7CsYISU5PrcKzQxdTmQhxr0Isp5FIca8yLqcvFONaQF1Of63GsES+mmAtyrAEvpiFX5NgbVOTfUpNjbzNC+i1FOfaGHttRZBt7Q68VIkFfnmtzTY7LYyFX5Lg81eXEj23KWh6C223K2IQdkJd/Dbkgwo39y5ty4MYcgx2IuGvMMVogEuSNOUYLRIK8McdoPUiANjYbHHAglsamo1UhgdrYfHCUgVYag4odAVZpDSo2BEilNag4rMAprUHVWpFAbQ2qVosEamtQcSyJ+OLW1hCHkch4bg291osEfWvotWIk6FtDj8NGUmduDT0OGCTgwdDjUInYdIYeRwlSnGDowTLIbIKhhyARocvB0EOJQIwHQ69lK0EfDL2WrQR9MPQQHlIM4GDoUbaSDIyDoUfVCiWwztCDbkV3cmfoUbIS0cOdodealYgd7gx+rlkhxA1/LlrJBDqbQC5ayQw6m0GuWckUOpuClq1EBnBnc9DKlUha7mwSWryqQf02i65UeLk3zLkuJfh6w5frUsogNpFcmhKAvYHWwhQOYl/b0/nQwQljaLQMg4JEtDf3jZWsONpL+tZKgxzLeMFq5jyYF1TieVCAeUHr2tARQ3lvNOXIVJsbtLTV6alkyxlLYYqpNoixMe3HVBwRWxPtTGXSMZjGZqpt/XA6oSjOVBv0WPQIU52xk5bPsSHJuInqxiprTMZOpHI06pnjzRhM1jIZQ1GusODtxlFU90UbUxPMGK1Yx2TURVprwfYkIy8C0av0IKMvIrJaFJMRGGnuhU1KRmGkyRe2KRmJkWZf2KhkNEaafg16kNqMNP/CZiWjMtIEDNuVjMxIMzBsWDI6o6ybMCMjNFK9hD1LRmmkOgmblozUSOURdi0ZrekHHch1JiM2/ZoD9c9k1KYfdKDfmYzcSAVQrdmBzUh1D7YuGcGRyh3kbWQUR6pysKHJSI5yhQgzMpojlTXY5mRER6pnsM/JqI5UdyCNpMFepHqDNGcxSKoysNFpsGmqtkAySUZkpIoC25+MyUiVBPY/GZWRCgivkAyn1qTAAGRkRm2pATD15nkcA1pLIKM40hqUkkBvntcalNcZlX9GU8BMxobUDlbRYzLmo1CbGmbqbZqBTAYz9TbN4E3/MvU2zdCY8GUykqTQmt5lKTpkYzCZyxRt7lrfbXSNyuO9yVqmaA7Rmi6SXV+XxwfTsUxGx4TDQast3liROm+VOiYjaeoaK/IwGUtT15oGZjKapi5Y0Ycpmuu6ziQxS/EkG3uTwkzG6ISPGl7T4mhORlXKa1482Jh9bYKXKdrbezKZyxRtTP1WGnRG5jocRRC1TIN5SYtMQWcEh3RNr5yMCNGnxaaHliDSh8UG/kJ86FKKDfSF8NB5iw3shehY3wHyQnDothIbuEuVjioEKQSBjREbsdhAxggNrweRGEHGCI1YbJgJIkM9JjbMBIGhDhMbZgIpNJSXYCaIFaGIHyv3ZTyTl1D/pbck7LPAD/f5lvbPqJv+3NWJLgu4/TzlAuQvv00BPpIZ4UXX0Srdf9stC/+mHu9+4dWLkNXg8fVy1BsO/38b4+++jQGqQf6lFatgtwzQ6uyCAVq9fQJHK9pnIrQGu1IgLTCISLxfo0V2KQEtn6sh/4xWY/cH0GqzwvsXtILdJECrs0sEaPV2fQCtaJcH0BrsqoC0Ym13BNCiLN/+Ay1v9wXQauyyAFqt3RNAK9glAbS6rNL+Ey378P9faEW7uIDWkGXZHx3K8HbHwv1fF2F8VmTPvPtUwvjnr8e0Js2uu3GUbw93sMLPXJtBmUXSvsPCGrsosyDnQyvaBQW0Bvs2rkRemyjbZ2I3QaZFR029Ja170XZjQuyg7dZE2FHbwQTYqO3OxNd/a7s34fVJ29EKbpO2BxNhmHJOqXEPQdtkgmzWtjcxdtF2YzrsB223psH04pDyNS4aaLuzsqDeCdJ8GVcMtB1Nrn3Wdrk38AVtLVLiWoS2yWTbq7a9SbZv2v77rzjplQIkbBIft3HabwrE+PK/KRoXNaeni32W1twFis5OCM1coOeEx6fxrEvcFUW3uy9LOu90Zl3RdK8pD1kE3fMyf0pnm0lXNN3m46emL/mDUlpSvgOhCQwKm+UjDOyqm4WC5mX/kk6jcawmMiijHu7jNKXTXDae5jOocb+9+1UK3evhozkNKt32dSjpruhLufvEdtXlb7s+1pei9+3LjA+Qo34gpr6UvnE6PfTFtQS+y9dB8kU0YTy9qkOxqOMLL3xYWG9gUCwCWQ9TWecyo1iE8i7tx2litRalPJ/fIClyeV72J77u7pP5PxbRXPy/Llss4nk+y1m25KOLYhHQ8zkdeVJ6GYqChjPyA+rCoQhpO+5KMA9FTr8rJKhfJiGn363eG4qcfqfE+pK/Rum3SGjqd+uWGoqmfvcQpUOR1e8W2ydDUdXvntRQFPWvNk72ddHUTwWsr4umfipgfV009dMjWF8XYf20xeXroq3fb8Yu2vr9Zuyird+/HbsI7PePYxeN/aQftH1dBPZviss8FYH9YYVARWB/WCFQEdgf3kDQ6ybC4h82A7f2XevDAy4K9m3r4SImFaX+oRy5nopS/7gBV5T6xw24otQ/vgHni1z/+IDDF8X+x3UYXxT798dZLyB5XwT7IS0nPu+fpzzCKtpXdH4V7ZthV9H+Ft2q3FfX+VW5P0JexbuFsW9W7a4PN0W377Zh3BTlnlawTVHuaQXbFOWe3oBtinxPD7iaouDHzdhFwY+bsYuCH9+OXWT8+DC2VltE26Qcxm3R9ufVZW3R9vMKoS3afl4htEXbz28gtEXgz5uBi8CfH3EVjb9eHPZt0fjzGsRt0fj3FVooGv++QgtF49/fQAtF6N8fUISi9V83wxStfytBrJUXEUSv2wEaLAgE8YcnNYAFRSfNKnf1O4As2e93nA/TRj8EQG+tRj1hRS09vkOPQFmbP61/1mNQxNa3YswXryV214vXVhjI93pWp+gNBhKnlOWKSl0kjk3nfV6CqNxF4tl02lhV+Yesp8u1QuUdkkVHx3pzUMkHpZBVgj/zNb9c00sJCqsErGNqqimxYX2bYTXvlN1pnZtBW6uW7Plw0PM4Ks+gXKLWXHWwK6y4TfG/rrBipz9eYa2tmHJJy+04363UEDVuUT+RRAEzXWejn+wlnkrnOp18qVUIbL3Umhe82VzIcX/58cf/AdKKtXQ="

package/src/courier-bold-oblique.compressed.json

@@ -0,0 +1 @@
+"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"

package/src/courier-bold.compressed.json

@@ -0,0 +1 @@
+"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"

package/src/courier-oblique.compressed.json

@@ -0,0 +1 @@
+"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"

package/src/courier.compressed.json

@@ -0,0 +1 @@
+"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"

package/src/encoding.ts

@@ -0,0 +1,85 @@
+import { decompressJson, padStart } from "./utils.js";
+
+import AllEncodingsCompressed from "./all-encodings.compressed.json" with { type: "json" };
+
+type EncodingCharCode = number;
+type EncodingCharName = string;
+interface UnicodeMappings {
+  [unicodeCodePoint: number]: [EncodingCharCode, EncodingCharName];
+}
+
+let allUnicodeMappings: {
+  symbol: UnicodeMappings;
+  zapfdingbats: UnicodeMappings;
+  win1252: UnicodeMappings;
+} | null = null;
+
+const getAllUnicodeMappings = async () => {
+  if (allUnicodeMappings) return allUnicodeMappings;
+  const decompressedEncodings = await decompressJson(AllEncodingsCompressed);
+  allUnicodeMappings = JSON.parse(decompressedEncodings);
+  return allUnicodeMappings;
+};
+
+type EncodingNames = "Symbol" | "ZapfDingbats" | "WinAnsi";
+
+class Encoding {
+  name: EncodingNames;
+  supportedCodePoints: number[] = [];
+  #unicodeMappings: UnicodeMappings = {};
+
+  private constructor(name: EncodingNames) {
+    this.name = name;
+  }
+
+  static async create(name: EncodingNames, unicodeMappings: UnicodeMappings): Promise<Encoding> {
+    const encoding = new Encoding(name);
+    encoding.supportedCodePoints = Object.keys(unicodeMappings)
+      .map(Number)
+      .sort((a, b) => a - b);
+    encoding.#unicodeMappings = unicodeMappings;
+    return encoding;
+  }
+
+  canEncodeUnicodeCodePoint = (codePoint: number) => codePoint in this.#unicodeMappings;
+
+  encodeUnicodeCodePoint = (codePoint: number) => {
+    const mapped = this.#unicodeMappings[codePoint];
+    if (!mapped) {
+      const str = String.fromCharCode(codePoint);
+      const hexCode = `0x${padStart(codePoint.toString(16), 4, "0")}`;
+      const msg = `${this.name} cannot encode "${str}" (${hexCode})`;
+      throw new Error(msg);
+    }
+    return { code: mapped[0], name: mapped[1] };
+  };
+}
+
+export type EncodingType = Encoding;
+
+let encodingsCache: {
+  Symbol: Encoding;
+  ZapfDingbats: Encoding;
+  WinAnsi: Encoding;
+} | null = null;
+
+export const getEncodings = async () => {
+  if (encodingsCache) return encodingsCache;
+  const mappings = await getAllUnicodeMappings();
+  encodingsCache = {
+    Symbol: await Encoding.create("Symbol", mappings!.symbol),
+    ZapfDingbats: await Encoding.create("ZapfDingbats", mappings!.zapfdingbats),
+    WinAnsi: await Encoding.create("WinAnsi", mappings!.win1252),
+  };
+  return encodingsCache;
+};
+
+/** @deprecated Use getEncodings() instead for async loading */
+export const Encodings = {
+  Symbol: null as unknown as Encoding,
+  ZapfDingbats: null as unknown as Encoding,
+  WinAnsi: null as unknown as Encoding,
+};
+
+// Initialize encodings asynchronously
+void getEncodings().then((e) => Object.assign(Encodings, e));