@pdfme/pdf-lib 6.0.3 → 6.0.5-dev.1

package/dist/utils/elements/Circle.d.ts

@@ -0,0 +1,14 @@
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Circle extends GraphElement {
+    O: Point;
+    r: number;
+    constructor(O?: Point, r?: number);
+    ray(): number;
+    center(): Point;
+    /** This is used to standardize type Circle | Arc */
+    getCircle(): this;
+    isEqual(element: GraphElement): boolean;
+    includes(P: Point): boolean;
+    orthoProjection(P: Point): Point;
+}

package/dist/utils/elements/Ellipse.d.ts

@@ -0,0 +1,20 @@
+import { Size } from '../../types';
+import GraphElement from './GraphElement';
+import Point from './Point';
+import Segment from './Segment';
+export default class Ellipse extends GraphElement {
+    A: Point;
+    B: Point;
+    C: Point;
+    constructor(A?: Point, B?: Point, C?: Point);
+    center(): Point;
+    axis(): Segment;
+    a(): number;
+    b(): number;
+    rotation(): number;
+    getSize(): Size;
+    isEqual(element: GraphElement): boolean;
+    includes(P: Point): boolean;
+    orthoProjection(P: Point): Point;
+    polarRay(teta: number): number;
+}

package/dist/utils/elements/GraphElement.d.ts

@@ -0,0 +1,6 @@
+import Point from './Point';
+export default abstract class GraphElement {
+    abstract isEqual(element: GraphElement): boolean;
+    abstract orthoProjection(P: Point): Point;
+    distance(P: Point): number;
+}

package/dist/utils/elements/Line.d.ts

@@ -0,0 +1,23 @@
+import { Coordinates } from '../../types';
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Line extends GraphElement {
+    origin(): Point;
+    dirVect(): Coordinates;
+    A: Point;
+    B: Point;
+    constructor(A?: Point, B?: Point);
+    /** Line equation */
+    y(x: number): number;
+    /** The slope */
+    a(): number;
+    /** Origin y coordinate */
+    b(): number;
+    isEqual(element: GraphElement): boolean;
+    /** Reversed line equation */
+    x(y: number): number;
+    includes(P: Point): boolean;
+    /** This is used to standarsize type Segment | HalfLine | Line */
+    getLine(): Line;
+    orthoProjection(P: Point): Point;
+}

package/dist/utils/elements/Plot.d.ts

@@ -0,0 +1,11 @@
+import { Coordinates } from '../../types';
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Plot extends GraphElement {
+    points: Coordinates[];
+    constructor(points?: Coordinates[]);
+    getPoints(): Coordinates[];
+    translate(translationVector: Coordinates): void;
+    isEqual(element: GraphElement): boolean;
+    orthoProjection(P: Point): Point;
+}

package/dist/utils/elements/Point.d.ts

@@ -0,0 +1,18 @@
+import type { Coordinates } from '../../types';
+import GraphElement from './GraphElement';
+export default class Point extends GraphElement {
+    static type: string;
+    x: number;
+    y: number;
+    constructor(coords?: {
+        x: number;
+        y: number;
+    });
+    toCoords(): {
+        x: number;
+        y: number;
+    };
+    isEqual(element: GraphElement): boolean;
+    orthoProjection(): Point;
+    plus(vect: Coordinates): Point;
+}

package/dist/utils/elements/Rectangle.d.ts

@@ -0,0 +1,21 @@
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Rectangle extends GraphElement {
+    static type: string;
+    start: Point;
+    end: Point;
+    constructor(start?: Point, end?: Point);
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    getCoords(): {
+        x: number;
+        y: number;
+    };
+    getStart(): Point;
+    getEnd(): Point;
+    center(): Point;
+    isEqual(element: GraphElement): boolean;
+    orthoProjection(P: Point): Point;
+}

package/dist/utils/elements/Segment.d.ts

