@adnsistemas/pdf-lib 1.18.0

package/src/types/fontkit.ts

@@ -0,0 +1,640 @@
+/**
+ * Represents a glyph bounding box
+ */
+export interface BoundingBox {
+  minX: number /** The minimum X position in the bounding box */;
+  minY: number /** The minimum Y position in the bounding box */;
+  maxX: number /** The maxmimum X position in the bounding box */;
+  maxY: number /** The maxmimum Y position in the bounding box */;
+  width: number /** The width of the bounding box */;
+  height: number /** The height of the bounding box */;
+}
+
+/**
+ * Path objects are returned by glyphs and represent the actual vector outlines
+ * for each glyph in the font. Paths can be converted to SVG path data strings,
+ * or to functions that can be applied to render the path to a graphics context.
+ */
+export interface Path {
+  /**
+   * This property represents the path’s bounding box, i.e. the smallest
+   * rectangle that contains the entire path shape. This is the exact
+   * bounding box, taking into account control points that may be outside the
+   * visible shape.
+   */
+  bbox: BoundingBox;
+
+  /**
+   * This property represents the path’s control box. It is like the
+   * bounding box, but it includes all points of the path, including control
+   * points of bezier segments. It is much faster to compute than the real
+   * bounding box, but less accurate if there are control points outside of the
+   * visible shape.
+   */
+  cbox: BoundingBox;
+
+  /**
+   * Moves the virtual pen to the given x, y coordinates.
+   */
+  moveTo(x: number, y: number): void;
+
+  /**
+   * Adds a line to the path from the current point to the
+   * given x, y coordinates.
+   */
+  lineTo(x: number, y: number): void;
+
+  /**
+   * Adds a quadratic curve to the path from the current point to the
+   * given x, y coordinates using cpx, cpy as a control point.
+   */
+  quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+
+  /**
+   * Adds a bezier curve to the path from the current point to the
+   * given x, y coordinates using cp1x, cp1y and cp2x, cp2y as control points.
+   */
+  bezierCurveTo(
+    cp1x: number,
+    cp1y: number,
+    cp2x: number,
+    cp2y: number,
+    x: number,
+    y: number,
+  ): void;
+
+  /**
+   * Closes the current sub-path by drawing a straight line back to the
+   * starting point.
+   */
+  closePath(): void;
+
+  /**
+   * Compiles the path to a JavaScript function that can be applied with a
+   * graphics context in order to render the path.
+   */
+  toFunction(): Function; // tslint:disable-line ban-types
+
+  /**
+   * Converts the path to an SVG path data string.
+   */
+  toSVG(): string;
+}
+
+/**
+ * Glyph objects represent a glyph in the font. They have various properties for
+ * accessing metrics and the actual vector path the glyph represents, and
+ * methods for rendering the glyph to a graphics context.
+ *
+ * You do not create glyph objects directly. They are created by various methods
+ * on the Font object. There are several subclasses of the base Glyph class
+ * internally that may be returned depending on the font format, but they all
+ * include the following API.
+ */
+export interface Glyph {
+  // Properties
+  id: number /** The glyph's id in the font */;
+  /**
+   * An array of unicode code points that are represented by this glyph. There
+   * can be multiple code points in the case of ligatures and other glyphs that
+   * represent multiple visual characters.
+   */
+  codePoints: number[];
+  path: Path /** Vector Path object representing the glyph */;
+  /**
+   * The Glyph’s bounding box, i.e. the rectangle that encloses the glyph
+   * outline as tightly as possible.
+   */
+  bbox: BoundingBox;
+  /**
+   * The Glyph’s control box. This is often the same as the bounding box, but is
+   * faster to compute. Because of the way bezier curves are defined, some of
+   * the control points can be outside of the bounding box. Where bbox takes
+   * this into account, cbox does not. Thus, cbox is less accurate, but faster
+   * to compute.
+   */
+  cbox: BoundingBox;
+  advanceWidth: number /** The Glyph's advance width */;
+
+  /**
+   * For COLR glyphs, which are vector based, this returns an array of objects
+   * representing the glyphs and colors for each layer in render order.
+   */
+  layers: any[];
+
+  // Methods
+  /**
+   * Renders the glyph to the given graphics context, at the specified
+   * font size.
+   */
+  render(context: any, size: number): void;
+
+  // Color Glyph Properties/Methods
+  /**
+   * For SBIX glyphs, which are bitmap based, this returns an object containing
+   * some properties about the image, along with the image data itself
+   * (usually PNG).
+   */
+  getImageForSize(size: number): Uint8Array;
+}
+
+/**
+ * Represents positioning information for a glyph in a GlyphRun.
+ */
+export interface GlyphPosition {
+  /**
+   * The amount to move the virtual pen in the X direction after rendering
+   * this glyph.
+   */
+  xAdvance: number;
+
+  /**
+   * The amount to move the virtual pen in the Y direction after rendering
+   * this glyph.
+   */
+  yAdvance: number;
+
+  /**
+   * The offset from the pen position in the X direction at which to render
+   * this glyph.
+   */
+  xOffset: number;
+
+  /**
+   * The offset from the pen position in the Y direction at which to render
+   * this glyph.
+   */
+  yOffset: number;
+}
+
+/**
+ * Represents a run of Glyph and GlyphPosition objects.
+ * Returned by the Font.layout method.
+ */
+export interface GlyphRun {
+  /**
+   * An array of Glyph objects in the run
+   */
+  glyphs: Glyph[];
+
+  /**
+   * An array of GlyphPosition objects for each glyph in the run
+   */
+  positions: GlyphPosition[];
+
+  /**
+   * The script that was requested for shaping. This was either passed in or detected automatically.
+   */
+  script: string;
+
+  /**
+   * The language requested for shaping, as passed in. If `null`, the default language for the
+   * script was used.
+   */
+  language: string | null;
+
+  /**
+   * The direction requested for shaping, as passed in (either ltr or rtl).
+   * If `null`, the default direction of the script is used.
+   */
+  direction: 'ltr' | 'rtl' | null;
+
+  /**
+   * The features requested during shaping. This is a combination of user
+   * specified features and features chosen by the shaper.
+   */
+  features: object;
+
+  /**
+   * The total advance width of the run.
+   */
+  advanceWidth: number;
+
+  /**
+   * The total advance height of the run.
+   */
+  advanceHeight: number;
+
+  /**
+   * The bounding box containing all glyphs in the run.
+   */
+  bbox: BoundingBox;
+}
+
+export interface SubsetStream {
+  on: (
+    eventType: 'data' | 'end',
+    callback: (data: Uint8Array) => any,
+  ) => SubsetStream;
+}
+
+export interface Subset {
+  /**
+   * Includes the given glyph object or glyph ID in the subset.
+   * Returns the glyph's new ID in the subset.
+   */
+  includeGlyph(glyph: number | Glyph): number;
+
+  /**
+   * Returns a stream containing the encoded font file that can be piped to a
+   * destination, such as a file.
+   */
+  encodeStream(): SubsetStream;
+}
+
+/**
+ * A map of OpenType features as described in OpenType's spec:
+ * https://docs.microsoft.com/en-gb/typography/opentype/spec/featurelist.
+ */
+export interface OpenTypeFeatures {
+  aalt?: boolean;
+  abvf?: boolean;
+  abvm?: boolean;
+  abvs?: boolean;
+  afrc?: boolean;
+  akhn?: boolean;
+  blwf?: boolean;
+  blwm?: boolean;
+  blws?: boolean;
+  calt?: boolean;
+  case?: boolean;
+  ccmp?: boolean;
+  cfar?: boolean;
+  cjct?: boolean;
+  clig?: boolean;
+  cpct?: boolean;
+  cpsp?: boolean;
+  cswh?: boolean;
+  curs?: boolean;
+  cv01?: boolean;
+  cv02?: boolean;
+  cv03?: boolean;
+  cv04?: boolean;
+  cv05?: boolean;
+  cv06?: boolean;
+  cv07?: boolean;
+  cv08?: boolean;
+  cv09?: boolean;
+  cv10?: boolean;
+  cv11?: boolean;
+  cv22?: boolean;
+  cv23?: boolean;
+  cv24?: boolean;
+  cv25?: boolean;
+  cv26?: boolean;
+  cv27?: boolean;
+  cv28?: boolean;
+  cv29?: boolean;
+  cv30?: boolean;
+  cv31?: boolean;
+  cv32?: boolean;
+  cv33?: boolean;
+  cv34?: boolean;
+  cv35?: boolean;
+  cv36?: boolean;
+  cv37?: boolean;
+  cv38?: boolean;
+  cv39?: boolean;
+  cv40?: boolean;
+  cv41?: boolean;
+  cv42?: boolean;
+  cv43?: boolean;
+  cv44?: boolean;
+  cv45?: boolean;
+  cv46?: boolean;
+  cv47?: boolean;
+  cv48?: boolean;
+  cv49?: boolean;
+  cv50?: boolean;
+  cv51?: boolean;
+  cv52?: boolean;
+  cv53?: boolean;
+  cv54?: boolean;
+  cv55?: boolean;
+  cv56?: boolean;
+  cv57?: boolean;
+  cv58?: boolean;
+  cv59?: boolean;
+  cv60?: boolean;
+  cv61?: boolean;
+  cv62?: boolean;
+  cv63?: boolean;
+  cv64?: boolean;
+  cv65?: boolean;
+  cv66?: boolean;
+  cv67?: boolean;
+  cv68?: boolean;
+  cv69?: boolean;
+  cv70?: boolean;
+  cv71?: boolean;
+  cv72?: boolean;
+  cv73?: boolean;
+  cv74?: boolean;
+  cv75?: boolean;
+  cv76?: boolean;
+  cv77?: boolean;
+  cv78?: boolean;
+  cv79?: boolean;
+  cv80?: boolean;
+  cv81?: boolean;
+  cv82?: boolean;
+  cv83?: boolean;
+  cv84?: boolean;
+  cv85?: boolean;
+  cv86?: boolean;
+  cv87?: boolean;
+  cv88?: boolean;
+  cv89?: boolean;
+  cv90?: boolean;
+  cv91?: boolean;
+  cv92?: boolean;
+  cv93?: boolean;
+  cv94?: boolean;
+  cv95?: boolean;
+  cv96?: boolean;
+  cv97?: boolean;
+  cv98?: boolean;
+  cv99?: boolean;
+  c2pc?: boolean;
+  c2sc?: boolean;
+  dist?: boolean;
+  dlig?: boolean;
+  dnom?: boolean;
+  dtls?: boolean;
+  expt?: boolean;
+  falt?: boolean;
+  fin2?: boolean;
+  fin3?: boolean;
+  fina?: boolean;
+  flac?: boolean;
+  frac?: boolean;
+  fwid?: boolean;
+  half?: boolean;
+  haln?: boolean;
+  halt?: boolean;
+  hist?: boolean;
+  hkna?: boolean;
+  hlig?: boolean;
+  hngl?: boolean;
+  hojo?: boolean;
+  hwid?: boolean;
+  init?: boolean;
+  isol?: boolean;
+  ital?: boolean;
+  jalt?: boolean;
+  jp78?: boolean;
+  jp83?: boolean;
+  jp90?: boolean;
+  jp04?: boolean;
+  kern?: boolean;
+  lfbd?: boolean;
+  liga?: boolean;
+  ljmo?: boolean;
+  lnum?: boolean;
+  locl?: boolean;
+  ltra?: boolean;
+  ltrm?: boolean;
+  mark?: boolean;
+  med2?: boolean;
+  medi?: boolean;
+  mgrk?: boolean;
+  mkmk?: boolean;
+  mset?: boolean;
+  nalt?: boolean;
+  nlck?: boolean;
+  nukt?: boolean;
+  numr?: boolean;
+  onum?: boolean;
+  opbd?: boolean;
+  ordn?: boolean;
+  ornm?: boolean;
+  palt?: boolean;
+  pcap?: boolean;
+  pkna?: boolean;
+  pnum?: boolean;
+  pref?: boolean;
+  pres?: boolean;
+  pstf?: boolean;
+  psts?: boolean;
+  pwid?: boolean;
+  qwid?: boolean;
+  rand?: boolean;
+  rclt?: boolean;
+  rkrf?: boolean;
+  rlig?: boolean;
+  rphf?: boolean;
+  rtbd?: boolean;
+  rtla?: boolean;
+  rtlm?: boolean;
+  ruby?: boolean;
+  rvrn?: boolean;
+  salt?: boolean;
+  sinf?: boolean;
+  size?: boolean;
+  smcp?: boolean;
+  smpl?: boolean;
+  ss01?: boolean;
+  ss02?: boolean;
+  ss03?: boolean;
+  ss04?: boolean;
+  ss05?: boolean;
+  ss06?: boolean;
+  ss07?: boolean;
+  ss08?: boolean;
+  ss09?: boolean;
+  ss10?: boolean;
+  ss11?: boolean;
+  ss12?: boolean;
+  ss13?: boolean;
+  ss14?: boolean;
+  ss15?: boolean;
+  ss16?: boolean;
+  ss17?: boolean;
+  ss18?: boolean;
+  ss19?: boolean;
+  ss20?: boolean;
+  ssty?: boolean;
+  stch?: boolean;
+  subs?: boolean;
+  sups?: boolean;
+  swsh?: boolean;
+  titl?: boolean;
+  tjmo?: boolean;
+  tnam?: boolean;
+  tnum?: boolean;
+  trad?: boolean;
+  twid?: boolean;
+  unic?: boolean;
+  valt?: boolean;
+  vatu?: boolean;
+  vert?: boolean;
+  vhal?: boolean;
+  vjmo?: boolean;
+  vkna?: boolean;
+  vkrn?: boolean;
+  vpal?: boolean;
+  vrt2?: boolean;
+  vrtr?: boolean;
+  zero?: boolean;
+}
+/**
+ * A map of Apple Advanced Typography (AAT) as decribed by Apple’s TrueType
+ * Reference manual:
+ * https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6AATIntro.html
+ */
+export interface AATFeatures {
+  acnt?: boolean;
+  ankr?: boolean;
+  avar?: boolean;
+  bdat?: boolean;
+  bhed?: boolean;
+  bloc?: boolean;
+  bsln?: boolean;
+  cmap?: boolean;
+  cvar?: boolean;
+  cvt?: boolean;
+  EBSC?: boolean;
+  fdsc?: boolean;
+  feat?: boolean;
+  fmtx?: boolean;
+  fond?: boolean;
+  fpgm?: boolean;
+  fvar?: boolean;
+  gasp?: boolean;
+  gcid?: boolean;
+  glyf?: boolean;
+  gvar?: boolean;
+  hdmx?: boolean;
+  head?: boolean;
+  hhea?: boolean;
+  hmtx?: boolean;
+  just?: boolean;
+  kern?: boolean;
+  kerx?: boolean;
+  lcar?: boolean;
+  loca?: boolean;
+  ltag?: boolean;
+  maxp?: boolean;
+  meta?: boolean;
+  mort?: boolean;
+  morx?: boolean;
+  name?: boolean;
+  opbd?: boolean;
+  'OS/2'?: boolean;
+  post?: boolean;
+  prep?: boolean;
+  prop?: boolean;
+  sbix?: boolean;
+  trak?: boolean;
+  vhea?: boolean;
+  vmtx?: boolean;
+  xref?: boolean;
+  Zapf?: boolean;
+}
+
+/**
+ * The features is an object mapping OpenType features to a boolean
+ * enabling or disabling each. If this is an AAT font,
+ * the OpenType feature tags are mapped to AAT features.
+ */
+export interface TypeFeatures extends OpenTypeFeatures, AATFeatures {
+  [key: string]: boolean | undefined;
+}
+
+/**
+ * There are several different types of font objects that are returned by
+ * fontkit depending on the font format. They all inherit from the TTFFont class
+ * and have the same public API.
+ */
+export interface Font {
+  // Metadata properties
+  postscriptName: string | null;
+  fullName: string | null;
+  familyName: string | null;
+  subfamilyName: string | null;
+  copyright: string | null;
+  version: string | null;
+
+  // Metrics properties
+  unitsPerEm: number /** Size of the font’s internal coordinate grid */;
+  ascent: number /** The font’s ascender */;
+  descent: number /** The font’s descender */;
+  lineGap: number /** Amount of space that should be included between lines */;
+  underlinePosition: number /** Offset from the normal underline position that should be used */;
+  underlineThickness: number /** Weight of the underline that should be used */;
+  italicAngle: number /** If this is an italic font, the angle the cursor should be drawn at to match the font design */;
+  capHeight: number /** Height of capital letters above the baseline. */;
+  xHeight: number /** Height of lower case letters. */;
+  bbox: BoundingBox /** Font’s bounding box, i.e. the box that encloses all glyphs in the font */;
+
+  // Other properties
+  numGlyphs: number /** Number of glyphs in the font */;
+  characterSet: number[] /** Array of all of the unicode code points supported by the font */;
+  availableFeatures: (keyof TypeFeatures)[] /** Array of all OpenType feature tags (or mapped AAT tags) supported by the font */;
+  cff: any;
+  'OS/2': { sFamilyClass: number };
+  head: { macStyle: { italic: boolean } };
+  post: { isFixedPitch: boolean };
+
+  // Character to Glyph Mapping Methods
+
+  /**
+   * Maps a single unicode code point (number) to a Glyph object.
+   * Does not perform any advanced substitutions (there is no context to do so).
+   */
+  glyphForCodePoint(codePoint: number): Glyph;
+
+  /**
+   * Returns whether there is glyph in the font for the given
+   * unicode code point.
+   */
+  hasGlyphForCodePoint(codePoint: number): boolean;
+
+  /**
+   * This method returns an array of Glyph objects for the given string.
+   * This is only a one-to-one mapping from characters to glyphs. For most uses,
+   * you should use Font.layout, which provides a much more advanced mapping
+   * supporting AAT and OpenType shaping.
+   */
+  glyphsForString(str: string): Glyph[];
+
+  // Glyph Metrics and Layout Methods
+
+  /**
+   * Returns the advance width (described above) for a single glyph id.
+   */
+  widthOfGlyph(glyphId: number): number;
+
+  /**
+   * This method returns a GlyphRun object, which includes an array of Glyphs
+   * and GlyphPositions for the given string. Glyph objects are described below.
+   * GlyphPosition objects include 4 properties: xAdvance, yAdvance, xOffset,
+   * and yOffset.
+   *
+   * The features parameter is an array of OpenType feature tags to be applied
+   * in addition to the default set. If this is an AAT font, the OpenType
+   * feature tags are mapped to AAT features.
+   */
+  layout(
+    str: string,
+    features?: TypeFeatures | (keyof TypeFeatures)[],
+  ): GlyphRun;
+
+  // Other Methods
+
+  /**
+   * Returns a glyph object for the given glyph id. You can pass the array of
+   * code points this glyph represents for your use later, and it will be
+   * stored in the glyph object.
+   */
+  getGlyph(glyphId: number, codePoints?: number[]): Glyph;
+
+  /**
+   * Returns a Subset object for this font.
+   */
+  createSubset(): Subset;
+}
+
+export interface Fontkit {
+  create(buffer: Uint8Array, postscriptName?: string): Font;
+}

