PDFKit

https://pdfkit.org
Admin
PDFKit is a JavaScript PDF generation library for Node and the browser that enables developers to...
Tokens:52,227
Snippets:332
Trust Score:9.2
Update:6 days ago
Show doc for...
Tokens:
Raw
### Install PDFKit with npm

Source: https://pdfkit.org/docs/getting_started.html

Install PDFKit using the npm package manager. Run this command after installing npm.

```bash
npm install pdfkit

```

--------------------------------

### Example with link and underline options in text

Source: https://pdfkit.org/docs/annotations.html

This example shows how to add a link and underline to text using the 'link' and 'underline' options in the text method. It is a simpler alternative to manually calculating rectangles.

```javascript
doc.fontSize(20)
   .fillColor('red')
   .text('Another link!', 20, 0, {
     link: 'http://apple.com/',
     underline: true
   }
);

```

--------------------------------

### Install PDFKit with npm and yarn

Source: https://pdfkit.org/index.html

Install PDFKit using either npm or yarn package managers. The commands are provided as alternatives; choose the one matching your package manager.

```bash
# with npm
npm install pdfkit

# with yarn
yarn add pdfkit

```

--------------------------------

### Example using multiple annotation types

Source: https://pdfkit.org/docs/annotations.html

This example demonstrates adding a link, underline, highlight, strike, notes, and a goTo annotation to a PDF document. It shows how to measure text with widthOfString and currentLineHeight, and how to use options like color and Name for notes.

```javascript
// Add the link text
doc.fontSize(25)
   .fillColor('blue')
   .text('This is a link!', 20, 0);

// Measure the text
const width = doc.widthOfString('This is a link!');
const height = doc.currentLineHeight();

// Add the underline and link annotations
doc.underline(20, 0, width, height, {color: 'blue'})
   .link(20, 0, width, height, 'http://google.com/');

// Create the highlighted text
doc.moveDown()
   .fillColor('black')
   .highlight(20, doc.y, doc.widthOfString('This text is highlighted!'), height)
   .text('This text is highlighted!');

// Create text with a spot color
doc.addSpotColor('PANTONE185C', 0, 100, 78, 9)
doc.moveDown()
   .fillColor('PANTONE185C')
   .text('This text uses spot color!');

// Create the crossed out text
doc.moveDown()
   .strike(20, doc.y, doc.widthOfString('STRIKE!'), height)
   .text('STRIKE!');

// Create note
doc.note(10, 30, 30, 30, "Text of note");

// Create note with custom options
doc.note(10, 80, 30, 30, "Text of custom note", {Name: 'Key', color: 'red'});

// Adding go to as annotation
doc.goTo(20, doc.y, 10, 20, 'LINK', {});

```

--------------------------------

### PDFKit lineCap and lineJoin example

Source: https://pdfkit.org/docs/vector.html

This example demonstrates the lineCap and lineJoin properties in PDFKit. It sets a large line width to make the effects visible, then shows the 'butt', 'round', and 'square' line caps, and the 'miter', 'round', and 'bevel' line joins. Use this to understand how each setting affects the appearance of stroked paths.

```javascript
// these examples are easier to see with a large line width
doc.lineWidth(25);

// line cap settings
doc.lineCap('butt')
   .moveTo(50, 20)
   .lineTo(100, 20)
   .stroke();

doc.lineCap('round')
   .moveTo(150, 20)
   .lineTo(200, 20)
   .stroke();

// square line cap shown with a circle instead of a line so you can see it
doc.lineCap('square')
   .moveTo(250, 20)
   .circle(275, 30, 15)
   .stroke();

// line join settings
doc.lineJoin('miter')
   .rect(50, 100, 50, 50)
   .stroke();

doc.lineJoin('round')
   .rect(150, 100, 50, 50)
   .stroke();

doc.lineJoin('bevel')
   .rect(250, 100, 50, 50)
   .stroke();

```

--------------------------------

### Equivalent manual structure creation for text()

Source: https://pdfkit.org/docs/accessibility.html

Shows the equivalent manual structure creation for the automatic text() example. It creates a P structure element for each paragraph and adds them to the section.

```javascript
const section = doc.struct('Sect');
doc.addStructure(section);
section.add(doc.struct('P', () => { doc.text("Foo. "); });
section.add(doc.struct('P', () => { doc.text("Bar. "); });
```