@@ -0,0 +1,19 @@
+import GraphElement from './GraphElement';
+import Line from './Line';
+import Point from './Point';
+export default class Segment extends GraphElement {
+    static type: string;
+    A: Point;
+    B: Point;
+    constructor(A?: Point, B?: Point);
+    origin(): Point;
+    destination(): Point;
+    dirVect(): import("../..").Coordinates;
+    length(): number;
+    isEqual(element: GraphElement): boolean;
+    /** Returns an equivalent line object */
+    getLine(): Line;
+    includes(P: Point): boolean;
+    middle(): Point;
+    orthoProjection(P: Point): Point;
+}

package/dist/utils/errors.d.ts

@@ -0,0 +1 @@
+export declare const error: (msg: string) => never;

package/dist/utils/intersections.d.ts

@@ -0,0 +1,9 @@
+import Circle from './elements/Circle';
+import Line from './elements/Line';
+import { Coordinates, GraphicElement } from '../types';
+export declare function intersections(A: GraphicElement, B: GraphicElement): Coordinates[];
+export declare function intersection(A: GraphicElement, B: GraphicElement): Coordinates | undefined;
+export declare function intersectionLine(A: Line, B: Line): Coordinates[];
+export declare function intersectionCircleLine(A: Circle, B: Line): Coordinates[];
+export declare function intersectionCircle(A: Circle, B: Circle): Coordinates[];
+export declare function getIntersections(elements: GraphicElement[]): Coordinates[];

package/dist/utils/maths.d.ts

@@ -0,0 +1,45 @@
+import Point from './elements/Point';
+import { Coordinates } from '../types';
+/** This value represents the precision we accept for float values */
+export declare const FLOAT_APPROXIMATION = 0.000001;
+/** Calculates the distance between 2 points */
+export declare const distance: (A: Point, B: Point) => number;
+export declare const distanceCoords: (A: Coordinates, B: Coordinates) => number;
+/** Calculates the distance denoted by a vector */
+export declare const norm: (vect: Coordinates) => number;
+/** Calculates the orthogonal vector of provided vector */
+export declare const orthogonal: ({ x, y }: Coordinates) => Coordinates;
+/** Check if 2 vectors are proportional */
+export declare const isColinear: ({ x: ux, y: uy }: Coordinates, { x: vx, y: vy }: Coordinates) => boolean;
+/** Check if 2 floating values can be considered equals */
+export declare const isEqual: (a: number, b: number) => boolean;
+/** Return true if a is proportional to b: (a = kb), considering float imprecision */
+export declare const isProportional: (a: number, b: number) => boolean;
+/** Calculate the scalar product between 2 vectors */
+export declare const scalar: ({ x: ux, y: uy }: Coordinates, { x: vx, y: vy }: Coordinates) => number;
+/** Calculate the sum of 2 vectors */
+export declare const plus: ({ x: ux, y: uy }: Coordinates, { x: vx, y: vy }: Coordinates) => Coordinates;
+/** Calculate the vector multiplied by a scalar */
+export declare const times: ({ x, y }: Coordinates, k?: number) => Coordinates;
+/** Calculate the difference of 2 vectors */
+export declare const minus: (u: Coordinates, v: Coordinates) => Coordinates;
+/** Returns the vector between 2 points. */
+export declare const vector: (A: Point, B: Point) => Coordinates;
+/**
+ * Returns the angle between the vector and the horizontal axis (Ox).
+ * The return value is between -PI and PI.
+ * @returns {number} angle in radian between -Pi and Pi
+ */
+export declare const orientation: ({ x, y }: Coordinates) => number;
+/** Returns the unit vector associated to the provided vector,
+ * or the Null vector (0, 0) if the vector is null
+ */
+export declare const unitVector: (u: Coordinates) => Coordinates;
+/** Returns the angle from u to v in radian */
+export declare const angle: (u: Coordinates, v: Coordinates, previousAngle?: number) => number;
+/** Returns the angle between the lines (BA) and (BC) in radian
+ * @returns {number} the angle in radian, between -Pi and Pi
+ */
+export declare const angleABC: (A: Point, B: Point, C: Point, previousAngle?: number) => number;
+/** Rotate the vector by an angle in radian */
+export declare const rotate: (vect: Coordinates, teta: number) => Coordinates;

