Introduction #

• With mutool run.
• With mupdf.js <https://mupdfjs.readthedocs.io/en/latest/> package for Node and browsers.

Functions #

mupdf.installLoadFontFunction(callback) #

callback(fontName, scriptName, isBold, isItalic)

mupdf.enableICC() #

mupdf.disableICC() #

mupdf.emptyStore() #

mupdf.shrinkStore(percent) #

• number percent:
• Returns: boolean

mupdf.setUserCSS(stylesheet, useDocumentStyles) #

• string stylesheet: The CSS text to use.
• boolean useDocumentStyles: Whether to respect the document’s own style sheet.

Types #

Common #

Archive #

Constructors #

Archive(path) #

• string path: Path string to the archive file or directory.

var archive1 = new mupdf.Archive("example1.zip")
var archive2 = new mupdf.Archive("example2.tar")
var archive3 = new mupdf.Archive("images/")

Archive(buffer) #

• Buffer | ArrayBuffer | Uint8Array | string buffer: Buffer containing a archive.

var archive1 = new mupdf.Archive(fs.readFileSync("example1.zip"))
var archive2 = new mupdf.Archive(fs.readFileSync("example1.tar"))

Instance methods #

Archive.prototype.getFormat() #

• Returns: string

var archive = new mupdf.Archive("example1.zip")
print(archive.getFormat())

Archive.prototype.countEntries() #

• Returns: number

var archive = new mupdf.Archive("example1.zip")
var numEntries = archive.countEntries()

Archive.prototype.listEntry(idx) #

• number idx: Entry index.
• Returns: string | null

var archive = new mupdf.Archive("example1.zip")
var entry = archive.listEntry(0)

Archive.prototype.hasEntry(name) #

• string name: Entry name to look for.
• Returns: boolean

var archive = new mupdf.Archive("example1.zip")
var hasEntry = archive.hasEntry("file1.txt")

Archive.prototype.readEntry(name) #

• string name: Name of entry to look for.
• Returns: Buffer

var archive = new mupdf.Archive("example1.zip")
var contents = archive.readEntry("file1.txt")

Examples #

		var archive = new mupdf.Archive("example1.zip")
		var n = archive.countEntries()
		for (var i = 0; i < n; ++i) {
			var entry = archive.listEntry(i)
			var contents = archive.readEntry(entry)
			console.log("entry", entry, contents.length)
		}

Buffer #

Constructors #

Buffer(data) #

• Buffer | ArrayBuffer | Uint8Array | string | null data: Contents used to populate buffer, or leave it empty if null.

var buffer = new mupdf.Buffer("hello world")

Instance properties #

Buffer.prototype.length #

• Throws: TypeError on attempted writes.
• Returns: number

Buffer.prototype.[n] #

• Throws: RangeError on out of bounds accesses.

var byte = buffer[0]

Instance methods #

Buffer.prototype.asString() #

• Returns: string

var str = buffer.asString()

Buffer.prototype.asUint8Array() #

• Returns: Uint8Array

var arr = buffer.asUint8Array()

Buffer.prototype.getLength() #

• Returns: number

var length = buffer.getLength()

Buffer.prototype.readByte(at) #

• number at: Index to read byte at.
• Returns: number

buffer.readByte(0)

Buffer.prototype.slice(start, end) #

• number start: Start index.
• number end: End index (optional).
• Returns: Buffer

var buffer = new mupdf.Buffer()
buffer.write("hello world") // buffer contains "hello world"
var newBuffer = buffer.slice(1, -1) // newBuffer contains "ello worl"

Buffer.prototype.write(str) #

• string str: String to append.

buffer.write("hello world")

Buffer.prototype.writeBuffer(data) #

• Buffer | ArrayBuffer | Uint8Array | string data: Data buffer to append.

buffer.writeBuffer(anotherBuffer)

Buffer.prototype.writeByte(byte) #

• number byte: The byte value to append.

buffer.writeByte(0x2a)

Buffer.prototype.writeLine(str) #

• string str: String to append.

buffer.writeLine("a line")

Buffer.prototype.writeRune© #

• number c: The character unicode codepoint.

buffer.writeRune(0x4f60) // To append U+4f60, 你
buffer.writeRune(0x597d) // To append U+597d, 好
buffer.writeRune(0xff01) // To append U+ff01, ！

Buffer.prototype.save(filename) #

• string filename: Filename to save to.

buffer.save("buffer.dat")

Color #

• In the ColorSpace.DeviceCMYK color space the components are [Cyan, Magenta, Yellow, Black]. A full intensity magenta color would therefore be [0, 1, 0, 0].
• In the ColorSpace.DeviceRGB color space the components are [Red, Green, Blue]. A full intensity green color would therefore be [0, 1, 0].
• In the ColorSpace.DeviceGray color space the components are [Black]. A full intensity black color would therefore be [0].

	type Color = [number] | [number, number, number] | [number, number, number, number]

ColorSpace #

Constructors #

ColorSpace(from, name) #

• Buffer | ArrayBuffer | Uint8Array | string from: A buffer containing an ICC profile.
• string name: A user descriptive name for the new colorspace.

var icc_colorspace = new mupdf.ColorSpace(fs.readFileSync("SWOP.icc"), "SWOP")

Static properties #

ColorSpace.DeviceGray #

ColorSpace.DeviceRGB #

ColorSpace.DeviceBGR #

ColorSpace.DeviceCMYK #

ColorSpace.Lab #

Instance methods #

ColorSpace.prototype.getName() #

ColorSpace.prototype.getNumberOfComponents() #

• Returns: number of components

var cs = mupdf.ColorSpace.DeviceRGB
var num = cs.getNumberOfComponents() // 3

ColorSpace.prototype.getType() #

• Returns: "None" | "Gray" | "RGB" | "BGR" | "CMYK" | "Lab" | "Indexed" | "Separation"

ColorSpace.prototype.isCMYK() #

• Returns: boolean

var bool = colorSpace.isCMYK()

ColorSpace.prototype.isDeviceN() #

• Returns: boolean

var bool = colorSpace.isDeviceN()

ColorSpace.prototype.isGray() #

• Returns: boolean

var bool = colorSpace.isGray()

ColorSpace.prototype.isIndexed() #

• Returns: boolean

var bool = colorSpace.isIndexed()

ColorSpace.prototype.isLab() #

• Returns: boolean

var bool = colorSpace.isLab()

ColorSpace.prototype.isRGB() #

• Returns: boolean

var bool = colorSpace.isRGB()

ColorSpace.prototype.isSubtractive() #

• Returns: boolean

var bool = colorSpace.isSubtractive()

ColorSpace.prototype.toString() #

• Returns: string

var cs = mupdf.ColorSpace.DeviceRGB
var name = cs.toString() // "[ColorSpace DeviceRGB]"

DOM #

Constructors #

DOM #

Instance methods #

DOM.prototype.body() #

• Returns: DOM

var result = xml.body()

DOM.prototype.documentElement() #

• Returns: DOM

var result = xml.documentElement()

DOM.prototype.createElement(tag) #

• string tag: Tag name to use for element.
• Returns: DOM

var result = xml.createElement("div")

DOM.prototype.createTextNode(text) #

• string text: Text contents to put into element.
• Returns: DOM

var result = xml.createElement("Hello world!")

DOM.prototype.find(tag, attribute, value) #

• string tag: The tag of the element to look for.
• string attribute: The attribute of the element to look for.
• string value: The value of the attribute of the element to look for.
• Returns: DOM | null

var result = xml.find("tag", "attribute", "value")

DOM.prototype.findNext(tag, attribute, value) #

• string tag: The tag of the element to look for.
• string attribute: The attribute of the element to look for.
• string value: The value of the attribute of the element to look for.
• Returns: DOM | null

var result = xml.findNext("tag", "attribute", "value")

DOM.prototype.appendChild(dom, childDom) #

• DOM dom: The DOM that will be parent.
• DOM childDom: The DOM that will be a child.

xml.appendChild(dom, childDom)

DOM.prototype.insertBefore(dom, elementDom) #

• DOM dom: The reference DOM.
• DOM elementDom: The DOM that will be inserted before.

xml.insertBefore(dom, elementDom)

DOM.prototype.insertAfter(dom, elementDom) #

• DOM dom: The reference DOM.
• DOM elementDom: The DOM that will be inserted after.

xml.insertAfter(dom, elementDom)

DOM.prototype.remove() #

var result = xml.remove()

DOM.prototype.clone() #

• Returns: DOM

var result = xml.clone()

DOM.prototype.firstChild() #

• Returns: DOM | null

var result = xml.firstChild()

DOM.prototype.parent() #

• Returns: DOM | null

var result = xml.parent()

DOM.prototype.next() #

• Returns: DOM | null

var result = xml.next()

DOM.prototype.previous() #

• Returns: DOM | null

var result = xml.previous()

DOM.prototype.addAttribute(attribute, value) #

• string attribute: Desired attribute name.
• string value: Desired attribute value.
• Returns: DOM

var result = xml.addAttribute("attribute", "value")

DOM.prototype.removeAttribute(attribute) #

• string attribute: The name of the attribute to remove.
• Returns: DOM

xml.removeAttribute("attribute")

DOM.prototype.getAttribute(attribute) #

• string attribute: The name of the attribute to look up.
• Returns: string | null

var result = xml.attribute("attribute")

DOM.prototype.getAttributes() #

• Returns: Object

var dict = xml.getAttributes()

DOM.prototype.getText() #

• Returns: string | null

var text = xml.getText()

DOM.prototype.getTag() #

• Returns: string | null

var text = xml.getTag()

DefaultColorSpaces #

Constructors #

DefaultColorSpaces() #

Instance methods #

DefaultColorSpaces.prototype.getDefaultGray() #

• Returns: ColorSpace

DefaultColorSpaces.prototype.getDefaultRGB() #

• Returns: ColorSpace

DefaultColorSpaces.prototype.getDefaultCMYK() #

• Returns: ColorSpace

DefaultColorSpaces.prototype.getOutputIntent() #

• Returns: ColorSpace

DefaultColorSpaces.prototype.setDefaultGray(colorspace) #

• ColorSpace colorspace: The new default gray colorspace.

DefaultColorSpaces.prototype.setDefaultRGB(colorspace) #

• ColorSpace colorspace: The new default RGB colorspace.

DefaultColorSpaces.prototype.setDefaultCMYK(colorspace) #

• ColorSpace colorspace: The new default CMYK colorspace.

DefaultColorSpaces.prototype.setOutputIntent(colorspace) #

• ColorSpace colorspace: The new default output intent.

Device #

Constructors #

Device(callbacks) #

• callbacks: object containing callback functions

Constants #

Device.BLEND_NORMAL #

Device.BLEND_MULTIPLY #

Device.BLEND_SCREEN #

Device.BLEND_OVERLAY #

Device.BLEND_DARKEN #

Device.BLEND_LIGHTEN #

Device.BLEND_COLOR_DODGE #

Device.BLEND_COLOR_BURN #

Device.BLEND_HARD_LIGHT #

Device.BLEND_SOFT_LIGHT #

Device.BLEND_DIFFERENCE #

Device.BLEND_EXCLUSION #

Device.BLEND_HUE #

Device.BLEND_SATURATION #

Device.BLEND_COLOR #

Device.BLEND_LUMINOSITY #

Instance methods #

Device.prototype.close() #

device.close()

Device.prototype.fillPath(path, evenOdd, ctm, colorspace, color, alpha) #

• Path path: Path object.
• boolean evenOdd: Use :term:even-odd rule or :term: non-zero winding number rule to fill the path.
• Matrix ctm: The transform to apply.
• ColorSpace colorspace: The colorspace of the color to fill with.
• Color color: The color to fill the path with.
• number alpha: The :term: opacity.

device.fillPath(path, false, mupdf.Matrix.identity, mupdf.ColorSpace.DeviceRGB, [1, 0, 0], true)

Device.prototype.strokePath(path, stroke, ctm, colorspace, color, alpha) #

• Path path: Path object.
• StrokeState stroke: Stroke state.
• Matrix ctm: The transform to apply.
• ColorSpace colorspace: Colorspace.
• Color color: The color to stroke the path with.
• number alpha: The :term: opacity.

device.strokePath(path,
{dashes: [5, 10], lineWidth: 3, lineCap: 'Round' },
mupdf.Matrix.identity,
mupdf.ColorSpace.DeviceRGB,
[0, 1, 0],
0.5
)

Device.prototype.clipPath(path, evenOdd, ctm) #

• Path path: Path object.
• boolean evenOdd: Use :term:even-odd rule or :term: non-zero winding number rule to fill the path.
• Matrix ctm: The transform to apply.

device.clipPath(path, true, mupdf.Matrix.identity)

Device.prototype.clipStrokePath(path, stroke, ctm) #

• Path path: Path object.
• StrokeState stroke: Stroke state.
• Matrix ctm: The transform to apply.

device.clipStrokePath(path, true, mupdf.Matrix.identity)

Device.prototype.fillText(text, ctm, colorspace, color, alpha) #