--------------------------------

### Fill paths with non-zero and even-odd winding rules

Source: https://pdfkit.org/docs/vector.html

Demonstrates using the 'non-zero' and 'even-odd' winding rules with the fill method. Includes initial setup with fillColor, translate, and scale transformations.

```javascript
// Initial setup
doc.fillColor('red')
   .translate(-100, -50)
   .scale(0.8);

// Draw the path with the non-zero winding rule
doc.path('M 250,75 L 323,301 131,161 369,161 177,301 z')
   .fill('non-zero');

// Draw the path with the even-odd winding rule
doc.translate(280, 0)
   .path('M 250,75 L 323,301 131,161 369,161 177,301 z')
   .fill('even-odd');

```

--------------------------------

### Create structure tree with options

Source: https://pdfkit.org/docs/accessibility.html

Example of creating a structure tree with options such as title, expanded, actual, alt, and bbox. The bbox option is required for Figure elements in PDF/UA.

```javascript
const titlePage = doc.struct('Sect', {
    title: 'Title Page'
}, [
    doc.struct('H', [
        doc.struct('Span', {
            expanded: 'Portable Document Format for Universal Accessibility',
            actual: 'PDF/UA'
        }, [
            pdfUAStructureContent
        ]),
        doc.struct('Span', {
            actual: 'in a Nutshell'
        }, [
            inANutshellStructureContent
        ]),
    ]),
    doc.struct('Figure', {
        alt: 'photo of a concrete path with tactile paving',
        bbox: [100, 200, 500, 600]
    }, [
        photoStructureContent
    ])
]);
```

--------------------------------

### Example: Adding images with scaling and alignment options

Source: https://pdfkit.org/docs/images.html

Demonstrates using `doc.image` with various options: proportional scaling by width, fitting within dimensions, stretching, scaling by factor, and fitting with centering. Each image is followed by a text label and some include rectangles for visualization.

```javascript
// Scale proprotionally to the specified width
doc.image('images/test.jpeg', 0, 15, {width: 300})
   .text('Proportional to width', 0, 0);

// Fit the image within the dimensions
doc.image('images/test.jpeg', 320, 15, {fit: [100, 100]})
   .rect(320, 15, 100, 100)
   .stroke()
   .text('Fit', 320, 0);

// Stretch the image
doc.image('images/test.jpeg', 320, 145, {width: 200, height: 100})
   .text('Stretch', 320, 130);

// Scale the image
doc.image('images/test.jpeg', 320, 280, {scale: 0.25})
   .text('Scale', 320, 265);

// Fit the image in the dimensions, and center it both horizontally and vertically
doc.image('images/test.jpeg', 430, 15, {fit: [100, 100], align: 'center', valign: 'center'})
   .rect(430, 15, 100, 100).stroke()
   .text('Centered', 430, 0);
```

--------------------------------

### Use toBlob to get a Blob for displaying or downloading PDF

Source: https://pdfkit.org/index.html

Import PDFDocument, registerStdFonts, and toBlob from 'pdfkit/output'. Call toBlob(doc) before adding content and ending the document. After doc.end(), await the output to get a Blob, create an object URL, and set iframe.src. Optionally revoke the URL when no longer needed.

```javascript
import { PDFDocument, registerStdFonts } from 'pdfkit';
import Helvetica from 'pdfkit/standard-fonts/Helvetica';
import HelveticaBold from 'pdfkit/standard-fonts/HelveticaBold';
import { toBlob } from 'pdfkit/output';

registerStdFonts(Helvetica, HelveticaBold);
const doc = new PDFDocument();
const output = toBlob(doc);

// Add your content to the document here, as usual.

doc.end();
const blob = await output;
const url = URL.createObjectURL(blob);
iframe.src = url;

// Revoke the URL when the iframe no longer needs the PDF.
// URL.revokeObjectURL(url);

```

--------------------------------

### Table positioning with text before and after

Source: https://pdfkit.org/docs/table.html

Demonstrates that PDFKit tracks the table's position, so subsequent text or tables are placed below the table row. The example chains .text('before'), .table(), and .text('after').

```javascript
doc
    .text('before')
    .table({
        data: [
            ['Column 1', 'Column 2', 'Column 3'],
            ['One value goes here', 'Another one here', 'OK?']
        ]
    })
    .text('after')
```