package/dist/utils/numbers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Converts a number to its string representation in decimal. This function
+ * differs from simply converting a number to a string with `.toString()`
+ * because this function's output string will **not** contain exponential
+ * notation.
+ *
+ * Credit: https://stackoverflow.com/a/46545519
+ */
+export declare const numberToString: (num: number) => string;
+export declare const sizeInBytes: (n: number) => number;
+/**
+ * Converts a number into its constituent bytes and returns them as
+ * a number[].
+ *
+ * Returns most significant byte as first element in array. It may be necessary
+ * to call .reverse() to get the bits in the desired order.
+ *
+ * Example:
+ *   bytesFor(0x02A41E) => [ 0b10, 0b10100100, 0b11110 ]
+ *
+ * Credit for algorithm: https://stackoverflow.com/a/1936865
+ */
+export declare const bytesFor: (n: number) => Uint8Array<ArrayBuffer>;

package/dist/utils/objects.d.ts

@@ -0,0 +1,15 @@
+import { FontNames } from '@pdf-lib/standard-fonts';
+export declare const values: (obj: any) => any[];
+export declare const StandardFontValues: any[];
+export declare const isStandardFont: (input: any) => input is FontNames;
+export declare const rectanglesAreEqual: (a: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, b: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}) => boolean;

package/dist/utils/pdfDocEncoding.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Decode a byte array into a string using PDFDocEncoding.
+ *
+ * @param bytes a byte array (decimal representation) containing a string
+ *              encoded with PDFDocEncoding.
+ */
+export declare const pdfDocEncodingDecode: (bytes: Uint8Array) => string;

package/dist/utils/png.d.ts

@@ -0,0 +1,17 @@
+export declare enum PngType {
+    Greyscale = "Greyscale",
+    Truecolour = "Truecolour",
+    IndexedColour = "IndexedColour",
+    GreyscaleWithAlpha = "GreyscaleWithAlpha",
+    TruecolourWithAlpha = "TruecolourWithAlpha"
+}
+export declare class PNG {
+    static load: (pngData: Uint8Array) => PNG;
+    readonly rgbChannel: Uint8Array;
+    readonly alphaChannel?: Uint8Array;
+    readonly type: PngType;
+    readonly width: number;
+    readonly height: number;
+    readonly bitsPerComponent: number;
+    private constructor();
+}

package/dist/utils/rng.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generates a pseudo random number. Although it is not cryptographically secure
+ * and uniformly distributed, it is not a concern for the intended use-case,
+ * which is to generate distinct numbers.
+ *
+ * Credit: https://stackoverflow.com/a/19303725/10254049
+ */
+export declare class SimpleRNG {
+    static withSeed: (seed: number) => SimpleRNG;
+    private seed;
+    private constructor();
+    nextInt(): number;
+}

package/dist/utils/strings.d.ts

@@ -0,0 +1,25 @@
+export declare const toCharCode: (character: string) => number;
+export declare const toCodePoint: (character: string) => number | undefined;
+export declare const toHexStringOfMinLength: (num: number, minLength: number) => string;
+export declare const toHexString: (num: number) => string;
+export declare const charFromCode: (code: number) => string;
+export declare const charFromHexCode: (hex: string) => string;
+export declare const padStart: (value: string, length: number, padChar: string) => string;
+export declare const stringAsByteArray: (str: string) => Uint8Array;
+export declare const copyStringIntoBuffer: (str: string, buffer: Uint8Array, offset: number) => number;
+export declare const addRandomSuffix: (prefix: string, suffixLength?: number) => string;
+export declare const escapeRegExp: (str: string) => string;
+export declare const cleanText: (text: string) => string;
+export declare const escapedNewlineChars: string[];
+export declare const newlineChars: string[];
+export declare const isNewlineChar: (text: string) => boolean;
+export declare const lineSplit: (text: string) => string[];
+export declare const mergeLines: (text: string) => string;
+export declare const charAtIndex: (text: string, index: number) => [string, number];
+export declare const charSplit: (text: string) => string[];
+export declare const breakTextIntoLines: (text: string, wordBreaks: string[], maxWidth: number, computeWidthOfText: (t: string) => number) => string[];
+export declare const parseDate: (dateStr: string) => Date | undefined;
+export declare const findLastMatch: (value: string, regex: RegExp) => {
+    match: RegExpMatchArray | undefined;
+    pos: number;
+};

