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

package/src/utils/png.ts

@@ -1,100 +0,0 @@
-import UPNGModule from '@pdf-lib/upng';
-
-type DecodedPng = {
-  ctype: number;
-  width: number;
-  height: number;
-};
-
-type UPNGApi = {
-  decode: (input: ArrayBuffer) => DecodedPng;
-  toRGBA8: (decoded: DecodedPng) => ArrayBuffer[];
-};
-
-const isUPNGApi = (value: unknown): value is UPNGApi =>
-  !!value &&
-  typeof value === 'object' &&
-  typeof (value as UPNGApi).decode === 'function' &&
-  typeof (value as UPNGApi).toRGBA8 === 'function';
-
-const resolveUPNG = (value: unknown): UPNGApi => {
-  let current: unknown = value;
-
-  while (current && typeof current === 'object') {
-    if (isUPNGApi(current)) return current;
-    current = (current as { default?: unknown }).default;
-  }
-
-  throw new TypeError('Failed to resolve @pdf-lib/upng exports');
-};
-
-const UPNG = resolveUPNG(UPNGModule);
-
-const getImageType = (ctype: number) => {
-  if (ctype === 0) return PngType.Greyscale;
-  if (ctype === 2) return PngType.Truecolour;
-  if (ctype === 3) return PngType.IndexedColour;
-  if (ctype === 4) return PngType.GreyscaleWithAlpha;
-  if (ctype === 6) return PngType.TruecolourWithAlpha;
-  throw new Error(`Unknown color type: ${ctype}`);
-};
-
-const splitAlphaChannel = (rgbaChannel: Uint8Array) => {
-  const pixelCount = Math.floor(rgbaChannel.length / 4);
-
-  const rgbChannel = new Uint8Array(pixelCount * 3);
-  const alphaChannel = new Uint8Array(pixelCount * 1);
-
-  let rgbaOffset = 0;
-  let rgbOffset = 0;
-  let alphaOffset = 0;
-
-  while (rgbaOffset < rgbaChannel.length) {
-    rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++];
-    rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++];
-    rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++];
-    alphaChannel[alphaOffset++] = rgbaChannel[rgbaOffset++];
-  }
-
-  return { rgbChannel, alphaChannel };
-};
-
-export enum PngType {
-  Greyscale = 'Greyscale',
-  Truecolour = 'Truecolour',
-  IndexedColour = 'IndexedColour',
-  GreyscaleWithAlpha = 'GreyscaleWithAlpha',
-  TruecolourWithAlpha = 'TruecolourWithAlpha',
-}
-
-export class PNG {
-  static load = (pngData: Uint8Array) => new PNG(pngData);
-
-  readonly rgbChannel: Uint8Array;
-  readonly alphaChannel?: Uint8Array;
-  readonly type: PngType;
-  readonly width: number;
-  readonly height: number;
-  readonly bitsPerComponent: number;
-
-  private constructor(pngData: Uint8Array) {
-    const upng = UPNG.decode(pngData.buffer as ArrayBuffer);
-    const frames = UPNG.toRGBA8(upng);
-
-    if (frames.length > 1) throw new Error(`Animated PNGs are not supported`);
-
-    const frame = new Uint8Array(frames[0]);
-    const { rgbChannel, alphaChannel } = splitAlphaChannel(frame);
-
-    this.rgbChannel = rgbChannel;
-
-    const hasAlphaValues = alphaChannel.some((a) => a < 255);
-    if (hasAlphaValues) this.alphaChannel = alphaChannel;
-
-    this.type = getImageType(upng.ctype);
-
-    this.width = upng.width;
-    this.height = upng.height;
-    this.bitsPerComponent = 8;
-  }
-}

package/src/utils/rng.ts

@@ -1,21 +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 class SimpleRNG {
-  static withSeed = (seed: number) => new SimpleRNG(seed);
-
-  private seed: number;
-
-  private constructor(seed: number) {
-    this.seed = seed;
-  }
-
-  nextInt(): number {
-    const x = Math.sin(this.seed++) * 10000;
-    return x - Math.floor(x);
-  }
-}

package/src/utils/strings.ts

