resumectl 0.0.0-stage → 0.1.0

package/src/rendering/compile.ts

@@ -0,0 +1,101 @@
+// Compile with XeLaTeX or Tectonic and retain actual paragraph geometry for later checks.
+import { existsSync } from "node:fs";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { layoutToClassOptions, resolveConfig, type LayoutOptions } from "../project/config.ts";
+import { hash, manifestPath, parseMeasurements, type BuildManifest } from "./measurements.ts";
+import { resolveInputs } from "../content/tex.ts";
+
+import { TEMPLATE_DIR, FONT_DIR } from "./assets.ts";
+export { TEMPLATE_DIR, FONT_DIR } from "./assets.ts";
+export interface BuildOptions { outDir?: string; layout?: LayoutOptions }
+export interface BuildResult {
+  pdfPath: string;
+  logPath: string;
+  manifestPath: string;
+  output: string;
+}
+export class BuildError extends Error {}
+export type TexEngine = "xelatex" | "tectonic";
+
+/** XeLaTeX when installed, else Tectonic, which downloads TeX packages on first use. */
+export function texEngine(): TexEngine | null {
+  const forced = process.env.RESUMECTL_ENGINE;
+  if (forced === "xelatex" || forced === "tectonic") return forced;
+  return Bun.which("xelatex") ? "xelatex" : Bun.which("tectonic") ? "tectonic" : null;
+}
+/** Whether Tectonic has built its format before; until then a build downloads about 45 MB. */
+export function tectonicCacheReady(): boolean {
+  const result = Bun.spawnSync(["tectonic", "-X", "show", "user-cache-dir"], { stdout: "pipe", stderr: "pipe", timeout: 10_000 });
+  return result.exitCode === 0 && existsSync(join(dirname(result.stdout.toString().trim()), "formats"));
+}
+
+function texPathLiteral(path: string): string {
+  if (/[{}%#\\\r\n]/.test(path)) throw new BuildError(`path contains characters unsupported by TeX: ${path}`);
+  return `\\detokenize{${path}}`;
+}
+/** The string second argument remains supported for existing library consumers. */
+export async function compile(texPath: string, options: string | BuildOptions = {}): Promise<BuildResult> {
+  texPath = resolve(texPath);
+  const opts = typeof options === "string" ? { outDir: options } : options;
+  if (!/\.tex$/i.test(texPath)) throw new BuildError("source must have a .tex extension");
+  const { config } = await resolveConfig({ texPath, configPath: opts.layout ? null : undefined, overrides: {
+    ...(opts.layout ? { layout: opts.layout } : {}), ...(opts.outDir ? { build: { outDir: opts.outDir } } : {}),
+  } });
+  const tex = await resolveInputs(await Bun.file(texPath).text(), texPath);
+  const job = basename(texPath).replace(/\.tex$/i, "");
+  texPathLiteral(job);
+  const out = resolve(config.build.outDir!);
+  await mkdir(out, { recursive: true });
+  const pdfPath = join(out, `${job}.pdf`);
+  const logPath = join(out, `${job}.log`);
+  const measurementPath = join(out, `${job}.rmlayout`);
+  const metadataPath = manifestPath(pdfPath);
+  // Neither old PDFs nor old measurements may survive a failed compile.
+  await Promise.all([pdfPath, metadataPath, measurementPath].map(p => rm(p, { force: true })));
+  const engine = texEngine();
+  if (!engine) throw new BuildError("no TeX engine found; install Tectonic (brew install tectonic) or TinyTeX-1, then run resumectl doctor");
+  const setup = `\\edef\\ResumeFontDir{${texPathLiteral(FONT_DIR + "/")}}\\def\\ResumeMeasure{1}`
+    + `\\def\\ResumeConfigOptions{${layoutToClassOptions(config.layout)}}`;
+  // Tectonic reads a file rather than TeX code; a same-named wrapper keeps the job name.
+  const wrapperDir = engine === "tectonic" ? await mkdtemp(join(tmpdir(), "resumectl-")) : null;
+  let proc: ReturnType<typeof Bun.spawnSync>;
+  try {
+    let command: string[];
+    if (wrapperDir) {
+      const wrapper = join(wrapperDir, `${job}.tex`);
+      await Bun.write(wrapper, `${setup}\\input{${texPathLiteral(texPath)}}\n`);
+      command = ["tectonic", "--chatter", "minimal", "--keep-logs", "--keep-intermediates", "-o", out,
+        "-Z", `search-path=${TEMPLATE_DIR}`, "-Z", `search-path=${dirname(texPath)}`, wrapper];
+    } else {
+      command = ["xelatex", "-interaction=nonstopmode", "-halt-on-error", "-no-shell-escape",
+        `-output-directory=${out}`, `-jobname=${job}`, `${setup}\\input{${texPathLiteral(basename(texPath))}}`];
+    }
+    proc = Bun.spawnSync(command, {
+      cwd: dirname(texPath),
+      env: { ...process.env, TEXINPUTS: `${TEMPLATE_DIR}//:${process.env.TEXINPUTS ?? ""}` },
+      stdout: "pipe", stderr: "pipe",
+    });
+  } finally {
+    if (wrapperDir) await rm(wrapperDir, { recursive: true, force: true });
+  }
+  const output = (proc.stdout!.toString() + proc.stderr!.toString()).split("\n").slice(-40).join("\n");
+  if (proc.exitCode !== 0 || !await Bun.file(pdfPath).exists()) {
+    await rm(pdfPath, { force: true });
+    throw new BuildError(`${engine} failed${proc.signalCode ? ` (${proc.signalCode})` : ""}\n\n${output}`);
+  }
+  if (!await Bun.file(measurementPath).exists()) throw new BuildError("the resume class did not emit layout measurements; remove any outdated local resume.cls");
+  const log = await Bun.file(logPath).text();
+  const manifest: BuildManifest = {
+    version: 1, sourceHash: hash(tex), pdfHash: hash(await Bun.file(pdfPath).bytes()), layout: config.layout,
+    bullets: parseMeasurements(await Bun.file(measurementPath).text()),
+    overflows: [...log.matchAll(/Overfull \\[hv]box \([^\n]+/g)].map(m => m[0]),
+  };
+  await Bun.write(metadataPath, JSON.stringify(manifest, null, 2) + "\n");
+  return { pdfPath, logPath, manifestPath: metadataPath, output };
+}
+export async function cleanIntermediates(pdfPath: string): Promise<void> {
+  const stem = pdfPath.replace(/\.pdf$/i, "");
+  await Promise.all(["aux", "log", "out", "rmlayout"].map(ext => rm(`${stem}.${ext}`, { force: true })));
+}

package/src/rendering/font-metrics.ts

@@ -0,0 +1,89 @@
+// Minimal sfnt reader: advance widths for a set of characters, straight from a
+// TrueType/OpenType file's cmap + hmtx tables. Used by scripts/gen-metrics.ts.
+
+export interface FontMetrics {
+  /** Font file the table was generated from (basename only). */
+  source: string;
+  /** Advance widths in 1/1000 em, keyed by character. */
+  widths: Record<string, number>;
+}
+
+function tables(view: DataView): Map<string, number> {
+  const count = view.getUint16(4);
+  const out = new Map<string, number>();
+  for (let i = 0; i < count; i++) {
+    const rec = 12 + i * 16;
+    const tag = String.fromCharCode(...[0, 1, 2, 3].map(k => view.getUint8(rec + k)));
+    out.set(tag, view.getUint32(rec + 8));
+  }
+  return out;
+}
+
+/** Unicode code point → glyph id, from a format 4 or format 12 cmap subtable. */
+function readCmap(view: DataView, cmap: number): (cp: number) => number {
+  const n = view.getUint16(cmap + 2);
+  let best: { format: number; offset: number } | null = null;
+  for (let i = 0; i < n; i++) {
+    const rec = cmap + 4 + i * 8;
+    const platform = view.getUint16(rec);
+    const encoding = view.getUint16(rec + 2);
+    const offset = cmap + view.getUint32(rec + 4);
+    const format = view.getUint16(offset);
+    const unicode = platform === 0 || (platform === 3 && (encoding === 1 || encoding === 10));
+    if (unicode && (format === 12 || (format === 4 && best?.format !== 12))) best = { format, offset };
+  }
+  if (!best) throw new Error("no Unicode cmap subtable");
+  const { format, offset } = best;
+
+  if (format === 12) {
+    const groups = view.getUint32(offset + 12);
+    return cp => {
+      for (let g = 0; g < groups; g++) {
+        const rec = offset + 16 + g * 12;
+        const start = view.getUint32(rec);
+        const end = view.getUint32(rec + 4);
+        if (cp >= start && cp <= end) return view.getUint32(rec + 8) + (cp - start);
+      }
+      return 0;
+    };
+  }
+
+  const segX2 = view.getUint16(offset + 6);
+  const ends = offset + 14;
+  const starts = ends + segX2 + 2;
+  const deltas = starts + segX2;
+  const ranges = deltas + segX2;
+  return cp => {
+    for (let s = 0; s < segX2; s += 2) {
+      if (cp > view.getUint16(ends + s)) continue;
+      const start = view.getUint16(starts + s);
+      if (cp < start) return 0;
+      const delta = view.getInt16(deltas + s);
+      const rangeOffset = view.getUint16(ranges + s);
+      if (rangeOffset === 0) return (cp + delta) & 0xffff;
+      const glyph = view.getUint16(ranges + s + rangeOffset + (cp - start) * 2);
+      return glyph === 0 ? 0 : (glyph + delta) & 0xffff;
+    }
+    return 0;
+  };
+}
+
+export async function readFontMetrics(path: string, chars: string): Promise<FontMetrics> {
+  const view = new DataView(await Bun.file(path).arrayBuffer());
+  const t = tables(view);
+  const head = t.get("head"), hhea = t.get("hhea"), hmtx = t.get("hmtx"), cmap = t.get("cmap");
+  if (head === undefined || hhea === undefined || hmtx === undefined || cmap === undefined) {
+    throw new Error(`${path}: missing head/hhea/hmtx/cmap table`);
+  }
+  const unitsPerEm = view.getUint16(head + 18);
+  const numHMetrics = view.getUint16(hhea + 34);
+  const glyphOf = readCmap(view, cmap);
+  const advance = (gid: number) => view.getUint16(hmtx + 4 * Math.min(gid, numHMetrics - 1));
+
+  const widths: Record<string, number> = {};
+  for (const ch of chars) {
+    const gid = glyphOf(ch.codePointAt(0)!);
+    if (gid !== 0) widths[ch] = Math.round((advance(gid) * 1000) / unitsPerEm);
+  }
+  return { source: path.split("/").pop()!, widths };
+}

package/src/rendering/font-width.ts

@@ -0,0 +1,11 @@
+import serifMetrics from "./metrics/serif.json";
+import sansMetrics from "./metrics/sans.json";
+import type { ClassOptions } from "../content/tex.ts";
+
+/** Legacy width estimate retained for API consumers; never used by the gates. */
+export function typographicWidth(visible: string, opts: ClassOptions): number {
+  const table: Record<string, number> = opts.style === "sans" ? sansMetrics.widths : serifMetrics.widths;
+  let units = 0;
+  for (const ch of visible) units += (table[ch] ?? 500) + opts.tracking * 10;
+  return Math.round(units * opts.scale);
+}

package/src/rendering/measurements.ts

@@ -0,0 +1,81 @@
+import { InputError } from "../errors.ts";
+import type { LayoutOptions } from "../project/config.ts";
+
+export interface RenderedBullet {
+  id: number;
+  section: string;
+  lines: number;
+  lineWidthPt: number;
+  lastLineWidthPt: number;
+  lastLineFill: number;
+  unsupported: boolean;
+}
+export interface BuildManifest {
+  version: 1;
+  sourceHash: string;
+  pdfHash: string;
+  layout: LayoutOptions;
+  bullets: RenderedBullet[];
+  overflows: string[];
+}
+export const hash = (data: string | Uint8Array) => new Bun.CryptoHasher("sha256").update(data).digest("hex");
+export const manifestPath = (pdf: string) => pdf.replace(/\.pdf$/i, "") + ".resumectl.json";
+
+/** Read positions in scaled TeX points. No font-width approximation is involved. */
+export function parseMeasurements(raw: string): RenderedBullet[] {
+  type Paragraph = { width?: number; start?: number; end?: number; lines?: number };
+  const bullets = new Map<number, { section: string; unsupported: boolean; paragraphs: Map<number, Paragraph> }>();
+  for (const line of raw.trim().split(/\r?\n/).filter(Boolean)) {
+    const [tag, idText, paraText, value] = line.split("|");
+    const id = Number(idText);
+    if (!Number.isInteger(id) || id < 1) throw new InputError("invalid bullet measurement ID; rebuild the PDF");
+    if (tag === "B") {
+      if (bullets.has(id)) throw new InputError("duplicate bullet measurement ID; rebuild the PDF");
+      bullets.set(id, { section: line.split("|").slice(2).join("|"), unsupported: false, paragraphs: new Map() });
+      continue;
+    }
+    const bullet = bullets.get(id);
+    if (!bullet) throw new InputError("incomplete bullet measurements; rebuild the PDF");
+    if (tag === "U") { bullet.unsupported = true; continue; }
+    const paragraph = Number(paraText);
+    const n = Number(value);
+    if (!["P", "S", "E", "L"].includes(tag) || !Number.isInteger(paragraph) || paragraph < 1 || !Number.isFinite(n)) {
+      throw new InputError("invalid paragraph measurements; rebuild the PDF");
+    }
+    const p = bullet.paragraphs.get(paragraph) ?? {};
+    const key = ({ P: "width", S: "start", E: "end", L: "lines" } as const)[tag as "P" | "S" | "E" | "L"];
+    if (p[key] !== undefined) throw new InputError("duplicate paragraph measurement; unsupported bullet structure");
+    p[key] = n;
+    bullet.paragraphs.set(paragraph, p);
+  }
+  return [...bullets].map(([id, bullet]) => {
+    const paragraphs = [...bullet.paragraphs].sort(([a], [b]) => a - b).map(([, p]) => p);
+    if (!paragraphs.length || paragraphs.some(p => !(p.width! > 0) || !Number.isInteger(p.lines) || p.lines! < 1 || p.start === undefined || p.end === undefined)) {
+      throw new InputError(`bullet ${id} has no complete rendered measurements; use ordinary itemize paragraphs`);
+    }
+    const last = paragraphs.at(-1)!;
+    const width = last.end! - last.start!;
+    if (width < 0) throw new InputError(`bullet ${id} has an unsupported paragraph layout`);
+    return {
+      id, section: bullet.section, lines: paragraphs.reduce((n, p) => n + p.lines!, 0),
+      lineWidthPt: last.width! / 65536, lastLineWidthPt: width / 65536,
+      lastLineFill: width / last.width!, unsupported: bullet.unsupported,
+    };
+  });
+}
+
+export async function readManifest(pdfPath: string): Promise<BuildManifest> {
+  const path = manifestPath(pdfPath);
+  if (!await Bun.file(path).exists()) throw new InputError(`render measurements not found: ${path}; run resumectl build first`);
+  let value: BuildManifest;
+  try { value = await Bun.file(path).json(); }
+  catch { throw new InputError(`invalid build metadata: ${path}; rebuild the PDF`); }
+  if (!value || value.version !== 1 || !value.layout || typeof value.sourceHash !== "string" || typeof value.pdfHash !== "string" || !Array.isArray(value.bullets) || !Array.isArray(value.overflows)
+    || value.overflows.some(v => typeof v !== "string")
+    || value.bullets.some(b => !b || typeof b.section !== "string" || !Number.isInteger(b.id) || b.id < 1 || !Number.isInteger(b.lines) || b.lines < 1
+      || !Number.isFinite(b.lineWidthPt) || b.lineWidthPt <= 0 || !Number.isFinite(b.lastLineWidthPt) || b.lastLineWidthPt < 0
+      || !Number.isFinite(b.lastLineFill) || b.lastLineFill < 0 || typeof b.unsupported !== "boolean")) {
+    throw new InputError(`invalid build metadata: ${path}; rebuild the PDF`);
+  }
+  return value;
+}

package/src/rendering/metrics/sans.json

@@ -0,0 +1,122 @@
+{
+  "source": "Inter-430.ttf",
+  "widths": {
+    "0": 635,
+    "1": 409,
+    "2": 612,
+    "3": 621,
+    "4": 649,
+    "5": 596,
+    "6": 623,
+    "7": 567,
+    "8": 622,
+    "9": 623,
+    " ": 277,
+    "!": 292,
+    "\"": 475,
+    "#": 635,
+    "$": 643,
+    "%": 985,
+    "&": 647,
+    "'": 304,
+    "(": 366,
+    ")": 366,
+    "*": 507,
+    "+": 664,
+    ",": 292,
+    "-": 461,
+    ".": 292,
+    "/": 363,
+    ":": 292,
+    ";": 306,
+    "<": 664,
+    "=": 664,
+    ">": 664,
+    "?": 516,
+    "@": 971,
+    "A": 696,
+    "B": 655,
+    "C": 731,
+    "D": 722,
+    "E": 602,
+    "F": 590,
+    "G": 747,
+    "H": 744,
+    "I": 270,
+    "J": 572,
+    "K": 677,
+    "L": 565,
+    "M": 906,
+    "N": 754,
+    "O": 765,
+    "P": 640,
+    "Q": 766,
+    "R": 645,
+    "S": 643,
+    "T": 648,
+    "U": 743,
+    "V": 696,
+    "W": 991,
+    "X": 688,
+    "Y": 684,
+    "Z": 632,
+    "[": 366,
+    "\\": 363,
+    "]": 366,
+    "^": 473,
+    "_": 458,
+    "`": 327,
+    "a": 563,
+    "b": 614,
+    "c": 573,
+    "d": 614,
+    "e": 584,
+    "f": 373,
+    "g": 615,
+    "h": 594,
+    "i": 245,
+    "j": 245,
+    "k": 552,
+    "l": 245,
+    "m": 879,
+    "n": 594,
+    "o": 601,
+    "p": 614,
+    "q": 614,
+    "r": 379,
+    "s": 531,
+    "t": 331,
+    "u": 594,
+    "v": 566,
+    "w": 821,
+    "x": 549,
+    "y": 566,
+    "z": 554,
+    "{": 431,
+    "|": 336,
+    "}": 431,
+    "~": 664,
+    "–": 500,
+    "—": 1000,
+    "·": 292,
+    "•": 554,
+    "→": 954,
+    "←": 954,
+    "↑": 841,
+    "↓": 841,
+    "↗": 776,
+    "×": 664,
+    "±": 664,
+    "≈": 664,
+    "≤": 664,
+    "≥": 664,
+    "°": 456,
+    "€": 668,
+    "£": 614,
+    "’": 266,
+    "‘": 266,
+    "“": 450,
+    "”": 450,
+    "…": 878
+  }
+}

package/src/rendering/metrics/serif.json

@@ -0,0 +1,121 @@
+{
+  "source": "texgyretermes-regular.otf",
+  "widths": {
+    "0": 500,
+    "1": 500,
+    "2": 500,
+    "3": 500,
+    "4": 500,
+    "5": 500,
+    "6": 500,
+    "7": 500,
+    "8": 500,
+    "9": 500,
+    " ": 250,
+    "!": 333,
+    "\"": 408,
+    "#": 500,
+    "$": 500,
+    "%": 833,
+    "&": 778,
+    "'": 180,
+    "(": 333,
+    ")": 333,
+    "*": 500,
+    "+": 564,
+    ",": 250,
+    "-": 333,
+    ".": 250,
+    "/": 278,
+    ":": 278,
+    ";": 278,
+    "<": 564,
+    "=": 564,
+    ">": 564,
+    "?": 444,
+    "@": 921,
+    "A": 722,
+    "B": 667,
+    "C": 667,
+    "D": 722,
+    "E": 611,
+    "F": 556,
+    "G": 722,
+    "H": 722,
+    "I": 333,
+    "J": 389,
+    "K": 722,
+    "L": 611,
+    "M": 889,
+    "N": 722,
+    "O": 722,
+    "P": 556,
+    "Q": 722,
+    "R": 667,
+    "S": 556,
+    "T": 611,
+    "U": 722,
+    "V": 722,
+    "W": 944,
+    "X": 722,
+    "Y": 722,
+    "Z": 611,
+    "[": 333,
+    "\\": 278,
+    "]": 333,
+    "^": 469,
+    "_": 500,
+    "`": 333,
+    "a": 444,
+    "b": 500,
+    "c": 444,
+    "d": 500,
+    "e": 444,
+    "f": 333,
+    "g": 500,
+    "h": 500,
+    "i": 278,
+    "j": 278,
+    "k": 500,
+    "l": 278,
+    "m": 778,
+    "n": 500,
+    "o": 500,
+    "p": 500,
+    "q": 500,
+    "r": 333,
+    "s": 389,
+    "t": 278,
+    "u": 500,
+    "v": 500,
+    "w": 722,
+    "x": 500,
+    "y": 500,
+    "z": 444,
+    "{": 480,
+    "|": 200,
+    "}": 480,
+    "~": 541,
+    "–": 500,
+    "—": 1000,
+    "·": 250,
+    "•": 350,
+    "→": 1000,
+    "←": 1000,
+    "↑": 653,
+    "↓": 653,
+    "×": 564,
+    "±": 564,
+    "≈": 564,
+    "≤": 564,
+    "≥": 564,
+    "°": 400,
+    "€": 500,
+    "£": 500,
+    "’": 333,
+    "‘": 333,
+    "“": 444,
+    "”": 444,
+    "…": 1000
+  }
+}

package/template/fonts/OFL-Inter.txt

@@ -0,0 +1,93 @@
+Copyright 2020 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.