• Text text: Text object.
• Matrix ctm: The transform to apply.
• ColorSpace colorspace: Colorspace
• Color color: The color used to fill the text.
• number alpha: The :term: opacity.

device.fillText(text, mupdf.Matrix.identity, mupdf.ColorSpace.DeviceRGB, [1, 0, 0], 1)

Device.prototype.strokeText(text, stroke, ctm, colorspace, color, alpha) #

• Text text: Text object.
• StrokeState stroke: Stroke state.
• Matrix ctm: The transform to apply.
• ColorSpace colorspace: Colorspace
• Color color: The color used to stroke the text.
• number alpha: The :term: opacity.

device.strokeText(text,
{ dashes: [5, 10], lineWidth: 3, lineCap: 'Round' },
mupdf.Matrix.identity,
mupdf.ColorSpace.DeviceRGB,
[1, 0, 0],
1
)

Device.prototype.clipText(text, ctm) #

• Text text: Text object.
• Matrix ctm: The transform to apply.

device.clipText(text, mupdf.Matrix.identity)

Device.prototype.clipStrokeText(text, stroke, ctm) #

• Text text: Text object.
• StrokeState stroke: stroke state.
• Matrix ctm: The transform to apply.

device.clipStrokeText(text,
{ dashes: [5, 10], lineWidth: 3, lineCap: 'Round' },
mupdf.Matrix.identity
)

Device.prototype.ignoreText(text, ctm) #

• Text text: Text object.
• Matrix ctm: The transform to apply.

device.ignoreText(text, mupdf.Matrix.identity)

Device.prototype.fillShade(shade, ctm, alpha) #

• Shade shade: The gradient.
• Matrix ctm: The transform to apply.
• number alpha: The :term: opacity.

device.fillShade(shade, mupdf.Matrix.identity, true, { overPrinting: true })

Device.prototype.fillImage(image, ctm, alpha) #

• Image image: Image object.
• Matrix ctm: The transform to apply.
• number alpha: The :term: opacity.

device.fillImage(image, mupdf.Matrix.identity, false, { overPrinting: true })

Device.prototype.fillImageMask(image, ctm, colorspace, color, alpha) #

• Image image: Image object.
• Matrix ctm: The transform to apply.
• ColorSpace colorspace: Colorspace
• Color color: The color to be used.
• number alpha: The :term: opacity.

device.fillImageMask(image, mupdf.Matrix.identity, mupdf.ColorSpace.DeviceRGB, [0, 1, 0], true)

Device.prototype.clipImageMask(image, ctm) #

• Image image: Image object.
• Matrix ctm: The transform to apply.

device.clipImageMask(image, mupdf.Matrix.identity)

Device.prototype.popClip() #

device.popClip()

Device.prototype.beginMask(area, luminosity, colorspace, color) #

• Rect area: Mask area.
• boolean luminosity: If luminosity is true, the mask is derived from the luminosity (grayscale value) of the graphics drawn; otherwise the color is ignored completely and the mask is derived from the alpha of the group.
• ColorSpace colorspace: Colorspace
• Color color: The color to be used.

device.beginMask([0, 0, 100, 100], true, mupdf.ColorSpace.DeviceRGB, [1, 0, 1])

Device.prototype.endMask() #

device.endMask()

Device.prototype.beginGroup(area, colorspace, isolated, knockout, blendmode, alpha) #

• Rect area: The blend area.
• ColorSpace colorspace: Colorspace
• boolean isolated: Whether the group is isolated.
• boolean knockout: Whether the group is knockout.
• string blendmode: The blend mode used when compositing this group with its backdrop.
• number alpha: The :term: opacity.

device.beginGroup(
[0, 0, 100, 100],
mupdf.ColorSpace.DeviceRGB,
true,
true,
"Multiply",
0.5
)

Device.prototype.endGroup() #

device.endGroup()

Device.prototype.beginTile(area, view, xstep, ystep, ctm, id, doc_id) #

• Rect area: Area
• Rect view: View
• number xstep: x step.
• number ystep: y step.
• Matrix ctm: The transform to apply.
• number id:
• number doc_id: The purpose of id/doc_id is to allow for efficient caching of rendered tiles. If id is 0, then no caching is performed. If it is non-zero, then id/doc_id are assumed to uniquely identify this tile.

device.beginTile([0, 0, 100, 100], [100, 100, 200, 200], 10, 10, mupdf.Matrix.identity, 0)

Device.prototype.endTile() #

device.endTile()

Device.prototype.renderFlags(set, clear) #

• “mask”
• “color”
• “uncacheable”
• “fillcolor-undefined”
• “strokecolor-undefined”
• “startcap-undefined”
• “dashcap-undefined”
• “endcap-undefined”
• “linejoin-undefined”
• “miterlimit-undefined”
• “linewidth-undefined”
• “bbox-defined”
• “gridfit-as-tiled”
• Array of string set: Rendering flags to set.
• Array of string clear: Rendering flags to clear.

device.renderFlags(["mask", "startcap-undefined"], [])

Device.prototype.setDefaultColorSpaces(defaultCS) #

• DefaultColorSpaces defaultCS: The new set of default colorspaces.

var defaultCS = new DefaultColorSpaces()
defaultCS.setDefaultRGB(defaultCS.getDefaultGray())
device.setDefaultColorSpaces(new DefaultColorSpaces())

Device.prototype.beginLayer(name) #

• string name: Name of this marked-content layer.

device.beginLayer("my tag")

Device.prototype.endLayer() #

device.endLayer()

Device.prototype.beginStructure(structure, raw, index) #

• string structure: One of the pre-defined structure types in PDF.
• string raw: The tag name.
• number index: A unique identifier.

device.beginStructure("Document", "my_tag_name", 123)

Device.prototype.endStructure() #

device.endStructure()

Device.prototype.beginMetatext(meta, text) #

• “ActualText”
• “Alt”
• “Abbreviation”
• “Title”
• string meta: The meta text type
• string text: The text value.

device.beginMetatext("Title", "My title")

Device.prototype.endMetatext() #

device.endMetatext()

DisplayList #

	var list = new mupdf.DisplayList([0, 0, 595, 842])
	var listDevice = new mupdf.DisplayListDevice(list)
	page.run(listDevice, mupdf.Matrix.identity)

var pixmap = new mupdf.Pixmap(mupdf.ColorSpace.DeviceRGB, [0, 0, 595, 842], false)
var drawDevice = new mupdf.DrawDevice(mupdf.Matrix.identity, pixmap)
list.run(drawDevice, mupdf.Matrix.identity)

var searchHits = list.search("hello world")

Constructors #

DisplayList(mediabox) #

• Rect mediabox: The size of the page.

var displayList = new mupdf.DisplayList([0, 0, 595, 842])

Instance methods #

DisplayList.prototype.run(device, matrix) #

• Device device: The device to replay the device calls to.
• Matrix matrix: Transformation matrix to apply to coordinates in all device calls.

displayList.run(device, mupdf.Matrix.identity)

DisplayList.prototype.getBounds() #

• Returns: Rect

var bounds = displayList.getBounds()

DisplayList.prototype.toPixmap(matrix, colorspace, alpha) #

• Matrix matrix: Transformation matrix.
• ColorSpace colorspace: The desired colorspace of the returned pixmap.
• boolean alpha: Whether the returned pixmap has transparency or not. If the pixmap handles transparency, it starts out transparent (otherwise it is filled white), before the contents of the display list are rendered onto the pixmap.
• Returns: Pixmap

var pixmap = displayList.toPixmap(mupdf.Matrix.identity, mupdf.ColorSpace.DeviceRGB, false)

DisplayList.prototype.toStructuredText(options) #

• string options: See :doc:/reference/common/stext-options.
• Returns: StructuredText

var sText = displayList.toStructuredText("preserve-whitespace")

DisplayList.prototype.search(needle, max_hits) #

• string needle: The text to search for.
• number options: Optional options for the search. A logical or of options such as StructuredText.SEARCH_EXACT.
• Returns: Array of Array of Quad

var results = displayList.search("my search phrase")

DisplayList.protoype.decodeBarcode(subarea, rotate) #

• Rect subarea: Only detect barcode within subarea. Defaults to the entire area returned by DisplayList.prototype.getBounds().
• number rotate: Degrees of rotation to rotate display list before detecting barcode. Defaults to 0.
• Returns: Object with barcode information.

var barcodeInfo = displayList.decodeBarcode([0, 0, 100, 100 ], 0)

DisplayListDevice #

Constructors #

DisplayListDevice(displayList) #

• DisplayList displayList: the display list to populate.

var myDisplayList = new mupdf.DisplayList([0, 0, 100, 100])
var displayListDevice = new mupdf.DisplayListDevice(myDisplayList)

Document #

Document #

Constants #

Document.PERMISSION_PRINT #

Document.PERMISSION_EDIT #

Document.PERMISSION_COPY #

Document.PERMISSION_ANNOTATE #

Document.PERMISSION_FORM #

Document.PERMISSION_ACCESSIBILITY #

Document.PERMISSION_ASSEMBLE #

Document.PERMISSION_PRINT_HQ #

Static methods #

• string filename: File name to open.
• Buffer | ArrayBuffer | Uint8Array | string buffer: Buffer containing a document file.
• string magic: An optional :term: MIME-type or file extension. Defaults to “application/pdf”.
• string accelerator: File name of accelerator file.
• Buffer | ArrayBuffer | Uint8Array | string acceleratorbuffer: Buffer containing an accelerator file.
• Archive dir: An archive from which to load resources for rendering.
• Returns: Document

var document1 = mupdf.Document.openDocument("my_pdf.pdf", "application/pdf")
var document2 = mupdf.Document.openDocument("my_pdf.pdf", dir)
var document3 = mupdf.Document.openDocument("my_pdf.pdf", acceleratorfile, dir)
var document4 = mupdf.Document.openDocument(fs.readFileSync("my_pdf.pdf"), "application/pdf")
var document5 = mupdf.Document.openDocument(fs.readFileSync("my_pdf.pdf"), acceleratorbuffer, "application/pdf")
var document6 = mupdf.Document.openDocument(fs.readFileSync("my_pdf.pdf"), acceleratorbuffer, dir, "application/pdf")

• string magic: An optional :term: MIME-type or file extension. Defaults to “application/pdf”.
• string filename: File name to check contents of.
• Buffer | ArrayBuffer | Uint8Array | string buffer: Buffer containing a PDF file.
• Archive dir: An archive from which to load resources for rendering.
• Returns: boolean

var recognized1 = mupdf.Document.recognize("application/pdf")
var recognized2 = mupdf.Document.recognizeContent("my_pdf.pdf")
var recognized3 = mupdf.Document.recognizeContent(buffer, "application/pdf")
var recognized4 = mupdf.Document.recognizeContent(buffer, dir, "application/pdf")

Instance methods #

Document.prototype.needsPassword() #

• Returns: boolean

var needsPassword = document.needsPassword()

Document.prototype.authenticatePassword(password) #

• string password: The password to attempt authentication with.
• Returns: number

var auth = document.authenticatePassword("abracadabra")

Document.prototype.hasPermission(permission) #

• “print” | “edit” | “copy” | “annotate” | “form” | “accessibility” | “assemble” | “print-hq” permission:

• Returns: boolean

var canEdit1 = document.hasPermission("edit")
var canEdit2 = document.hasPermission(Document.PERMISSION_EDIT)

Document.prototype.getMetaData(key) #

• string key: What metadata type to return.
• Returns: string | null

var format = document.getMetaData("format")
var modificationDate = doc.getMetaData("info:ModDate")
var author = doc.getMetaData("info:Author")

Document.prototype.setMetaData(key, value) #

• string key: Metadata key to set.
• string value: New value to set for the given key.

document.setMetaData("info:Author", "My Name")

Document.prototype.isReflowable() #

• Returns: boolean

var isReflowable = document.isReflowable()

Document.prototype.layout(pageWidth, pageHeight, fontSize) #

• number pageWidth: Desired page width.
• number pageHeight: Desired page height.
• number fontSize: Desire font size.

document.layout(300, 300, 16)

Document.prototype.countPages() #

• Returns: number

var numPages = document.countPages()

Document.prototype.loadPage(number) #

• number number: Number of page to load, 0 means the first page in the document.
• Returns: Page | PDFPage.

var page = document.loadPage(0) // loads the 1st page of the document

Document.prototype.loadOutline() #

• Returns: Array of OutlineItem (nested).

var outline = document.loadOutline()

Document.prototype.outlineIterator() #

• Returns: OutlineIterator

var obj = document.outlineIterator()

Document.prototype.resolveLink(link) #

• Link | string link: A link or a link URI string to resolve.
• Returns: number

var pageNumber = document.resolveLink(my_link)

Document.prototype.resolveLinkDestination(link) #

• Link | string link: A link or a link URI string to resolve.
• Returns: LinkDestination

var linkDestination = document.resolveLinkDestination(linkuri)

Document.prototype.isPDF() #

• Returns: boolean

var isPDF = document.isPDF()

Document.prototype.asPDF() #

• Returns: PDFDocument | null