@@ -1,191 +0,0 @@
-export const toCharCode = (character: string) => character.charCodeAt(0);
-
-export const toCodePoint = (character: string) => character.codePointAt(0);
-
-export const toHexStringOfMinLength = (num: number, minLength: number) =>
-  padStart(num.toString(16), minLength, '0').toUpperCase();
-
-export const toHexString = (num: number) => toHexStringOfMinLength(num, 2);
-
-export const charFromCode = (code: number) => String.fromCharCode(code);
-
-export const charFromHexCode = (hex: string) => charFromCode(parseInt(hex, 16));
-
-export const padStart = (value: string, length: number, padChar: string) => {
-  let padding = '';
-  for (let idx = 0, len = length - value.length; idx < len; idx++) {
-    padding += padChar;
-  }
-  return padding + value;
-};
-
-export const stringAsByteArray = (str: string): Uint8Array => {
-  const buffer = new Uint8Array(str.length);
-  copyStringIntoBuffer(str, buffer, 0);
-  return buffer;
-};
-
-export const copyStringIntoBuffer = (str: string, buffer: Uint8Array, offset: number): number => {
-  const length = str.length;
-  for (let idx = 0; idx < length; idx++) {
-    buffer[offset++] = str.charCodeAt(idx);
-  }
-  return length;
-};
-
-export const addRandomSuffix = (prefix: string, suffixLength = 4) =>
-  `${prefix}-${Math.floor(Math.random() * 10 ** suffixLength)}`;
-
-export const escapeRegExp = (str: string) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-
-export const cleanText = (text: string) =>
-  text.replace(/\t|\u0085|\u2028|\u2029/g, '    ').replace(/[\b\v]/g, '');
-
-export const escapedNewlineChars = ['\\n', '\\f', '\\r', '\\v'];
-
-export const newlineChars = ['\n', '\f', '\r', '\v'];
-
-export const isNewlineChar = (text: string) => /^[\n\f\r\v]$/.test(text);
-
-export const lineSplit = (text: string) => text.split(/[\n\f\r\v]/);
-
-export const mergeLines = (text: string) => text.replace(/[\n\f\r\v]/g, ' ');
-
-// JavaScript's String.charAt() method doesn work on strings containing UTF-16
-// characters (with high and low surrogate pairs), such as 💩 (poo emoji). This
-// `charAtIndex()` function does.
-//
-// Credit: https://github.com/mathiasbynens/String.prototype.at/blob/master/at.js#L14-L48
-export const charAtIndex = (text: string, index: number): [string, number] => {
-  // Get the first code unit and code unit value
-  const cuFirst = text.charCodeAt(index);
-  let cuSecond: number;
-  const nextIndex = index + 1;
-  let length = 1;
-  if (
-    // Check if it's the start of a surrogate pair.
-    cuFirst >= 0xd800 &&
-    cuFirst <= 0xdbff && // high surrogate
-    text.length > nextIndex // there is a next code unit
-  ) {
-    cuSecond = text.charCodeAt(nextIndex);
-    if (cuSecond >= 0xdc00 && cuSecond <= 0xdfff) length = 2; // low surrogate
-  }
-  return [text.slice(index, index + length), length];
-};
-
-export const charSplit = (text: string) => {
-  const chars: string[] = [];
-
-  for (let idx = 0, len = text.length; idx < len; ) {
-    const [c, cLen] = charAtIndex(text, idx);
-    chars.push(c);
-    idx += cLen;
-  }
-
-  return chars;
-};
-
-const buildWordBreakRegex = (wordBreaks: string[]) => {
-  const newlineCharUnion = escapedNewlineChars.join('|');
-
-  const escapedRules: string[] = ['$'];
-  for (let idx = 0, len = wordBreaks.length; idx < len; idx++) {
-    const wordBreak = wordBreaks[idx];
-    if (isNewlineChar(wordBreak)) {
-      throw new TypeError(`\`wordBreak\` must not include ${newlineCharUnion}`);
-    }
-    escapedRules.push(wordBreak === '' ? '.' : escapeRegExp(wordBreak));
-  }
-
-  const breakRules = escapedRules.join('|');
-  return new RegExp(`(${newlineCharUnion})|((.*?)(${breakRules}))`, 'gm');
-};
-
-export const breakTextIntoLines = (
-  text: string,
-  wordBreaks: string[],
-  maxWidth: number,
-  computeWidthOfText: (t: string) => number,
-): string[] => {
-  const regex = buildWordBreakRegex(wordBreaks);
-
-  const words = cleanText(text).match(regex)!;
-
-  let currLine = '';
-  let currWidth = 0;
-  const lines: string[] = [];
-
-  const pushCurrLine = () => {
-    if (currLine !== '') lines.push(currLine);
-    currLine = '';
-    currWidth = 0;
-  };
-
-  for (let idx = 0, len = words.length; idx < len; idx++) {
-    const word = words[idx];
-    if (isNewlineChar(word)) {
-      pushCurrLine();
-    } else {
-      const width = computeWidthOfText(word);
-      if (currWidth + width > maxWidth) pushCurrLine();
-      currLine += word;
-      currWidth += width;
-    }
-  }
-  pushCurrLine();
-
-  return lines;
-};
-
-// See section "7.9.4 Dates" of the PDF specification
-const dateRegex = /^D:(\d\d\d\d)(\d\d)?(\d\d)?(\d\d)?(\d\d)?(\d\d)?([+\-Z])?(\d\d)?'?(\d\d)?'?$/;
-
-export const parseDate = (dateStr: string): Date | undefined => {
-  const match = dateStr.match(dateRegex);
-
-  if (!match) return undefined;
-
-  const [
-    ,
-    year,
-    month = '01',
-    day = '01',
-    hours = '00',
-    mins = '00',
-    secs = '00',
-    offsetSign = 'Z',
-    offsetHours = '00',
-    offsetMins = '00',
-  ] = match;
-
-  // http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15
-  const tzOffset = offsetSign === 'Z' ? 'Z' : `${offsetSign}${offsetHours}:${offsetMins}`;
-  const date = new Date(`${year}-${month}-${day}T${hours}:${mins}:${secs}${tzOffset}`);
-
-  return date;
-};
-
-export const findLastMatch = (value: string, regex: RegExp) => {
-  const MAX_STRING_LENGTH = 10000;
-  if (value.length > MAX_STRING_LENGTH) {
-    return { match: undefined, pos: 0 };
-  }
-
-  let position = 0;
-  let lastMatch: RegExpMatchArray | undefined;
-  let iterations = 0;
-  const MAX_ITERATIONS = 1000;
-
-  while (position < value.length) {
-    if (++iterations > MAX_ITERATIONS) {
-      return { match: lastMatch, pos: position };
-    }
-
-    const match = value.substring(position).match(regex);
-    if (!match) return { match: lastMatch, pos: position };
-    lastMatch = match;
-    position += (match.index ?? 0) + match[0].length;
-  }
-  return { match: lastMatch, pos: position };
-};