package/{src/utils/unicode.ts → dist/utils/unicode.d.ts}

@@ -1,5 +1,3 @@
-import { toHexString } from './strings';
-
 /**
  * Encodes a string to UTF-8.
  *
@@ -87,55 +85,7 @@ import { toHexString } from './strings';
  *   - [4] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length#Description
  *
  */
-export const utf8Encode = (input: string, byteOrderMark = true): Uint8Array => {
-  const encoded = [];
-
-  if (byteOrderMark) encoded.push(0xef, 0xbb, 0xbf);
-
-  for (let idx = 0, len = input.length; idx < len; ) {
-    const codePoint = input.codePointAt(idx)!;
-
-    // One byte encoding
-    if (codePoint < 0x80) {
-      const byte1 = codePoint & 0x7f;
-      encoded.push(byte1);
-      idx += 1;
-    }
-
-    // Two byte encoding
-    else if (codePoint < 0x0800) {
-      const byte1 = ((codePoint >> 6) & 0x1f) | 0xc0;
-      const byte2 = (codePoint & 0x3f) | 0x80;
-      encoded.push(byte1, byte2);
-      idx += 1;
-    }
-
-    // Three byte encoding
-    else if (codePoint < 0x010000) {
-      const byte1 = ((codePoint >> 12) & 0x0f) | 0xe0;
-      const byte2 = ((codePoint >> 6) & 0x3f) | 0x80;
-      const byte3 = (codePoint & 0x3f) | 0x80;
-      encoded.push(byte1, byte2, byte3);
-      idx += 1;
-    }
-
-    // Four byte encoding (surrogate pair)
-    else if (codePoint < 0x110000) {
-      const byte1 = ((codePoint >> 18) & 0x07) | 0xf0;
-      const byte2 = ((codePoint >> 12) & 0x3f) | 0x80;
-      const byte3 = ((codePoint >> 6) & 0x3f) | 0x80;
-      const byte4 = ((codePoint >> 0) & 0x3f) | 0x80;
-      encoded.push(byte1, byte2, byte3, byte4);
-      idx += 2;
-    }
-
-    // Should never reach this case
-    else throw new Error(`Invalid code point: 0x${toHexString(codePoint)}`);
-  }
-
-  return new Uint8Array(encoded);
-};
-
+export declare const utf8Encode: (input: string, byteOrderMark?: boolean) => Uint8Array;
 /**
  * Encodes a string to UTF-16.
  *
@@ -200,33 +150,7 @@ export const utf8Encode = (input: string, byteOrderMark = true): Uint8Array => {
  *   - [3] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length#Description
  *
  */
-export const utf16Encode = (input: string, byteOrderMark = true): Uint16Array => {
-  const encoded = [];
-
-  if (byteOrderMark) encoded.push(0xfeff);
-
-  for (let idx = 0, len = input.length; idx < len; ) {
-    const codePoint = input.codePointAt(idx)!;
-
-    // Two byte encoding
-    if (codePoint < 0x010000) {
-      encoded.push(codePoint);
-      idx += 1;
-    }
-
-    // Four byte encoding (surrogate pair)
-    else if (codePoint < 0x110000) {
-      encoded.push(highSurrogate(codePoint), lowSurrogate(codePoint));
-      idx += 2;
-    }
-
-    // Should never reach this case
-    else throw new Error(`Invalid code point: 0x${toHexString(codePoint)}`);
-  }
-
-  return new Uint16Array(encoded);
-};
-
+export declare const utf16Encode: (input: string, byteOrderMark?: boolean) => Uint16Array;
 /**
  * Returns `true` if the `codePoint` is within the
  * Basic Multilingual Plane (BMP). Code points inside the BMP are not encoded
@@ -235,8 +159,7 @@ export const utf16Encode = (input: string, byteOrderMark = true): Uint16Array =>
  *
  * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
  */