--------------------------------

### Creating Named Destinations with addNamedDestination

Source: https://pdfkit.org/docs/destinations.html

Shows how to insert anchors for the current page using addNamedDestination with various destination types and parameters. Includes examples for FitH, XYZ, and using the destination option in text.

```javascript
// Insert anchor for current page
doc.addNamedDestination('LINK');

// Insert anchor for current page with only horizontal magnified to fit where vertical top is 100
doc.addNamedDestination('LINK', 'FitH', 100);

// Insert anchor to display a portion of the current page, 1/2 inch in from the top and left and zoomed 50%
doc.addNamedDestination('LINK', 'XYZ', 36, 36, 50);

// Insert anchor for this text
doc.text('End of paragraph', { destination: 'ENDP' });
```

--------------------------------

### Create structure automatically with list()

Source: https://pdfkit.org/docs/accessibility.html

Example of using the structParent option in list() to automatically add list items to a parent structure element. By default, each item contains a label (Lbl) and body (LBody).

```javascript
// Create a list, add it to the structure tree, then add items to it
const list = doc.struct('List');
someElement.add(list);
doc.list(["Foo. ", "Bar. "], { structParent: list });
```

--------------------------------

### Set font with standard, TrueType, and collection fonts

Source: https://pdfkit.org/docs/text.html

Shows how to set the font size and use the `font` method with a standard PDF font name, a TrueType font file path, and a collection font (.ttc) with a style name. The example uses `doc.fontSize(18)` and chains `.text()` and `.moveDown(0.5)` calls.

```javascript
// Set the font size
doc.fontSize(18);

// Using a standard PDF font
doc.font('Times-Roman')
   .text('Hello from Times Roman!')
   .moveDown(0.5);

// Using a TrueType font (.ttf)
doc.font('fonts/GoodDog.ttf')
   .text('This is Good Dog!')
   .moveDown(0.5);

// Using a collection font (.ttc or .dfont)
doc.font('fonts/Chalkboard.ttc', 'Chalkboard-Bold')
   .text('This is Chalkboard, not Comic Sans.');

```

--------------------------------

### Create hierarchical form fields and annotations with PDFKit

Source: https://pdfkit.org/docs/forms.html

Sets up a form hierarchy using `doc.formField` with `parent` options, then adds text annotations and a push button. The example uses `doc.initForm()` and establishes a default font with `doc.font('Helvetica')`. The resulting field names are 'rootField.child1Field.leaf1', 'rootField.child1Field.leaf2', 'rootField.child2Field.leaf1', and 'btn1'.

```javascript
doc.font('Helvetica'); // establishes the default font
doc.initForm();

let rootField = doc.formField('rootField');
let child1Field = doc.formField('child1Field', { parent: rootField });
let child2Field = doc.formField('child2Field', { parent: rootField });

// Add text form annotation 'rootField.child1Field.leaf1'
doc.formText('leaf1', 10, 10, 200, 40, {
  parent: child1Field,
  multiline: true
});
// Add text form annotation 'rootField.child1Field.leaf2'
doc.formText('leaf2', 10, 60, 200, 40, {
  parent: child1Field,
  multiline: true
});
// Add text form annotation 'rootField.child2Field.leaf1'
doc.formText('leaf1', 10, 110, 200, 80, {
  parent: child2Field,
  multiline: true
});

// Add push button form annotation 'btn1'
var opts = {
  backgroundColor: 'yellow',
  label: 'Test Button'
};
doc.formPushButton('btn1', 10, 200, 100, 30, opts);
```

--------------------------------

### Add a single structure element to the document

Source: https://pdfkit.org/docs/accessibility.html

Create a structure element with doc.struct('P', myStructContent) and add it to the document's structure tree using doc.addStructure(). This is the simplest structure tree example.

```javascript
// Add a single structure element which includes the structure content to the document's structure
doc.addStructure(doc.struct('P', myStructContent));

```

--------------------------------

### Table with column and row spans

Source: https://pdfkit.org/docs/table.html

Shows how to set colSpan and rowSpan properties on individual cells to create tables with merged cells. The example includes a header with a colspan of 2, a cell with a rowspan of 3, and a cell with both colSpan and rowSpan.

