@pdfme/pdf-lib 5.5.9 → 5.5.10-dev.125

package/dist/types/src/utils/elements/Arc.d.ts

@@ -1,22 +0,0 @@
-import Circle from './Circle';
-import GraphElement from './GraphElement';
-import Point from './Point';
-export default class Arc extends GraphElement {
-    O: Point;
-    A: Point;
-    B: Point;
-    /** Last sweep. Used to deduce the angle orientation */
-    lastSweep: number;
-    constructor(O?: Point, A?: Point, B?: Point, lastSweep?: number);
-    center(): Point;
-    origin(): Point;
-    destination(): Point;
-    sweep(): number;
-    ray(): number;
-    isEqual(element: GraphElement): boolean;
-    getCircle(): Circle;
-    originVect(): import("../..").Coordinates;
-    middle(): Point;
-    includes(P: Point): boolean;
-    orthoProjection(P: Point): Point;
-}

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

@@ -1,14 +0,0 @@
-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/types/src/utils/elements/Ellipse.d.ts

@@ -1,20 +0,0 @@
-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/types/src/utils/elements/GraphElement.d.ts

@@ -1,6 +0,0 @@
-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/types/src/utils/elements/Line.d.ts

@@ -1,23 +0,0 @@
-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/types/src/utils/elements/Plot.d.ts

@@ -1,11 +0,0 @@
-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/types/src/utils/elements/Point.d.ts

@@ -1,18 +0,0 @@
-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/types/src/utils/elements/Rectangle.d.ts

@@ -1,21 +0,0 @@
-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/types/src/utils/elements/Segment.d.ts

@@ -1,19 +0,0 @@
-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/types/src/utils/elements/index.d.ts

@@ -1,9 +0,0 @@
-export { default as Arc } from './Arc';
-export { default as Circle } from './Circle';
-export { default as GraphElement } from './GraphElement';
-export { default as Ellipse } from './Ellipse';
-export { default as Line } from './Line';
-export { default as SegmePlotnt } from './Plot';
-export { default as Point } from './Point';
-export { default as Rectangle } from './Rectangle';
-export { default as Segment } from './Segment';

package/dist/types/src/utils/errors.d.ts

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

package/dist/types/src/utils/index.d.ts

@@ -1,11 +0,0 @@
-export * from './arrays';
-export * from './async';
-export * from './strings';
-export * from './unicode';
-export * from './numbers';
-export * from './errors';
-export * from './base64';
-export * from './objects';
-export * from './validators';
-export * from './pdfDocEncoding';
-export { default as Cache } from './Cache';

package/dist/types/src/utils/intersections.d.ts

@@ -1,9 +0,0 @@
-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/types/src/utils/maths.d.ts

@@ -1,45 +0,0 @@
-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/types/src/utils/numbers.d.ts