var doc = mupdf.Document.openDocument(filename)
var pdf = doc.asPDF()
if (pdf) {
// the document has a native PDF representation
} else {
// it does not have a native PDF representation
}

Document.prototype.formatLinkURI(linkDestination) #

• LinkDestination linkDestination: The link destination object to format.
• Returns: string

var uri = document.formatLinkURI({
chapter: 0,
page: 42,
type: "FitV",
x: 0,
y: 0,
width: 100,
height: 50,
zoom: 1
})
page.createLink([0, 0, 100, 100], uri)

DocumentWriter #

Constructors #

• Buffer buffer: The buffer to output to.
• Buffer filename: The file name to output to.
• string format: The file format.
• string options: The options as key-value pairs.

var writer = new mupdf.DocumentWriter(buffer, "PDF", "")

Instance methods #

DocumentWriter.prototype.beginPage(mediabox) #

• Rect mediaBox: The page size.
• Returns: Device

var device = writer.beginPage([0, 0, 100, 100])

DocumentWriter.prototype.endPage() #

writer.endPage()

DocumentWriter.prototype.close() #

writer.close()

DrawDevice #

Constructors #

DrawDevice(matrix, pixmap) #

• Matrix matrix: The matrix to apply.
• Pixmap pixmap: The pixmap that will be drawn to.

var drawDevice = new mupdf.DrawDevice(mupdf.Matrix.identity, pixmap)

Font #

Constructors #

• "Times-Roman"
• "Times-Italic"
• "Times-Bold"
• "Times-BoldItalic"
• "Helvetica"
• "Helvetica-Oblique"
• "Helvetica-Bold"
• "Helvetica-BoldOblique"
• "Courier"
• "Courier-Oblique"
• "Courier-Bold"
• "Courier-BoldOblique"
• "Symbol"
• "ZapfDingbats"

• string name: Font name.
• Buffer | ArrayBuffer | Uint8Array data: The font data if loaded from a buffer.
• string filename: The name of the font file to load.
• number index: Subfont index (only used for TTC fonts).

var font1 = new mupdf.Font("Times-Roman")
var font2 = new mupdf.Font("ko")

            var font3 = new mupdf.Font("Comic Sans", "/usr/share/fonts/truetype/msttcorefonts/Comic_Sans_MS.ttf")
            var font4 = new mupdf.Font("Comic Sans", "/usr/share/fonts/truetype/msttcorefonts/Comic_Sans_MS.ttf", 1)
	var font5 = new mupdf.Font("Freight Sans", fs.readFileSync("DroidSansFallbackFull.ttf"))

Constants #

Font.SIMPLE_ENCODING_LATIN #

Font.SIMPLE_ENCODING_GREEK #

Font.SIMPLE_ENCODING_CYRILLIC #

Instance methods #

Font.prototype.getName() #

• Returns: string

var name = font.getName()

Font.prototype.encodeCharacter(unicode) #

• number | string unicode: The unicode character, or the first unicode character of a string.
• Returns: number.

var index = font.encodeCharacter(0x42)

Font.prototype.advanceGlyph(glyph , wmode) #

• number glyph: The glyph as unicode character.
• number wmode: 0 for horizontal writing, and 1 for vertical writing, defaults to horizontal.
• Returns: number

var width = font.advanceGlyph(0x42)

Font.prototype.isBold() #

• Returns: boolean

var isBold = font.isBold()

Font.prototype.isItalic() #

• Returns: boolean

var isItalic = font.isItalic()

Font.prototype.isMono() #

• Returns: boolean

var isMono = font.isMono()

Font.prototype.isSerif() #

• Returns: boolean

var isSerif = font.isSerif()

Image #

Constructors #

• Pixmap pixmap: A pixmap with the image data.
• Buffer | ArrayBuffer | Uint8Array data: Image data.
• string filename: Image file to load.
• Image mask: An optional image mask.

var image1 = new mupdf.Image(pixmap, imagemask)
var image2 = new mupdf.Image(buffer, imagemask)
var image3 = new mupdf.Image("logo.png", imagemask)

Instance methods #

Image.prototype.getWidth() #

• Returns: number

var width = image.getWidth()

Image.prototype.getHeight() #

• Returns: number

var height = image.getHeight()

Image.prototype.getXResolution() #

• Returns: number

var xRes = image.getXResolution()

Image.prototype.getYResolution() #

• Returns: number

var yRes = image.getYResolution()

Image.prototype.getColorSpace() #

• Returns: ColorSpace | null

var cs = image.getColorSpace()

Image.prototype.getNumberOfComponents() #

• Returns: number

var num = image.getNumberOfComponents()

Image.prototype.getBitsPerComponent() #

• Returns: number

var bits = image.getBitsPerComponent()

Image.prototype.getImageMask() #

• Returns: boolean

var hasMask = image.getImageMask()

Image.prototype.getMask() #

• Returns: Image | null

var mask = image.getMask()

Image.prototype.getInterpolate() #

• Returns: boolean

var interpolate = image.getInterpolate()

Image.prototype.getColorKey() #

• Returns: Array of number | null

var result = image.getColorKey()

Image.prototype.getDecode() #

• Returns: Array of number | null

var arr = image.getDecode()

Image.prototype.getOrientation() #

• Returns: number

var orientation = image.getOrientation()

Image.prototype.setOrientation(orientation) #

• number orientation: Orientation value described in this table:

Image.prototype.toPixmap(scaledWidth, scaledHeight) #

• number scaledWidth:
• number scaledHeight:
• Returns: Pixmap

var pixmap = image.toPixmap()
var scaledPixmap = image.toPixmap(100, 100)

Link #

Constructors #

Link #

Instance methods #

Link.prototype.getBounds() #

• Returns: Rect

var rect = link.getBounds()

Link.prototype.setBounds(rect) #

• Rect rect: Desired bounds for link.

link.setBounds([0, 0, 100, 100])

Link.prototype.getURI() #

• Returns: string

var uri = link.getURI()

Link.prototype.setURI(uri) #

• string uri: An URI describing the desired link destination.

Link.prototype.isExternal() #

• Returns: boolean

var isExternal = link.isExternal()

LinkDestination #

LinkDestination(chapter, page, type, x, y, width, height) #

• number chapter:
• number page:
• “Fit” | “FitB” | “FitH” | “FitBH” | “FitV” | “FitBV” | “FitR” | “XYZ” type:

Constants #

LinkDestination.FIT #

LinkDestination.FIT_H #

LinkDestination.FIT_V #

LinkDestination.FIT_B #

LinkDestination.FIT_BH #

LinkDestination.FIT_BV #

LinkDestination.FIT_R #

LinkDestination.XYZ #

Instance properties #

LinkDestination.prototype.chapter #

The chapter within the document.

LinkDestination.prototype.page #

The page within the document.

LinkDestination.prototype.type #

Either "Fit", "FitB", "FitH", "FitBH", "FitV", "FitBV", "FitR" or "XYZ".

The type controls which of the x, y, width, height, and zoom values are used.

LinkDestination.prototype.x #

The left coordinate. Used for "FitV", "FitBV", "FitR", and "XYZ".

LinkDestination.prototype.y #

The top coordinate. Used for "FitH", "FitBH", "FitR", and "XYZ".

LinkDestination.prototype.width #

The width of the zoomed in region. Used for "FitR".

LinkDestination.prototype.height #

The height of the zoomed in region. Used for "FitR".

LinkDestination.prototype.zoom #

The zoom factor. Used for "XYZ".

Matrix #

	/ a b 0 \
	| c d 0 |
	\ e f 1 /

	[a, b, c, d, e, f]

	type Matrix = [number, number, number, number, number, number]

Constructors #

Matrix #

Static properties #

Matrix.identity #

var m = mupdf.Matrix.identity

Static methods #

Matrix.scale(sx, sy) #

• number sx: X scale as a floating point number.
• number sy: Y scale as a floating point number.
• Returns: Matrix

var m = mupdf.Matrix.scale(2, 2)

Matrix.translate(tx, ty) #

• number tx: X translation as a floating point number.
• number ty: Y translation as a floating point number.
• Returns: Matrix

var m = mupdf.Matrix.translate(2, 2)

Matrix.rotate(theta) #

• number theta: Rotation in degrees, positive for CW and negative for CCW.
• Returns: Matrix

var m = mupdf.Matrix.rotate(90)

Matrix.concat(a, b) #

• Matrix a: Left side matrix.
• Matrix b: Right side matrix.
• Returns: Matrix

var m = mupdf.Matrix.concat([1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2])
// expected result [4, 4, 4, 4, 6, 6]

Matrix.invert(matrix) #

• Matrix matrix: Matrix to invert.
• Returns: Matrix

var m = mupdf.Matrix.invert([1, 0.5, 1, 1, 1, 1])

MultiArchive #

Constructors #

MultiArchive() #

var multiArchive = new mupdf.MultiArchive()

Instance methods #

MultiArchive.prototype.mountArchive(subArchive, path) #

• Archive subArchive: An archive that will be a child archive of this one.
• string path: The path at which the archive will be inserted.

var archive = new mupdf.MultiArchive()
archive.mountArchive(new mupdf.Archive("example1.zip"), null)
archive.mountArchive(new mupdf.Archive("example2.zip"), "subpath")
console.log(archive.hasEntry("file1.txt"))
console.log(archive.hasEntry("subpath/file2.txt"))

OutlineItem #

Constructors #

OutlineItem #

	interface OutlineItem {
		title: string | undefined,
		uri: string | undefined,
		open: boolean,
		down?: OutlineItem[],
		page?: number,
	}

OutlineIterator #

Constructors #

OutlineIterator #

Constants #

OutlineIterator.ITERATOR_DID_NOT_MOVE #

OutlineIterator.ITERATOR_AT_ITEM #

OutlineIterator.ITERATOR_AT_EMPTY #

OutlineIterator.FLAG_BOLD #

OutlineIterator.FLAG_ITALIC #

Instance methods #

OutlineIterator.prototype.item() #

• Returns: OutlineItem | null

var obj = outlineIterator.item()

OutlineIterator.prototype.next() #

• Returns: number

var result = outlineIterator.next()

OutlineIterator.prototype.prev() #

• Returns: number

var result = outlineIterator.prev()

OutlineIterator.prototype.up() #

• Returns: number

var result = outlineIterator.up()

OutlineIterator.prototype.down() #

• Returns: number

var result = outlineIterator.down()

OutlineIterator.prototype.insert(item) #

• OutlineItem item: the item to insert
• Returns: number

var result = outlineIterator.insert(item)

OutlineIterator.prototype.delete() #

• Returns: number

outlineIterator.delete()

OutlineIterator.prototype.update(item) #

• OutlineItem item: An item populated with the properties that should be stored.

outlineIterator.update(item)

Page #

Constructors #

Page #

Constants #

Page.MEDIA_BOX #

Page.CROP_BOX #

Page.BLEED_BOX #

Page.TRIM_BOX #

Page.ART_BOX #

Instance methods #

Page.prototype.getBounds(box) #

• string box: Which :term: page box to query.
• Returns: Rect

var rect = page.getBounds()

Page.prototype.run(device, transform) #

• Device device: The device object.
• Matrix matrix: The transformation matrix.

page.run(dev, mupdf.Matrix.identity)

Page.prototype.runPageContents(device, transform) #

• Device device: The device object.
• Matrix matrix: The transformation matrix.

page.runPageContents(dev, mupdf.Matrix.identity)

Page.prototype.runPageAnnots(device, transform) #

• Device device: The device object.
• Matrix matrix: The transformation matrix.

page.runPageAnnots(dev, mupdf.Matrix.identity)

Page.prototype.runPageWidgets(device, transform) #

• Device device: The device object.
• Matrix matrix: The transformation matrix.

page.runPageWidgets(dev, mupdf.Matrix.identity)

Page.prototype.toPixmap(matrix, colorspace, alpha, showExtras) #

• Matrix matrix: The transformation matrix.
• ColorSpace colorspace: The desired colorspace of the returned pixmap.
• boolean alpha: Whether the resulting pixmap should have an alpha component. Defaults to true.
• boolean showExtras: Whether to render annotations and widgets. Defaults to true.
• Returns: Pixmap

var pixmap = page.toPixmap(mupdf.Matrix.identity, mupdf.ColorSpace.DeviceRGB, true, true)

Page.prototype.toDisplayList(showExtras) #

• boolean showExtras: Whether to render annotations and widgets. Defaults to true.
• Returns: DisplayList

var displayList = page.toDisplayList(true)

Page.prototype.toStructuredText(options) #

• string options: See :doc:/reference/common/stext-options.
• Returns: StructuredText

var sText = page.toStructuredText("preserve-whitespace")

Page.prototype.search(needle, maxHits) #

• string needle: The text to search for.
• number options: Optional options for the search. A logical or of options such as StructuredText.SEARCH_EXACT.
• Returns: Array of Array of Quad

var results = page.search("my search phrase")

Page.prototype.getLinks() #

• Returns: Array of Link

var links = page.getLinks()
var link = links[0]
var linkDestination = doc.resolveLink(link)

Page.prototype.createLink(rect, uri) #