```javascript
doc.table({
  columnStyles: [200, "*", "*"],
  data: [
    [{ colSpan: 2, text: "Header with Colspan = 2" }, "Header 3"],
    ["Header 1", "Header 2", "Header 3"],
    ["Sample value 1", "Sample value 2", "Sample value 3"],
    [
      {
        rowSpan: 3,
        text: "rowspan set to 3\nLorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor",
      },
      "Sample value 2",
      "Sample value 3",
    ],
    ["Sample value 2", "Sample value 3"],
    ["Sample value 2", "Sample value 3"],
    [
      "Sample value 1",
      {
        colSpan: 2,
        rowSpan: 2,
        text: "Both:\nrowspan and colspan\ncan be defined at the same time",
      },
    ],
    ["Sample value 1"],
  ],
})
```

--------------------------------

### Create structure automatically with text()

Source: https://pdfkit.org/docs/accessibility.html

Example of using the structParent option in text() to automatically mark each paragraph and add it to a parent structure element. The text() method creates a P structure element for each paragraph by default.

```javascript
// Create a section, add it to the document structure, then add paragraphs to it
const section = doc.struct('Sect');
doc.addStructure(section);
doc.text("Foo. \nBar. ", { structParent: section });
```

--------------------------------

### Draw SVG Path with doc.path()

Source: https://pdfkit.org/docs/vector.html

Use the SVG path parser to draw a path defined in SVG syntax. The example chains the stroke() method to render the path. Supports all SVG command types.

```javascript
doc.path('M 0,20 L 100,160 Q 130,200 150,120 C 190,-40 200,200 300,150 L 400,90')
   .stroke()
```

--------------------------------

### Create a PDF with PDFKit using CommonJS require

Source: https://pdfkit.org/index.html

This example shows how to create a PDF document with PDFKit using the CommonJS require syntax. It demonstrates embedding a font, adding text, images, vector graphics, and links, and finalizing the document. The code uses the named PDFDocument export, which is preferred for new code.

```javascript
const { PDFDocument } = require('pdfkit');
const fs = require('fs');

// Create a document
const doc = new PDFDocument();

// Pipe its output somewhere, like to a file or HTTP response
// See below for browser usage
doc.pipe(fs.createWriteStream('output.pdf'));

// Embed a font, set the font size, and render some text
doc
  .font('fonts/PalatinoBold.ttf')
  .fontSize(25)
  .text('Some text with an embedded font!', 100, 100);

// Add an image, constrain it to a given size, and center it vertically and horizontally
doc.image('path/to/image.png', {
  fit: [250, 300],
  align: 'center',
  valign: 'center'
});

// Add another page
doc
  .addPage()
  .fontSize(25)
  .text('Here is some vector graphics...', 100, 100);

// Draw a triangle
doc
  .save()
  .moveTo(100, 150)
  .lineTo(100, 250)
  .lineTo(200, 250)
  .fill('#FF3300');

// Apply some transforms and render an SVG path with the 'even-odd' fill rule
doc
  .scale(0.6)
  .translate(470, -380)
  .path('M 250,75 L 323,301 131,161 369,161 177,301 z')
  .fill('red', 'even-odd')
  .restore();

// Add some text with annotations
doc
  .addPage()
  .fillColor('blue')
  .text('Here is a link!', 100, 100)
  .underline(100, 100, 160, 27, { color: '#0000FF' })
  .link(100, 100, 160, 27, 'http://google.com/');

// Finalize PDF file
doc.end();

```

--------------------------------

### Creating GoTo Links with goTo

Source: https://pdfkit.org/docs/destinations.html

Shows how to create go-to links to named destinations using doc.goTo and the goTo option in text.

```javascript
// Go to annotation
doc.goTo(10, 10, 100, 20, 'LINK')

// Go to annotation for this text
doc.text('Another goto', 20, 0, {
  goTo: 'ENDP',
  underline: true
});
```

--------------------------------

### Style precedence example

Source: https://pdfkit.org/docs/table.html

Shows how cell styles are merged from defaultStyle, columnStyles, rowStyles, and cellStyle. The resulting border combines values from each level, with cellStyle having the highest precedence.

```javascript
doc.table({
  defaultStyle: { border: 1 },
  columnStyles: { border: { right: 2 } },
  rowStyles: { border: { bottom: 3 } },
  data: [
    [{ border: { left: 4 } }]
  ]
})
```