-export const isWithinBMP = (codePoint: number) => codePoint >= 0 && codePoint <= 0xffff;
-
+export declare const isWithinBMP: (codePoint: number) => boolean;
 /**
  * Returns `true` if the given `codePoint` is valid and must be represented
  * with a surrogate pair when encoded.
@@ -244,24 +167,9 @@ export const isWithinBMP = (codePoint: number) => codePoint >= 0 && codePoint <=
  *
  * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
  */
-export const hasSurrogates = (codePoint: number) => codePoint >= 0x010000 && codePoint <= 0x10ffff;
-
-// From Unicode 3.0 spec, section 3.7:
-//   http://unicode.org/versions/Unicode3.0.0/ch03.pdf
-export const highSurrogate = (codePoint: number) =>
-  Math.floor((codePoint - 0x10000) / 0x400) + 0xd800;
-
-// From Unicode 3.0 spec, section 3.7:
-//   http://unicode.org/versions/Unicode3.0.0/ch03.pdf
-export const lowSurrogate = (codePoint: number) => ((codePoint - 0x10000) % 0x400) + 0xdc00;
-
-enum ByteOrder {
-  BigEndian = 'BigEndian',
-  LittleEndian = 'LittleEndian',
-}
-
-const REPLACEMENT = '�'.codePointAt(0)!;
-
+export declare const hasSurrogates: (codePoint: number) => boolean;
+export declare const highSurrogate: (codePoint: number) => number;
+export declare const lowSurrogate: (codePoint: number) => number;
 /**
  * Decodes a Uint8Array of data to a string using UTF-16.
  *
@@ -274,100 +182,5 @@ const REPLACEMENT = '�'.codePointAt(0)!;
  *                      at the start of the encoding. (default `true`)
  * @returns The decoded string.
  */
-export const utf16Decode = (input: Uint8Array, byteOrderMark = true): string => {
-  // Need at least 2 bytes of data in UTF-16 encodings
-  if (input.length <= 1) return String.fromCodePoint(REPLACEMENT);
-
-  const byteOrder = byteOrderMark ? readBOM(input) : ByteOrder.BigEndian;
-
-  // Skip byte order mark if needed
-  let idx = byteOrderMark ? 2 : 0;
-
-  const codePoints: number[] = [];
-
-  while (input.length - idx >= 2) {
-    const first = decodeValues(input[idx++], input[idx++], byteOrder);
-
-    if (isHighSurrogate(first)) {
-      if (input.length - idx < 2) {
-        // Need at least 2 bytes left for the low surrogate that is required
-        codePoints.push(REPLACEMENT);
-      } else {
-        const second = decodeValues(input[idx++], input[idx++], byteOrder);
-        if (isLowSurrogate(second)) {
-          codePoints.push(first, second);
-        } else {
-          // Low surrogates should always follow high surrogates
-          codePoints.push(REPLACEMENT);
-        }
-      }
-    } else if (isLowSurrogate(first)) {
-      // High surrogates should always come first since `decodeValues()`
-      // accounts for the byte ordering
-      idx += 2;
-      codePoints.push(REPLACEMENT);
-    } else {
-      codePoints.push(first);
-    }
-  }
-
-  // There shouldn't be extra byte(s) left over
-  if (idx < input.length) codePoints.push(REPLACEMENT);
-
-  return String.fromCodePoint(...codePoints);
-};
-
-/**
- * Returns `true` if the given `codePoint` is a high surrogate.
- * @param codePoint The code point to be evaluated.
- *
- * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
- */
-const isHighSurrogate = (codePoint: number) => codePoint >= 0xd800 && codePoint <= 0xdbff;
-
-/**
- * Returns `true` if the given `codePoint` is a low surrogate.
- * @param codePoint The code point to be evaluated.
- *
- * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
- */
-const isLowSurrogate = (codePoint: number) => codePoint >= 0xdc00 && codePoint <= 0xdfff;
-
-/**
- * Decodes the given utf-16 values first and second using the specified
- * byte order.
- * @param first The first byte of the encoding.
- * @param second The second byte of the encoding.
- * @param byteOrder The byte order of the encoding.
- * Reference: https://en.wikipedia.org/wiki/UTF-16#Examples
- */
-const decodeValues = (first: number, second: number, byteOrder: ByteOrder) => {
-  // Append the binary representation of the preceding byte by shifting the
-  // first one 8 to the left and than applying a bitwise or-operator to append
-  // the second one.
-  if (byteOrder === ByteOrder.LittleEndian) return (second << 8) | first;
-  if (byteOrder === ByteOrder.BigEndian) return (first << 8) | second;
-  throw new Error(`Invalid byteOrder: ${byteOrder}`);
-};
-
-/**
- * Returns whether the given array contains a byte order mark for the
- * UTF-16BE or UTF-16LE encoding. If it has neither, BigEndian is assumed.
- *
- * Reference: https://en.wikipedia.org/wiki/Byte_order_mark#UTF-16
- *
- * @param bytes The byte array to be evaluated.
- */
-// prettier-ignore
-const readBOM = (bytes: Uint8Array): ByteOrder => (
-    hasUtf16BigEndianBOM(bytes) ? ByteOrder.BigEndian
-  : hasUtf16LittleEndianBOM(bytes) ? ByteOrder.LittleEndian
-  : ByteOrder.BigEndian
-);
-
-const hasUtf16BigEndianBOM = (bytes: Uint8Array) => bytes[0] === 0xfe && bytes[1] === 0xff;
-
-const hasUtf16LittleEndianBOM = (bytes: Uint8Array) => bytes[0] === 0xff && bytes[1] === 0xfe;
-
-export const hasUtf16BOM = (bytes: Uint8Array) =>
-  hasUtf16BigEndianBOM(bytes) || hasUtf16LittleEndianBOM(bytes);
+export declare const utf16Decode: (input: Uint8Array, byteOrderMark?: boolean) => string;
+export declare const hasUtf16BOM: (bytes: Uint8Array) => boolean;