• Rect rect: Rectangle specifying the active area on the page the link should cover.
• string destinationUri: A URI string describing the desired link destination.
• Returns: Link.

// create a link to an external URL
var link = page.createLink([0, 0, 100, 50], "https://example.com")

Page.prototype.deleteLink(link) #

• Link link: The link to remove.

page.deleteLink(link_obj)

Page.prototype.getLabel() #

• Returns: string

var label = page.getLabel()

Page.prototype.isPDF() #

• Returns: boolean

var isPDF = page.isPDF()

Page.prototype.decodeBarcode(subarea, rotate) #

• Rect subarea: Only detect barcode within subarea. Defaults to the entire page.
• number rotate: Degrees of rotation to rotate page before detecting barcode. Defaults to 0.
• Returns: Object with barcode information.

var info = page.decodeBarcode(page.getBounds(), 0)

Path #

• move to point, append by calling Path.prototype.moveTo()
• close subpath, append by calling Path.prototype.closePath()
• draw a straight line, append by calling Path.prototype.lineTo()
• draw a cubic Bézier curve, append by calling either of Path.prototype.curveTo(), Path.prototype.curveToV(), or Path.prototype.curveToY()
• draw a rectangle, append by calling Path.prototype.rect(), this is a subpath on its own and is equivalent to a move to a position, followed by drawing three lines and closing the subpath.

Constructors #

Path() #

var path = new mupdf.Path()

Instance methods #

Path.prototype.closePath() #

path.closePath()

Path.prototype.curveTo(x1, y1, x2, y2, x3, y3) #

• number x1: X1 coordinate.
• number y1: Y1 coordinate.
• number x2: X2 coordinate.
• number y2: Y2 coordinate.
• number x3: X3 coordinate.
• number y3: Y3 coordinate.

path.curveTo(0, 0, 10, 10, 100, 100)

Path.prototype.curveToV(cx, cy, ex, ey) #

• number cx: CX coordinate.
• number cy: CY coordinate.
• number ex: EX coordinate.
• number ey: EY coordinate.

path.curveToV(0, 0, 100, 100)

Path.prototype.curveToY(cx, cy, ex, ey) #

• number cx: CX coordinate.
• number cy: CY coordinate.
• number ex: EX coordinate.
• number ey: EY coordinate.

path.curveToY(0, 0, 100, 100)

Path.prototype.getBounds(strokeState, transform) #

• StrokeState | null stroke: The stroking properties to use.
• Matrix transform: A transform matrix applied to all points in path.
• Returns: Rect

var rect = path.getBounds(strokeState, mupdf.Matrix.identity)

Path.prototype.lineTo(x, y) #

• number x: X coordinate.
• number y: Y coordinate.

path.lineTo(20, 20)

Path.prototype.moveTo(x, y) #

• number x: X coordinate.
• number y: Y coordinate.

path.moveTo(10, 10)

Path.prototype.rect(x1, y1, x2, y2) #

moveTo(x1, y1)
lineTo(x2, y1)
lineTo(x2, y2)
lineto(x1, y2)
closePath()

• number x1: X1 coordinate.
• number y1: Y1 coordinate.
• number x2: X2 coordinate.
• number y2: Y2 coordinate.

path.rect(0, 0, 100, 100)

Path.prototype.transform(matrix) #

• Matrix matrix: Transformation matrix to apply.

path.transform(mupdf.Matrix.scale(2, 2))

Path.prototype.walk(walker) #

• PathWalker walker: Object with callback functions.

function print(...args) {
console.log(args.join(" "))
}

PathWalker #

Constructors #

PathWalker #

closePath() #

curveTo(x1, y1, x2, y2, x3, y3) #

• number x1: X1 coordinate.
• number y1: Y1 coordinate.
• number x2: X2 coordinate.
• number y2: Y2 coordinate.
• number x3: X3 coordinate.
• number y3: Y3 coordinate.

lineTo(x, y) #

• number x: X coordinate.
• number y: Y coordinate.

moveTo(x, y) #

• number x: X coordinate.
• number y: Y coordinate.

Pixmap #

Constructors #

• ColorSpace | null colorspace: The desired colorspace for the new pixmap. null implies a single component alpha pixmap.
• Rect bbox: The desired dimensions of the new pixmap.
• boolean alpha: Whether the new pixmap should have an alpha component.
• Pixmap pixmap: The original pixmap without alpha.
• Pixmap mask: Soft mask used as alpha in the combined pixmap.

var pixmap1 = new mupdf.Pixmap(mupdf.ColorSpace.DeviceRGB, [0, 0, 100, 100], true)
var pixmap2 = new mupdf.Pixmap(
new mupdf.Image("photo.png").toPixmap(),
new mupdf.Image("softmask.png").toPixmap()
)

Instance methods #

Pixmap.prototype.clear(value) #

• number value: The value to use for clearing.

pixmap.clear(255)

Pixmap.prototype.getBounds() #

• Returns: Rect

var rect = pixmap.getBounds()

Pixmap.prototype.getWidth() #

• Returns: number

var w = pixmap.getWidth()

Pixmap.prototype.getHeight() #

• Returns: number

var h = pixmap.getHeight()

Pixmap.prototype.getNumberOfComponents() #

• Returns: number

var num = pixmap.getNumberOfComponents()

Pixmap.prototype.getAlpha() #

• Returns: boolean

var alpha = pixmap.getAlpha()

Pixmap.prototype.getStride() #

• Returns: number

var stride = pixmap.getStride()

Pixmap.prototype.getColorSpace() #

• Returns: ColorSpace | null

var cs = pixmap.getColorSpace()

Pixmap.prototype.setResolution(x, y) #

• number x: Horizontal resolution in dots per inch.
• number y: Vertical resolution in dots per inch.

pixmap.setResolution(300, 300)

Pixmap.prototype.getX() #

var x = pixmap.getX()

Pixmap.prototype.getY() #

• Returns: number

var y = pixmap.getY()

Pixmap.prototype.getXResolution() #

• Returns: number

var xRes = pixmap.getXResolution()

Pixmap.prototype.getYResolution() #

• Returns: number

var yRes = pixmap.getYResolution()

Pixmap.prototype.invert() #

pixmap.invert()

Pixmap.prototype.invertLuminance() #

pixmap.invertLuminance()

Pixmap.prototype.gamma(p) #

• number p: Desired gamma level.

pixmap.gamma(3.5)

Pixmap.prototype.tint(black, white) #

• Color | number black: Map black to this color.
• Color | number white: Map white to this color.

pixmap.tint(0xffff00, 0xffff00)

Pixmap.prototype.warp(points, width, height) #

• Quad points: The corners of a convex quadrilateral within the Pixmap to be warped.
• number width: Width of resulting pixmap.
• number height: Height of resulting pixmap.
• Returns: Pixmap

var warpedPixmap = pixmap.warp([[0, 0], [100, 100], [130, 170], [150, 200]], 200, 200)

Pixmap.prototype.autowarp(points) #

• Quad points: The corners of a convex quadrilateral within the Pixmap to be warped.
• Returns: Pixmap

var warpedPixmap = pixmap.autowarp([0,0,100,0,0,100,100,100])

Pixmap.prototype.convertToColorSpace(colorspace, keepAlpha) #

• ColorSpace colorspace: The desired colorspace.
• boolean keepAlpha: Whether to keep the alpha component.
• Returns: Pixmap

Pixmap.prototype.getPixels() #

• Returns: Array of number

var pixels = pixmap.getPixels()

Pixmap.prototype.asPNG() #

• Returns: Buffer

var buffer = pixmap.asPNG()

Pixmap.prototype.asPSD() #

• Returns: Buffer

var buffer = pixmap.asPSD()

Pixmap.prototype.asPAM() #

• Returns: Buffer

var buffer = pixmap.asPAM()

Pixmap.prototype.asJPEG(quality, invert_cmyk) #

• number quality: Desired compression quality, between 0 and 100.
• boolean invert_cmyk: How to handle polarity in :term: CMYK JPEG images.
• Returns: Buffer

var buffer = pixmap.asJPEG(80, false)

Pixmap.prototype.decodeBarcode(rotate) #

• number rotate: Degrees of rotation to rotate pixmap before detecting barcode. Defaults to 0.
• Returns: Object with barcode information.

var barcodeInfo = displayList.decodeBarcode([0, 0, 100, 100 ], 0)

Pixmap.prototype.encodeBarcode(barcodeType, contents, size, errorCorrectionLevel, quietZones, humanReadableText) #

• string barcodeType: The desired barcode type.
• string contents: The textual content to encode into the barcode.
• number size: The size of the barcode in pixels.
• number errorCorrectionLevel: The error correction level (0-8).
• boolean quietZones: Whether to add an empty margin around the barcode.
• boolean humanReadableText: Whether to add human-readable text. Some barcodes, e.g. EAN-13, can have the barcode contents printed in human-readable text next to the barcode.
• Returns: Pixmap

var pix = Pixmap.encodeBarcode("qrcode", "Hello world!", 100, 2, true, false)

Pixmap.prototype.getSample(x, y, index) #

• number x: X coordinate.
• number y: Y coordinate.
• number index: Component index. i.e. For CMYK ColorSpaces 0 = Cyan, 3 = Black, for RGB 0 = Red, 2 == Blue etc.
• Throws: RangeError if x, y, or index are out of range.
• Returns: number

// Get green component of pixel at 10, 10
var sample = rgbpixmap.getSample(10, 10, 1)

Pixmap.prototype.saveAsPNG(filename) #

• string filename: Desired name of image file.

pixmap.saveAsPNG("filename.png")

Pixmap.prototype.saveAsJPEG(filename, quality) #

• string filename: Desired name of image file.
• number quality: Desired quality between 0 and 100. Defaults to 90.

pixmap.saveAsJPEG("filename.jpg", 80)

Pixmap.prototype.saveAsPAM(filename) #

• string filename: Desired name of image file.

pixmap.saveAsPAM("filename.pam")

Pixmap.prototype.saveAsPNM(filename) #

• string filename: Desired name of image file.

pixmap.saveAsPNM("filename.pnm")

Pixmap.prototype.saveAsPBM(filename) #

• string filename: Desired name of image file.

pixmap.saveAsPBM("filename.pbm")

Pixmap.prototype.saveAsPKM(filename) #

• string filename: Desired name of image file.

pixmap.saveAsPKM("filename.pkm")

Pixmap.prototype.saveAsJPX(filename, quality) #

• string filename: Desired name of image file.
• number quality: Desired quality between 0 and 100. Defaults to 90.

pixmap.saveAsJPX("filename.jpx", 90)

Pixmap.prototype.detectDocument(points) #

• Returns: Quad | null

var documentLocation = pixmap.detectDocument([0,0,100,0,100,100,0,100])

Pixmap.prototype.detectSkew() #

• Returns: number

var angle = pixmap.detectSkew()

Pixmap.prototype.deskew(angle, border) #

• number angle: The angle to deskew.
• string border: “increase” increases the size of the pixmap so no pixels are lost. “maintain” maintains the size of the pixmap. “decrease” decreases the size of the page so no new pixels are shown.
• Returns: Pixmap

var deskewed = pixmap.deskew(angle, 0)

Pixmap.prototype.computeMD5() #

• Returns: string

var md5 = pixmap.computeMD5()

Point #

Constructors #

Point #

Static methods #

Point.transform(point, matrix) #

• Point point: Point to transform.
• Matrix matrix: Matrix describing transformation to perform.
• Returns: Point

var m = mupdf.Point.transform([100, 100], [1, 0.5, 1, 1, 1, 1])

Quad #

	type Quad = [ number, number, number, number number, number, number, number ]

Constructors #

Quad #

Static properties #

Quad.empty #

Quad.invalid #

Quad.infinite #

Static methods #

Quad.isEmpty(quad) #

• Quad quad: Rectangle to evaluate.
• Returns: boolean

var isEmpty = mupdf.Quad.isEmpty([0, 0, 0, 0]) // true
var isEmpty = mupdf.Quad.isEmpty([0, 0, 100, 100]) // false

Quad.isValid(quad) #

• Quad quad: Rectangle to evaluate.
• Returns: boolean

var isValid = mupdf.Quad.isValid([0, 0, 100, 100]) // true
var isValid = mupdf.Quad.isValid([0, 0, -100, 100]) // false

Quad.isInfinite(quad) #

• Quad quad: Rectangle to evaluate.
• Returns: boolean

var isInfinite = mupdf.Quad.isInfinite([0x80000000, 0x80000000, 0x7fffff80, 0x7fffff80]) //true
var isInfinite = mupdf.Quad.isInfinite([0, 0, 100, 100]) // false

Quad.transform(quad, matrix) #

• Quad quad: Quad to transform.
• Matrix matrix: Matrix describing transformation to perform.
• Returns: Quad

var m = mupdf.Quad.transform([0, 0, 100, 100], [1, 0.5, 1, 1, 1, 1])

Quad.isPointInside(quad, point) #

var inside = mupdf.Rect.isPointInside([0, 0, 100, 100], [50, 50])

Quad.quadFromRect(rect) #

• Rect rect:
• Returns: Quad