```javascript
{ 
    border: { 
        top: 1, // From the default
        right: 2, // From the column
        bottom: 3, // From the row
        left: 4  // From the cell
    }
}
```

--------------------------------

### Draw Triangle with doc.polygon()

Source: https://pdfkit.org/docs/vector.html

Use the polygon helper to draw a triangle by passing a list of points (arrays of x,y pairs). The example then calls stroke() to render the shape.

```javascript
doc.polygon([100, 0], [50, 100], [150, 100]);
doc.stroke();
```

--------------------------------

### Manual equivalent of closure shortcut

Source: https://pdfkit.org/docs/accessibility.html

Shows the manual steps equivalent to the closure shortcut: creating a structure element, marking content, adding text, ending marked content, and adding the content to the element.

```javascript
const myStruct = doc.struct('P');
doc.addStructure(myStruct);
const myStructContent = doc.markStructureContent('P');
doc.text('Hello, world! ');
doc.endMarkedContent();
myStruct.add(myStructContent);
myStruct.end();
```

--------------------------------

### goTo(x, y, width, height, name)

Source: https://pdfkit.org/docs/destinations.html

Creates a go-to link annotation that navigates to a named destination when clicked. The annotation is placed at the specified coordinates and size.

```APIDOC
## goTo(x, y, width, height, name)

### Description
Creates a go-to link annotation that navigates to a named destination when clicked. The annotation is placed at the specified coordinates and size.

### Method
goTo

### Parameters
- **x** (number) - Required - The x-coordinate of the annotation.
- **y** (number) - Required - The y-coordinate of the annotation.
- **width** (number) - Required - The width of the annotation.
- **height** (number) - Required - The height of the annotation.
- **name** (string) - Required - The name of the destination to navigate to.

### Example
```javascript
// Go to annotation
doc.goTo(10, 10, 100, 20, 'LINK')
```
```

--------------------------------

### Listen for pageAdded event

Source: https://pdfkit.org/docs/getting_started.html

Registers a listener for the 'pageAdded' event, which fires whenever a page is created, either automatically or via addPage(). The example adds text to each new page.

```javascript
doc.on('pageAdded', () => doc.text("Page Title"));
```

--------------------------------

### Table with row height function

Source: https://pdfkit.org/docs/table.html

Computes row heights dynamically using a function that receives the row index (starting from 0) and returns the height. Here, heights are `(row + 1) * 25`.

```javascript
doc.table({
    rowStyles: (row) => (row + 1) * 25,
    data: [
        ["row 1", "column B"],
        ["row 2", "column B"],
        ["row 3", "column B"],
    ],
  });
```

--------------------------------

### Define a path with moveTo, lineTo, quadraticCurveTo, bezierCurveTo, and stroke

Source: https://pdfkit.org/docs/vector.html

Creates a vector path by setting the current point, drawing lines and curves, and stroking the path. Demonstrates method chaining, which is optional in PDFKit.

```javascript
doc.moveTo(0, 20)                               // set the current point
   .lineTo(100, 160)                            // draw a line
   .quadraticCurveTo(130, 200, 150, 120)        // draw a quadratic curve
   .bezierCurveTo(190, -40, 200, 200, 300, 150) // draw a bezier curve
   .lineTo(400, 90)                             // draw another line
   .stroke();                                   // stroke the path
```

--------------------------------

### Create and use a tiling pattern

Source: https://pdfkit.org/demo/browser.html

Defines a 45-degree stripe pattern and fills a circle with it, using blue as the background color.

```javascript
// stroke & fill uncolored tiling pattern
var stripe45d = doc.pattern(
  [1, 1, 4, 4],
  3,
  3,
  '1 w 0 1 m 4 5 l s 2 0 m 5 3 l s'
);

doc.circle(280, 350, 50).fill([stripe45d, 'blue']);
```

--------------------------------

### Create and apply linear and radial gradients

Source: https://pdfkit.org/docs/vector.html

Shows how to create a linear gradient with stops, fill a rectangle, then create a radial gradient with opacity stops and fill a circle. Uses doc.linearGradient and doc.radialGradient.