package/src/utils/validators.ts

@@ -1,192 +0,0 @@
-/* tslint:disable:ban-types */
-
-import { values as objectValues } from './objects';
-
-export const backtick = (val: any) => `\`${val}\``;
-export const singleQuote = (val: any) => `'${val}'`;
-
-type Primitive = string | number | boolean | undefined | null;
-
-// prettier-ignore
-const formatValue = (value: any) => {
-  const type = typeof value;
-  if (type ==='string') return singleQuote(value);
-  else if (type ==='undefined') return backtick(value);
-  else return value;
-};
-
-export const createValueErrorMsg = (value: any, valueName: string, values: Primitive[]) => {
-  const allowedValues = Array(values.length);
-
-  for (let idx = 0, len = values.length; idx < len; idx++) {
-    const v = values[idx];
-    allowedValues[idx] = formatValue(v);
-  }
-
-  const joinedValues = allowedValues.join(' or ');
-
-  // prettier-ignore
-  return `${backtick(valueName)} must be one of ${joinedValues}, but was actually ${formatValue(value)}`;
-};
-
-export const assertIsOneOf = (
-  value: any,
-  valueName: string,
-  allowedValues: Primitive[] | { [key: string]: Primitive },
-) => {
-  if (!Array.isArray(allowedValues)) {
-    allowedValues = objectValues(allowedValues);
-  }
-  for (let idx = 0, len = allowedValues.length; idx < len; idx++) {
-    if (value === allowedValues[idx]) return;
-  }
-  throw new TypeError(createValueErrorMsg(value, valueName, allowedValues));
-};
-
-export const assertIsOneOfOrUndefined = (
-  value: any,
-  valueName: string,
-  allowedValues: Primitive[] | { [key: string]: Primitive },
-) => {
-  if (!Array.isArray(allowedValues)) {
-    allowedValues = objectValues(allowedValues);
-  }
-  assertIsOneOf(value, valueName, allowedValues.concat(undefined));
-};
-
-export const assertIsSubset = (
-  values: any[],
-  valueName: string,
-  allowedValues: Primitive[] | { [key: string]: Primitive },
-) => {
-  if (!Array.isArray(allowedValues)) {
-    allowedValues = objectValues(allowedValues);
-  }
-  for (let idx = 0, len = values.length; idx < len; idx++) {
-    assertIsOneOf(values[idx], valueName, allowedValues);
-  }
-};
-
-export const getType = (val: any) => {
-  if (val === null) return 'null';
-  if (val === undefined) return 'undefined';
-  if (typeof val === 'string') return 'string';
-  if (isNaN(val)) return 'NaN';
-  if (typeof val === 'number') return 'number';
-  if (typeof val === 'boolean') return 'boolean';
-  if (typeof val === 'symbol') return 'symbol';
-  if (typeof val === 'bigint') return 'bigint';
-  if (val.constructor && val.constructor.name) return val.constructor.name;
-  if (val.name) return val.name;
-  if (val.constructor) return String(val.constructor);
-  return String(val);
-};
-
-export type TypeDescriptor =
-  | 'null'
-  | 'undefined'
-  | 'string'
-  | 'number'
-  | 'boolean'
-  | 'symbol'
-  | 'bigint'
-  | DateConstructor
-  | ArrayConstructor
-  | Uint8ArrayConstructor
-  | ArrayBufferConstructor
-  | FunctionConstructor
-  | [Function, string];
-
-export const isType = (value: any, type: TypeDescriptor) => {
-  if (type === 'null') return value === null;
-  if (type === 'undefined') return value === undefined;
-  if (type === 'string') return typeof value === 'string';
-  if (type === 'number') return typeof value === 'number' && !isNaN(value);
-  if (type === 'boolean') return typeof value === 'boolean';
-  if (type === 'symbol') return typeof value === 'symbol';
-  if (type === 'bigint') return typeof value === 'bigint';
-  if (type === Date) return value instanceof Date;
-  if (type === Array) return value instanceof Array;
-  if (type === Uint8Array) return value instanceof Uint8Array;
-  if (type === ArrayBuffer) return value instanceof ArrayBuffer;
-  if (type === Function) return value instanceof Function;
-  return value instanceof (type as [Function, string])[0];
-};
-
-export const createTypeErrorMsg = (value: any, valueName: string, types: TypeDescriptor[]) => {
-  const allowedTypes = Array(types.length);
-
-  for (let idx = 0, len = types.length; idx < len; idx++) {
-    const type = types[idx];
-    if (type === 'null') allowedTypes[idx] = backtick('null');
-    if (type === 'undefined') allowedTypes[idx] = backtick('undefined');
-    if (type === 'string') allowedTypes[idx] = backtick('string');
-    else if (type === 'number') allowedTypes[idx] = backtick('number');
-    else if (type === 'boolean') allowedTypes[idx] = backtick('boolean');
-    else if (type === 'symbol') allowedTypes[idx] = backtick('symbol');
-    else if (type === 'bigint') allowedTypes[idx] = backtick('bigint');
-    else if (type === Array) allowedTypes[idx] = backtick('Array');
-    else if (type === Uint8Array) allowedTypes[idx] = backtick('Uint8Array');
-    else if (type === ArrayBuffer) allowedTypes[idx] = backtick('ArrayBuffer');
-    else allowedTypes[idx] = backtick((type as [Function, string])[1]);
-  }
-
-  const joinedTypes = allowedTypes.join(' or ');
-
-  // prettier-ignore
-  return `${backtick(valueName)} must be of type ${joinedTypes}, but was actually of type ${backtick(getType(value))}`;
-};
-
-export const assertIs = (value: any, valueName: string, types: TypeDescriptor[]) => {
-  for (let idx = 0, len = types.length; idx < len; idx++) {
-    if (isType(value, types[idx])) return;
-  }
-  throw new TypeError(createTypeErrorMsg(value, valueName, types));
-};
-
-export const assertOrUndefined = (value: any, valueName: string, types: TypeDescriptor[]) => {
-  assertIs(value, valueName, types.concat('undefined'));
-};
-
-export const assertEachIs = (values: any[], valueName: string, types: TypeDescriptor[]) => {
-  for (let idx = 0, len = values.length; idx < len; idx++) {
-    assertIs(values[idx], valueName, types);
-  }
-};
-
-export const assertRange = (value: any, valueName: string, min: number, max: number) => {
-  assertIs(value, valueName, ['number']);
-  assertIs(min, 'min', ['number']);
-  assertIs(max, 'max', ['number']);
-  max = Math.max(min, max);
-  if (value < min || value > max) {
-    // prettier-ignore
-    throw new Error(`${backtick(valueName)} must be at least ${min} and at most ${max}, but was actually ${value}`);
-  }
-};
-
-export const assertRangeOrUndefined = (value: any, valueName: string, min: number, max: number) => {
-  assertIs(value, valueName, ['number', 'undefined']);
-  if (typeof value === 'number') assertRange(value, valueName, min, max);
-};
-
-export const assertMultiple = (value: any, valueName: string, multiplier: number) => {
-  assertIs(value, valueName, ['number']);
-  if (value % multiplier !== 0) {
-    // prettier-ignore
-    throw new Error(`${backtick(valueName)} must be a multiple of ${multiplier}, but was actually ${value}`);
-  }
-};
-
-export const assertInteger = (value: any, valueName: string) => {
-  if (!Number.isInteger(value)) {
-    throw new Error(`${backtick(valueName)} must be an integer, but was actually ${value}`);
-  }
-};
-
-export const assertPositive = (value: number, valueName: string) => {
-  if (![1, 0].includes(Math.sign(value))) {
-    // prettier-ignore
-    throw new Error(`${backtick(valueName)} must be a positive number or 0, but was actually ${value}`);
-  }
-};