Rect #

	type Rect = [number, number, number, number]

Constructors #

Rect #

Static properties #

Rect.empty #

Rect.invalid #

Rect.infinite #

Static methods #

Rect.isEmpty(rect) #

• Rect rect: Rectangle to evaluate.
• Returns: boolean

var isEmpty = mupdf.Rect.isEmpty([0, 0, 0, 0]) // true
var isEmpty = mupdf.Rect.isEmpty([0, 0, 100, 100]) // false

Rect.isValid(rect) #

• Rect rect: Rectangle to evaluate.
• Returns: boolean

var isValid = mupdf.Rect.isValid([0, 0, 100, 100]) // true
var isValid = mupdf.Rect.isValid([0, 0, -100, 100]) // false

Rect.isInfinite(rect) #

• Rect rect: Rectangle to evaluate.
• Returns: boolean

var isInfinite = mupdf.Rect.isInfinite([0x80000000, 0x80000000, 0x7fffff80, 0x7fffff80]) //true
var isInfinite = mupdf.Rect.isInfinite([0, 0, 100, 100]) // false

Rect.transform(rect, matrix) #

• Rect rect: Rectangle to transform.
• Matrix matrix: Matrix describing transformation to perform.
• Returns: Rect

var m = mupdf.Rect.transform([0, 0, 100, 100], [1, 0.5, 1, 1, 1, 1])

Rect.isPointInside(rect, point) #

var inside = mupdf.Rect.isPointInside([0, 0, 100, 100], [50, 50])

Rect.rectFromQuad(quad) #

• Quad quad:
• Returns: Rect

Shade #

Shade #

Instance methods #

Shade.prototype.getBounds() #

• Returns: Rect

var bounds = shade.getBounds()

Story #

Constructors #

Story(contents, userCSS, em, archive) #

• string contents: HTML source code. If omitted, a basic minimum is generated.
• string userCSS: CSS source code. Defaults to the empty string.
• number em: The default text font size. Default to 12.
• Archive archive: An archive from which to load resources for rendering. Currently supported resource types are images and text fonts. If omitted, the Story will not try to look up any such data and may thus produce incomplete output. Defaults to null.

var story = new mupdf.Story(<contents>, <css>, <em>, <archive>)

Instance methods #

Story.prototype.document() #

• Returns: DOM

var xml = story.document()

Story.prototype.place(rect, flags) #

• 0 means that all the text was placed successfully.
• 1 means that some text was not placed due not fitting within the height of the rectangle.
• 2 means that some text was not placed due not fitting within the width of the rectangle. For this to be detected flags must be set to 1.
• Rect rect: Rectangle to place the story within.
• number flags: When set to 1, will detect when a word does not fit in the rectangle, instead more set to 2.
• Returns: { filled: Rect, more: number }

do {
var result = story.place([0, 0, 100, 100])
// TODO: create device for this bit of story
story.draw(device, mupdf.Matrix.identity)
// TODO: close device
} while (result.more)

Story.prototype.draw(device, transform) #

• Device device: The device
• Matrix transform: The transform matrix.

story.draw(device, mupdf.Matrix.identity)

StrokeState #

Constructors #

StrokeState(template) #

• “lineCap”: string: The :term:line cap style to be used. One of "Butt" | "Round" | "Square"
• “lineJoin”: string: The :term:line join style to be used. One of "Miter" | "Round" | "Bevel"
• “lineWidth”: number: The line width to be used.
• “miterLimit”: number: The :term:miter limit to be used.
• “dashPhase”: number: The dash phase to be used.
• “dashPattern”: Array of number: The sequence of dash lengths to be used.
• Object template: An object with the parameters to set.

var strokeState = new mupdf.StrokeState({
lineCap: "Square",
lineJoin: "Bevel",
lineWidth: 2.0,
miterLimit: 1.414,
dashPhase: 11,
dashPattern: [ 2, 3 ]
})

Instance methods #

StrokeState.prototype.getLineCap() #

• Returns: "Butt" | "Round" | "Square"

var lineCap = strokeState.getLineCap()

StrokeState.prototype.getLineJoin() #

• Returns: "Miter" | "Round" | "Bevel"

var lineJoin = strokeState.getLineJoin()

StrokeState.prototype.getLineWidth() #

• Returns: number

var width = strokeState.getLineWidth()

StrokeState.prototype.getMiterLimit() #

• Returns: number

var limit = strokeState.getMiterLimit()

StrokeState.prototype.getDashPhase() #

• Returns: number

var limit = strokeState.getDashPhase()

StrokeState.prototype.getDashPattern() #

• Returns: Array of number | null

var dashPattern = strokeState.getDashPattern()

StructuredText #

Constructors #

StructuredText #

Static properties #

StructuredText.SEARCH_EXACT #

StructuredText.SEARCH_IGNORE_CASE #

StructuredText.SEARCH_IGNORE_DIACRITICS #

StructuredText.SEARCH_REGEXP #

StructuredText.SEARCH_KEEP_LINES #

StructuredText.SEARCH_KEEP_PARAGRAPHS #

StructuredText.SEARCH_KEEP_HYPHENS #

Instance methods #

StructuredText.prototype.search(needle, maxHits) #

• string needle: The text to search for.
• number options: Optional options for the search. A logical or of options such as StructuredText.SEARCH_EXACT.
• Returns: Array of Array of Quad

var result = sText.search("Hello World!")

StructuredText.prototype.highlight(p, q, maxHits) #

• Point p: Start point.
• Point q: End point.
• number maxHits: The maximum number of hits to return. Default 500.
• Returns: Array of Quad

var result = sText.highlight([100, 100], [200, 100])

StructuredText.prototype.copy(p, q) #

• Point p: Start point.
• Point q: End point.
• Returns: string

var result = sText.copy([100, 100], [200, 100])

StructuredText.prototype.walk(walker) #

• StructuredTextWalker walker: Callback object.

var sText = page.toStructuredText()
sText.walk({
beginLine: function (bbox, wmode, direction) {
console.log("beginLine", bbox, wmode, direction)
},
endLine: function () {
console.log("endLine")
},
beginTextBlock: function (bbox) {
console.log("beginTextBlock", bbox)
},
endTextBlock: function () {
console.log("endTextBlock")
},
beginStruct: function (standard, raw, index) {
console.log("beginStruct", standard, raw, index)
},
endStruct: function () {
console.log("endStruct")
},
onChar: function (utf, origin, font, size, quad, argb, flags) {
console.log("onChar", utf, origin, font, size, quad, argb, flags)
},
onImageBlock: function (bbox, transform, image) {
console.log("onImageBlock", bbox, transform, image)
},
onVector: function (bbox, flags, argb) {
console.log("onVector", bbox, flags, argb)
},
})

StructuredText.prototype.asText() #

• Returns: string

StructuredText.prototype.asHTML(id) #

• number id: Used to number the “id” on the top div tag (as "page" + id).
• Returns: string

StructuredText.prototype.asJSON(scale) #

• number scale: Optional scaling factor to multiply all the coordinates by.
• Returns: string containing JSON of the following schema:

type StructuredTextPage = {
blocks: StructuredTextBlock[]
}
type StructuredTextBlock = {
type: "image" | "text",
bbox: {
x: number,
y: number,
w: number,
h: number
},
lines: StructuredTextLine[],
}
type StructuredTextLine = {
wmode: 0 | 1,	// 0=horizontal, 1=vertical
bbox: {
x: number,
y: number,
w: number,
h: number
},
font: {
name: string,
family: "serif" | "sans-serif" | "monospace",
weight: "normal" | "bold",
style: "normal" | "italic",
size: number
},
// text origin point for first character in line
x: number,
y: number,
text: string
}

var data = JSON.parse(page.toStructuredText("preserve-spans").asJSON())

StructuredTextWalker #

Constructors #

StructuredTextWalker #

beginTextBlock(bbox) #

• Rect bbox:

endTextBlock() #

beginLine(bbox, wmode, direction) #

• Rect bbox:
• number wmode:
• Point direction:

endLine() #

beginStruct(standard, raw, index) #

• string standard:
• string raw:
• number index:

endStruct() #

onChar(c, origin, font, size, quad, color, flags) #

• string c:
• Point origin:
• Font font:
• number size:
• Quad quad:
• Color color:
• number flags:

onImageBlock(bbox, transform, image) #

• Rect bbox:
• Matrix transform:
• Image image:

onVector(bbox, flags, rgb) #

• Rect bbox:
• Object flags:
• Array of number rgb:

Text #

Constructors #

Text() #

var text = new mupdf.Text()

Instance methods #

Text.prototype.getBounds(strokeState, transform) #

• StrokeState strokeState: The stroking state.
• Matrix transform: The transformation matrix.

Text.prototype.showGlyph(font, trm, gid, uni, wmode) #

• Font font: Font object.
• Matrix trm: Transformation matrix.
• number gid: Glyph id.
• number uni: Unicode codepoint.
• number wmode: 0 (default) for horizontal writing, and 1 for vertical writing.

text.showGlyph(new mupdf.Font("Times-Roman"), mupdf.Matrix.identity, 21, 0x66, 0)
text.showGlyph(new mupdf.Font("Times-Roman"), mupdf.Matrix.identity, -1, 0x69, 0)

Text.prototype.showString(font, trm, str, wmode) #

• Font font: Font object.
• Matrix trm: Transformation matrix.
• string str: Content for Text object.
• number wmode: 0 (default) for horizontal writing, and 1 for vertical writing.

text.showString(new mupdf.Font("Times-Roman"), mupdf.Matrix.identity, "Hello World")

Text.prototype.walk(walker) #

• TextWalker walker: Function with protocol methods, see example below for details.

function print(...args) {
console.log(args.join(" "))
}

TextWalker #

TextWalker #

beginSpan(font, trm, wmode, bidiLevel, markupDirection, language) #

• Font font:
• Matrix trm:
• number wmode:
• int bidiLevel:
• int markupDirection:
• string language:

endSpan() #

showGlyph(font, trm, gid, ucs, wmode, bidiLevel) #

• Font font:
• Matrix trm:
• number gid:
• number ucs:
• number wmode:
• number bidiLevel:

TreeArchive #

Constructors #

TreeArchive() #

var treeArchive = new mupdf.TreeArchive()

Instance methods #

TreeArchive.prototype.add(name, buffer) #

• string name: Name of archive entry to add.
• Buffer | ArrayBuffer | Uint8Array | string buffer: Buffer of data to store with the entry.

var buf = new mupdf.Buffer()
buf.writeLine("hello world!")
var archive = new mupdf.TreeArchive()
archive.add("file2.txt", buf)
print(archive.hasEntry("file2.txt"))

PDF #

PDFAnnotation #

Annotation Types #

An icon with a popup of text.

Set the appearance with the Icon attribute.

Attributes: `Rect`, `color-attribute`, `icon-attribute`.

Text in a rectangle on the page.

The text font and color is defined by DefaultAppearance.

Attributes: `border-attribute`, `rect-attribute`, `default-appearance-attribute`.

A line with optional arrow heads.

The line width is determined by the border attribute.

The end points are defined by the Line attribute.

Attributes: `border-attribute`, `color-attribute`, `line-attribute`, `line-ending-styles-attribute`.

A rectangle.

Attributes: `rect-attribute`, `rect-attribute`, `color-attribute`, `interior-color-attribute`.

An ellipse.

Attributes: `rect-attribute`, `border-attribute`, `color-attribute`, `interior-color-attribute`.

A polygon shape (closed and open).

The shape is defined by the Vertices attribute.

The line width is defined by the Border attribute.

Attributes: `vertices-attribute`, `border-attribute`, `color-attribute`, `interior-color-attribute`, LineEndingStyles.

Text markups.

The shape is defined by the `quadpoints-attribute`.

A rubber stamp.

The appearance is either a stock name, or a `custom image <stamp-image-attribute>`.

A free-hand line.

The shape is defined by the `inklist-attribute` attribute.

A file attachment.

The appearance is an icon on the page.

Set the attached file contents with the `filespec-attribute` attribute,
and the appearance with the `icon-attribute` attribute.

A black box.

Redaction annotations are used to mark areas of the page that
can be redacted. They do NOT redact any content by themselves,
you MUST apply them using `PDFAnnotation.prototype.applyRedaction` or
`PDFPage.prototype.applyRedactions`.

• Link
• Popup – see PDFAnnotation.prototype.setPopup()
• Widget – see PDFWidget

Constructors #

PDFAnnotation #

Instance methods #

PDFAnnotation.prototype.getBounds() #

• Returns: Rect

var bounds = annotation.getBounds()

PDFAnnotation.prototype.run(device, matrix) #

• Device device: The device to make device calls to while rendering the annotation.
• Matrix matrix: The transformation matrix.

annotation.run(device, mupdf.Matrix.identity)

PDFAnnotation.prototype.toPixmap(matrix, colorspace, alpha) #

• Matrix matrix: Transformation matrix.
• ColorSpace colorspace: The desired colorspace of the returned pixmap.
• boolean alpha: Whether the returned pixmap has transparency or not. If the pixmap handles transparency, it starts out transparent (otherwise it is filled white), before the contents of the display list are rendered onto the pixmap.
• Returns: Pixmap

