Spaces:
Running
Running
Download 731ai/node_modules/pdf-lib/ts3.4/cjs/api/PDFDocument.d.ts from u11310019/interactive-multi-web: direct link, hf CLI and curl.
- Browser
- Download file 33.6 kB
-
https://huggingface.co/spaces/u11310019/interactive-multi-web/resolve/main/731ai/node_modules/pdf-lib/ts3.4/cjs/api/PDFDocument.d.ts
- Command line
-
hf download hf://spaces/u11310019/interactive-multi-web/731ai/node_modules/pdf-lib/ts3.4/cjs/api/PDFDocument.d.ts
-
curl -L -o PDFDocument.d.ts https://huggingface.co/spaces/u11310019/interactive-multi-web/resolve/main/731ai/node_modules/pdf-lib/ts3.4/cjs/api/PDFDocument.d.ts
33.6 kB
| import PDFEmbeddedPage from "./PDFEmbeddedPage"; | |
| import PDFFont from "./PDFFont"; | |
| import PDFImage from "./PDFImage"; | |
| import PDFPage from "./PDFPage"; | |
| import PDFForm from "./form/PDFForm"; | |
| import { StandardFonts } from "./StandardFonts"; | |
| import { PageBoundingBox, PDFCatalog, PDFContext } from "../core"; | |
| import { AttachmentOptions, SaveOptions, Base64SaveOptions, LoadOptions, CreateOptions, EmbedFontOptions, SetTitleOptions } from "./PDFDocumentOptions"; | |
| import PDFRef from "../core/objects/PDFRef"; | |
| import { Fontkit } from "../types/fontkit"; | |
| import { TransformationMatrix } from "../types/matrix"; | |
| /** | |
| * Represents a PDF document. | |
| */ | |
| export default class PDFDocument { | |
| /** | |
| * Load an existing [[PDFDocument]]. The input data can be provided in | |
| * multiple formats: | |
| * | |
| * | Type | Contents | | |
| * | ------------- | ------------------------------------------------------ | | |
| * | `string` | A base64 encoded string (or data URI) containing a PDF | | |
| * | `Uint8Array` | The raw bytes of a PDF | | |
| * | `ArrayBuffer` | The raw bytes of a PDF | | |
| * | |
| * For example: | |
| * ```js | |
| * import { PDFDocument } from 'pdf-lib' | |
| * | |
| * // pdf=string | |
| * const base64 = | |
| * 'JVBERi0xLjcKJYGBgYEKCjUgMCBvYmoKPDwKL0ZpbHRlciAvRmxhdGVEZWNvZGUKL0xlbm' + | |
| * 'd0aCAxMDQKPj4Kc3RyZWFtCniccwrhMlAAwaJ0Ln2P1Jyy1JLM5ERdc0MjCwUjE4WQNC4Q' + | |
| * '6cNlCFZkqGCqYGSqEJLLZWNuYGZiZmbkYuZsZmlmZGRgZmluDCQNzc3NTM2NzdzMXMxMjQ' + | |
| * 'ztFEKyuEK0uFxDuAAOERdVCmVuZHN0cmVhbQplbmRvYmoKCjYgMCBvYmoKPDwKL0ZpbHRl' + | |
| * 'ciAvRmxhdGVEZWNvZGUKL1R5cGUgL09ialN0bQovTiA0Ci9GaXJzdCAyMAovTGVuZ3RoID' + | |
| * 'IxNQo+PgpzdHJlYW0KeJxVj9GqwjAMhu/zFHkBzTo3nCCCiiKIHPEICuJF3cKoSCu2E8/b' + | |
| * '20wPIr1p8v9/8kVhgilmGfawX2CGaVrgcAi0/bsy0lrX7IGWpvJ4iJYEN3gEmrrGBlQwGs' + | |
| * 'HHO9VBX1wNrxAqMX87RBD5xpJuddqwd82tjAHxzV1U5LPgy52DKXWnr1Lheg+j/c/pzGVr' + | |
| * 'iqV0VlwZPXGPCJjElw/ybkwUmeoWgxesDXGhHJC/D/iikp1Av80ptKU0FdBEe25pPihAM1' + | |
| * 'u6ytgaaWfs2Hrz35CJT1+EWmAKZW5kc3RyZWFtCmVuZG9iagoKNyAwIG9iago8PAovU2l6' + | |
| * 'ZSA4Ci9Sb290IDIgMCBSCi9GaWx0ZXIgL0ZsYXRlRGVjb2RlCi9UeXBlIC9YUmVmCi9MZW' + | |
| * '5ndGggMzgKL1cgWyAxIDIgMiBdCi9JbmRleCBbIDAgOCBdCj4+CnN0cmVhbQp4nBXEwREA' + | |
| * 'EBAEsCwz3vrvRmOOyyOoGhZdutHN2MT55fIAVocD+AplbmRzdHJlYW0KZW5kb2JqCgpzdG' + | |
| * 'FydHhyZWYKNTEwCiUlRU9G' | |
| * | |
| * const dataUri = 'data:application/pdf;base64,' + base64 | |
| * | |
| * const pdfDoc1 = await PDFDocument.load(base64) | |
| * const pdfDoc2 = await PDFDocument.load(dataUri) | |
| * | |
| * // pdf=Uint8Array | |
| * import fs from 'fs' | |
| * const uint8Array = fs.readFileSync('with_update_sections.pdf') | |
| * const pdfDoc3 = await PDFDocument.load(uint8Array) | |
| * | |
| * // pdf=ArrayBuffer | |
| * const url = 'https://pdf-lib.js.org/assets/with_update_sections.pdf' | |
| * const arrayBuffer = await fetch(url).then(res => res.arrayBuffer()) | |
| * const pdfDoc4 = await PDFDocument.load(arrayBuffer) | |
| * | |
| * ``` | |
| * | |
| * @param pdf The input data containing a PDF document. | |
| * @param options The options to be used when loading the document. | |
| * @returns Resolves with a document loaded from the input. | |
| */ | |
| static load(pdf: string | Uint8Array | ArrayBuffer, options?: LoadOptions): Promise<PDFDocument>; | |
| /** | |
| * Create a new [[PDFDocument]]. | |
| * @returns Resolves with the newly created document. | |
| */ | |
| static create(options?: CreateOptions): Promise<PDFDocument>; | |
| /** The low-level context of this document. */ | |
| readonly context: PDFContext; | |
| /** The catalog of this document. */ | |
| readonly catalog: PDFCatalog; | |
| /** Whether or not this document is encrypted. */ | |
| readonly isEncrypted: boolean; | |
| /** The default word breaks used in PDFPage.drawText */ | |
| defaultWordBreaks: string[]; | |
| private fontkit?; | |
| private pageCount; | |
| private readonly pageCache; | |
| private readonly pageMap; | |
| private readonly formCache; | |
| private readonly fonts; | |
| private readonly images; | |
| private readonly embeddedPages; | |
| private readonly embeddedFiles; | |
| private readonly javaScripts; | |
| private constructor(); | |
| /** | |
| * Register a fontkit instance. This must be done before custom fonts can | |
| * be embedded. See [here](https://github.com/Hopding/pdf-lib/tree/master#fontkit-installation) | |
| * for instructions on how to install and register a fontkit instance. | |
| * | |
| * > You do **not** need to call this method to embed standard fonts. | |
| * | |
| * For example: | |
| * ```js | |
| * import { PDFDocument } from 'pdf-lib' | |
| * import fontkit from '@pdf-lib/fontkit' | |
| * | |
| * const pdfDoc = await PDFDocument.create() | |
| * pdfDoc.registerFontkit(fontkit) | |
| * ``` | |
| * | |
| * @param fontkit The fontkit instance to be registered. | |
| */ | |
| registerFontkit(fontkit: Fontkit): void; | |
| /** | |
| * Get the [[PDFForm]] containing all interactive fields for this document. | |
| * For example: | |
| * ```js | |
| * const form = pdfDoc.getForm() | |
| * const fields = form.getFields() | |
| * fields.forEach(field => { | |
| * const type = field.constructor.name | |
| * const name = field.getName() | |
| * console.log(`${type}: ${name}`) | |
| * }) | |
| * ``` | |
| * @returns The form for this document. | |
| */ | |
| getForm(): PDFForm; | |
| /** | |
| * Get this document's title metadata. The title appears in the | |
| * "Document Properties" section of most PDF readers. For example: | |
| * ```js | |
| * const title = pdfDoc.getTitle() | |
| * ``` | |
| * @returns A string containing the title of this document, if it has one. | |
| */ | |
| getTitle(): string | undefined; | |
| /** | |
| * Get this document's author metadata. The author appears in the | |
| * "Document Properties" section of most PDF readers. For example: | |
| * ```js | |
| * const author = pdfDoc.getAuthor() | |
| * ``` | |
| * @returns A string containing the author of this document, if it has one. | |
| */ | |
| getAuthor(): string | undefined; | |
| /** | |
| * Get this document's subject metadata. The subject appears in the | |
| * "Document Properties" section of most PDF readers. For example: | |
| * ```js | |
| * const subject = pdfDoc.getSubject() | |
| * ``` | |
| * @returns A string containing the subject of this document, if it has one. | |
| */ | |
| getSubject(): string | undefined; | |
| /** | |
| * Get this document's keywords metadata. The keywords appear in the | |
| * "Document Properties" section of most PDF readers. For example: | |
| * ```js | |
| * const keywords = pdfDoc.getKeywords() | |
| * ``` | |
| * @returns A string containing the keywords of this document, if it has any. | |
| */ | |
| getKeywords(): string | undefined; | |
| /** | |
| * Get this document's creator metadata. The creator appears in the | |
| * "Document Properties" section of most PDF readers. For example: | |
| * ```js | |
| * const creator = pdfDoc.getCreator() | |
| * ``` | |
| * @returns A string containing the creator of this document, if it has one. | |
| */ | |
| getCreator(): string | undefined; | |
| /** | |
| * Get this document's producer metadata. The producer appears in the | |
| * "Document Properties" section of most PDF readers. For example: | |
| * ```js | |
| * const producer = pdfDoc.getProducer() | |
| * ``` | |
| * @returns A string containing the producer of this document, if it has one. | |
| */ | |
| getProducer(): string | undefined; | |
| /** | |
| * Get this document's creation date metadata. The creation date appears in | |
| * the "Document Properties" section of most PDF readers. For example: | |
| * ```js | |
| * const creationDate = pdfDoc.getCreationDate() | |
| * ``` | |
| * @returns A Date containing the creation date of this document, | |
| * if it has one. | |
| */ | |
| getCreationDate(): Date | undefined; | |
| /** | |
| * Get this document's modification date metadata. The modification date | |
| * appears in the "Document Properties" section of most PDF readers. | |
| * For example: | |
| * ```js | |
| * const modification = pdfDoc.getModificationDate() | |
| * ``` | |
| * @returns A Date containing the modification date of this document, | |
| * if it has one. | |
| */ | |
| getModificationDate(): Date | undefined; | |
| /** | |
| * Set this document's title metadata. The title will appear in the | |
| * "Document Properties" section of most PDF readers. For example: | |
| * ```js | |
| * pdfDoc.setTitle('🥚 The Life of an Egg 🍳') | |
| * ``` | |
| * | |
| * To display the title in the window's title bar, set the | |
| * `showInWindowTitleBar` option to `true` (works for _most_ PDF readers). | |
| * For example: | |
| * ```js | |
| * pdfDoc.setTitle('🥚 The Life of an Egg 🍳', { showInWindowTitleBar: true }) | |
| * ``` | |
| * | |
| * @param title The title of this document. | |
| * @param options The options to be used when setting the title. | |
| */ | |
| setTitle(title: string, options?: SetTitleOptions): void; | |
| /** | |
| * Set this document's author metadata. The author will appear in the | |
| * "Document Properties" section of most PDF readers. For example: | |
| * ```js | |
| * pdfDoc.setAuthor('Humpty Dumpty') | |
| * ``` | |
| * @param author The author of this document. | |
| */ | |
| setAuthor(author: string): void; | |
| /** | |
| * Set this document's subject metadata. The subject will appear in the | |
| * "Document Properties" section of most PDF readers. For example: | |
| * ```js | |
| * pdfDoc.setSubject('📘 An Epic Tale of Woe 📖') | |
| * ``` | |
| * @param subject The subject of this document. | |
| */ | |
| setSubject(subject: string): void; | |
| /** | |
| * Set this document's keyword metadata. These keywords will appear in the | |
| * "Document Properties" section of most PDF readers. For example: | |
| * ```js | |
| * pdfDoc.setKeywords(['eggs', 'wall', 'fall', 'king', 'horses', 'men']) | |
| * ``` | |
| * @param keywords An array of keywords associated with this document. | |
| */ | |
| setKeywords(keywords: string[]): void; | |
| /** | |
| * Set this document's creator metadata. The creator will appear in the | |
| * "Document Properties" section of most PDF readers. For example: | |
| * ```js | |
| * pdfDoc.setCreator('PDF App 9000 🤖') | |
| * ``` | |
| * @param creator The creator of this document. | |
| */ | |
| setCreator(creator: string): void; | |
| /** | |
| * Set this document's producer metadata. The producer will appear in the | |
| * "Document Properties" section of most PDF readers. For example: | |
| * ```js | |
| * pdfDoc.setProducer('PDF App 9000 🤖') | |
| * ``` | |
| * @param producer The producer of this document. | |
| */ | |
| setProducer(producer: string): void; | |
| /** | |
| * Set this document's language metadata. The language will appear in the | |
| * "Document Properties" section of some PDF readers. For example: | |
| * ```js | |
| * pdfDoc.setLanguage('en-us') | |
| * ``` | |
| * | |
| * @param language An RFC 3066 _Language-Tag_ denoting the language of this | |
| * document, or an empty string if the language is unknown. | |
| */ | |
| setLanguage(language: string): void; | |
| /** | |
| * Set this document's creation date metadata. The creation date will appear | |
| * in the "Document Properties" section of most PDF readers. For example: | |
| * ```js | |
| * pdfDoc.setCreationDate(new Date()) | |
| * ``` | |
| * @param creationDate The date this document was created. | |
| */ | |
| setCreationDate(creationDate: Date): void; | |
| /** | |
| * Set this document's modification date metadata. The modification date will | |
| * appear in the "Document Properties" section of most PDF readers. For | |
| * example: | |
| * ```js | |
| * pdfDoc.setModificationDate(new Date()) | |
| * ``` | |
| * @param modificationDate The date this document was last modified. | |
| */ | |
| setModificationDate(modificationDate: Date): void; | |
| /** | |
| * Get the number of pages contained in this document. For example: | |
| * ```js | |
| * const totalPages = pdfDoc.getPageCount() | |
| * ``` | |
| * @returns The number of pages in this document. | |
| */ | |
| getPageCount(): number; | |
| /** | |
| * Get an array of all the pages contained in this document. The pages are | |
| * stored in the array in the same order that they are rendered in the | |
| * document. For example: | |
| * ```js | |
| * const pages = pdfDoc.getPages() | |
| * pages[0] // The first page of the document | |
| * pages[2] // The third page of the document | |
| * pages[197] // The 198th page of the document | |
| * ``` | |
| * @returns An array of all the pages contained in this document. | |
| */ | |
| getPages(): PDFPage[]; | |
| /** | |
| * Get the page rendered at a particular `index` of the document. For example: | |
| * ```js | |
| * pdfDoc.getPage(0) // The first page of the document | |
| * pdfDoc.getPage(2) // The third page of the document | |
| * pdfDoc.getPage(197) // The 198th page of the document | |
| * ``` | |
| * @returns The [[PDFPage]] rendered at the given `index` of the document. | |
| */ | |
| getPage(index: number): PDFPage; | |
| /** | |
| * Get an array of indices for all the pages contained in this document. The | |
| * array will contain a range of integers from | |
| * `0..pdfDoc.getPageCount() - 1`. For example: | |
| * ```js | |
| * const pdfDoc = await PDFDocument.create() | |
| * pdfDoc.addPage() | |
| * pdfDoc.addPage() | |
| * pdfDoc.addPage() | |
| * | |
| * const indices = pdfDoc.getPageIndices() | |
| * indices // => [0, 1, 2] | |
| * ``` | |
| * @returns An array of indices for all pages contained in this document. | |
| */ | |
| getPageIndices(): number[]; | |
| /** | |
| * Remove the page at a given index from this document. For example: | |
| * ```js | |
| * pdfDoc.removePage(0) // Remove the first page of the document | |
| * pdfDoc.removePage(2) // Remove the third page of the document | |
| * pdfDoc.removePage(197) // Remove the 198th page of the document | |
| * ``` | |
| * Once a page has been removed, it will no longer be rendered at that index | |
| * in the document. | |
| * @param index The index of the page to be removed. | |
| */ | |
| removePage(index: number): void; | |
| /** | |
| * Add a page to the end of this document. This method accepts three | |
| * different value types for the `page` parameter: | |
| * | |
| * | Type | Behavior | | |
| * | ------------------ | ----------------------------------------------------------------------------------- | | |
| * | `undefined` | Create a new page and add it to the end of this document | | |
| * | `[number, number]` | Create a new page with the given dimensions and add it to the end of this document | | |
| * | `PDFPage` | Add the existing page to the end of this document | | |
| * | |
| * For example: | |
| * ```js | |
| * // page=undefined | |
| * const newPage = pdfDoc.addPage() | |
| * | |
| * // page=[number, number] | |
| * import { PageSizes } from 'pdf-lib' | |
| * const newPage1 = pdfDoc.addPage(PageSizes.A7) | |
| * const newPage2 = pdfDoc.addPage(PageSizes.Letter) | |
| * const newPage3 = pdfDoc.addPage([500, 750]) | |
| * | |
| * // page=PDFPage | |
| * const pdfDoc1 = await PDFDocument.create() | |
| * const pdfDoc2 = await PDFDocument.load(...) | |
| * const [existingPage] = await pdfDoc1.copyPages(pdfDoc2, [0]) | |
| * pdfDoc1.addPage(existingPage) | |
| * ``` | |
| * | |
| * @param page Optionally, the desired dimensions or existing page. | |
| * @returns The newly created (or existing) page. | |
| */ | |
| addPage(page?: PDFPage | [number, number]): PDFPage; | |
| /** | |
| * Insert a page at a given index within this document. This method accepts | |
| * three different value types for the `page` parameter: | |
| * | |
| * | Type | Behavior | | |
| * | ------------------ | ------------------------------------------------------------------------------ | | |
| * | `undefined` | Create a new page and insert it into this document | | |
| * | `[number, number]` | Create a new page with the given dimensions and insert it into this document | | |
| * | `PDFPage` | Insert the existing page into this document | | |
| * | |
| * For example: | |
| * ```js | |
| * // page=undefined | |
| * const newPage = pdfDoc.insertPage(2) | |
| * | |
| * // page=[number, number] | |
| * import { PageSizes } from 'pdf-lib' | |
| * const newPage1 = pdfDoc.insertPage(2, PageSizes.A7) | |
| * const newPage2 = pdfDoc.insertPage(0, PageSizes.Letter) | |
| * const newPage3 = pdfDoc.insertPage(198, [500, 750]) | |
| * | |
| * // page=PDFPage | |
| * const pdfDoc1 = await PDFDocument.create() | |
| * const pdfDoc2 = await PDFDocument.load(...) | |
| * const [existingPage] = await pdfDoc1.copyPages(pdfDoc2, [0]) | |
| * pdfDoc1.insertPage(0, existingPage) | |
| * ``` | |
| * | |
| * @param index The index at which the page should be inserted (zero-based). | |
| * @param page Optionally, the desired dimensions or existing page. | |
| * @returns The newly created (or existing) page. | |
| */ | |
| insertPage(index: number, page?: PDFPage | [number, number]): PDFPage; | |
| /** | |
| * Copy pages from a source document into this document. Allows pages to be | |
| * copied between different [[PDFDocument]] instances. For example: | |
| * ```js | |
| * const pdfDoc = await PDFDocument.create() | |
| * const srcDoc = await PDFDocument.load(...) | |
| * | |
| * const copiedPages = await pdfDoc.copyPages(srcDoc, [0, 3, 89]) | |
| * const [firstPage, fourthPage, ninetiethPage] = copiedPages; | |
| * | |
| * pdfDoc.addPage(fourthPage) | |
| * pdfDoc.insertPage(0, ninetiethPage) | |
| * pdfDoc.addPage(firstPage) | |
| * ``` | |
| * @param srcDoc The document from which pages should be copied. | |
| * @param indices The indices of the pages that should be copied. | |
| * @returns Resolves with an array of pages copied into this document. | |
| */ | |
| copyPages(srcDoc: PDFDocument, indices: number[]): Promise<PDFPage[]>; | |
| /** | |
| * Get a copy of this document. | |
| * | |
| * For example: | |
| * ```js | |
| * const srcDoc = await PDFDocument.load(...) | |
| * const pdfDoc = await srcDoc.copy() | |
| * ``` | |
| * | |
| * > **NOTE:** This method won't copy all information over to the new | |
| * > document (acroforms, outlines, etc...). | |
| * | |
| * @returns Resolves with a copy this document. | |
| */ | |
| copy(): Promise<PDFDocument>; | |
| /** | |
| * Add JavaScript to this document. The supplied `script` is executed when the | |
| * document is opened. The `script` can be used to perform some operation | |
| * when the document is opened (e.g. logging to the console), or it can be | |
| * used to define a function that can be referenced later in a JavaScript | |
| * action. For example: | |
| * ```js | |
| * // Show "Hello World!" in the console when the PDF is opened | |
| * pdfDoc.addJavaScript( | |
| * 'main', | |
| * 'console.show(); console.println("Hello World!");' | |
| * ); | |
| * | |
| * // Define a function named "foo" that can be called in JavaScript Actions | |
| * pdfDoc.addJavaScript( | |
| * 'foo', | |
| * 'function foo() { return "foo"; }' | |
| * ); | |
| * ``` | |
| * See the [JavaScript for Acrobat API Reference](https://www.adobe.com/content/dam/acom/en/devnet/acrobat/pdfs/js_api_reference.pdf) | |
| * for details. | |
| * @param name The name of the script. Must be unique per document. | |
| * @param script The JavaScript to execute. | |
| */ | |
| addJavaScript(name: string, script: string): void; | |
| /** | |
| * Add an attachment to this document. Attachments are visible in the | |
| * "Attachments" panel of Adobe Acrobat and some other PDF readers. Any | |
| * type of file can be added as an attachment. This includes, but is not | |
| * limited to, `.png`, `.jpg`, `.pdf`, `.csv`, `.docx`, and `.xlsx` files. | |
| * | |
| * The input data can be provided in multiple formats: | |
| * | |
| * | Type | Contents | | |
| * | ------------- | -------------------------------------------------------------- | | |
| * | `string` | A base64 encoded string (or data URI) containing an attachment | | |
| * | `Uint8Array` | The raw bytes of an attachment | | |
| * | `ArrayBuffer` | The raw bytes of an attachment | | |
| * | |
| * For example: | |
| * ```js | |
| * // attachment=string | |
| * await pdfDoc.attach('/9j/4AAQSkZJRgABAQAAAQABAAD/2wBD...', 'cat_riding_unicorn.jpg', { | |
| * mimeType: 'image/jpeg', | |
| * description: 'Cool cat riding a unicorn! 🦄🐈🕶️', | |
| * creationDate: new Date('2019/12/01'), | |
| * modificationDate: new Date('2020/04/19'), | |
| * }) | |
| * await pdfDoc.attach('data:image/jpeg;base64,/9j/4AAQ...', 'cat_riding_unicorn.jpg', { | |
| * mimeType: 'image/jpeg', | |
| * description: 'Cool cat riding a unicorn! 🦄🐈🕶️', | |
| * creationDate: new Date('2019/12/01'), | |
| * modificationDate: new Date('2020/04/19'), | |
| * }) | |
| * | |
| * // attachment=Uint8Array | |
| * import fs from 'fs' | |
| * const uint8Array = fs.readFileSync('cat_riding_unicorn.jpg') | |
| * await pdfDoc.attach(uint8Array, 'cat_riding_unicorn.jpg', { | |
| * mimeType: 'image/jpeg', | |
| * description: 'Cool cat riding a unicorn! 🦄🐈🕶️', | |
| * creationDate: new Date('2019/12/01'), | |
| * modificationDate: new Date('2020/04/19'), | |
| * }) | |
| * | |
| * // attachment=ArrayBuffer | |
| * const url = 'https://pdf-lib.js.org/assets/cat_riding_unicorn.jpg' | |
| * const arrayBuffer = await fetch(url).then(res => res.arrayBuffer()) | |
| * await pdfDoc.attach(arrayBuffer, 'cat_riding_unicorn.jpg', { | |
| * mimeType: 'image/jpeg', | |
| * description: 'Cool cat riding a unicorn! 🦄🐈🕶️', | |
| * creationDate: new Date('2019/12/01'), | |
| * modificationDate: new Date('2020/04/19'), | |
| * }) | |
| * ``` | |
| * | |
| * @param attachment The input data containing the file to be attached. | |
| * @param name The name of the file to be attached. | |
| * @returns Resolves when the attachment is complete. | |
| */ | |
| attach(attachment: string | Uint8Array | ArrayBuffer, name: string, options?: AttachmentOptions): Promise<void>; | |
| /** | |
| * Embed a font into this document. The input data can be provided in multiple | |
| * formats: | |
| * | |
| * | Type | Contents | | |
| * | --------------- | ------------------------------------------------------- | | |
| * | `StandardFonts` | One of the standard 14 fonts | | |
| * | `string` | A base64 encoded string (or data URI) containing a font | | |
| * | `Uint8Array` | The raw bytes of a font | | |
| * | `ArrayBuffer` | The raw bytes of a font | | |
| * | |
| * For example: | |
| * ```js | |
| * // font=StandardFonts | |
| * import { StandardFonts } from 'pdf-lib' | |
| * const font1 = await pdfDoc.embedFont(StandardFonts.Helvetica) | |
| * | |
| * // font=string | |
| * const font2 = await pdfDoc.embedFont('AAEAAAAVAQAABABQRFNJRx/upe...') | |
| * const font3 = await pdfDoc.embedFont('data:font/opentype;base64,AAEAAA...') | |
| * | |
| * // font=Uint8Array | |
| * import fs from 'fs' | |
| * const font4 = await pdfDoc.embedFont(fs.readFileSync('Ubuntu-R.ttf')) | |
| * | |
| * // font=ArrayBuffer | |
| * const url = 'https://pdf-lib.js.org/assets/ubuntu/Ubuntu-R.ttf' | |
| * const ubuntuBytes = await fetch(url).then(res => res.arrayBuffer()) | |
| * const font5 = await pdfDoc.embedFont(ubuntuBytes) | |
| * ``` | |
| * See also: [[registerFontkit]] | |
| * @param font The input data for a font. | |
| * @param options The options to be used when embedding the font. | |
| * @returns Resolves with the embedded font. | |
| */ | |
| embedFont(font: StandardFonts | string | Uint8Array | ArrayBuffer, options?: EmbedFontOptions): Promise<PDFFont>; | |
| /** | |
| * Embed a standard font into this document. | |
| * For example: | |
| * ```js | |
| * import { StandardFonts } from 'pdf-lib' | |
| * const helveticaFont = pdfDoc.embedFont(StandardFonts.Helvetica) | |
| * ``` | |
| * @param font The standard font to be embedded. | |
| * @param customName The name to be used when embedding the font. | |
| * @returns The embedded font. | |
| */ | |
| embedStandardFont(font: StandardFonts, customName?: string): PDFFont; | |
| /** | |
| * Embed a JPEG image into this document. The input data can be provided in | |
| * multiple formats: | |
| * | |
| * | Type | Contents | | |
| * | ------------- | ------------------------------------------------------------- | | |
| * | `string` | A base64 encoded string (or data URI) containing a JPEG image | | |
| * | `Uint8Array` | The raw bytes of a JPEG image | | |
| * | `ArrayBuffer` | The raw bytes of a JPEG image | | |
| * | |
| * For example: | |
| * ```js | |
| * // jpg=string | |
| * const image1 = await pdfDoc.embedJpg('/9j/4AAQSkZJRgABAQAAAQABAAD/2wBD...') | |
| * const image2 = await pdfDoc.embedJpg('data:image/jpeg;base64,/9j/4AAQ...') | |
| * | |
| * // jpg=Uint8Array | |
| * import fs from 'fs' | |
| * const uint8Array = fs.readFileSync('cat_riding_unicorn.jpg') | |
| * const image3 = await pdfDoc.embedJpg(uint8Array) | |
| * | |
| * // jpg=ArrayBuffer | |
| * const url = 'https://pdf-lib.js.org/assets/cat_riding_unicorn.jpg' | |
| * const arrayBuffer = await fetch(url).then(res => res.arrayBuffer()) | |
| * const image4 = await pdfDoc.embedJpg(arrayBuffer) | |
| * ``` | |
| * | |
| * @param jpg The input data for a JPEG image. | |
| * @returns Resolves with the embedded image. | |
| */ | |
| embedJpg(jpg: string | Uint8Array | ArrayBuffer): Promise<PDFImage>; | |
| /** | |
| * Embed a PNG image into this document. The input data can be provided in | |
| * multiple formats: | |
| * | |
| * | Type | Contents | | |
| * | ------------- | ------------------------------------------------------------ | | |
| * | `string` | A base64 encoded string (or data URI) containing a PNG image | | |
| * | `Uint8Array` | The raw bytes of a PNG image | | |
| * | `ArrayBuffer` | The raw bytes of a PNG image | | |
| * | |
| * For example: | |
| * ```js | |
| * // png=string | |
| * const image1 = await pdfDoc.embedPng('iVBORw0KGgoAAAANSUhEUgAAAlgAAAF3...') | |
| * const image2 = await pdfDoc.embedPng('data:image/png;base64,iVBORw0KGg...') | |
| * | |
| * // png=Uint8Array | |
| * import fs from 'fs' | |
| * const uint8Array = fs.readFileSync('small_mario.png') | |
| * const image3 = await pdfDoc.embedPng(uint8Array) | |
| * | |
| * // png=ArrayBuffer | |
| * const url = 'https://pdf-lib.js.org/assets/small_mario.png' | |
| * const arrayBuffer = await fetch(url).then(res => res.arrayBuffer()) | |
| * const image4 = await pdfDoc.embedPng(arrayBuffer) | |
| * ``` | |
| * | |
| * @param png The input data for a PNG image. | |
| * @returns Resolves with the embedded image. | |
| */ | |
| embedPng(png: string | Uint8Array | ArrayBuffer): Promise<PDFImage>; | |
| /** | |
| * Embed one or more PDF pages into this document. | |
| * | |
| * For example: | |
| * ```js | |
| * const pdfDoc = await PDFDocument.create() | |
| * | |
| * const sourcePdfUrl = 'https://pdf-lib.js.org/assets/with_large_page_count.pdf' | |
| * const sourcePdf = await fetch(sourcePdfUrl).then((res) => res.arrayBuffer()) | |
| * | |
| * // Embed page 74 of `sourcePdf` into `pdfDoc` | |
| * const [embeddedPage] = await pdfDoc.embedPdf(sourcePdf, [73]) | |
| * ``` | |
| * | |
| * See [[PDFDocument.load]] for examples of the allowed input data formats. | |
| * | |
| * @param pdf The input data containing a PDF document. | |
| * @param indices The indices of the pages that should be embedded. | |
| * @returns Resolves with an array of the embedded pages. | |
| */ | |
| embedPdf(pdf: string | Uint8Array | ArrayBuffer | PDFDocument, indices?: number[]): Promise<PDFEmbeddedPage[]>; | |
| /** | |
| * Embed a single PDF page into this document. | |
| * | |
| * For example: | |
| * ```js | |
| * const pdfDoc = await PDFDocument.create() | |
| * | |
| * const sourcePdfUrl = 'https://pdf-lib.js.org/assets/with_large_page_count.pdf' | |
| * const sourceBuffer = await fetch(sourcePdfUrl).then((res) => res.arrayBuffer()) | |
| * const sourcePdfDoc = await PDFDocument.load(sourceBuffer) | |
| * const sourcePdfPage = sourcePdfDoc.getPages()[73] | |
| * | |
| * const embeddedPage = await pdfDoc.embedPage( | |
| * sourcePdfPage, | |
| * | |
| * // Clip a section of the source page so that we only embed part of it | |
| * { left: 100, right: 450, bottom: 330, top: 570 }, | |
| * | |
| * // Translate all drawings of the embedded page by (10, 200) units | |
| * [1, 0, 0, 1, 10, 200], | |
| * ) | |
| * ``` | |
| * | |
| * @param page The page to be embedded. | |
| * @param boundingBox | |
| * Optionally, an area of the source page that should be embedded | |
| * (defaults to entire page). | |
| * @param transformationMatrix | |
| * Optionally, a transformation matrix that is always applied to the embedded | |
| * page anywhere it is drawn. | |
| * @returns Resolves with the embedded pdf page. | |
| */ | |
| embedPage(page: PDFPage, boundingBox?: PageBoundingBox, transformationMatrix?: TransformationMatrix): Promise<PDFEmbeddedPage>; | |
| /** | |
| * Embed one or more PDF pages into this document. | |
| * | |
| * For example: | |
| * ```js | |
| * const pdfDoc = await PDFDocument.create() | |
| * | |
| * const sourcePdfUrl = 'https://pdf-lib.js.org/assets/with_large_page_count.pdf' | |
| * const sourceBuffer = await fetch(sourcePdfUrl).then((res) => res.arrayBuffer()) | |
| * const sourcePdfDoc = await PDFDocument.load(sourceBuffer) | |
| * | |
| * const page1 = sourcePdfDoc.getPages()[0] | |
| * const page2 = sourcePdfDoc.getPages()[52] | |
| * const page3 = sourcePdfDoc.getPages()[73] | |
| * | |
| * const embeddedPages = await pdfDoc.embedPages([page1, page2, page3]) | |
| * ``` | |
| * | |
| * @param page | |
| * The pages to be embedded (they must all share the same context). | |
| * @param boundingBoxes | |
| * Optionally, an array of clipping boundaries - one for each page | |
| * (defaults to entirety of each page). | |
| * @param transformationMatrices | |
| * Optionally, an array of transformation matrices - one for each page | |
| * (each page's transformation will apply anywhere it is drawn). | |
| * @returns Resolves with an array of the embedded pdf pages. | |
| */ | |
| embedPages(pages: PDFPage[], boundingBoxes?: (PageBoundingBox | undefined)[], transformationMatrices?: (TransformationMatrix | undefined)[]): Promise<PDFEmbeddedPage[]>; | |
| /** | |
| * > **NOTE:** You shouldn't need to call this method directly. The [[save]] | |
| * > and [[saveAsBase64]] methods will automatically ensure that all embedded | |
| * > assets are flushed before serializing the document. | |
| * | |
| * Flush all embedded fonts, PDF pages, and images to this document's | |
| * [[context]]. | |
| * | |
| * @returns Resolves when the flush is complete. | |
| */ | |
| flush(): Promise<void>; | |
| /** | |
| * Serialize this document to an array of bytes making up a PDF file. | |
| * For example: | |
| * ```js | |
| * const pdfBytes = await pdfDoc.save() | |
| * ``` | |
| * | |
| * There are a number of things you can do with the serialized document, | |
| * depending on the JavaScript environment you're running in: | |
| * * Write it to a file in Node or React Native | |
| * * Download it as a Blob in the browser | |
| * * Render it in an `iframe` | |
| * | |
| * @param options The options to be used when saving the document. | |
| * @returns Resolves with the bytes of the serialized document. | |
| */ | |
| save(options?: SaveOptions): Promise<Uint8Array>; | |
| /** | |
| * Serialize this document to a base64 encoded string or data URI making up a | |
| * PDF file. For example: | |
| * ```js | |
| * const base64String = await pdfDoc.saveAsBase64() | |
| * base64String // => 'JVBERi0xLjcKJYGBgYEKC...' | |
| * | |
| * const base64DataUri = await pdfDoc.saveAsBase64({ dataUri: true }) | |
| * base64DataUri // => 'data:application/pdf;base64,JVBERi0xLjcKJYGBgYEKC...' | |
| * ``` | |
| * | |
| * @param options The options to be used when saving the document. | |
| * @returns Resolves with a base64 encoded string or data URI of the | |
| * serialized document. | |
| */ | |
| saveAsBase64(options?: Base64SaveOptions): Promise<string>; | |
| findPageForAnnotationRef(ref: PDFRef): PDFPage | undefined; | |
| private embedAll; | |
| private updateInfoDict; | |
| private getInfoDict; | |
| private assertFontkit; | |
| private computePages; | |
| private getOrCreateForm; | |
| } | |
| //# sourceMappingURL=PDFDocument.d.ts.map | |