package/tsconfig.build.json

@@ -1,14 +0,0 @@
-{
-  "extends": "../../tsconfig.build.base.json",
-  "compilerOptions": {
-    "declaration": true,
-    "declarationDir": "./dist",
-    "emitDeclarationOnly": true,
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "skipLibCheck": true
-  },
-  "include": ["src/**/*.ts"]
-}

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "composite": true,
-    "declaration": true,
-    "declarationDir": "./dist/typecheck",
-    "emitDeclarationOnly": true,
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "outDir": "./dist/typecheck",
-    "tsBuildInfoFile": "./dist/typecheck/tsconfig.tsbuildinfo",
-    "skipLibCheck": true
-  },
-  "include": ["src/**/*.ts"]
-}

package/vite.config.mts

@@ -1,39 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { builtinModules } from 'node:module';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { defineConfig } from 'vite';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const packageJson = JSON.parse(readFileSync(resolve(__dirname, 'package.json'), 'utf8')) as {
-  dependencies?: Record<string, string>;
-  peerDependencies?: Record<string, string>;
-};
-
-const builtinModuleSet = new Set([
-  ...builtinModules,
-  ...builtinModules.map((moduleName) => `node:${moduleName}`),
-]);
-const packageDependencies = [
-  ...Object.keys(packageJson.dependencies ?? {}),
-  ...Object.keys(packageJson.peerDependencies ?? {}),
-];
-
-const isExternal = (id: string) =>
-  builtinModuleSet.has(id) ||
-  packageDependencies.some((dependency) => id === dependency || id.startsWith(`${dependency}/`));
-
-export default defineConfig({
-  build: {
-    lib: {
-      entry: resolve(__dirname, 'src/index.ts'),
-      fileName: 'index',
-      formats: ['es'],
-    },
-    minify: false,
-    outDir: 'dist',
-    rollupOptions: { external: isExternal },
-    sourcemap: true,
-    target: 'es2020',
-  },
-});