var pixmap = annotation.toPixmap(mupdf.Matrix.identity, mupdf.ColorSpace.DeviceRGB, true)

PDFAnnotation.prototype.toDisplayList() #

• Returns: DisplayList

var displayList = annotation.toDisplayList()

PDFAnnotation.prototype.getObject() #

• Returns: PDFObject

var obj = annotation.getObject()

PDFAnnotation.prototype.setAppearance(appearance, state, transform, bbox, resources, contents) #

• string | null appearance: Appearance stream (“N” for normal, “R” for roll-over or “D” for down). Defaults to “N”.
• string | null state: The annotation state to set the appearance for or null for the current state. Only widget annotations of pushbutton, check box, or radio button type have states, which are “Off” or “Yes”. For other types of annotations pass null.
• Matrix transform: The transformation matrix.
• Rect bbox: The bounding box.,
• PDFObject resources: Resources object.
• Buffer | ArrayBuffer | Uint8Array | string contents: Contents string.

annotation.setAppearance(
"N",
null,
mupdf.Matrix.identity,
[0, 0, 100, 100],
resources,
contents
)

PDFAnnotation.prototype.update() #

• Returns: boolean

annotation.update()

PDFAnnotation.prototype.setAppearanceFromDisplayList(appearance, state, transform, list) #

• string appearance: Appearance stream (“N”, “R” or “D”).
• string state: The annotation state to set the appearance for or null for the current state. Only widget annotations of pushbutton, check box, or radio button type have states, which are “Off” or “Yes”. For other types of annotations pass null.
• Matrix transform: The transformation matrix.
• DisplayList list: The display list.

annotation.setAppearanceFromDisplayList(
"N",
null,
mupdf.Matrix.identity,
displayList
)

PDFAnnotation.prototype.getHiddenForEditing() #

• Returns: boolean

var hidden = annotation.getHiddenForEditing()

PDFAnnotation.prototype.setHiddenForEditing(hidden) #

• boolean hidden:

annotation.setHiddenForEditing(true)

PDFAnnotation.prototype.getHot() #

• Returns: boolean

annotation.getHot()

PDFAnnotation.prototype.setHot(hot) #

• boolean hot:

annotation.setHot(true)

PDFAnnotation.prototype.requestSynthesis() #

annotation.requestSynthesis()

PDFAnnotation.prototype.requestResynthesis() #

annotation.requestResynthesis()

PDFAnnotation.prototype.process(processor) #

• PDFProcessor processor: User defined function.

annotation.process(processor)

PDFAnnotation.prototype.applyRedaction(blackBoxes, imageMethod, lineArtMethod, textMethod) #

Annotation attributes #

Common #

PDFAnnotation.prototype.getType() #

• Returns: string

var type = annotation.getType()

PDFAnnotation.prototype.getFlags() #

• Returns: number

var flags = annotation.getFlags()

PDFAnnotation.prototype.setFlags(flags) #

• number flags: A bit mask with the flags (see below).

annotation.setFlags(4) // Clears all other flags and sets "NoZoom".

PDFAnnotation.prototype.getContents() #

• Returns: string

var contents = annotation.getContents()

PDFAnnotation.prototype.setContents(text) #

• string text:

annotation.setContents("Hello World")

PDFAnnotation.prototype.getCreationDate() #

• Returns: Date

var date = annotation.getCreationDate()

PDFAnnotation.prototype.setCreationDate(date) #

• Date date: A Date object.

annotation.setCreationDate(new Date())

PDFAnnotation.prototype.getModificationDate() #

• Returns: Date

var date = annotation.getModificationDate()

PDFAnnotation.prototype.setModificationDate(date) #

• Date date:

annotation.setModificationDate(new Date())

PDFAnnotation.prototype.getLanguage() #

• Returns: string | null

var language = annotation.getLanguage()

PDFAnnotation.prototype.setLanguage(language) #

• string language: The desired language code.

annotation.setLanguage("en")

Rect #

PDFAnnotation.prototype.hasRect() #

• Returns: boolean

var hasRect = annotation.hasRect()

PDFAnnotation.prototype.getRect() #

• Returns: Rect

var rect = annotation.getRect()

PDFAnnotation.prototype.setRect(rect) #

• Rect rect: The new desired bounding box.

annotation.setRect([0, 0, 100, 100])

Rich contents #

PDFAnnotation.prototype.hasRichContents() #

• Returns: boolean

var hasRichContents = annotation.hasRichContents()

PDFAnnotation.prototype.getRichContents() #

• Returns: string

var richContents = annotation.getRichContents()

PDFAnnotation.prototype.setRichContents(plainText, richText) #

• string plainText:
• string richText:

annotation.setRichContents("plain text", "<b><i>Rich-Text</i></b>")

PDFAnnotation.prototype.getRichDefaults() #

• Returns: string

var richDefaults = annotation.getRichDefaults()

PDFAnnotation.prototype.setRichDefaults(style) #

• string style:

annotation.setRichDefaults("font-size: 16pt")

Color #

PDFAnnotation.prototype.getColor() #

• Returns: Color

var color = annotation.getColor()

PDFAnnotation.prototype.setColor(color) #

• Color color: The new color.
• Throws: TypeError if number of components is not 0, 1, 3, or 4.

annotation.setColor([0, 1, 0])

Opacity #

PDFAnnotation.prototype.getOpacity() #

• Returns: number

var opacity = annotation.getOpacity()

PDFAnnotation.prototype.setOpacity(opacity) #

• number opacity: The desired opacity.

annotation.setOpacity(0.5)

Quadding #

PDFAnnotation.prototype.hasQuadding() #

• Returns: boolean

var hasQuadding = annotation.hasQuadding()

PDFAnnotation.prototype.getQuadding() #

• Returns: number

var quadding = annotation.getQuadding()

PDFAnnotation.prototype.setQuadding(value) #

• number value: The desired quadding.

annotation.setQuadding(1)

Author #

PDFAnnotation.prototype.hasAuthor() #

• Returns: boolean

var hasAuthor = annotation.hasAuthor()

PDFAnnotation.prototype.getAuthor() #

• Returns: string

var author = annotation.getAuthor()

PDFAnnotation.prototype.setAuthor(author) #

• string author:

annotation.setAuthor("Jane Doe")

Border #

PDFAnnotation.prototype.hasBorder() #

• Returns: boolean

var hasBorder = annotation.hasBorder()

PDFAnnotation.prototype.getBorderStyle() #

• Returns: string

var borderStyle = annotation.getBorderStyle()

PDFAnnotation.prototype.setBorderStyle(style) #

• string style: The annotation style.

annotation.setBorderStyle("Dashed")

PDFAnnotation.prototype.getBorderWidth() #

• Returns: number

var w = annotation.getBorderWidth()

PDFAnnotation.prototype.setBorderWidth(width) #

• number width:

annotation.setBorderWidth(1.5)

PDFAnnotation.prototype.getBorderDashCount() #

• Returns: number

var dashCount = annotation.getBorderDashCount()

PDFAnnotation.prototype.getBorderDashItem(idx) #

• number idx:
• Returns: number

var length = annotation.getBorderDashItem(0)

PDFAnnotation.prototype.setBorderDashPattern(list) #

• Array of number dashPattern:

annotation.setBorderDashPattern([2.0, 1.0, 4.0, 1.0])

PDFAnnotation.prototype.clearBorderDash() #

annotation.clearBorderDash()

PDFAnnotation.prototype.addBorderDashItem(length) #

• number length:

annotation.addBorderDashItem(10.0)

PDFAnnotation.prototype.hasBorderEffect() #

• Returns: boolean

var hasEffect = annotation.hasBorderEffect()

PDFAnnotation.prototype.getBorderEffect() #

• Returns: string

var effect = annotation.getBorderEffect()

PDFAnnotation.prototype.setBorderEffect(effect) #

• string effect: The border effect.

annotation.setBorderEffect("None")

PDFAnnotation.prototype.getBorderEffectIntensity() #

• Returns: number

var intensity = annotation.getBorderEffectIntensity()

PDFAnnotation.prototype.setBorderEffectIntensity(intensity) #

• number intensity: Border effect intensity.

annotation.setBorderEffectIntensity(1.5)

Callout #

PDFAnnotation.prototype.hasCallout() #

• Returns: boolean

PDFAnnotation.prototype.setCalloutLine(line) #

• Array of Point points:

PDFAnnotation.prototype.getCalloutLine() #

• Returns: Array of Point | null

PDFAnnotation.prototype.setCalloutPoint(p) #

• Point p:

PDFAnnotation.prototype.getCalloutPoint() #

• Returns: Point

PDFAnnotation.prototype.setCalloutStyle(style) #

• string style:

PDFAnnotation.prototype.getCalloutStyle() #

• Returns: string

Default Appearance #

PDFAnnotation.prototype.hasDefaultAppearance() #

• Returns: boolean

var hasRect = annotation.hasDefaultAppearance()

PDFAnnotation.prototype.getDefaultAppearance() #

• Returns: { font: string, size: number, color: Color }

var appearance = annotation.getDefaultAppearance()
console.log("DA font:", appearance.font, appearance.size)
console.log("DA color:", appearance.color)

PDFAnnotation.prototype.setDefaultAppearance(font, size, color) #

• string font: The desired default font: "Helv" | "TiRo" | "Cour" for Helvetica, Times Roman, and Courier respectively.
• number size: The desired default font size.
• Color color: The desired default font color.

annotation.setDefaultAppearance("Helv", 16, [0, 0, 0])

Filespec #

PDFAnnotation.prototype.hasFilespec() #

• Returns: boolean

var hasFilespec = annotation.hasFilespec()

PDFAnnotation.prototype.getFilespec() #

• Returns: PDFObject | null

var fs = annotation.getFilespec()

PDFAnnotation.prototype.setFilespec(fs) #

• PDFObject fs:

annotation.setFilespec(fs)

Icon #

PDFAnnotation.prototype.hasIcon() #

• Returns: boolean

var hasIcon = annotation.hasIcon()

PDFAnnotation.prototype.getIcon() #

• Returns: string

var icon = annotation.getIcon()

PDFAnnotation.prototype.setIcon(name) #

• string name: An :term: icon name.

annotation.setIcon("Note")

Ink List #

PDFAnnotation.prototype.hasInkList() #

• Returns: boolean

var hasInkList = annotation.hasInkList()

PDFAnnotation.prototype.getInkList() #

• Returns: Array of Array of Point

var inkList = annotation.getInkList()

PDFAnnotation.prototype.setInkList(inkList) #

• Array of Array of Point inkList:

// this draws a box with a cross in three strokes:
annotation.setInkList([
[
[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]
],
[
[10, 0], [0, 10]
],
[
[0, 0], [10, 10]
]
])

PDFAnnotation.prototype.clearInkList() #

annotation.clearInkList()

PDFAnnotation.prototype.addInkListStroke() #

annotation.addInkListStroke()

PDFAnnotation.prototype.addInkListStrokeVertex(v) #

• Point v:

annotation.addInkListStrokeVertex([0, 0])

Interior Color #

PDFAnnotation.prototype.hasInteriorColor() #

• Returns: boolean

var hasInteriorColor = annotation.hasInteriorColor()

PDFAnnotation.prototype.getInteriorColor() #

• Returns: Color

var interiorColor = annotation.getInteriorColor()

PDFAnnotation.prototype.setInteriorColor(color) #

• Color color: The new desired interior color.
• Throws: TypeError if number of components is not 0, 1, 3, or 4.

annotation.setInteriorColor([0, 1, 1])

Line #

PDFAnnotation.prototype.hasLine() #

• Returns: boolean

var hasLine = annotation.hasLine()

PDFAnnotation.prototype.getLine() #

• Returns: Array of Point

var line = annotation.getLine()

PDFAnnotation.prototype.setLine(a, b) #

• Point a: The new point a.
• Point b: The new point b.

annotation.setLine([100, 100], [150, 175])

Line Ending Styles #

PDFAnnotation.prototype.hasLineEndingStyles() #

• Returns: boolean

var hasLineEndingStyles = annotation.hasLineEndingStyles()

PDFAnnotation.prototype.getLineEndingStyles() #

• Returns: { start: string, end: string } Returns an object with the key/value pairs

var lineEndingStyles = annotation.getLineEndingStyles()

PDFAnnotation.prototype.setLineEndingStyles(start, end) #

• string start:
• string end:

annotation.setLineEndingStyles("Square", "OpenArrow")

Line Leaders #

PDFAnnotation.prototype.setLineLeader(v) #

• number v: The length of leader lines that extend from each endpoint of the line perpendicular to the line itself. A positive value means that the leader lines appear in the direction that is clockwise when traversing the line from its starting point to its ending point a negative value indicates the opposite direction.

PDFAnnotation.prototype.getLineLeader() #

• Returns: number

PDFAnnotation.prototype.setLineLeaderExtension(v) #

• number v: A non-negative number representing the length of leader line extensions that extend from the line proper 180 degrees from the leader lines.

PDFAnnotation.prototype.getLineLeaderExtension() #