```javascript
// Create a linear gradient
let grad = doc.linearGradient(50, 0, 150, 100);
grad.stop(0, 'green')
    .stop(1, 'red');

doc.rect(50, 0, 100, 100);
doc.fill(grad);

// Create a radial gradient
grad = doc.radialGradient(300, 50, 0, 300, 50, 50);
grad.stop(0, 'orange', 0)
    .stop(1, 'orange', 1);

doc.circle(300, 50, 50);
doc.fill(grad);

```

--------------------------------

### Register a font with registerFont and use it later

Source: https://pdfkit.org/docs/text.html

Registers a font file under a name using `doc.registerFont('Heading Font', 'fonts/Chalkboard.ttc', 'Chalkboard-Bold')` and then uses that name in the `font` method. This avoids entering the full path each time.

```javascript
// Register a font
doc.registerFont('Heading Font', 'fonts/Chalkboard.ttc', 'Chalkboard-Bold');

// Use the font later
doc.font('Heading Font')
   .text('This is a heading.');

```

--------------------------------

### Basic table with data array

Source: https://pdfkit.org/docs/table.html

Creates a simple table by passing an array of rows to `doc.table()`. Each inner array represents a row, and the first row is typically the header.

```javascript
doc.table({
    data: [
        ['Column 1', 'Column 2', 'Column 3'],
        ['One value goes here', 'Another one here', 'OK?']
    ]
})
```

--------------------------------

### Register file data in browser with registerFile

Source: https://pdfkit.org/docs/getting_started.html

In the browser, the file system is unavailable. Fetch a font file, convert to Uint8Array, and register it under the exact path using registerFile. Then use registerFont and font to use the loaded font. Unregister the path when no longer needed by passing undefined.

```javascript
import { PDFDocument, registerFile } from 'pdfkit';

const response = await fetch('/fonts/Roboto-Regular.ttf');
const fontData = new Uint8Array(await response.arrayBuffer());

registerFile('fonts/Roboto-Regular.ttf', fontData);

const doc = new PDFDocument();
doc.registerFont('Roboto', 'fonts/Roboto-Regular.ttf');
doc.font('Roboto').text('This font was loaded from memory.');

// Unregister the path when it is no longer needed.
registerFile('fonts/Roboto-Regular.ttf', undefined);

```

--------------------------------

### dash(length, options)

Source: https://pdfkit.org/docs/vector.html

Creates non-continuous dashed lines. Takes a length specifying how long each dash should be, and an optional hash with `space` and `phase` properties. Throws if passed invalid lengths.

```APIDOC
## dash(length, options)

### Description
Creates non-continuous dashed lines. Takes a length specifying how long each dash should be, and an optional hash with `space` and `phase` properties. Throws if passed invalid lengths.

### Method
dash

### Parameters
- **length** (number) - Required - Length of each dash. Must be a positive number.
- **options** (object) - Optional - Additional properties.
  - **space** (number) - Optional - Length of the space between dashes. Defaults to `length`.
  - **phase** (number) - Optional - Starting point of the sequence of dashes. Defaults to `0`.

### Example
```js
doc.circle(100, 50, 50)
   .dash(5, {space: 10})
   .stroke();
```
```

--------------------------------

### Use toBytes for contiguous Uint8Array output

Source: https://pdfkit.org/docs/getting_started.html

Import toBytes from 'pdfkit/output' and call it before doc.end() to get a promise that resolves to a Uint8Array. Use this when a binary API, worker, or parser needs a single contiguous buffer.

```javascript
import { toBytes } from 'pdfkit/output';

const output = toBytes(doc);
doc.end();
const bytes = await output;

```

--------------------------------

### text(text, x, y, options) with goTo option

Source: https://pdfkit.org/docs/destinations.html

The text method can be used to create a go-to link by passing a 'goTo' option. This creates a clickable text that navigates to the specified destination.

```APIDOC
## text(text, x, y, options) with goTo option

### Description
The text method can be used to create a go-to link by passing a 'goTo' option. This creates a clickable text that navigates to the specified destination.

### Method
text

### Parameters
- **text** (string) - Required - The text to display.
- **x** (number) - Optional - The x-coordinate of the text.
- **y** (number) - Optional - The y-coordinate of the text.
- **options** (object) - Optional - An object containing the 'goTo' property (string) that specifies the destination name. Other options like 'underline' may also be supported.

### Example
```javascript
// Go to annotation for this text
doc.text('Another goto', 20, 0, {
  goTo: 'ENDP',
  underline: true
});
```
```