package/dist/utils/validators.d.ts

@@ -0,0 +1,26 @@
+export declare const backtick: (val: any) => string;
+export declare const singleQuote: (val: any) => string;
+type Primitive = string | number | boolean | undefined | null;
+export declare const createValueErrorMsg: (value: any, valueName: string, values: Primitive[]) => string;
+export declare const assertIsOneOf: (value: any, valueName: string, allowedValues: Primitive[] | {
+    [key: string]: Primitive;
+}) => void;
+export declare const assertIsOneOfOrUndefined: (value: any, valueName: string, allowedValues: Primitive[] | {
+    [key: string]: Primitive;
+}) => void;
+export declare const assertIsSubset: (values: any[], valueName: string, allowedValues: Primitive[] | {
+    [key: string]: Primitive;
+}) => void;
+export declare const getType: (val: any) => any;
+export type TypeDescriptor = 'null' | 'undefined' | 'string' | 'number' | 'boolean' | 'symbol' | 'bigint' | DateConstructor | ArrayConstructor | Uint8ArrayConstructor | ArrayBufferConstructor | FunctionConstructor | [Function, string];
+export declare const isType: (value: any, type: TypeDescriptor) => boolean;
+export declare const createTypeErrorMsg: (value: any, valueName: string, types: TypeDescriptor[]) => string;
+export declare const assertIs: (value: any, valueName: string, types: TypeDescriptor[]) => void;
+export declare const assertOrUndefined: (value: any, valueName: string, types: TypeDescriptor[]) => void;
+export declare const assertEachIs: (values: any[], valueName: string, types: TypeDescriptor[]) => void;
+export declare const assertRange: (value: any, valueName: string, min: number, max: number) => void;
+export declare const assertRangeOrUndefined: (value: any, valueName: string, min: number, max: number) => void;
+export declare const assertMultiple: (value: any, valueName: string, multiplier: number) => void;
+export declare const assertInteger: (value: any, valueName: string) => void;
+export declare const assertPositive: (value: number, valueName: string) => void;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pdfme/pdf-lib",
-  "version": "6.0.3",
+  "version": "6.0.5-dev.1",
   "description": "Create and modify PDF files with JavaScript",
   "keywords": [
     "create",
@@ -28,6 +28,11 @@
   },
   "type": "module",
   "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md"
+  ],
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",