• Returns: number

PDFAnnotation.prototype.setLineLeaderOffset(v) #

• number v: A non-negative number representing the length of the leader line offset, which is the amount of empty space between the endpoints of the annotation and the beginning of the leader lines.

PDFAnnotation.prototype.getLineLeaderOffset() #

• Returns: number

PDFAnnotation.prototype.setLineCaption(on) #

• boolean on:

PDFAnnotation.prototype.getLineCaption() #

• Returns: boolean

PDFAnnotation.prototype.setLineCaptionOffset(point) #

• Point point: A point specifying the offset of the caption text from its normal position.

PDFAnnotation.prototype.getLineCaptionOffset() #

• Returns: Point

Open #

PDFAnnotation.prototype.hasOpen() #

• Returns: boolean

var hasOpen = annotation.hasOpen()

PDFAnnotation.prototype.getIsOpen() #

• Returns: boolean

var isOpen = annotation.getIsOpen()

PDFAnnotation.prototype.setIsOpen(state) #

• boolean state:

annotation.setIsOpen(true)

Popup #

PDFAnnotation.prototype.hasPopup() #

• Returns: boolean

var hasPopup = annotation.hasPopup()

PDFAnnotation.prototype.getPopup() #

• Returns: Rect

var popupRect = annotation.getPopup()

PDFAnnotation.prototype.setPopup(rect) #

• Rect rect: The desired area where the popup should appear.

annotation.setPopup([0, 0, 100, 100])

QuadPoints #

PDFAnnotation.prototype.hasQuadPoints() #

• Returns: boolean

var hasQuadPoints = annotation.hasQuadPoints()

PDFAnnotation.prototype.getQuadPoints() #

• Returns: Array of Quad

var quadPoints = annotation.getQuadPoints()

PDFAnnotation.prototype.setQuadPoints(quadList) #

• Array of Quad quadList: The quadpoints to set.

// two quads, the first one wider than the second one
annotation.setQuadPoints([
[ 100, 100, 200, 100, 200, 150, 100, 150 ],
[ 125, 150, 175, 150, 175, 200, 125, 200 ]
])

PDFAnnotation.prototype.clearQuadPoints() #

annotation.clearQuadPoints()

PDFAnnotation.prototype.addQuadPoint(quad) #

• Quad quad: The quadpoint to add.

annotation.addQuadPoint([1, 2, 3, 4, 5, 6, 7, 8])

Vertices #

PDFAnnotation.prototype.hasVertices() #

• Returns: boolean

var hasVertices = annotation.hasVertices()

PDFAnnotation.prototype.getVertices() #

• Returns: Array of Point

var vertices = annotation.getVertices()

PDFAnnotation.prototype.setVertices(vertices) #

• Array of Point vertices:

annotation.setVertices([
[0, 0],
[10, 10],
[20, 20]
])

PDFAnnotation.prototype.clearVertices() #

annotation.clearVertices()

PDFAnnotation.prototype.addVertex(vertex) #

• Point vertex:

annotation.addVertex([0, 0])

Stamp image #

PDFAnnotation.prototype.getStampImageObject() #

• Returns: PDFObject | null

var pdfobj = annotation.getStampImageObject()

PDFAnnotation.prototype.setStampImageObject(imgobj) #

• PDFObject imgobj: PDFObject corresponding to the desired image.

annotation.setStampImageObject(imgobj)

PDFAnnotation.prototype.setStampImage(img) #

• Image img: The image to become the stamp annotations appearance.

annotation.setStampImage(img)

Intent #

PDFAnnotation.prototype.hasIntent() #

• Returns: boolean

var hasIntent = annotation.hasIntent()

PDFAnnotation.prototype.getIntent() #

• “FreeTextCallout”
• “FreeTextTypeWriter”
• “LineArrow”
• “LineDimension”
• “PolyLineDimension”
• “PolygonCloud”
• “PolygonDimension”
• “StampImage”
• “StampSnapshot”
• Returns: string

var intent = annotation.getIntent()

PDFAnnotation.prototype.setIntent(intent) #

• string intent: Intent value, see getIntent() for permissible values.

annotation.setIntent("LineArrow")

Events #

PDFAnnotation.prototype.eventEnter() #

annot.eventEnter()

PDFAnnotation.prototype.eventExit() #

annot.eventExit()

PDFAnnotation.prototype.eventDown() #

widget.eventDown()

PDFAnnotation.prototype.eventUp() #

widget.eventUp()

PDFAnnotation.prototype.eventFocus() #

widget.eventFocus()

PDFAnnotation.prototype.eventBlur() #

widget.eventBlur()

PDFDocument #

PDF Objects #

PDFObjects are always bound to the document that created them. Do
**NOT** mix and match objects from one document with another
document!

Constructors #

PDFDocument() #

Static methods #

PDFDocument.formatURIFromPathAndDest(path, destination) #

• string path: An absolute or relative path to a remote document file.
• Link | string destination: Link or string referring to a destination using either a destination object or a destination name in the remote document.

PDFDocument.appendDestToURI(uri, destination) #

• string uri: An URI to a remote document file.
• Link | string | number destination: A Link or string referring to a destination using either a destination object or a destination name in the remote document, or a page number.

Instance methods #

PDFDocument.prototype.needsPassword() #

• Returns: boolean

var needsPassword = document.needsPassword()

PDFDocument.prototype.authenticatePassword(password) #

• string password: The password to attempt authentication with.
• Returns: number

var auth = document.authenticatePassword("abracadabra")

PDFDocument.prototype.hasPermission(permission) #

• string permission: The permission to seek for, e.g. “edit”.
• Returns: boolean

var canEdit = document.hasPermission("edit")

PDFDocument.prototype.getVersion() #

• Returns: number

var version = pdfDocument.getVersion()

PDFDocument.prototype.setLanguage(lang) #

• string lang:

pdfDocument.setLanguage("en")

PDFDocument.prototype.getLanguage() #

• Returns: string | null

var lang = pdfDocument.getLanguage()

PDFDocument.prototype.wasPureXFA() #

• Returns: boolean

var wasPureXFA = pdfDocument.wasPureXFA()

PDFDocument.prototype.wasRepaired() #

• Returns: boolean

var wasRepaired = pdfDocument.wasRepaired()

PDFDocument.prototype.loadNameTree(treeName) #

• Returns: Object

var dests = pdfDocument.loadNameTree("Dests")
for (var p in dests) {
console.log("Destination: " + p)
}

Objects #

PDFDocument.prototype.newNull() #

• Returns: PDFObject

var obj = doc.newNull()

PDFDocument.prototype.newBoolean(v) #

• boolean v:
• Returns: PDFObject

var obj = doc.newBoolean(true)

PDFDocument.prototype.newInteger(v) #

• number v:
• Returns: PDFObject

var obj = doc.newInteger(1)

PDFDocument.prototype.newReal(v) #

• number v:
• Returns: PDFObject

var obj = doc.newReal(7.3)

PDFDocument.prototype.newString(v) #

• string v:
• Returns: PDFObject

var obj = doc.newString("hello")

PDFDocument.prototype.newByteString(v) #

• Uint8Array | Array of number v:
• Returns: PDFObject

var obj = doc.newByteString([21, 31])

PDFDocument.prototype.newName(v) #

• string v:
• Returns: PDFObject

var obj = doc.newName("hello")

PDFDocument.prototype.newIndirect(objectNumber, generation) #

• number objectNumber:
• number generation:
• Returns: PDFObject

var obj = doc.newIndirect(42, 0)

PDFDocument.prototype.newArray() #

• Returns: PDFObject

var obj = doc.newArray()

PDFDocument.prototype.newDictionary() #

• Returns: PDFObject

var obj = doc.newDictionary()

Indirect objects #

PDFDocument.prototype.getTrailer() #

• Returns: PDFObject

var dict = doc.getTrailer()

PDFDocument.prototype.countObjects() #

• Returns: number

var num = doc.countObjects()

PDFDocument.prototype.createObject() #

• Returns: PDFObject

var obj = doc.createObject()

PDFDocument.prototype.deleteObject(num) #

• PDFObject | number num: Delete the referenced object number.

doc.deleteObject(obj)

PDFDocument.prototype.addObject(obj) #

• PDFObject obj: Object to add.
• Returns: PDFObject

var ref = doc.addObject(obj)

PDFDocument.prototype.addStream(buf, obj) #

• Buffer | ArrayBuffer | Uint8Array | string buf: Buffer whose data to put into stream.
• PDFObject obj: The object to add the stream to.
• Returns: PDFObject

var stream = doc.addStream(buffer, object)

PDFDocument.prototype.addRawStream(buf, obj) #

• Buffer | ArrayBuffer | Uint8Array | string buf: Buffer whose data to put into stream.
• PDFObject obj: The object to add the stream to.
• Returns: PDFObject

var stream = doc.addRawStream(buffer, object)

Page Tree #

PDFDocument.prototype.setPageTreeCache(enabled) #

• boolean enabled:

PDFDocument.protoype.findPage(number) #

• number number: The page number, the first page is number zero.
• Throws: Error on out of range page numbers.
• Returns: PDFObject

var obj = pdfDocument.findPage(0)

PDFDocument.prototype.findPageNumber(page) #

• PDFPage page:
• Returns: number

var pageNumber = pdfDocument.findPageNumber(page)

PDFDocument.prototype.lookupDest(obj) #

• PDFObject obj:
• Returns: PDFObject | null

var destination = pdfDocument.lookupDest(nameobj)

PDFDocument.prototype.rearrangePages(pages) #

• Array of number pages: An array of page numbers, each page number is 0-based.

var document = new Document.openDocument("my_pdf.pdf")
pdfDocument.rearrangePages([3,2])
pdfDocument.save("fewer_pages.pdf", "garbage")

PDFDocument.prototype.insertPage(at, page) #

• number at: The index to insert at.
• PDFObject page: The PDFObject representing the page to insert.

pdfDocument.insertPage(-1, page)

PDFDocument.prototype.deletePage(index) #

• number index: The page number, the first page is number zero.

pdfDocument.deletePage(0)

PDFDocument.prototype.addPage(mediabox, rotate, resources, contents) #

• Rect mediabox: Describes the dimensions of the page.
• number rotate: Rotation value.
• PDFObject resources: Resources dictionary object.
• Buffer | ArrayBuffer | Uint8Array | string contents: Contents string. This represents the page content stream.
• Returns: PDFObject

var helvetica = pdfDocument.addSimpleFont(new mupdf.Font("Helvetica"), "Latin")
var fonts = pdfDocument.newDictionary()
fonts.put("F1", helvetica)
var resources = pdfDocument.addObject(pdfDocument.newDictionary())
resources.put("Font", fonts)
var pageObject = pdfDocument.addPage(
[0,0,300,350],
0,
resources,
"BT /F1 12 Tf 100 100 Td (Hello, world!) Tj ET"
)
pdfDocument.insertPage(-1, pageObject)

Resources #

PDFDocument.prototype.addSimpleFont(font, encoding) #

• Font font:
• “Latin” | “Greek” | “Cyrillic” encoding: Which 8-bit encoding to use. Defaults to “Latin”.

• Returns: PDFObject

var obj = pdfDocument.addSimpleFont(new mupdf.Font("Times-Roman"), "Latin")

PDFDocument.prototype.addCJKFont(font, language, wmode, style) #

• Font font:
• string language:
• number wmode: 0 for horizontal writing, and 1 for vertical writing.
• string style:
• Returns: PDFObject

var obj = pdfDocument.addCJKFont(new mupdf.Font("ja"), "ja", 0, "serif")

PDFDocument.prototype.addFont(font) #

• Font font:
• Returns: PDFObject

var obj = pdfDocument.addFont(new mupdf.Font("Times-Roman"))

PDFDocument.prototype.addImage(image) #

• Image image:
• Returns: PDFObject

var obj = pdfDocument.addImage(new mupdf.Image(pixmap))

PDFDocument.prototype.loadImage(obj) #

• PDFObject obj:
• Returns: Image

var image = pdfDocument.loadImage(obj)

Embedded/Associated files #

PDFDocument.protoype.addEmbeddedFile(filename, mimetype, contents, creationDate, modificationDate, addChecksum) #

• string filename:
• string mimetype: The :term: MIME-type.
• Buffer | ArrayBuffer | Uint8Array | string contents:
• Date creationDate:
• Date modificationDate:
• boolean addChecksum: Defaults to false.
• Returns: PDFObject

var fileSpecObject = pdfDocument.addEmbeddedFile(
"my_file.jpg",
 "image/jpeg",
 buffer,
 new Date(),
 new Date(),
 false
)

PDFDocument.prototype.getEmbeddedFiles() #

• Returns: Record

PDFDocument.prototype.deleteEmbeddedFile(filename) #

• string filename: Name of embedded file to delete.

doc.deleteEmbeddedFile("test.txt")

PDFDocument.prototype.insertEmbeddedFile(filename, fileSpecObject) #

• string filename: Name of the file to insert.
• PDFObject fileSpecObject: :term: File specification.

