@chialab/pdfjs-lib 1.0.0-alpha.12 → 1.0.0-alpha.14

package/dist/browser/index.js

@@ -25468,6 +25468,13 @@ function colorToRgb(color) {
   }
   throw new Error(`Invalid color format: ${color}`);
 }
+function rgbToHex(r, g, b) {
+  const toHex = (value) => value.toString(16).padStart(2, "0");
+  if (Array.isArray(r)) {
+    return `#${toHex(r[0])}${toHex(r[1])}${toHex(r[2])}`;
+  }
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
 
 // src/lib/PDFPageProxy.ts
 var getAnnotations = PDFPageProxy.prototype.getAnnotations;
@@ -26369,6 +26376,7 @@ export {
   makeSerializable,
   noContextMenu,
   normalizeUnicode,
+  rgbToHex,
   setLayerDimensions,
   shadow,
   stopEvent,

package/dist/lib/AnnotationData.d.ts

@@ -1,12 +1,12 @@
 import type { SvgRoot } from './SvgCanvasContext';
-type Rect = [number, number, number, number];
-type Color = [number, number, number];
-type Dir = 'ltr' | 'rtl';
-declare enum BorderStyle {
+export type Rect = [number, number, number, number];
+export type Color = [number, number, number];
+export type Dir = 'ltr' | 'rtl';
+export declare enum BorderStyle {
     SOLID = 1,
     DASHED = 2
 }
-declare enum LineEnding {
+export declare enum LineEnding {
     NONE = "None",
     SQUARE = "Square",
     CIRCLE = "Circle",
@@ -202,4 +202,3 @@ export declare function isTrapNetAnnotation(annotation: AnnotationData): annotat
 export declare function isWatermarkAnnotation(annotation: AnnotationData): annotation is WatermarkAnnotationData;
 export declare function isThreeDAnnotation(annotation: AnnotationData): annotation is ThreeDAnnotationData;
 export declare function isRedactAnnotation(annotation: AnnotationData): annotation is RedactAnnotationData;
-export {};

package/dist/lib/utils.d.ts

@@ -24,4 +24,6 @@ export declare function makeSerializable<T>(object: T): T;
  * @param color The color in hex format (e.g., '#ff0000' or '#f00').
  * @returns An array of RGB values [r, g, b].
  */
-export declare function colorToRgb(color: string): number[];
+export declare function colorToRgb(color: string): [number, number, number];
+export declare function rgbToHex(rgb: [number, number, number]): string;
+export declare function rgbToHex(r: number, g: number, b: number): string;

package/dist/node/index.js

@@ -6882,8 +6882,330 @@ var NodeWasmFactory = class extends BaseWasmFactory {
   }
 };
 
-// src/lib/NodeUtils.ts
+// src/lib/utils.ts
+async function canvasToData(canvas) {
+  if ("toBlob" in canvas) {
+    const blob = await new Promise(
+      (resolve) => canvas.toBlob((data) => resolve(data))
+    );
+    if (!blob) {
+      throw new Error("Failed to generate graphics");
+    }
+    return new Uint8Array(await blob.arrayBuffer());
+  }
+  const buffer = await canvas.encode("png");
+  return new Uint8Array(buffer);
+}
+async function toDataUrl(data, type = "image/png") {
+  if (typeof FileReader !== "undefined") {
+    return new Promise((resolve) => {
+      const reader = new FileReader();
+      reader.onload = () => {
+        resolve(reader.result);
+      };
+      reader.readAsDataURL(new Blob([data], { type }));
+    });
+  }
+  return `data:${type};base64,${Buffer.from(data).toString("base64")}`;
+}
+function makeSerializable(object) {
+  if (typeof object !== "object" || object === null) {
+    return object;
+  }
+  if (object instanceof Int8Array || object instanceof Uint8Array || object instanceof Uint8ClampedArray || object instanceof Int16Array || object instanceof Uint16Array || object instanceof Int32Array || object instanceof Uint32Array || object instanceof Float32Array || object instanceof Float64Array) {
+    return makeSerializable(Array.from(object));
+  }
+  if (object instanceof BigInt64Array || object instanceof BigUint64Array) {
+    return makeSerializable(Array.from(object));
+  }
+  if (Array.isArray(object)) {
+    return object.map(makeSerializable);
+  }
+  return Object.fromEntries(
+    Object.entries(object).map(([key, value]) => [
+      key,
+      makeSerializable(value)
+    ])
+  );
+}
+function colorToRgb(color) {
+  if (color.startsWith("#")) {
+    const hex = color.slice(1);
+    if (hex.length === 3) {
+      return [
+        Number.parseInt(hex[0] + hex[0], 16),
+        Number.parseInt(hex[1] + hex[1], 16),
+        Number.parseInt(hex[2] + hex[2], 16)
+      ];
+    }
+    if (hex.length === 6) {
+      return [
+        Number.parseInt(hex.slice(0, 2), 16),
+        Number.parseInt(hex.slice(2, 4), 16),
+        Number.parseInt(hex.slice(4, 6), 16)
+      ];
+    }
+  }
+  throw new Error(`Invalid color format: ${color}`);
+}
+function rgbToHex(r, g, b) {
+  const toHex = (value) => value.toString(16).padStart(2, "0");
+  if (Array.isArray(r)) {
+    return `#${toHex(r[0])}${toHex(r[1])}${toHex(r[2])}`;
+  }
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+
+// src/lib/NodeFilterFactory.ts
 var filtersRegistry = /* @__PURE__ */ new Map();
+function createTables(maps) {
+  if (maps.length === 1) {
+    const mapR2 = maps[0];
+    const buffer = new Array(256);
+    for (let i = 0; i < 256; i++) {
+      buffer[i] = mapR2[i] / 255;
+    }
+    return [buffer, buffer, buffer];
+  }
+  const [mapR, mapG, mapB] = maps;
+  const bufferR = new Array(256);
+  const bufferG = new Array(256);
+  const bufferB = new Array(256);
+  for (let i = 0; i < 256; i++) {
+    bufferR[i] = mapR[i] / 255;
+    bufferG[i] = mapG[i] / 255;
+    bufferB[i] = mapB[i] / 255;
+  }
+  return [bufferR, bufferG, bufferB];
+}
+function createTransferMapAlphaConversion(aTable) {
+  return (ctx) => {
+    const imageData = ctx.getImageData(
+      0,
+      0,
+      ctx.canvas.width,
+      ctx.canvas.height
+    );
+    const data = imageData.data;
+    const tableSize = aTable.length;
+    for (let i = 0; i < data.length; i += 4) {
+      const alpha = data[i + 3] / 255;
+      const index = alpha * (tableSize - 1);
+      const lower = Math.floor(index);
+      const upper = Math.min(lower + 1, tableSize - 1);
+      const t = index - lower;
+      const newAlpha = (1 - t) * aTable[lower] + t * aTable[upper];
+      data[i + 3] = newAlpha * 255;
+    }
+    ctx.putImageData(imageData, 0, 0);
+  };
+}
+function createTransferMapConversion(rTable, gTable, bTable) {
+  return (ctx) => {
+    const imageData = ctx.getImageData(
+      0,
+      0,
+      ctx.canvas.width,
+      ctx.canvas.height
+    );
+    const data = imageData.data;
+    const rSize = rTable.length;
+    const gSize = gTable.length;
+    const bSize = bTable.length;
+    for (let i = 0; i < data.length; i += 4) {
+      const r = data[i] / 255;
+      const g = data[i + 1] / 255;
+      const b = data[i + 2] / 255;
+      const rIndex = r * (rSize - 1);
+      const rLower = Math.floor(rIndex);
+      const rUpper = Math.min(rLower + 1, rSize - 1);
+      const rT = rIndex - rLower;
+      const newR = (1 - rT) * rTable[rLower] + rT * rTable[rUpper];
+      const gIndex = g * (gSize - 1);
+      const gLower = Math.floor(gIndex);
+      const gUpper = Math.min(gLower + 1, gSize - 1);
+      const gT = gIndex - gLower;
+      const newG = (1 - gT) * gTable[gLower] + gT * gTable[gUpper];
+      const bIndex = b * (bSize - 1);
+      const bLower = Math.floor(bIndex);
+      const bUpper = Math.min(bLower + 1, bSize - 1);
+      const bT = bIndex - bLower;
+      const newB = (1 - bT) * bTable[bLower] + bT * bTable[bUpper];
+      data[i] = newR * 255;
+      data[i + 1] = newG * 255;
+      data[i + 2] = newB * 255;
+    }
+    ctx.putImageData(imageData, 0, 0);
+  };
+}
+function createLuminosityConversion() {
+  return (ctx) => {
+    const imageData = ctx.getImageData(
+      0,
+      0,
+      ctx.canvas.width,
+      ctx.canvas.height
+    );
+    const data = imageData.data;
+    for (let i = 0; i < data.length; i += 4) {
+      const r = data[i];
+      const g = data[i + 1];
+      const b = data[i + 2];
+      data[i] = data[i + 1] = data[i + 2] = 0;
+      data[i + 3] = r * 0.3 + g * 0.59 + b * 0.11;
+    }
+    ctx.putImageData(imageData, 0, 0);
+  };
+}
+function createGrayConversion() {
+  return (ctx) => {
+    const imageData = ctx.getImageData(
+      0,
+      0,
+      ctx.canvas.width,
+      ctx.canvas.height
+    );
+    const data = imageData.data;
+    for (let i = 0; i < data.length; i += 4) {
+      const r = data[i];
+      const g = data[i + 1];
+      const b = data[i + 2];
+      const gray = r * 0.2126 + g * 0.7152 + b * 0.0722;
+      data[i] = data[i + 1] = data[i + 2] = gray;
+    }
+    ctx.putImageData(imageData, 0, 0);
+  };
+}
+var NodeFilterFactory2 = class extends NodeFilterFactory {
+  addFilter(maps) {
+    if (!maps) {
+      return "none";
+    }
+    const [rTable, gTable, bTable] = createTables(maps);
+    const url = `url(#filter_${maps.length === 1 ? rTable.join("_") : `${rTable.join("_")}_${gTable.join("_")}_${bTable.join("_")}`})`;
+    if (!filtersRegistry.has(url)) {
+      filtersRegistry.set(
+        url,
+        createTransferMapConversion(rTable, gTable, bTable)
+      );
+    }
+    return url;
+  }
+  addHCMFilter(fgColor, bgColor) {
+    const fgRGB = colorToRgb(fgColor);
+    const bgRGB = colorToRgb(bgColor);
+    const url = `url(#hcm_${rgbToHex(fgRGB)}_${rgbToHex(bgRGB)})`;
+    if (!filtersRegistry.has(url)) {
+      const table = new Array(256);
+      for (let i = 0; i <= 255; i++) {
+        const x = i / 255;
+        table[i] = x <= 0.03928 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
+      }
+      const transferMapFilter = createTransferMapConversion(
+        table,
+        table,
+        table
+      );
+      const grayFilter = createGrayConversion();
+      const getSteps = (c, n) => {
+        const start = fgRGB[c] / 255;
+        const end = bgRGB[c] / 255;
+        const arr = new Array(n + 1);
+        for (let i = 0; i <= n; i++) {
+          arr[i] = start + i / n * (end - start);
+        }
+        return arr;
+      };
+      const finalTransferMap = createTransferMapConversion(
+        getSteps(0, 5),
+        getSteps(1, 5),
+        getSteps(2, 5)
+      );
+      filtersRegistry.set(url, (ctx) => {
+        transferMapFilter(ctx);
+        grayFilter(ctx);
+        finalTransferMap(ctx);
+      });
+    }
+    return url;
+  }
+  addAlphaFilter(map) {
+    const [tableA] = createTables([map]);
+    const url = `url(#alpha_${tableA.join("_")})`;
+    if (!filtersRegistry.has(url)) {
+      filtersRegistry.set(url, createTransferMapAlphaConversion(map));
+    }
+    return url;
+  }
+  addLuminosityFilter(map) {
+    const url = `url(#luminosity${map ? `_${map.join("_")}` : ""})`;
+    if (!filtersRegistry.has(url)) {
+      const tables = map ? createTables([map]) : null;
+      const alphaFilter = tables ? createTransferMapAlphaConversion(tables[0]) : null;
+      const luminosityFilter = createLuminosityConversion();
+      filtersRegistry.set(url, (ctx) => {
+        luminosityFilter(ctx);
+        alphaFilter?.(ctx);
+      });
+    }
+    return url;
+  }
+  addHighlightHCMFilter(filterName, fgColor, bgColor, newFgColor, newBgColor) {
+    const fgRGB = colorToRgb(fgColor);
+    const bgRGB = colorToRgb(bgColor);
+    let newFgRGB = colorToRgb(newFgColor);
+    let newBgRGB = colorToRgb(newBgColor);
+    const url = `url(#highlight_hcm_${filterName}_${rgbToHex(fgRGB)}_${rgbToHex(bgRGB)}_${rgbToHex(newFgRGB)}_${rgbToHex(newBgRGB)})`;
+    if (!filtersRegistry.has(url)) {
+      let fgGray = Math.round(
+        0.2126 * fgRGB[0] + 0.7152 * fgRGB[1] + 0.0722 * fgRGB[2]
+      );
+      let bgGray = Math.round(
+        0.2126 * bgRGB[0] + 0.7152 * bgRGB[1] + 0.0722 * bgRGB[2]
+      );
+      if (bgGray < fgGray) {
+        [fgGray, bgGray, newFgRGB, newBgRGB] = [
+          bgGray,
+          fgGray,
+          newBgRGB,
+          newFgRGB
+        ];
+      }
+      const grayFilter = createGrayConversion();
+      const getSteps = (fg, bg, n) => {
+        const arr = new Array(256);
+        const step = (bgGray - fgGray) / n;
+        const newStart = fg / 255;
+        const newStep = (bg - fg) / (255 * n);
+        let prev = 0;
+        for (let i = 0; i <= n; i++) {
+          const k = Math.round(fgGray + i * step);
+          const value = newStart + i * newStep;
+          for (let j = prev; j <= k; j++) {
+            arr[j] = value;
+          }
+          prev = k + 1;
+        }
+        for (let i = prev; i < 256; i++) {
+          arr[i] = arr[prev - 1];
+        }
+        return arr;
+      };
+      const transferMapFilter = createTransferMapConversion(
+        getSteps(newFgRGB[0], newBgRGB[0], 5),
+        getSteps(newFgRGB[1], newBgRGB[1], 5),
+        getSteps(newFgRGB[2], newBgRGB[2], 5)
+      );
+      filtersRegistry.set(url, (ctx) => {
+        grayFilter(ctx);
+        transferMapFilter(ctx);
+      });
+    }
+    return url;
+  }
+};
+
+// src/lib/NodeCanvasFactory.ts
 var NodeCanvasFactory2 = class extends NodeCanvasFactory {
   create(width, height) {
     const factory = this;
@@ -6923,96 +7245,6 @@ var NodeCanvasFactory2 = class extends NodeCanvasFactory {
     };
   }
 };
-var _NodeFilterFactory_instances, createTables_fn2;
-var NodeFilterFactory2 = class extends NodeFilterFactory {
-  constructor() {
-    super(...arguments);
-    __privateAdd(this, _NodeFilterFactory_instances);
-  }
-  addAlphaFilter(map) {
-    const [tableA] = __privateMethod(this, _NodeFilterFactory_instances, createTables_fn2).call(this, [map]);
-    const url = `url(#alpha_${tableA.join("_")})`;
-    if (!filtersRegistry.has(url)) {
-      filtersRegistry.set(url, (ctx) => {
-        const imageData = ctx.getImageData(
-          0,
-          0,
-          ctx.canvas.width,
-          ctx.canvas.height
-        );
-        const data = imageData.data;
-        const tableSize = tableA.length;
-        for (let i = 0; i < data.length; i += 4) {
-          const alpha = data[i + 3] / 255;
-          const index = alpha * (tableSize - 1);
-          const lower = Math.floor(index);
-          const upper = Math.min(lower + 1, tableSize - 1);
-          const t = index - lower;
-          const newAlpha = (1 - t) * tableA[lower] + t * tableA[upper];
-          data[i + 3] = newAlpha * 255;
-        }
-        ctx.putImageData(imageData, 0, 0);
-      });
-    }
-    return url;
-  }
-  addLuminosityFilter(map) {
-    const url = `url(#luminosity${map ? `_${map.join("_")}` : ""})`;
-    if (!filtersRegistry.has(url)) {
-      const tables = map ? __privateMethod(this, _NodeFilterFactory_instances, createTables_fn2).call(this, [map]) : null;
-      const tableA = tables ? tables[0] : null;
-      const tableSize = tableA?.length;
-      filtersRegistry.set(url, (ctx) => {
-        const imageData = ctx.getImageData(
-          0,
-          0,
-          ctx.canvas.width,
-          ctx.canvas.height
-        );
-        const data = imageData.data;
-        for (let i = 0; i < data.length; i += 4) {
-          const r = data[i];
-          const g = data[i + 1];
-          const b = data[i + 2];
-          data[i] = data[i + 1] = data[i + 2] = 0;
-          data[i + 3] = r * 0.3 + g * 0.59 + b * 0.11;
-          if (tableA && tableSize != null) {
-            const alpha = data[i + 3] / 255;
-            const index = alpha * (tableSize - 1);
-            const lower = Math.floor(index);
-            const upper = Math.min(lower + 1, tableSize - 1);
-            const t = index - lower;
-            const newAlpha = (1 - t) * tableA[lower] + t * tableA[upper];
-            data[i + 3] = newAlpha * 255;
-          }
-        }
-        ctx.putImageData(imageData, 0, 0);
-      });
-    }
-    return url;
-  }
-};
-_NodeFilterFactory_instances = new WeakSet();
-createTables_fn2 = function(maps) {
-  if (maps.length === 1) {
-    const mapR2 = maps[0];
-    const buffer = new Array(256);
-    for (let i = 0; i < 256; i++) {
-      buffer[i] = mapR2[i] / 255;
-    }
-    return [buffer, buffer, buffer];
-  }
-  const [mapR, mapG, mapB] = maps;
-  const bufferR = new Array(256);
-  const bufferG = new Array(256);
-  const bufferB = new Array(256);
-  for (let i = 0; i < 256; i++) {
-    bufferR[i] = mapR[i] / 255;
-    bufferG[i] = mapG[i] / 255;
-    bufferB[i] = mapB[i] / 255;
-  }
-  return [bufferR, bufferG, bufferB];
-};
 
 // src/pdf.js/src/display/pattern_helper.js
 var PathType = {
@@ -25851,73 +26083,6 @@ async function toSvgNode(ctx) {
   return ctx.getNode();
 }
 
-// src/lib/utils.ts
-async function canvasToData(canvas) {
-  if ("toBlob" in canvas) {
-    const blob = await new Promise(
-      (resolve) => canvas.toBlob((data) => resolve(data))
-    );
-    if (!blob) {
-      throw new Error("Failed to generate graphics");
-    }
-    return new Uint8Array(await blob.arrayBuffer());
-  }
-  const buffer = await canvas.encode("png");
-  return new Uint8Array(buffer);
-}
-async function toDataUrl(data, type = "image/png") {
-  if (typeof FileReader !== "undefined") {
-    return new Promise((resolve) => {
-      const reader = new FileReader();
-      reader.onload = () => {
-        resolve(reader.result);
-      };
-      reader.readAsDataURL(new Blob([data], { type }));
-    });
-  }
-  return `data:${type};base64,${Buffer.from(data).toString("base64")}`;
-}
-function makeSerializable(object) {
-  if (typeof object !== "object" || object === null) {
-    return object;
-  }
-  if (object instanceof Int8Array || object instanceof Uint8Array || object instanceof Uint8ClampedArray || object instanceof Int16Array || object instanceof Uint16Array || object instanceof Int32Array || object instanceof Uint32Array || object instanceof Float32Array || object instanceof Float64Array) {
-    return makeSerializable(Array.from(object));
-  }
-  if (object instanceof BigInt64Array || object instanceof BigUint64Array) {
-    return makeSerializable(Array.from(object));
-  }
-  if (Array.isArray(object)) {
-    return object.map(makeSerializable);
-  }
-  return Object.fromEntries(
-    Object.entries(object).map(([key, value]) => [
-      key,
-      makeSerializable(value)
-    ])
-  );
-}
-function colorToRgb(color) {
-  if (color.startsWith("#")) {
-    const hex = color.slice(1);
-    if (hex.length === 3) {
-      return [
-        Number.parseInt(hex[0] + hex[0], 16),
-        Number.parseInt(hex[1] + hex[1], 16),
-        Number.parseInt(hex[2] + hex[2], 16)
-      ];
-    }
-    if (hex.length === 6) {
-      return [
-        Number.parseInt(hex.slice(0, 2), 16),
-        Number.parseInt(hex.slice(2, 4), 16),
-        Number.parseInt(hex.slice(4, 6), 16)
-      ];
-    }
-  }
-  throw new Error(`Invalid color format: ${color}`);
-}
-
 // src/lib/PDFPageProxy.ts
 var getAnnotations = PDFPageProxy.prototype.getAnnotations;
 PDFPageProxy.prototype.getAnnotations = async function(params) {
@@ -26818,6 +26983,7 @@ export {
   makeSerializable,
   noContextMenu,
   normalizeUnicode,
+  rgbToHex,
   setLayerDimensions,
   shadow,
   stopEvent,

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@chialab/pdfjs-lib",
 	"description": "A custom Mozilla's PDF.js build with better Node support and extras.",
-	"version": "1.0.0-alpha.12",
+	"version": "1.0.0-alpha.14",
 	"type": "module",
 	"author": "Chialab <dev@chialab.it>",
 	"license": "MIT",