@@ -1,23 +0,0 @@
-/**
- * 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/types/src/utils/objects.d.ts

@@ -1,15 +0,0 @@
-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/types/src/utils/pdfDocEncoding.d.ts

@@ -1,7 +0,0 @@
-/**
- * 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/types/src/utils/png.d.ts

@@ -1,17 +0,0 @@
-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/types/src/utils/rng.d.ts

@@ -1,13 +0,0 @@
-/**
- * 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/types/src/utils/strings.d.ts

@@ -1,25 +0,0 @@
-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/dist/types/src/utils/unicode.d.ts

@@ -1,186 +0,0 @@
-/**
- * Encodes a string to UTF-8.
- *
- * @param input The string to be encoded.
- * @param byteOrderMark Whether or not a byte order marker (BOM) should be added
- *                      to the start of the encoding. (default `true`)
- * @returns A Uint8Array containing the UTF-8 encoding of the input string.
- *
- * -----------------------------------------------------------------------------
- *
- * JavaScript strings are composed of Unicode code points. Code points are
- * integers in the range 0 to 1,114,111 (0x10FFFF). When serializing a string,
- * it must be encoded as a sequence of words. A word is typically 8, 16, or 32
- * bytes in size. As such, Unicode defines three encoding forms: UTF-8, UTF-16,
- * and UTF-32. These encoding forms are described in the Unicode standard [1].
- * This function implements the UTF-8 encoding form.
- *
- * -----------------------------------------------------------------------------
- *
- * In UTF-8, each code point is mapped to a sequence of 1, 2, 3, or 4 bytes.
- * Note that the logic which defines this mapping is slightly convoluted, and
- * not as straightforward as the mapping logic for UTF-16 or UTF-32. The UTF-8
- * mapping logic is as follows [2]:
- *
- * • If a code point is in the range U+0000..U+007F, then view it as a 7-bit
- *   integer: 0bxxxxxxx. Map the code point to 1 byte with the first high order
- *   bit set to 0:
- *
- *       b1=0b0xxxxxxx
- *
- * • If a code point is in the range U+0080..U+07FF, then view it as an 11-bit
- *   integer: 0byyyyyxxxxxx. Map the code point to 2 bytes with the first 5 bits
- *   of the code point stored in the first byte, and the last 6 bits stored in
- *   the second byte:
- *
- *       b1=0b110yyyyy    b2=0b10xxxxxx
- *
- * • If a code point is in the range U+0800..U+FFFF, then view it as a 16-bit
- *   integer, 0bzzzzyyyyyyxxxxxx. Map the code point to 3 bytes with the first
- *   4 bits stored in the first byte, the next 6 bits stored in the second byte,
- *   and the last 6 bits in the third byte:
- *
- *       b1=0b1110zzzz    b2=0b10yyyyyy    b3=0b10xxxxxx
- *
- * • If a code point is in the range U+10000...U+10FFFF, then view it as a
- *   21-bit integer, 0bvvvzzzzzzyyyyyyxxxxxx. Map the code point to 4 bytes with
- *   the first 3 bits stored in the first byte, the next 6 bits stored in the
- *   second byte, the next 6 bits stored in the third byte, and the last 6 bits
- *   stored in the fourth byte:
- *
- *       b1=0b11110xxx    b2=0b10zzzzzz    b3=0b10yyyyyy    b4=0b10xxxxxx
- *
- * -----------------------------------------------------------------------------
- *
- * It is important to note, when iterating through the code points of a string
- * in JavaScript, that if a character is encoded as a surrogate pair it will
- * increase the string's length by 2 instead of 1 [4]. For example:
- *
- * ```
- * > 'a'.length
- * 1
- * > '💩'.length
- * 2
- * > '語'.length
- * 1
- * > 'a💩語'.length
- * 4
- * ```
- *
- * The results of the above example are explained by the fact that the
- * characters 'a' and '語' are not represented by surrogate pairs, but '💩' is.
- *
- * Because of this idiosyncrasy in JavaScript's string implementation and APIs,
- * we must "jump" an extra index after encoding a character as a surrogate
- * pair. In practice, this means we must increment the index of our for loop by
- * 2 if we encode a surrogate pair, and 1 in all other cases.
- *
- * -----------------------------------------------------------------------------
- *
- * References:
- *   - [1] https://www.unicode.org/versions/Unicode12.0.0/UnicodeStandard-12.0.pdf
- *         3.9  Unicode Encoding Forms - UTF-8
- *   - [2] http://www.herongyang.com/Unicode/UTF-8-UTF-8-Encoding.html
- *   - [3] http://www.herongyang.com/Unicode/UTF-8-UTF-8-Encoding-Algorithm.html
- *   - [4] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length#Description
- *
- */
-export declare const utf8Encode: (input: string, byteOrderMark?: boolean) => Uint8Array;
-/**
- * Encodes a string to UTF-16.
- *
- * @param input The string to be encoded.
- * @param byteOrderMark Whether or not a byte order marker (BOM) should be added
- *                      to the start of the encoding. (default `true`)
- * @returns A Uint16Array containing the UTF-16 encoding of the input string.
- *
- * -----------------------------------------------------------------------------
- *
- * JavaScript strings are composed of Unicode code points. Code points are
- * integers in the range 0 to 1,114,111 (0x10FFFF). When serializing a string,
- * it must be encoded as a sequence of words. A word is typically 8, 16, or 32
- * bytes in size. As such, Unicode defines three encoding forms: UTF-8, UTF-16,
- * and UTF-32. These encoding forms are described in the Unicode standard [1].
- * This function implements the UTF-16 encoding form.
- *
- * -----------------------------------------------------------------------------
- *
- * In UTF-16, each code point is mapped to one or two 16-bit integers. The
- * UTF-16 mapping logic is as follows [2]:
- *
- * • If a code point is in the range U+0000..U+FFFF, then map the code point to
- *   a 16-bit integer with the most significant byte first.
- *
- * • If a code point is in the range U+10000..U+10000, then map the code point
- *   to two 16-bit integers. The first integer should contain the high surrogate
- *   and the second integer should contain the low surrogate. Both surrogates
- *   should be written with the most significant byte first.
- *
- * -----------------------------------------------------------------------------
- *
- * It is important to note, when iterating through the code points of a string
- * in JavaScript, that if a character is encoded as a surrogate pair it will
- * increase the string's length by 2 instead of 1 [4]. For example:
- *
- * ```
- * > 'a'.length
- * 1
- * > '💩'.length
- * 2
- * > '語'.length
- * 1
- * > 'a💩語'.length
- * 4
- * ```
- *
- * The results of the above example are explained by the fact that the
- * characters 'a' and '語' are not represented by surrogate pairs, but '💩' is.
- *
- * Because of this idiosyncrasy in JavaScript's string implementation and APIs,
- * we must "jump" an extra index after encoding a character as a surrogate
- * pair. In practice, this means we must increment the index of our for loop by
- * 2 if we encode a surrogate pair, and 1 in all other cases.
- *
- * -----------------------------------------------------------------------------
- *
- * References:
- *   - [1] https://www.unicode.org/versions/Unicode12.0.0/UnicodeStandard-12.0.pdf
- *         3.9  Unicode Encoding Forms - UTF-8
- *   - [2] http://www.herongyang.com/Unicode/UTF-16-UTF-16-Encoding.html
- *   - [3] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length#Description
- *
- */
-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
- * with surrogate pairs.
- * @param codePoint The code point to be evaluated.
- *
- * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
- */
-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.
- * @param codePoint The code point to be evaluated.
- *
- * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
- */
-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.
- *
- * Note that this function attempts to recover from erronous input by
- * inserting the replacement character (�) to mark invalid code points
- * and surrogate pairs.
- *
- * @param input A Uint8Array containing UTF-16 encoded data
- * @param byteOrderMark Whether or not a byte order marker (BOM) should be read
- *                      at the start of the encoding. (default `true`)
- * @returns The decoded string.
- */
-export declare const utf16Decode: (input: Uint8Array, byteOrderMark?: boolean) => string;
-export declare const hasUtf16BOM: (bytes: Uint8Array) => boolean;