--------------------------------

### Register standard fonts in browser with registerStdFonts

Source: https://pdfkit.org/docs/text.html

Browser applications must import and register only the standard-font data they use. This example imports Helvetica and TimesRoman from 'pdfkit/standard-fonts' and registers them with `registerStdFonts` before creating a PDFDocument and setting the font to 'Times-Roman'.

```javascript
import { PDFDocument, registerStdFonts } from 'pdfkit';
import Helvetica from 'pdfkit/standard-fonts/Helvetica';
import TimesRoman from 'pdfkit/standard-fonts/TimesRoman';

registerStdFonts(Helvetica, TimesRoman);

const doc = new PDFDocument();
doc.font('Times-Roman');

```

--------------------------------

### Link outline items to specific pages

Source: https://pdfkit.org/docs/outline.html

Creates outline items that link to specific pages using the pageNumber option (0-based index). The example adds text to three pages and then adds outline items linking to pages 1 and 2.

```javascript
doc.text('Page 1');
doc.addPage();
doc.text('Page 2');
doc.addPage();
doc.text('Page 3');

// Link to page 1 (index 0)
outline.addItem('Chapter 1', { pageNumber: 0 });
// Link to page 2 (index 1)
outline.addItem('Chapter 2', { pageNumber: 1 });

```

--------------------------------

### Create a PDFDocument with ES module import

Source: https://pdfkit.org/docs/getting_started.html

Import the named PDFDocument export and create a new instance. Use this in ES modules.

```javascript
import { PDFDocument } from 'pdfkit';
const doc = new PDFDocument();

```

--------------------------------

### Rich text with continued option and color change

Source: https://pdfkit.org/docs/text.html

Uses the continued option to retain text wrapping state between text calls. The width option from the first call is retained by the second call. The example changes fill color from green to red.

```javascript
doc.fillColor('green')
   .text(lorem.slice(0, 500), {
     width: 465,
     continued: true
   }).fillColor('red')
   .text(lorem.slice(500));
```

--------------------------------

### Create PDF document and display in iframe

Source: https://pdfkit.org/demo/browser.html

Creates a PDFDocument, collects its data chunks, and on end creates a blob URL to set as the iframe source. Revokes the previous blob URL if one exists.

```javascript
// create a document and collect its output
var doc = new PDFDocument();
var chunks = [];
doc.on('data', function(chunk) {
  chunks.push(chunk);
});
doc.on('end', function() {
  var blob = new Blob(chunks, { type: 'application/pdf' });
  if (iframe.pdfkitURL) {
    URL.revokeObjectURL(iframe.pdfkitURL);
  }
  iframe.pdfkitURL = URL.createObjectURL(blob);
  iframe.src = iframe.pdfkitURL;
});
```

--------------------------------

### linearGradient(x1, y1, x2, y2)

Source: https://pdfkit.org/docs/vector.html

Creates a linear gradient object. The gradient is defined by a start point (x1, y1) and an end point (x2, y2). After creation, color stops must be added using the stop method before applying the gradient to a fill.

```APIDOC
## linearGradient(x1, y1, x2, y2)

### Description
Creates a linear gradient object. The gradient is defined by a start point (x1, y1) and an end point (x2, y2). After creation, color stops must be added using the stop method before applying the gradient to a fill.

### Method
linearGradient

### Parameters
- **x1** (number) - Required - The x-coordinate of the start point.
- **y1** (number) - Required - The y-coordinate of the start point.
- **x2** (number) - Required - The x-coordinate of the end point.
- **y2** (number) - Required - The y-coordinate of the end point.

### Returns
A gradient object with a `stop` method.

### Example
```javascript
let grad = doc.linearGradient(50, 0, 150, 100);
grad.stop(0, 'green')
    .stop(1, 'red');

doc.rect(50, 0, 100, 100);
doc.fill(grad);
```
```

--------------------------------

### Automatic ending of structure content and artifacts

Source: https://pdfkit.org/docs/accessibility.html

Structure content does not nest and is mutually exclusive with artifact content. Marking structure or artifact content automatically ends current marking of structure or artifact content and any descendant marking. This example marks multiple paragraphs without needing to close them.