pdfDocument.insertEmbeddedFile("test.txt", fileSpecObject)
pdfDocument.deleteEmbeddedFile("test.txt")

PDFDocument.prototype.getFilespecParams(fileSpecObject) #

• PDFObject fileSpecObject: :term: file specification object.
• Returns: PDFFilespecParams

var obj = pdfDocument.getFilespecParams(fileSpecObject)

PDFDocument.prototype.getEmbeddedFileContents(fileSpecObject) #

• Object fileSpecObject: :term: file specification
• Returns: Buffer | null

var buffer = pdfDocument.getEmbeddedFileContents(fileSpecObject)

PDFDocument.prototype.verifyEmbeddedFileChecksum(fileSpecObject) #

• Object fileSpecObject: :term: file specification.
• Returns: boolean

var fileChecksumValid = pdfDocument.verifyEmbeddedFileChecksum(fileSpecObject)

PDFDocument.prototype.isFilespec(object) #

• PDFObject object:
• Returns: boolean

var isFilespec = pdfDocument.isFilespec(obj)

PDFDocument.prototype.isEmbeddedFile(object) #

• PDFObject object:
• Returns: boolean

var isFilespecObject = pdfDocument.isEmbeddedFile(obj)

PDFDocument.prototype.countAssociatedFiles() #

• Returns: number

var count = pdfDocument.countAssociatedFiles()

PDFDocument.prototype.associatedFile(n) #

• Returns: PDFObject | null

var obj = pdfDocument.associatedFile(0)

Grafting #

PDFDocument.prototype.newGraftMap() #

• Returns: PDFGraftMap

var graftMap = doc.newGraftMap()

PDFDocument.prototype.graftObject(obj) #

• PDFObject obj: The object to graft.
• Returns: PDFObject

var copiedObj = doc.graftObject(obj)

PDFDocument.prototype.graftPage(to, srcDoc, srcPage) #

• number to: The page number to insert the page before. Page numbers start at 0 and -1 means at the end of the document.
• PDFDocument srcDoc: Source document.
• number srcPage: Source page number.

doc.graftPage(-1, srcDoc, 0)

Journalling #

PDFDocument.prototype.enableJournal() #

pdfDocument.enableJournal()

PDFDocument.prototype.getJournal() #

• Returns: Object

var journal = pdfDocument.getJournal()

PDFDocument.prototype.beginOperation(op) #

• string op: The name of the operation.

pdfDocument.beginOperation("Change annotation color")
// Change the annotation
pdfDocument.endOperation()

PDFDocument.prototype.beginImplicitOperation() #

pdfDocument.beginOperation("Complex operation")
pdfDocument.beginImplicitOperation()
pdfDocument.endOperation()
pdfDocument.beginImplicitOperation()
pdfDocument.endOperation()
pdfDocument.endOperation()

PDFDocument.prototype.endOperation() #

pdfDocument.endOperation()

PDFDocument.prototype.abandonOperation() #

pdfDocument.abandonOperation()

PDFDocument.prototype.canUndo() #

• Returns: boolean

var canUndo = pdfDocument.canUndo()

PDFDocument.prototype.canRedo() #

• Returns: boolean

var canRedo = pdfDocument.canRedo()

PDFDocument.prototype.undo() #

pdfDocument.undo()

PDFDocument.prototype.redo() #

pdfDocument.redo()

PDFDocument.prototype.saveJournal(filename) #

• string filename: File to save the journal to.

pdfDocument.saveJournal("test.journal")

Layers #

PDFDocument.prototype.countLayerConfigs() #

• Returns: number

var configs = pdfDocument.countLayerConfigs()

PDFDocument.prototype.getLayerConfigName(n) #

• Returns: string

var name = pdfDocument.getLayerConfigName(0)

PDFDocument.prototype.getLayerConfigInfo(n) #

• Returns: string

var creator = pdfDocument.getLayerConfigCreator(0)

PDFDocument.prototype.selectLayerConfig(n) #

var info = pdfDocument.selectLayerConfig(1)

PDFDocument.prototype.countLayerConfigUIs() #

• Returns: number

PDFDocument.prototype.getLayerConfigUIInfo(n) #

• Returns: { type: number, depth: number, selected: boolean, locked: boolean, text: string }

PDFDocument.prototype.countLayers() #

• Returns: number

var layers = pdfDocument.countLayers()

PDFDocument.prototype.isLayerVisible(n) #

• number n: What layer to check visibility of.
• Returns: boolean

var visible = pdfDocument.isLayerVisible(1)

PDFDocument.prototype.setLayerVisible(n, visible) #

• number n: What layer to change visibility for.
• boolean visible: Whether the layer should be visible.
• Returns: number

pdfDocument.setLayerVisible(1, true)

getLayerName(n) #

• Returns: string

var name = pdfDocument.getLayerName(0)

Page Labels #

PDFDocument.prototype.setPageLabels(index, style, prefix, start) #

• number index: The start page index to start labeling from.
• string style: Can be one of the following strings: “” (none), “D” (decimal), “R” (roman numerals upper-case), “r” (roman numerals lower-case), “A” (alpha upper-case), or “a” (alpha lower-case).
• string prefix: Define a prefix for the labels.
• number start: The ordinal with which to start numbering.

doc.setPageLabels(0, "D", "Prefix", 1)

PDFDocument.prototype.deletePageLabels(index) #

• number index:

doc.deletePageLabels(0)

Saving #

PDFDocument.prototype.check() #

PDFDocument.prototype.canBeSavedIncrementally() #

• Returns: boolean

var canBeSavedIncrementally = pdfDocument.canBeSavedIncrementally()

PDFDocument.prototype.saveToBuffer(options) #

• string options: See :doc: /reference/common/pdf-write-options.
• Returns: Buffer

var buffer = doc.saveToBuffer("garbage=2,compress=yes")

PDFDocument.prototype.save(filename, options) #

• string filename:
• string options: See :doc: /reference/common/pdf-write-options

doc.save("out.pdf", "incremental")

PDFDocument.prototype.countVersions() #

• Returns: number

var versionNum = pdfDocument.countVersions()

PDFDocument.prototype.hasUnsavedChanges() #

• Returns: boolean

var hasUnsavedChanges = pdfDocument.hasUnsavedChanges()

PDFDocument.prototype.countUnsavedVersions() #

• Returns: number

var unsavedVersionNum = pdfDocument.countUnsavedVersions()

PDFDocument.prototype.validateChangeHistory() #

• Returns: number

var changeHistory = pdfDocument.validateChangeHistory()

Processing #

PDFDocument.prototype.subsetFonts() #

pdfDocument.subsetFonts()

PDFDocument.prototype.bake(bakeAnnots, bakeWidgets) #

• boolean bakeAnnots: Whether to bake annotations or not. Defaults to true.
• boolean bakeWidgets: Whether to bake widgets or not. Defaults to true.

AcroForm Javascript #

PDFDocument.prototype.enableJS() #

pdfDocument.enableJS()

PDFDocument.prototype.disableJS() #

pdfDocument.disableJS()

PDFDocument.prototype.isJSSupported() #

• Returns: boolean

var jsIsSupported = pdfDocument.isJSSupported()

PDFDocument.prototype.setJSEventListener(listener) #

• Object listener: The Javascript listener function.

pdfDocument.setJSEventListener({
onAlert: function(message) {
print(message)
}
})

ZUGFeRD #

PDFDocument.prototype.zugferdProfile() #

• Returns: string

var profile = pdfDocument.zugferdProfile()

PDFDocument.prototype.zugferdVersion() #

• Returns: number

var version = pdfDocument.zugferdVersion()

PDFDocument.prototype.zugferdXML() #

• Returns: Buffer | null

var buf = pdfDocument.zugferdXML()

PDFFilespecParams #

The name of the file.

The MIME type for an embedded file.

The size in bytes of the embedded file contents.

The creation date of the embedded file.

The modification date of the embedded file.

PDFGraftMap #

Constructors #

PDFGraftMap #

Instance methods #

PDFGraftMap.prototype.graftObject(obj) #

• PDFObject object: The object to graft.
• Returns: PDFObject

var map = document.newGraftMap()
map.graftObject(obj)

PDFGraftMap.prototype.graftPage(to, srcDoc, srcPage) #

• number to: The page number to insert the page before.
• PDFDocument srcDoc: Source document.
• number srcPage: Source page number.

var map = dstdoc.newGraftMap()
map.graftObject(-1, srcdoc, 0)

PDFObject #

`null`, `true`, `false`, and numbers are translated directly.

Strings are translated to PDF names, unless they are surrounded by
parentheses: `"Foo"` becomes the `/Foo` and `"(Foo)"` becomes
`(Foo)`.

Arrays and dictionaries are recursively translated to PDF arrays and dictionaries.
Be aware of cycles though! The translation does NOT cope with cyclic references!

Constructors #

PDFObject #

Instance properties #

PDFObject.prototype.length #

PDFObject.prototype.[n] #

• Throws: Error on out of bounds accesses.

var pdfObject = pdfDocument.newArray()
pdfObject[0] = "hello"
pdfObject[1] = "world"

PDFObject.prototype.[name] #

var pages = doc.getTrailer().Root.Pages
pages.Hello = "world"
pages["Xyzzy"] = 42
delete pages["Hello"]
delete pages.Xyzzy

Instance methods #

PDFObject.prototype.get(…path) #

• Array …path: The path.
• Returns: PDFObject | null

var dict = pdfDocument.newDictionary()
var value = dict.get("my_key")
var arr = pdfDocument.newArray()
var value = arr.get(1)
var page7 = pdfDocument.getTrailer().get("Root", "Pages", "Kids", 7)

PDFObject.prototype.getInheritable(key) #

• PDFObject | string key:
• Returns: PDFObject | null

var page = pdfDocument.loadPage(0)
var pageObj = page.getObject()
var rotate = pageObj.getInheritable("Rotate")

PDFObject.prototype.put(key, value) #

• PDFObject | string | number key: Interpreted as an index for arrays or a key string for dictionaries.
• PDFObject | Array | string | number | boolean | null value: The value to set at the array index or for dictionary key.

var dict = pdfDocument.newDictionary()
dict.put("my_key", "my_value")
var arr = pdfDocument.newArray()
arr.put(0, 42)

PDFObject.prototype.delete(key) #

• number | string | PDFObject key:

var dict = pdfDocument.newDictionary()
dict.put("my_key", "my_value")
dict.delete("my_key")
var arr = pdfDocument.newArray()
arr.put(1, 42)
arr.delete(1)

PDFObject.prototype.resolve() #

• Returns: PDFObject

var resolvedObj = obj.resolve()

PDFObject.prototype.isArray() #

• Returns: boolean

var result = obj.isArray()

PDFObject.prototype.isDictionary() #

• Returns: boolean

var result = obj.isDictionary()

PDFObject.prototype.forEach(callback) #

• callback: “(val: PDFObject, key: number | string, self: PDFObject) => void”

obj.forEach(function (value, key) {
console.log("value="+value+",key="+key)
})

PDFObject.prototype.push(item) #

• PDFObject item:

obj.push("item")

PDFObject.prototype.toString(tight, ascii) #

• boolean tight: Whether to print the object as tightly as possible, or as human-readably as possible.
• boolean ascii: Whether to print binary data as ascii or as binary data.
• Returns: string

var str = obj.toString()

PDFObject.prototype.valueOf() #

• Returns: A Javascript value or this.

var val = obj.valueOf()

PDFObject.prototype.compare(other_obj) #

• PDFObject other:
• Returns: number

var match = pdfObj.compare(other_obj)

Streams #

PDFObject.prototype.isStream() #

• Returns: boolean

var val = obj.isStream()

PDFObject.prototype.readStream() #

• Returns: Buffer

var buffer = obj.readStream()

PDFObject.prototype.readRawStream() #

• Returns: Buffer

var buffer = obj.readRawStream()

PDFObject.prototype.writeObject(obj) #

• PDFObject obj:

obj.writeObject(obj)

PDFObject.prototype.writeStream(buf) #

• Buffer | ArrayBuffer | Uint8Array buf:

obj.writeStream(buffer)

PDFObject.prototype.writeRawStream(buf) #

• Buffer | ArrayBuffer | Uint8Array buf:

obj.writeRawStream(buffer)

Primitive Objects #

PDFObject.prototype.isNull() #

• Returns: boolean

var val = obj.isNull()

PDFObject.prototype.isBoolean() #

• Returns: boolean

var val = obj.isBoolean()

PDFObject.prototype.asBoolean() #

• Returns: boolean

var val = obj.asBoolean()

PDFObject.prototype.isInteger() #

• Returns: boolean

var val = obj.isInteger()

PDFObject.prototype.isReal() #

• Returns: boolean

var val = pdfObj.isReal()

PDFObject.prototype.isNumber() #

• Returns: boolean

var val = obj.isNumber()

PDFObject.prototype.asNumber() #

• Returns: number

var val = obj.asNumber()

PDFObject.prototype.isName() #

• Returns: boolean

var val = obj.isName()

PDFObject.prototype.asName() #

• Returns: string

var val = obj.asName()

PDFObject.prototype.isString() #

• Returns: boolean