package/dist/types/src/utils/validators.d.ts

@@ -1,26 +0,0 @@
-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/eslint.config.mjs

@@ -1,47 +0,0 @@
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Import the root config
-const rootConfigPath = resolve(__dirname, '../../eslint.config.mjs');
-const rootConfig = await import(rootConfigPath);
-
-export default [
-  ...rootConfig.default,
-  {
-    files: ['src/**/*.ts'],
-    languageOptions: {
-      parserOptions: {
-        project: ['./tsconfig.esm.json'],
-        tsconfigRootDir: __dirname,
-      },
-    },
-    rules: {
-      // Disable strict TypeScript rules for pdf-lib migration
-      '@typescript-eslint/no-explicit-any': 'off',
-      '@typescript-eslint/no-unsafe-assignment': 'off',
-      '@typescript-eslint/no-unsafe-member-access': 'off',
-      '@typescript-eslint/no-unsafe-call': 'off',
-      '@typescript-eslint/no-unsafe-return': 'off',
-      '@typescript-eslint/no-unsafe-argument': 'off',
-      '@typescript-eslint/no-unsafe-enum-comparison': 'off',
-      '@typescript-eslint/no-unsafe-function-type': 'off',
-      '@typescript-eslint/restrict-template-expressions': 'off',
-      '@typescript-eslint/ban-ts-comment': 'off',
-      '@typescript-eslint/no-unused-vars': 'off',
-      '@typescript-eslint/no-duplicate-enum-values': 'off',
-      '@typescript-eslint/require-await': 'off',
-      '@typescript-eslint/no-empty-object-type': 'off',
-      '@typescript-eslint/no-unnecessary-type-assertion': 'off',
-      '@typescript-eslint/no-extra-non-null-assertion': 'off',
-      '@typescript-eslint/no-wrapper-object-types': 'off',
-      '@typescript-eslint/no-unused-expressions': 'off',
-      '@typescript-eslint/unbound-method': 'off',
-      '@typescript-eslint/await-thenable': 'off',
-      '@typescript-eslint/prefer-promise-reject-errors': 'off',
-      '@typescript-eslint/no-redundant-type-constituents': 'off',
-    },
-  },
-];

package/tsconfig.cjs.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base",
-  "compilerOptions": {
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "outDir": "./dist/cjs",
-    "skipLibCheck": true
-  }
-}

package/tsconfig.esm.json

@@ -1,11 +0,0 @@
-{
-  "extends": "../../tsconfig.base",
-  "compilerOptions": {
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "outDir": "./dist/esm",
-    "declaration": true,
-    "declarationDir": "dist/types",
-    "skipLibCheck": true
-  }
-}

package/tsconfig.node.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base",
-  "compilerOptions": {
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "outDir": "./dist/node",
-    "skipLibCheck": true
-  }
-}