```javascript
// Mark multiple paragraphs without needing to close them
doc.markContent('Artifact', { type: "Layout" });
doc.rect(x1, y1, w1, h1);
const myStructContent = doc.markStructureContent('P');
doc.text('Hello, world! ');
doc.markContent('Artifact', { type: "Layout" });
doc.rect(x2, y2, w2, h2);
const myStructContent = doc.markStructureContent('P');
doc.markContent('Span');
doc.text('Bonjour, tout le monde! ');
doc.markContent('Artifact', { type: "Layout" });
doc.rect(x3, y3, w3, h3);
const myStructContent = doc.markStructureContent('P');
doc.text('Hello again! ');

```

--------------------------------

### goTo(x, y, w, h, name, options)

Source: https://pdfkit.org/docs/annotations.html

Adds a go-to annotation that navigates to a named destination within the PDF. The name parameter specifies the destination name.

```APIDOC
## goTo(x, y, w, h, name, options)

### Description
Adds a go-to annotation that navigates to a named destination within the PDF. The name parameter specifies the destination name.

### Method
goTo

### Parameters
- **x** (number) - Required - The x-coordinate of the annotation rectangle.
- **y** (number) - Required - The y-coordinate of the annotation rectangle.
- **w** (number) - Required - The width of the annotation rectangle.
- **h** (number) - Required - The height of the annotation rectangle.
- **name** (string) - Required - The name of the destination to go to.
- **options** (object) - Optional - Additional options.

### Example
```js
doc.goTo(20, doc.y, 10, 20, 'LINK', {});
```
```

--------------------------------

### Initialize form and set default font

Source: https://pdfkit.org/docs/forms.html

Must be called before adding any form annotation. Establishes the default form field font.

```javascript
doc.font('Helvetica'); // establishes the default form field font
doc.initForm();
```

--------------------------------

### Wrap text into columns with PDFKit text options

Source: https://pdfkit.org/docs/text.html

Use this snippet to render a long text into multiple columns with a specified width and height. The example sets columns to 3, columnGap to 15, height to 100, width to 465, and align to 'justify'. The output is a multi-column text layout in the PDF.

```javascript
const lorem = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam in suscipit purus. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Vivamus nec hendrerit felis. Morbi aliquam facilisis risus eu lacinia. Sed eu leo in turpis fringilla hendrerit. Ut nec accumsan nisl. Suspendisse rhoncus nisl posuere tortor tempus et dapibus elit porta. Cras leo neque, elementum a rhoncus ut, vestibulum non nibh. Phasellus pretium justo turpis. Etiam vulputate, odio vitae tincidunt ultricies, eros odio dapibus nisi, ut tincidunt lacus arcu eu elit. Aenean velit erat, vehicula eget lacinia ut, dignissim non tellus. Aliquam nec lacus mi, sed vestibulum nunc. Suspendisse potenti. Curabitur vitae sem turpis. Vestibulum sed neque eget dolor dapibus porttitor at sit amet sem. Fusce a turpis lorem. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae;';

doc.text(lorem, {
  columns: 3,
  columnGap: 15,
  height: 100,
  width: 465,
  align: 'justify'
});
```

--------------------------------

### Basic table with row chaining

Source: https://pdfkit.org/docs/table.html

Creates a table using the verbose method of chaining `.row()` calls on the `doc.table()` object. Each `.row()` adds a row to the table.

```javascript
doc.table()
   .row(['Column 1', 'Column 2', 'Column 3'])
   .row(['One value goes here', 'Another one here', 'OK?'])
```

--------------------------------

### Add gradient fill and tiling pattern

Source: https://pdfkit.org/examples/browserify/browser.html

Creates a linear gradient with three color stops and fills a rectangle. Then defines a tiling pattern and fills a circle with it combined with a blue color.

```javascript
doc.save();

// a gradient fill
var gradient = doc
  .linearGradient(100, 300, 200, 300)
  .stop(0, 'green')
  .stop(0.5, 'red')
  .stop(1, 'green');

doc.rect(100, 300, 100, 100).fill(gradient);

// stroke & fill uncolored tiling pattern
var stripe45d = doc.pattern(
  [1, 1, 4, 4],
  3,
  3,
  '1 w 0 1 m 4 5 l s 2 0 m 5 3 l s'
);

doc.circle(280, 350, 50).fill([stripe45d, 'blue']);
```
Tokens:
Raw