package/src/types/index.ts

@@ -0,0 +1 @@
+export { TransformationMatrix } from 'src/types/matrix';

package/src/types/matrix.ts

@@ -0,0 +1,29 @@
+/**
+ * A transformation matrix according to section `8.3.3 Common Transformations`
+ * of the PDF specification (page 117).
+ *
+ * To cite from the spec:
+ *
+ *   * Translations shall be specified as `[1 0 0 1 tx ty]`, where `tx` and
+ *     `ty` shall be the distances to translate the origin of the coordinate
+ *     system in the horizontal and vertical dimensions, respectively.
+ *   * Scaling shall be obtained by `[sx 0 0 sy 0 0]`. This scales the
+ *     coordinates so that 1 unit in the horizontal and vertical dimensions of
+ *     the new coordinate system is the same size as `sx` and `sy` units,
+ *     respectively, in the previous coordinate system.
+ *   * Rotations shall be produced by `[cos(q) sin(q) -sin(q) cos(q) 0 0]`,
+ *     which has the effect of rotating the coordinate system axes by an angle
+ *     `q` counter clockwise.
+ *   * Skew shall be specified by `[1 tan(a) tan(b) 1 0 0]`, which skews the
+ *     x-axis by an angle `a` and the y axis by an angle `b`.
+ */
+export type TransformationMatrix = [
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+];
+
+export const identityMatrix: TransformationMatrix = [1, 0, 0, 1, 0, 0];

package/src/utils/Cache.ts

@@ -0,0 +1,26 @@
+class Cache<T> {
+  static readonly populatedBy = <T>(populate: () => T) => new Cache(populate);
+
+  private readonly populate: () => T;
+  private value: T | undefined;
+
+  private constructor(populate: () => T) {
+    this.populate = populate;
+    this.value = undefined;
+  }
+
+  getValue(): T | undefined {
+    return this.value;
+  }
+
+  access(): T {
+    if (!this.value) this.value = this.populate();
+    return this.value;
+  }
+
+  invalidate(): void {
+    this.value = undefined;
+  }
+}
+
+export default Cache;